Rustfmt

src/backup.rs

@@ -171,9 +171,7 @@ impl<'a, 'b> Backup<'a, 'b> {
     ///
     /// Will return `Err` if the underlying `sqlite3_backup_init` call returns
     /// `NULL`.
-    pub fn new(from: &'a Connection,
-               to: &'b mut Connection)
-               -> Result<Backup<'a, 'b>> {
+    pub fn new(from: &'a Connection, to: &'b mut Connection) -> Result<Backup<'a, 'b>> {
         Backup::new_with_names(from, DatabaseName::Main, to, DatabaseName::Main)
     }
 

src/blob.rs

@@ -352,7 +352,8 @@ mod test {
 
         {
             // ... but it should've written the first 10 bytes
-            let mut blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false).unwrap();
+            let mut blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false)
+                             .unwrap();
             let mut bytes = [0u8; 10];
             assert_eq!(10, blob.read(&mut bytes[..]).unwrap());
             assert_eq!(b"0123456701", &bytes);
@@ -369,7 +370,8 @@ mod test {
 
         {
             // ... but it should've written the first 10 bytes
-            let mut blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false).unwrap();
+            let mut blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false)
+                             .unwrap();
             let mut bytes = [0u8; 10];
             assert_eq!(10, blob.read(&mut bytes[..]).unwrap());
             assert_eq!(b"aaaaaaaaaa", &bytes);

src/error.rs

@@ -85,13 +85,18 @@ impl fmt::Display for Error {
         match self {
             &Error::SqliteFailure(ref err, None) => err.fmt(f),
             &Error::SqliteFailure(_, Some(ref s)) => write!(f, "{}", s),
-            &Error::SqliteSingleThreadedMode => write!(f, "SQLite was compiled or configured for single-threaded use only"),
+            &Error::SqliteSingleThreadedMode => {
+                write!(f,
+                       "SQLite was compiled or configured for single-threaded use only")
+            }
             &Error::FromSqlConversionFailure(ref err) => err.fmt(f),
             &Error::Utf8Error(ref err) => err.fmt(f),
             &Error::NulError(ref err) => err.fmt(f),
             &Error::InvalidParameterName(ref name) => write!(f, "Invalid parameter name: {}", name),
             &Error::InvalidPath(ref p) => write!(f, "Invalid path: {}", p.to_string_lossy()),
-            &Error::ExecuteReturnedResults => write!(f, "Execute returned results - did you mean to call query?"),
+            &Error::ExecuteReturnedResults => {
+                write!(f, "Execute returned results - did you mean to call query?")
+            }
             &Error::QueryReturnedNoRows => write!(f, "Query returned no rows"),
             &Error::GetFromStaleRow => write!(f, "Attempted to get a value from a stale row"),
             &Error::InvalidColumnIndex(i) => write!(f, "Invalid column index: {}", i),
@@ -111,13 +116,17 @@ impl error::Error for Error {
         match self {
             &Error::SqliteFailure(ref err, None) => err.description(),
             &Error::SqliteFailure(_, Some(ref s)) => s,
-            &Error::SqliteSingleThreadedMode => "SQLite was compiled or configured for single-threaded use only",
+            &Error::SqliteSingleThreadedMode => {
+                "SQLite was compiled or configured for single-threaded use only"
+            }
             &Error::FromSqlConversionFailure(ref err) => err.description(),
             &Error::Utf8Error(ref err) => err.description(),
             &Error::InvalidParameterName(_) => "invalid parameter name",
             &Error::NulError(ref err) => err.description(),
             &Error::InvalidPath(_) => "invalid path",
-            &Error::ExecuteReturnedResults => "execute returned results - did you mean to call query?",
+            &Error::ExecuteReturnedResults => {
+                "execute returned results - did you mean to call query?"
+            }
             &Error::QueryReturnedNoRows => "query returned no rows",
             &Error::GetFromStaleRow => "attempted to get a value from a stale row",
             &Error::InvalidColumnIndex(_) => "invalid column index",

src/lib.rs

@@ -87,8 +87,8 @@ mod error;
 #[cfg(feature = "load_extension")]mod load_extension_guard;
 #[cfg(feature = "trace")]pub mod trace;
 #[cfg(feature = "backup")]pub mod backup;
-#[cfg(feature = "functions")] pub mod functions;
-#[cfg(feature = "blob")] pub mod blob;
+#[cfg(feature = "functions")]pub mod functions;
+#[cfg(feature = "blob")]pub mod blob;
 
 /// Old name for `Result`. `SqliteResult` is deprecated.
 pub type SqliteResult<T> = Result<T>;
@@ -182,17 +182,15 @@ impl Connection {
     ///
     /// Will return `Err` if `path` cannot be converted to a C-compatible string or if the
     /// underlying SQLite open call fails.
-    pub fn open_with_flags<P: AsRef<Path>>(path: P,
-                                           flags: OpenFlags)
-        -> Result<Connection> {
-            let c_path = try!(path_to_cstring(path.as_ref()));
-            InnerConnection::open_with_flags(&c_path, flags).map(|db| {
-                Connection {
-                    db: RefCell::new(db),
-                    path: Some(path.as_ref().to_path_buf()),
-                }
-            })
-        }
+    pub fn open_with_flags<P: AsRef<Path>>(path: P, flags: OpenFlags) -> Result<Connection> {
+        let c_path = try!(path_to_cstring(path.as_ref()));
+        InnerConnection::open_with_flags(&c_path, flags).map(|db| {
+            Connection {
+                db: RefCell::new(db),
+                path: Some(path.as_ref().to_path_buf()),
+            }
+        })
+    }
 
     /// Open a new connection to an in-memory SQLite database.
     ///
@@ -249,9 +247,9 @@ impl Connection {
     /// Will return `Err` if the underlying SQLite call fails.
     pub fn transaction_with_behavior<'a>(&'a self,
                                          behavior: TransactionBehavior)
-        -> Result<Transaction<'a>> {
-            Transaction::new(self, behavior)
-        }
+                                         -> Result<Transaction<'a>> {
+        Transaction::new(self, behavior)
+    }
 
     /// Convenience method to run multiple SQL statements (that cannot take any parameters).
     ///
@@ -359,7 +357,11 @@ impl Connection {
     ///
     /// Will return `Err` if `sql` cannot be converted to a C-compatible string or if the
     /// underlying SQLite call fails.
-    pub fn query_row_and_then<T, E, F>(&self, sql: &str, params: &[&ToSql], f: F) -> result::Result<T, E>
+    pub fn query_row_and_then<T, E, F>(&self,
+                                       sql: &str,
+                                       params: &[&ToSql],
+                                       f: F)
+                                       -> result::Result<T, E>
         where F: FnOnce(Row) -> result::Result<T, E>,
               E: convert::From<Error>
     {
@@ -390,9 +392,9 @@ impl Connection {
     /// does exactly the same thing.
     pub fn query_row_safe<T, F>(&self, sql: &str, params: &[&ToSql], f: F) -> Result<T>
         where F: FnOnce(Row) -> T
-        {
-            self.query_row(sql, params, f)
-        }
+    {
+        self.query_row(sql, params, f)
+    }
 
     /// Prepare a SQL statement for execution.
     ///
@@ -490,9 +492,9 @@ impl Connection {
     pub fn load_extension<P: AsRef<Path>>(&self,
                                           dylib_path: P,
                                           entry_point: Option<&str>)
-        -> Result<()> {
-            self.db.borrow_mut().load_extension(dylib_path.as_ref(), entry_point)
-        }
+                                          -> Result<()> {
+        self.db.borrow_mut().load_extension(dylib_path.as_ref(), entry_point)
+    }
 
     fn decode_result(&self, code: c_int) -> Result<()> {
         self.db.borrow_mut().decode_result(code)
@@ -506,8 +508,8 @@ impl Connection {
 impl fmt::Debug for Connection {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("Connection")
-            .field("path", &self.path)
-            .finish()
+         .field("path", &self.path)
+         .finish()
     }
 }
 
@@ -542,60 +544,58 @@ impl Default for OpenFlags {
 }
 
 impl InnerConnection {
-    fn open_with_flags(c_path: &CString,
-                       flags: OpenFlags)
-        -> Result<InnerConnection> {
-            unsafe {
-                // Before opening the database, we need to check that SQLite hasn't been
-                // compiled or configured to be in single-threaded mode. If it has, we're
-                // exposing a very unsafe API to Rust, so refuse to open connections at all.
-                // Unfortunately, the check for this is quite gross. sqlite3_threadsafe() only
-                // returns how SQLite was _compiled_; there is no public API to check whether
-                // someone called sqlite3_config() to set single-threaded mode. We can cheat
-                // by trying to allocate a mutex, though; in single-threaded mode due to
-                // compilation settings, the magic value 8 is returned (see the definition of
-                // sqlite3_mutex_alloc at https://github.com/mackyle/sqlite/blob/master/src/mutex.h);
-                // in single-threaded mode due to sqlite3_config(), the magic value 8 is also
-                // returned (see the definition of noopMutexAlloc at
-                // https://github.com/mackyle/sqlite/blob/master/src/mutex_noop.c).
-                const SQLITE_SINGLETHREADED_MUTEX_MAGIC: usize = 8;
-                let mutex_ptr = ffi::sqlite3_mutex_alloc(0);
-                let is_singlethreaded = if mutex_ptr as usize == SQLITE_SINGLETHREADED_MUTEX_MAGIC {
-                    true
+    fn open_with_flags(c_path: &CString, flags: OpenFlags) -> Result<InnerConnection> {
+        unsafe {
+            // Before opening the database, we need to check that SQLite hasn't been
+            // compiled or configured to be in single-threaded mode. If it has, we're
+            // exposing a very unsafe API to Rust, so refuse to open connections at all.
+            // Unfortunately, the check for this is quite gross. sqlite3_threadsafe() only
+            // returns how SQLite was _compiled_; there is no public API to check whether
+            // someone called sqlite3_config() to set single-threaded mode. We can cheat
+            // by trying to allocate a mutex, though; in single-threaded mode due to
+            // compilation settings, the magic value 8 is returned (see the definition of
+            // sqlite3_mutex_alloc at https://github.com/mackyle/sqlite/blob/master/src/mutex.h);
+            // in single-threaded mode due to sqlite3_config(), the magic value 8 is also
+            // returned (see the definition of noopMutexAlloc at
+            // https://github.com/mackyle/sqlite/blob/master/src/mutex_noop.c).
+            const SQLITE_SINGLETHREADED_MUTEX_MAGIC: usize = 8;
+            let mutex_ptr = ffi::sqlite3_mutex_alloc(0);
+            let is_singlethreaded = if mutex_ptr as usize == SQLITE_SINGLETHREADED_MUTEX_MAGIC {
+                true
+            } else {
+                false
+            };
+            ffi::sqlite3_mutex_free(mutex_ptr);
+            if is_singlethreaded {
+                return Err(Error::SqliteSingleThreadedMode);
+            }
+
+            let mut db: *mut ffi::sqlite3 = mem::uninitialized();
+            let r = ffi::sqlite3_open_v2(c_path.as_ptr(), &mut db, flags.bits(), ptr::null());
+            if r != ffi::SQLITE_OK {
+                let e = if db.is_null() {
+                    error_from_sqlite_code(r, None)
                 } else {
-                    false
-                };
-                ffi::sqlite3_mutex_free(mutex_ptr);
-                if is_singlethreaded {
-                    return Err(Error::SqliteSingleThreadedMode);
-                }
-
-                let mut db: *mut ffi::sqlite3 = mem::uninitialized();
-                let r = ffi::sqlite3_open_v2(c_path.as_ptr(), &mut db, flags.bits(), ptr::null());
-                if r != ffi::SQLITE_OK {
-                    let e = if db.is_null() {
-                        error_from_sqlite_code(r, None)
-                    } else {
-                        let e = error_from_handle(db, r);
-                        ffi::sqlite3_close(db);
-                        e
-                    };
-
-                    return Err(e);
-                }
-                let r = ffi::sqlite3_busy_timeout(db, 5000);
-                if r != ffi::SQLITE_OK {
                     let e = error_from_handle(db, r);
                     ffi::sqlite3_close(db);
-                    return Err(e);
-                }
+                    e
+                };
 
-                // attempt to turn on extended results code; don't fail if we can't.
-                ffi::sqlite3_extended_result_codes(db, 1);
-
-                Ok(InnerConnection { db: db })
+                return Err(e);
             }
+            let r = ffi::sqlite3_busy_timeout(db, 5000);
+            if r != ffi::SQLITE_OK {
+                let e = error_from_handle(db, r);
+                ffi::sqlite3_close(db);
+                return Err(e);
+            }
+
+            // attempt to turn on extended results code; don't fail if we can't.
+            ffi::sqlite3_extended_result_codes(db, 1);
+
+            Ok(InnerConnection { db: db })
         }
+    }
 
     fn db(&self) -> *mut ffi::Struct_sqlite3 {
         self.db
@@ -621,10 +621,10 @@ impl InnerConnection {
         let c_sql = try!(str_to_cstring(sql));
         unsafe {
             let r = ffi::sqlite3_exec(self.db(),
-            c_sql.as_ptr(),
-            None,
-            ptr::null_mut(),
-            ptr::null_mut());
+                                      c_sql.as_ptr(),
+                                      None,
+                                      ptr::null_mut(),
+                                      ptr::null_mut());
             self.decode_result(r)
         }
     }
@@ -663,25 +663,22 @@ impl InnerConnection {
         unsafe { ffi::sqlite3_last_insert_rowid(self.db()) }
     }
 
-    fn prepare<'a>(&mut self,
-                   conn: &'a Connection,
-                   sql: &str)
-        -> Result<Statement<'a>> {
-            if sql.len() >= ::std::i32::MAX as usize {
-                return Err(error_from_sqlite_code(ffi::SQLITE_TOOBIG, None));
-            }
-            let mut c_stmt: *mut ffi::sqlite3_stmt = unsafe { mem::uninitialized() };
-            let c_sql = try!(str_to_cstring(sql));
-            let r = unsafe {
-                let len_with_nul = (sql.len() + 1) as c_int;
-                ffi::sqlite3_prepare_v2(self.db(),
-                c_sql.as_ptr(),
-                len_with_nul,
-                &mut c_stmt,
-                ptr::null_mut())
-            };
-            self.decode_result(r).map(|_| Statement::new(conn, c_stmt))
+    fn prepare<'a>(&mut self, conn: &'a Connection, sql: &str) -> Result<Statement<'a>> {
+        if sql.len() >= ::std::i32::MAX as usize {
+            return Err(error_from_sqlite_code(ffi::SQLITE_TOOBIG, None));
         }
+        let mut c_stmt: *mut ffi::sqlite3_stmt = unsafe { mem::uninitialized() };
+        let c_sql = try!(str_to_cstring(sql));
+        let r = unsafe {
+            let len_with_nul = (sql.len() + 1) as c_int;
+            ffi::sqlite3_prepare_v2(self.db(),
+                                    c_sql.as_ptr(),
+                                    len_with_nul,
+                                    &mut c_stmt,
+                                    ptr::null_mut())
+        };
+        self.decode_result(r).map(|_| Statement::new(conn, c_stmt))
+    }
 
     fn changes(&mut self) -> c_int {
         unsafe { ffi::sqlite3_changes(self.db()) }
@@ -790,7 +787,7 @@ impl<'conn> Statement<'conn> {
                 } else {
                     Ok(self.conn.changes())
                 }
-            },
+            }
             ffi::SQLITE_ROW => Err(Error::ExecuteReturnedResults),
             _ => Err(self.conn.decode_result(r).unwrap_err()),
         }
@@ -839,19 +836,16 @@ impl<'conn> Statement<'conn> {
     /// # Failure
     ///
     /// Will return `Err` if binding parameters fails.
-    pub fn query_map<'a, T, F>(&'a mut self,
-                               params: &[&ToSql],
-                               f: F)
-        -> Result<MappedRows<'a, F>>
+    pub fn query_map<'a, T, F>(&'a mut self, params: &[&ToSql], f: F) -> Result<MappedRows<'a, F>>
         where F: FnMut(&Row) -> T
-        {
-            let row_iter = try!(self.query(params));
+    {
+        let row_iter = try!(self.query(params));
 
-            Ok(MappedRows {
-                rows: row_iter,
-                map: f,
-            })
-        }
+        Ok(MappedRows {
+            rows: row_iter,
+            map: f,
+        })
+    }
 
     /// Executes the prepared statement and maps a function over the resulting
     /// rows, where the function returns a `Result` with `Error` type implementing
@@ -866,17 +860,17 @@ impl<'conn> Statement<'conn> {
     pub fn query_and_then<'a, T, E, F>(&'a mut self,
                                        params: &[&ToSql],
                                        f: F)
-        -> Result<AndThenRows<'a, F>>
+                                       -> Result<AndThenRows<'a, F>>
         where E: convert::From<Error>,
               F: FnMut(&Row) -> result::Result<T, E>
-              {
-                  let row_iter = try!(self.query(params));
+    {
+        let row_iter = try!(self.query(params));
 
-                  Ok(AndThenRows {
-                      rows: row_iter,
-                      map: f,
-                  })
-              }
+        Ok(AndThenRows {
+            rows: row_iter,
+            map: f,
+        })
+    }
 
     /// Consumes the statement.
     ///
@@ -892,9 +886,9 @@ impl<'conn> Statement<'conn> {
 
     unsafe fn bind_parameters(&mut self, params: &[&ToSql]) -> Result<()> {
         assert!(params.len() as c_int == ffi::sqlite3_bind_parameter_count(self.stmt),
-        "incorrect number of parameters to query(): expected {}, got {}",
-        ffi::sqlite3_bind_parameter_count(self.stmt),
-        params.len());
+                "incorrect number of parameters to query(): expected {}, got {}",
+                ffi::sqlite3_bind_parameter_count(self.stmt),
+                params.len());
 
         for (i, p) in params.iter().enumerate() {
             try!(self.conn.decode_result(p.bind_parameter(self.stmt, (i + 1) as c_int)));
@@ -926,10 +920,10 @@ impl<'conn> fmt::Debug for Statement<'conn> {
             str::from_utf8(c_slice)
         };
         f.debug_struct("Statement")
-            .field("conn", self.conn)
-            .field("stmt", &self.stmt)
-            .field("sql", &sql)
-            .finish()
+         .field("conn", self.conn)
+         .field("stmt", &self.stmt)
+         .field("sql", &sql)
+         .finish()
     }
 }
 
@@ -963,15 +957,15 @@ pub struct AndThenRows<'stmt, F> {
 }
 
 impl<'stmt, T, E, F> Iterator for AndThenRows<'stmt, F>
-where E: convert::From<Error>,
-      F: FnMut(&Row) -> result::Result<T, E>
+    where E: convert::From<Error>,
+          F: FnMut(&Row) -> result::Result<T, E>
 {
     type Item = result::Result<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))
+                      .and_then(|row| (self.map)(&row))
         })
     }
 }
@@ -1222,11 +1216,11 @@ mod test {
     #[test]
     fn test_open_with_flags() {
         for bad_flags in [OpenFlags::empty(),
-        SQLITE_OPEN_READ_ONLY | SQLITE_OPEN_READ_WRITE,
-        SQLITE_OPEN_READ_ONLY | SQLITE_OPEN_CREATE]
-            .iter() {
-                assert!(Connection::open_in_memory_with_flags(*bad_flags).is_err());
-            }
+                          SQLITE_OPEN_READ_ONLY | SQLITE_OPEN_READ_WRITE,
+                          SQLITE_OPEN_READ_ONLY | SQLITE_OPEN_CREATE]
+                             .iter() {
+            assert!(Connection::open_in_memory_with_flags(*bad_flags).is_err());
+        }
     }
 
     #[test]
@@ -1402,7 +1396,7 @@ mod test {
 
         assert_eq!(2i32, second.get(0));
 
-        match first.get_checked::<i32,i32>(0).unwrap_err() {
+        match first.get_checked::<i32, i32>(0).unwrap_err() {
             Error::GetFromStaleRow => (),
             err => panic!("Unexpected error {}", err),
         }
@@ -1450,7 +1444,7 @@ mod test {
                 if version >= 3007016 {
                     assert_eq!(err.extended_code, ffi::SQLITE_CONSTRAINT_NOTNULL)
                 }
-            },
+            }
             err => panic!("Unexpected error {}", err),
         }
     }

src/named_params.rs

@@ -37,11 +37,7 @@ impl Connection {
     ///
     /// Will return `Err` if `sql` cannot be converted to a C-compatible string or if the
     /// underlying SQLite call fails.
-    pub fn query_row_named<T, F>(&self,
-                                 sql: &str,
-                                 params: &[(&str, &ToSql)],
-                                 f: F)
-                                 -> Result<T>
+    pub fn query_row_named<T, F>(&self, sql: &str, params: &[(&str, &ToSql)], f: F) -> Result<T>
         where F: FnOnce(Row) -> T
     {
         let mut stmt = try!(self.prepare(sql));
@@ -91,9 +87,7 @@ impl<'conn> Statement<'conn> {
     /// which case `query` should be used instead), or the underling SQLite call fails.
     pub fn execute_named(&mut self, params: &[(&str, &ToSql)]) -> Result<c_int> {
         try!(self.bind_parameters_named(params));
-        unsafe {
-            self.execute_()
-        }
+        unsafe { self.execute_() }
     }
 
     /// Execute the prepared statement with named parameter(s), returning an iterator over the
@@ -118,9 +112,7 @@ impl<'conn> Statement<'conn> {
     /// # Failure
     ///
     /// Will return `Err` if binding parameters fails.
-    pub fn query_named<'a>(&'a mut self,
-                           params: &[(&str, &ToSql)])
-                           -> Result<Rows<'a>> {
+    pub fn query_named<'a>(&'a mut self, params: &[(&str, &ToSql)]) -> Result<Rows<'a>> {
         self.reset_if_needed();
         try!(self.bind_parameters_named(params));
 
@@ -198,8 +190,10 @@ mod test {
         let mut stmt = db.prepare("INSERT INTO test (x, y) VALUES (:x, :y)").unwrap();
         stmt.execute_named(&[(":x", &"one")]).unwrap();
 
-        let result: Option<String> = db.query_row("SELECT y FROM test WHERE x = 'one'", &[],
-                                  |row| row.get(0)).unwrap();
+        let result: Option<String> = db.query_row("SELECT y FROM test WHERE x = 'one'",
+                                                  &[],
+                                                  |row| row.get(0))
+                                       .unwrap();
         assert!(result.is_none());
     }
 
@@ -213,8 +207,10 @@ mod test {
         stmt.execute_named(&[(":x", &"one")]).unwrap();
         stmt.execute_named(&[(":y", &"two")]).unwrap();
 
-        let result: String = db.query_row("SELECT x FROM test WHERE y = 'two'", &[],
-                                  |row| row.get(0)).unwrap();
+        let result: String = db.query_row("SELECT x FROM test WHERE y = 'two'",
+                                          &[],
+                                          |row| row.get(0))
+                               .unwrap();
         assert_eq!(result, "one");
     }
 }

src/transaction.rs

@@ -47,9 +47,7 @@ pub struct Transaction<'conn> {
 
 impl<'conn> Transaction<'conn> {
     /// Begin a new transaction. Cannot be nested; see `savepoint` for nested transactions.
-    pub fn new(conn: &Connection,
-               behavior: TransactionBehavior)
-               -> Result<Transaction> {
+    pub fn new(conn: &Connection, behavior: TransactionBehavior) -> Result<Transaction> {
         let query = match behavior {
             TransactionBehavior::Deferred => "BEGIN DEFERRED",
             TransactionBehavior::Immediate => "BEGIN IMMEDIATE",

src/types.rs

@@ -422,54 +422,54 @@ mod test {
         let row = rows.next().unwrap().unwrap();
 
         // check the correct types come back as expected
-        assert_eq!(vec![1, 2], row.get_checked::<i32,Vec<u8>>(0).unwrap());
-        assert_eq!("text", row.get_checked::<i32,String>(1).unwrap());
-        assert_eq!(1, row.get_checked::<i32,c_int>(2).unwrap());
-        assert_eq!(1.5, row.get_checked::<i32,c_double>(3).unwrap());
-        assert!(row.get_checked::<i32,Option<c_int>>(4).unwrap().is_none());
-        assert!(row.get_checked::<i32,Option<c_double>>(4).unwrap().is_none());
-        assert!(row.get_checked::<i32,Option<String>>(4).unwrap().is_none());
+        assert_eq!(vec![1, 2], row.get_checked::<i32, Vec<u8>>(0).unwrap());
+        assert_eq!("text", row.get_checked::<i32, String>(1).unwrap());
+        assert_eq!(1, row.get_checked::<i32, c_int>(2).unwrap());
+        assert_eq!(1.5, row.get_checked::<i32, c_double>(3).unwrap());
+        assert!(row.get_checked::<i32, Option<c_int>>(4).unwrap().is_none());
+        assert!(row.get_checked::<i32, Option<c_double>>(4).unwrap().is_none());
+        assert!(row.get_checked::<i32, Option<String>>(4).unwrap().is_none());
 
         // check some invalid types
 
         // 0 is actually a blob (Vec<u8>)
-        assert!(is_invalid_column_type(row.get_checked::<i32,c_int>(0).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,c_int>(0).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,i64>(0).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,c_double>(0).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,String>(0).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,time::Timespec>(0).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,Option<c_int>>(0).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, c_int>(0).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, c_int>(0).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, i64>(0).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, c_double>(0).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, String>(0).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, time::Timespec>(0).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, Option<c_int>>(0).err().unwrap()));
 
         // 1 is actually a text (String)
-        assert!(is_invalid_column_type(row.get_checked::<i32,c_int>(1).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,i64>(1).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,c_double>(1).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,Vec<u8>>(1).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,Option<c_int>>(1).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, c_int>(1).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, i64>(1).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, c_double>(1).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, Vec<u8>>(1).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, Option<c_int>>(1).err().unwrap()));
 
         // 2 is actually an integer
-        assert!(is_invalid_column_type(row.get_checked::<i32,c_double>(2).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,String>(2).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,Vec<u8>>(2).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,time::Timespec>(2).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,Option<c_double>>(2).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, c_double>(2).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, String>(2).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, Vec<u8>>(2).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, time::Timespec>(2).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, Option<c_double>>(2).err().unwrap()));
 
         // 3 is actually a float (c_double)
-        assert!(is_invalid_column_type(row.get_checked::<i32,c_int>(3).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,i64>(3).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,String>(3).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,Vec<u8>>(3).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,time::Timespec>(3).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,Option<c_int>>(3).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, c_int>(3).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, i64>(3).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, String>(3).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, Vec<u8>>(3).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, time::Timespec>(3).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, Option<c_int>>(3).err().unwrap()));
 
         // 4 is actually NULL
-        assert!(is_invalid_column_type(row.get_checked::<i32,c_int>(4).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,i64>(4).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,c_double>(4).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,String>(4).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,Vec<u8>>(4).err().unwrap()));
-        assert!(is_invalid_column_type(row.get_checked::<i32,time::Timespec>(4).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, c_int>(4).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, i64>(4).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, c_double>(4).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, String>(4).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, Vec<u8>>(4).err().unwrap()));
+        assert!(is_invalid_column_type(row.get_checked::<i32, time::Timespec>(4).err().unwrap()));
     }
 
     #[test]
@@ -486,11 +486,11 @@ mod test {
 
         let row = rows.next().unwrap().unwrap();
         assert_eq!(Value::Blob(vec![1, 2]),
-                   row.get_checked::<i32,Value>(0).unwrap());
+                   row.get_checked::<i32, Value>(0).unwrap());
         assert_eq!(Value::Text(String::from("text")),
-                   row.get_checked::<i32,Value>(1).unwrap());
-        assert_eq!(Value::Integer(1), row.get_checked::<i32,Value>(2).unwrap());
-        assert_eq!(Value::Real(1.5), row.get_checked::<i32,Value>(3).unwrap());
-        assert_eq!(Value::Null, row.get_checked::<i32,Value>(4).unwrap());
+                   row.get_checked::<i32, Value>(1).unwrap());
+        assert_eq!(Value::Integer(1), row.get_checked::<i32, Value>(2).unwrap());
+        assert_eq!(Value::Real(1.5), row.get_checked::<i32, Value>(3).unwrap());
+        assert_eq!(Value::Null, row.get_checked::<i32, Value>(4).unwrap());
     }
 }