Add support for INSERT OR REPLACE on SQLite

First piece of diesel-rs#196. SQLite has extremely simple semantics here. `INSERT
OR REPLACE` will literally take what the new row would have been had the
insert succeeded, and will replace the existing row with it. For this to
be most useful, we'll probably want to make it easier to use non-literal
expressions in insert at some point in the future. We'll need to see
what other usage looks like.

This also lays the groundwork for supporting the other modifiers on
SQLite. I had originally planned on doing an API that looks more like
what PG will look like. However, since the semantics are so different,
we'll probably want to keep the APIs from stepping on each others toes.

Another alternative I had leaned towards was `insert.or(replace)`.
However, as I started thinking about the compile fail tests that'd be
required there, and saw the implementation, I shied away from it. Since
there's a fixed set of 4 modifiers that we will support, I think one
function each is fine.

Author: sgrif

diesel/src/lib.rs

@@ -85,6 +85,8 @@ pub mod prelude {
 pub use prelude::*;
 #[doc(inline)]
 pub use query_builder::functions::{insert, update, delete, select};
+#[cfg(feature = "sqlite")]
+pub use sqlite::query_builder::functions::*;
 pub use result::Error::NotFound;
 #[doc(inline)]
 pub use types::structs::data_types;

diesel/src/query_builder/functions.rs

@@ -1,6 +1,7 @@
 use expression::Expression;
 use super::{UpdateTarget, IncompleteUpdateStatement, IncompleteInsertStatement, SelectStatement};
 use super::delete_statement::DeleteStatement;
+use super::insert_statement::Insert;
 
 /// Creates an update statement. Helpers for updating a single row can be
 /// generated by
@@ -108,8 +109,8 @@ pub fn delete<T: UpdateTarget>(source: T) -> DeleteStatement<T> {
 /// Creates an insert statement. Will add the given data to a table. This
 /// function is not exported by default. As with other commands, the resulting
 /// query can return the inserted rows if you choose.
-pub fn insert<'a, T: ?Sized>(records: &'a T) -> IncompleteInsertStatement<&'a T> {
-    IncompleteInsertStatement::new(records)
+pub fn insert<'a, T: ?Sized>(records: &'a T) -> IncompleteInsertStatement<&'a T, Insert> {
+    IncompleteInsertStatement::new(records, Insert)
 }
 
 /// Creates a bare select statement, with no from clause. Primarily used for

diesel/src/query_builder/insert_statement.rs

@@ -7,43 +7,49 @@ use result::QueryResult;
 
 /// The structure returned by [`insert`](fn.insert.html). The only thing that can be done with it
 /// is call `into`.
-pub struct IncompleteInsertStatement<T> {
+pub struct IncompleteInsertStatement<T, Op> {
     records: T,
+    operator: Op
 }
 
-impl<T> IncompleteInsertStatement<T> {
+impl<T, Op> IncompleteInsertStatement<T, Op> {
     #[doc(hidden)]
-    pub fn new(records: T) -> Self {
+    pub fn new(records: T, operator: Op) -> Self {
         IncompleteInsertStatement {
             records: records,
+            operator: operator,
         }
     }
 
     /// Specify which table the data passed to `insert` should be added to.
-    pub fn into<S>(self, target: S) -> InsertStatement<S, T> where
-        InsertStatement<S, T>: AsQuery,
+    pub fn into<S>(self, target: S) -> InsertStatement<S, T, Op> where
+        InsertStatement<S, T, Op>: AsQuery,
     {
         InsertStatement {
+            operator: self.operator,
             target: target,
             records: self.records,
         }
     }
 }
 
-pub struct InsertStatement<T, U> {
+pub struct InsertStatement<T, U, Op> {
+    operator: Op,
     target: T,
     records: U,
 }
 
-impl<T, U, DB> QueryFragment<DB> for InsertStatement<T, U> where
+impl<T, U, Op, DB> QueryFragment<DB> for InsertStatement<T, U, Op> where
     DB: Backend,
     T: Table,
     T::FromClause: QueryFragment<DB>,
     U: Insertable<T, DB> + Copy,
+    Op: QueryFragment<DB>,
 {
     fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult {
         let values = self.records.values();
-        out.push_sql("INSERT INTO ");
+        try!(self.operator.to_sql(out));
+        out.push_sql(" INTO ");
         try!(self.target.from_clause().to_sql(out));
         out.push_sql(" (");
         try!(values.column_names(out));
@@ -54,6 +60,7 @@ impl<T, U, DB> QueryFragment<DB> for InsertStatement<T, U> where
 
     fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()> {
         let values = self.records.values();
+        try!(self.operator.collect_binds(out));
         try!(self.target.from_clause().collect_binds(out));
         try!(values.values_bind_params(out));
         Ok(())
@@ -64,14 +71,14 @@ impl<T, U, DB> QueryFragment<DB> for InsertStatement<T, U> where
     }
 }
 
-impl_query_id!(noop: InsertStatement<T, U>);
+impl_query_id!(noop: InsertStatement<T, U, Op>);
 
-impl<T, U> AsQuery for InsertStatement<T, U> where
+impl<T, U, Op> AsQuery for InsertStatement<T, U, Op> where
     T: Table,
-    InsertQuery<T::AllColumns, InsertStatement<T, U>>: Query,
+    InsertQuery<T::AllColumns, InsertStatement<T, U, Op>>: Query,
 {
     type SqlType = <Self::Query as Query>::SqlType;
-    type Query = InsertQuery<T::AllColumns, InsertStatement<T, U>>;
+    type Query = InsertQuery<T::AllColumns, Self>;
 
     fn as_query(self) -> Self::Query {
         InsertQuery {
@@ -81,7 +88,7 @@ impl<T, U> AsQuery for InsertStatement<T, U> where
     }
 }
 
-impl<T, U> InsertStatement<T, U> {
+impl<T, U, Op> InsertStatement<T, U, Op> {
     /// Specify what expression is returned after execution of the `insert`.
     /// # Examples
     ///
@@ -115,9 +122,9 @@ impl<T, U> InsertStatement<T, U> {
     /// # #[cfg(not(feature = "postgres"))]
     /// # fn main() {}
     /// ```
