insert_many method

Author: kurtbuilds

Cargo.toml

@@ -19,3 +19,4 @@ ormlite-macro = { path = "macro", version = "0.22" }
 ormlite = { path = "ormlite", version = "0.22" }
 convert_case = "0.7.1"
 quote = "1.0"
+itertools = "0.14.0"

core/src/model.rs

@@ -75,9 +75,9 @@ where
         A: 'a + Send + sqlx::Acquire<'a, Database = DB>,
         Self: Send;
 
-    // fn insert_many<'e, E>(db: E, values: Vec<Self>) -> BoxFuture<'e, Result<Vec<Self>>>
-    // where
-    //     E: 'e + sqlx::Executor<'e, Database = DB>;
+    fn insert_many<'e, E>(values: Vec<Self>, db: E) -> BoxFuture<'e, Result<Vec<Self>>>
+    where
+        E: 'e + sqlx::Executor<'e, Database = DB>;
 
     /// `Model` objects can't track what fields are updated, so this method will update all fields.
     /// If you want to update only some fields, use `update_partial` instead.

macro/Cargo.toml

@@ -21,11 +21,11 @@ default-postgres = ["postgres"]
 default-mysql = ["mysql"]
 
 [dependencies]
-syn = { version = "2", features = ["derive", "parsing"] }
-quote = "1"
-proc-macro2 = "1"
+syn.workspace = true
+quote.workspace = true
+proc-macro2.workspace = true
 ormlite-core.workspace = true
 ormlite-attr.workspace = true
 sqlx.workspace = true
-itertools = "0.13.0"
+itertools.workspace = true
 convert_case.workspace = true

macro/src/codegen/common.rs

