Don't panic when reseting a SQLite statement fails

As per SQLite's docs, resetting a prepared statement isn't actually an
operation that can fail, but it will return the appropriate error code
if the last call to `sqlite3_step` was an error. The statement object
isn't inherently corrupted, so we can continue to reuse it.

Author: sgrif

diesel/src/sqlite/connection/stmt.rs

@@ -128,9 +128,9 @@ impl Statement {
         }
     }
 
-    fn reset(&mut self) -> QueryResult<()> {
+    fn reset(&mut self) {
         self.bind_index = 0;
-        ensure_sqlite_ok(unsafe { ffi::sqlite3_reset(self.inner_statement) }, &self.raw_connection)
+        unsafe { ffi::sqlite3_reset(self.inner_statement) };
     }
 }
 
@@ -189,15 +189,6 @@ impl Deref for StatementUse {
 
 impl Drop for StatementUse {
     fn drop(&mut self) {
-        use std::thread::panicking;
-
-        let reset_result = self.statement.borrow_mut().reset();
-        if let Err(e) = reset_result {
-            if panicking() {
-                write!(stderr(), "Error resetting SQLite prepared statement: {:?}", e).unwrap();
-            } else {
-                panic!("Error resetting SQLite prepared statement: {:?}", e);
-            }
-        }
+        self.statement.borrow_mut().reset();
     }
 }

diesel_tests/Cargo.toml

@@ -13,14 +13,13 @@ diesel = { path = "../diesel", default-features = false }
 dotenv = { git = "https://github.com/slapresta/rust-dotenv.git" }
 
 [dependencies]
+assert_matches = "1.0.1"
+chrono = { version = "^0.2.17" }
 diesel = { path = "../diesel", default-features = false, features = ["quickcheck", "chrono", "uuid"] }
 diesel_codegen = { path = "../diesel_codegen", default-features = false }
 dotenv_macros = { git = "https://github.com/slapresta/rust-dotenv.git", optional = true }
-chrono = { version = "^0.2.17" }
-uuid = { version = "^0.2.0" }
-
-[dev-dependencies]
 quickcheck = "0.2.25"
+uuid = { version = "^0.2.0" }
 
 [features]
 default = ["with-syntex"]

diesel_tests/tests/errors.rs

@@ -0,0 +1,30 @@
+use diesel;
+use diesel::prelude::*;
+use diesel::result::Error::DatabaseError;
+use schema::*;
+
+macro_rules! try_no_coerce {
+    ($e:expr) => ({
+        match $e {
+            Ok(e) => e,
+            Err(e) => return Err(e),
+        }
+    })
+}
+
+#[test]
+fn cached_prepared_statements_can_be_reused_after_error() {
+    let connection = connection_without_transaction();
+    let user = User::new(1, "Sean");
+    let query = diesel::insert(&user).into(users::table);
+
+    connection.test_transaction(|| {
+        try_no_coerce!(query.execute(&connection));
+
+        let failure = query.execute(&connection);
+        assert_matches!(failure, Err(DatabaseError(_)));
+        Ok(())
+    });
+
+    connection.test_transaction(|| query.execute(&connection));
+}

diesel_tests/tests/lib.rs

@@ -2,6 +2,7 @@
 #![cfg_attr(feature = "unstable", plugin(diesel_codegen, dotenv_macros))]
 
 extern crate quickcheck;
+#[macro_use] extern crate assert_matches;
 #[macro_use] extern crate diesel;
 
 #[cfg(feature = "unstable")]
@@ -14,6 +15,7 @@ mod associations;
 mod boxed_queries;
 mod connection;
 mod debug;
+mod errors;
 mod expressions;
 mod filter;
 mod filter_operators;