-    pub fn returning<E>(self, returns: E) -> InsertQuery<E, InsertStatement<T, U>> where
-        E: Expression,
-        InsertQuery<E, InsertStatement<T, U>>: Query,
+    pub fn returning<E>(self, returns: E) -> InsertQuery<E, Self> where
+        E: Expression + SelectableExpression<T>,
+        InsertQuery<E, Self>: Query,
     {
         InsertQuery {
             returning: returns,
@@ -132,9 +139,8 @@ pub struct InsertQuery<T, U> {
     statement: U,
 }
 
-impl<T, U, V> Query for InsertQuery<T, InsertStatement<U, V>> where
-    U: Table,
-    T: Expression + SelectableExpression<U> + NonAggregate,
+impl<T, U> Query for InsertQuery<T, U> where
+    T: Expression + NonAggregate,
 {
     type SqlType = T::SqlType;
 }
@@ -163,3 +169,22 @@ impl<T, U, DB> QueryFragment<DB> for InsertQuery<T, U> where
 }
 
 impl_query_id!(noop: InsertQuery<T, U>);
+
+pub struct Insert;
+
+impl<DB: Backend> QueryFragment<DB> for Insert {
+    fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult {
+        out.push_sql("INSERT");
+        Ok(())
+    }
+
+    fn collect_binds(&self, _out: &mut DB::BindCollector) -> QueryResult<()> {
+        Ok(())
+    }
+
+    fn is_safe_to_cache_prepared(&self) -> bool {
+        true
+    }
+}
+
+impl_query_id!(Insert);

diesel/src/sqlite/mod.rs

@@ -1,8 +1,9 @@
 mod backend;
 mod connection;
-mod query_builder;
 mod types;
 
+pub mod query_builder;
+
 pub use self::backend::{Sqlite, SqliteType};
 pub use self::connection::SqliteConnection;
 pub use self::query_builder::SqliteQueryBuilder;

diesel/src/sqlite/query_builder/functions.rs

@@ -0,0 +1,26 @@
+use expression::predicates::Or;
+use query_builder::insert_statement::{IncompleteInsertStatement, Insert};
+use super::nodes::Replace;
+
+// FIXME: Replace this example with an actual running doctest once we have a
+// more reasonable story for `impl Insertable` and friends without codegen
+/// Creates a SQLite `INSERT OR REPLACE` statement. If a constraint violation
+/// fails, SQLite will attempt to replace the offending row instead.
+///
+/// # Example
+///
+/// ```ignore
+/// insert(&NewUser::new("Sean")).into(users).execute(&conn).unwrap();
+/// insert(&NewUser::new("Tess")).into(users).execute(&conn).unwrap();
+///
+/// let new_user = User { id: 1, name: "Jim" };
+/// insert_or_replace(&new_user).into(users).execute(&conn).unwrap();
+///
+/// let names = users.select(name).order(id).load::<String>(&conn);
+/// assert_eq!(Ok(vec!["Jim".into(), "Tess".into()]), names);
+/// ```
+pub fn insert_or_replace<'a, T: ?Sized>(records: &'a T)
+    -> IncompleteInsertStatement<&'a T, Or<Insert, Replace>>
+{
+    IncompleteInsertStatement::new(records, Or::new(Insert, Replace))
+}

