Avoid unecessary allocation in quaint query building

Cargo.toml

@@ -23,3 +23,6 @@ members = [
   "libs/prisma-models",
   "libs/prisma-value",
 ]
+
+[patch."https://github.com/prisma/quaint"]
+quaint = { path = "../quaint" }

migration-engine/connectors/sql-migration-connector/src/sql_migration_persistence.rs

@@ -111,7 +111,10 @@ impl MigrationPersistence for SqlMigrationPersistence<'_> {
             .value(DATAMODEL_STEPS_COLUMN, model_steps_json)
             .value(DATABASE_MIGRATION_COLUMN, database_migration_json)
             .value(ERRORS_COLUMN, errors_json)
-            .value(STARTED_AT_COLUMN, self.convert_datetime(migration.started_at))
+            .value(
+                STARTED_AT_COLUMN,
+                self.convert_datetime(migration.started_at),
+            )
             .value(FINISHED_AT_COLUMN, ParameterizedValue::Null);
 
         match self.sql_family() {
@@ -122,7 +125,7 @@ impl MigrationPersistence for SqlMigrationPersistence<'_> {
                 cloned.revision = usize::try_from(id).unwrap();
             }
             SqlFamily::Postgres => {
-                let returning_insert = Insert::from(insert).returning(vec!["revision"]);
+                let returning_insert = Insert::from(insert).returning(&["revision"]);
                 let result_set = self.conn().query(returning_insert.into()).await.unwrap();
 
                 result_set.into_iter().next().map(|row| {
@@ -236,19 +239,20 @@ fn parse_rows_new(result_set: ResultSet) -> Vec<Migration> {
             let datamodel_string: String = row[DATAMODEL_COLUMN].to_string().unwrap();
             let datamodel_steps_json: String = row[DATAMODEL_STEPS_COLUMN].to_string().unwrap();
 
-            let database_migration_string: String = row[DATABASE_MIGRATION_COLUMN].to_string().unwrap();
+            let database_migration_string: String =
+                row[DATABASE_MIGRATION_COLUMN].to_string().unwrap();
             let errors_json: String = row[ERRORS_COLUMN].to_string().unwrap();
 
             let finished_at = match &row[FINISHED_AT_COLUMN] {
                 ParameterizedValue::Null => None,
                 x => Some(convert_parameterized_date_value(x)),
             };
 
-            let datamodel_steps =
-                serde_json::from_str(&datamodel_steps_json).expect("Error parsing the migration steps");
+            let datamodel_steps = serde_json::from_str(&datamodel_steps_json)
+                .expect("Error parsing the migration steps");
 
-            let database_migration_json =
-                serde_json::from_str(&database_migration_string).expect("Error parsing the database migration steps");
+            let database_migration_json = serde_json::from_str(&database_migration_string)
+                .expect("Error parsing the database migration steps");
             let errors: Vec<String> = serde_json::from_str(&errors_json).unwrap();
 
             Migration {

migration-engine/migration-engine-tests/tests/error_tests.rs

@@ -117,9 +117,10 @@ async fn unreachable_database_must_return_a_proper_error_on_mysql() {
 
 #[tokio::test]
 async fn unreachable_database_must_return_a_proper_error_on_postgres() {
-    let mut url: Url = postgres_10_url("unreachable_database_must_return_a_proper_error_on_postgres")
-        .parse()
-        .unwrap();
+    let mut url: Url =
+        postgres_10_url("unreachable_database_must_return_a_proper_error_on_postgres")
+            .parse()
+            .unwrap();
 
     url.set_port(Some(8787)).unwrap();
 
@@ -194,7 +195,9 @@ async fn database_access_denied_must_return_a_proper_error_in_rpc() {
     let url: Url = mysql_url(db_name).parse().unwrap();
     let conn = create_mysql_database(&url).await.unwrap();
 
-    conn.execute_raw("DROP USER IF EXISTS jeanyves", &[]).await.unwrap();
+    conn.execute_raw("DROP USER IF EXISTS jeanyves", &[])
+        .await
+        .unwrap();
     conn.execute_raw("CREATE USER jeanyves IDENTIFIED BY '1234'", &[])
         .await
         .unwrap();
@@ -288,7 +291,11 @@ async fn datamodel_parser_errors_must_return_a_known_error(api: &TestApi) {
         }
     "#;
 
-    let error = api.infer_apply(bad_dm).send_user_facing().await.unwrap_err();
+    let error = api
+        .infer_apply(bad_dm)
+        .send_user_facing()
+        .await
+        .unwrap_err();
 
     let expected_msg = "\u{1b}[1;91merror\u{1b}[0m: \u{1b}[1mType \"Post\" is neither a built-in type, nor refers to another model, custom type, or enum.\u{1b}[0m\n  \u{1b}[1;94m-->\u{1b}[0m  \u{1b}[4mschema.prisma:4\u{1b}[0m\n\u{1b}[1;94m   | \u{1b}[0m\n\u{1b}[1;94m 3 | \u{1b}[0m            id Float @id\n\u{1b}[1;94m 4 | \u{1b}[0m            post \u{1b}[1;91mPost[]\u{1b}[0m\n\u{1b}[1;94m   | \u{1b}[0m\n";
 
@@ -302,7 +309,9 @@ async fn datamodel_parser_errors_must_return_a_known_error(api: &TestApi) {
 }
 
 #[test_each_connector]
-async fn unique_constraint_errors_in_migrations_must_return_a_known_error(api: &TestApi) -> TestResult {
+async fn unique_constraint_errors_in_migrations_must_return_a_known_error(
+    api: &TestApi,
+) -> TestResult {
     use quaint::ast::*;
 
     let dm = r#"
@@ -314,7 +323,7 @@ async fn unique_constraint_errors_in_migrations_must_return_a_known_error(api: &
 
     api.infer_and_apply(dm).await;
 
-    let insert = Insert::multi_into(api.render_table_name("Fruit"), vec!["name"])
+    let insert = Insert::multi_into(api.render_table_name("Fruit"), &["name"])
         .values(("banana",))
         .values(("apple",))
         .values(("banana",));