Make sure we only use RETURNING on backends that support it

SQLite does not support RETURNING clauses. To my knowledge it is the
only backend that does not support it (though the syntax is different on
SQL Server).

Of course at the moment the only backend supported on master is PG,
which *does* support it. However, this was an extraction from the SQLite
branch that is able to live on its own. I've removed most uses of
`get_result` and `get_results` in tests, except for one explicit test
that returning clauses work (which is currently in a cfg attr which is
always true, but won't be once SQLite is merged).

There are still some places that it's being used which I need to track
down, but right now I've got those modules set to only run on PG anyway,
as they have other issues that require detangling from PG.

Author: sgrif

diesel/src/backend.rs

@@ -26,6 +26,8 @@ pub trait TypeMetadata {
     type TypeMetadata;
 }
 
+pub trait SupportsReturningClause {}
+
 pub struct Debug;
 
 impl Backend for Debug {
@@ -37,6 +39,8 @@ impl TypeMetadata for Debug {
     type TypeMetadata = ();
 }
 
+impl SupportsReturningClause for Debug {}
+
 pub struct Pg;
 
 #[derive(Debug, Clone, Copy, Default)]
@@ -53,3 +57,5 @@ impl Backend for Pg {
 impl TypeMetadata for Pg {
     type TypeMetadata = PgTypeMetadata;
 }
+
+impl SupportsReturningClause for Pg {}

diesel/src/query_builder/insert_statement.rs

@@ -1,4 +1,4 @@
-use backend::Backend;
+use backend::{Backend, SupportsReturningClause};
 use persistable::{Insertable, InsertableColumns};
 use expression::Expression;
 use query_builder::*;
@@ -83,7 +83,7 @@ impl<T, U> Query for InsertQuery<T, U> where
 }
 
 impl<T, U, DB> QueryFragment<DB> for InsertQuery<T, U> where
-    DB: Backend,
+    DB: Backend + SupportsReturningClause,
     T: QueryFragment<DB>,
     U: QueryFragment<DB>,
 {

diesel/src/query_builder/update_statement/mod.rs

@@ -4,7 +4,7 @@ pub mod target;
 pub use self::changeset::{Changeset, AsChangeset};
 pub use self::target::UpdateTarget;
 
-use backend::Backend;
+use backend::{Backend, SupportsReturningClause};
 use expression::Expression;
 use query_builder::{Query, AsQuery, QueryFragment, QueryBuilder, BuildQueryResult, Context};
 use query_source::Table;
@@ -75,7 +75,7 @@ impl<T, U> AsQuery for UpdateStatement<T, U> where
 pub struct UpdateQuery<T, U>(UpdateStatement<T, U>);
 
 impl<T, U, DB> QueryFragment<DB> for UpdateQuery<T, U> where
-    DB: Backend,
+    DB: Backend + SupportsReturningClause,
     T: UpdateTarget,
     <T::Table as Table>::AllColumns: QueryFragment<DB>,
     UpdateStatement<T, U>: QueryFragment<DB>,

diesel_codegen/src/update.rs

@@ -141,6 +141,7 @@ fn save_changes_impl(
                 $_pub fn save_changes<'update, T, Conn>(&'update self, connection: &Conn)
                     -> ::diesel::QueryResult<T> where
                     Conn::Backend: ::diesel::types::HasSqlType<$sql_type> +
+                        ::diesel::backend::SupportsReturningClause +
                         ::diesel::types::HasSqlType<
                             <<$table as ::diesel::query_source::Table>::PrimaryKey
                             as ::diesel::expression::Expression>::SqlType>,

diesel_tests/tests/filter.rs

@@ -41,8 +41,8 @@ fn filter_by_equality_on_nullable_columns() {
         NewUser::new("Tess", Some("brown")),
         NewUser::new("Jim", Some("black")),
     ];
-    let data: Vec<User> = insert(&data).into(users)
-        .get_results(&connection).unwrap().collect();;
+    insert(&data).into(users).execute(&connection).unwrap();
+    let data = users.load(&connection).unwrap().collect::<Vec<User>>();
     let sean = data[0].clone();
     let tess = data[1].clone();
     let jim = data[2].clone();
@@ -62,8 +62,8 @@ fn filter_by_is_not_null_on_nullable_columns() {
         NewUser::new("Derek", Some("red")),
         NewUser::new("Gordon", None),
     ];
-    let data: Vec<User> = insert(&data).into(users)
-        .get_results(&connection).unwrap().collect();
+    insert(&data).into(users).execute(&connection).unwrap();
+    let data = users.load(&connection).unwrap().collect::<Vec<User>>();
     let derek = data[0].clone();
 
     let source = users.filter(hair_color.is_not_null());
@@ -79,8 +79,8 @@ fn filter_by_is_null_on_nullable_columns() {
         NewUser::new("Derek", Some("red")),
         NewUser::new("Gordon", None),
     ];
-    let data: Vec<User> = insert(&data).into(users)
-        .get_results(&connection).unwrap().collect();
+    insert(&data).into(users).execute(&connection).unwrap();
+    let data = users.load(&connection).unwrap().collect::<Vec<User>>();
     let gordon = data[1].clone();
 
     let source = users.filter(hair_color.is_null());
@@ -151,8 +151,8 @@ fn filter_on_multiple_columns() {
         NewUser::new("Tess", Some("black")),
         NewUser::new("Tess", Some("brown")),
     ];
-    let data: Vec<User> = insert(data).into(users)
-        .get_results(&connection).unwrap().collect();
+    insert(data).into(users).execute(&connection).unwrap();
+    let data = users.load(&connection).unwrap().collect::<Vec<User>>();
     let black_haired_sean = data[0].clone();
     let brown_haired_sean = data[1].clone();
     let black_haired_tess = data[3].clone();
@@ -187,8 +187,8 @@ fn filter_called_twice_means_same_thing_as_and() {
         NewUser::new("Tess", Some("black")),
         NewUser::new("Tess", Some("brown")),
     ];
-    let data: Vec<User> = insert(data).into(users)
-        .get_results(&connection).unwrap().collect();
+    insert(data).into(users).execute(&connection).unwrap();
+    let data = users.load(&connection).unwrap().collect::<Vec<User>>();
     let black_haired_sean = data[0].clone();
     let brown_haired_sean = data[1].clone();
     let black_haired_tess = data[3].clone();

diesel_tests/tests/filter_operators.rs

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

diesel_tests/tests/insert.rs

@@ -5,20 +5,37 @@ use diesel::*;
 fn insert_records() {
     use schema::users::table as users;
     let connection = connection();
+    let new_users: &[_] = &[
+        NewUser::new("Sean", Some("Black")),
+        NewUser::new("Tess", None),
+    ];
+
+    insert(new_users).into(users).execute(&connection).unwrap();
+    let actual_users = users.load(&connection).unwrap().collect::<Vec<User>>();
 
+    let expected_users = vec![
+        User { id: actual_users[0].id, name: "Sean".to_string(), hair_color: Some("Black".to_string()) },
+        User { id: actual_users[1].id, name: "Tess".to_string(), hair_color: None },
+    ];
+    assert_eq!(expected_users, actual_users);
+}
+
+#[test]
+#[cfg(not(feature = "sqlite"))]
+fn insert_records_using_returning_clause() {
+    use schema::users::table as users;
+    let connection = connection();
     let new_users: &[_] = &[
         NewUser::new("Sean", Some("Black")),
         NewUser::new("Tess", None),
     ];
-    let inserted_users: Vec<User> = insert(new_users).into(users).get_results(&connection).unwrap().collect();
 
+    let inserted_users: Vec<User> = insert(new_users).into(users).get_results(&connection).unwrap().collect();
     let expected_users = vec![
         User { id: inserted_users[0].id, name: "Sean".to_string(), hair_color: Some("Black".to_string()) },
         User { id: inserted_users[1].id, name: "Tess".to_string(), hair_color: None },
     ];
-    let actual_users: Vec<_> = users.load(&connection).unwrap().collect();
 
-    assert_eq!(expected_users, actual_users);
     assert_eq!(expected_users, inserted_users);
 }
 
@@ -36,7 +53,7 @@ fn insert_with_defaults() {
         NewUser::new("Sean", Some("Black")),
         NewUser::new("Tess", None),
     ];
-    let inserted_users: Vec<_> = insert(new_users).into(users).get_results(&connection).unwrap().collect();
+    insert(new_users).into(users).execute(&connection).unwrap();
 
     let expected_users = vec![
         User { id: 1, name: "Sean".to_string(), hair_color: Some("Black".to_string()) },
@@ -45,7 +62,6 @@ fn insert_with_defaults() {
     let actual_users: Vec<_> = users.load(&connection).unwrap().collect();
 
     assert_eq!(expected_users, actual_users);
-    assert_eq!(expected_users, inserted_users);
 }
 
 #[test]
@@ -62,7 +78,7 @@ fn insert_with_defaults_not_provided() {
         BaldUser { name: "Sean".to_string() },
         BaldUser { name: "Tess".to_string() },
     ];
-    let inserted_users: Vec<_> = insert(new_users).into(users).get_results(&connection).unwrap().collect();
+    insert(new_users).into(users).execute(&connection).unwrap();
 
     let expected_users = vec![
         User { id: 1, name: "Sean".to_string(), hair_color: Some("Green".to_string()) },
@@ -71,7 +87,6 @@ fn insert_with_defaults_not_provided() {
     let actual_users: Vec<_> = users.load(&connection).unwrap().collect();
 
     assert_eq!(expected_users, actual_users);
-    assert_eq!(expected_users, inserted_users);
 }
 
 #[test]
@@ -113,17 +128,15 @@ fn insert_borrowed_content() {
         BorrowedUser { name: "Sean" },
         BorrowedUser { name: "Tess" },
     ];
-    let inserted_users: Vec<User> = insert(new_users).into(users).get_results(&connection)
-        .unwrap().collect();
+    insert(new_users).into(users).execute(&connection).unwrap();
 
+    let actual_users: Vec<User> = users.load(&connection).unwrap().collect();
     let expected_users = vec![
-        User::new(inserted_users[0].id, "Sean"),
-        User::new(inserted_users[1].id, "Tess"),
+        User::new(actual_users[0].id, "Sean"),
+        User::new(actual_users[1].id, "Tess"),
     ];
-    let actual_users: Vec<_> = users.load(&connection).unwrap().collect();
 
     assert_eq!(expected_users, actual_users);
-    assert_eq!(expected_users, inserted_users);
 }
 
 #[test]

diesel_tests/tests/order.rs

@@ -11,8 +11,8 @@ fn order_by_column() {
         NewUser::new("Tess", None),
         NewUser::new("Jim", None),
     ];
-    let data: Vec<User> =
-        insert(&data).into(users).get_results(&conn).unwrap().collect();
+    insert(&data).into(users).execute(&conn).unwrap();
+    let data = users.load(&conn).unwrap().collect::<Vec<User>>();
     let sean = &data[0];
     let tess = &data[1];
     let jim = &data[2];
@@ -25,8 +25,9 @@ fn order_by_column() {
     let data: Vec<_> = users.order(name).load(&conn).unwrap().collect();
     assert_eq!(expected_data, data);
 
-    let aaron = insert(&NewUser::new("Aaron", None)).into(users)
-        .get_result::<User>(&conn).unwrap();
+    insert(&NewUser::new("Aaron", None)).into(users)
+        .execute(&conn).unwrap();
+    let aaron = users.order(id.desc()).first::<User>(&conn).unwrap();
     let expected_data = vec![
         User::new(aaron.id, "Aaron"),
         User::new(jim.id, "Jim"),
@@ -47,8 +48,8 @@ fn order_by_descending_column() {
         NewUser::new("Tess", None),
         NewUser::new("Jim", None),
     ];
-    let data: Vec<User> = insert(&data).into(users)
-        .get_results(&conn).unwrap().collect();
+    insert(&data).into(users).execute(&conn).unwrap();
+    let data = users.load(&conn).unwrap().collect::<Vec<User>>();
     let sean = &data[0];
     let tess = &data[1];
     let jim = &data[2];
@@ -61,8 +62,9 @@ fn order_by_descending_column() {
     let data: Vec<_> = users.order(name.desc()).load(&conn).unwrap().collect();
     assert_eq!(expected_data, data);
 
-    let aaron = insert(&NewUser::new("Aaron", None)).into(users)
-        .get_result::<User>(&conn).unwrap();
+    insert(&NewUser::new("Aaron", None)).into(users)
+        .execute(&conn).unwrap();
+    let aaron = users.order(id.desc()).first::<User>(&conn).unwrap();
     let expected_data = vec![
         User::new(tess.id, "Tess"),
         User::new(sean.id, "Sean"),

diesel_tests/tests/select.rs

@@ -137,11 +137,10 @@ fn selecting_columns_with_different_definition_order() {
     connection.execute("CREATE TABLE users (id SERIAL PRIMARY KEY, hair_color VARCHAR, name VARCHAR NOT NULL)")
         .unwrap();
     let expected_user = User::with_hair_color(1, "Sean", "black");
-    let user_from_insert = insert(&NewUser::new("Sean", Some("black"))).into(users::table)
-        .get_result(&connection);
+    insert(&NewUser::new("Sean", Some("black"))).into(users::table)
+        .execute(&connection).unwrap();
     let user_from_select = users::table.first(&connection);
 
-    assert_eq!(Ok(&expected_user), user_from_insert.as_ref());
     assert_eq!(Ok(&expected_user), user_from_select.as_ref());
 }