diff --git a/README.md b/README.md index 46912b2..268f23f 100644 --- a/README.md +++ b/README.md @@ -49,12 +49,12 @@ fn main() -> Result<()> { let mut stmt = conn .prepare("SELECT id, name, time_created, data FROM person")?; let person_iter = stmt - .query_map(NO_PARAMS, |row| Person { - id: row.get(0), - name: row.get(1), - time_created: row.get(2), - data: row.get(3), - })?; + .query_map(NO_PARAMS, |row| Ok(Person { + id: row.get(0)?, + name: row.get(1)?, + time_created: row.get(2)?, + data: row.get(3)?, + }))?; for person in person_iter { println!("Found person {:?}", person.unwrap()); diff --git a/src/blob.rs b/src/blob.rs index 99d0013..372fc4c 100644 --- a/src/blob.rs +++ b/src/blob.rs @@ -28,8 +28,7 @@ //! )?; //! //! let rowid = db.last_insert_rowid(); -//! let mut blob = db -//! .blob_open(DatabaseName::Main, "test", "content", rowid, false)?; +//! let mut blob = db.blob_open(DatabaseName::Main, "test", "content", rowid, false)?; //! //! // Make sure to test that the number of bytes written matches what you expect; //! // if you try to write too much, the data will be truncated to the size of the diff --git a/src/busy.rs b/src/busy.rs index e0ee835..f801e3f 100644 --- a/src/busy.rs +++ b/src/busy.rs @@ -82,7 +82,7 @@ mod test { use std::time::Duration; use tempdir; - use crate::{Connection, Error, ErrorCode, TransactionBehavior, NO_PARAMS}; + use crate::{Connection, Error, ErrorCode, Result, TransactionBehavior, NO_PARAMS}; #[test] fn test_default_busy() { @@ -94,7 +94,7 @@ mod test { .transaction_with_behavior(TransactionBehavior::Exclusive) .unwrap(); let db2 = Connection::open(&path).unwrap(); - let r = db2.query_row("PRAGMA schema_version", NO_PARAMS, |_| unreachable!()); + let r: Result<()> = db2.query_row("PRAGMA schema_version", NO_PARAMS, |_| unreachable!()); match r.unwrap_err() { Error::SqliteFailure(err, _) => { assert_eq!(err.code, ErrorCode::DatabaseBusy); @@ -127,7 +127,7 @@ mod test { assert_eq!(tx.recv().unwrap(), 1); let _ = db2 .query_row("PRAGMA schema_version", NO_PARAMS, |row| { - row.get_checked::<_, i32>(0) + row.get::<_, i32>(0) }) .expect("unexpected error"); @@ -166,7 +166,7 @@ mod test { assert_eq!(tx.recv().unwrap(), 1); let _ = db2 .query_row("PRAGMA schema_version", NO_PARAMS, |row| { - row.get_checked::<_, i32>(0) + row.get::<_, i32>(0) }) .expect("unexpected error"); assert_eq!(CALLED.load(Ordering::Relaxed), true); diff --git a/src/cache.rs b/src/cache.rs index 2c44641..a93410f 100644 --- a/src/cache.rs +++ b/src/cache.rs @@ -298,7 +298,7 @@ mod test { let mut stmt = db.prepare_cached(sql).unwrap(); assert_eq!( (1i32, 2i32), - stmt.query_map(NO_PARAMS, |r| (r.get(0), r.get(1))) + stmt.query_map(NO_PARAMS, |r| Ok((r.get(0)?, r.get(1)?))) .unwrap() .next() .unwrap() diff --git a/src/config.rs b/src/config.rs index 36337f0..a10faac 100644 --- a/src/config.rs +++ b/src/config.rs @@ -25,12 +25,18 @@ pub enum DbConfig { impl Connection { /// Returns the current value of a `config`. /// - /// - SQLITE_DBCONFIG_ENABLE_FKEY: return `false` or `true` to indicate whether FK enforcement is off or on - /// - SQLITE_DBCONFIG_ENABLE_TRIGGER: return `false` or `true` to indicate whether triggers are disabled or enabled - /// - SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: return `false` or `true` to indicate whether fts3_tokenizer are disabled or enabled - /// - SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: return `false` to indicate checkpoints-on-close are not disabled or `true` if they are - /// - SQLITE_DBCONFIG_ENABLE_QPSG: return `false` or `true` to indicate whether the QPSG is disabled or enabled - /// - SQLITE_DBCONFIG_TRIGGER_EQP: return `false` to indicate output-for-trigger are not disabled or `true` if it is + /// - SQLITE_DBCONFIG_ENABLE_FKEY: return `false` or `true` to indicate + /// whether FK enforcement is off or on + /// - SQLITE_DBCONFIG_ENABLE_TRIGGER: return `false` or `true` to indicate + /// whether triggers are disabled or enabled + /// - SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: return `false` or `true` to + /// indicate whether fts3_tokenizer are disabled or enabled + /// - SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: return `false` to indicate + /// checkpoints-on-close are not disabled or `true` if they are + /// - SQLITE_DBCONFIG_ENABLE_QPSG: return `false` or `true` to indicate + /// whether the QPSG is disabled or enabled + /// - SQLITE_DBCONFIG_TRIGGER_EQP: return `false` to indicate + /// output-for-trigger are not disabled or `true` if it is pub fn db_config(&self, config: DbConfig) -> Result { let c = self.db.borrow(); unsafe { @@ -47,12 +53,18 @@ impl Connection { /// Make configuration changes to a database connection /// - /// - SQLITE_DBCONFIG_ENABLE_FKEY: `false` to disable FK enforcement, `true` to enable FK enforcement - /// - SQLITE_DBCONFIG_ENABLE_TRIGGER: `false` to disable triggers, `true` to enable triggers - /// - SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: `false` to disable fts3_tokenizer(), `true` to enable fts3_tokenizer() - /// - SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: `false` (the default) to enable checkpoints-on-close, `true` to disable them - /// - SQLITE_DBCONFIG_ENABLE_QPSG: `false` to disable the QPSG, `true` to enable QPSG - /// - SQLITE_DBCONFIG_TRIGGER_EQP: `false` to disable output for trigger programs, `true` to enable it + /// - SQLITE_DBCONFIG_ENABLE_FKEY: `false` to disable FK enforcement, `true` + /// to enable FK enforcement + /// - SQLITE_DBCONFIG_ENABLE_TRIGGER: `false` to disable triggers, `true` to + /// enable triggers + /// - SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: `false` to disable + /// fts3_tokenizer(), `true` to enable fts3_tokenizer() + /// - SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: `false` (the default) to enable + /// checkpoints-on-close, `true` to disable them + /// - SQLITE_DBCONFIG_ENABLE_QPSG: `false` to disable the QPSG, `true` to + /// enable QPSG + /// - SQLITE_DBCONFIG_TRIGGER_EQP: `false` to disable output for trigger + /// programs, `true` to enable it pub fn set_db_config(&self, config: DbConfig, new_val: bool) -> Result { let c = self.db.borrow_mut(); unsafe { @@ -78,11 +90,25 @@ mod test { let db = Connection::open_in_memory().unwrap(); let opposite = !db.db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_FKEY).unwrap(); - assert_eq!(db.set_db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_FKEY, opposite), Ok(opposite)); - assert_eq!(db.db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_FKEY), Ok(opposite)); + assert_eq!( + db.set_db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_FKEY, opposite), + Ok(opposite) + ); + assert_eq!( + db.db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_FKEY), + Ok(opposite) + ); - let opposite = !db.db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_TRIGGER).unwrap(); - assert_eq!(db.set_db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_TRIGGER, opposite), Ok(opposite)); - assert_eq!(db.db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_TRIGGER), Ok(opposite)); + let opposite = !db + .db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_TRIGGER) + .unwrap(); + assert_eq!( + db.set_db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_TRIGGER, opposite), + Ok(opposite) + ); + assert_eq!( + db.db_config(DbConfig::SQLITE_DBCONFIG_ENABLE_TRIGGER), + Ok(opposite) + ); } } diff --git a/src/functions.rs b/src/functions.rs index c3ea25c..a4773a0 100644 --- a/src/functions.rs +++ b/src/functions.rs @@ -38,12 +38,11 @@ //! let db = Connection::open_in_memory()?; //! add_regexp_function(&db)?; //! -//! let is_match: bool = db -//! .query_row( -//! "SELECT regexp('[aeiou]*', 'aaaaeeeiii')", -//! NO_PARAMS, -//! |row| row.get(0), -//! )?; +//! let is_match: bool = db.query_row( +//! "SELECT regexp('[aeiou]*', 'aaaaeeeiii')", +//! NO_PARAMS, +//! |row| row.get(0), +//! )?; //! //! assert!(is_match); //! Ok(()) @@ -771,7 +770,7 @@ mod test { let dual_sum = "SELECT my_sum(i), my_sum(j) FROM (SELECT 2 AS i, 1 AS j UNION ALL SELECT \ 2, 1)"; let result: (i64, i64) = db - .query_row(dual_sum, NO_PARAMS, |r| (r.get(0), r.get(1))) + .query_row(dual_sum, NO_PARAMS, |r| Ok((r.get(0)?, r.get(1)?))) .unwrap(); assert_eq!((4, 2), result); } diff --git a/src/lib.rs b/src/lib.rs index 3f801a6..ad09f12 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -38,15 +38,15 @@ //! params![me.name, me.time_created, me.data], //! )?; //! -//! let mut stmt = conn -//! .prepare("SELECT id, name, time_created, data FROM person")?; -//! let person_iter = stmt -//! .query_map(params![], |row| Person { -//! id: row.get(0), -//! name: row.get(1), -//! time_created: row.get(2), -//! data: row.get(3), -//! })?; +//! let mut stmt = conn.prepare("SELECT id, name, time_created, data FROM person")?; +//! let person_iter = stmt.query_map(params![], |row| { +//! Ok(Person { +//! id: row.get(0)?, +//! name: row.get(1)?, +//! time_created: row.get(2)?, +//! data: row.get(3)?, +//! }) +//! })?; //! //! for person in person_iter { //! println!("Found person {:?}", person.unwrap()); @@ -474,7 +474,7 @@ impl Connection { where P: IntoIterator, P::Item: ToSql, - F: FnOnce(&Row<'_, '_>) -> T, + F: FnOnce(&Row<'_, '_>) -> Result, { let mut stmt = self.prepare(sql)?; stmt.query_row(params, f) @@ -496,12 +496,12 @@ impl Connection { /// or if the underlying SQLite call fails. pub fn query_row_named(&self, sql: &str, params: &[(&str, &dyn ToSql)], f: F) -> Result where - F: FnOnce(&Row<'_, '_>) -> T, + F: FnOnce(&Row<'_, '_>) -> Result, { let mut stmt = self.prepare(sql)?; let mut rows = stmt.query_named(params)?; - rows.get_expected_row().map(|r| f(&r)) + rows.get_expected_row().and_then(|r| f(&r)) } /// Convenience method to execute a query that is expected to return a @@ -517,7 +517,7 @@ impl Connection { /// conn.query_row_and_then( /// "SELECT value FROM preferences WHERE name='locale'", /// NO_PARAMS, - /// |row| row.get_checked(0), + /// |row| row.get(0), /// ) /// } /// ``` @@ -859,9 +859,9 @@ mod test { let tx2 = db2.transaction().unwrap(); // SELECT first makes sqlite lock with a shared lock - tx1.query_row("SELECT x FROM foo LIMIT 1", NO_PARAMS, |_| ()) + tx1.query_row("SELECT x FROM foo LIMIT 1", NO_PARAMS, |_| Ok(())) .unwrap(); - tx2.query_row("SELECT x FROM foo LIMIT 1", NO_PARAMS, |_| ()) + tx2.query_row("SELECT x FROM foo LIMIT 1", NO_PARAMS, |_| Ok(())) .unwrap(); tx1.execute("INSERT INTO foo VALUES(?1)", &[1]).unwrap(); @@ -1062,7 +1062,7 @@ mod test { let mut v = Vec::::new(); while let Some(row) = rows.next() { - v.push(row.unwrap().get(0)); + v.push(row.unwrap().get(0).unwrap()); } assert_eq!(v, [3i32, 2, 1]); @@ -1073,7 +1073,7 @@ mod test { let mut v = Vec::::new(); while let Some(row) = rows.next() { - v.push(row.unwrap().get(0)); + v.push(row.unwrap().get(0).unwrap()); } assert_eq!(v, [2i32, 1]); @@ -1126,7 +1126,7 @@ mod test { err => panic!("Unexpected error {}", err), } - let bad_query_result = db.query_row("NOT A PROPER QUERY; test123", NO_PARAMS, |_| ()); + let bad_query_result = db.query_row("NOT A PROPER QUERY; test123", NO_PARAMS, |_| Ok(())); assert!(bad_query_result.is_err()); } @@ -1401,7 +1401,7 @@ mod test { let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap(); let results: Result> = query - .query_and_then(NO_PARAMS, |row| row.get_checked(1)) + .query_and_then(NO_PARAMS, |row| row.get(1)) .unwrap() .collect(); @@ -1422,7 +1422,7 @@ mod test { let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap(); let bad_type: Result> = query - .query_and_then(NO_PARAMS, |row| row.get_checked(1)) + .query_and_then(NO_PARAMS, |row| row.get(1)) .unwrap() .collect(); @@ -1432,7 +1432,7 @@ mod test { } let bad_idx: Result> = query - .query_and_then(NO_PARAMS, |row| row.get_checked(3)) + .query_and_then(NO_PARAMS, |row| row.get(3)) .unwrap() .collect(); @@ -1456,9 +1456,7 @@ mod test { let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap(); let results: CustomResult> = query - .query_and_then(NO_PARAMS, |row| { - row.get_checked(1).map_err(CustomError::Sqlite) - }) + .query_and_then(NO_PARAMS, |row| row.get(1).map_err(CustomError::Sqlite)) .unwrap() .collect(); @@ -1479,9 +1477,7 @@ mod test { let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap(); let bad_type: CustomResult> = query - .query_and_then(NO_PARAMS, |row| { - row.get_checked(1).map_err(CustomError::Sqlite) - }) + .query_and_then(NO_PARAMS, |row| row.get(1).map_err(CustomError::Sqlite)) .unwrap() .collect(); @@ -1491,9 +1487,7 @@ mod test { } let bad_idx: CustomResult> = query - .query_and_then(NO_PARAMS, |row| { - row.get_checked(3).map_err(CustomError::Sqlite) - }) + .query_and_then(NO_PARAMS, |row| row.get(3).map_err(CustomError::Sqlite)) .unwrap() .collect(); @@ -1524,7 +1518,7 @@ mod test { let query = "SELECT x, y FROM foo ORDER BY x DESC"; let results: CustomResult = db.query_row_and_then(query, NO_PARAMS, |row| { - row.get_checked(1).map_err(CustomError::Sqlite) + row.get(1).map_err(CustomError::Sqlite) }); assert_eq!(results.unwrap(), "hello"); @@ -1541,7 +1535,7 @@ mod test { let query = "SELECT x, y FROM foo ORDER BY x DESC"; let bad_type: CustomResult = db.query_row_and_then(query, NO_PARAMS, |row| { - row.get_checked(1).map_err(CustomError::Sqlite) + row.get(1).map_err(CustomError::Sqlite) }); match bad_type.unwrap_err() { @@ -1550,7 +1544,7 @@ mod test { } let bad_idx: CustomResult = db.query_row_and_then(query, NO_PARAMS, |row| { - row.get_checked(3).map_err(CustomError::Sqlite) + row.get(3).map_err(CustomError::Sqlite) }); match bad_idx.unwrap_err() { @@ -1577,7 +1571,8 @@ mod test { db.execute_batch(sql).unwrap(); db.query_row("SELECT * FROM foo", params![], |r| { - assert_eq!(2, r.column_count()) + assert_eq!(2, r.column_count()); + Ok(()) }) .unwrap(); } diff --git a/src/row.rs b/src/row.rs index e0381a1..27bc69e 100644 --- a/src/row.rs +++ b/src/row.rs @@ -73,7 +73,7 @@ pub struct MappedRows<'stmt, F> { impl<'stmt, T, F> MappedRows<'stmt, F> where - F: FnMut(&Row<'_, '_>) -> T, + F: FnMut(&Row<'_, '_>) -> Result, { pub(crate) fn new(rows: Rows<'stmt>, f: F) -> MappedRows<'stmt, F> { MappedRows { rows, map: f } @@ -82,7 +82,7 @@ where impl Iterator for MappedRows<'_, F> where - F: FnMut(&Row<'_, '_>) -> T, + F: FnMut(&Row<'_, '_>) -> Result, { type Item = Result; @@ -90,7 +90,7 @@ where let map = &mut self.map; self.rows .next() - .map(|row_result| row_result.map(|row| (map)(&row))) + .map(|row_result| row_result.and_then(|row| (map)(&row))) } } @@ -136,16 +136,16 @@ impl<'a, 'stmt> Row<'a, 'stmt> { /// /// ## Failure /// - /// Panics if calling `row.get_checked(idx)` would return an error, + /// Panics if calling `row.get(idx)` would return an error, /// including: /// - /// * If the underlying SQLite column type is not a valid type as a - /// source for `T` + /// * If the underlying SQLite column type is not a valid type as a source + /// for `T` /// * If the underlying SQLite integral value is outside the range /// representable by `T` /// * If `idx` is outside the range of columns in the returned query - pub fn get(&self, idx: I) -> T { - self.get_checked(idx).unwrap() + pub fn get_unwrap(&self, idx: I) -> T { + self.get(idx).unwrap() } /// Get the value of a particular column of the result row. @@ -164,7 +164,7 @@ impl<'a, 'stmt> Row<'a, 'stmt> { /// If the result type is i128 (which requires the `i128_blob` feature to be /// enabled), and the underlying SQLite column is a blob whose size is not /// 16 bytes, `Error::InvalidColumnType` will also be returned. - pub fn get_checked(&self, idx: I) -> Result { + pub fn get(&self, idx: I) -> Result { let idx = idx.idx(self.stmt)?; let value = self.stmt.value_ref(idx); FromSql::column_result(value).map_err(|err| match err { @@ -184,7 +184,7 @@ impl<'a, 'stmt> Row<'a, 'stmt> { /// This `ValueRef` is valid only as long as this Row, which is enforced by /// it's lifetime. This means that while this method is completely safe, /// it can be somewhat difficult to use, and most callers will be better - /// served by `get` or `get_checked`. + /// served by `get` or `get`. /// /// ## Failure /// @@ -208,7 +208,7 @@ impl<'a, 'stmt> Row<'a, 'stmt> { /// This `ValueRef` is valid only as long as this Row, which is enforced by /// it's lifetime. This means that while this method is completely safe, /// it can be difficult to use, and most callers will be better served by - /// `get` or `get_checked`. + /// `get` or `get`. /// /// ## Failure /// diff --git a/src/statement.rs b/src/statement.rs index a32aa28..aa07ea7 100644 --- a/src/statement.rs +++ b/src/statement.rs @@ -176,7 +176,7 @@ impl Statement<'_> { /// let mut names = Vec::new(); /// while let Some(result_row) = rows.next() { /// let row = result_row?; - /// names.push(row.get(0)); + /// names.push(row.get(0)?); /// } /// /// Ok(names) @@ -267,7 +267,7 @@ impl Statement<'_> { where P: IntoIterator, P::Item: ToSql, - F: FnMut(&Row<'_, '_>) -> T, + F: FnMut(&Row<'_, '_>) -> Result, { let rows = self.query(params)?; Ok(MappedRows::new(rows, f)) @@ -306,7 +306,7 @@ impl Statement<'_> { f: F, ) -> Result> where - F: FnMut(&Row<'_, '_>) -> T, + F: FnMut(&Row<'_, '_>) -> Result, { let rows = self.query_named(params)?; Ok(MappedRows::new(rows, f)) @@ -354,7 +354,7 @@ impl Statement<'_> { /// fn get_names(conn: &Connection) -> Result> { /// let mut stmt = conn.prepare("SELECT name FROM people WHERE id = :id")?; /// let rows = - /// stmt.query_and_then_named(&[(":id", &"one")], |row| name_to_person(row.get(0)))?; + /// stmt.query_and_then_named(&[(":id", &"one")], |row| name_to_person(row.get(0)?))?; /// /// let mut persons = Vec::new(); /// for person_result in rows { @@ -410,11 +410,11 @@ impl Statement<'_> { where P: IntoIterator, P::Item: ToSql, - F: FnOnce(&Row<'_, '_>) -> T, + F: FnOnce(&Row<'_, '_>) -> Result, { let mut rows = self.query(params)?; - rows.get_expected_row().map(|r| f(&r)) + rows.get_expected_row().and_then(|r| f(&r)) } /// Consumes the statement. @@ -798,8 +798,8 @@ mod test { .unwrap(); let mut rows = stmt.query_named(&[(":name", &"one")]).unwrap(); - let id: i32 = rows.next().unwrap().unwrap().get(0); - assert_eq!(1, id); + let id: Result = rows.next().unwrap().and_then(|row| row.get(0)); + assert_eq!(Ok(1), id); } #[test] @@ -816,8 +816,8 @@ mod test { .unwrap(); let mut rows = stmt .query_map_named(&[(":name", &"one")], |row| { - let id: i32 = row.get(0); - 2 * id + let id: Result = row.get(0); + id.map(|i| 2 * i) }) .unwrap(); @@ -840,7 +840,7 @@ mod test { .unwrap(); let mut rows = stmt .query_and_then_named(&[(":name", &"one")], |row| { - let id: i32 = row.get(0); + let id: i32 = row.get(0)?; if id == 1 { Ok(id) } else { diff --git a/src/trace.rs b/src/trace.rs index ddf537f..8af3f27 100644 --- a/src/trace.rs +++ b/src/trace.rs @@ -140,13 +140,13 @@ mod test { let mut db = Connection::open_in_memory().unwrap(); db.trace(Some(tracer)); { - let _ = db.query_row("SELECT ?", &[1i32], |_| {}); - let _ = db.query_row("SELECT ?", &["hello"], |_| {}); + let _ = db.query_row("SELECT ?", &[1i32], |_| Ok(())); + let _ = db.query_row("SELECT ?", &["hello"], |_| Ok(())); } db.trace(None); { - let _ = db.query_row("SELECT ?", &[2i32], |_| {}); - let _ = db.query_row("SELECT ?", &["goodbye"], |_| {}); + let _ = db.query_row("SELECT ?", &[2i32], |_| Ok(())); + let _ = db.query_row("SELECT ?", &["goodbye"], |_| Ok(())); } let traced_stmts = TRACED_STMTS.lock().unwrap(); diff --git a/src/types/from_sql.rs b/src/types/from_sql.rs index c917b7a..1264c25 100644 --- a/src/types/from_sql.rs +++ b/src/types/from_sql.rs @@ -210,8 +210,7 @@ mod test { { for n in out_of_range { let err = db - .query_row("SELECT ?", &[n], |r| r.get_checked::<_, T>(0)) - .unwrap() + .query_row("SELECT ?", &[n], |r| r.get::<_, T>(0)) .unwrap_err(); match err { Error::IntegralValueOutOfRange(_, value) => assert_eq!(*n, value), diff --git a/src/types/mod.rs b/src/types/mod.rs index 508b273..48aa60a 100644 --- a/src/types/mod.rs +++ b/src/types/mod.rs @@ -207,16 +207,16 @@ mod test { { let row1 = rows.next().unwrap().unwrap(); - let s1: Option = row1.get(0); - let b1: Option> = row1.get(1); + let s1: Option = row1.get_unwrap(0); + let b1: Option> = row1.get_unwrap(1); assert_eq!(s.unwrap(), s1.unwrap()); assert!(b1.is_none()); } { let row2 = rows.next().unwrap().unwrap(); - let s2: Option = row2.get(0); - let b2: Option> = row2.get(1); + let s2: Option = row2.get_unwrap(0); + let b2: Option> = row2.get_unwrap(1); assert!(s2.is_none()); assert_eq!(b, b2); } @@ -246,102 +246,94 @@ mod test { let row = rows.next().unwrap().unwrap(); // check the correct types come back as expected - assert_eq!(vec![1, 2], row.get_checked::<_, Vec>(0).unwrap()); - assert_eq!("text", row.get_checked::<_, String>(1).unwrap()); - assert_eq!(1, row.get_checked::<_, c_int>(2).unwrap()); - assert!((1.5 - row.get_checked::<_, c_double>(3).unwrap()).abs() < EPSILON); - assert!(row.get_checked::<_, Option>(4).unwrap().is_none()); - assert!(row.get_checked::<_, Option>(4).unwrap().is_none()); - assert!(row.get_checked::<_, Option>(4).unwrap().is_none()); + assert_eq!(vec![1, 2], row.get::<_, Vec>(0).unwrap()); + assert_eq!("text", row.get::<_, String>(1).unwrap()); + assert_eq!(1, row.get::<_, c_int>(2).unwrap()); + assert!((1.5 - row.get::<_, c_double>(3).unwrap()).abs() < EPSILON); + assert!(row.get::<_, Option>(4).unwrap().is_none()); + assert!(row.get::<_, Option>(4).unwrap().is_none()); + assert!(row.get::<_, Option>(4).unwrap().is_none()); // check some invalid types // 0 is actually a blob (Vec) assert!(is_invalid_column_type( - row.get_checked::<_, c_int>(0).err().unwrap() + row.get::<_, c_int>(0).err().unwrap() )); assert!(is_invalid_column_type( - row.get_checked::<_, c_int>(0).err().unwrap() + row.get::<_, c_int>(0).err().unwrap() + )); + assert!(is_invalid_column_type(row.get::<_, i64>(0).err().unwrap())); + assert!(is_invalid_column_type( + row.get::<_, c_double>(0).err().unwrap() )); assert!(is_invalid_column_type( - row.get_checked::<_, i64>(0).err().unwrap() + row.get::<_, String>(0).err().unwrap() )); assert!(is_invalid_column_type( - row.get_checked::<_, c_double>(0).err().unwrap() + row.get::<_, time::Timespec>(0).err().unwrap() )); assert!(is_invalid_column_type( - row.get_checked::<_, String>(0).err().unwrap() - )); - assert!(is_invalid_column_type( - row.get_checked::<_, time::Timespec>(0).err().unwrap() - )); - assert!(is_invalid_column_type( - row.get_checked::<_, Option>(0).err().unwrap() + row.get::<_, Option>(0).err().unwrap() )); // 1 is actually a text (String) assert!(is_invalid_column_type( - row.get_checked::<_, c_int>(1).err().unwrap() + row.get::<_, c_int>(1).err().unwrap() + )); + assert!(is_invalid_column_type(row.get::<_, i64>(1).err().unwrap())); + assert!(is_invalid_column_type( + row.get::<_, c_double>(1).err().unwrap() )); assert!(is_invalid_column_type( - row.get_checked::<_, i64>(1).err().unwrap() + row.get::<_, Vec>(1).err().unwrap() )); assert!(is_invalid_column_type( - row.get_checked::<_, c_double>(1).err().unwrap() - )); - assert!(is_invalid_column_type( - row.get_checked::<_, Vec>(1).err().unwrap() - )); - assert!(is_invalid_column_type( - row.get_checked::<_, Option>(1).err().unwrap() + row.get::<_, Option>(1).err().unwrap() )); // 2 is actually an integer assert!(is_invalid_column_type( - row.get_checked::<_, String>(2).err().unwrap() + row.get::<_, String>(2).err().unwrap() )); assert!(is_invalid_column_type( - row.get_checked::<_, Vec>(2).err().unwrap() + row.get::<_, Vec>(2).err().unwrap() )); assert!(is_invalid_column_type( - row.get_checked::<_, Option>(2).err().unwrap() + row.get::<_, Option>(2).err().unwrap() )); // 3 is actually a float (c_double) assert!(is_invalid_column_type( - row.get_checked::<_, c_int>(3).err().unwrap() + row.get::<_, c_int>(3).err().unwrap() + )); + assert!(is_invalid_column_type(row.get::<_, i64>(3).err().unwrap())); + assert!(is_invalid_column_type( + row.get::<_, String>(3).err().unwrap() )); assert!(is_invalid_column_type( - row.get_checked::<_, i64>(3).err().unwrap() + row.get::<_, Vec>(3).err().unwrap() )); assert!(is_invalid_column_type( - row.get_checked::<_, String>(3).err().unwrap() - )); - assert!(is_invalid_column_type( - row.get_checked::<_, Vec>(3).err().unwrap() - )); - assert!(is_invalid_column_type( - row.get_checked::<_, Option>(3).err().unwrap() + row.get::<_, Option>(3).err().unwrap() )); // 4 is actually NULL assert!(is_invalid_column_type( - row.get_checked::<_, c_int>(4).err().unwrap() + row.get::<_, c_int>(4).err().unwrap() + )); + assert!(is_invalid_column_type(row.get::<_, i64>(4).err().unwrap())); + assert!(is_invalid_column_type( + row.get::<_, c_double>(4).err().unwrap() )); assert!(is_invalid_column_type( - row.get_checked::<_, i64>(4).err().unwrap() + row.get::<_, String>(4).err().unwrap() )); assert!(is_invalid_column_type( - row.get_checked::<_, c_double>(4).err().unwrap() + row.get::<_, Vec>(4).err().unwrap() )); assert!(is_invalid_column_type( - row.get_checked::<_, String>(4).err().unwrap() - )); - assert!(is_invalid_column_type( - row.get_checked::<_, Vec>(4).err().unwrap() - )); - assert!(is_invalid_column_type( - row.get_checked::<_, time::Timespec>(4).err().unwrap() + row.get::<_, time::Timespec>(4).err().unwrap() )); } @@ -360,19 +352,16 @@ mod test { let mut rows = stmt.query(NO_PARAMS).unwrap(); let row = rows.next().unwrap().unwrap(); - assert_eq!( - Value::Blob(vec![1, 2]), - row.get_checked::<_, Value>(0).unwrap() - ); + assert_eq!(Value::Blob(vec![1, 2]), row.get::<_, Value>(0).unwrap()); assert_eq!( Value::Text(String::from("text")), - row.get_checked::<_, Value>(1).unwrap() + row.get::<_, Value>(1).unwrap() ); - assert_eq!(Value::Integer(1), row.get_checked::<_, Value>(2).unwrap()); - match row.get_checked::<_, Value>(3).unwrap() { + assert_eq!(Value::Integer(1), row.get::<_, Value>(2).unwrap()); + match row.get::<_, Value>(3).unwrap() { Value::Real(val) => assert!((1.5 - val).abs() < EPSILON), x => panic!("Invalid Value {:?}", x), } - assert_eq!(Value::Null, row.get_checked::<_, Value>(4).unwrap()); + assert_eq!(Value::Null, row.get::<_, Value>(4).unwrap()); } } diff --git a/src/types/to_sql.rs b/src/types/to_sql.rs index 0d9a21d..ed5da10 100644 --- a/src/types/to_sql.rs +++ b/src/types/to_sql.rs @@ -229,7 +229,7 @@ mod test { let res = stmt .query_map(NO_PARAMS, |row| { - (row.get::<_, i128>(0), row.get::<_, String>(1)) + Ok((row.get::<_, i128>(0)?, row.get::<_, String>(1)?)) }) .unwrap() .collect::, _>>() diff --git a/src/vtab/csvtab.rs b/src/vtab/csvtab.rs index 67659f3..8e733f4 100644 --- a/src/vtab/csvtab.rs +++ b/src/vtab/csvtab.rs @@ -389,7 +389,7 @@ mod test { let mut rows = s.query(NO_PARAMS).unwrap(); let row = rows.next().unwrap().unwrap(); - assert_eq!(row.get::<_, i32>(0), 2); + assert_eq!(row.get_unwrap::<_, i32>(0), 2); } db.execute_batch("DROP TABLE vtab").unwrap(); }