refactor(core): Also relax lifetime of argument passed to Query::bind and Query::try_bind

Signed-off-by: Joshua Potts <[email protected]>

Author: iamjpotts

sqlx-core/src/query.rs

@@ -73,7 +73,7 @@ where
     }
 }
 
-impl<'q, DB: Database> Query<'q, DB, <DB as Database>::Arguments> {
+impl<DB: Database> Query<'_, DB, <DB as Database>::Arguments> {
     /// Bind a value for use with this SQL query.
     ///
     /// If the number of times this is called does not match the number of bind parameters that
@@ -84,7 +84,7 @@ impl<'q, DB: Database> Query<'q, DB, <DB as Database>::Arguments> {
     /// flavors will perform type coercion (Postgres will return a database error).
     ///
     /// If encoding the value fails, the error is stored and later surfaced when executing the query.
-    pub fn bind<T: 'q + Encode<'q, DB> + Type<DB>>(mut self, value: T) -> Self {
+    pub fn bind<'t, T: Encode<'t, DB> + Type<DB>>(mut self, value: T) -> Self {
         let Ok(arguments) = self.get_arguments() else {
             return self;
         };
@@ -101,7 +101,7 @@ impl<'q, DB: Database> Query<'q, DB, <DB as Database>::Arguments> {
     }
 
     /// Like [`Query::bind`] but immediately returns an error if encoding a value failed.
-    pub fn try_bind<T: 'q + Encode<'q, DB> + Type<DB>>(
+    pub fn try_bind<'t, T: Encode<'t, DB> + Type<DB>>(
         &mut self,
         value: T,
     ) -> Result<(), BoxDynError> {

sqlx-test/src/lib.rs

@@ -1,5 +1,5 @@
 use sqlx::pool::PoolOptions;
-use sqlx::{Connection, Database, Pool};
+use sqlx::{Connection, Database, Error, Pool};
 use std::env;
 
 pub fn setup_if_needed() {
@@ -9,13 +9,15 @@ pub fn setup_if_needed() {
 
 // Make a new connection
 // Ensure [dotenvy] and [env_logger] have been setup
-pub async fn new<DB>() -> anyhow::Result<DB::Connection>
+pub async fn new<DB>() -> sqlx::Result<DB::Connection>
 where
     DB: Database,
 {
     setup_if_needed();
 
-    Ok(DB::Connection::connect(&env::var("DATABASE_URL")?).await?)
+    let db_url = env::var("DATABASE_URL").map_err(|e| Error::Configuration(Box::new(e)))?;
+
+    Ok(DB::Connection::connect(&db_url).await?)
 }
 
 // Make a new pool

tests/any/any.rs

@@ -1,6 +1,8 @@
-use sqlx::any::AnyRow;
+use sqlx::any::{install_default_drivers, AnyRow};
 use sqlx::{Any, Connection, Executor, Row};
+use sqlx_core::error::BoxDynError;
 use sqlx_core::sql_str::AssertSqlSafe;
+use sqlx_core::Error;
 use sqlx_test::new;
 
 #[sqlx_macros::test]
@@ -142,3 +144,65 @@ async fn it_can_fail_and_recover_with_pool() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[sqlx_macros::test]
+async fn it_can_query_by_string_args() -> sqlx::Result<()> {
+    install_default_drivers();
+
+    let mut conn = new::<Any>().await?;
+
+    let string = "Hello, world!".to_string();
+    let ref tuple = ("Hello, world!".to_string(),);
+
+    #[cfg(feature = "postgres")]
+    const SQL: &str =
+        "SELECT 'Hello, world!' as string where 'Hello, world!' in ($1, $2, $3, $4, $5, $6, $7)";
+
+    #[cfg(not(feature = "postgres"))]
+    const SQL: &str =
+        "SELECT 'Hello, world!' as string where 'Hello, world!' in (?, ?, ?, ?, ?, ?, ?)";
+
+    {
+        let query = sqlx::query(SQL)
+            // validate flexibility of lifetimes
+            .bind(&string)
+            .bind(&string[..])
+            .bind(Some(&string))
+            .bind(Some(&string[..]))
+            .bind(&Option::<String>::None)
+            .bind(&string.clone())
+            .bind(&tuple.0); // should not get "temporary value is freed at the end of this statement" here
+
+        let result = query.fetch_one(&mut conn).await?;
+
+        let column_0: String = result.try_get(0)?;
+
+        assert_eq!(column_0, string);
+    }
+
+    {
+        let mut query = sqlx::query(SQL);
+
+        let query = || -> Result<_, BoxDynError> {
+            // validate flexibility of lifetimes
+            query.try_bind(&string)?;
+            query.try_bind(&string[..])?;
+            query.try_bind(Some(&string))?;
+            query.try_bind(Some(&string[..]))?;
+            query.try_bind(&Option::<String>::None)?;
+            query.try_bind(&string.clone())?;
+            query.try_bind(&tuple.0)?;
+
+            Ok(query)
+        }()
+        .map_err(Error::Encode)?;
+
+        let result = query.fetch_one(&mut conn).await?;
+
+        let column_0: String = result.try_get(0)?;
+
+        assert_eq!(column_0, string);
+    }
+
+    Ok(())
+}