Update the definition of Executor and AnyConnectionBackend + update Postgres driver

Author: joeydewaal

sqlx-core/src/any/connection/backend.rs

@@ -1,5 +1,6 @@
 use crate::any::{Any, AnyArguments, AnyQueryResult, AnyRow, AnyStatement, AnyTypeInfo};
 use crate::describe::Describe;
+use crate::sql_str::SqlStr;
 use either::Either;
 use futures_core::future::BoxFuture;
 use futures_core::stream::BoxStream;
@@ -69,23 +70,23 @@ pub trait AnyConnectionBackend: std::any::Any + Debug + Send + 'static {
 
     fn fetch_many<'q>(
         &'q mut self,
-        query: &'q str,
+        query: SqlStr,
         persistent: bool,
         arguments: Option<AnyArguments<'q>>,
     ) -> BoxStream<'q, crate::Result<Either<AnyQueryResult, AnyRow>>>;
 
     fn fetch_optional<'q>(
         &'q mut self,
-        query: &'q str,
+        query: SqlStr,
         persistent: bool,
         arguments: Option<AnyArguments<'q>>,
     ) -> BoxFuture<'q, crate::Result<Option<AnyRow>>>;
 
     fn prepare_with<'c, 'q: 'c>(
         &'c mut self,
-        sql: &'q str,
+        sql: SqlStr,
         parameters: &[AnyTypeInfo],
     ) -> BoxFuture<'c, crate::Result<AnyStatement>>;
 
-    fn describe<'q>(&'q mut self, sql: &'q str) -> BoxFuture<'q, crate::Result<Describe<Any>>>;
+    fn describe<'q>(&'q mut self, sql: SqlStr) -> BoxFuture<'q, crate::Result<Describe<Any>>>;
 }

sqlx-core/src/any/connection/executor.rs

@@ -2,6 +2,7 @@ use crate::any::{Any, AnyConnection, AnyQueryResult, AnyRow, AnyStatement, AnyTy
 use crate::describe::Describe;
 use crate::error::Error;
 use crate::executor::{Execute, Executor};
+use crate::sql_str::SqlSafeStr;
 use either::Either;
 use futures_core::future::BoxFuture;
 use futures_core::stream::BoxStream;
@@ -23,8 +24,8 @@ impl<'c> Executor<'c> for &'c mut AnyConnection {
             Ok(arguments) => arguments,
             Err(error) => return stream::once(future::ready(Err(error))).boxed(),
         };
-        self.backend
-            .fetch_many(query.sql(), query.persistent(), arguments)
+        let persistent = query.persistent();
+        self.backend.fetch_many(query.sql(), persistent, arguments)
     }
 
     fn fetch_optional<'e, 'q: 'e, E>(
@@ -39,28 +40,29 @@ impl<'c> Executor<'c> for &'c mut AnyConnection {
             Ok(arguments) => arguments,
             Err(error) => return future::ready(Err(error)).boxed(),
         };
+        let persistent = query.persistent();
         self.backend
-            .fetch_optional(query.sql(), query.persistent(), arguments)
+            .fetch_optional(query.sql(), persistent, arguments)
     }
 
-    fn prepare_with<'e, 'q: 'e>(
+    fn prepare_with<'e>(
         self,
-        sql: &'q str,
+        sql: impl SqlSafeStr,
         parameters: &[AnyTypeInfo],
     ) -> BoxFuture<'e, Result<AnyStatement, Error>>
     where
         'c: 'e,
     {
-        self.backend.prepare_with(sql, parameters)
+        self.backend.prepare_with(sql.into_sql_str(), parameters)
     }
 
-    fn describe<'e, 'q: 'e>(
+    fn describe<'e>(
         self,
-        sql: &'q str,
+        sql: impl SqlSafeStr,
     ) -> BoxFuture<'e, Result<Describe<Self::Database>, Error>>
     where
         'c: 'e,
     {
-        self.backend.describe(sql)
+        self.backend.describe(sql.into_sql_str())
     }
 }

