From 1dc144c8c1ba68155ecb82967523057093e9bf83 Mon Sep 17 00:00:00 2001
From: gwenn <gtreguier@gmail.com>
Date: Sat, 1 Aug 2015 08:09:59 +0200
Subject: [PATCH 01/22] Add test_execute_select.

---
 src/lib.rs | 28 +++++++++++++++++++++-------
 1 file changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index f98780b..cd83fe2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -580,7 +580,7 @@ impl<'conn> SqliteStatement<'conn> {
 
     /// Get all the column names in the result set of the prepared statement.
     pub fn column_names(&self) -> Vec<&str> {
-        let n = unsafe { ffi::sqlite3_column_count(self.stmt) };
+        let n = self.column_count();
         let mut cols = Vec::with_capacity(n as usize);
         for i in 0..n {
             let slice = unsafe {
@@ -625,11 +625,13 @@ impl<'conn> SqliteStatement<'conn> {
 
             self.needs_reset = true;
             let r = ffi::sqlite3_step(self.stmt);
-            match r {
-                ffi::SQLITE_DONE => Ok(self.conn.changes()),
-                ffi::SQLITE_ROW => Err(SqliteError{ code: r,
-                    message: "Unexpected row result - did you mean to call query?".to_string() }),
-                _ => Err(self.conn.decode_result(r).unwrap_err()),
+            if r == ffi::SQLITE_ROW || self.column_count() != 0 {
+                Err(SqliteError{ code: r,
+                    message: "Unexpected row result - did you mean to call query?".to_string() })
+            } else if r == ffi::SQLITE_DONE {
+                Ok(self.conn.changes())
+            } else {
+                Err(self.conn.decode_result(r).unwrap_err())
             }
         }
     }
@@ -710,6 +712,10 @@ impl<'conn> SqliteStatement<'conn> {
         }
     }
 
+    fn column_count(&self) -> c_int {
+        unsafe { ffi::sqlite3_column_count(self.stmt) }
+    }
+
     fn finalize_(&mut self) -> SqliteResult<()> {
         let r = unsafe { ffi::sqlite3_finalize(self.stmt) };
         self.stmt = ptr::null_mut();
@@ -895,7 +901,7 @@ impl<'stmt> SqliteRow<'stmt> {
                 message: "Cannot get values from a row after advancing to next row".to_string() });
         }
         unsafe {
-            if idx < 0 || idx >= ffi::sqlite3_column_count(self.stmt.stmt) {
+            if idx < 0 || idx >= self.stmt.column_count() {
                 return Err(SqliteError{ code: ffi::SQLITE_MISUSE,
                     message: "Invalid column index".to_string() });
             }
@@ -993,6 +999,14 @@ mod test {
         assert_eq!(3i32, db.query_row("SELECT SUM(x) FROM foo", &[], |r| r.get(0)).unwrap());
     }
 
+    #[test]
+    fn test_execute_select() {
+        let db = checked_memory_handle();
+        let err = db.execute("SELECT 1 WHERE 1 < ?", &[&1i32]).unwrap_err();
+        assert!(err.code == ffi::SQLITE_DONE);
+        assert!(err.message == "Unexpected row result - did you mean to call query?");
+    }
+
     #[test]
     fn test_prepare_column_names() {
         let db = checked_memory_handle();

From c31c68d5e3acb41106680c54a0757ae06187f65b Mon Sep 17 00:00:00 2001
From: gwenn <gtreguier@gmail.com>
Date: Sat, 1 Aug 2015 09:11:31 +0200
Subject: [PATCH 02/22] Only check column count when DONE.

---
 src/lib.rs | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index cd83fe2..9ef89c3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -625,13 +625,18 @@ impl<'conn> SqliteStatement<'conn> {
 
             self.needs_reset = true;
             let r = ffi::sqlite3_step(self.stmt);
-            if r == ffi::SQLITE_ROW || self.column_count() != 0 {
-                Err(SqliteError{ code: r,
-                    message: "Unexpected row result - did you mean to call query?".to_string() })
-            } else if r == ffi::SQLITE_DONE {
-                Ok(self.conn.changes())
-            } else {
-                Err(self.conn.decode_result(r).unwrap_err())
+            match r {
+                ffi::SQLITE_DONE => {
+                    if self.column_count() != 0 {
+                        Err(SqliteError{ code: ffi::SQLITE_MISUSE,
+                            message: "Unexpected column count - did you mean to call query?".to_string() })
+                    } else {
+                        Ok(self.conn.changes())
+                    }
+                },
+                ffi::SQLITE_ROW => Err(SqliteError{ code: r,
+                    message: "Unexpected row result - did you mean to call query?".to_string() }),
+                _ => Err(self.conn.decode_result(r).unwrap_err()),
             }
         }
     }
@@ -1003,8 +1008,8 @@ mod test {
     fn test_execute_select() {
         let db = checked_memory_handle();
         let err = db.execute("SELECT 1 WHERE 1 < ?", &[&1i32]).unwrap_err();
-        assert!(err.code == ffi::SQLITE_DONE);
-        assert!(err.message == "Unexpected row result - did you mean to call query?");
+        assert!(err.code == ffi::SQLITE_MISUSE);
+        assert!(err.message == "Unexpected column count - did you mean to call query?");
     }
 
     #[test]

From f91db1b3503a8186d08f797ae0a3e32f2d9129a9 Mon Sep 17 00:00:00 2001
From: gwenn <gtreguier@gmail.com>
Date: Sat, 1 Aug 2015 10:08:28 +0200
Subject: [PATCH 03/22] Cache column_count (I am not sure it's worth it)

---
 src/lib.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 9ef89c3..0435cb3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -571,16 +571,18 @@ pub struct SqliteStatement<'conn> {
     conn: &'conn SqliteConnection,
     stmt: *mut ffi::sqlite3_stmt,
     needs_reset: bool,
+    column_count: c_int,
 }
 
 impl<'conn> SqliteStatement<'conn> {
     fn new(conn: &SqliteConnection, stmt: *mut ffi::sqlite3_stmt) -> SqliteStatement {
-        SqliteStatement{ conn: conn, stmt: stmt, needs_reset: false }
+        SqliteStatement{ conn: conn, stmt: stmt, needs_reset: false,
+            column_count: unsafe { ffi::sqlite3_column_count(stmt) }}
     }
 
     /// Get all the column names in the result set of the prepared statement.
     pub fn column_names(&self) -> Vec<&str> {
-        let n = self.column_count();
+        let n = self.column_count;
         let mut cols = Vec::with_capacity(n as usize);
         for i in 0..n {
             let slice = unsafe {
@@ -627,7 +629,7 @@ impl<'conn> SqliteStatement<'conn> {
             let r = ffi::sqlite3_step(self.stmt);
             match r {
                 ffi::SQLITE_DONE => {
-                    if self.column_count() != 0 {
+                    if self.column_count != 0 {
                         Err(SqliteError{ code: ffi::SQLITE_MISUSE,
                             message: "Unexpected column count - did you mean to call query?".to_string() })
                     } else {
@@ -717,10 +719,6 @@ impl<'conn> SqliteStatement<'conn> {
         }
     }
 
-    fn column_count(&self) -> c_int {
-        unsafe { ffi::sqlite3_column_count(self.stmt) }
-    }
-
     fn finalize_(&mut self) -> SqliteResult<()> {
         let r = unsafe { ffi::sqlite3_finalize(self.stmt) };
         self.stmt = ptr::null_mut();
@@ -906,7 +904,7 @@ impl<'stmt> SqliteRow<'stmt> {
                 message: "Cannot get values from a row after advancing to next row".to_string() });
         }
         unsafe {
-            if idx < 0 || idx >= self.stmt.column_count() {
+            if idx < 0 || idx >= self.stmt.column_count {
                 return Err(SqliteError{ code: ffi::SQLITE_MISUSE,
                     message: "Invalid column index".to_string() });
             }

From 4fa6d3c020734d442c26411564f66ffe03155cf4 Mon Sep 17 00:00:00 2001
From: gwenn <gtreguier@gmail.com>
Date: Sat, 1 Aug 2015 10:18:06 +0200
Subject: [PATCH 04/22] Reset as soon as possible.

---
 src/lib.rs | 18 ++++--------------
 1 file changed, 4 insertions(+), 14 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 0435cb3..ecab5f6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -613,20 +613,11 @@ impl<'conn> SqliteStatement<'conn> {
     /// }
     /// ```
     pub fn execute(&mut self, params: &[&ToSql]) -> SqliteResult<c_int> {
-        self.reset_if_needed();
-
         unsafe {
-            assert!(params.len() as c_int == ffi::sqlite3_bind_parameter_count(self.stmt),
-                    "incorrect number of parameters to execute(): expected {}, got {}",
-                    ffi::sqlite3_bind_parameter_count(self.stmt),
-                    params.len());
+            try!(self.bind_parameters(params));
 
-            for (i, p) in params.iter().enumerate() {
-                try!(self.conn.decode_result(p.bind_parameter(self.stmt, (i + 1) as c_int)));
-            }
-
-            self.needs_reset = true;
             let r = ffi::sqlite3_step(self.stmt);
+            ffi::sqlite3_reset(self.stmt);
             match r {
                 ffi::SQLITE_DONE => {
                     if self.column_count != 0 {
@@ -669,11 +660,12 @@ impl<'conn> SqliteStatement<'conn> {
             try!(self.bind_parameters(params));
         }
 
+        self.needs_reset = true;
         Ok(SqliteRows::new(self))
     }
 
     /// Executes the prepared statement and maps a function over the resulting
-    /// rows. 
+    /// rows.
     ///
     /// Unlike the iterator produced by `query`, the returned iterator does not expose the possibility
     /// for accessing stale rows.
@@ -707,8 +699,6 @@ impl<'conn> SqliteStatement<'conn> {
             try!(self.conn.decode_result(p.bind_parameter(self.stmt, (i + 1) as c_int)));
         }
 
-        self.needs_reset = true;
-
         Ok(())
     }
 

From 7b8051dc7ea087d3346ba71fcfc10a62310fe39a Mon Sep 17 00:00:00 2001
From: Gwenael Treguier <gwen@cas75-5-78-192-41-37.fbxo.proxad.net>
Date: Thu, 6 Aug 2015 21:15:30 +0200
Subject: [PATCH 05/22] Check Rust str length before binding.

---
 src/types.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/types.rs b/src/types.rs
index 1d30b30..f55a80e 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -102,8 +102,12 @@ raw_to_impl!(c_double, sqlite3_bind_double);
 
 impl<'a> ToSql for &'a str {
     unsafe fn bind_parameter(&self, stmt: *mut sqlite3_stmt, col: c_int) -> c_int {
+        let length = self.len();
+        if length > ::std::i32::MAX as usize {
+            return ffi::SQLITE_TOOBIG;
+        }
         match str_to_cstring(self) {
-            Ok(c_str) => ffi::sqlite3_bind_text(stmt, col, c_str.as_ptr(), -1,
+            Ok(c_str) => ffi::sqlite3_bind_text(stmt, col, c_str.as_ptr(), length as c_int,
                                                 ffi::SQLITE_TRANSIENT()),
             Err(_)    => ffi::SQLITE_MISUSE,
         }

From 9c63b9f37a24117c022129b0f37736938df5e563 Mon Sep 17 00:00:00 2001
From: Gwenael Treguier <gwen@cas75-5-78-192-41-37.fbxo.proxad.net>
Date: Thu, 6 Aug 2015 21:45:54 +0200
Subject: [PATCH 06/22] Check Rust blob length before binding.

---
 src/types.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/types.rs b/src/types.rs
index f55a80e..5ad4ed7 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -122,6 +122,9 @@ impl ToSql for String {
 
 impl<'a> ToSql for &'a [u8] {
     unsafe fn bind_parameter(&self, stmt: *mut sqlite3_stmt, col: c_int) -> c_int {
+        if self.len() > ::std::i32::MAX as usize {
+            return ffi::SQLITE_TOOBIG;
+        }
         ffi::sqlite3_bind_blob(
             stmt, col, mem::transmute(self.as_ptr()), self.len() as c_int, ffi::SQLITE_TRANSIENT())
     }

From 6bc1a8bb59fd22d07646495b0426703e755a9785 Mon Sep 17 00:00:00 2001
From: Gwenael Treguier <gwen@cas75-5-78-192-41-37.fbxo.proxad.net>
Date: Sat, 8 Aug 2015 09:30:50 +0200
Subject: [PATCH 07/22] Check when statement is too long.

---
 src/lib.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/lib.rs b/src/lib.rs
index f98780b..c49da64 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -542,6 +542,12 @@ impl InnerSqliteConnection {
     fn prepare<'a>(&mut self,
                    conn: &'a SqliteConnection,
                    sql: &str) -> SqliteResult<SqliteStatement<'a>> {
+        if sql.len() >= ::std::i32::MAX as usize {
+            return Err(SqliteError {
+                code: ffi::SQLITE_TOOBIG,
+                message: "statement too long".to_string()
+            });
+        }
         let mut c_stmt: *mut ffi::sqlite3_stmt = unsafe { mem::uninitialized() };
         let c_sql = try!(str_to_cstring(sql));
         let r = unsafe {

From e1532f5edfeec447de44465494df739f23e5e6a8 Mon Sep 17 00:00:00 2001
From: Patrick Fernie <patrick.fernie@gmail.com>
Date: Thu, 27 Aug 2015 10:44:24 -0400
Subject: [PATCH 08/22] Correct idx-checking behavior for
 SqliteRow::get_checked()

---
 src/lib.rs | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index f98780b..290c4a2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -866,9 +866,19 @@ impl<'stmt> SqliteRow<'stmt> {
     /// Returns a `SQLITE_MISMATCH`-coded `SqliteError` if the underlying SQLite column
     /// type is not a valid type as a source for `T`.
     ///
-    /// Panics if `idx` is outside the range of columns in the returned query or if this row
-    /// is stale.
+    /// Returns a `SQLITE_MISUSE`-coded `SqliteError` if `idx` is outside the valid column range
+    /// for this row or if this row is stale.
     pub fn get_checked<T: FromSql>(&self, idx: c_int) -> SqliteResult<T> {
+        if self.row_idx != self.current_row.get() {
+            return Err(SqliteError{ code: ffi::SQLITE_MISUSE,
+                message: "Cannot get values from a row after advancing to next row".to_string() });
+        }
+        unsafe {
+            if idx < 0 || idx >= ffi::sqlite3_column_count(self.stmt.stmt) {
+                return Err(SqliteError{ code: ffi::SQLITE_MISUSE,
+                    message: "Invalid column index".to_string() });
+            }
+        }
         let valid_column_type = unsafe {
             T::column_has_valid_sqlite_type(self.stmt.stmt, idx)
         };

From 29072e585b289426bd248fb6ddc523adad8dc833 Mon Sep 17 00:00:00 2001
From: Patrick Fernie <patrick.fernie@gmail.com>
Date: Thu, 27 Aug 2015 13:43:43 -0400
Subject: [PATCH 09/22] Implement SqliteStatement::query_and_then()

Allows for more ergonomic unification of error types
---
 src/lib.rs | 226 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 224 insertions(+), 2 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 290c4a2..229cc8e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -55,6 +55,7 @@ extern crate libsqlite3_sys as ffi;
 #[macro_use] extern crate bitflags;
 
 use std::default::Default;
+use std::convert;
 use std::mem;
 use std::ptr;
 use std::fmt;
@@ -90,7 +91,7 @@ unsafe fn errmsg_to_string(errmsg: *const c_char) -> String {
 }
 
 /// Encompasses an error result from a call to the SQLite C API.
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub struct SqliteError {
     /// The error code returned by a SQLite C API call. See [SQLite Result
     /// Codes](http://www.sqlite.org/rescode.html) for details.
@@ -664,7 +665,7 @@ impl<'conn> SqliteStatement<'conn> {
     }
 
     /// Executes the prepared statement and maps a function over the resulting
-    /// rows. 
+    /// rows.
     ///
     /// Unlike the iterator produced by `query`, the returned iterator does not expose the possibility
     /// for accessing stale rows.
@@ -680,6 +681,25 @@ impl<'conn> SqliteStatement<'conn> {
         })
     }
 
+    /// Executes the prepared statement and maps a function over the resulting
+    /// rows, where the function returns a `Result` with `Error` type implementing
+    /// `std::convert::From<SqliteError>` (so errors can be unified).
+    ///
+    /// Unlike the iterator produced by `query`, the returned iterator does not expose the possibility
+    /// for accessing stale rows.
+    pub fn query_and_then<'a, T, E, F>(&'a mut self, params: &[&ToSql], f: F)
+                                     -> SqliteResult<AndThenRows<'a, F>>
+                                     where T: 'static,
+                                           E: convert::From<SqliteError>,
+                                           F: FnMut(SqliteRow) -> Result<T, E> {
+        let row_iter = try!(self.query(params));
+
+        Ok(AndThenRows{
+            rows: row_iter,
+            map: f,
+        })
+    }
+
     /// Consumes the statement.
     ///
     /// Functionally equivalent to the `Drop` implementation, but allows callers to see any errors
@@ -746,6 +766,28 @@ impl<'stmt, T, F> Iterator for MappedRows<'stmt, F>
     }
 }
 
+/// An iterator over the mapped resulting rows of a query, with an Error type
+/// unifying with SqliteError.
+pub struct AndThenRows<'stmt, F> {
+    rows: SqliteRows<'stmt>,
+    map: F,
+}
+
+impl<'stmt, T, E, F> Iterator for AndThenRows<'stmt, F>
+                        where T: 'static,
+                              E: convert::From<SqliteError>,
+                              F: FnMut(SqliteRow) -> Result<T, E> {
+    type Item = Result<T, E>;
+
+    // Through the magic of FromIterator, if F returns a Result<T, E>,
+    // you can collect that to a Result<Vec<T>, E>
+    fn next(&mut self) -> Option<Self::Item> {
+        self.rows.next().map(|row_result| row_result
+                             .map_err(E::from)
+                             .and_then(|row| (self.map)(row)))
+    }
+}
+
 /// An iterator over the resulting rows of a query.
 ///
 /// ## Warning
@@ -920,6 +962,8 @@ mod test {
     extern crate tempdir;
     use super::*;
     use self::tempdir::TempDir;
+    use std::error::Error as StdError;
+    use std::fmt;
 
     // this function is never called, but is still type checked; in
     // particular, calls with specific instantiations will require
@@ -1081,6 +1125,184 @@ mod test {
         assert_eq!(results.unwrap().concat(), "hello, world!");
     }
 
+    #[test]
+    fn test_query_and_then() {
+        let db = checked_memory_handle();
+        let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER, y TEXT);
+                   INSERT INTO foo VALUES(4, \"hello\");
+                   INSERT INTO foo VALUES(3, \", \");
+                   INSERT INTO foo VALUES(2, \"world\");
+                   INSERT INTO foo VALUES(1, \"!\");
+                   END;";
+        db.execute_batch(sql).unwrap();
+
+        let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
+        let results: SqliteResult<Vec<String>> = query
+            .query_and_then(&[], |row| row.get_checked(1))
+            .unwrap()
+            .collect();
+
+        assert_eq!(results.unwrap().concat(), "hello, world!");
+    }
+
+    #[test]
+    fn test_query_and_then_fails() {
+        let db = checked_memory_handle();
+        let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER, y TEXT);
+                   INSERT INTO foo VALUES(4, \"hello\");
+                   INSERT INTO foo VALUES(3, \", \");
+                   INSERT INTO foo VALUES(2, \"world\");
+                   INSERT INTO foo VALUES(1, \"!\");
+                   END;";
+        db.execute_batch(sql).unwrap();
+
+        let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
+        let bad_type: SqliteResult<Vec<f64>> = query
+            .query_and_then(&[], |row| row.get_checked(1))
+            .unwrap()
+            .collect();
+
+        assert_eq!(bad_type, Err(SqliteError{
+            code: ffi::SQLITE_MISMATCH,
+            message: "Invalid column type".to_owned(),
+        }));
+
+        let bad_idx: SqliteResult<Vec<String>> = query
+            .query_and_then(&[], |row| row.get_checked(3))
+            .unwrap()
+            .collect();
+
+        assert_eq!(bad_idx, Err(SqliteError{
+            code: ffi::SQLITE_MISUSE,
+            message: "Invalid column index".to_owned(),
+        }));
+    }
+
+    #[test]
+    fn test_query_and_then_custom_error() {
+        #[derive(Debug)]
+        enum CustomError {
+            Sqlite(SqliteError),
+        };
+
+        impl fmt::Display for CustomError {
+            fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+                match *self {
+                    CustomError::Sqlite(ref se) => write!(f, "{}: {}", self.description(), se),
+                }
+            }
+        }
+
+        impl StdError for CustomError {
+            fn description(&self) -> &str { "my custom error" }
+            fn cause(&self) -> Option<&StdError> {
+                match *self {
+                    CustomError::Sqlite(ref se) => Some(se),
+                }
+            }
+        }
+
+        impl From<SqliteError> for CustomError {
+            fn from(se: SqliteError) -> CustomError {
+                CustomError::Sqlite(se)
+            }
+        }
+        type CustomResult<T> = Result<T, CustomError>;
+
+        let db = checked_memory_handle();
+        let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER, y TEXT);
+                   INSERT INTO foo VALUES(4, \"hello\");
+                   INSERT INTO foo VALUES(3, \", \");
+                   INSERT INTO foo VALUES(2, \"world\");
+                   INSERT INTO foo VALUES(1, \"!\");
+                   END;";
+        db.execute_batch(sql).unwrap();
+
+        let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
+        let results: CustomResult<Vec<String>> = query
+            .query_and_then(&[], |row| row.get_checked(1).map_err(CustomError::Sqlite))
+            .unwrap()
+            .collect();
+
+        assert_eq!(results.unwrap().concat(), "hello, world!");
+    }
+
+    #[test]
+    fn test_query_and_then_custom_error_fails() {
+        #[derive(Debug, PartialEq)]
+        enum CustomError {
+            SomeError,
+            Sqlite(SqliteError),
+        };
+
+        impl fmt::Display for CustomError {
+            fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+                match *self {
+                    CustomError::SomeError      => write!(f, "{}", self.description()),
+                    CustomError::Sqlite(ref se) => write!(f, "{}: {}", self.description(), se),
+                }
+            }
+        }
+
+        impl StdError for CustomError {
+            fn description(&self) -> &str { "my custom error" }
+            fn cause(&self) -> Option<&StdError> {
+                match *self {
+                    CustomError::SomeError      => None,
+                    CustomError::Sqlite(ref se) => Some(se),
+                }
+            }
+        }
+
+        impl From<SqliteError> for CustomError {
+            fn from(se: SqliteError) -> CustomError {
+                CustomError::Sqlite(se)
+            }
+        }
+        type CustomResult<T> = Result<T, CustomError>;
+
+        let db = checked_memory_handle();
+        let sql = "BEGIN;
+                   CREATE TABLE foo(x INTEGER, y TEXT);
+                   INSERT INTO foo VALUES(4, \"hello\");
+                   INSERT INTO foo VALUES(3, \", \");
+                   INSERT INTO foo VALUES(2, \"world\");
+                   INSERT INTO foo VALUES(1, \"!\");
+                   END;";
+        db.execute_batch(sql).unwrap();
+
+        let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
+        let bad_type: CustomResult<Vec<f64>> = query
+            .query_and_then(&[], |row| row.get_checked(1).map_err(CustomError::Sqlite))
+            .unwrap()
+            .collect();
+
+        assert_eq!(bad_type, Err(CustomError::Sqlite(SqliteError{
+            code: ffi::SQLITE_MISMATCH,
+            message: "Invalid column type".to_owned(),
+        })));
+
+        let bad_idx: CustomResult<Vec<String>> = query
+            .query_and_then(&[], |row| row.get_checked(3).map_err(CustomError::Sqlite))
+            .unwrap()
+            .collect();
+
+        assert_eq!(bad_idx, Err(CustomError::Sqlite(SqliteError{
+            code: ffi::SQLITE_MISUSE,
+            message: "Invalid column index".to_owned(),
+        })));
+
+        let non_sqlite_err: CustomResult<Vec<String>> = query
+            .query_and_then(&[], |_| Err(CustomError::SomeError))
+            .unwrap()
+            .collect();
+
+        assert_eq!(non_sqlite_err, Err(CustomError::SomeError));
+    }
+
     #[test]
     fn test_query_row() {
         let db = checked_memory_handle();

From e4eda2041e804f38922952cac1ee2e1e974e191b Mon Sep 17 00:00:00 2001
From: Patrick Fernie <patrick.fernie@gmail.com>
Date: Thu, 27 Aug 2015 14:01:01 -0400
Subject: [PATCH 10/22] Implement SqliteConnection::query_row_and_then()

---
 src/lib.rs | 33 +++++++++++++++++++++++++++++++--
 1 file changed, 31 insertions(+), 2 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 229cc8e..91f32db 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -302,6 +302,37 @@ impl SqliteConnection {
         }
     }
 
+    /// Convenience method to execute a query that is expected to return a single row,
+    /// and execute a mapping via `f` on that returned row with the possibility of failure.
+    /// The `Result` type of `f` must implement `std::convert::From<SqliteError>`.
+    ///
+    /// ## Example
+    ///
+    /// ```rust,no_run
+    /// # use rusqlite::{SqliteResult,SqliteConnection};
+    /// fn preferred_locale(conn: &SqliteConnection) -> SqliteResult<String> {
+    ///     conn.query_row_and_then("SELECT value FROM preferences WHERE name='locale'", &[], |row| {
+    ///         row.get_checked(0)
+    ///     })
+    /// }
+    /// ```
+    ///
+    /// If the query returns more than one row, all rows except the first are ignored.
+    pub fn query_row_and_then<T, E, F>(&self, sql: &str, params: &[&ToSql], f: F) -> Result<T, E>
+                           where F: FnOnce(SqliteRow) -> Result<T, E>,
+                                 E: convert::From<SqliteError> {
+        let mut stmt = try!(self.prepare(sql));
+        let mut rows = try!(stmt.query(params));
+
+        match rows.next() {
+            Some(row) => row.map_err(E::from).and_then(f),
+            None      => Err(E::from(SqliteError{
+                code: ffi::SQLITE_NOTICE,
+                message: "Query did not return a row".to_string(),
+            }))
+        }
+    }
+
     /// Convenience method to execute a query that is expected to return a single row.
     ///
     /// ## Example
@@ -779,8 +810,6 @@ impl<'stmt, T, E, F> Iterator for AndThenRows<'stmt, F>
                               F: FnMut(SqliteRow) -> Result<T, E> {
     type Item = Result<T, E>;
 
-    // Through the magic of FromIterator, if F returns a Result<T, E>,
-    // you can collect that to a Result<Vec<T>, E>
     fn next(&mut self) -> Option<Self::Item> {
         self.rows.next().map(|row_result| row_result
                              .map_err(E::from)

From b7efb37b3542522247a6a9da037889cd3d947cfc Mon Sep 17 00:00:00 2001
From: Huon Wilson <dbau.pp+github@gmail.com>
Date: Tue, 8 Sep 2015 18:06:41 +1000
Subject: [PATCH 11/22] Relax uses of `P: AsRef<...>` from `&P` to `P`.

This means that one can pass `AsRef` types directly, without having to
insert a `&`, e.g. `SqliteConnection::open("foo.db")` (new)
vs. `SqliteConnection::open(&"foo.db")` (old).

This should be backwards compatible, since there is an impl in the
standard library:

    impl<'a, T, U> AsRef<U> for &'a T where U: ?Sized, T: AsRef<U> + ?Sized

I.e. the old `&P` satisfies the new bound still. (Taking `P` directly is
what the standard library does with similar functions, like
`File::open`.)
---
 src/lib.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index f98780b..0814ecb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -160,7 +160,7 @@ impl SqliteConnection {
     ///
     /// `SqliteConnection::open(path)` is equivalent to `SqliteConnection::open_with_flags(path,
     /// SQLITE_OPEN_READ_WRITE | SQLITE_OPEN_CREATE)`.
-    pub fn open<P: AsRef<Path>>(path: &P) -> SqliteResult<SqliteConnection> {
+    pub fn open<P: AsRef<Path>>(path: P) -> SqliteResult<SqliteConnection> {
         let flags = Default::default();
         SqliteConnection::open_with_flags(path, flags)
     }
@@ -175,7 +175,7 @@ impl SqliteConnection {
     ///
     /// Database Connection](http://www.sqlite.org/c3ref/open.html) for a description of valid
     /// flag combinations.
-    pub fn open_with_flags<P: AsRef<Path>>(path: &P, flags: SqliteOpenFlags)
+    pub fn open_with_flags<P: AsRef<Path>>(path: P, flags: SqliteOpenFlags)
             -> SqliteResult<SqliteConnection> {
         let c_path = try!(path_to_cstring(path.as_ref()));
         InnerSqliteConnection::open_with_flags(&c_path, flags).map(|db| {
@@ -393,10 +393,10 @@ impl SqliteConnection {
     /// fn load_my_extension(conn: &SqliteConnection) -> SqliteResult<()> {
     ///     let _guard = try!(SqliteLoadExtensionGuard::new(conn));
     ///
-    ///     conn.load_extension(Path::new("my_sqlite_extension"), None)
+    ///     conn.load_extension("my_sqlite_extension", None)
     /// }
     #[cfg(feature = "load_extension")]
-    pub fn load_extension<P: AsRef<Path>>(&self, dylib_path: &P, entry_point: Option<&str>) -> SqliteResult<()> {
+    pub fn load_extension<P: AsRef<Path>>(&self, dylib_path: P, entry_point: Option<&str>) -> SqliteResult<()> {
         self.db.borrow_mut().load_extension(dylib_path, entry_point)
     }
 

From 05669082a343ad08166968336810cc72bf51941a Mon Sep 17 00:00:00 2001
From: gwenn <gtreguier@gmail.com>
Date: Sat, 1 Aug 2015 12:04:02 +0200
Subject: [PATCH 12/22] Debug db path and stmt sql.

---
 src/lib.rs | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 530cfc0..eb96b11 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -58,7 +58,7 @@ use std::default::Default;
 use std::mem;
 use std::ptr;
 use std::fmt;
-use std::path::{Path};
+use std::path::{Path,PathBuf};
 use std::error;
 use std::rc::{Rc};
 use std::cell::{RefCell, Cell};
@@ -151,6 +151,7 @@ fn path_to_cstring(p: &Path) -> SqliteResult<CString> {
 /// prepare multiple statements at the same time).
 pub struct SqliteConnection {
     db: RefCell<InnerSqliteConnection>,
+    path: Option<PathBuf>,
 }
 
 unsafe impl Send for SqliteConnection {}
@@ -179,7 +180,7 @@ impl SqliteConnection {
             -> SqliteResult<SqliteConnection> {
         let c_path = try!(path_to_cstring(path.as_ref()));
         InnerSqliteConnection::open_with_flags(&c_path, flags).map(|db| {
-            SqliteConnection{ db: RefCell::new(db) }
+            SqliteConnection{ db: RefCell::new(db), path: Some(path.as_ref().to_path_buf()) }
         })
     }
 
@@ -190,7 +191,7 @@ impl SqliteConnection {
     pub fn open_in_memory_with_flags(flags: SqliteOpenFlags) -> SqliteResult<SqliteConnection> {
         let c_memory = try!(str_to_cstring(":memory:"));
         InnerSqliteConnection::open_with_flags(&c_memory, flags).map(|db| {
-            SqliteConnection{ db: RefCell::new(db) }
+            SqliteConnection{ db: RefCell::new(db), path: None }
         })
     }
 
@@ -411,7 +412,7 @@ impl SqliteConnection {
 
 impl fmt::Debug for SqliteConnection {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "SqliteConnection()")
+        write!(f, "SqliteConnection( path: {:?} )", &self.path)
     }
 }
 
@@ -673,7 +674,7 @@ impl<'conn> SqliteStatement<'conn> {
     }
 
     /// Executes the prepared statement and maps a function over the resulting
-    /// rows. 
+    /// rows.
     ///
     /// Unlike the iterator produced by `query`, the returned iterator does not expose the possibility
     /// for accessing stale rows.
@@ -728,7 +729,11 @@ impl<'conn> SqliteStatement<'conn> {
 
 impl<'conn> fmt::Debug for SqliteStatement<'conn> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Statement( conn: {:?}, stmt: {:?} )", self.conn, self.stmt)
+        let sql = unsafe {
+            let c_slice = CStr::from_ptr(ffi::sqlite3_sql(self.stmt)).to_bytes();
+            str::from_utf8(c_slice)
+        };
+        write!(f, "SqliteStatement( conn: {:?}, stmt: {:?}, sql: {:?} )", self.conn, self.stmt, sql)
     }
 }
 

From d07c7ec8a6b9bb2935b0b464aef7137b582a782b Mon Sep 17 00:00:00 2001
From: John Gallagher <jgallagher@bignerdranch.com>
Date: Sun, 20 Sep 2015 20:44:51 -0400
Subject: [PATCH 13/22] Add basic unit test of statement debug including SQL

---
 src/lib.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/lib.rs b/src/lib.rs
index eb96b11..622fb09 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1161,4 +1161,13 @@ mod test {
         }
         assert_eq!(db.last_insert_rowid(), 10);
     }
+
+    #[test]
+    fn test_statement_debugging() {
+        let db = checked_memory_handle();
+        let query = "SELECT 12345";
+        let stmt = db.prepare(query).unwrap();
+
+        assert!(format!("{:?}", stmt).contains(query));
+    }
 }

From 072a336b33d42ec8726e820359e6d9342ada50bb Mon Sep 17 00:00:00 2001
From: John Gallagher <jgallagher@bignerdranch.com>
Date: Sun, 20 Sep 2015 21:28:50 -0400
Subject: [PATCH 14/22] Refactor: Reduce duplication across query_and_then
 tests.

---
 src/lib.rs | 342 +++++++++++++++++++++++++----------------------------
 1 file changed, 160 insertions(+), 182 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index cd381b2..c142a1c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1003,10 +1003,10 @@ impl<'stmt> SqliteRow<'stmt> {
 mod test {
     extern crate libsqlite3_sys as ffi;
     extern crate tempdir;
-    use super::*;
+    pub use super::*;
     use self::tempdir::TempDir;
-    use std::error::Error as StdError;
-    use std::fmt;
+    pub use std::error::Error as StdError;
+    pub use std::fmt;
 
     // this function is never called, but is still type checked; in
     // particular, calls with specific instantiations will require
@@ -1016,7 +1016,7 @@ mod test {
         ensure_send::<SqliteConnection>();
     }
 
-    fn checked_memory_handle() -> SqliteConnection {
+    pub fn checked_memory_handle() -> SqliteConnection {
         SqliteConnection::open_in_memory().unwrap()
     }
 
@@ -1176,184 +1176,6 @@ mod test {
         assert_eq!(results.unwrap().concat(), "hello, world!");
     }
 
-    #[test]
-    fn test_query_and_then() {
-        let db = checked_memory_handle();
-        let sql = "BEGIN;
-                   CREATE TABLE foo(x INTEGER, y TEXT);
-                   INSERT INTO foo VALUES(4, \"hello\");
-                   INSERT INTO foo VALUES(3, \", \");
-                   INSERT INTO foo VALUES(2, \"world\");
-                   INSERT INTO foo VALUES(1, \"!\");
-                   END;";
-        db.execute_batch(sql).unwrap();
-
-        let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
-        let results: SqliteResult<Vec<String>> = query
-            .query_and_then(&[], |row| row.get_checked(1))
-            .unwrap()
-            .collect();
-
-        assert_eq!(results.unwrap().concat(), "hello, world!");
-    }
-
-    #[test]
-    fn test_query_and_then_fails() {
-        let db = checked_memory_handle();
-        let sql = "BEGIN;
-                   CREATE TABLE foo(x INTEGER, y TEXT);
-                   INSERT INTO foo VALUES(4, \"hello\");
-                   INSERT INTO foo VALUES(3, \", \");
-                   INSERT INTO foo VALUES(2, \"world\");
-                   INSERT INTO foo VALUES(1, \"!\");
-                   END;";
-        db.execute_batch(sql).unwrap();
-
-        let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
-        let bad_type: SqliteResult<Vec<f64>> = query
-            .query_and_then(&[], |row| row.get_checked(1))
-            .unwrap()
-            .collect();
-
-        assert_eq!(bad_type, Err(SqliteError{
-            code: ffi::SQLITE_MISMATCH,
-            message: "Invalid column type".to_owned(),
-        }));
-
-        let bad_idx: SqliteResult<Vec<String>> = query
-            .query_and_then(&[], |row| row.get_checked(3))
-            .unwrap()
-            .collect();
-
-        assert_eq!(bad_idx, Err(SqliteError{
-            code: ffi::SQLITE_MISUSE,
-            message: "Invalid column index".to_owned(),
-        }));
-    }
-
-    #[test]
-    fn test_query_and_then_custom_error() {
-        #[derive(Debug)]
-        enum CustomError {
-            Sqlite(SqliteError),
-        };
-
-        impl fmt::Display for CustomError {
-            fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-                match *self {
-                    CustomError::Sqlite(ref se) => write!(f, "{}: {}", self.description(), se),
-                }
-            }
-        }
-
-        impl StdError for CustomError {
-            fn description(&self) -> &str { "my custom error" }
-            fn cause(&self) -> Option<&StdError> {
-                match *self {
-                    CustomError::Sqlite(ref se) => Some(se),
-                }
-            }
-        }
-
-        impl From<SqliteError> for CustomError {
-            fn from(se: SqliteError) -> CustomError {
-                CustomError::Sqlite(se)
-            }
-        }
-        type CustomResult<T> = Result<T, CustomError>;
-
-        let db = checked_memory_handle();
-        let sql = "BEGIN;
-                   CREATE TABLE foo(x INTEGER, y TEXT);
-                   INSERT INTO foo VALUES(4, \"hello\");
-                   INSERT INTO foo VALUES(3, \", \");
-                   INSERT INTO foo VALUES(2, \"world\");
-                   INSERT INTO foo VALUES(1, \"!\");
-                   END;";
-        db.execute_batch(sql).unwrap();
-
-        let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
-        let results: CustomResult<Vec<String>> = query
-            .query_and_then(&[], |row| row.get_checked(1).map_err(CustomError::Sqlite))
-            .unwrap()
-            .collect();
-
-        assert_eq!(results.unwrap().concat(), "hello, world!");
-    }
-
-    #[test]
-    fn test_query_and_then_custom_error_fails() {
-        #[derive(Debug, PartialEq)]
-        enum CustomError {
-            SomeError,
-            Sqlite(SqliteError),
-        };
-
-        impl fmt::Display for CustomError {
-            fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-                match *self {
-                    CustomError::SomeError      => write!(f, "{}", self.description()),
-                    CustomError::Sqlite(ref se) => write!(f, "{}: {}", self.description(), se),
-                }
-            }
-        }
-
-        impl StdError for CustomError {
-            fn description(&self) -> &str { "my custom error" }
-            fn cause(&self) -> Option<&StdError> {
-                match *self {
-                    CustomError::SomeError      => None,
-                    CustomError::Sqlite(ref se) => Some(se),
-                }
-            }
-        }
-
-        impl From<SqliteError> for CustomError {
-            fn from(se: SqliteError) -> CustomError {
-                CustomError::Sqlite(se)
-            }
-        }
-        type CustomResult<T> = Result<T, CustomError>;
-
-        let db = checked_memory_handle();
-        let sql = "BEGIN;
-                   CREATE TABLE foo(x INTEGER, y TEXT);
-                   INSERT INTO foo VALUES(4, \"hello\");
-                   INSERT INTO foo VALUES(3, \", \");
-                   INSERT INTO foo VALUES(2, \"world\");
-                   INSERT INTO foo VALUES(1, \"!\");
-                   END;";
-        db.execute_batch(sql).unwrap();
-
-        let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
-        let bad_type: CustomResult<Vec<f64>> = query
-            .query_and_then(&[], |row| row.get_checked(1).map_err(CustomError::Sqlite))
-            .unwrap()
-            .collect();
-
-        assert_eq!(bad_type, Err(CustomError::Sqlite(SqliteError{
-            code: ffi::SQLITE_MISMATCH,
-            message: "Invalid column type".to_owned(),
-        })));
-
-        let bad_idx: CustomResult<Vec<String>> = query
-            .query_and_then(&[], |row| row.get_checked(3).map_err(CustomError::Sqlite))
-            .unwrap()
-            .collect();
-
-        assert_eq!(bad_idx, Err(CustomError::Sqlite(SqliteError{
-            code: ffi::SQLITE_MISUSE,
-            message: "Invalid column index".to_owned(),
-        })));
-
-        let non_sqlite_err: CustomResult<Vec<String>> = query
-            .query_and_then(&[], |_| Err(CustomError::SomeError))
-            .unwrap()
-            .collect();
-
-        assert_eq!(non_sqlite_err, Err(CustomError::SomeError));
-    }
-
     #[test]
     fn test_query_row() {
         let db = checked_memory_handle();
@@ -1431,4 +1253,160 @@ mod test {
 
         assert!(format!("{:?}", stmt).contains(query));
     }
+
+    mod query_and_then_tests {
+        extern crate libsqlite3_sys as ffi;
+        use super::*;
+
+        #[derive(Debug, PartialEq)]
+        enum CustomError {
+            SomeError,
+            Sqlite(SqliteError),
+        }
+
+        impl fmt::Display for CustomError {
+            fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+                match *self {
+                    CustomError::SomeError      => write!(f, "{}", self.description()),
+                    CustomError::Sqlite(ref se) => write!(f, "{}: {}", self.description(), se),
+                }
+            }
+        }
+
+        impl StdError for CustomError {
+            fn description(&self) -> &str { "my custom error" }
+            fn cause(&self) -> Option<&StdError> {
+                match *self {
+                    CustomError::SomeError      => None,
+                    CustomError::Sqlite(ref se) => Some(se),
+                }
+            }
+        }
+
+        impl From<SqliteError> for CustomError {
+            fn from(se: SqliteError) -> CustomError {
+                CustomError::Sqlite(se)
+            }
+        }
+
+        type CustomResult<T> = Result<T, CustomError>;
+
+        #[test]
+        fn test_query_and_then() {
+            let db = checked_memory_handle();
+            let sql = "BEGIN;
+                       CREATE TABLE foo(x INTEGER, y TEXT);
+                       INSERT INTO foo VALUES(4, \"hello\");
+                       INSERT INTO foo VALUES(3, \", \");
+                       INSERT INTO foo VALUES(2, \"world\");
+                       INSERT INTO foo VALUES(1, \"!\");
+                       END;";
+            db.execute_batch(sql).unwrap();
+
+            let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
+            let results: SqliteResult<Vec<String>> = query
+                .query_and_then(&[], |row| row.get_checked(1))
+                .unwrap()
+                .collect();
+
+            assert_eq!(results.unwrap().concat(), "hello, world!");
+        }
+
+        #[test]
+        fn test_query_and_then_fails() {
+            let db = checked_memory_handle();
+            let sql = "BEGIN;
+                       CREATE TABLE foo(x INTEGER, y TEXT);
+                       INSERT INTO foo VALUES(4, \"hello\");
+                       INSERT INTO foo VALUES(3, \", \");
+                       INSERT INTO foo VALUES(2, \"world\");
+                       INSERT INTO foo VALUES(1, \"!\");
+                       END;";
+            db.execute_batch(sql).unwrap();
+
+            let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
+            let bad_type: SqliteResult<Vec<f64>> = query
+                .query_and_then(&[], |row| row.get_checked(1))
+                .unwrap()
+                .collect();
+
+            assert_eq!(bad_type, Err(SqliteError{
+                code: ffi::SQLITE_MISMATCH,
+                message: "Invalid column type".to_owned(),
+            }));
+
+            let bad_idx: SqliteResult<Vec<String>> = query
+                .query_and_then(&[], |row| row.get_checked(3))
+                .unwrap()
+                .collect();
+
+            assert_eq!(bad_idx, Err(SqliteError{
+                code: ffi::SQLITE_MISUSE,
+                message: "Invalid column index".to_owned(),
+            }));
+        }
+
+        #[test]
+        fn test_query_and_then_custom_error() {
+            let db = checked_memory_handle();
+            let sql = "BEGIN;
+                       CREATE TABLE foo(x INTEGER, y TEXT);
+                       INSERT INTO foo VALUES(4, \"hello\");
+                       INSERT INTO foo VALUES(3, \", \");
+                       INSERT INTO foo VALUES(2, \"world\");
+                       INSERT INTO foo VALUES(1, \"!\");
+                       END;";
+            db.execute_batch(sql).unwrap();
+
+            let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
+            let results: CustomResult<Vec<String>> = query
+                .query_and_then(&[], |row| row.get_checked(1).map_err(CustomError::Sqlite))
+                .unwrap()
+                .collect();
+
+            assert_eq!(results.unwrap().concat(), "hello, world!");
+        }
+
+        #[test]
+        fn test_query_and_then_custom_error_fails() {
+            let db = checked_memory_handle();
+            let sql = "BEGIN;
+                       CREATE TABLE foo(x INTEGER, y TEXT);
+                       INSERT INTO foo VALUES(4, \"hello\");
+                       INSERT INTO foo VALUES(3, \", \");
+                       INSERT INTO foo VALUES(2, \"world\");
+                       INSERT INTO foo VALUES(1, \"!\");
+                       END;";
+            db.execute_batch(sql).unwrap();
+
+            let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap();
+            let bad_type: CustomResult<Vec<f64>> = query
+                .query_and_then(&[], |row| row.get_checked(1).map_err(CustomError::Sqlite))
+                .unwrap()
+                .collect();
+
+            assert_eq!(bad_type, Err(CustomError::Sqlite(SqliteError{
+                code: ffi::SQLITE_MISMATCH,
+                message: "Invalid column type".to_owned(),
+            })));
+
+            let bad_idx: CustomResult<Vec<String>> = query
+                .query_and_then(&[], |row| row.get_checked(3).map_err(CustomError::Sqlite))
+                .unwrap()
+                .collect();
+
+            assert_eq!(bad_idx, Err(CustomError::Sqlite(SqliteError{
+                code: ffi::SQLITE_MISUSE,
+                message: "Invalid column index".to_owned(),
+            })));
+
+            let non_sqlite_err: CustomResult<Vec<String>> = query
+                .query_and_then(&[], |_| Err(CustomError::SomeError))
+                .unwrap()
+                .collect();
+
+            assert_eq!(non_sqlite_err, Err(CustomError::SomeError));
+        }
+
+    }
 }

From 1918dc14d0419b42bb4765d30a989b4af121f757 Mon Sep 17 00:00:00 2001
From: John Gallagher <jgallagher@bignerdranch.com>
Date: Sun, 20 Sep 2015 21:30:40 -0400
Subject: [PATCH 15/22] Add tests for query_row_and_then().

---
 src/lib.rs | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/src/lib.rs b/src/lib.rs
index c142a1c..83d364d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1408,5 +1408,53 @@ mod test {
             assert_eq!(non_sqlite_err, Err(CustomError::SomeError));
         }
 
+        #[test]
+        fn test_query_row_and_then_custom_error() {
+            let db = checked_memory_handle();
+            let sql = "BEGIN;
+                       CREATE TABLE foo(x INTEGER, y TEXT);
+                       INSERT INTO foo VALUES(4, \"hello\");
+                       END;";
+            db.execute_batch(sql).unwrap();
+
+            let query = "SELECT x, y FROM foo ORDER BY x DESC";
+            let results: CustomResult<String> = db
+                .query_row_and_then(query, &[], |row| row.get_checked(1).map_err(CustomError::Sqlite));
+
+            assert_eq!(results.unwrap(), "hello");
+        }
+
+        #[test]
+        fn test_query_row_and_then_custom_error_fails() {
+            let db = checked_memory_handle();
+            let sql = "BEGIN;
+                       CREATE TABLE foo(x INTEGER, y TEXT);
+                       INSERT INTO foo VALUES(4, \"hello\");
+                       END;";
+            db.execute_batch(sql).unwrap();
+
+            let query = "SELECT x, y FROM foo ORDER BY x DESC";
+            let bad_type: CustomResult<f64> = db
+                .query_row_and_then(query, &[], |row| row.get_checked(1).map_err(CustomError::Sqlite));
+
+            assert_eq!(bad_type, Err(CustomError::Sqlite(SqliteError{
+                code: ffi::SQLITE_MISMATCH,
+                message: "Invalid column type".to_owned(),
+            })));
+
+            let bad_idx: CustomResult<String> = db
+                .query_row_and_then(query, &[], |row| row.get_checked(3).map_err(CustomError::Sqlite));
+
+            assert_eq!(bad_idx, Err(CustomError::Sqlite(SqliteError{
+                code: ffi::SQLITE_MISUSE,
+                message: "Invalid column index".to_owned(),
+            })));
+
+            let non_sqlite_err: CustomResult<String> = db
+                .query_row_and_then(query, &[], |_| Err(CustomError::SomeError));
+
+            assert_eq!(non_sqlite_err, Err(CustomError::SomeError));
+        }
+
     }
 }

From 7ee69fe103f4a55f8f832fb47157e9992e692c9c Mon Sep 17 00:00:00 2001
From: John Gallagher <jgallagher@bignerdranch.com>
Date: Mon, 21 Sep 2015 10:31:11 -0400
Subject: [PATCH 16/22] Remove get_opt (superceded by get_checked).

---
 src/lib.rs | 45 +++++++++++----------------------------------
 1 file changed, 11 insertions(+), 34 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 83d364d..fb3a50c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -941,7 +941,7 @@ impl<'stmt> SqliteRow<'stmt> {
     /// Panics if `idx` is outside the range of columns in the returned query or if this row
     /// is stale.
     pub fn get<T: FromSql>(&self, idx: c_int) -> T {
-        self.get_opt(idx).unwrap()
+        self.get_checked(idx).unwrap()
     }
 
     /// Get the value of a particular column of the result row.
@@ -954,37 +954,6 @@ impl<'stmt> SqliteRow<'stmt> {
     /// Returns a `SQLITE_MISUSE`-coded `SqliteError` if `idx` is outside the valid column range
     /// for this row or if this row is stale.
     pub fn get_checked<T: FromSql>(&self, idx: c_int) -> SqliteResult<T> {
-        if self.row_idx != self.current_row.get() {
-            return Err(SqliteError{ code: ffi::SQLITE_MISUSE,
-                message: "Cannot get values from a row after advancing to next row".to_string() });
-        }
-        unsafe {
-            if idx < 0 || idx >= ffi::sqlite3_column_count(self.stmt.stmt) {
-                return Err(SqliteError{ code: ffi::SQLITE_MISUSE,
-                    message: "Invalid column index".to_string() });
-            }
-        }
-        let valid_column_type = unsafe {
-            T::column_has_valid_sqlite_type(self.stmt.stmt, idx)
-        };
-
-        if valid_column_type {
-            Ok(self.get(idx))
-        } else {
-            Err(SqliteError{
-                code: ffi::SQLITE_MISMATCH,
-                message: "Invalid column type".to_string(),
-            })
-        }
-    }
-
-    /// Attempt to get the value of a particular column of the result row.
-    ///
-    /// ## Failure
-    ///
-    /// Returns a `SQLITE_MISUSE`-coded `SqliteError` if `idx` is outside the valid column range
-    /// for this row or if this row is stale.
-    pub fn get_opt<T: FromSql>(&self, idx: c_int) -> SqliteResult<T> {
         if self.row_idx != self.current_row.get() {
             return Err(SqliteError{ code: ffi::SQLITE_MISUSE,
                 message: "Cannot get values from a row after advancing to next row".to_string() });
@@ -994,7 +963,15 @@ impl<'stmt> SqliteRow<'stmt> {
                 return Err(SqliteError{ code: ffi::SQLITE_MISUSE,
                     message: "Invalid column index".to_string() });
             }
-            FromSql::column_result(self.stmt.stmt, idx)
+
+            if T::column_has_valid_sqlite_type(self.stmt.stmt, idx) {
+                FromSql::column_result(self.stmt.stmt, idx)
+            } else {
+                Err(SqliteError{
+                    code: ffi::SQLITE_MISMATCH,
+                    message: "Invalid column type".to_string(),
+                })
+            }
         }
     }
 }
@@ -1226,7 +1203,7 @@ mod test {
 
         assert_eq!(2i32, second.get(0));
 
-        let result = first.get_opt::<i32>(0);
+        let result = first.get_checked::<i32>(0);
         assert!(result.unwrap_err().message.contains("advancing to next row"));
     }
 

From c3bc8b594a40f12eecde0b05e262f2c03380f28d Mon Sep 17 00:00:00 2001
From: John Gallagher <jgallagher@bignerdranch.com>
Date: Mon, 21 Sep 2015 10:39:13 -0400
Subject: [PATCH 17/22] Bump version to 0.3.0.

Updates Changelog and CONTRIBUTORS for changes in this version.
---
 CONTRIBUTORS.md |  2 ++
 Cargo.toml      |  2 +-
 Changelog.md    | 11 +++++++++++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 09b1187..e151714 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -5,3 +5,5 @@ rusqlite contributors (sorted alphabetically)
 * [Marcus Klaas de Vries](https://github.com/marcusklaas)
 * [gwenn](https://github.com/gwenn)
 * [Jimmy Lu](https://github.com/Yuhta)
+* [Huon Wilson](https://github.com/huonw)
+* [Patrick Fernie](https://github.com/pfernie)
diff --git a/Cargo.toml b/Cargo.toml
index 5d05ed5..0fbf0ee 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rusqlite"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["John Gallagher <jgallagher@bignerdranch.com>"]
 description = "Ergonomic wrapper for SQLite"
 repository = "https://github.com/jgallagher/rusqlite"
diff --git a/Changelog.md b/Changelog.md
index 4fc6eff..6ce64d3 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,3 +1,14 @@
+# Version 0.3.0 (2015-09-21)
+
+* Removes `get_opt`. Use `get_checked` instead.
+* Add `query_row_and_then` and `query_and_then` convenience functions. These are analogous to
+  `query_row` and `query_map` but allow functions that can fail by returning `Result`s.
+* Relax uses of `P: AsRef<...>` from `&P` to `P`.
+* Add additional error check for calling `execute` when `query` was intended.
+* Improve debug formatting of `SqliteStatement` and `SqliteConnection`.
+* Changes documentation of `get_checked` to correctly indicate that it returns errors (not panics)
+  when given invalid types or column indices.
+
 # Version 0.2.0 (2015-07-26)
 
 * Add `column_names()` to `SqliteStatement`.

From b41275cbc84bc19c9453cf723e05e3e18a70f144 Mon Sep 17 00:00:00 2001
From: John Gallagher <jgallagher@bignerdranch.com>
Date: Tue, 22 Sep 2015 10:18:26 -0700
Subject: [PATCH 18/22] Update Changelog and Cargo.toml to 0.3.1

---
 Cargo.toml   | 2 +-
 Changelog.md | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 0fbf0ee..cd70b17 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rusqlite"
-version = "0.3.0"
+version = "0.3.1"
 authors = ["John Gallagher <jgallagher@bignerdranch.com>"]
 description = "Ergonomic wrapper for SQLite"
 repository = "https://github.com/jgallagher/rusqlite"
diff --git a/Changelog.md b/Changelog.md
index 6ce64d3..624b076 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,3 +1,8 @@
+# Version 0.3.1 (2015-09-22)
+
+* Reset underlying SQLite statements as soon as possible after executing, as recommended by
+  http://www.sqlite.org/cvstrac/wiki?p=ScrollingCursor.
+
 # Version 0.3.0 (2015-09-21)
 
 * Removes `get_opt`. Use `get_checked` instead.

From 420c4d4d9f05d0bb03fe2745f01933b8e59d5e6c Mon Sep 17 00:00:00 2001
From: John Gallagher <jgallagher@bignerdranch.com>
Date: Tue, 3 Nov 2015 11:27:52 -0500
Subject: [PATCH 19/22] Address RFC 1214 warning

---
 src/types.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/types.rs b/src/types.rs
index 5ad4ed7..a1d041f 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -74,7 +74,7 @@ pub trait ToSql {
 }
 
 /// A trait for types that can be created from a SQLite value.
-pub trait FromSql {
+pub trait FromSql: Sized {
     unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> SqliteResult<Self>;
 
     /// FromSql types can implement this method and use sqlite3_column_type to check that

From 78979c44ee5f3ce804a63750346771393e645621 Mon Sep 17 00:00:00 2001
From: John Gallagher <jgallagher@bignerdranch.com>
Date: Tue, 3 Nov 2015 11:29:02 -0500
Subject: [PATCH 20/22] Bump version to 0.4.0

---
 Cargo.toml   | 2 +-
 Changelog.md | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index cd70b17..68e7347 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rusqlite"
-version = "0.3.1"
+version = "0.4.0"
 authors = ["John Gallagher <jgallagher@bignerdranch.com>"]
 description = "Ergonomic wrapper for SQLite"
 repository = "https://github.com/jgallagher/rusqlite"
diff --git a/Changelog.md b/Changelog.md
index 624b076..2987801 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,3 +1,7 @@
+# Version 0.4.0 (2015-11-03)
+
+* Adds `Sized` bound to `FromSql` trait as required by RFC 1214.
+
 # Version 0.3.1 (2015-09-22)
 
 * Reset underlying SQLite statements as soon as possible after executing, as recommended by

From 270abfc44f5a153f6eec4f1728e60b901c8fd7eb Mon Sep 17 00:00:00 2001
From: John Gallagher <jgallagher@bignerdranch.com>
Date: Tue, 3 Nov 2015 11:33:03 -0500
Subject: [PATCH 21/22] Update to travis CI's container-based infrastructure

---
 .travis.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.travis.yml b/.travis.yml
index e7cc210..837d9f4 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,4 +1,5 @@
 language: rust
+sudo: false
 
 env:
     global:

From 7586556db5b4ad4db94e5e6ab5232f8868b8f5c9 Mon Sep 17 00:00:00 2001
From: John Gallagher <jgallagher@bignerdranch.com>
Date: Tue, 3 Nov 2015 11:37:23 -0500
Subject: [PATCH 22/22] Add to CONTRIBUTORS

---
 CONTRIBUTORS.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index e151714..24b0e7e 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -7,3 +7,4 @@ rusqlite contributors (sorted alphabetically)
 * [Jimmy Lu](https://github.com/Yuhta)
 * [Huon Wilson](https://github.com/huonw)
 * [Patrick Fernie](https://github.com/pfernie)
+* [Steve Klabnik](https://github.com/steveklabnik)