Remove the batch_insert function from tests

We support batch insertion on all backends now.

Author: sgrif

diesel/src/query_builder/insert_statement.rs

@@ -34,7 +34,7 @@ impl<T, Op> IncompleteInsertStatement<T, Op> {
     }
 }
 
-pub trait IntoInsertStatement<Tab, Op=Insert, Ret=NoReturningClause> {
+pub trait IntoInsertStatement<Tab, Op, Ret> {
     type InsertStatement;
 
     fn into_insert_statement(self, target: Tab, operator: Op, returning: Ret)

diesel_tests/tests/associations.rs

@@ -142,11 +142,11 @@ fn conn_with_test_data() -> (TestConnection, User, User, User) {
     let tess = find_user_by_name("Tess", &connection);
     let jim = find_user_by_name("Jim", &connection);
     let new_posts = vec![sean.new_post("Hello", None), sean.new_post("World", None)];
-    batch_insert(&new_posts, posts::table, &connection);
+    insert(&new_posts).into(posts::table).execute(&connection).unwrap();
     let new_posts = vec![tess.new_post("Hello 2", None), tess.new_post("World 2", None)];
-    batch_insert(&new_posts, posts::table, &connection);
+    insert(&new_posts).into(posts::table).execute(&connection).unwrap();
     let new_posts = vec![jim.new_post("Hello 3", None), jim.new_post("World 3", None)];
-    batch_insert(&new_posts, posts::table, &connection);
+    insert(&new_posts).into(posts::table).execute(&connection).unwrap();
 
     (connection, sean, tess, jim)
 }

diesel_tests/tests/bench.rs

@@ -13,7 +13,7 @@ use self::schema::{
     users, posts, comments,
     NewUser, NewPost, NewComment,
     User, Post, Comment,
-    TestConnection, batch_insert,
+    TestConnection,
 };
 use diesel::*;
 
@@ -40,7 +40,7 @@ macro_rules! bench_trivial_query {
             let data: Vec<_> = (0..$n).map(|i| {
                 NewUser::new(&format!("User {}", i), None)
             }).collect();
-            batch_insert(&data, users::table, &conn);
+            insert(&data).into(users::table).execute(&conn).unwrap();
 
             b.iter(|| {
                 users::table.load::<User>(&conn).unwrap()
@@ -54,7 +54,7 @@ macro_rules! bench_trivial_query {
             let data: Vec<_> = (0..$n).map(|i| {
                 NewUser::new(&format!("User {}", i), None)
             }).collect();
-            batch_insert(&data, users::table, &conn);
+            insert(&data).into(users::table).execute(&conn).unwrap();
 
             b.iter(|| {
                 users::table.into_boxed().load::<User>(&conn).unwrap()
@@ -86,7 +86,7 @@ macro_rules! bench_medium_complex_query {
                 let hair_color = if i % 2 == 0 { "black" } else { "brown" };
                 NewUser::new(&format!("User {}", i), Some(hair_color))
             }).collect();
-            batch_insert(&data, users::table, &conn);
+            insert(&data).into(users::table).execute(&conn).unwrap();
 
             b.iter(|| {
                 use schema::users::dsl::*;
@@ -105,7 +105,7 @@ macro_rules! bench_medium_complex_query {
                 let hair_color = if i % 2 == 0 { "black" } else { "brown" };
                 NewUser::new(&format!("User {}", i), Some(hair_color))
             }).collect();
-            batch_insert(&data, users::table, &conn);
+            insert(&data).into(users::table).execute(&conn).unwrap();
 
             b.iter(|| {
                 use schema::users::dsl::*;
@@ -140,7 +140,7 @@ fn loading_associations_sequentially(b: &mut Bencher) {
         let hair_color = if i % 2 == 0 { "black" } else { "brown" };
         NewUser::new(&format!("User {}", i), Some(hair_color))
     }).collect();
-    batch_insert(&data, users::table, &conn);
+    insert(&data).into(users::table).execute(&conn).unwrap();
     let all_users = users::table.load::<User>(&conn).unwrap();
     let data: Vec<_> = all_users.iter().flat_map(|user| {
         let user_id = user.id;
@@ -149,7 +149,7 @@ fn loading_associations_sequentially(b: &mut Bencher) {
             NewPost::new(user_id, &title, None)
         })
     }).collect();
-    batch_insert(&data, posts::table, &conn);
+    insert(&data).into(posts::table).execute(&conn).unwrap();
     let all_posts = posts::table.load::<Post>(&conn).unwrap();
     let data: Vec<_> = all_posts.iter().flat_map(|post| {
         let post_id = post.id;
@@ -161,7 +161,7 @@ fn loading_associations_sequentially(b: &mut Bencher) {
     let comment_data: Vec<_> = data.iter().map(|&(ref title, post_id)| {
         NewComment(post_id, &title)
     }).collect();
-    batch_insert(&comment_data, comments::table, &conn);
+    insert(&comment_data).into(comments::table).execute(&conn).unwrap();
 
     // ACTUAL BENCHMARK
     b.iter(|| {

diesel_tests/tests/expressions/mod.rs

@@ -1,7 +1,7 @@
 mod date_and_time;
 mod ops;
 
-use schema::{connection, NewUser, batch_insert, connection_with_sean_and_tess_in_users_table};
+use schema::{connection, NewUser, connection_with_sean_and_tess_in_users_table};
 use schema::users::dsl::*;
 use diesel::*;
 use diesel::backend::Backend;
@@ -79,7 +79,7 @@ fn max_returns_same_type_as_expression_being_maximized() {
         NewUser::new("C", None),
         NewUser::new("A", None),
     ];
-    batch_insert(data, users, &connection);
+    insert(data).into(users).execute(&connection).unwrap();
     assert_eq!(Ok("C".to_string()), source.first(&connection));
     connection.execute("DELETE FROM users WHERE name = 'C'").unwrap();
     assert_eq!(Ok("B".to_string()), source.first(&connection));
@@ -161,7 +161,7 @@ fn function_with_multiple_arguments() {
 
     let connection = connection();
     let new_users = vec![NewUser::new("Sean", Some("black")), NewUser::new("Tess", None)];
-    batch_insert(&new_users, users, &connection);
+    insert(&new_users).into(users).execute(&connection).unwrap();
 
     let expected_data = vec!["black".to_string(), "Tess".to_string()];
     let data = users.select(coalesce(hair_color, name))

diesel_tests/tests/filter.rs

@@ -40,7 +40,7 @@ fn filter_by_equality_on_nullable_columns() {
         NewUser::new("Tess", Some("brown")),
         NewUser::new("Jim", Some("black")),
     ];
-    batch_insert(&data, users, &connection);
+    insert(&data).into(users).execute(&connection).unwrap();
 
     let data = users.load::<User>(&connection).unwrap();
     let sean = data[0].clone();
@@ -62,7 +62,7 @@ fn filter_by_is_not_null_on_nullable_columns() {
         NewUser::new("Derek", Some("red")),
         NewUser::new("Gordon", None),
     ];
-    batch_insert(&data, users, &connection);
+    insert(&data).into(users).execute(&connection).unwrap();
     let data = users.load::<User>(&connection).unwrap();
     let derek = data[0].clone();
 
@@ -79,7 +79,7 @@ fn filter_by_is_null_on_nullable_columns() {
         NewUser::new("Derek", Some("red")),
         NewUser::new("Gordon", None),
     ];
-    batch_insert(&data, users, &connection);
+    insert(&data).into(users).execute(&connection).unwrap();
     let data = users.load::<User>(&connection).unwrap();
     let gordon = data[1].clone();
 
@@ -129,7 +129,7 @@ fn filter_then_select() {
 
     let connection = connection();
     let data = vec![NewUser::new("Sean", None), NewUser::new("Tess", None)];
-    batch_insert(&data, users, &connection);
+    insert(&data).into(users).execute(&connection).unwrap();
 
     assert_eq!(Ok("Sean".to_string()),
         users.filter(name.eq("Sean")).select(name).first(&connection));
@@ -151,7 +151,7 @@ fn filter_on_multiple_columns() {
         NewUser::new("Tess", Some("black")),
         NewUser::new("Tess", Some("brown")),
     ];
-    batch_insert(data, users, &connection);
+    insert(data).into(users).execute(&connection).unwrap();
     let data = users.load::<User>(&connection).unwrap();
     let black_haired_sean = data[0].clone();
     let brown_haired_sean = data[1].clone();
@@ -183,7 +183,7 @@ fn filter_called_twice_means_same_thing_as_and() {
         NewUser::new("Tess", Some("black")),
         NewUser::new("Tess", Some("brown")),
     ];
-    batch_insert(data, users, &connection);
+    insert(data).into(users).execute(&connection).unwrap();
     let data = users.load::<User>(&connection).unwrap();
     let black_haired_sean = data[0].clone();
     let brown_haired_sean = data[1].clone();

diesel_tests/tests/filter_operators.rs

@@ -91,7 +91,7 @@ fn filter_by_like() {
         NewUser::new("Tess Griffin", None),
         NewUser::new("Jim", None),
     ];
-    batch_insert(&data, users, &connection);
+    insert(&data).into(users).execute(&connection).unwrap();
     let data = users.load::<User>(&connection).unwrap();
     let sean = data[0].clone();
     let tess = data[1].clone();

diesel_tests/tests/find.rs

@@ -45,7 +45,10 @@ fn find_with_composite_pk() {
     let third_following = Following { user_id: 2, post_id: 1, email_notifications: false };
 
     let connection = connection();
-    batch_insert(&[first_following, second_following, third_following], followings, &connection);
+    insert(&vec![first_following, second_following, third_following])
+        .into(followings)
+        .execute(&connection)
+        .unwrap();
 
     assert_eq!(Ok(first_following), followings.find((1, 1)).first(&connection));
     assert_eq!(Ok(second_following), followings.find((1, 2)).first(&connection));

diesel_tests/tests/insert.rs

@@ -10,7 +10,7 @@ fn insert_records() {
         NewUser::new("Tess", None),
     ];
 
-    batch_insert(new_users, users, &connection);
+    insert(new_users).into(users).execute(&connection).unwrap();
     let actual_users = users.load::<User>(&connection).unwrap();
 
     let expected_users = vec![
@@ -127,7 +127,7 @@ fn insert_returning_count_returns_number_of_rows_inserted() {
         BaldUser { name: "Sean".to_string() },
         BaldUser { name: "Tess".to_string() },
     ];
-    let count = batch_insert(new_users, users, &connection);
+    let count = insert(new_users).into(users).execute(&connection).unwrap();
     let second_count = insert(&BaldUser { name: "Guy".to_string() }).into(users).execute(&connection).unwrap();
 
     assert_eq!(2, count);
@@ -154,7 +154,7 @@ fn insert_borrowed_content() {
         BorrowedUser { name: "Sean" },
         BorrowedUser { name: "Tess" },
     ];
-    batch_insert(new_users, users, &connection);
+    insert(new_users).into(users).execute(&connection).unwrap();
 
     let actual_users = users.load::<User>(&connection).unwrap();
     let expected_users = vec![

diesel_tests/tests/joins.rs

@@ -220,15 +220,15 @@ fn join_through_other() {
     let connection = connection_with_sean_and_tess_in_users_table();
 
     insert(&NewUser::new("Jim", None)).into(users).execute(&connection).unwrap();
-    batch_insert(&vec![
+    insert(&vec![
         NewPost::new(1, "Hello", None), NewPost::new(2, "World", None),
         NewPost::new(1, "Hello again!", None),
-    ], posts::table, &connection);
+    ]).into(posts::table).execute(&connection).unwrap();
     let posts = posts::table.load::<Post>(&connection).unwrap();
-    batch_insert(&vec![
+    insert(&vec![
         NewComment(posts[0].id, "OMG"), NewComment(posts[1].id, "WTF"),
         NewComment(posts[2].id, "Best post ever!!!")
-    ], comments::table, &connection);
+    ]).into(comments::table).execute(&connection).unwrap();
     let comments = comments::table.load::<Comment>(&connection).unwrap();
 
     let data = users.inner_join(comments::table).load(&connection)

diesel_tests/tests/order.rs

@@ -11,7 +11,7 @@ fn order_by_column() {
         NewUser::new("Tess", None),
         NewUser::new("Jim", None),
     ];
-    batch_insert(&data, users, &conn);
+    insert(&data).into(users).execute(&conn).unwrap();
     let data = users.load::<User>(&conn).unwrap();
     let sean = &data[0];
     let tess = &data[1];
@@ -48,7 +48,7 @@ fn order_by_descending_column() {
         NewUser::new("Tess", None),
         NewUser::new("Jim", None),
     ];
-    batch_insert(&data, users, &conn);
+    insert(&data).into(users).execute(&conn).unwrap();
     let data = users.load::<User>(&conn).unwrap();
     let sean = &data[0];
     let tess = &data[1];