sqlx-core/src/any/statement.rs

@@ -3,7 +3,7 @@ use crate::column::ColumnIndex;
 use crate::database::Database;
 use crate::error::Error;
 use crate::ext::ustr::UStr;
-use crate::sql_str::{AssertSqlSafe, SqlSafeStr, SqlStr};
+use crate::sql_str::SqlStr;
 use crate::statement::Statement;
 use crate::HashMap;
 use either::Either;
@@ -32,8 +32,8 @@ impl Statement for AnyStatement {
         }
     }
 
-    fn sql(&self) -> &str {
-        &self.sql.as_str()
+    fn sql(&self) -> SqlStr {
+        self.sql.clone()
     }
 
     fn parameters(&self) -> Option<Either<&[AnyTypeInfo], usize>> {
@@ -64,7 +64,7 @@ impl<'i> ColumnIndex<AnyStatement> for &'i str {
 impl<'q> AnyStatement {
     #[doc(hidden)]
     pub fn try_from_statement<S>(
-        query: &'q str,
+        query: SqlStr,
         statement: &S,
         column_names: Arc<HashMap<UStr, usize>>,
     ) -> crate::Result<Self>
@@ -91,7 +91,7 @@ impl<'q> AnyStatement {
             .collect::<Result<Vec<_>, _>>()?;
 
         Ok(Self {
-            sql: AssertSqlSafe(query).into_sql_str(),
+            sql: query,
             columns,
             column_names,
             parameters,

sqlx-core/src/executor.rs

@@ -1,6 +1,7 @@
 use crate::database::Database;
 use crate::describe::Describe;
 use crate::error::{BoxDynError, Error};
+use crate::sql_str::{SqlSafeStr, SqlStr};
 
 use either::Either;
 use futures_core::future::BoxFuture;
@@ -146,9 +147,9 @@ pub trait Executor<'c>: Send + Debug + Sized {
     /// This explicit API is provided to allow access to the statement metadata available after
     /// it prepared but before the first row is returned.
     #[inline]
-    fn prepare<'e, 'q: 'e>(
+    fn prepare<'e>(
         self,
-        query: &'q str,
+        query: impl SqlSafeStr,
     ) -> BoxFuture<'e, Result<<Self::Database as Database>::Statement, Error>>
     where
         'c: 'e,
@@ -161,9 +162,9 @@ pub trait Executor<'c>: Send + Debug + Sized {
     ///
     /// Only some database drivers (PostgreSQL, MSSQL) can take advantage of
     /// this extra information to influence parameter type inference.
-    fn prepare_with<'e, 'q: 'e>(
+    fn prepare_with<'e>(
         self,
-        sql: &'q str,
+        sql: impl SqlSafeStr,
         parameters: &'e [<Self::Database as Database>::TypeInfo],
     ) -> BoxFuture<'e, Result<<Self::Database as Database>::Statement, Error>>
     where
@@ -175,9 +176,9 @@ pub trait Executor<'c>: Send + Debug + Sized {
     /// This is used by compile-time verification in the query macros to
     /// power their type inference.
     #[doc(hidden)]
-    fn describe<'e, 'q: 'e>(
+    fn describe<'e>(
         self,
-        sql: &'q str,
+        sql: impl SqlSafeStr,
     ) -> BoxFuture<'e, Result<Describe<Self::Database>, Error>>
     where
         'c: 'e;
@@ -192,7 +193,7 @@ pub trait Executor<'c>: Send + Debug + Sized {
 ///
 pub trait Execute<'q, DB: Database>: Send + Sized {
     /// Gets the SQL that will be executed.
-    fn sql(&self) -> &'q str;
+    fn sql(self) -> SqlStr;
 
     /// Gets the previously cached statement, if available.
     fn statement(&self) -> Option<&DB::Statement>;
@@ -210,12 +211,13 @@ pub trait Execute<'q, DB: Database>: Send + Sized {
     fn persistent(&self) -> bool;
 }
 
-// NOTE: `Execute` is explicitly not implemented for String and &String to make it slightly more
-//       involved to write `conn.execute(format!("SELECT {val}"))`
-impl<'q, DB: Database> Execute<'q, DB> for &'q str {
+impl<'q, DB: Database, T> Execute<'q, DB> for (T, Option<<DB as Database>::Arguments<'q>>)
+where
+    T: SqlSafeStr + Send,
+{
     #[inline]
-    fn sql(&self) -> &'q str {
-        self
+    fn sql(self) -> SqlStr {
+        self.0.into_sql_str()
     }
 
     #[inline]
@@ -225,7 +227,7 @@ impl<'q, DB: Database> Execute<'q, DB> for &'q str {
 
     #[inline]
     fn take_arguments(&mut self) -> Result<Option<<DB as Database>::Arguments<'q>>, BoxDynError> {
-        Ok(None)
+        Ok(self.1.take())
     }
 
     #[inline]
@@ -234,10 +236,13 @@ impl<'q, DB: Database> Execute<'q, DB> for &'q str {
     }
 }
 
