Add SqlStr

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;
@@ -96,23 +97,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<'q>>>;
+    ) -> BoxFuture<'c, crate::Result<AnyStatement>>;
 
-    fn describe<'q>(&'q mut self, sql: &'q str) -> BoxFuture<'q, crate::Result<Describe<Any>>>;
+    fn describe(&mut self, sql: SqlStr) -> BoxFuture<'_, 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<'q>, Error>>
+    ) -> 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/database.rs

@@ -28,7 +28,7 @@ impl Database for Any {
     type Arguments<'q> = AnyArguments<'q>;
     type ArgumentBuffer<'q> = AnyArgumentBuffer<'q>;
 
-    type Statement<'q> = AnyStatement<'q>;
+    type Statement = AnyStatement;
 
     const NAME: &'static str = "Any";
 

sqlx-core/src/any/statement.rs

@@ -3,15 +3,15 @@ use crate::column::ColumnIndex;
 use crate::database::Database;
 use crate::error::Error;
 use crate::ext::ustr::UStr;
+use crate::sql_str::SqlStr;
 use crate::statement::Statement;
 use crate::HashMap;
 use either::Either;
-use std::borrow::Cow;
 use std::sync::Arc;
 
-pub struct AnyStatement<'q> {
+pub struct AnyStatement {
     #[doc(hidden)]
-    pub sql: Cow<'q, str>,
+    pub sql: SqlStr,
     #[doc(hidden)]
     pub parameters: Option<Either<Vec<AnyTypeInfo>, usize>>,
     #[doc(hidden)]
@@ -20,20 +20,24 @@ pub struct AnyStatement<'q> {
     pub columns: Vec<AnyColumn>,
 }
 
-impl<'q> Statement<'q> for AnyStatement<'q> {
+impl Statement for AnyStatement {
     type Database = Any;
 
-    fn to_owned(&self) -> AnyStatement<'static> {
-        AnyStatement::<'static> {
-            sql: Cow::Owned(self.sql.clone().into_owned()),
+    fn to_owned(&self) -> AnyStatement {
+        AnyStatement {
+            sql: self.sql.clone(),
             column_names: self.column_names.clone(),
             parameters: self.parameters.clone(),
             columns: self.columns.clone(),
         }
     }
 
-    fn sql(&self) -> &str {
-        &self.sql
+    fn sql_cloned(&self) -> SqlStr {
+        self.sql.clone()
+    }
+
+    fn into_sql(self) -> SqlStr {
+        self.sql
     }
 
     fn parameters(&self) -> Option<Either<&[AnyTypeInfo], usize>> {
@@ -51,8 +55,8 @@ impl<'q> Statement<'q> for AnyStatement<'q> {
     impl_statement_query!(AnyArguments<'_>);
 }
 
-impl ColumnIndex<AnyStatement<'_>> for &'_ str {
-    fn index(&self, statement: &AnyStatement<'_>) -> Result<usize, Error> {
+impl ColumnIndex<AnyStatement> for &'_ str {
+    fn index(&self, statement: &AnyStatement) -> Result<usize, Error> {
         statement
             .column_names
             .get(*self)
@@ -61,15 +65,14 @@ impl ColumnIndex<AnyStatement<'_>> for &'_ str {
     }
 }
 
-impl<'q> AnyStatement<'q> {
+impl AnyStatement {
     #[doc(hidden)]
     pub fn try_from_statement<S>(
-        query: &'q str,
-        statement: &S,
+        statement: S,
         column_names: Arc<HashMap<UStr, usize>>,
     ) -> crate::Result<Self>
     where
-        S: Statement<'q>,
+        S: Statement,
         AnyTypeInfo: for<'a> TryFrom<&'a <S::Database as Database>::TypeInfo, Error = Error>,
         AnyColumn: for<'a> TryFrom<&'a <S::Database as Database>::Column, Error = Error>,
     {
@@ -91,7 +94,7 @@ impl<'q> AnyStatement<'q> {
             .collect::<Result<Vec<_>, _>>()?;
 
         Ok(Self {
-            sql: query.into(),
+            sql: statement.into_sql(),
             columns,
             column_names,
             parameters,

sqlx-core/src/column.rs

@@ -125,8 +125,8 @@ macro_rules! impl_column_index_for_row {
 #[macro_export]
 macro_rules! impl_column_index_for_statement {
     ($S:ident) => {
-        impl $crate::column::ColumnIndex<$S<'_>> for usize {
-            fn index(&self, statement: &$S<'_>) -> Result<usize, $crate::error::Error> {
+        impl $crate::column::ColumnIndex<$S> for usize {
+            fn index(&self, statement: &$S) -> Result<usize, $crate::error::Error> {
                 let len = $crate::statement::Statement::columns(statement).len();
 
                 if *self >= len {

sqlx-core/src/database.rs

@@ -101,7 +101,7 @@ pub trait Database: 'static + Sized + Send + Debug {
     type ArgumentBuffer<'q>;
 
     /// The concrete `Statement` implementation for this database.
-    type Statement<'q>: Statement<'q, Database = Self>;
+    type Statement: Statement<Database = Self>;
 
     /// The display name for this database driver.
     const NAME: &'static str;

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;
@@ -148,10 +149,10 @@ 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,
-    ) -> BoxFuture<'e, Result<<Self::Database as Database>::Statement<'q>, Error>>
+        query: impl SqlSafeStr,
+    ) -> BoxFuture<'e, Result<<Self::Database as Database>::Statement, Error>>
     where
         'c: 'e,
     {
@@ -163,11 +164,11 @@ 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<'q>, Error>>
+    ) -> BoxFuture<'e, Result<<Self::Database as Database>::Statement, Error>>
     where
         'c: 'e;
 
@@ -177,9 +178,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;
@@ -194,10 +195,10 @@ 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<'q>>;
+    fn statement(&self) -> Option<&DB::Statement>;
 
     /// Returns the arguments to be bound against the query string.
     ///
@@ -212,22 +213,23 @@ 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]
-    fn statement(&self) -> Option<&DB::Statement<'q>> {
+    fn statement(&self) -> Option<&DB::Statement> {
         None
     }
 
     #[inline]
     fn take_arguments(&mut self) -> Result<Option<<DB as Database>::Arguments<'q>>, BoxDynError> {
-        Ok(None)
+        Ok(self.1.take())
     }
 
     #[inline]
@@ -236,20 +238,23 @@ 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]
-    fn statement(&self) -> Option<&DB::Statement<'q>> {
+    fn statement(&self) -> Option<&DB::Statement> {
         None
     }
 
     #[inline]
     fn take_arguments(&mut self) -> Result<Option<<DB as Database>::Arguments<'q>>, BoxDynError> {
-        Ok(self.1.take())
+        Ok(None)
     }
 
     #[inline]

sqlx-core/src/lib.rs

@@ -72,6 +72,7 @@ pub mod net;
 pub mod query_as;
 pub mod query_builder;
 pub mod query_scalar;
+pub mod sql_str;
 
 pub mod raw_sql;
 pub mod row;