fix: RawSql lifetime issues (#3613)

* chore(raw_sql): create regression test

* fix: `RawSql` lifetime issues

* chore(raw_sql): try not adding another lifetime param

Author: abonander

sqlx-core/src/raw_sql.rs

@@ -1,4 +1,5 @@
 use either::Either;
+use futures_core::future::BoxFuture;
 use futures_core::stream::BoxStream;
 
 use crate::database::Database;
@@ -139,26 +140,25 @@ impl<'q, DB: Database> Execute<'q, DB> for RawSql<'q> {
 impl<'q> RawSql<'q> {
     /// Execute the SQL string and return the total number of rows affected.
     #[inline]
-    pub async fn execute<'e, E>(
-        self,
-        executor: E,
-    ) -> crate::Result<<E::Database as Database>::QueryResult>
+    pub async fn execute<'e, E, DB>(self, executor: E) -> crate::Result<DB::QueryResult>
     where
         'q: 'e,
-        E: Executor<'e>,
+        DB: Database,
+        E: Executor<'e, Database = DB>,
     {
         executor.execute(self).await
     }
 
     /// Execute the SQL string. Returns a stream which gives the number of rows affected for each statement in the string.
     #[inline]
-    pub fn execute_many<'e, E>(
+    pub fn execute_many<'e, E, DB>(
         self,
         executor: E,
-    ) -> BoxStream<'e, crate::Result<<E::Database as Database>::QueryResult>>
+    ) -> BoxStream<'e, crate::Result<DB::QueryResult>>
     where
         'q: 'e,
-        E: Executor<'e>,
+        DB: Database,
+        E: Executor<'e, Database = DB>,
     {
         executor.execute_many(self)
     }
@@ -167,13 +167,11 @@ impl<'q> RawSql<'q> {
     ///
     /// If the string contains multiple statements, their results will be concatenated together.
     #[inline]
-    pub fn fetch<'e, E>(
-        self,
-        executor: E,
-    ) -> BoxStream<'e, Result<<E::Database as Database>::Row, Error>>
+    pub fn fetch<'e, E, DB>(self, executor: E) -> BoxStream<'e, Result<DB::Row, Error>>
     where
         'q: 'e,
-        E: Executor<'e>,
+        DB: Database,
+        E: Executor<'e, Database = DB>,
     {
         executor.fetch(self)
     }
@@ -183,19 +181,14 @@ impl<'q> RawSql<'q> {
     /// For each query in the stream, any generated rows are returned first,
     /// then the `QueryResult` with the number of rows affected.
     #[inline]
-    pub fn fetch_many<'e, E>(
+    pub fn fetch_many<'e, E, DB>(
         self,
         executor: E,
-    ) -> BoxStream<
-        'e,
-        Result<
-            Either<<E::Database as Database>::QueryResult, <E::Database as Database>::Row>,
-            Error,
-        >,
-    >
+    ) -> BoxStream<'e, Result<Either<DB::QueryResult, DB::Row>, Error>>
     where
         'q: 'e,
-        E: Executor<'e>,
+        DB: Database,
+        E: Executor<'e, Database = DB>,
     {
         executor.fetch_many(self)
     }
@@ -208,15 +201,13 @@ impl<'q> RawSql<'q> {
     /// To avoid exhausting available memory, ensure the result set has a known upper bound,
     /// e.g. using `LIMIT`.
     #[inline]
-    pub async fn fetch_all<'e, E>(
-        self,
-        executor: E,
-    ) -> crate::Result<Vec<<E::Database as Database>::Row>>
+    pub fn fetch_all<'e, E, DB>(self, executor: E) -> BoxFuture<'e, crate::Result<Vec<DB::Row>>>
     where
         'q: 'e,
-        E: Executor<'e>,
+        DB: Database,
+        E: Executor<'e, Database = DB>,
     {
-        executor.fetch_all(self).await
+        executor.fetch_all(self)
     }
 
     /// Execute the SQL string, returning the first row or [`Error::RowNotFound`] otherwise.
@@ -232,15 +223,13 @@ impl<'q> RawSql<'q> {
     ///
     /// Otherwise, you might want to add `LIMIT 1` to your query.
     #[inline]
-    pub async fn fetch_one<'e, E>(
-        self,
-        executor: E,
-    ) -> crate::Result<<E::Database as Database>::Row>
+    pub fn fetch_one<'e, E, DB>(self, executor: E) -> BoxFuture<'e, crate::Result<DB::Row>>
     where
         'q: 'e,
-        E: Executor<'e>,
+        DB: Database,
+        E: Executor<'e, Database = DB>,
     {
-        executor.fetch_one(self).await
+        executor.fetch_one(self)
     }
 
     /// Execute the SQL string, returning the first row or [`None`] otherwise.
@@ -256,13 +245,11 @@ impl<'q> RawSql<'q> {
     ///
     /// Otherwise, you might want to add `LIMIT 1` to your query.
     #[inline]
-    pub async fn fetch_optional<'e, E>(
-        self,
-        executor: E,
-    ) -> crate::Result<<E::Database as Database>::Row>
+    pub async fn fetch_optional<'e, E, DB>(self, executor: E) -> crate::Result<DB::Row>
     where
         'q: 'e,
-        E: Executor<'e>,
+        DB: Database,
+        E: Executor<'e, Database = DB>,
     {
         executor.fetch_one(self).await
     }

tests/sqlite/sqlite.rs

@@ -8,6 +8,7 @@ use sqlx::{
 };
 use sqlx_sqlite::LockedSqliteHandle;
 use sqlx_test::new;
+use std::future::Future;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
@@ -969,6 +970,24 @@ async fn test_multiple_set_rollback_hook_calls_drop_old_handler() -> anyhow::Res
     Ok(())
 }
 
+#[sqlx_macros::test]
+async fn issue_3150() {
+    // Same bounds as `tokio::spawn()`
+    async fn fake_spawn<F>(future: F) -> F::Output
+    where
+        F: Future + Send + 'static,
+    {
+        future.await
+    }
+
+    fake_spawn(async {
+        let mut db = SqliteConnection::connect(":memory:").await.unwrap();
+        sqlx::raw_sql("").execute(&mut db).await.unwrap();
+        db.close().await.unwrap();
+    })
+    .await;
+}
+
 #[cfg(feature = "sqlite-preupdate-hook")]
 #[sqlx_macros::test]
 async fn test_query_with_preupdate_hook_insert() -> anyhow::Result<()> {