-impl<'q, DB: Database> Execute<'q, DB> for (&'q str, Option<<DB as Database>::Arguments<'q>>) {
+impl<'q, DB: Database, T> Execute<'q, DB> for T
+where
+    T: SqlSafeStr + Send,
+{
     #[inline]
-    fn sql(&self) -> &'q str {
-        self.0
+    fn sql(self) -> SqlStr {
+        self.into_sql_str()
     }
 
     #[inline]
@@ -247,7 +252,7 @@ impl<'q, DB: Database> Execute<'q, DB> for (&'q str, Option<<DB as Database>::Ar
 
     #[inline]
     fn take_arguments(&mut self) -> Result<Option<<DB as Database>::Arguments<'q>>, BoxDynError> {
-        Ok(self.1.take())
+        Ok(None)
     }
 
     #[inline]

sqlx-core/src/logger.rs

@@ -1,4 +1,4 @@
-use crate::connection::LogSettings;
+use crate::{connection::LogSettings, sql_str::SqlStr};
 use std::time::Instant;
 
 // Yes these look silly. `tracing` doesn't currently support dynamic levels
@@ -60,16 +60,16 @@ pub(crate) fn private_level_filter_to_trace_level(
     private_level_filter_to_levels(filter).map(|(level, _)| level)
 }
 
-pub struct QueryLogger<'q> {
-    sql: &'q str,
+pub struct QueryLogger {
+    sql: SqlStr,
     rows_returned: u64,
     rows_affected: u64,
     start: Instant,
     settings: LogSettings,
 }
 
-impl<'q> QueryLogger<'q> {
-    pub fn new(sql: &'q str, settings: LogSettings) -> Self {
+impl QueryLogger {
+    pub fn new(sql: SqlStr, settings: LogSettings) -> Self {
         Self {
             sql,
             rows_returned: 0,
@@ -104,18 +104,18 @@ impl<'q> QueryLogger<'q> {
             let log_is_enabled = log::log_enabled!(target: "sqlx::query", log_level)
                 || private_tracing_dynamic_enabled!(target: "sqlx::query", tracing_level);
             if log_is_enabled {
-                let mut summary = parse_query_summary(self.sql);
+                let mut summary = parse_query_summary(self.sql.as_str());
 
-                let sql = if summary != self.sql {
+                let sql = if summary != self.sql.as_str() {
                     summary.push_str(" …");
                     format!(
                         "\n\n{}\n",
-                        self.sql /*
-                                 sqlformat::format(
-                                     self.sql,
-                                     &sqlformat::QueryParams::None,
-                                     sqlformat::FormatOptions::default()
-                                 )*/
+                        self.sql.as_str() /*
+                                          sqlformat::format(
+                                              self.sql,
+                                              &sqlformat::QueryParams::None,
+                                              sqlformat::FormatOptions::default()
+                                          )*/
                     )
                 } else {
                     String::new()
@@ -158,7 +158,7 @@ impl<'q> QueryLogger<'q> {
     }
 }
 
-impl<'q> Drop for QueryLogger<'q> {
+impl Drop for QueryLogger {
     fn drop(&mut self) {
         self.finish();
     }

sqlx-core/src/migrate/migration.rs

@@ -2,14 +2,16 @@ use std::borrow::Cow;
 
 use sha2::{Digest, Sha384};
 
+use crate::sql_str::{SqlSafeStr, SqlStr};
+
 use super::MigrationType;
 
 #[derive(Debug, Clone)]
 pub struct Migration {
     pub version: i64,
     pub description: Cow<'static, str>,
     pub migration_type: MigrationType,
-    pub sql: Cow<'static, str>,
+    pub sql: SqlStr,
     pub checksum: Cow<'static, [u8]>,
     pub no_tx: bool,
 }
@@ -19,10 +21,13 @@ impl Migration {
         version: i64,
         description: Cow<'static, str>,
         migration_type: MigrationType,
-        sql: Cow<'static, str>,
+        sql: impl SqlSafeStr,
         no_tx: bool,
     ) -> Self {
-        let checksum = Cow::Owned(Vec::from(Sha384::digest(sql.as_bytes()).as_slice()));
+        let sql = sql.into_sql_str();
+        let checksum = Cow::Owned(Vec::from(
+            Sha384::digest(sql.as_str().as_bytes()).as_slice(),
+        ));
 
         Migration {
             version,

sqlx-core/src/migrate/source.rs

@@ -1,5 +1,6 @@
 use crate::error::BoxDynError;
 use crate::migrate::{Migration, MigrationType};
+use crate::sql_str::AssertSqlSafe;
 use futures_core::future::BoxFuture;
 
 use std::borrow::Cow;
@@ -131,7 +132,7 @@ pub fn resolve_blocking(path: &Path) -> Result<Vec<(Migration, PathBuf)>, Resolv
                 version,
                 Cow::Owned(description),
                 migration_type,
-                Cow::Owned(sql),
+                AssertSqlSafe(sql),
                 no_tx,
             ),
             entry_path,

sqlx-core/src/pool/executor.rs

@@ -8,6 +8,7 @@ use crate::describe::Describe;
 use crate::error::Error;
 use crate::executor::{Execute, Executor};
 use crate::pool::Pool;
+use crate::sql_str::SqlSafeStr;
 
 impl<'p, DB: Database> Executor<'p> for &'_ Pool<DB>
 where
@@ -48,22 +49,30 @@ where
         Box::pin(async move { pool.acquire().await?.fetch_optional(query).await })
     }
 
-    fn prepare_with<'e, 'q: 'e>(
+    fn prepare_with<'e>(
         self,
-        sql: &'q str,
+        sql: impl SqlSafeStr,
         parameters: &'e [<Self::Database as Database>::TypeInfo],
-    ) -> BoxFuture<'e, Result<<Self::Database as Database>::Statement, Error>> {
+    ) -> BoxFuture<'e, Result<<Self::Database as Database>::Statement, Error>>
+    where
+        'p: 'e,
+    {
         let pool = self.clone();
+        let sql = sql.into_sql_str();
 
         Box::pin(async move { pool.acquire().await?.prepare_with(sql, parameters).await })
     }
 
     #[doc(hidden)]
-    fn describe<'e, 'q: 'e>(
+    fn describe<'e>(
         self,
-        sql: &'q str,
-    ) -> BoxFuture<'e, Result<Describe<Self::Database>, Error>> {
+        sql: impl SqlSafeStr,
+    ) -> BoxFuture<'e, Result<Describe<Self::Database>, Error>>
+    where
+        'p: 'e,
+    {
         let pool = self.clone();
+        let sql = sql.into_sql_str();
 
         Box::pin(async move { pool.acquire().await?.describe(sql).await })
     }