Add sanity check for insert that does not do an insertion

src/convenient.rs

@@ -9,10 +9,16 @@ impl<'conn> Statement<'conn> {
     /// # Failure
     /// Will return `Err` if no row is inserted or many rows are inserted.
     pub fn insert(&mut self, params: &[&ToSql]) -> Result<i64> {
+        // Some non-insertion queries could still return 1 change (an UPDATE, for example), so
+        // to guard against that we can check that the connection's last_insert_rowid() changes
+        // after we execute the statement.
+        let prev_rowid = self.conn.last_insert_rowid();
         let changes = try!(self.execute(params));
+        let new_rowid = self.conn.last_insert_rowid();
         match changes {
-            1 => Ok(self.conn.last_insert_rowid()),
-            _ => Err(Error::QueryInsertedRows(changes))
+            1 if prev_rowid != new_rowid => Ok(new_rowid),
+            1 if prev_rowid == new_rowid => Err(Error::StatementFailedToInsertRow),
+            _ => Err(Error::StatementChangedRows(changes))
         }
     }
 
@@ -45,16 +51,31 @@ mod test {
         assert_eq!(stmt.insert(&[&1i32]).unwrap(), 1);
         assert_eq!(stmt.insert(&[&2i32]).unwrap(), 2);
         match stmt.insert(&[&1i32]).unwrap_err() {
-            Error::QueryInsertedRows(0) => (),
+            Error::StatementChangedRows(0) => (),
             err => panic!("Unexpected error {}", err),
         }
         let mut multi = db.prepare("INSERT INTO foo (x) SELECT 3 UNION ALL SELECT 4").unwrap();
         match multi.insert(&[]).unwrap_err() {
-            Error::QueryInsertedRows(2) => (),
+            Error::StatementChangedRows(2) => (),
             err => panic!("Unexpected error {}", err),
         }
     }
 
+    #[test]
+    fn test_insert_failures() {
+        let db = Connection::open_in_memory().unwrap();
+        db.execute_batch("CREATE TABLE foo(x INTEGER UNIQUE)").unwrap();
+        let mut insert = db.prepare("INSERT INTO foo (x) VALUES (?)").unwrap();
+        let mut update = db.prepare("UPDATE foo SET x = ?").unwrap();
+
+        assert_eq!(insert.insert(&[&1i32]).unwrap(), 1);
+
+        match update.insert(&[&2i32]) {
+            Err(Error::StatementFailedToInsertRow) => (),
+            r => panic!("Unexpected result {:?}", r),
+        }
+    }
+
     #[test]
     fn test_exists() {
         let db = Connection::open_in_memory().unwrap();
@@ -69,4 +90,4 @@ mod test {
         assert!(stmt.exists(&[&2i32]).unwrap());
         assert!(!stmt.exists(&[&0i32]).unwrap());
     }
-}
+}

src/error.rs

@@ -57,7 +57,11 @@ pub enum Error {
     InvalidColumnType,
 
     /// Error when a query that was expected to insert one row did not insert any or insert many.
-    QueryInsertedRows(c_int),
+    StatementChangedRows(c_int),
+
+    /// Error when a query that was expected to insert a row did not change the connection's
+    /// last_insert_rowid().
+    StatementFailedToInsertRow,
 
     /// Error returned by `functions::Context::get` when the function argument cannot be converted
     /// to the requested type.
@@ -105,7 +109,8 @@ impl fmt::Display for Error {
             Error::InvalidColumnIndex(i) => write!(f, "Invalid column index: {}", i),
             Error::InvalidColumnName(ref name) => write!(f, "Invalid column name: {}", name),
             Error::InvalidColumnType => write!(f, "Invalid column type"),
-            Error::QueryInsertedRows(i) => write!(f, "Query inserted {} rows", i),
+            Error::StatementChangedRows(i) => write!(f, "Query changed {} rows", i),
+            Error::StatementFailedToInsertRow => write!(f, "Statement failed to insert new row"),
 
             #[cfg(feature = "functions")]
             Error::InvalidFunctionParameterType => write!(f, "Invalid function parameter type"),
@@ -136,7 +141,8 @@ impl error::Error for Error {
             Error::InvalidColumnIndex(_) => "invalid column index",
             Error::InvalidColumnName(_) => "invalid column name",
             Error::InvalidColumnType => "invalid column type",
-            Error::QueryInsertedRows(_) => "query inserted zero or more than one row",
+            Error::StatementChangedRows(_) => "query inserted zero or more than one row",
+            Error::StatementFailedToInsertRow => "statement failed to insert new row",
 
             #[cfg(feature = "functions")]
             Error::InvalidFunctionParameterType => "invalid function parameter type",
@@ -162,7 +168,8 @@ impl error::Error for Error {
             Error::InvalidColumnName(_) |
             Error::InvalidColumnType |
             Error::InvalidPath(_) => None,
-            Error::QueryInsertedRows(_) => None,
+            Error::StatementChangedRows(_) => None,
+            Error::StatementFailedToInsertRow => None,
 
             #[cfg(feature = "functions")]
             Error::InvalidFunctionParameterType => None,