@@ -140,6 +140,7 @@ pub fn insertion_binding(c: &ColumnMeta) -> TokenStream {
 }
 
 pub trait OrmliteCodegen {
+    fn dialect_ts(&self) -> TokenStream;
     fn database_ts(&self) -> TokenStream;
     fn placeholder_ts(&self) -> TokenStream;
     // A placeholder that works at the phase when its invoked (e.g. during comp time, it can be used.

macro/src/codegen/from_row.rs

@@ -72,6 +72,7 @@ pub fn impl_FromRow(db: &dyn OrmliteCodegen, attr: &TableMeta, cache: &MetadataC
                 )*
         {
             fn from_row(row: &'a #row) -> ::std::result::Result<Self, ::ormlite::SqlxError> {
+                #[allow(unused_mut)]
                 let mut model = Self::from_row_using_aliases(row, &[
                     #(
                         #field_names,

macro/src/codegen/insert.rs

@@ -1,3 +1,4 @@
+use itertools::Itertools;
 use crate::codegen::common::{generate_conditional_bind, insertion_binding, OrmliteCodegen};
 use crate::MetadataCache;
 use ormlite_attr::ColumnMeta;
@@ -38,6 +39,7 @@ pub fn impl_Model__insert(db: &dyn OrmliteCodegen, attr: &ModelMeta, metadata_ca
     });
 
     quote! {
+        #[allow(unused_mut)]
         fn insert<'a, A>(mut self, conn: A) -> ::ormlite::__private::Insertion<'a, A, Self, #db>
             where
                 A: 'a + Send + ::ormlite::Acquire<'a, Database=#db>
@@ -132,11 +134,12 @@ pub fn impl_Insert(db: &dyn OrmliteCodegen, meta: &TableMeta, model: &Ident, ret
     let query_bindings = meta.database_columns().filter(|&c| !c.has_database_default).map(|c| {
         if let Some(rust_default) = &c.rust_default {
             let default: syn::Expr = syn::parse_str(&rust_default).expect("Failed to parse default_value");
-            return quote! {
+            quote! {
                 q = q.bind(#default);
-            };
+            }
+        } else {
+            insertion_binding(c)
         }
-        insertion_binding(c)
     });
 
     let insert_join = meta.many_to_one_joins().map(|c| insert_join(c));
@@ -152,6 +155,7 @@ pub fn impl_Insert(db: &dyn OrmliteCodegen, meta: &TableMeta, model: &Ident, ret
         impl ::ormlite::model::Insert<#db> for #model {
             type Model = #returns;
 
+            #[allow(unused_mut)]
             fn insert<'a, A>(self, db: A) -> #box_future<'a, ::ormlite::Result<Self::Model>>
             where
                 A: 'a + Send + ::ormlite::Acquire<'a, Database = #db>,
@@ -214,3 +218,54 @@ pub fn insert_join(c: &ColumnMeta) -> TokenStream {
         };
     }
 }
+
+pub fn impl_Model__insert_many(db: &dyn OrmliteCodegen, meta: &ModelMeta, _mc: &MetadataCache) -> TokenStream {
+    let box_future = crate::util::box_fut_ts();
+    let placeholder = db.placeholder_ts();
+    let dialect = db.dialect_ts();
+    let db = db.database_ts();
+
+    let query_bindings = meta.database_columns().map(|c| {
+        if let Some(rust_default) = &c.rust_default {
+            let default: syn::Expr = syn::parse_str(&rust_default).expect("Failed to parse default_value");
+            quote! {
+                q = q.bind(#default);
+            }
+        } else if c.is_join() {
+            let name = &c.ident;
+            quote! {
+                q = q.bind(model.#name._id());
+            }
+        } else {
+            insertion_binding(c)
+        }
+    }).collect_vec();
+
+    quote! {
+        fn insert_many<'e, E>(values: Vec<Self>, db: E) -> #box_future<'e, ::ormlite::Result<Vec<Self>>>
+        where
+            E: 'e + ::ormlite::Executor<'e, Database = #db>,
+        {
+            Box::pin(async move {
+                let table = <Self as ::ormlite::TableMeta>::table_name();
+                let columns = <Self as ::ormlite::TableMeta>::table_columns();
+                let mut sql_values = ::ormlite::__private::Values::Values(Vec::new());
+                for _ in 0..values.len() {
+                    let mut value = ::ormlite::__private::Value::new();
+                    value = value.placeholders(columns.len(), #dialect);
+                    sql_values = sql_values.value(value);
+                }
+                let sql = ::ormlite::__private::Insert::new(table)
+                    .columns(columns)
+                    .values(sql_values)
+                    .returning(columns);
+                let sql = ::ormlite::__private::ToSql::to_sql(&sql, #dialect);
+                let mut q = ::ormlite::query_as::<#db, Self>(&sql);
+                for model in values {
+                    #(#query_bindings)*
+                }
+                q.fetch_all(db).await.map_err(Into::into)
+            })
+        }
+    }
+}

macro/src/codegen/model.rs

@@ -1,5 +1,5 @@
 use crate::codegen::common::OrmliteCodegen;
-use crate::codegen::insert::impl_Model__insert;
+use crate::codegen::insert::{impl_Model__insert, impl_Model__insert_many};
 use crate::codegen::select::impl_Model__select;
 use crate::codegen::update::impl_Model__update_all_fields;
 use crate::MetadataCache;
@@ -12,6 +12,7 @@ pub fn impl_Model(db: &dyn OrmliteCodegen, attr: &ModelMeta, metadata_cache: &Me
     let partial_model = attr.builder_struct();
 
     let impl_Model__insert = impl_Model__insert(db, &attr, metadata_cache);
+    let impl_Model__insert_many = impl_Model__insert_many(db, &attr, metadata_cache);
     let impl_Model__update_all_fields = impl_Model__update_all_fields(db, attr);
     let impl_Model__delete = impl_Model__delete(db, attr);
     let impl_Model__fetch_one = impl_Model__fetch_one(db, attr);
@@ -24,6 +25,7 @@ pub fn impl_Model(db: &dyn OrmliteCodegen, attr: &ModelMeta, metadata_cache: &Me
             type ModelBuilder<'a> = #partial_model<'a> where Self: 'a;
 
             #impl_Model__insert
+            #impl_Model__insert_many
             #impl_Model__update_all_fields
             #impl_Model__delete
             #impl_Model__fetch_one

macro/src/codegen/mysql.rs

@@ -7,6 +7,9 @@ use quote::quote;
 pub struct MysqlBackend {}
 
 impl OrmliteCodegen for MysqlBackend {
+    fn dialect_ts(&self) -> TokenStream {
+        quote! { ::ormlite::__private::Dialect::Mysql }
+    }
     fn database_ts(&self) -> TokenStream {
         quote! { ::ormlite::mysql::Mysql }
     }

macro/src/codegen/postgres.rs

@@ -7,6 +7,9 @@ use quote::quote;
 pub struct PostgresBackend;
 
 impl OrmliteCodegen for PostgresBackend {
+    fn dialect_ts(&self) -> TokenStream {
+        quote! { ::ormlite::__private::Dialect::Postgres }
+    }
     fn database_ts(&self) -> TokenStream {
         quote! { ::ormlite::postgres::Postgres }
     }

macro/src/codegen/sqlite.rs

@@ -7,6 +7,9 @@ use quote::quote;
 pub struct SqliteBackend {}
 
 impl OrmliteCodegen for SqliteBackend {
+    fn dialect_ts(&self) -> TokenStream {
+        quote! { ::ormlite::__private::Dialect::Sqlite }
+    }
     fn database_ts(&self) -> TokenStream {
         quote! { ::ormlite::sqlite::Sqlite }
     }