diesel/src/sqlite/query_builder.rs diesel/src/sqlite/query_builder/mod.rsdiesel/src/sqlite/query_builder.rs renamed to diesel/src/sqlite/query_builder/mod.rs

@@ -1,6 +1,10 @@
 use super::backend::Sqlite;
 use query_builder::{QueryBuilder, BuildQueryResult};
 
+pub mod functions;
+#[doc(hidden)]
+pub mod nodes;
+
 pub struct SqliteQueryBuilder {
     pub sql: String,
 }

diesel/src/sqlite/query_builder/nodes.rs

@@ -0,0 +1,23 @@
+use backend::Backend;
+use query_builder::{QueryFragment, QueryBuilder, BuildQueryResult};
+use result::QueryResult;
+use sqlite::Sqlite;
+
+pub struct Replace;
+
+impl QueryFragment<Sqlite> for Replace {
+    fn to_sql(&self, out: &mut <Sqlite as Backend>::QueryBuilder) -> BuildQueryResult {
+        out.push_sql("REPLACE");
+        Ok(())
+    }
+
+    fn collect_binds(&self, _out: &mut <Sqlite as Backend>::BindCollector) -> QueryResult<()> {
+        Ok(())
+    }
+
+    fn is_safe_to_cache_prepared(&self) -> bool {
+        true
+    }
+}
+
+impl_query_id!(Replace);

diesel_compile_tests/tests/compile-fail/batch_insert_is_not_supported_on_sqlite.rs

@@ -3,7 +3,7 @@ extern crate diesel;
 
 use diesel::*;
 use diesel::backend::Backend;
-use diesel::sqlite::*;
+use diesel::sqlite::{Sqlite, SqliteQueryBuilder, SqliteConnection};
 use diesel::types::{Integer, VarChar};
 
 table! {

diesel_compile_tests/tests/compile-fail/insert_statement_does_not_support_returning_methods_on_sqlite.rs

@@ -2,7 +2,7 @@
 extern crate diesel;
 
 use diesel::*;
-use diesel::sqlite::*;
+use diesel::sqlite::{Sqlite, SqliteQueryBuilder, SqliteConnection};
 use diesel::backend::Backend;
 use diesel::types::{Integer, VarChar};
 

diesel_compile_tests/tests/compile-fail/sqlite_upsert_cannot_be_used_on_pg.rs

@@ -0,0 +1,25 @@
+#![feature(custom_derive, custom_attribute, plugin)]
+#![plugin(diesel_codegen)]
+
+#[macro_use]
+extern crate diesel;
+
+use diesel::*;
+use diesel::pg::PgConnection;
+
+table! {
+    users {
+        id -> Integer,
+    }
+}
+
+#[insertable_into(users)]
+struct User {
+    id: i32,
+}
+
+fn main() {
+    let connection = PgConnection::establish("").unwrap();
+    insert_or_replace(&User { id: 1 }).into(users::table).execute(&connection).unwrap();
+    //~^ ERROR type mismatch resolving `<diesel::pg::PgConnection as diesel::Connection>::Backend == diesel::sqlite::Sqlite`
+}