fix doc test

Author: joeydewaal

sqlx-core/src/query.rs

@@ -558,7 +558,7 @@ where
 /// let query = format!("SELECT * FROM articles WHERE content LIKE '%{user_input}%'");
 /// // where `conn` is `PgConnection` or `MySqlConnection`
 /// // or some other type that implements `Executor`.
-/// let results = sqlx::query(&query).fetch_all(&mut conn).await?;
+/// let results = sqlx::query(sqlx::AssertSqlSafe(query)).fetch_all(&mut conn).await?;
 /// # Ok(())
 /// # }
 /// ```

sqlx-core/src/sql_str.rs

@@ -1,4 +1,4 @@
-use std::borrow::Borrow;
+use std::borrow::{Borrow, Cow};
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 
@@ -102,6 +102,15 @@ impl SqlSafeStr for AssertSqlSafe<Arc<String>> {
     }
 }
 
+impl SqlSafeStr for AssertSqlSafe<Cow<'static, str>> {
+    fn into_sql_str(self) -> SqlStr {
+        match self.0 {
+            Cow::Borrowed(str) => str.into_sql_str(),
+            Cow::Owned(str) => AssertSqlSafe(str).into_sql_str(),
+        }
+    }
+}
+
 /// A SQL string that is ready to execute on a database connection.
 ///
 /// This is essentially `Cow<'static, str>` but which can be constructed from additional types

sqlx-core/src/transaction.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::fmt::{self, Debug, Formatter};
 use std::ops::{Deref, DerefMut};
 

sqlx-mysql/src/transaction.rs

@@ -1,6 +1,7 @@
 use std::borrow::Cow;
 
 use futures_core::future::BoxFuture;
+use sqlx_core::sql_str::{AssertSqlSafe, SqlSafeStr};
 
 use crate::connection::Waiting;
 use crate::error::Error;
@@ -27,10 +28,10 @@ impl TransactionManager for MySqlTransactionManager {
                 // 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) => statement,
+                Some(statement) => AssertSqlSafe(statement).into_sql_str(),
                 None => begin_ansi_transaction_sql(depth),
             };
-            conn.execute(&*statement).await?;
+            conn.execute(statement).await?;
             if !conn.in_transaction() {
                 return Err(Error::BeginFailed);
             }

sqlx-postgres/src/any.rs

@@ -5,9 +5,8 @@ use crate::{
 use futures_core::future::BoxFuture;
 use futures_core::stream::BoxStream;
 use futures_util::{stream, StreamExt, TryFutureExt, TryStreamExt};
-use std::borrow::Cow;
-use std::{future, pin::pin};
 use sqlx_core::sql_str::SqlStr;
+use std::borrow::Cow;
 use std::{future, pin::pin};
 
 use sqlx_core::any::{

sqlx-postgres/src/transaction.rs

@@ -1,5 +1,6 @@
 use futures_core::future::BoxFuture;
 use sqlx_core::database::Database;
+use sqlx_core::sql_str::{AssertSqlSafe, SqlSafeStr};
 use std::borrow::Cow;
 
 use crate::error::Error;
@@ -25,13 +26,13 @@ impl TransactionManager for PgTransactionManager {
                 // 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) => statement,
+                Some(statement) => AssertSqlSafe(statement).into_sql_str(),
                 None => begin_ansi_transaction_sql(depth),
             };
 
             let rollback = Rollback::new(conn);
 
-            rollback.conn.queue_simple_query(&statement)?;
+            rollback.conn.queue_simple_query(statement.as_str())?;
             rollback.conn.wait_until_ready().await?;
             if !rollback.conn.in_transaction() {
                 return Err(Error::BeginFailed);

sqlx-sqlite/src/connection/worker.rs

@@ -1,11 +1,12 @@
+use std::borrow::Cow;
 use std::future::Future;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::thread;
 
 use futures_channel::oneshot;
 use futures_intrusive::sync::{Mutex, MutexGuard};
-use sqlx_core::sql_str::SqlStr;
+use sqlx_core::sql_str::{AssertSqlSafe, SqlSafeStr, SqlStr};
 use tracing::span::Span;
 
 use sqlx_core::describe::Describe;
@@ -219,12 +220,12 @@ impl ConnectionWorker {
                                     }
                                     continue;
                                 },
-                                Some(statement) => statement,
+                                Some(statement) => AssertSqlSafe(statement).into_sql_str(),
                                 None => begin_ansi_transaction_sql(depth),
                             };
                             let res =
                                 conn.handle
-                                    .exec(begin_ansi_transaction_sql(depth).as_str())
+                                    .exec(statement.as_str())
                                     .map(|_| {
                                         shared.transaction_depth.fetch_add(1, Ordering::Release);
                                     });