From f04047db01bfd46aa6b672ebfafd85c1971838b7 Mon Sep 17 00:00:00 2001 From: gwenn Date: Tue, 30 Oct 2018 20:11:35 +0100 Subject: [PATCH 1/3] Rust 2018 --- Cargo.toml | 1 + libsqlite3-sys/Cargo.toml | 1 + src/backup.rs | 32 ++++++++-------- src/blob.rs | 14 +++---- src/busy.rs | 6 +-- src/cache.rs | 14 +++---- src/context.rs | 12 +++--- src/error.rs | 4 +- src/functions.rs | 50 ++++++++++++------------- src/hooks.rs | 6 +-- src/lib.rs | 74 ++++++++++++++++++------------------- src/limits.rs | 14 +++---- src/load_extension_guard.rs | 4 +- src/row.rs | 4 +- src/statement.rs | 72 ++++++++++++++++++------------------ src/trace.rs | 6 +-- src/transaction.rs | 34 ++++++++--------- src/types/chrono.rs | 10 ++--- src/types/from_sql.rs | 2 +- src/types/mod.rs | 2 +- src/types/serde_json.rs | 8 ++-- src/types/time.rs | 6 +-- src/types/to_sql.rs | 6 +-- src/types/value_ref.rs | 2 +- src/unlock_notify.rs | 4 +- src/version.rs | 2 +- src/vtab/array.rs | 16 ++++---- src/vtab/csvtab.rs | 28 +++++++------- src/vtab/mod.rs | 16 ++++---- src/vtab/series.rs | 20 +++++----- 30 files changed, 236 insertions(+), 234 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 3d2068e..94abf17 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,6 +2,7 @@ name = "rusqlite" version = "0.15.0" authors = ["John Gallagher "] +edition = "2018" description = "Ergonomic wrapper for SQLite" repository = "https://github.com/jgallagher/rusqlite" documentation = "http://docs.rs/rusqlite/" diff --git a/libsqlite3-sys/Cargo.toml b/libsqlite3-sys/Cargo.toml index c8cdbf7..476984f 100644 --- a/libsqlite3-sys/Cargo.toml +++ b/libsqlite3-sys/Cargo.toml @@ -2,6 +2,7 @@ name = "libsqlite3-sys" version = "0.10.0" authors = ["John Gallagher "] +edition = "2018" repository = "https://github.com/jgallagher/rusqlite" description = "Native bindings to the libsqlite3 library" license = "MIT" diff --git a/src/backup.rs b/src/backup.rs index e3646e8..40e2e7c 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -23,8 +23,8 @@ //! dst: P, //! progress: fn(backup::Progress), //! ) -> Result<()> { -//! let mut dst = try!(Connection::open(dst)); -//! let backup = try!(backup::Backup::new(src, &mut dst)); +//! let mut dst = Connection::open(dst)?; +//! let backup = backup::Backup::new(src, &mut dst)?; //! backup.run_to_completion(5, time::Duration::from_millis(250), Some(progress)) //! } //! ``` @@ -37,10 +37,10 @@ use std::os::raw::c_int; use std::thread; use std::time::Duration; -use ffi; +use crate::ffi; -use error::{error_from_handle, error_from_sqlite_code}; -use {Connection, DatabaseName, Result}; +use crate::error::{error_from_handle, error_from_sqlite_code}; +use crate::{Connection, DatabaseName, Result}; impl Connection { /// Back up the `name` database to the given destination path. @@ -62,17 +62,17 @@ impl Connection { progress: Option, ) -> Result<()> { use self::StepResult::{Busy, Done, Locked, More}; - let mut dst = try!(Connection::open(dst_path)); - let backup = try!(Backup::new_with_names( + let mut dst = Connection::open(dst_path)?; + let backup = Backup::new_with_names( self, name, &mut dst, DatabaseName::Main - )); + )?; let mut r = More; while r == More { - r = try!(backup.step(100)); + r = backup.step(100)?; if let Some(f) = progress { f(backup.progress()); } @@ -105,13 +105,13 @@ impl Connection { progress: Option, ) -> Result<()> { use self::StepResult::{Busy, Done, Locked, More}; - let src = try!(Connection::open(src_path)); - let restore = try!(Backup::new_with_names(&src, DatabaseName::Main, self, name)); + let src = Connection::open(src_path)?; + let restore = Backup::new_with_names(&src, DatabaseName::Main, self, name)?; let mut r = More; let mut busy_count = 0i32; 'restore_loop: while r == More || r == Busy { - r = try!(restore.step(100)); + r = restore.step(100)?; if let Some(ref f) = progress { f(restore.progress()); } @@ -201,8 +201,8 @@ impl<'a, 'b> Backup<'a, 'b> { to: &'b mut Connection, to_name: DatabaseName, ) -> Result> { - let to_name = try!(to_name.to_cstring()); - let from_name = try!(from_name.to_cstring()); + let to_name = to_name.to_cstring()?; + let from_name = from_name.to_cstring()?; let to_db = to.db.borrow_mut().db; @@ -287,7 +287,7 @@ impl<'a, 'b> Backup<'a, 'b> { assert!(pages_per_step > 0, "pages_per_step must be positive"); loop { - let r = try!(self.step(pages_per_step)); + let r = self.step(pages_per_step)?; if let Some(progress) = progress { progress(self.progress()) } @@ -309,7 +309,7 @@ impl<'a, 'b> Drop for Backup<'a, 'b> { mod test { use super::Backup; use std::time::Duration; - use {Connection, DatabaseName, NO_PARAMS}; + use crate::{Connection, DatabaseName, NO_PARAMS}; #[test] fn test_backup() { diff --git a/src/blob.rs b/src/blob.rs index 8ed630a..e2263bf 100644 --- a/src/blob.rs +++ b/src/blob.rs @@ -64,7 +64,7 @@ use std::ptr; use super::ffi; use super::types::{ToSql, ToSqlOutput}; -use {Connection, DatabaseName, Result}; +use crate::{Connection, DatabaseName, Result}; /// Handle to an open BLOB. pub struct Blob<'conn> { @@ -92,9 +92,9 @@ impl Connection { ) -> Result> { let mut c = self.db.borrow_mut(); let mut blob = ptr::null_mut(); - let db = try!(db.to_cstring()); - let table = try!(super::str_to_cstring(table)); - let column = try!(super::str_to_cstring(column)); + let db = db.to_cstring()?; + let table = super::str_to_cstring(table)?; + let column = super::str_to_cstring(column)?; let rc = unsafe { ffi::sqlite3_blob_open( c.db(), @@ -263,15 +263,15 @@ impl ToSql for ZeroBlob { #[cfg(test)] mod test { use std::io::{BufRead, BufReader, BufWriter, Read, Seek, SeekFrom, Write}; - use {Connection, DatabaseName, Result}; + use crate::{Connection, DatabaseName, Result}; fn db_with_test_blob() -> Result<(Connection, i64)> { - let db = try!(Connection::open_in_memory()); + let db = Connection::open_in_memory()?; let sql = "BEGIN; CREATE TABLE test (content BLOB); INSERT INTO test VALUES (ZEROBLOB(10)); END;"; - try!(db.execute_batch(sql)); + db.execute_batch(sql)?; let rowid = db.last_insert_rowid(); Ok((db, rowid)) } diff --git a/src/busy.rs b/src/busy.rs index 84a810b..dc7a889 100644 --- a/src/busy.rs +++ b/src/busy.rs @@ -4,8 +4,8 @@ use std::os::raw::{c_int, c_void}; use std::ptr; use std::time::Duration; -use ffi; -use {Connection, InnerConnection, Result}; +use crate::ffi; +use crate::{Connection, InnerConnection, Result}; impl Connection { /// Set a busy handler that sleeps for a specified amount of time when a @@ -81,7 +81,7 @@ mod test { use std::thread; use std::time::Duration; - use {Connection, Error, ErrorCode, TransactionBehavior, NO_PARAMS}; + use crate::{Connection, Error, ErrorCode, TransactionBehavior, NO_PARAMS}; #[test] fn test_default_busy() { diff --git a/src/cache.rs b/src/cache.rs index 075bc6e..6d56c31 100644 --- a/src/cache.rs +++ b/src/cache.rs @@ -1,10 +1,10 @@ //! Prepared statements cache for faster execution. use lru_cache::LruCache; -use raw_statement::RawStatement; +use crate::raw_statement::RawStatement; use std::cell::RefCell; use std::ops::{Deref, DerefMut}; -use {Connection, Result, Statement}; +use crate::{Connection, Result, Statement}; impl Connection { /// Prepare a SQL statement for execution, returning a previously prepared @@ -16,14 +16,14 @@ impl Connection { /// # use rusqlite::{Connection, Result}; /// fn insert_new_people(conn: &Connection) -> Result<()> { /// { - /// let mut stmt = try!(conn.prepare_cached("INSERT INTO People (name) VALUES (?)")); - /// try!(stmt.execute(&["Joe Smith"])); + /// let mut stmt = conn.prepare_cached("INSERT INTO People (name) VALUES (?)")?; + /// stmt.execute(&["Joe Smith"])?; /// } /// { /// // This will return the same underlying SQLite statement handle without /// // having to prepare it again. - /// let mut stmt = try!(conn.prepare_cached("INSERT INTO People (name) VALUES (?)")); - /// try!(stmt.execute(&["Bob Jones"])); + /// let mut stmt = conn.prepare_cached("INSERT INTO People (name) VALUES (?)")?; + /// stmt.execute(&["Bob Jones"])?; /// } /// Ok(()) /// } @@ -152,7 +152,7 @@ impl StatementCache { #[cfg(test)] mod test { use super::StatementCache; - use {Connection, NO_PARAMS}; + use crate::{Connection, NO_PARAMS}; impl StatementCache { fn clear(&self) { diff --git a/src/context.rs b/src/context.rs index e4ce95a..9834a7d 100644 --- a/src/context.rs +++ b/src/context.rs @@ -5,14 +5,14 @@ use std::os::raw::{c_char, c_int, c_void}; #[cfg(feature = "array")] use std::rc::Rc; -use ffi; -use ffi::sqlite3_context; -use ffi::sqlite3_value; +use crate::ffi; +use crate::ffi::sqlite3_context; +use crate::ffi::sqlite3_value; -use str_to_cstring; -use types::{ToSqlOutput, ValueRef}; +use crate::str_to_cstring; +use crate::types::{ToSqlOutput, ValueRef}; #[cfg(feature = "array")] -use vtab::array::{free_array, ARRAY_TYPE}; +use crate::vtab::array::{free_array, ARRAY_TYPE}; impl<'a> ValueRef<'a> { pub(crate) unsafe fn from_value(value: *mut sqlite3_value) -> ValueRef<'a> { diff --git a/src/error.rs b/src/error.rs index 27674f8..0b36443 100644 --- a/src/error.rs +++ b/src/error.rs @@ -3,8 +3,8 @@ use std::fmt; use std::os::raw::c_int; use std::path::PathBuf; use std::str; -use types::Type; -use {errmsg_to_string, ffi}; +use crate::types::Type; +use crate::{errmsg_to_string, ffi}; /// Old name for `Error`. `SqliteError` is deprecated. #[deprecated(since = "0.6.0", note = "Use Error instead")] diff --git a/src/functions.rs b/src/functions.rs index b8cc4f0..5e141a4 100644 --- a/src/functions.rs +++ b/src/functions.rs @@ -20,7 +20,7 @@ //! fn add_regexp_function(db: &Connection) -> Result<()> { //! let mut cached_regexes = HashMap::new(); //! db.create_scalar_function("regexp", 2, true, move |ctx| { -//! let regex_s = try!(ctx.get::(0)); +//! let regex_s = ctx.get::(0)?; //! let entry = cached_regexes.entry(regex_s.clone()); //! let regex = { //! use std::collections::hash_map::Entry::{Occupied, Vacant}; @@ -33,7 +33,7 @@ //! } //! }; //! -//! let text = try!(ctx.get::(1)); +//! let text = ctx.get::(1)?; //! Ok(regex.is_match(&text)) //! }) //! } @@ -58,14 +58,14 @@ use std::os::raw::{c_int, c_void}; use std::ptr; use std::slice; -use ffi; -use ffi::sqlite3_context; -use ffi::sqlite3_value; +use crate::ffi; +use crate::ffi::sqlite3_context; +use crate::ffi::sqlite3_value; -use context::set_result; -use types::{FromSql, FromSqlError, ToSql, ValueRef}; +use crate::context::set_result; +use crate::types::{FromSql, FromSqlError, ToSql, ValueRef}; -use {str_to_cstring, Connection, Error, InnerConnection, Result}; +use crate::{str_to_cstring, Connection, Error, InnerConnection, Result}; unsafe fn report_error(ctx: *mut sqlite3_context, err: &Error) { // Extended constraint error codes were added in SQLite 3.7.16. We don't have @@ -198,14 +198,14 @@ where /// "step" function called once for each row in an aggregate group. May be /// called 0 times if there are no rows. - fn step(&self, &mut Context, &mut A) -> Result<()>; + fn step(&self, _: &mut Context, _: &mut A) -> Result<()>; /// Computes and returns the final result. Will be called exactly once for /// each invocation of the function. If `step()` was called at least /// once, will be given `Some(A)` (the same `A` as was created by /// `init` and given to `step`); if `step()` was not called (because /// the function is running against 0 rows), will be given `None`. - fn finalize(&self, Option) -> Result; + fn finalize(&self, _: Option) -> Result; } impl Connection { @@ -224,12 +224,12 @@ impl Connection { /// ```rust /// # use rusqlite::{Connection, Result, NO_PARAMS}; /// fn scalar_function_example(db: Connection) -> Result<()> { - /// try!(db.create_scalar_function("halve", 1, true, |ctx| { - /// let value = try!(ctx.get::(0)); + /// db.create_scalar_function("halve", 1, true, |ctx| { + /// let value = ctx.get::(0)?; /// Ok(value / 2f64) - /// })); + /// })?; /// - /// let six_halved: f64 = try!(db.query_row("SELECT halve(6)", NO_PARAMS, |r| r.get(0))); + /// let six_halved: f64 = db.query_row("SELECT halve(6)", NO_PARAMS, |r| r.get(0))?; /// assert_eq!(six_halved, 3f64); /// Ok(()) /// } @@ -326,7 +326,7 @@ impl InnerConnection { } let boxed_f: *mut F = Box::into_raw(Box::new(x_func)); - let c_name = try!(str_to_cstring(fn_name)); + let c_name = str_to_cstring(fn_name)?; let mut flags = ffi::SQLITE_UTF8; if deterministic { flags |= ffi::SQLITE_DETERMINISTIC; @@ -441,7 +441,7 @@ impl InnerConnection { } let boxed_aggr: *mut D = Box::into_raw(Box::new(aggr)); - let c_name = try!(str_to_cstring(fn_name)); + let c_name = str_to_cstring(fn_name)?; let mut flags = ffi::SQLITE_UTF8; if deterministic { flags |= ffi::SQLITE_DETERMINISTIC; @@ -463,7 +463,7 @@ impl InnerConnection { } fn remove_function(&mut self, fn_name: &str, n_arg: c_int) -> Result<()> { - let c_name = try!(str_to_cstring(fn_name)); + let c_name = str_to_cstring(fn_name)?; let r = unsafe { ffi::sqlite3_create_function_v2( self.db(), @@ -490,12 +490,12 @@ mod test { use std::f64::EPSILON; use std::os::raw::c_double; - use functions::{Aggregate, Context}; - use {Connection, Error, Result, NO_PARAMS}; + use crate::functions::{Aggregate, Context}; + use crate::{Connection, Error, Result, NO_PARAMS}; fn half(ctx: &Context) -> Result { assert!(ctx.len() == 1, "called with unexpected number of arguments"); - let value = try!(ctx.get::(0)); + let value = ctx.get::(0)?; Ok(value / 2f64) } @@ -529,7 +529,7 @@ mod test { let saved_re: Option<&Regex> = unsafe { ctx.get_aux(0) }; let new_re = match saved_re { None => { - let s = try!(ctx.get::(0)); + let s = ctx.get::(0)?; match Regex::new(&s) { Ok(r) => Some(r), Err(err) => return Err(Error::UserFunctionError(Box::new(err))), @@ -607,7 +607,7 @@ mod test { db.create_scalar_function("regexp", 2, true, move |ctx| { assert!(ctx.len() == 2, "called with unexpected number of arguments"); - let regex_s = try!(ctx.get::(0)); + let regex_s = ctx.get::(0)?; let entry = cached_regexes.entry(regex_s.clone()); let regex = { use std::collections::hash_map::Entry::{Occupied, Vacant}; @@ -620,7 +620,7 @@ mod test { } }; - let text = try!(ctx.get::(1)); + let text = ctx.get::(1)?; Ok(regex.is_match(&text)) }) .unwrap(); @@ -648,7 +648,7 @@ mod test { let mut ret = String::new(); for idx in 0..ctx.len() { - let s = try!(ctx.get::(idx)); + let s = ctx.get::(idx)?; ret.push_str(&s); } @@ -675,7 +675,7 @@ mod test { } fn step(&self, ctx: &mut Context, sum: &mut i64) -> Result<()> { - *sum += try!(ctx.get::(0)); + *sum += ctx.get::(0)?; Ok(()) } diff --git a/src/hooks.rs b/src/hooks.rs index c36b313..8478b79 100644 --- a/src/hooks.rs +++ b/src/hooks.rs @@ -4,9 +4,9 @@ use std::os::raw::{c_char, c_int, c_void}; use std::ptr; -use ffi; +use crate::ffi; -use {Connection, InnerConnection}; +use crate::{Connection, InnerConnection}; /// Authorizer Action Codes #[derive(Debug, PartialEq)] @@ -290,7 +290,7 @@ fn free_boxed_hook(p: *mut c_void) { mod test { use super::Action; use std::sync::atomic::{AtomicBool, Ordering}; - use Connection; + use crate::Connection; #[test] fn test_commit_hook() { diff --git a/src/lib.rs b/src/lib.rs index 3448f87..c2ef16a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -88,32 +88,32 @@ use std::str; use std::sync::atomic::{AtomicBool, Ordering, ATOMIC_BOOL_INIT}; use std::sync::{Arc, Mutex, Once, ONCE_INIT}; -use cache::StatementCache; -use error::{error_from_handle, error_from_sqlite_code}; -use raw_statement::RawStatement; -use types::{ToSql, ValueRef}; +use crate::cache::StatementCache; +use crate::error::{error_from_handle, error_from_sqlite_code}; +use crate::raw_statement::RawStatement; +use crate::types::{ToSql, ValueRef}; -pub use statement::Statement; +pub use crate::statement::Statement; -pub use row::{AndThenRows, MappedRows, Row, RowIndex, Rows}; +pub use crate::row::{AndThenRows, MappedRows, Row, RowIndex, Rows}; -pub use transaction::{DropBehavior, Savepoint, Transaction, TransactionBehavior}; +pub use crate::transaction::{DropBehavior, Savepoint, Transaction, TransactionBehavior}; #[allow(deprecated)] -pub use transaction::{SqliteTransaction, SqliteTransactionBehavior}; +pub use crate::transaction::{SqliteTransaction, SqliteTransactionBehavior}; -pub use error::Error; +pub use crate::error::Error; #[allow(deprecated)] -pub use error::SqliteError; -pub use ffi::ErrorCode; +pub use crate::error::SqliteError; +pub use crate::ffi::ErrorCode; -pub use cache::CachedStatement; -pub use version::*; +pub use crate::cache::CachedStatement; +pub use crate::version::*; #[cfg(feature = "hooks")] -pub use hooks::*; +pub use crate::hooks::*; #[cfg(feature = "load_extension")] #[allow(deprecated)] -pub use load_extension_guard::{LoadExtensionGuard, SqliteLoadExtensionGuard}; +pub use crate::load_extension_guard::{LoadExtensionGuard, SqliteLoadExtensionGuard}; #[cfg(feature = "backup")] pub mod backup; @@ -162,11 +162,11 @@ unsafe fn errmsg_to_string(errmsg: *const c_char) -> String { } fn str_to_cstring(s: &str) -> Result { - Ok(try!(CString::new(s))) + Ok(CString::new(s)?) } fn path_to_cstring(p: &Path) -> Result { - let s = try!(p.to_str().ok_or_else(|| Error::InvalidPath(p.to_owned()))); + let s = p.to_str().ok_or_else(|| Error::InvalidPath(p.to_owned()))?; str_to_cstring(s) } @@ -253,7 +253,7 @@ 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())); + let c_path = path_to_cstring(path.as_ref())?; InnerConnection::open_with_flags(&c_path, flags).map(|db| Connection { db: RefCell::new(db), cache: StatementCache::with_capacity(STATEMENT_CACHE_DEFAULT_CAPACITY), @@ -270,7 +270,7 @@ impl Connection { /// /// Will return `Err` if the underlying SQLite open call fails. pub fn open_in_memory_with_flags(flags: OpenFlags) -> Result { - let c_memory = try!(str_to_cstring(":memory:")); + let c_memory = str_to_cstring(":memory:")?; InnerConnection::open_with_flags(&c_memory, flags).map(|db| Connection { db: RefCell::new(db), cache: StatementCache::with_capacity(STATEMENT_CACHE_DEFAULT_CAPACITY), @@ -398,7 +398,7 @@ impl Connection { P::Item: ToSql, F: FnOnce(&Row) -> T, { - let mut stmt = try!(self.prepare(sql)); + let mut stmt = self.prepare(sql)?; stmt.query_row(params, f) } @@ -416,8 +416,8 @@ impl Connection { where F: FnOnce(&Row) -> T, { - let mut stmt = try!(self.prepare(sql)); - let mut rows = try!(stmt.query_named(params)); + let mut stmt = self.prepare(sql)?; + let mut rows = stmt.query_named(params)?; rows.get_expected_row().map(|r| f(&r)) } @@ -454,8 +454,8 @@ impl Connection { F: FnOnce(&Row) -> result::Result, E: convert::From, { - let mut stmt = try!(self.prepare(sql)); - let mut rows = try!(stmt.query(params)); + let mut stmt = self.prepare(sql)?; + let mut rows = stmt.query(params)?; rows.get_expected_row().map_err(E::from).and_then(|r| f(&r)) } @@ -467,9 +467,9 @@ impl Connection { /// ```rust,no_run /// # use rusqlite::{Connection, Result}; /// fn insert_new_people(conn: &Connection) -> Result<()> { - /// let mut stmt = try!(conn.prepare("INSERT INTO People (name) VALUES (?)")); - /// try!(stmt.execute(&["Joe Smith"])); - /// try!(stmt.execute(&["Bob Jones"])); + /// let mut stmt = conn.prepare("INSERT INTO People (name) VALUES (?)")?; + /// stmt.execute(&["Joe Smith"])?; + /// stmt.execute(&["Bob Jones"])?; /// Ok(()) /// } /// ``` @@ -506,8 +506,8 @@ impl Connection { /// # use rusqlite::{Connection, Result}; /// # use std::path::{Path}; /// fn load_my_extension(conn: &Connection) -> Result<()> { - /// try!(conn.load_extension_enable()); - /// try!(conn.load_extension(Path::new("my_sqlite_extension"), None)); + /// conn.load_extension_enable()?; + /// conn.load_extension(Path::new("my_sqlite_extension"), None)?; /// conn.load_extension_disable() /// } /// ``` @@ -546,7 +546,7 @@ impl Connection { /// # use rusqlite::{Connection, Result, LoadExtensionGuard}; /// # use std::path::{Path}; /// fn load_my_extension(conn: &Connection) -> Result<()> { - /// let _guard = try!(LoadExtensionGuard::new(conn)); + /// let _guard = LoadExtensionGuard::new(conn)?; /// /// conn.load_extension("my_sqlite_extension", None) /// } @@ -817,7 +817,7 @@ impl InnerConnection { #[cfg(feature = "hooks")] fn new(db: *mut ffi::sqlite3) -> InnerConnection { InnerConnection { - db: db, + db, interrupt_lock: Arc::new(Mutex::new(db)), free_commit_hook: None, free_rollback_hook: None, @@ -919,7 +919,7 @@ impl InnerConnection { } fn execute_batch(&mut self, sql: &str) -> Result<()> { - let c_sql = try!(str_to_cstring(sql)); + let c_sql = str_to_cstring(sql)?; unsafe { let r = ffi::sqlite3_exec( self.db(), @@ -940,11 +940,11 @@ impl InnerConnection { #[cfg(feature = "load_extension")] fn load_extension(&self, dylib_path: &Path, entry_point: Option<&str>) -> Result<()> { - let dylib_str = try!(path_to_cstring(dylib_path)); + let dylib_str = path_to_cstring(dylib_path)?; unsafe { let mut errmsg: *mut c_char = mem::uninitialized(); let r = if let Some(entry_point) = entry_point { - let c_entry = try!(str_to_cstring(entry_point)); + let c_entry = str_to_cstring(entry_point)?; ffi::sqlite3_load_extension( self.db, dylib_str.as_ptr(), @@ -973,7 +973,7 @@ impl InnerConnection { 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 c_sql = str_to_cstring(sql)?; let len_with_nul = (sql.len() + 1) as c_int; let r = unsafe { if cfg!(feature = "unlock_notify") { @@ -1087,7 +1087,7 @@ mod test { extern crate tempdir; use self::tempdir::TempDir; pub use super::*; - use ffi; + use crate::ffi; pub use std::error::Error as StdError; pub use std::fmt; @@ -1578,7 +1578,7 @@ mod test { let i_to_insert = i as i64; assert_eq!( insert_stmt - .execute(&[&i_to_insert as &dyn ToSql, &v]) + .execute(&[&i_to_insert as &ToSql, &v]) .unwrap(), 1 ); diff --git a/src/limits.rs b/src/limits.rs index d8fc2b0..cbe9beb 100644 --- a/src/limits.rs +++ b/src/limits.rs @@ -2,10 +2,10 @@ use std::os::raw::c_int; -use ffi; -pub use ffi::Limit; +use crate::ffi; +pub use crate::ffi::Limit; -use Connection; +use crate::Connection; impl Connection { /// Returns the current value of a limit. @@ -23,8 +23,8 @@ impl Connection { #[cfg(test)] mod test { - use ffi::Limit; - use Connection; + use crate::ffi::Limit; + use crate::Connection; #[test] fn test_limit() { @@ -57,13 +57,13 @@ mod test { assert_eq!(99, db.limit(Limit::SQLITE_LIMIT_VARIABLE_NUMBER)); // SQLITE_LIMIT_TRIGGER_DEPTH was added in SQLite 3.6.18. - if ::version_number() >= 3006018 { + if crate::version_number() >= 3006018 { db.set_limit(Limit::SQLITE_LIMIT_TRIGGER_DEPTH, 32); assert_eq!(32, db.limit(Limit::SQLITE_LIMIT_TRIGGER_DEPTH)); } // SQLITE_LIMIT_WORKER_THREADS was added in SQLite 3.8.7. - if ::version_number() >= 3008007 { + if crate::version_number() >= 3008007 { db.set_limit(Limit::SQLITE_LIMIT_WORKER_THREADS, 2); assert_eq!(2, db.limit(Limit::SQLITE_LIMIT_WORKER_THREADS)); } diff --git a/src/load_extension_guard.rs b/src/load_extension_guard.rs index 9843fcd..1c9893f 100644 --- a/src/load_extension_guard.rs +++ b/src/load_extension_guard.rs @@ -1,4 +1,4 @@ -use {Connection, Result}; +use crate::{Connection, Result}; /// Old name for `LoadExtensionGuard`. `SqliteLoadExtensionGuard` is deprecated. #[deprecated(since = "0.6.0", note = "Use LoadExtensionGuard instead")] @@ -12,7 +12,7 @@ pub type SqliteLoadExtensionGuard<'conn> = LoadExtensionGuard<'conn>; /// # use rusqlite::{Connection, Result, LoadExtensionGuard}; /// # use std::path::{Path}; /// fn load_my_extension(conn: &Connection) -> Result<()> { -/// let _guard = try!(LoadExtensionGuard::new(conn)); +/// let _guard = LoadExtensionGuard::new(conn)?; /// /// conn.load_extension(Path::new("my_sqlite_extension"), None) /// } diff --git a/src/row.rs b/src/row.rs index 095eaee..b1911e6 100644 --- a/src/row.rs +++ b/src/row.rs @@ -2,7 +2,7 @@ use std::marker::PhantomData; use std::{convert, result}; use super::{Error, Result, Statement}; -use types::{FromSql, FromSqlError, ValueRef}; +use crate::types::{FromSql, FromSqlError, ValueRef}; /// An handle for the resulting rows of a query. pub struct Rows<'stmt> { @@ -165,7 +165,7 @@ impl<'a, 'stmt> Row<'a, 'stmt> { /// 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 { - let idx = try!(idx.idx(self.stmt)); + let idx = idx.idx(self.stmt)?; let value = self.stmt.value_ref(idx); FromSql::column_result(value).map_err(|err| match err { FromSqlError::InvalidType => Error::InvalidColumnType(idx, value.data_type()), diff --git a/src/statement.rs b/src/statement.rs index f1c7765..f972c06 100644 --- a/src/statement.rs +++ b/src/statement.rs @@ -11,9 +11,9 @@ use super::str_to_cstring; use super::{ AndThenRows, Connection, Error, MappedRows, RawStatement, Result, Row, Rows, ValueRef, }; -use types::{ToSql, ToSqlOutput}; +use crate::types::{ToSql, ToSqlOutput}; #[cfg(feature = "array")] -use vtab::array::{free_array, ARRAY_TYPE}; +use crate::vtab::array::{free_array, ARRAY_TYPE}; /// A prepared statement. pub struct Statement<'conn> { @@ -70,10 +70,10 @@ impl<'conn> Statement<'conn> { /// ```rust,no_run /// # use rusqlite::{Connection, Result}; /// fn update_rows(conn: &Connection) -> Result<()> { - /// let mut stmt = try!(conn.prepare("UPDATE foo SET bar = 'baz' WHERE qux = ?")); + /// let mut stmt = conn.prepare("UPDATE foo SET bar = 'baz' WHERE qux = ?")?; /// - /// try!(stmt.execute(&[1i32])); - /// try!(stmt.execute(&[2i32])); + /// stmt.execute(&[1i32])?; + /// stmt.execute(&[2i32])?; /// /// Ok(()) /// } @@ -89,7 +89,7 @@ impl<'conn> Statement<'conn> { P: IntoIterator, P::Item: ToSql, { - try!(self.bind_parameters(params)); + self.bind_parameters(params)?; self.execute_with_bound_parameters() } @@ -107,7 +107,7 @@ impl<'conn> Statement<'conn> { /// ```rust,no_run /// # use rusqlite::{Connection, Result}; /// fn insert(conn: &Connection) -> Result { - /// let mut stmt = try!(conn.prepare("INSERT INTO test (name) VALUES (:name)")); + /// let mut stmt = conn.prepare("INSERT INTO test (name) VALUES (:name)")?; /// stmt.execute_named(&[(":name", &"one")]) /// } /// ``` @@ -118,7 +118,7 @@ impl<'conn> Statement<'conn> { /// returns rows (in 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)); + self.bind_parameters_named(params)?; self.execute_with_bound_parameters() } @@ -140,7 +140,7 @@ impl<'conn> Statement<'conn> { P: IntoIterator, P::Item: ToSql, { - let changes = try!(self.execute(params)); + let changes = self.execute(params)?; match changes { 1 => Ok(self.conn.last_insert_rowid()), _ => Err(Error::StatementChangedRows(changes)), @@ -159,12 +159,12 @@ impl<'conn> Statement<'conn> { /// ```rust,no_run /// # use rusqlite::{Connection, Result, NO_PARAMS}; /// fn get_names(conn: &Connection) -> Result> { - /// let mut stmt = try!(conn.prepare("SELECT name FROM people")); - /// let mut rows = try!(stmt.query(NO_PARAMS)); + /// let mut stmt = conn.prepare("SELECT name FROM people")?; + /// let mut rows = stmt.query(NO_PARAMS)?; /// /// let mut names = Vec::new(); /// while let Some(result_row) = rows.next() { - /// let row = try!(result_row); + /// let row = result_row?; /// names.push(row.get(0)); /// } /// @@ -180,8 +180,8 @@ impl<'conn> Statement<'conn> { P: IntoIterator, P::Item: ToSql, { - try!(self.check_readonly()); - try!(self.bind_parameters(params)); + self.check_readonly()?; + self.bind_parameters(params)?; Ok(Rows::new(self)) } @@ -196,8 +196,8 @@ impl<'conn> Statement<'conn> { /// ```rust,no_run /// # use rusqlite::{Connection, Result}; /// fn query(conn: &Connection) -> Result<()> { - /// let mut stmt = try!(conn.prepare("SELECT * FROM test where name = :name")); - /// let mut rows = try!(stmt.query_named(&[(":name", &"one")])); + /// let mut stmt = conn.prepare("SELECT * FROM test where name = :name")?; + /// let mut rows = stmt.query_named(&[(":name", &"one")])?; /// while let Some(row) = rows.next() { /// // ... /// } @@ -209,8 +209,8 @@ impl<'conn> Statement<'conn> { /// /// Will return `Err` if binding parameters fails. pub fn query_named<'a>(&'a mut self, params: &[(&str, &ToSql)]) -> Result> { - try!(self.check_readonly()); - try!(self.bind_parameters_named(params)); + self.check_readonly()?; + self.bind_parameters_named(params)?; Ok(Rows::new(self)) } @@ -222,12 +222,12 @@ impl<'conn> Statement<'conn> { /// ```rust,no_run /// # use rusqlite::{Connection, Result, NO_PARAMS}; /// fn get_names(conn: &Connection) -> Result> { - /// let mut stmt = try!(conn.prepare("SELECT name FROM people")); - /// let rows = try!(stmt.query_map(NO_PARAMS, |row| row.get(0))); + /// let mut stmt = conn.prepare("SELECT name FROM people")?; + /// let rows = stmt.query_map(NO_PARAMS, |row| row.get(0))?; /// /// let mut names = Vec::new(); /// for name_result in rows { - /// names.push(try!(name_result)); + /// names.push(name_result?); /// } /// /// Ok(names) @@ -259,12 +259,12 @@ impl<'conn> Statement<'conn> { /// ```rust,no_run /// # use rusqlite::{Connection, Result}; /// fn get_names(conn: &Connection) -> Result> { - /// let mut stmt = try!(conn.prepare("SELECT name FROM people WHERE id = :id")); - /// let rows = try!(stmt.query_map_named(&[(":id", &"one")], |row| row.get(0))); + /// let mut stmt = conn.prepare("SELECT name FROM people WHERE id = :id")?; + /// let rows = stmt.query_map_named(&[(":id", &"one")], |row| row.get(0))?; /// /// let mut names = Vec::new(); /// for name_result in rows { - /// names.push(try!(name_result)); + /// names.push(name_result?); /// } /// /// Ok(names) @@ -330,13 +330,13 @@ impl<'conn> Statement<'conn> { /// } /// /// fn get_names(conn: &Connection) -> Result> { - /// let mut stmt = try!(conn.prepare("SELECT name FROM people WHERE id = :id")); + /// let mut stmt = conn.prepare("SELECT name FROM people WHERE id = :id")?; /// let rows = - /// try!(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 { - /// persons.push(try!(person_result)); + /// persons.push(person_result?); /// } /// /// Ok(persons) @@ -366,7 +366,7 @@ impl<'conn> Statement<'conn> { P: IntoIterator, P::Item: ToSql, { - let mut rows = try!(self.query(params)); + let mut rows = self.query(params)?; let exists = { match rows.next() { Some(_) => true, @@ -391,7 +391,7 @@ impl<'conn> Statement<'conn> { P::Item: ToSql, F: FnOnce(&Row) -> T, { - let mut rows = try!(self.query(params)); + let mut rows = self.query(params)?; rows.get_expected_row().map(|r| f(&r)) } @@ -415,7 +415,7 @@ impl<'conn> Statement<'conn> { /// Will return Err if `name` is invalid. Will return Ok(None) if the name /// is valid but not a bound parameter of this statement. pub fn parameter_index(&self, name: &str) -> Result> { - let c_name = try!(str_to_cstring(name)); + let c_name = str_to_cstring(name)?; Ok(self.stmt.bind_parameter_index(&c_name)) } @@ -431,7 +431,7 @@ impl<'conn> Statement<'conn> { if index > expected { break; } - try!(self.bind_parameter(&p, index)); + self.bind_parameter(&p, index)?; } assert_eq!( index, expected, @@ -444,8 +444,8 @@ impl<'conn> Statement<'conn> { fn bind_parameters_named(&mut self, params: &[(&str, &ToSql)]) -> Result<()> { for &(name, value) in params { - if let Some(i) = try!(self.parameter_index(name)) { - try!(self.bind_parameter(value, i)); + if let Some(i) = self.parameter_index(name)? { + self.bind_parameter(value, i)?; } else { return Err(Error::InvalidParameterName(name.into())); } @@ -454,7 +454,7 @@ impl<'conn> Statement<'conn> { } fn bind_parameter(&self, param: &ToSql, col: usize) -> Result<()> { - let value = try!(param.to_sql()); + let value = param.to_sql()?; let ptr = unsafe { self.stmt.ptr() }; let value = match value { @@ -489,7 +489,7 @@ impl<'conn> Statement<'conn> { if length > ::std::i32::MAX as usize { ffi::SQLITE_TOOBIG } else { - let c_str = try!(str_to_cstring(s)); + let c_str = str_to_cstring(s)?; let destructor = if length > 0 { ffi::SQLITE_TRANSIENT() } else { @@ -673,7 +673,7 @@ impl<'conn> Statement<'conn> { #[cfg(test)] mod test { - use {Connection, Error, Result, NO_PARAMS}; + use crate::{Connection, Error, Result, NO_PARAMS}; #[test] fn test_execute_named() { diff --git a/src/trace.rs b/src/trace.rs index a11396b..810b8d0 100644 --- a/src/trace.rs +++ b/src/trace.rs @@ -7,8 +7,8 @@ use std::ptr; use std::time::Duration; use super::ffi; -use error::error_from_sqlite_code; -use {Connection, Result}; +use crate::error::error_from_sqlite_code; +use crate::{Connection, Result}; /// Set up the process-wide SQLite error logging callback. /// This function is marked unsafe for two reasons: @@ -124,7 +124,7 @@ mod test { use std::sync::Mutex; use std::time::Duration; - use Connection; + use crate::Connection; #[test] fn test_trace() { diff --git a/src/transaction.rs b/src/transaction.rs index 05dd3d5..a294c22 100644 --- a/src/transaction.rs +++ b/src/transaction.rs @@ -1,5 +1,5 @@ use std::ops::Deref; -use {Connection, Result}; +use crate::{Connection, Result}; /// Old name for `TransactionBehavior`. `SqliteTransactionBehavior` is /// deprecated. @@ -51,10 +51,10 @@ pub type SqliteTransaction<'conn> = Transaction<'conn>; /// # fn do_queries_part_1(_conn: &Connection) -> Result<()> { Ok(()) } /// # fn do_queries_part_2(_conn: &Connection) -> Result<()> { Ok(()) } /// fn perform_queries(conn: &mut Connection) -> Result<()> { -/// let tx = try!(conn.transaction()); +/// let tx = conn.transaction()?; /// -/// try!(do_queries_part_1(&tx)); // tx causes rollback if this fails -/// try!(do_queries_part_2(&tx)); // tx causes rollback if this fails +/// do_queries_part_1(&tx)?; // tx causes rollback if this fails +/// do_queries_part_2(&tx)?; // tx causes rollback if this fails /// /// tx.commit() /// } @@ -79,10 +79,10 @@ pub struct Transaction<'conn> { /// # fn do_queries_part_1(_conn: &Connection) -> Result<()> { Ok(()) } /// # fn do_queries_part_2(_conn: &Connection) -> Result<()> { Ok(()) } /// fn perform_queries(conn: &mut Connection) -> Result<()> { -/// let sp = try!(conn.savepoint()); +/// let sp = conn.savepoint()?; /// -/// try!(do_queries_part_1(&sp)); // sp causes rollback if this fails -/// try!(do_queries_part_2(&sp)); // sp causes rollback if this fails +/// do_queries_part_1(&sp)?; // sp causes rollback if this fails +/// do_queries_part_2(&sp)?; // sp causes rollback if this fails /// /// sp.commit() /// } @@ -127,12 +127,12 @@ impl<'conn> Transaction<'conn> { /// # use rusqlite::{Connection, Result}; /// # fn perform_queries_part_1_succeeds(_conn: &Connection) -> bool { true } /// fn perform_queries(conn: &mut Connection) -> Result<()> { - /// let mut tx = try!(conn.transaction()); + /// let mut tx = conn.transaction()?; /// /// { - /// let sp = try!(tx.savepoint()); + /// let sp = tx.savepoint()?; /// if perform_queries_part_1_succeeds(&sp) { - /// try!(sp.commit()); + /// sp.commit()?; /// } /// // otherwise, sp will rollback /// } @@ -345,10 +345,10 @@ impl Connection { /// # fn do_queries_part_1(_conn: &Connection) -> Result<()> { Ok(()) } /// # fn do_queries_part_2(_conn: &Connection) -> Result<()> { Ok(()) } /// fn perform_queries(conn: &mut Connection) -> Result<()> { - /// let tx = try!(conn.transaction()); + /// let tx = conn.transaction()?; /// - /// try!(do_queries_part_1(&tx)); // tx causes rollback if this fails - /// try!(do_queries_part_2(&tx)); // tx causes rollback if this fails + /// do_queries_part_1(&tx)?; // tx causes rollback if this fails + /// do_queries_part_2(&tx)?; // tx causes rollback if this fails /// /// tx.commit() /// } @@ -388,10 +388,10 @@ impl Connection { /// # fn do_queries_part_1(_conn: &Connection) -> Result<()> { Ok(()) } /// # fn do_queries_part_2(_conn: &Connection) -> Result<()> { Ok(()) } /// fn perform_queries(conn: &mut Connection) -> Result<()> { - /// let sp = try!(conn.savepoint()); + /// let sp = conn.savepoint()?; /// - /// try!(do_queries_part_1(&sp)); // sp causes rollback if this fails - /// try!(do_queries_part_2(&sp)); // sp causes rollback if this fails + /// do_queries_part_1(&sp)?; // sp causes rollback if this fails + /// do_queries_part_2(&sp)?; // sp causes rollback if this fails /// /// sp.commit() /// } @@ -419,7 +419,7 @@ impl Connection { #[cfg(test)] mod test { use super::DropBehavior; - use {Connection, NO_PARAMS}; + use crate::{Connection, NO_PARAMS}; fn checked_memory_handle() -> Connection { let db = Connection::open_in_memory().unwrap(); diff --git a/src/types/chrono.rs b/src/types/chrono.rs index 77f8031..c5fbd41 100644 --- a/src/types/chrono.rs +++ b/src/types/chrono.rs @@ -5,8 +5,8 @@ use std::borrow::Cow; use self::chrono::{DateTime, Local, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc}; -use types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef}; -use Result; +use crate::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef}; +use crate::Result; /// ISO 8601 calendar date without timezone => "YYYY-MM-DD" impl ToSql for NaiveDate { @@ -95,7 +95,7 @@ impl FromSql for DateTime { fn column_result(value: ValueRef) -> FromSqlResult { { // Try to parse value as rfc3339 first. - let s = try!(value.as_str()); + let s = value.as_str()?; // If timestamp looks space-separated, make a copy and replace it with 'T'. let s = if s.len() >= 11 && s.as_bytes()[10] == b' ' { @@ -122,7 +122,7 @@ impl FromSql for DateTime { /// RFC3339 ("YYYY-MM-DDTHH:MM:SS.SSS[+-]HH:MM") into `DateTime`. impl FromSql for DateTime { fn column_result(value: ValueRef) -> FromSqlResult { - let utc_dt = try!(DateTime::::column_result(value)); + let utc_dt = DateTime::::column_result(value)?; Ok(utc_dt.with_timezone(&Local)) } } @@ -132,7 +132,7 @@ mod test { use super::chrono::{ DateTime, Duration, Local, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc, }; - use {Connection, NO_PARAMS}; + use crate::{Connection, NO_PARAMS}; fn checked_memory_handle() -> Connection { let db = Connection::open_in_memory().unwrap(); diff --git a/src/types/from_sql.rs b/src/types/from_sql.rs index 8f7e132..7fa00ac 100644 --- a/src/types/from_sql.rs +++ b/src/types/from_sql.rs @@ -181,7 +181,7 @@ impl FromSql for Value { #[cfg(test)] mod test { use super::FromSql; - use {Connection, Error}; + use crate::{Connection, Error}; fn checked_memory_handle() -> Connection { Connection::open_in_memory().unwrap() diff --git a/src/types/mod.rs b/src/types/mod.rs index 009f865..e39240c 100644 --- a/src/types/mod.rs +++ b/src/types/mod.rs @@ -116,7 +116,7 @@ mod test { use super::Value; use std::f64::EPSILON; use std::os::raw::{c_double, c_int}; - use {Connection, Error, NO_PARAMS}; + use crate::{Connection, Error, NO_PARAMS}; fn checked_memory_handle() -> Connection { let db = Connection::open_in_memory().unwrap(); diff --git a/src/types/serde_json.rs b/src/types/serde_json.rs index dc3fc26..33cc8f6 100644 --- a/src/types/serde_json.rs +++ b/src/types/serde_json.rs @@ -3,8 +3,8 @@ extern crate serde_json; use self::serde_json::Value; -use types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef}; -use Result; +use crate::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef}; +use crate::Result; /// Serialize JSON `Value` to text. impl ToSql for Value { @@ -28,8 +28,8 @@ impl FromSql for Value { #[cfg(test)] mod test { use super::serde_json; - use types::ToSql; - use {Connection, NO_PARAMS}; + use crate::types::ToSql; + use crate::{Connection, NO_PARAMS}; fn checked_memory_handle() -> Connection { let db = Connection::open_in_memory().unwrap(); diff --git a/src/types/time.rs b/src/types/time.rs index 8a5f171..53351d0 100644 --- a/src/types/time.rs +++ b/src/types/time.rs @@ -1,7 +1,7 @@ extern crate time; -use types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef}; -use Result; +use crate::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef}; +use crate::Result; const SQLITE_DATETIME_FMT: &str = "%Y-%m-%dT%H:%M:%S.%fZ"; const SQLITE_DATETIME_FMT_LEGACY: &str = "%Y-%m-%d %H:%M:%S:%f %Z"; @@ -33,7 +33,7 @@ impl FromSql for time::Timespec { #[cfg(test)] mod test { use super::time; - use {Connection, NO_PARAMS}; + use crate::{Connection, NO_PARAMS}; fn checked_memory_handle() -> Connection { let db = Connection::open_in_memory().unwrap(); diff --git a/src/types/to_sql.rs b/src/types/to_sql.rs index 2793ba1..651107b 100644 --- a/src/types/to_sql.rs +++ b/src/types/to_sql.rs @@ -1,8 +1,8 @@ use super::{Null, Value, ValueRef}; use std::borrow::Cow; #[cfg(feature = "array")] -use vtab::array::Array; -use Result; +use crate::vtab::array::Array; +use crate::Result; /// `ToSqlOutput` represents the possible output types for implementors of the /// `ToSql` trait. @@ -208,7 +208,7 @@ mod test { #[test] fn test_i128() { use std::i128; - use {Connection, NO_PARAMS}; + use crate::{Connection, NO_PARAMS}; let db = Connection::open_in_memory().unwrap(); db.execute_batch("CREATE TABLE foo (i128 BLOB, desc TEXT)") .unwrap(); diff --git a/src/types/value_ref.rs b/src/types/value_ref.rs index cd99bb2..50f9b17 100644 --- a/src/types/value_ref.rs +++ b/src/types/value_ref.rs @@ -1,5 +1,5 @@ use super::{Type, Value}; -use types::{FromSqlError, FromSqlResult}; +use crate::types::{FromSqlError, FromSqlResult}; /// A non-owning [dynamic type value](http://sqlite.org/datatype3.html). Typically the /// memory backing this value is owned by SQLite. diff --git a/src/unlock_notify.rs b/src/unlock_notify.rs index c4f2f1f..785f05e 100644 --- a/src/unlock_notify.rs +++ b/src/unlock_notify.rs @@ -6,7 +6,7 @@ use std::os::raw::c_void; #[cfg(feature = "unlock_notify")] use std::sync::{Condvar, Mutex}; -use ffi; +use crate::ffi; #[cfg(feature = "unlock_notify")] struct UnlockNotification { @@ -102,7 +102,7 @@ mod test { use std::sync::mpsc::sync_channel; use std::thread; use std::time; - use {Connection, OpenFlags, Result, Transaction, TransactionBehavior, NO_PARAMS}; + use crate::{Connection, OpenFlags, Result, Transaction, TransactionBehavior, NO_PARAMS}; #[test] fn test_unlock_notify() { diff --git a/src/version.rs b/src/version.rs index 39c7d6b..215900b 100644 --- a/src/version.rs +++ b/src/version.rs @@ -1,4 +1,4 @@ -use ffi; +use crate::ffi; use std::ffi::CStr; /// Returns the SQLite version as an integer; e.g., `3016002` for version diff --git a/src/vtab/array.rs b/src/vtab/array.rs index 23d3aa1..496a8f8 100644 --- a/src/vtab/array.rs +++ b/src/vtab/array.rs @@ -5,13 +5,13 @@ use std::default::Default; use std::os::raw::{c_char, c_int, c_void}; use std::rc::Rc; -use ffi; -use types::{ToSql, ToSqlOutput, Value}; -use vtab::{ +use crate::ffi; +use crate::types::{ToSql, ToSqlOutput, Value}; +use crate::vtab::{ eponymous_only_module, Context, IndexConstraintOp, IndexInfo, Module, VTab, VTabConnection, VTabCursor, Values, }; -use {Connection, Result}; +use crate::{Connection, Result}; // http://sqlite.org/bindptr.html @@ -131,7 +131,7 @@ impl ArrayTabCursor { impl VTabCursor for ArrayTabCursor { fn filter(&mut self, idx_num: c_int, _idx_str: Option<&str>, args: &Values) -> Result<()> { if idx_num > 0 { - self.ptr = try!(args.get_array(0)); + self.ptr = args.get_array(0)?; } else { self.ptr = None; } @@ -170,9 +170,9 @@ impl VTabCursor for ArrayTabCursor { #[cfg(test)] mod test { use std::rc::Rc; - use types::Value; - use vtab::array; - use Connection; + use crate::types::Value; + use crate::vtab::array; + use crate::Connection; #[test] fn test_array_module() { diff --git a/src/vtab/csvtab.rs b/src/vtab/csvtab.rs index 041e57e..c289843 100644 --- a/src/vtab/csvtab.rs +++ b/src/vtab/csvtab.rs @@ -8,13 +8,13 @@ use std::path::Path; use std::result; use std::str; -use ffi; -use types::Null; -use vtab::{ +use crate::ffi; +use crate::types::Null; +use crate::vtab::{ dequote, escape_double_quote, parse_boolean, read_only_module, Context, CreateVTab, IndexInfo, Module, VTab, VTabConnection, VTabCursor, Values, }; -use {Connection, Error, Result}; +use crate::{Connection, Error, Result}; /// Register the "csv" module. /// ```sql @@ -60,7 +60,7 @@ impl CSVTab { } fn parameter(c_slice: &[u8]) -> Result<(&str, &str)> { - let arg = try!(str::from_utf8(c_slice)).trim(); + let arg = str::from_utf8(c_slice)?.trim(); let mut split = arg.split('='); if let Some(key) = split.next() { if let Some(value) = split.next() { @@ -107,7 +107,7 @@ impl VTab for CSVTab { let args = &args[3..]; for c_slice in args { - let (param, value) = try!(CSVTab::parameter(c_slice)); + let (param, value) = CSVTab::parameter(c_slice)?; match param { "filename" => { if !Path::new(value).exists() { @@ -189,10 +189,10 @@ impl VTab for CSVTab { let mut cols: Vec = Vec::new(); if vtab.has_headers || (n_col.is_none() && schema.is_none()) { - let mut reader = try!(vtab.reader()); + let mut reader = vtab.reader()?; if vtab.has_headers { { - let headers = try!(reader.headers()); + let headers = reader.headers()?; // headers ignored if cols is not empty if n_col.is_none() && schema.is_none() { cols = headers @@ -204,7 +204,7 @@ impl VTab for CSVTab { vtab.offset_first_row = reader.position().clone(); } else { let mut record = csv::ByteRecord::new(); - if try!(reader.read_byte_record(&mut record)) { + if reader.read_byte_record(&mut record)? { for (i, _) in record.iter().enumerate() { cols.push(format!("c{}", i)); } @@ -245,7 +245,7 @@ impl VTab for CSVTab { } fn open(&self) -> Result { - Ok(CSVTabCursor::new(try!(self.reader()))) + Ok(CSVTabCursor::new(self.reader()?)) } } @@ -288,7 +288,7 @@ impl VTabCursor for CSVTabCursor { fn filter(&mut self, _idx_num: c_int, _idx_str: Option<&str>, _args: &Values) -> Result<()> { { let offset_first_row = self.vtab().offset_first_row.clone(); - try!(self.reader.seek(offset_first_row)); + self.reader.seek(offset_first_row)?; } self.row_number = 0; self.next() @@ -301,7 +301,7 @@ impl VTabCursor for CSVTabCursor { return Ok(()); } - self.eof = !try!(self.reader.read_record(&mut self.cols)); + self.eof = !self.reader.read_record(&mut self.cols)?; } self.row_number += 1; @@ -340,8 +340,8 @@ impl From for Error { #[cfg(test)] mod test { - use vtab::csvtab; - use {Connection, Result, NO_PARAMS}; + use crate::vtab::csvtab; + use crate::{Connection, Result, NO_PARAMS}; #[test] fn test_csv_module() { diff --git a/src/vtab/mod.rs b/src/vtab/mod.rs index a219198..d719579 100644 --- a/src/vtab/mod.rs +++ b/src/vtab/mod.rs @@ -17,12 +17,12 @@ use std::os::raw::{c_char, c_int, c_void}; use std::ptr; use std::slice; -use context::set_result; -use error::error_from_sqlite_code; -use ffi; -pub use ffi::{sqlite3_vtab, sqlite3_vtab_cursor}; -use types::{FromSql, FromSqlError, ToSql, ValueRef}; -use {str_to_cstring, Connection, Error, InnerConnection, Result}; +use crate::context::set_result; +use crate::error::error_from_sqlite_code; +use crate::ffi; +pub use crate::ffi::{sqlite3_vtab, sqlite3_vtab_cursor}; +use crate::types::{FromSql, FromSqlError, ToSql, ValueRef}; +use crate::{str_to_cstring, Connection, Error, InnerConnection, Result}; // let conn: Connection = ...; // let mod: Module = ...; // VTab builder @@ -474,7 +474,7 @@ impl<'a> Values<'a> { // So it seems not possible to enhance `ValueRef::from_value`. #[cfg(feature = "array")] pub(crate) fn get_array(&self, idx: usize) -> Result> { - use types::Value; + use crate::types::Value; let arg = self.args[idx]; let ptr = unsafe { ffi::sqlite3_value_pointer(arg, array::ARRAY_TYPE) }; if ptr.is_null() { @@ -544,7 +544,7 @@ impl InnerConnection { module: &Module, aux: Option, ) -> Result<()> { - let c_name = try!(str_to_cstring(module_name)); + let c_name = str_to_cstring(module_name)?; let r = match aux { Some(aux) => { let boxed_aux: *mut T::Aux = Box::into_raw(Box::new(aux)); diff --git a/src/vtab/series.rs b/src/vtab/series.rs index 88fe393..716719d 100644 --- a/src/vtab/series.rs +++ b/src/vtab/series.rs @@ -4,13 +4,13 @@ use std::default::Default; use std::os::raw::c_int; -use ffi; -use types::Type; -use vtab::{ +use crate::ffi; +use crate::types::Type; +use crate::vtab::{ eponymous_only_module, Context, IndexConstraintOp, IndexInfo, Module, VTab, VTabConnection, VTabCursor, Values, }; -use {Connection, Result}; +use crate::{Connection, Result}; /// Register the "generate_series" module. pub fn load_module(conn: &Connection) -> Result<()> { @@ -188,19 +188,19 @@ impl VTabCursor for SeriesTabCursor { let idx_num = QueryPlanFlags::from_bits_truncate(idx_num); let mut i = 0; if idx_num.contains(QueryPlanFlags::START) { - self.min_value = try!(args.get(i)); + self.min_value = args.get(i)?; i += 1; } else { self.min_value = 0; } if idx_num.contains(QueryPlanFlags::STOP) { - self.max_value = try!(args.get(i)); + self.max_value = args.get(i)?; i += 1; } else { self.max_value = 0xffff_ffff; } if idx_num.contains(QueryPlanFlags::STEP) { - self.step = try!(args.get(i)); + self.step = args.get(i)?; if self.step < 1 { self.step = 1; } @@ -263,9 +263,9 @@ impl VTabCursor for SeriesTabCursor { #[cfg(test)] mod test { - use ffi; - use vtab::series; - use {Connection, NO_PARAMS}; + use crate::ffi; + use crate::vtab::series; + use crate::{Connection, NO_PARAMS}; #[test] fn test_series_module() { From 1262238229719fe24d02b6e127e52879b9e6698e Mon Sep 17 00:00:00 2001 From: gwenn Date: Tue, 30 Oct 2018 20:13:41 +0100 Subject: [PATCH 2/3] Rustfmt --- src/backup.rs | 9 ++------- src/blob.rs | 2 +- src/cache.rs | 4 ++-- src/error.rs | 4 ++-- src/hooks.rs | 2 +- src/lib.rs | 4 +--- src/transaction.rs | 2 +- src/types/mod.rs | 2 +- src/types/to_sql.rs | 4 ++-- src/unlock_notify.rs | 2 +- src/vtab/array.rs | 2 +- 11 files changed, 15 insertions(+), 22 deletions(-) diff --git a/src/backup.rs b/src/backup.rs index 40e2e7c..250e0c8 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -63,12 +63,7 @@ impl Connection { ) -> Result<()> { use self::StepResult::{Busy, Done, Locked, More}; let mut dst = Connection::open(dst_path)?; - let backup = Backup::new_with_names( - self, - name, - &mut dst, - DatabaseName::Main - )?; + let backup = Backup::new_with_names(self, name, &mut dst, DatabaseName::Main)?; let mut r = More; while r == More { @@ -308,8 +303,8 @@ impl<'a, 'b> Drop for Backup<'a, 'b> { #[cfg(test)] mod test { use super::Backup; - use std::time::Duration; use crate::{Connection, DatabaseName, NO_PARAMS}; + use std::time::Duration; #[test] fn test_backup() { diff --git a/src/blob.rs b/src/blob.rs index e2263bf..0b41a5f 100644 --- a/src/blob.rs +++ b/src/blob.rs @@ -262,8 +262,8 @@ impl ToSql for ZeroBlob { #[cfg(test)] mod test { - use std::io::{BufRead, BufReader, BufWriter, Read, Seek, SeekFrom, Write}; use crate::{Connection, DatabaseName, Result}; + use std::io::{BufRead, BufReader, BufWriter, Read, Seek, SeekFrom, Write}; fn db_with_test_blob() -> Result<(Connection, i64)> { let db = Connection::open_in_memory()?; diff --git a/src/cache.rs b/src/cache.rs index 6d56c31..8dc3912 100644 --- a/src/cache.rs +++ b/src/cache.rs @@ -1,10 +1,10 @@ //! Prepared statements cache for faster execution. -use lru_cache::LruCache; use crate::raw_statement::RawStatement; +use crate::{Connection, Result, Statement}; +use lru_cache::LruCache; use std::cell::RefCell; use std::ops::{Deref, DerefMut}; -use crate::{Connection, Result, Statement}; impl Connection { /// Prepare a SQL statement for execution, returning a previously prepared diff --git a/src/error.rs b/src/error.rs index 0b36443..f11958d 100644 --- a/src/error.rs +++ b/src/error.rs @@ -1,10 +1,10 @@ +use crate::types::Type; +use crate::{errmsg_to_string, ffi}; use std::error; use std::fmt; use std::os::raw::c_int; use std::path::PathBuf; use std::str; -use crate::types::Type; -use crate::{errmsg_to_string, ffi}; /// Old name for `Error`. `SqliteError` is deprecated. #[deprecated(since = "0.6.0", note = "Use Error instead")] diff --git a/src/hooks.rs b/src/hooks.rs index 8478b79..947e7f4 100644 --- a/src/hooks.rs +++ b/src/hooks.rs @@ -289,8 +289,8 @@ fn free_boxed_hook(p: *mut c_void) { #[cfg(test)] mod test { use super::Action; - use std::sync::atomic::{AtomicBool, Ordering}; use crate::Connection; + use std::sync::atomic::{AtomicBool, Ordering}; #[test] fn test_commit_hook() { diff --git a/src/lib.rs b/src/lib.rs index c2ef16a..b5b3d68 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1577,9 +1577,7 @@ mod test { for (i, v) in vals.iter().enumerate() { let i_to_insert = i as i64; assert_eq!( - insert_stmt - .execute(&[&i_to_insert as &ToSql, &v]) - .unwrap(), + insert_stmt.execute(&[&i_to_insert as &ToSql, &v]).unwrap(), 1 ); } diff --git a/src/transaction.rs b/src/transaction.rs index a294c22..17bb279 100644 --- a/src/transaction.rs +++ b/src/transaction.rs @@ -1,5 +1,5 @@ -use std::ops::Deref; use crate::{Connection, Result}; +use std::ops::Deref; /// Old name for `TransactionBehavior`. `SqliteTransactionBehavior` is /// deprecated. diff --git a/src/types/mod.rs b/src/types/mod.rs index e39240c..0d19dc1 100644 --- a/src/types/mod.rs +++ b/src/types/mod.rs @@ -114,9 +114,9 @@ mod test { extern crate time; use super::Value; + use crate::{Connection, Error, NO_PARAMS}; use std::f64::EPSILON; use std::os::raw::{c_double, c_int}; - use crate::{Connection, Error, NO_PARAMS}; fn checked_memory_handle() -> Connection { let db = Connection::open_in_memory().unwrap(); diff --git a/src/types/to_sql.rs b/src/types/to_sql.rs index 651107b..81df0d9 100644 --- a/src/types/to_sql.rs +++ b/src/types/to_sql.rs @@ -1,8 +1,8 @@ use super::{Null, Value, ValueRef}; -use std::borrow::Cow; #[cfg(feature = "array")] use crate::vtab::array::Array; use crate::Result; +use std::borrow::Cow; /// `ToSqlOutput` represents the possible output types for implementors of the /// `ToSql` trait. @@ -207,8 +207,8 @@ mod test { #[cfg(feature = "i128_blob")] #[test] fn test_i128() { - use std::i128; use crate::{Connection, NO_PARAMS}; + use std::i128; let db = Connection::open_in_memory().unwrap(); db.execute_batch("CREATE TABLE foo (i128 BLOB, desc TEXT)") .unwrap(); diff --git a/src/unlock_notify.rs b/src/unlock_notify.rs index 785f05e..0f8f6fa 100644 --- a/src/unlock_notify.rs +++ b/src/unlock_notify.rs @@ -99,10 +99,10 @@ pub fn wait_for_unlock_notify(_db: *mut ffi::sqlite3) -> c_int { #[cfg(feature = "unlock_notify")] #[cfg(test)] mod test { + use crate::{Connection, OpenFlags, Result, Transaction, TransactionBehavior, NO_PARAMS}; use std::sync::mpsc::sync_channel; use std::thread; use std::time; - use crate::{Connection, OpenFlags, Result, Transaction, TransactionBehavior, NO_PARAMS}; #[test] fn test_unlock_notify() { diff --git a/src/vtab/array.rs b/src/vtab/array.rs index 496a8f8..672e34d 100644 --- a/src/vtab/array.rs +++ b/src/vtab/array.rs @@ -169,10 +169,10 @@ impl VTabCursor for ArrayTabCursor { #[cfg(test)] mod test { - use std::rc::Rc; use crate::types::Value; use crate::vtab::array; use crate::Connection; + use std::rc::Rc; #[test] fn test_array_module() { From dc49b28520c00b9dd62d10bf137dbd621221bdbb Mon Sep 17 00:00:00 2001 From: gwenn Date: Thu, 6 Dec 2018 19:00:55 +0100 Subject: [PATCH 3/3] Fix some clippy warnings --- src/error.rs | 2 +- src/row.rs | 2 +- src/types/from_sql.rs | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/error.rs b/src/error.rs index ab768ff..8f324dd 100644 --- a/src/error.rs +++ b/src/error.rs @@ -8,7 +8,7 @@ use std::str; /// Enum listing possible errors from rusqlite. #[derive(Debug)] -#[allow(enum_variant_names)] +#[allow(clippy::enum_variant_names)] pub enum Error { /// An error from an underlying SQLite call. SqliteFailure(ffi::Error, Option), diff --git a/src/row.rs b/src/row.rs index b1911e6..545e190 100644 --- a/src/row.rs +++ b/src/row.rs @@ -27,7 +27,7 @@ impl<'stmt> Rows<'stmt> { /// This is a "streaming iterator". For a more natural interface, /// consider using `query_map` or `query_and_then` instead, which /// return types that implement `Iterator`. - #[cfg_attr(feature = "cargo-clippy", allow(should_implement_trait))] // cannot implement Iterator + #[allow(clippy::should_implement_trait)] // cannot implement Iterator pub fn next<'a>(&'a mut self) -> Option>> { self.stmt.and_then(|stmt| match stmt.step() { Ok(true) => Some(Ok(Row { diff --git a/src/types/from_sql.rs b/src/types/from_sql.rs index 7fa00ac..4feefdf 100644 --- a/src/types/from_sql.rs +++ b/src/types/from_sql.rs @@ -47,7 +47,7 @@ impl Error for FromSqlError { } } - #[cfg_attr(feature = "clippy", allow(match_same_arms))] + #[allow(clippy::match_same_arms)] fn cause(&self) -> Option<&Error> { match *self { FromSqlError::Other(ref err) => err.cause(),