Move Connection, AnyConnectionBackend and TransactionManager to SqlStr

Author: joeydewaal

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

@@ -4,7 +4,6 @@ use crate::sql_str::SqlStr;
 use either::Either;
 use futures_core::future::BoxFuture;
 use futures_core::stream::BoxStream;
-use std::borrow::Cow;
 use std::fmt::Debug;
 
 pub trait AnyConnectionBackend: std::any::Any + Debug + Send + 'static {
@@ -34,7 +33,7 @@ pub trait AnyConnectionBackend: std::any::Any + Debug + Send + 'static {
     ///
     /// If we are already inside a transaction and `statement.is_some()`, then
     /// `Error::InvalidSavePoint` is returned without running any statements.
-    fn begin(&mut self, statement: Option<Cow<'static, str>>) -> BoxFuture<'_, crate::Result<()>>;
+    fn begin(&mut self, statement: Option<SqlStr>) -> BoxFuture<'_, crate::Result<()>>;
 
     fn commit(&mut self) -> BoxFuture<'_, crate::Result<()>>;
 

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

@@ -1,12 +1,12 @@
 use futures_core::future::BoxFuture;
-use std::borrow::Cow;
 use std::future::Future;
 
 use crate::any::{Any, AnyConnectOptions};
 use crate::connection::{ConnectOptions, Connection};
 use crate::error::Error;
 
 use crate::database::Database;
+use crate::sql_str::SqlSafeStr;
 pub use backend::AnyConnectionBackend;
 
 use crate::transaction::Transaction;
@@ -96,12 +96,12 @@ impl Connection for AnyConnection {
 
     fn begin_with(
         &mut self,
-        statement: impl Into<Cow<'static, str>>,
+        statement: impl SqlSafeStr,
     ) -> impl Future<Output = Result<Transaction<'_, Self::Database>, Error>> + Send + '_
     where
         Self: Sized,
     {
-        Transaction::begin(self, Some(statement.into()))
+        Transaction::begin(self, Some(statement.into_sql_str()))
     }
 
     fn cached_statements_size(&self) -> usize {

sqlx-core/src/any/transaction.rs

@@ -1,9 +1,9 @@
-use std::borrow::Cow;
 use std::future::Future;
 
 use crate::any::{Any, AnyConnection};
 use crate::database::Database;
 use crate::error::Error;
+use crate::sql_str::SqlStr;
 use crate::transaction::TransactionManager;
 
 pub struct AnyTransactionManager;
@@ -13,7 +13,7 @@ impl TransactionManager for AnyTransactionManager {
 
     fn begin<'conn>(
         conn: &'conn mut AnyConnection,
-        statement: Option<Cow<'static, str>>,
+        statement: Option<SqlStr>,
     ) -> impl Future<Output = Result<(), Error>> + Send + 'conn {
         conn.backend.begin(statement)
     }

sqlx-core/src/connection.rs

@@ -1,10 +1,10 @@
 use crate::database::{Database, HasStatementCache};
 use crate::error::Error;
 
+use crate::sql_str::SqlSafeStr;
 use crate::transaction::{Transaction, TransactionManager};
 use futures_core::future::BoxFuture;
 use log::LevelFilter;
-use std::borrow::Cow;
 use std::fmt::Debug;
 use std::future::Future;
 use std::str::FromStr;
@@ -59,12 +59,12 @@ pub trait Connection: Send {
     /// `statement` does not put the connection into a transaction.
     fn begin_with(
         &mut self,
-        statement: impl Into<Cow<'static, str>>,
+        statement: impl SqlSafeStr,
     ) -> impl Future<Output = Result<Transaction<'_, Self::Database>, Error>> + Send + '_
     where
         Self: Sized,
     {
-        Transaction::begin(self, Some(statement.into()))
+        Transaction::begin(self, Some(statement.into_sql_str()))
     }
 
     /// Returns `true` if the connection is currently in a transaction.

sqlx-core/src/pool/mod.rs

@@ -54,7 +54,6 @@
 //! [`Pool::acquire`] or
 //! [`Pool::begin`].
 
-use std::borrow::Cow;
 use std::fmt;
 use std::future::Future;
 use std::pin::{pin, Pin};
@@ -69,6 +68,7 @@ use futures_util::FutureExt;
 use crate::connection::Connection;
 use crate::database::Database;
 use crate::error::Error;
+use crate::sql_str::SqlSafeStr;
 use crate::transaction::Transaction;
 
 pub use self::connection::PoolConnection;
@@ -390,11 +390,11 @@ impl<DB: Database> Pool<DB> {
     /// Retrieves a connection and immediately begins a new transaction using `statement`.
     pub async fn begin_with(
         &self,
-        statement: impl Into<Cow<'static, str>>,
+        statement: impl SqlSafeStr,
     ) -> Result<Transaction<'static, DB>, Error> {
         Transaction::begin(
             MaybePoolConnection::PoolConnection(self.acquire().await?),
-            Some(statement.into()),
+            Some(statement.into_sql_str()),
         )
         .await
     }
@@ -403,12 +403,12 @@ impl<DB: Database> Pool<DB> {
     /// transaction using `statement`.
     pub async fn try_begin_with(
         &self,
-        statement: impl Into<Cow<'static, str>>,
+        statement: impl SqlSafeStr,
     ) -> Result<Option<Transaction<'static, DB>>, Error> {
         match self.try_acquire() {
             Some(conn) => Transaction::begin(
                 MaybePoolConnection::PoolConnection(conn),
-                Some(statement.into()),
+                Some(statement.into_sql_str()),
             )
             .await
             .map(Some),

sqlx-core/src/transaction.rs

@@ -1,4 +1,3 @@
-use std::borrow::Cow;
 use std::fmt::{self, Debug, Formatter};
 use std::future::{self, Future};
 use std::ops::{Deref, DerefMut};
@@ -25,7 +24,7 @@ pub trait TransactionManager {
     /// `Error::InvalidSavePoint` is returned without running any statements.
     fn begin<'conn>(
         conn: &'conn mut <Self::Database as Database>::Connection,
-        statement: Option<Cow<'static, str>>,
+        statement: Option<SqlStr>,
     ) -> impl Future<Output = Result<(), Error>> + Send + 'conn;
 
     /// Commit the active transaction or release the most recent savepoint.
@@ -99,7 +98,7 @@ where
     #[doc(hidden)]
     pub fn begin(
         conn: impl Into<MaybePoolConnection<'c, DB>>,
-        statement: Option<Cow<'static, str>>,
+        statement: Option<SqlStr>,
     ) -> BoxFuture<'c, Result<Self, Error>> {
         let mut conn = conn.into();
 

sqlx-mysql/src/any.rs

@@ -17,7 +17,6 @@ use sqlx_core::describe::Describe;
 use sqlx_core::executor::Executor;
 use sqlx_core::sql_str::SqlStr;
 use sqlx_core::transaction::TransactionManager;
-use std::borrow::Cow;
 use std::{future, pin::pin};
 
 sqlx_core::declare_driver_with_optional_migrate!(DRIVER = MySql);
@@ -39,10 +38,7 @@ impl AnyConnectionBackend for MySqlConnection {
         Connection::ping(self).boxed()
     }
 
-    fn begin(
-        &mut self,
-        statement: Option<Cow<'static, str>>,
-    ) -> BoxFuture<'_, sqlx_core::Result<()>> {
+    fn begin(&mut self, statement: Option<SqlStr>) -> BoxFuture<'_, sqlx_core::Result<()>> {
         MySqlTransactionManager::begin(self, statement).boxed()
     }
 

sqlx-mysql/src/connection/mod.rs

@@ -1,8 +1,8 @@
-use std::borrow::Cow;
 use std::fmt::{self, Debug, Formatter};
 use std::future::Future;
 
 pub(crate) use sqlx_core::connection::*;
+use sqlx_core::sql_str::SqlSafeStr;
 pub(crate) use stream::{MySqlStream, Waiting};
 
 use crate::common::StatementCache;
@@ -117,12 +117,12 @@ impl Connection for MySqlConnection {
 
     fn begin_with(
         &mut self,
-        statement: impl Into<Cow<'static, str>>,
+        statement: impl SqlSafeStr,
     ) -> impl Future<Output = Result<Transaction<'_, Self::Database>, Error>> + Send + '_
     where
         Self: Sized,
     {
-        Transaction::begin(self, Some(statement.into()))
+        Transaction::begin(self, Some(statement.into_sql_str()))
     }
 
     fn shrink_buffers(&mut self) {

sqlx-mysql/src/transaction.rs

@@ -1,6 +1,4 @@
-use std::borrow::Cow;
-
-use sqlx_core::sql_str::{AssertSqlSafe, SqlSafeStr};
+use sqlx_core::sql_str::SqlStr;
 
 use crate::connection::Waiting;
 use crate::error::Error;
@@ -16,16 +14,14 @@ pub struct MySqlTransactionManager;
 impl TransactionManager for MySqlTransactionManager {
     type Database = MySql;
 
-    async fn begin(
-        conn: &mut MySqlConnection,
-        statement: Option<Cow<'static, str>>,
-    ) -> Result<(), Error> {
+    async fn begin(conn: &mut MySqlConnection, statement: Option<SqlStr>) -> Result<(), Error> {
         let depth = conn.inner.transaction_depth;
+
         let statement = match statement {
             // custom `BEGIN` statements are not allowed if we're already in a transaction
             // (we need to issue a `SAVEPOINT` instead)
             Some(_) if depth > 0 => return Err(Error::InvalidSavePointStatement),
-            Some(statement) => AssertSqlSafe(statement).into_sql_str(),
+            Some(statement) => statement,
             None => begin_ansi_transaction_sql(depth),
         };
         conn.execute(statement).await?;

sqlx-postgres/src/any.rs

@@ -6,7 +6,6 @@ use futures_core::future::BoxFuture;
 use futures_core::stream::BoxStream;
 use futures_util::{stream, FutureExt, StreamExt, TryFutureExt, TryStreamExt};
 use sqlx_core::sql_str::SqlStr;
-use std::borrow::Cow;
 use std::{future, pin::pin};
 
 use sqlx_core::any::{
@@ -41,10 +40,7 @@ impl AnyConnectionBackend for PgConnection {
         Connection::ping(self).boxed()
     }
 
-    fn begin(
-        &mut self,
-        statement: Option<Cow<'static, str>>,
-    ) -> BoxFuture<'_, sqlx_core::Result<()>> {
+    fn begin(&mut self, statement: Option<SqlStr>) -> BoxFuture<'_, sqlx_core::Result<()>> {
         PgTransactionManager::begin(self, statement).boxed()
     }