From f529d130b92a10df6942bf880ed3509a1fffa7fb Mon Sep 17 00:00:00 2001 From: gwenn Date: Tue, 2 Feb 2016 19:12:00 +0100 Subject: [PATCH] Rustfmt --- src/backup.rs | 4 +- src/blob.rs | 6 +- src/error.rs | 17 ++- src/lib.rs | 258 ++++++++++++++++++++++---------------------- src/named_params.rs | 26 ++--- src/transaction.rs | 4 +- src/types.rs | 82 +++++++------- 7 files changed, 197 insertions(+), 200 deletions(-) diff --git a/src/backup.rs b/src/backup.rs index e55c8ee..484171f 100644 --- a/src/backup.rs +++ b/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> { + pub fn new(from: &'a Connection, to: &'b mut Connection) -> Result> { Backup::new_with_names(from, DatabaseName::Main, to, DatabaseName::Main) } diff --git a/src/blob.rs b/src/blob.rs index f8b1710..9f50980 100644 --- a/src/blob.rs +++ b/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); diff --git a/src/error.rs b/src/error.rs index ba93df8..3f356f6 100644 --- a/src/error.rs +++ b/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", diff --git a/src/lib.rs b/src/lib.rs index d4b445e..d15b0e0 100644 --- a/src/lib.rs +++ b/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 = Result; @@ -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>(path: P, - flags: OpenFlags) - -> Result { - 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>(path: P, flags: OpenFlags) -> Result { + 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::new(self, behavior) - } + -> Result> { + 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(&self, sql: &str, params: &[&ToSql], f: F) -> result::Result + pub fn query_row_and_then(&self, + sql: &str, + params: &[&ToSql], + f: F) + -> result::Result where F: FnOnce(Row) -> result::Result, E: convert::From { @@ -390,9 +392,9 @@ impl Connection { /// does exactly the same thing. pub fn query_row_safe(&self, sql: &str, params: &[&ToSql], f: F) -> Result 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>(&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 { - 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 { + 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> { - 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> { + 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> + pub fn query_map<'a, T, F>(&'a mut self, params: &[&ToSql], f: F) -> Result> 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> + -> Result> where E: convert::From, F: FnMut(&Row) -> result::Result - { - 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, - F: FnMut(&Row) -> result::Result + where E: convert::From, + F: FnMut(&Row) -> result::Result { type Item = result::Result; fn next(&mut self) -> Option { 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::(0).unwrap_err() { + match first.get_checked::(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), } } diff --git a/src/named_params.rs b/src/named_params.rs index 4f55dd8..34b3c67 100644 --- a/src/named_params.rs +++ b/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(&self, - sql: &str, - params: &[(&str, &ToSql)], - f: F) - -> Result + pub fn query_row_named(&self, sql: &str, params: &[(&str, &ToSql)], f: F) -> Result 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 { 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> { + pub fn query_named<'a>(&'a mut self, params: &[(&str, &ToSql)]) -> Result> { 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 = db.query_row("SELECT y FROM test WHERE x = 'one'", &[], - |row| row.get(0)).unwrap(); + let result: Option = 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"); } } diff --git a/src/transaction.rs b/src/transaction.rs index 3adbdb2..ea09cef 100644 --- a/src/transaction.rs +++ b/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 { + pub fn new(conn: &Connection, behavior: TransactionBehavior) -> Result { let query = match behavior { TransactionBehavior::Deferred => "BEGIN DEFERRED", TransactionBehavior::Immediate => "BEGIN IMMEDIATE", diff --git a/src/types.rs b/src/types.rs index de3d709..c458e01 100644 --- a/src/types.rs +++ b/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::>(0).unwrap()); - assert_eq!("text", row.get_checked::(1).unwrap()); - assert_eq!(1, row.get_checked::(2).unwrap()); - assert_eq!(1.5, row.get_checked::(3).unwrap()); - assert!(row.get_checked::>(4).unwrap().is_none()); - assert!(row.get_checked::>(4).unwrap().is_none()); - assert!(row.get_checked::>(4).unwrap().is_none()); + assert_eq!(vec![1, 2], row.get_checked::>(0).unwrap()); + assert_eq!("text", row.get_checked::(1).unwrap()); + assert_eq!(1, row.get_checked::(2).unwrap()); + assert_eq!(1.5, row.get_checked::(3).unwrap()); + assert!(row.get_checked::>(4).unwrap().is_none()); + assert!(row.get_checked::>(4).unwrap().is_none()); + assert!(row.get_checked::>(4).unwrap().is_none()); // check some invalid types // 0 is actually a blob (Vec) - assert!(is_invalid_column_type(row.get_checked::(0).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(0).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(0).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(0).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(0).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(0).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::>(0).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(0).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(0).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(0).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(0).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(0).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(0).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::>(0).err().unwrap())); // 1 is actually a text (String) - assert!(is_invalid_column_type(row.get_checked::(1).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(1).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(1).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::>(1).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::>(1).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(1).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(1).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(1).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::>(1).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::>(1).err().unwrap())); // 2 is actually an integer - assert!(is_invalid_column_type(row.get_checked::(2).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(2).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::>(2).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(2).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::>(2).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(2).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(2).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::>(2).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(2).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::>(2).err().unwrap())); // 3 is actually a float (c_double) - assert!(is_invalid_column_type(row.get_checked::(3).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(3).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(3).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::>(3).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(3).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::>(3).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(3).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(3).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(3).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::>(3).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(3).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::>(3).err().unwrap())); // 4 is actually NULL - assert!(is_invalid_column_type(row.get_checked::(4).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(4).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(4).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(4).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::>(4).err().unwrap())); - assert!(is_invalid_column_type(row.get_checked::(4).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(4).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(4).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(4).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(4).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::>(4).err().unwrap())); + assert!(is_invalid_column_type(row.get_checked::(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::(0).unwrap()); + row.get_checked::(0).unwrap()); assert_eq!(Value::Text(String::from("text")), - row.get_checked::(1).unwrap()); - assert_eq!(Value::Integer(1), row.get_checked::(2).unwrap()); - assert_eq!(Value::Real(1.5), row.get_checked::(3).unwrap()); - assert_eq!(Value::Null, row.get_checked::(4).unwrap()); + row.get_checked::(1).unwrap()); + assert_eq!(Value::Integer(1), row.get_checked::(2).unwrap()); + assert_eq!(Value::Real(1.5), row.get_checked::(3).unwrap()); + assert_eq!(Value::Null, row.get_checked::(4).unwrap()); } }