update test

Author: JosiahParry

tests/any/any.rs

@@ -150,6 +150,68 @@ 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(())
+}
+
 #[cfg(feature = "json")]
 #[sqlx_macros::test]
 async fn it_encodes_decodes_json() -> anyhow::Result<()> {
@@ -165,25 +227,9 @@ async fn it_encodes_decodes_json() -> anyhow::Result<()> {
         "items": [1, 2, 3]
     });
 
-    // Create temp table:
-    sqlx::query("create temporary table json_test (data TEXT)")
-        .execute(&mut conn)
-        .await?;
-
-    #[cfg(feature = "postgres")]
-    let query = "insert into json_test (data) values ($1)";
-
-    #[cfg(not(feature = "postgres"))]
-    let query = "insert into json_test (data) values (?)";
-
-    // Insert into the temporary table:
-    sqlx::query(query)
-        .bind(Json(&json_value))
-        .execute(&mut conn)
-        .await?;
-
     // This will work by encoding JSON as text and decoding it back
-    let result: serde_json::Value = sqlx::query_scalar("select data from json_test")
+    let result: serde_json::Value = sqlx::query_scalar("SELECT ?")
+        .bind(Json(&json_value))
         .fetch_one(&mut conn)
         .await?;
 
@@ -193,25 +239,22 @@ async fn it_encodes_decodes_json() -> anyhow::Result<()> {
     #[derive(Serialize, Deserialize, Debug, PartialEq)]
     struct TestData {
         name: String,
-        value: i32,
-        items: [i32; 3],
+        count: i32,
     }
 
     let test_data = TestData {
-        name: "test".to_string(),
-        value: 42,
-        items: [1, 2, 3],
+        name: "example".to_string(),
+        count: 100,
     };
 
-    let result: Json<TestData> = sqlx::query_scalar("select data from json_test")
+    let result: Json<TestData> = sqlx::query_scalar("SELECT ?")
+        .bind(Json(&test_data))
         .fetch_one(&mut conn)
         .await?;
 
     assert_eq!(result.0, test_data);
-    #[sqlx_macros::test]
-    async fn it_can_query_by_string_args() -> sqlx::Result<()> {
-        install_default_drivers();
 
+<<<<<<< Updated upstream
         let mut conn = new::<Any>().await?;
 
         let string = "Hello, world!".to_string();
@@ -372,5 +415,7 @@ async fn it_can_query_by_string_args() -> sqlx::Result<()> {
         assert_eq!(column_0, string);
     }
 
+=======
+>>>>>>> Stashed changes
     Ok(())
 }