From 4327a84edb2773ef740891efad8ec11e38d3b774 Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Sat, 12 Dec 2015 13:50:12 -0500 Subject: [PATCH 01/11] Rename SqliteConnection -> Connection. Leave old name in as a (deprecated) typealias. --- Changelog.md | 1 + README.md | 6 +- src/backup.rs | 38 +++++------ src/functions.rs | 28 ++++---- src/lib.rs | 129 ++++++++++++++++++------------------ src/load_extension_guard.rs | 10 +-- src/named_params.rs | 28 ++++---- src/trace.rs | 10 +-- src/transaction.rs | 26 ++++---- src/types.rs | 10 +-- 10 files changed, 145 insertions(+), 141 deletions(-) diff --git a/Changelog.md b/Changelog.md index d3c78b4..e1d2597 100644 --- a/Changelog.md +++ b/Changelog.md @@ -1,5 +1,6 @@ # Version UPCOMING (TBD) +* Renamed `SqliteConnection` to `Connection`. The old name remains as a typealias. * Adds a variety of `..._named` methods for executing queries using named placeholder parameters. * Adds `backup` feature that exposes SQLite's online backup API. * Adds `functions` feature that allows user-defined scalar functions to be added to diff --git a/README.md b/README.md index 1bc6742..96f0fd3 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ extern crate rusqlite; extern crate time; use time::Timespec; -use rusqlite::SqliteConnection; +use rusqlite::Connection; #[derive(Debug)] struct Person { @@ -22,7 +22,7 @@ struct Person { } fn main() { - let conn = SqliteConnection::open_in_memory().unwrap(); + let conn = Connection::open_in_memory().unwrap(); conn.execute("CREATE TABLE person ( id INTEGER PRIMARY KEY, @@ -72,7 +72,7 @@ performing checks at runtime to ensure you do not try to retrieve the values of will panic if you do so. A specific example that will panic: ```rust -fn bad_function_will_panic(conn: &SqliteConnection) -> SqliteResult { +fn bad_function_will_panic(conn: &Connection) -> SqliteResult { let mut stmt = try!(conn.prepare("SELECT id FROM my_table")); let mut rows = try!(stmt.query(&[])); diff --git a/src/backup.rs b/src/backup.rs index e50ad20..5d9c2c2 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -1,6 +1,6 @@ //! Online SQLite backup API. //! -//! To create a `Backup`, you must have two distinct `SqliteConnection`s - one +//! To create a `Backup`, you must have two distinct `Connection`s - one //! for the source (which can be used while the backup is running) and one for //! the destination (which cannot). A `Backup` handle exposes three methods: //! `step` will attempt to back up a specified number of pages, `progress` gets @@ -14,13 +14,13 @@ //! documentation](https://www.sqlite.org/backup.html). //! //! ```rust,no_run -//! # use rusqlite::{backup, SqliteConnection, SqliteResult}; +//! # use rusqlite::{backup, Connection, SqliteResult}; //! # use std::path::Path; //! # use std::time; //! -//! fn backupDb>(src: &SqliteConnection, dst: P, progress: fn(backup::Progress)) +//! fn backupDb>(src: &Connection, dst: P, progress: fn(backup::Progress)) //! -> SqliteResult<()> { -//! let mut dst = try!(SqliteConnection::open(dst)); +//! let mut dst = try!(Connection::open(dst)); //! let backup = try!(backup::Backup::new(src, &mut dst)); //! backup.run_to_completion(5, time::Duration::from_millis(250), Some(progress)) //! } @@ -36,9 +36,9 @@ use std::time::Duration; use ffi; -use {DatabaseName, SqliteConnection, SqliteError, SqliteResult}; +use {DatabaseName, Connection, SqliteError, SqliteResult}; -impl SqliteConnection { +impl Connection { /// Back up the `name` database to the given destination path. /// If `progress` is not `None`, it will be called periodically /// until the backup completes. @@ -57,7 +57,7 @@ impl SqliteConnection { progress: Option) -> SqliteResult<()> { use self::StepResult::{More, Done, Busy, Locked}; - let mut dst = try!(SqliteConnection::open(dst_path)); + let mut dst = try!(Connection::open(dst_path)); let backup = try!(Backup::new_with_names(self, name, &mut dst, DatabaseName::Main)); let mut r = More; @@ -94,7 +94,7 @@ impl SqliteConnection { progress: Option) -> SqliteResult<()> { use self::StepResult::{More, Done, Busy, Locked}; - let src = try!(SqliteConnection::open(src_path)); + let src = try!(Connection::open(src_path)); let restore = try!(Backup::new_with_names(&src, DatabaseName::Main, self, name)); let mut r = More; @@ -170,8 +170,8 @@ impl<'a, 'b> Backup<'a, 'b> { /// /// Will return `Err` if the underlying `sqlite3_backup_init` call returns /// `NULL`. - pub fn new(from: &'a SqliteConnection, - to: &'b mut SqliteConnection) + pub fn new(from: &'a Connection, + to: &'b mut Connection) -> SqliteResult> { Backup::new_with_names(from, DatabaseName::Main, to, DatabaseName::Main) } @@ -185,9 +185,9 @@ impl<'a, 'b> Backup<'a, 'b> { /// /// Will return `Err` if the underlying `sqlite3_backup_init` call returns /// `NULL`. - pub fn new_with_names(from: &'a SqliteConnection, + pub fn new_with_names(from: &'a Connection, from_name: DatabaseName, - to: &'b mut SqliteConnection, + to: &'b mut Connection, to_name: DatabaseName) -> SqliteResult> { let to_name = try!(to_name.to_cstring()); @@ -298,21 +298,21 @@ impl<'a, 'b> Drop for Backup<'a, 'b> { #[cfg(test)] mod test { - use {SqliteConnection, DatabaseName}; + use {Connection, DatabaseName}; use std::time::Duration; use super::Backup; #[test] #[cfg_attr(rustfmt, rustfmt_skip)] fn test_backup() { - let src = SqliteConnection::open_in_memory().unwrap(); + let src = Connection::open_in_memory().unwrap(); let sql = "BEGIN; CREATE TABLE foo(x INTEGER); INSERT INTO foo VALUES(42); END;"; src.execute_batch(sql).unwrap(); - let mut dst = SqliteConnection::open_in_memory().unwrap(); + let mut dst = Connection::open_in_memory().unwrap(); { let backup = Backup::new(&src, &mut dst).unwrap(); @@ -336,14 +336,14 @@ mod test { #[test] #[cfg_attr(rustfmt, rustfmt_skip)] fn test_backup_temp() { - let src = SqliteConnection::open_in_memory().unwrap(); + let src = Connection::open_in_memory().unwrap(); let sql = "BEGIN; CREATE TEMPORARY TABLE foo(x INTEGER); INSERT INTO foo VALUES(42); END;"; src.execute_batch(sql).unwrap(); - let mut dst = SqliteConnection::open_in_memory().unwrap(); + let mut dst = Connection::open_in_memory().unwrap(); { let backup = Backup::new_with_names(&src, @@ -375,7 +375,7 @@ mod test { #[test] #[cfg_attr(rustfmt, rustfmt_skip)] fn test_backup_attached() { - let src = SqliteConnection::open_in_memory().unwrap(); + let src = Connection::open_in_memory().unwrap(); let sql = "ATTACH DATABASE ':memory:' AS my_attached; BEGIN; CREATE TABLE my_attached.foo(x INTEGER); @@ -383,7 +383,7 @@ mod test { END;"; src.execute_batch(sql).unwrap(); - let mut dst = SqliteConnection::open_in_memory().unwrap(); + let mut dst = Connection::open_in_memory().unwrap(); { let backup = Backup::new_with_names(&src, diff --git a/src/functions.rs b/src/functions.rs index d8df619..3ebe3d0 100644 --- a/src/functions.rs +++ b/src/functions.rs @@ -12,11 +12,11 @@ //! extern crate rusqlite; //! extern crate regex; //! -//! use rusqlite::{SqliteConnection, SqliteError, SqliteResult}; +//! use rusqlite::{Connection, SqliteError, SqliteResult}; //! use std::collections::HashMap; //! use regex::Regex; //! -//! fn add_regexp_function(db: &SqliteConnection) -> SqliteResult<()> { +//! fn add_regexp_function(db: &Connection) -> SqliteResult<()> { //! let mut cached_regexes = HashMap::new(); //! db.create_scalar_function("regexp", 2, true, move |ctx| { //! let regex_s = try!(ctx.get::(0)); @@ -41,7 +41,7 @@ //! } //! //! fn main() { -//! let db = SqliteConnection::open_in_memory().unwrap(); +//! let db = Connection::open_in_memory().unwrap(); //! add_regexp_function(&db).unwrap(); //! //! let is_match = db.query_row("SELECT regexp('[aeiou]*', 'aaaaeeeiii')", &[], @@ -65,7 +65,7 @@ pub use ffi::sqlite3_value_numeric_type; use types::Null; -use {SqliteResult, SqliteError, SqliteConnection, str_to_cstring, InnerSqliteConnection}; +use {SqliteResult, SqliteError, Connection, str_to_cstring, InnerConnection}; /// A trait for types that can be converted into the result of an SQL function. pub trait ToResult { @@ -341,7 +341,7 @@ impl<'a> Context<'a> { } } -impl SqliteConnection { +impl Connection { /// Attach a user-defined scalar function to this database connection. /// /// `fn_name` is the name the function will be accessible from SQL. @@ -355,9 +355,9 @@ impl SqliteConnection { /// # Example /// /// ```rust - /// # use rusqlite::{SqliteConnection, SqliteResult}; + /// # use rusqlite::{Connection, SqliteResult}; /// # type c_double = f64; - /// fn scalar_function_example(db: SqliteConnection) -> SqliteResult<()> { + /// fn scalar_function_example(db: Connection) -> SqliteResult<()> { /// try!(db.create_scalar_function("halve", 1, true, |ctx| { /// let value = try!(ctx.get::(0)); /// Ok(value / 2f64) @@ -397,7 +397,7 @@ impl SqliteConnection { } } -impl InnerSqliteConnection { +impl InnerConnection { fn create_scalar_function(&mut self, fn_name: &str, n_arg: c_int, @@ -477,7 +477,7 @@ mod test { use libc::c_double; use self::regex::Regex; - use {SqliteConnection, SqliteError, SqliteResult}; + use {Connection, SqliteError, SqliteResult}; use ffi; use functions::Context; @@ -489,7 +489,7 @@ mod test { #[test] fn test_function_half() { - let db = SqliteConnection::open_in_memory().unwrap(); + let db = Connection::open_in_memory().unwrap(); db.create_scalar_function("half", 1, true, half).unwrap(); let result = db.query_row("SELECT half(6)", &[], |r| r.get::(0)); @@ -498,7 +498,7 @@ mod test { #[test] fn test_remove_function() { - let db = SqliteConnection::open_in_memory().unwrap(); + let db = Connection::open_in_memory().unwrap(); db.create_scalar_function("half", 1, true, half).unwrap(); let result = db.query_row("SELECT half(6)", &[], |r| r.get::(0)); assert_eq!(3f64, result.unwrap()); @@ -546,7 +546,7 @@ mod test { #[test] #[cfg_attr(rustfmt, rustfmt_skip)] fn test_function_regexp_with_auxilliary() { - let db = SqliteConnection::open_in_memory().unwrap(); + let db = Connection::open_in_memory().unwrap(); db.execute_batch("BEGIN; CREATE TABLE foo (x string); INSERT INTO foo VALUES ('lisa'); @@ -571,7 +571,7 @@ mod test { #[test] #[cfg_attr(rustfmt, rustfmt_skip)] fn test_function_regexp_with_hashmap_cache() { - let db = SqliteConnection::open_in_memory().unwrap(); + let db = Connection::open_in_memory().unwrap(); db.execute_batch("BEGIN; CREATE TABLE foo (x string); INSERT INTO foo VALUES ('lisa'); @@ -621,7 +621,7 @@ mod test { #[test] fn test_varargs_function() { - let db = SqliteConnection::open_in_memory().unwrap(); + let db = Connection::open_in_memory().unwrap(); db.create_scalar_function("my_concat", -1, true, |ctx| { let mut ret = String::new(); diff --git a/src/lib.rs b/src/lib.rs index 0af8ff5..773a333 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -6,7 +6,7 @@ //! extern crate time; //! //! use time::Timespec; -//! use rusqlite::SqliteConnection; +//! use rusqlite::Connection; //! //! #[derive(Debug)] //! struct Person { @@ -17,7 +17,7 @@ //! } //! //! fn main() { -//! let conn = SqliteConnection::open_in_memory().unwrap(); +//! let conn = Connection::open_in_memory().unwrap(); //! //! conn.execute("CREATE TABLE person ( //! id INTEGER PRIMARY KEY, @@ -179,27 +179,30 @@ impl<'a> DatabaseName<'a> { } } +/// Old name for `Connection`. `SqliteConnection` is deprecated. +pub type SqliteConnection = Connection; + /// A connection to a SQLite database. -pub struct SqliteConnection { - db: RefCell, +pub struct Connection { + db: RefCell, path: Option, } -unsafe impl Send for SqliteConnection {} +unsafe impl Send for Connection {} -impl SqliteConnection { +impl Connection { /// Open a new connection to a SQLite database. /// - /// `SqliteConnection::open(path)` is equivalent to `SqliteConnection::open_with_flags(path, + /// `Connection::open(path)` is equivalent to `Connection::open_with_flags(path, /// SQLITE_OPEN_READ_WRITE | SQLITE_OPEN_CREATE)`. /// /// # Failure /// /// Will return `Err` if `path` cannot be converted to a C-compatible string or if the /// underlying SQLite open call fails. - pub fn open>(path: P) -> SqliteResult { + pub fn open>(path: P) -> SqliteResult { let flags = Default::default(); - SqliteConnection::open_with_flags(path, flags) + Connection::open_with_flags(path, flags) } /// Open a new connection to an in-memory SQLite database. @@ -207,9 +210,9 @@ impl SqliteConnection { /// # Failure /// /// Will return `Err` if the underlying SQLite open call fails. - pub fn open_in_memory() -> SqliteResult { + pub fn open_in_memory() -> SqliteResult { let flags = Default::default(); - SqliteConnection::open_in_memory_with_flags(flags) + Connection::open_in_memory_with_flags(flags) } /// Open a new connection to a SQLite database. @@ -223,10 +226,10 @@ impl SqliteConnection { /// underlying SQLite open call fails. pub fn open_with_flags>(path: P, flags: SqliteOpenFlags) - -> SqliteResult { + -> SqliteResult { let c_path = try!(path_to_cstring(path.as_ref())); - InnerSqliteConnection::open_with_flags(&c_path, flags).map(|db| { - SqliteConnection { + InnerConnection::open_with_flags(&c_path, flags).map(|db| { + Connection { db: RefCell::new(db), path: Some(path.as_ref().to_path_buf()), } @@ -241,10 +244,10 @@ impl SqliteConnection { /// # Failure /// /// Will return `Err` if the underlying SQLite open call fails. - pub fn open_in_memory_with_flags(flags: SqliteOpenFlags) -> SqliteResult { + pub fn open_in_memory_with_flags(flags: SqliteOpenFlags) -> SqliteResult { let c_memory = try!(str_to_cstring(":memory:")); - InnerSqliteConnection::open_with_flags(&c_memory, flags).map(|db| { - SqliteConnection { + InnerConnection::open_with_flags(&c_memory, flags).map(|db| { + Connection { db: RefCell::new(db), path: None, } @@ -259,10 +262,10 @@ impl SqliteConnection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteConnection, SqliteResult}; - /// # fn do_queries_part_1(conn: &SqliteConnection) -> SqliteResult<()> { Ok(()) } - /// # fn do_queries_part_2(conn: &SqliteConnection) -> SqliteResult<()> { Ok(()) } - /// fn perform_queries(conn: &SqliteConnection) -> SqliteResult<()> { + /// # use rusqlite::{Connection, SqliteResult}; + /// # fn do_queries_part_1(conn: &Connection) -> SqliteResult<()> { Ok(()) } + /// # fn do_queries_part_2(conn: &Connection) -> SqliteResult<()> { Ok(()) } + /// fn perform_queries(conn: &Connection) -> SqliteResult<()> { /// let tx = try!(conn.transaction()); /// /// try!(do_queries_part_1(conn)); // tx causes rollback if this fails @@ -299,8 +302,8 @@ impl SqliteConnection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteConnection, SqliteResult}; - /// fn create_tables(conn: &SqliteConnection) -> SqliteResult<()> { + /// # use rusqlite::{Connection, SqliteResult}; + /// fn create_tables(conn: &Connection) -> SqliteResult<()> { /// conn.execute_batch("BEGIN; /// CREATE TABLE foo(x INTEGER); /// CREATE TABLE bar(y TEXT); @@ -324,8 +327,8 @@ impl SqliteConnection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteConnection}; - /// fn update_rows(conn: &SqliteConnection) { + /// # use rusqlite::{Connection}; + /// fn update_rows(conn: &Connection) { /// match conn.execute("UPDATE foo SET bar = 'baz' WHERE qux = ?", &[&1i32]) { /// Ok(updated) => println!("{} rows were updated", updated), /// Err(err) => println!("update failed: {}", err), @@ -354,8 +357,8 @@ impl SqliteConnection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteResult,SqliteConnection}; - /// fn preferred_locale(conn: &SqliteConnection) -> SqliteResult { + /// # use rusqlite::{SqliteResult,Connection}; + /// fn preferred_locale(conn: &Connection) -> SqliteResult { /// conn.query_row("SELECT value FROM preferences WHERE name='locale'", &[], |row| { /// row.get(0) /// }) @@ -384,8 +387,8 @@ impl SqliteConnection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteResult,SqliteConnection}; - /// fn preferred_locale(conn: &SqliteConnection) -> SqliteResult { + /// # use rusqlite::{SqliteResult,Connection}; + /// fn preferred_locale(conn: &Connection) -> SqliteResult { /// conn.query_row_and_then("SELECT value FROM preferences WHERE name='locale'", &[], |row| { /// row.get_checked(0) /// }) @@ -413,8 +416,8 @@ impl SqliteConnection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteResult,SqliteConnection}; - /// fn preferred_locale(conn: &SqliteConnection) -> SqliteResult { + /// # use rusqlite::{SqliteResult,Connection}; + /// fn preferred_locale(conn: &Connection) -> SqliteResult { /// conn.query_row_safe("SELECT value FROM preferences WHERE name='locale'", &[], |row| { /// row.get(0) /// }) @@ -438,8 +441,8 @@ impl SqliteConnection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteConnection, SqliteResult}; - /// fn insert_new_people(conn: &SqliteConnection) -> SqliteResult<()> { + /// # use rusqlite::{Connection, SqliteResult}; + /// fn insert_new_people(conn: &Connection) -> SqliteResult<()> { /// let mut stmt = try!(conn.prepare("INSERT INTO People (name) VALUES (?)")); /// try!(stmt.execute(&[&"Joe Smith"])); /// try!(stmt.execute(&[&"Bob Jones"])); @@ -457,7 +460,7 @@ impl SqliteConnection { /// Close the SQLite connection. /// - /// This is functionally equivalent to the `Drop` implementation for `SqliteConnection` except + /// This is functionally equivalent to the `Drop` implementation for `Connection` except /// that it returns any error encountered to the caller. /// /// # Failure @@ -474,9 +477,9 @@ impl SqliteConnection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteConnection, SqliteResult}; + /// # use rusqlite::{Connection, SqliteResult}; /// # use std::path::{Path}; - /// fn load_my_extension(conn: &SqliteConnection) -> SqliteResult<()> { + /// fn load_my_extension(conn: &Connection) -> SqliteResult<()> { /// try!(conn.load_extension_enable()); /// try!(conn.load_extension(Path::new("my_sqlite_extension"), None)); /// conn.load_extension_disable() @@ -513,9 +516,9 @@ impl SqliteConnection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteConnection, SqliteResult, SqliteLoadExtensionGuard}; + /// # use rusqlite::{Connection, SqliteResult, SqliteLoadExtensionGuard}; /// # use std::path::{Path}; - /// fn load_my_extension(conn: &SqliteConnection) -> SqliteResult<()> { + /// fn load_my_extension(conn: &Connection) -> SqliteResult<()> { /// let _guard = try!(SqliteLoadExtensionGuard::new(conn)); /// /// conn.load_extension("my_sqlite_extension", None) @@ -542,15 +545,15 @@ impl SqliteConnection { } } -impl fmt::Debug for SqliteConnection { +impl fmt::Debug for Connection { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("SqliteConnection") + f.debug_struct("Connection") .field("path", &self.path) .finish() } } -struct InnerSqliteConnection { +struct InnerConnection { db: *mut ffi::Struct_sqlite3, } @@ -577,10 +580,10 @@ impl Default for SqliteOpenFlags { } } -impl InnerSqliteConnection { +impl InnerConnection { fn open_with_flags(c_path: &CString, flags: SqliteOpenFlags) - -> SqliteResult { + -> SqliteResult { unsafe { let mut db: *mut ffi::sqlite3 = mem::uninitialized(); let r = ffi::sqlite3_open_v2(c_path.as_ptr(), &mut db, flags.bits(), ptr::null()); @@ -604,7 +607,7 @@ impl InnerSqliteConnection { ffi::sqlite3_close(db); return Err(e); } - Ok(InnerSqliteConnection { db: db }) + Ok(InnerConnection { db: db }) } } @@ -686,7 +689,7 @@ impl InnerSqliteConnection { } fn prepare<'a>(&mut self, - conn: &'a SqliteConnection, + conn: &'a Connection, sql: &str) -> SqliteResult> { if sql.len() >= ::std::i32::MAX as usize { @@ -713,7 +716,7 @@ impl InnerSqliteConnection { } } -impl Drop for InnerSqliteConnection { +impl Drop for InnerConnection { #[allow(unused_must_use)] fn drop(&mut self) { self.close(); @@ -722,14 +725,14 @@ impl Drop for InnerSqliteConnection { /// A prepared statement. pub struct SqliteStatement<'conn> { - conn: &'conn SqliteConnection, + conn: &'conn Connection, stmt: *mut ffi::sqlite3_stmt, needs_reset: bool, column_count: c_int, } impl<'conn> SqliteStatement<'conn> { - fn new(conn: &SqliteConnection, stmt: *mut ffi::sqlite3_stmt) -> SqliteStatement { + fn new(conn: &Connection, stmt: *mut ffi::sqlite3_stmt) -> SqliteStatement { SqliteStatement { conn: conn, stmt: stmt, @@ -758,8 +761,8 @@ impl<'conn> SqliteStatement<'conn> { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteConnection, SqliteResult}; - /// fn update_rows(conn: &SqliteConnection) -> SqliteResult<()> { + /// # use rusqlite::{Connection, SqliteResult}; + /// fn update_rows(conn: &Connection) -> SqliteResult<()> { /// let mut stmt = try!(conn.prepare("UPDATE foo SET bar = 'baz' WHERE qux = ?")); /// /// try!(stmt.execute(&[&1i32])); @@ -810,8 +813,8 @@ impl<'conn> SqliteStatement<'conn> { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteConnection, SqliteResult}; - /// fn get_names(conn: &SqliteConnection) -> SqliteResult> { + /// # use rusqlite::{Connection, SqliteResult}; + /// fn get_names(conn: &Connection) -> SqliteResult> { /// let mut stmt = try!(conn.prepare("SELECT name FROM people")); /// let mut rows = try!(stmt.query(&[])); /// @@ -994,8 +997,8 @@ where E: convert::From, /// iterator). For example: /// /// ```rust,no_run -/// # use rusqlite::{SqliteConnection, SqliteResult}; -/// fn bad_function_will_panic(conn: &SqliteConnection) -> SqliteResult { +/// # use rusqlite::{Connection, SqliteResult}; +/// fn bad_function_will_panic(conn: &Connection) -> SqliteResult { /// let mut stmt = try!(conn.prepare("SELECT id FROM my_table")); /// let mut rows = try!(stmt.query(&[])); /// @@ -1090,8 +1093,8 @@ impl<'stmt> SqliteRow<'stmt> { /// for example) this isn't an issue, but it means you cannot do something like this: /// /// ```rust,no_run - /// # use rusqlite::{SqliteConnection, SqliteResult}; - /// fn bad_function_will_panic(conn: &SqliteConnection) -> SqliteResult { + /// # use rusqlite::{Connection, SqliteResult}; + /// fn bad_function_will_panic(conn: &Connection) -> SqliteResult { /// let mut stmt = try!(conn.prepare("SELECT id FROM my_table")); /// let mut rows = try!(stmt.query(&[])); /// @@ -1164,11 +1167,11 @@ mod test { // that those types are `Send`. #[allow(dead_code, unconditional_recursion)] fn ensure_send() { - ensure_send::(); + ensure_send::(); } - pub fn checked_memory_handle() -> SqliteConnection { - SqliteConnection::open_in_memory().unwrap() + pub fn checked_memory_handle() -> Connection { + Connection::open_in_memory().unwrap() } #[test] @@ -1178,7 +1181,7 @@ mod test { let path = temp_dir.path().join("test.db3"); { - let db = SqliteConnection::open(&path).unwrap(); + let db = Connection::open(&path).unwrap(); let sql = "BEGIN; CREATE TABLE foo(x INTEGER); INSERT INTO foo VALUES(42); @@ -1187,7 +1190,7 @@ mod test { } let path_string = path.to_str().unwrap(); - let db = SqliteConnection::open(&path_string).unwrap(); + let db = Connection::open(&path_string).unwrap(); let the_answer = db.query_row("SELECT x FROM foo", &[], |r| r.get::(0)); assert_eq!(42i64, the_answer.unwrap()); @@ -1195,7 +1198,7 @@ mod test { #[test] fn test_open() { - assert!(SqliteConnection::open_in_memory().is_ok()); + assert!(Connection::open_in_memory().is_ok()); let db = checked_memory_handle(); assert!(db.close().is_ok()); @@ -1207,7 +1210,7 @@ mod test { SQLITE_OPEN_READ_ONLY | SQLITE_OPEN_READ_WRITE, SQLITE_OPEN_READ_ONLY | SQLITE_OPEN_CREATE] .iter() { - assert!(SqliteConnection::open_in_memory_with_flags(*bad_flags).is_err()); + assert!(Connection::open_in_memory_with_flags(*bad_flags).is_err()); } } diff --git a/src/load_extension_guard.rs b/src/load_extension_guard.rs index ecc93e5..2c02798 100644 --- a/src/load_extension_guard.rs +++ b/src/load_extension_guard.rs @@ -1,26 +1,26 @@ -use {SqliteResult, SqliteConnection}; +use {SqliteResult, Connection}; /// RAII guard temporarily enabling SQLite extensions to be loaded. /// /// ## Example /// /// ```rust,no_run -/// # use rusqlite::{SqliteConnection, SqliteResult, SqliteLoadExtensionGuard}; +/// # use rusqlite::{Connection, SqliteResult, SqliteLoadExtensionGuard}; /// # use std::path::{Path}; -/// fn load_my_extension(conn: &SqliteConnection) -> SqliteResult<()> { +/// fn load_my_extension(conn: &Connection) -> SqliteResult<()> { /// let _guard = try!(SqliteLoadExtensionGuard::new(conn)); /// /// conn.load_extension(Path::new("my_sqlite_extension"), None) /// } /// ``` pub struct SqliteLoadExtensionGuard<'conn> { - conn: &'conn SqliteConnection, + conn: &'conn Connection, } impl<'conn> SqliteLoadExtensionGuard<'conn> { /// Attempt to enable loading extensions. Loading extensions will be disabled when this /// guard goes out of scope. Cannot be meaningfully nested. - pub fn new(conn: &SqliteConnection) -> SqliteResult { + pub fn new(conn: &Connection) -> SqliteResult { conn.load_extension_enable().map(|_| SqliteLoadExtensionGuard { conn: conn }) } } diff --git a/src/named_params.rs b/src/named_params.rs index 49305e7..60e99d8 100644 --- a/src/named_params.rs +++ b/src/named_params.rs @@ -2,11 +2,11 @@ use libc::c_int; use super::ffi; -use {SqliteResult, SqliteError, SqliteConnection, SqliteStatement, SqliteRows, SqliteRow, +use {SqliteResult, SqliteError, Connection, SqliteStatement, SqliteRows, SqliteRow, str_to_cstring}; use types::ToSql; -impl SqliteConnection { +impl Connection { /// Convenience method to prepare and execute a single SQL statement with named parameter(s). /// /// On success, returns the number of rows that were changed or inserted or deleted (via @@ -15,8 +15,8 @@ impl SqliteConnection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteConnection, SqliteResult}; - /// fn insert(conn: &SqliteConnection) -> SqliteResult { + /// # use rusqlite::{Connection, SqliteResult}; + /// fn insert(conn: &Connection) -> SqliteResult { /// conn.execute_named("INSERT INTO test (name) VALUES (:name)", &[(":name", &"one")]) /// } /// ``` @@ -79,8 +79,8 @@ impl<'conn> SqliteStatement<'conn> { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteConnection, SqliteResult}; - /// fn insert(conn: &SqliteConnection) -> SqliteResult { + /// # use rusqlite::{Connection, SqliteResult}; + /// fn insert(conn: &Connection) -> SqliteResult { /// let mut stmt = try!(conn.prepare("INSERT INTO test (name) VALUES (:name)")); /// stmt.execute_named(&[(":name", &"one")]) /// } @@ -105,8 +105,8 @@ impl<'conn> SqliteStatement<'conn> { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteConnection, SqliteResult, SqliteRows}; - /// fn query(conn: &SqliteConnection) -> SqliteResult<()> { + /// # use rusqlite::{Connection, SqliteResult, SqliteRows}; + /// fn query(conn: &Connection) -> SqliteResult<()> { /// let mut stmt = try!(conn.prepare("SELECT * FROM test where name = :name")); /// let mut rows = try!(stmt.query_named(&[(":name", &"one")])); /// for row in rows { @@ -146,11 +146,11 @@ impl<'conn> SqliteStatement<'conn> { #[cfg(test)] mod test { - use SqliteConnection; + use Connection; #[test] fn test_execute_named() { - let db = SqliteConnection::open_in_memory().unwrap(); + let db = Connection::open_in_memory().unwrap(); db.execute_batch("CREATE TABLE foo(x INTEGER)").unwrap(); assert_eq!(db.execute_named("INSERT INTO foo(x) VALUES (:x)", &[(":x", &1i32)]).unwrap(), @@ -167,7 +167,7 @@ mod test { #[test] fn test_stmt_execute_named() { - let db = SqliteConnection::open_in_memory().unwrap(); + let db = Connection::open_in_memory().unwrap(); let sql = "CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL, name TEXT NOT NULL, flag \ INTEGER)"; db.execute_batch(sql).unwrap(); @@ -184,7 +184,7 @@ mod test { #[test] fn test_query_named() { - let db = SqliteConnection::open_in_memory().unwrap(); + let db = Connection::open_in_memory().unwrap(); let sql = "CREATE TABLE test (id INTEGER PRIMARY KEY NOT NULL, name TEXT NOT NULL, flag \ INTEGER)"; db.execute_batch(sql).unwrap(); @@ -195,7 +195,7 @@ mod test { #[test] fn test_unbound_parameters_are_null() { - let db = SqliteConnection::open_in_memory().unwrap(); + let db = Connection::open_in_memory().unwrap(); let sql = "CREATE TABLE test (x TEXT, y TEXT)"; db.execute_batch(sql).unwrap(); @@ -209,7 +209,7 @@ mod test { #[test] fn test_unbound_parameters_are_reused() { - let db = SqliteConnection::open_in_memory().unwrap(); + let db = Connection::open_in_memory().unwrap(); let sql = "CREATE TABLE test (x TEXT, y TEXT)"; db.execute_batch(sql).unwrap(); diff --git a/src/trace.rs b/src/trace.rs index 682662c..f79f619 100644 --- a/src/trace.rs +++ b/src/trace.rs @@ -8,7 +8,7 @@ use std::str; use std::time::Duration; use super::ffi; -use {SqliteError, SqliteResult, SqliteConnection}; +use {SqliteError, SqliteResult, Connection}; /// Set up the process-wide SQLite error logging callback. /// This function is marked unsafe for two reasons: @@ -60,7 +60,7 @@ pub fn log(err_code: c_int, msg: &str) { } } -impl SqliteConnection { +impl Connection { /// Register or clear a callback function that can be used for tracing the execution of SQL statements. /// /// Prepared statement placeholders are replaced/logged with their assigned values. @@ -120,7 +120,7 @@ mod test { use std::sync::Mutex; use std::time::Duration; - use SqliteConnection; + use Connection; #[test] fn test_trace() { @@ -132,7 +132,7 @@ mod test { traced_stmts.push(s.to_owned()); } - let mut db = SqliteConnection::open_in_memory().unwrap(); + let mut db = Connection::open_in_memory().unwrap(); db.trace(Some(tracer)); { let _ = db.query_row("SELECT ?", &[&1i32], |_| {}); @@ -160,7 +160,7 @@ mod test { profiled.push((s.to_owned(), d)); } - let mut db = SqliteConnection::open_in_memory().unwrap(); + let mut db = Connection::open_in_memory().unwrap(); db.profile(Some(profiler)); db.execute_batch("PRAGMA application_id = 1").unwrap(); db.profile(None); diff --git a/src/transaction.rs b/src/transaction.rs index 1981f24..a26cc9d 100644 --- a/src/transaction.rs +++ b/src/transaction.rs @@ -1,4 +1,4 @@ -use {SqliteResult, SqliteConnection}; +use {SqliteResult, Connection}; pub use SqliteTransactionBehavior::{SqliteTransactionDeferred, SqliteTransactionImmediate, SqliteTransactionExclusive}; @@ -22,10 +22,10 @@ pub enum SqliteTransactionBehavior { /// ## Example /// /// ```rust,no_run -/// # use rusqlite::{SqliteConnection, SqliteResult}; -/// # fn do_queries_part_1(conn: &SqliteConnection) -> SqliteResult<()> { Ok(()) } -/// # fn do_queries_part_2(conn: &SqliteConnection) -> SqliteResult<()> { Ok(()) } -/// fn perform_queries(conn: &SqliteConnection) -> SqliteResult<()> { +/// # use rusqlite::{Connection, SqliteResult}; +/// # fn do_queries_part_1(conn: &Connection) -> SqliteResult<()> { Ok(()) } +/// # fn do_queries_part_2(conn: &Connection) -> SqliteResult<()> { Ok(()) } +/// fn perform_queries(conn: &Connection) -> SqliteResult<()> { /// let tx = try!(conn.transaction()); /// /// try!(do_queries_part_1(conn)); // tx causes rollback if this fails @@ -35,7 +35,7 @@ pub enum SqliteTransactionBehavior { /// } /// ``` pub struct SqliteTransaction<'conn> { - conn: &'conn SqliteConnection, + conn: &'conn Connection, depth: u32, commit: bool, finished: bool, @@ -43,7 +43,7 @@ pub struct SqliteTransaction<'conn> { impl<'conn> SqliteTransaction<'conn> { /// Begin a new transaction. Cannot be nested; see `savepoint` for nested transactions. - pub fn new(conn: &SqliteConnection, + pub fn new(conn: &Connection, behavior: SqliteTransactionBehavior) -> SqliteResult { let query = match behavior { @@ -71,9 +71,9 @@ impl<'conn> SqliteTransaction<'conn> { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteConnection, SqliteResult}; - /// # fn perform_queries_part_1_succeeds(conn: &SqliteConnection) -> bool { true } - /// fn perform_queries(conn: &SqliteConnection) -> SqliteResult<()> { + /// # use rusqlite::{Connection, SqliteResult}; + /// # fn perform_queries_part_1_succeeds(conn: &Connection) -> bool { true } + /// fn perform_queries(conn: &Connection) -> SqliteResult<()> { /// let tx = try!(conn.transaction()); /// /// { @@ -173,10 +173,10 @@ impl<'conn> Drop for SqliteTransaction<'conn> { #[cfg(test)] mod test { - use SqliteConnection; + use Connection; - fn checked_memory_handle() -> SqliteConnection { - let db = SqliteConnection::open_in_memory().unwrap(); + fn checked_memory_handle() -> Connection { + let db = Connection::open_in_memory().unwrap(); db.execute_batch("CREATE TABLE foo (x INTEGER)").unwrap(); db } diff --git a/src/types.rs b/src/types.rs index ddc0234..bf5f86c 100644 --- a/src/types.rs +++ b/src/types.rs @@ -176,12 +176,12 @@ impl ToSql for Option { /// ```rust,no_run /// # extern crate libc; /// # extern crate rusqlite; -/// # use rusqlite::{SqliteConnection, SqliteResult}; +/// # use rusqlite::{Connection, SqliteResult}; /// # use rusqlite::types::{Null}; /// # use libc::{c_int}; /// fn main() { /// } -/// fn insert_null(conn: &SqliteConnection) -> SqliteResult { +/// fn insert_null(conn: &Connection) -> SqliteResult { /// conn.execute("INSERT INTO people (name) VALUES (?)", &[&Null]) /// } /// ``` @@ -305,13 +305,13 @@ impl FromSql for Option { #[cfg(test)] mod test { - use SqliteConnection; + use Connection; use ffi; use super::time; use libc::{c_int, c_double}; - fn checked_memory_handle() -> SqliteConnection { - let db = SqliteConnection::open_in_memory().unwrap(); + fn checked_memory_handle() -> Connection { + let db = Connection::open_in_memory().unwrap(); db.execute_batch("CREATE TABLE foo (b BLOB, t TEXT, i INTEGER, f FLOAT, n)").unwrap(); db } From f0b6bf9152f717955df2bcfa7a16187271746f67 Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Sat, 12 Dec 2015 13:53:58 -0500 Subject: [PATCH 02/11] Rename SqliteError -> Error. --- Changelog.md | 1 + src/backup.rs | 14 ++++---- src/functions.rs | 16 ++++----- src/lib.rs | 79 +++++++++++++++++++++++---------------------- src/named_params.rs | 4 +-- src/trace.rs | 4 +-- src/types.rs | 6 ++-- 7 files changed, 64 insertions(+), 60 deletions(-) diff --git a/Changelog.md b/Changelog.md index e1d2597..d23ea20 100644 --- a/Changelog.md +++ b/Changelog.md @@ -1,6 +1,7 @@ # Version UPCOMING (TBD) * Renamed `SqliteConnection` to `Connection`. The old name remains as a typealias. +* Renamed `SqliteError` to `Error`. The old name remains as a typealias. * Adds a variety of `..._named` methods for executing queries using named placeholder parameters. * Adds `backup` feature that exposes SQLite's online backup API. * Adds `functions` feature that allows user-defined scalar functions to be added to diff --git a/src/backup.rs b/src/backup.rs index 5d9c2c2..02181f2 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -36,7 +36,7 @@ use std::time::Duration; use ffi; -use {DatabaseName, Connection, SqliteError, SqliteResult}; +use {DatabaseName, Connection, Error, SqliteResult}; impl Connection { /// Back up the `name` database to the given destination path. @@ -70,8 +70,8 @@ impl Connection { match r { Done => Ok(()), - Busy => Err(SqliteError::from_handle(ptr::null_mut(), ffi::SQLITE_BUSY)), - Locked => Err(SqliteError::from_handle(ptr::null_mut(), ffi::SQLITE_LOCKED)), + Busy => Err(Error::from_handle(ptr::null_mut(), ffi::SQLITE_BUSY)), + Locked => Err(Error::from_handle(ptr::null_mut(), ffi::SQLITE_LOCKED)), More => unreachable!(), } } @@ -115,8 +115,8 @@ impl Connection { match r { Done => Ok(()), - Busy => Err(SqliteError::from_handle(ptr::null_mut(), ffi::SQLITE_BUSY)), - Locked => Err(SqliteError::from_handle(ptr::null_mut(), ffi::SQLITE_LOCKED)), + Busy => Err(Error::from_handle(ptr::null_mut(), ffi::SQLITE_BUSY)), + Locked => Err(Error::from_handle(ptr::null_mut(), ffi::SQLITE_LOCKED)), More => unreachable!(), } } @@ -201,7 +201,7 @@ impl<'a, 'b> Backup<'a, 'b> { from.db.borrow_mut().db, from_name.as_ptr()); if b.is_null() { - return Err(SqliteError::from_handle(to_db, ffi::sqlite3_errcode(to_db))); + return Err(Error::from_handle(to_db, ffi::sqlite3_errcode(to_db))); } b }; @@ -245,7 +245,7 @@ impl<'a, 'b> Backup<'a, 'b> { ffi::SQLITE_BUSY => Ok(Busy), ffi::SQLITE_LOCKED => Ok(Locked), rc => { - Err(SqliteError { + Err(Error { code: rc, message: ffi::code_to_str(rc).into(), }) diff --git a/src/functions.rs b/src/functions.rs index 3ebe3d0..aa0fdf4 100644 --- a/src/functions.rs +++ b/src/functions.rs @@ -12,7 +12,7 @@ //! extern crate rusqlite; //! extern crate regex; //! -//! use rusqlite::{Connection, SqliteError, SqliteResult}; +//! use rusqlite::{Connection, Error, SqliteResult}; //! use std::collections::HashMap; //! use regex::Regex; //! @@ -26,7 +26,7 @@ //! match entry { //! Occupied(occ) => occ.into_mut(), //! Vacant(vac) => { -//! let r = try!(Regex::new(®ex_s).map_err(|e| SqliteError { +//! let r = try!(Regex::new(®ex_s).map_err(|e| Error { //! code: libsqlite3_sys::SQLITE_ERROR, //! message: format!("Invalid regular expression: {}", e), //! })); @@ -65,7 +65,7 @@ pub use ffi::sqlite3_value_numeric_type; use types::Null; -use {SqliteResult, SqliteError, Connection, str_to_cstring, InnerConnection}; +use {SqliteResult, Error, Connection, str_to_cstring, InnerConnection}; /// A trait for types that can be converted into the result of an SQL function. pub trait ToResult { @@ -228,7 +228,7 @@ impl FromValue for String { let utf8_str = str::from_utf8(c_slice); utf8_str.map(|s| s.to_string()) .map_err(|e| { - SqliteError { + Error { code: 0, message: e.to_string(), } @@ -302,7 +302,7 @@ impl<'a> Context<'a> { if T::parameter_has_valid_sqlite_type(arg) { T::parameter_value(arg) } else { - Err(SqliteError { + Err(Error { code: ffi::SQLITE_MISMATCH, message: "Invalid value type".to_string(), }) @@ -477,7 +477,7 @@ mod test { use libc::c_double; use self::regex::Regex; - use {Connection, SqliteError, SqliteResult}; + use {Connection, Error, SqliteResult}; use ffi; use functions::Context; @@ -519,7 +519,7 @@ mod test { None => { let s = try!(ctx.get::(0)); let r = try!(Regex::new(&s).map_err(|e| { - SqliteError { + Error { code: ffi::SQLITE_ERROR, message: format!("Invalid regular expression: {}", e), } @@ -593,7 +593,7 @@ mod test { match entry { Occupied(occ) => occ.into_mut(), Vacant(vac) => { - let r = try!(Regex::new(®ex_s).map_err(|e| SqliteError { + let r = try!(Regex::new(®ex_s).map_err(|e| Error { code: ffi::SQLITE_ERROR, message: format!("Invalid regular expression: {}", e), })); diff --git a/src/lib.rs b/src/lib.rs index 773a333..b718ac6 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -89,7 +89,7 @@ mod named_params; #[cfg(feature = "functions")] pub mod functions; /// A typedef of the result returned by many methods. -pub type SqliteResult = Result; +pub type SqliteResult = Result; unsafe fn errmsg_to_string(errmsg: *const c_char) -> String { let c_slice = CStr::from_ptr(errmsg).to_bytes(); @@ -97,9 +97,12 @@ unsafe fn errmsg_to_string(errmsg: *const c_char) -> String { utf8_str.unwrap_or("Invalid string encoding").to_string() } +/// Old name for `Error`. `SqliteError` is deprecated. +pub type SqliteError = Error; + /// Encompasses an error result from a call to the SQLite C API. #[derive(Debug, PartialEq)] -pub struct SqliteError { +pub struct Error { /// The error code returned by a SQLite C API call. See [SQLite Result /// Codes](http://www.sqlite.org/rescode.html) for details. pub code: c_int, @@ -109,26 +112,26 @@ pub struct SqliteError { pub message: String, } -impl fmt::Display for SqliteError { +impl fmt::Display for Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{} (SQLite error {})", self.message, self.code) } } -impl error::Error for SqliteError { +impl error::Error for Error { fn description(&self) -> &str { &self.message } } -impl SqliteError { - fn from_handle(db: *mut ffi::Struct_sqlite3, code: c_int) -> SqliteError { +impl Error { + fn from_handle(db: *mut ffi::Struct_sqlite3, code: c_int) -> Error { let message = if db.is_null() { ffi::code_to_str(code).to_string() } else { unsafe { errmsg_to_string(ffi::sqlite3_errmsg(db)) } }; - SqliteError { + Error { code: code, message: message, } @@ -137,7 +140,7 @@ impl SqliteError { fn str_to_cstring(s: &str) -> SqliteResult { CString::new(s).map_err(|_| { - SqliteError { + Error { code: ffi::SQLITE_MISUSE, message: format!("Could not convert string {} to C-combatible string", s), } @@ -145,7 +148,7 @@ fn str_to_cstring(s: &str) -> SqliteResult { } fn path_to_cstring(p: &Path) -> SqliteResult { - let s = try!(p.to_str().ok_or(SqliteError { + let s = try!(p.to_str().ok_or(Error { code: ffi::SQLITE_MISUSE, message: format!("Could not convert path {} to UTF-8 string", p.to_string_lossy()), @@ -382,7 +385,7 @@ impl Connection { /// Convenience method to execute a query that is expected to return a single row, /// and execute a mapping via `f` on that returned row with the possibility of failure. - /// The `Result` type of `f` must implement `std::convert::From`. + /// The `Result` type of `f` must implement `std::convert::From`. /// /// ## Example /// @@ -403,7 +406,7 @@ impl Connection { /// underlying SQLite call fails. pub fn query_row_and_then(&self, sql: &str, params: &[&ToSql], f: F) -> Result where F: FnOnce(SqliteRow) -> Result, - E: convert::From + E: convert::From { let mut stmt = try!(self.prepare(sql)); let mut rows = try!(stmt.query(params)); @@ -589,12 +592,12 @@ impl InnerConnection { 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() { - SqliteError { + Error { code: r, message: ffi::code_to_str(r).to_string(), } } else { - let e = SqliteError::from_handle(db, r); + let e = Error::from_handle(db, r); ffi::sqlite3_close(db); e }; @@ -603,7 +606,7 @@ impl InnerConnection { } let r = ffi::sqlite3_busy_timeout(db, 5000); if r != ffi::SQLITE_OK { - let e = SqliteError::from_handle(db, r); + let e = Error::from_handle(db, r); ffi::sqlite3_close(db); return Err(e); } @@ -619,7 +622,7 @@ impl InnerConnection { if code == ffi::SQLITE_OK { Ok(()) } else { - Err(SqliteError::from_handle(self.db(), code)) + Err(Error::from_handle(self.db(), code)) } } @@ -632,7 +635,7 @@ impl InnerConnection { } else { let message = errmsg_to_string(&*errmsg); ffi::sqlite3_free(errmsg as *mut c_void); - Err(SqliteError { + Err(Error { code: code, message: message, }) @@ -693,7 +696,7 @@ impl InnerConnection { sql: &str) -> SqliteResult> { if sql.len() >= ::std::i32::MAX as usize { - return Err(SqliteError { + return Err(Error { code: ffi::SQLITE_TOOBIG, message: "statement too long".to_string(), }); @@ -789,7 +792,7 @@ impl<'conn> SqliteStatement<'conn> { match r { ffi::SQLITE_DONE => { if self.column_count != 0 { - Err(SqliteError { + Err(Error { code: ffi::SQLITE_MISUSE, message: "Unexpected column count - did you mean to call query?" .to_string(), @@ -799,7 +802,7 @@ impl<'conn> SqliteStatement<'conn> { } } ffi::SQLITE_ROW => { - Err(SqliteError { + Err(Error { code: r, message: "Unexpected row result - did you mean to call query?".to_string(), }) @@ -867,7 +870,7 @@ impl<'conn> SqliteStatement<'conn> { /// Executes the prepared statement and maps a function over the resulting /// rows, where the function returns a `Result` with `Error` type implementing - /// `std::convert::From` (so errors can be unified). + /// `std::convert::From` (so errors can be unified). /// /// Unlike the iterator produced by `query`, the returned iterator does not expose the possibility /// for accessing stale rows. @@ -879,7 +882,7 @@ impl<'conn> SqliteStatement<'conn> { params: &[&ToSql], f: F) -> SqliteResult> - where E: convert::From, + where E: convert::From, F: FnMut(&SqliteRow) -> Result { let row_iter = try!(self.query(params)); @@ -968,14 +971,14 @@ impl<'stmt, T, F> Iterator for MappedRows<'stmt, F> where F: FnMut(&SqliteRow) - } /// An iterator over the mapped resulting rows of a query, with an Error type -/// unifying with SqliteError. +/// unifying with Error. pub struct AndThenRows<'stmt, F> { rows: SqliteRows<'stmt>, map: F, } impl<'stmt, T, E, F> Iterator for AndThenRows<'stmt, F> -where E: convert::From, +where E: convert::From, F: FnMut(&SqliteRow) -> Result { type Item = Result; @@ -1042,7 +1045,7 @@ impl<'stmt> SqliteRows<'stmt> { match self.next() { Some(row) => row, None => { - Err(SqliteError { + Err(Error { code: ffi::SQLITE_NOTICE, message: "Query did not return a row".to_string(), }) @@ -1121,21 +1124,21 @@ impl<'stmt> SqliteRow<'stmt> { /// /// ## Failure /// - /// Returns a `SQLITE_MISMATCH`-coded `SqliteError` if the underlying SQLite column + /// Returns a `SQLITE_MISMATCH`-coded `Error` if the underlying SQLite column /// type is not a valid type as a source for `T`. /// - /// Returns a `SQLITE_MISUSE`-coded `SqliteError` if `idx` is outside the valid column range + /// Returns a `SQLITE_MISUSE`-coded `Error` if `idx` is outside the valid column range /// for this row or if this row is stale. pub fn get_checked(&self, idx: c_int) -> SqliteResult { if self.row_idx != self.current_row.get() { - return Err(SqliteError { + return Err(Error { code: ffi::SQLITE_MISUSE, message: "Cannot get values from a row after advancing to next row".to_string(), }); } unsafe { if idx < 0 || idx >= self.stmt.column_count { - return Err(SqliteError { + return Err(Error { code: ffi::SQLITE_MISUSE, message: "Invalid column index".to_string(), }); @@ -1144,7 +1147,7 @@ impl<'stmt> SqliteRow<'stmt> { if T::column_has_valid_sqlite_type(self.stmt.stmt, idx) { FromSql::column_result(self.stmt.stmt, idx) } else { - Err(SqliteError { + Err(Error { code: ffi::SQLITE_MISMATCH, message: "Invalid column type".to_string(), }) @@ -1418,7 +1421,7 @@ mod test { #[derive(Debug, PartialEq)] enum CustomError { SomeError, - Sqlite(SqliteError), + Sqlite(Error), } impl fmt::Display for CustomError { @@ -1442,8 +1445,8 @@ mod test { } } - impl From for CustomError { - fn from(se: SqliteError) -> CustomError { + impl From for CustomError { + fn from(se: Error) -> CustomError { CustomError::Sqlite(se) } } @@ -1492,7 +1495,7 @@ mod test { .collect(); assert_eq!(bad_type, - Err(SqliteError { + Err(Error { code: ffi::SQLITE_MISMATCH, message: "Invalid column type".to_owned(), })); @@ -1503,7 +1506,7 @@ mod test { .collect(); assert_eq!(bad_idx, - Err(SqliteError { + Err(Error { code: ffi::SQLITE_MISUSE, message: "Invalid column index".to_owned(), })); @@ -1555,7 +1558,7 @@ mod test { .collect(); assert_eq!(bad_type, - Err(CustomError::Sqlite(SqliteError { + Err(CustomError::Sqlite(Error { code: ffi::SQLITE_MISMATCH, message: "Invalid column type".to_owned(), }))); @@ -1568,7 +1571,7 @@ mod test { .collect(); assert_eq!(bad_idx, - Err(CustomError::Sqlite(SqliteError { + Err(CustomError::Sqlite(Error { code: ffi::SQLITE_MISUSE, message: "Invalid column index".to_owned(), }))); @@ -1616,7 +1619,7 @@ mod test { }); assert_eq!(bad_type, - Err(CustomError::Sqlite(SqliteError { + Err(CustomError::Sqlite(Error { code: ffi::SQLITE_MISMATCH, message: "Invalid column type".to_owned(), }))); @@ -1626,7 +1629,7 @@ mod test { }); assert_eq!(bad_idx, - Err(CustomError::Sqlite(SqliteError { + Err(CustomError::Sqlite(Error { code: ffi::SQLITE_MISUSE, message: "Invalid column index".to_owned(), }))); diff --git a/src/named_params.rs b/src/named_params.rs index 60e99d8..0247c7f 100644 --- a/src/named_params.rs +++ b/src/named_params.rs @@ -2,7 +2,7 @@ use libc::c_int; use super::ffi; -use {SqliteResult, SqliteError, Connection, SqliteStatement, SqliteRows, SqliteRow, +use {SqliteResult, Error, Connection, SqliteStatement, SqliteRows, SqliteRow, str_to_cstring}; use types::ToSql; @@ -134,7 +134,7 @@ impl<'conn> SqliteStatement<'conn> { if let Some(i) = try!(self.parameter_index(name)) { try!(self.conn.decode_result(unsafe { value.bind_parameter(self.stmt, i) })); } else { - return Err(SqliteError { + return Err(Error { code: ffi::SQLITE_MISUSE, message: format!("Invalid parameter name: {}", name), }); diff --git a/src/trace.rs b/src/trace.rs index f79f619..9894d3f 100644 --- a/src/trace.rs +++ b/src/trace.rs @@ -8,7 +8,7 @@ use std::str; use std::time::Duration; use super::ffi; -use {SqliteError, SqliteResult, Connection}; +use {Error, SqliteResult, Connection}; /// Set up the process-wide SQLite error logging callback. /// This function is marked unsafe for two reasons: @@ -43,7 +43,7 @@ pub unsafe fn config_log(callback: Option) -> SqliteResult<()> }; if rc != ffi::SQLITE_OK { - return Err(SqliteError { + return Err(Error { code: rc, message: "sqlite3_config(SQLITE_CONFIG_LOG, ...)".to_string(), }); diff --git a/src/types.rs b/src/types.rs index bf5f86c..274e990 100644 --- a/src/types.rs +++ b/src/types.rs @@ -59,7 +59,7 @@ use std::ffi::CStr; use std::mem; use std::str; use super::ffi; -use super::{SqliteResult, SqliteError, str_to_cstring}; +use super::{SqliteResult, Error, str_to_cstring}; pub use ffi::sqlite3_stmt; pub use ffi::sqlite3_column_type; @@ -235,7 +235,7 @@ impl FromSql for String { let utf8_str = str::from_utf8(c_slice); utf8_str.map(|s| s.to_string()) .map_err(|e| { - SqliteError { + Error { code: 0, message: e.to_string(), } @@ -275,7 +275,7 @@ impl FromSql for time::Timespec { time::strptime(&txt, SQLITE_DATETIME_FMT) .map(|tm| tm.to_timespec()) .map_err(|parse_error| { - SqliteError { + Error { code: ffi::SQLITE_MISMATCH, message: format!("{}", parse_error), } From eb60bb3111382a3cefa2e6dbd517a5693867a6ff Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Sat, 12 Dec 2015 14:06:03 -0500 Subject: [PATCH 03/11] Rename `SqliteResult` -> `Result`. --- Changelog.md | 7 +- README.md | 2 +- src/backup.rs | 18 ++-- src/functions.rs | 46 +++++----- src/lib.rs | 170 ++++++++++++++++++------------------ src/load_extension_guard.rs | 8 +- src/named_params.rs | 26 +++--- src/trace.rs | 4 +- src/transaction.rs | 30 +++---- src/types.rs | 24 ++--- 10 files changed, 171 insertions(+), 164 deletions(-) diff --git a/Changelog.md b/Changelog.md index d23ea20..e9d7d56 100644 --- a/Changelog.md +++ b/Changelog.md @@ -1,7 +1,10 @@ # Version UPCOMING (TBD) -* Renamed `SqliteConnection` to `Connection`. The old name remains as a typealias. -* Renamed `SqliteError` to `Error`. The old name remains as a typealias. +* Removed `Sqlite` prefix on many types: + * `SqliteConnection` is now `Connection` + * `SqliteError` is now `Error` + * `SqliteResult` is now `Result` + The old, prefixed names are still exported should be considered deprecated. * Adds a variety of `..._named` methods for executing queries using named placeholder parameters. * Adds `backup` feature that exposes SQLite's online backup API. * Adds `functions` feature that allows user-defined scalar functions to be added to diff --git a/README.md b/README.md index 96f0fd3..05c8d98 100644 --- a/README.md +++ b/README.md @@ -72,7 +72,7 @@ performing checks at runtime to ensure you do not try to retrieve the values of will panic if you do so. A specific example that will panic: ```rust -fn bad_function_will_panic(conn: &Connection) -> SqliteResult { +fn bad_function_will_panic(conn: &Connection) -> Result { let mut stmt = try!(conn.prepare("SELECT id FROM my_table")); let mut rows = try!(stmt.query(&[])); diff --git a/src/backup.rs b/src/backup.rs index 02181f2..8eb5625 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -14,12 +14,12 @@ //! documentation](https://www.sqlite.org/backup.html). //! //! ```rust,no_run -//! # use rusqlite::{backup, Connection, SqliteResult}; +//! # use rusqlite::{backup, Connection, Result}; //! # use std::path::Path; //! # use std::time; //! //! fn backupDb>(src: &Connection, dst: P, progress: fn(backup::Progress)) -//! -> SqliteResult<()> { +//! -> Result<()> { //! let mut dst = try!(Connection::open(dst)); //! let backup = try!(backup::Backup::new(src, &mut dst)); //! backup.run_to_completion(5, time::Duration::from_millis(250), Some(progress)) @@ -36,7 +36,7 @@ use std::time::Duration; use ffi; -use {DatabaseName, Connection, Error, SqliteResult}; +use {DatabaseName, Connection, Error, Result}; impl Connection { /// Back up the `name` database to the given destination path. @@ -55,7 +55,7 @@ impl Connection { name: DatabaseName, dst_path: P, progress: Option) - -> SqliteResult<()> { + -> Result<()> { use self::StepResult::{More, Done, Busy, Locked}; let mut dst = try!(Connection::open(dst_path)); let backup = try!(Backup::new_with_names(self, name, &mut dst, DatabaseName::Main)); @@ -92,7 +92,7 @@ impl Connection { name: DatabaseName, src_path: P, progress: Option) - -> SqliteResult<()> { + -> Result<()> { use self::StepResult::{More, Done, Busy, Locked}; let src = try!(Connection::open(src_path)); let restore = try!(Backup::new_with_names(&src, DatabaseName::Main, self, name)); @@ -172,7 +172,7 @@ impl<'a, 'b> Backup<'a, 'b> { /// `NULL`. pub fn new(from: &'a Connection, to: &'b mut Connection) - -> SqliteResult> { + -> Result> { Backup::new_with_names(from, DatabaseName::Main, to, DatabaseName::Main) } @@ -189,7 +189,7 @@ impl<'a, 'b> Backup<'a, 'b> { from_name: DatabaseName, to: &'b mut Connection, to_name: DatabaseName) - -> SqliteResult> { + -> Result> { let to_name = try!(to_name.to_cstring()); let from_name = try!(from_name.to_cstring()); @@ -235,7 +235,7 @@ impl<'a, 'b> Backup<'a, 'b> { /// an error code other than `DONE`, `OK`, `BUSY`, or `LOCKED`. `BUSY` and /// `LOCKED` are transient errors and are therefore returned as possible /// `Ok` values. - pub fn step(&self, num_pages: c_int) -> SqliteResult { + pub fn step(&self, num_pages: c_int) -> Result { use self::StepResult::{Done, More, Busy, Locked}; let rc = unsafe { ffi::sqlite3_backup_step(self.b, num_pages) }; @@ -272,7 +272,7 @@ impl<'a, 'b> Backup<'a, 'b> { pages_per_step: c_int, pause_between_pages: Duration, progress: Option) - -> SqliteResult<()> { + -> Result<()> { use self::StepResult::{Done, More, Busy, Locked}; assert!(pages_per_step > 0, "pages_per_step must be positive"); diff --git a/src/functions.rs b/src/functions.rs index aa0fdf4..502b83a 100644 --- a/src/functions.rs +++ b/src/functions.rs @@ -12,11 +12,11 @@ //! extern crate rusqlite; //! extern crate regex; //! -//! use rusqlite::{Connection, Error, SqliteResult}; +//! use rusqlite::{Connection, Error, Result}; //! use std::collections::HashMap; //! use regex::Regex; //! -//! fn add_regexp_function(db: &Connection) -> SqliteResult<()> { +//! 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)); @@ -65,7 +65,7 @@ pub use ffi::sqlite3_value_numeric_type; use types::Null; -use {SqliteResult, Error, Connection, str_to_cstring, InnerConnection}; +use {Result, Error, Connection, str_to_cstring, InnerConnection}; /// A trait for types that can be converted into the result of an SQL function. pub trait ToResult { @@ -165,7 +165,7 @@ impl ToResult for Null { /// A trait for types that can be created from a SQLite function parameter value. pub trait FromValue: Sized { - unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult; + unsafe fn parameter_value(v: *mut sqlite3_value) -> Result; /// FromValue types can implement this method and use sqlite3_value_type to check that /// the type reported by SQLite matches a type suitable for Self. This method is used @@ -180,7 +180,7 @@ pub trait FromValue: Sized { macro_rules! raw_from_impl( ($t:ty, $f:ident, $c:expr) => ( impl FromValue for $t { - unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult<$t> { + unsafe fn parameter_value(v: *mut sqlite3_value) -> Result<$t> { Ok(ffi::$f(v)) } @@ -195,7 +195,7 @@ raw_from_impl!(c_int, sqlite3_value_int, ffi::SQLITE_INTEGER); raw_from_impl!(i64, sqlite3_value_int64, ffi::SQLITE_INTEGER); impl FromValue for bool { - unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult { + unsafe fn parameter_value(v: *mut sqlite3_value) -> Result { match ffi::sqlite3_value_int(v) { 0 => Ok(false), _ => Ok(true), @@ -208,7 +208,7 @@ impl FromValue for bool { } impl FromValue for c_double { - unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult { + unsafe fn parameter_value(v: *mut sqlite3_value) -> Result { Ok(ffi::sqlite3_value_double(v)) } @@ -219,7 +219,7 @@ impl FromValue for c_double { } impl FromValue for String { - unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult { + unsafe fn parameter_value(v: *mut sqlite3_value) -> Result { let c_text = ffi::sqlite3_value_text(v); if c_text.is_null() { Ok("".to_string()) @@ -242,7 +242,7 @@ impl FromValue for String { } impl FromValue for Vec { - unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult> { + unsafe fn parameter_value(v: *mut sqlite3_value) -> Result> { use std::slice::from_raw_parts; let c_blob = ffi::sqlite3_value_blob(v); let len = ffi::sqlite3_value_bytes(v); @@ -260,7 +260,7 @@ impl FromValue for Vec { } impl FromValue for Option { - unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult> { + unsafe fn parameter_value(v: *mut sqlite3_value) -> Result> { if sqlite3_value_type(v) == ffi::SQLITE_NULL { Ok(None) } else { @@ -296,7 +296,7 @@ impl<'a> Context<'a> { /// Will panic if `idx` is greater than or equal to `self.len()`. /// /// Will return Err if the underlying SQLite type cannot be converted to a `T`. - pub fn get(&self, idx: usize) -> SqliteResult { + pub fn get(&self, idx: usize) -> Result { let arg = self.args[idx]; unsafe { if T::parameter_has_valid_sqlite_type(arg) { @@ -355,9 +355,9 @@ impl Connection { /// # Example /// /// ```rust - /// # use rusqlite::{Connection, SqliteResult}; + /// # use rusqlite::{Connection, Result}; /// # type c_double = f64; - /// fn scalar_function_example(db: Connection) -> SqliteResult<()> { + /// fn scalar_function_example(db: Connection) -> Result<()> { /// try!(db.create_scalar_function("halve", 1, true, |ctx| { /// let value = try!(ctx.get::(0)); /// Ok(value / 2f64) @@ -377,8 +377,8 @@ impl Connection { n_arg: c_int, deterministic: bool, x_func: F) - -> SqliteResult<()> - where F: FnMut(&Context) -> SqliteResult, + -> Result<()> + where F: FnMut(&Context) -> Result, T: ToResult { self.db.borrow_mut().create_scalar_function(fn_name, n_arg, deterministic, x_func) @@ -392,7 +392,7 @@ impl Connection { /// # Failure /// /// Will return Err if the function could not be removed. - pub fn remove_function(&self, fn_name: &str, n_arg: c_int) -> SqliteResult<()> { + pub fn remove_function(&self, fn_name: &str, n_arg: c_int) -> Result<()> { self.db.borrow_mut().remove_function(fn_name, n_arg) } } @@ -403,14 +403,14 @@ impl InnerConnection { n_arg: c_int, deterministic: bool, x_func: F) - -> SqliteResult<()> - where F: FnMut(&Context) -> SqliteResult, + -> Result<()> + where F: FnMut(&Context) -> Result, T: ToResult { extern "C" fn call_boxed_closure(ctx: *mut sqlite3_context, argc: c_int, argv: *mut *mut sqlite3_value) - where F: FnMut(&Context) -> SqliteResult, + where F: FnMut(&Context) -> Result, T: ToResult { unsafe { @@ -452,7 +452,7 @@ impl InnerConnection { self.decode_result(r) } - fn remove_function(&mut self, fn_name: &str, n_arg: c_int) -> SqliteResult<()> { + fn remove_function(&mut self, fn_name: &str, n_arg: c_int) -> Result<()> { let c_name = try!(str_to_cstring(fn_name)); let r = unsafe { ffi::sqlite3_create_function_v2(self.db(), @@ -477,11 +477,11 @@ mod test { use libc::c_double; use self::regex::Regex; - use {Connection, Error, SqliteResult}; + use {Connection, Error, Result}; use ffi; use functions::Context; - fn half(ctx: &Context) -> SqliteResult { + fn half(ctx: &Context) -> Result { assert!(ctx.len() == 1, "called with unexpected number of arguments"); let value = try!(ctx.get::(0)); Ok(value / 2f64) @@ -511,7 +511,7 @@ mod test { // This implementation of a regexp scalar function uses SQLite's auxilliary data // (https://www.sqlite.org/c3ref/get_auxdata.html) to avoid recompiling the regular // expression multiple times within one query. - fn regexp_with_auxilliary(ctx: &Context) -> SqliteResult { + fn regexp_with_auxilliary(ctx: &Context) -> Result { assert!(ctx.len() == 2, "called with unexpected number of arguments"); let saved_re: Option<&Regex> = unsafe { ctx.get_aux(0) }; diff --git a/src/lib.rs b/src/lib.rs index b718ac6..eb43b04 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -68,6 +68,7 @@ use std::error; use std::rc::Rc; use std::cell::{RefCell, Cell}; use std::ffi::{CStr, CString}; +use std::result; use std::str; use libc::{c_int, c_void, c_char}; @@ -88,8 +89,11 @@ mod named_params; #[cfg(feature = "backup")]pub mod backup; #[cfg(feature = "functions")] pub mod functions; +/// Old name for `Result`. `SqliteResult` is deprecated. +pub type SqliteResult = Result; + /// A typedef of the result returned by many methods. -pub type SqliteResult = Result; +pub type Result = result::Result; unsafe fn errmsg_to_string(errmsg: *const c_char) -> String { let c_slice = CStr::from_ptr(errmsg).to_bytes(); @@ -138,7 +142,7 @@ impl Error { } } -fn str_to_cstring(s: &str) -> SqliteResult { +fn str_to_cstring(s: &str) -> Result { CString::new(s).map_err(|_| { Error { code: ffi::SQLITE_MISUSE, @@ -147,7 +151,7 @@ fn str_to_cstring(s: &str) -> SqliteResult { }) } -fn path_to_cstring(p: &Path) -> SqliteResult { +fn path_to_cstring(p: &Path) -> Result { let s = try!(p.to_str().ok_or(Error { code: ffi::SQLITE_MISUSE, message: format!("Could not convert path {} to UTF-8 string", @@ -172,7 +176,7 @@ pub enum DatabaseName<'a> { // impl to avoid dead code warnings. #[cfg(feature = "backup")] impl<'a> DatabaseName<'a> { - fn to_cstring(self) -> SqliteResult { + fn to_cstring(self) -> Result { use self::DatabaseName::{Main, Temp, Attached}; match self { Main => str_to_cstring("main"), @@ -203,7 +207,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>(path: P) -> SqliteResult { + pub fn open>(path: P) -> Result { let flags = Default::default(); Connection::open_with_flags(path, flags) } @@ -213,7 +217,7 @@ impl Connection { /// # Failure /// /// Will return `Err` if the underlying SQLite open call fails. - pub fn open_in_memory() -> SqliteResult { + pub fn open_in_memory() -> Result { let flags = Default::default(); Connection::open_in_memory_with_flags(flags) } @@ -229,7 +233,7 @@ impl Connection { /// underlying SQLite open call fails. pub fn open_with_flags>(path: P, flags: SqliteOpenFlags) - -> SqliteResult { + -> Result { let c_path = try!(path_to_cstring(path.as_ref())); InnerConnection::open_with_flags(&c_path, flags).map(|db| { Connection { @@ -247,7 +251,7 @@ impl Connection { /// # Failure /// /// Will return `Err` if the underlying SQLite open call fails. - pub fn open_in_memory_with_flags(flags: SqliteOpenFlags) -> SqliteResult { + pub fn open_in_memory_with_flags(flags: SqliteOpenFlags) -> Result { let c_memory = try!(str_to_cstring(":memory:")); InnerConnection::open_with_flags(&c_memory, flags).map(|db| { Connection { @@ -265,10 +269,10 @@ impl Connection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{Connection, SqliteResult}; - /// # fn do_queries_part_1(conn: &Connection) -> SqliteResult<()> { Ok(()) } - /// # fn do_queries_part_2(conn: &Connection) -> SqliteResult<()> { Ok(()) } - /// fn perform_queries(conn: &Connection) -> SqliteResult<()> { + /// # use rusqlite::{Connection, Result}; + /// # fn do_queries_part_1(conn: &Connection) -> Result<()> { Ok(()) } + /// # fn do_queries_part_2(conn: &Connection) -> Result<()> { Ok(()) } + /// fn perform_queries(conn: &Connection) -> Result<()> { /// let tx = try!(conn.transaction()); /// /// try!(do_queries_part_1(conn)); // tx causes rollback if this fails @@ -281,7 +285,7 @@ impl Connection { /// # Failure /// /// Will return `Err` if the underlying SQLite call fails. - pub fn transaction<'a>(&'a self) -> SqliteResult> { + pub fn transaction<'a>(&'a self) -> Result> { SqliteTransaction::new(self, SqliteTransactionDeferred) } @@ -294,7 +298,7 @@ impl Connection { /// Will return `Err` if the underlying SQLite call fails. pub fn transaction_with_behavior<'a>(&'a self, behavior: SqliteTransactionBehavior) - -> SqliteResult> { + -> Result> { SqliteTransaction::new(self, behavior) } @@ -305,8 +309,8 @@ impl Connection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{Connection, SqliteResult}; - /// fn create_tables(conn: &Connection) -> SqliteResult<()> { + /// # use rusqlite::{Connection, Result}; + /// fn create_tables(conn: &Connection) -> Result<()> { /// conn.execute_batch("BEGIN; /// CREATE TABLE foo(x INTEGER); /// CREATE TABLE bar(y TEXT); @@ -318,7 +322,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 execute_batch(&self, sql: &str) -> SqliteResult<()> { + pub fn execute_batch(&self, sql: &str) -> Result<()> { self.db.borrow_mut().execute_batch(sql) } @@ -343,7 +347,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 execute(&self, sql: &str, params: &[&ToSql]) -> SqliteResult { + pub fn execute(&self, sql: &str, params: &[&ToSql]) -> Result { self.prepare(sql).and_then(|mut stmt| stmt.execute(params)) } @@ -360,8 +364,8 @@ impl Connection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteResult,Connection}; - /// fn preferred_locale(conn: &Connection) -> SqliteResult { + /// # use rusqlite::{Result,Connection}; + /// fn preferred_locale(conn: &Connection) -> Result { /// conn.query_row("SELECT value FROM preferences WHERE name='locale'", &[], |row| { /// row.get(0) /// }) @@ -374,7 +378,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(&self, sql: &str, params: &[&ToSql], f: F) -> SqliteResult + pub fn query_row(&self, sql: &str, params: &[&ToSql], f: F) -> Result where F: FnOnce(SqliteRow) -> T { let mut stmt = try!(self.prepare(sql)); @@ -390,8 +394,8 @@ impl Connection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteResult,Connection}; - /// fn preferred_locale(conn: &Connection) -> SqliteResult { + /// # use rusqlite::{Result,Connection}; + /// fn preferred_locale(conn: &Connection) -> Result { /// conn.query_row_and_then("SELECT value FROM preferences WHERE name='locale'", &[], |row| { /// row.get_checked(0) /// }) @@ -404,8 +408,8 @@ 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 - where F: FnOnce(SqliteRow) -> Result, + pub fn query_row_and_then(&self, sql: &str, params: &[&ToSql], f: F) -> result::Result + where F: FnOnce(SqliteRow) -> result::Result, E: convert::From { let mut stmt = try!(self.prepare(sql)); @@ -419,8 +423,8 @@ impl Connection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{SqliteResult,Connection}; - /// fn preferred_locale(conn: &Connection) -> SqliteResult { + /// # use rusqlite::{Result,Connection}; + /// fn preferred_locale(conn: &Connection) -> Result { /// conn.query_row_safe("SELECT value FROM preferences WHERE name='locale'", &[], |row| { /// row.get(0) /// }) @@ -433,7 +437,7 @@ impl Connection { /// /// This method should be considered deprecated. Use `query_row` instead, which now /// does exactly the same thing. - pub fn query_row_safe(&self, sql: &str, params: &[&ToSql], f: F) -> SqliteResult + pub fn query_row_safe(&self, sql: &str, params: &[&ToSql], f: F) -> Result where F: FnOnce(SqliteRow) -> T { self.query_row(sql, params, f) @@ -444,8 +448,8 @@ impl Connection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{Connection, SqliteResult}; - /// fn insert_new_people(conn: &Connection) -> SqliteResult<()> { + /// # 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"])); @@ -457,7 +461,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 prepare<'a>(&'a self, sql: &str) -> SqliteResult> { + pub fn prepare<'a>(&'a self, sql: &str) -> Result> { self.db.borrow_mut().prepare(self, sql) } @@ -469,7 +473,7 @@ impl Connection { /// # Failure /// /// Will return `Err` if the underlying SQLite call fails. - pub fn close(self) -> SqliteResult<()> { + pub fn close(self) -> Result<()> { let mut db = self.db.borrow_mut(); db.close() } @@ -480,9 +484,9 @@ impl Connection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{Connection, SqliteResult}; + /// # use rusqlite::{Connection, Result}; /// # use std::path::{Path}; - /// fn load_my_extension(conn: &Connection) -> SqliteResult<()> { + /// 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_disable() @@ -493,7 +497,7 @@ impl Connection { /// /// Will return `Err` if the underlying SQLite call fails. #[cfg(feature = "load_extension")] - pub fn load_extension_enable(&self) -> SqliteResult<()> { + pub fn load_extension_enable(&self) -> Result<()> { self.db.borrow_mut().enable_load_extension(1) } @@ -505,7 +509,7 @@ impl Connection { /// /// Will return `Err` if the underlying SQLite call fails. #[cfg(feature = "load_extension")] - pub fn load_extension_disable(&self) -> SqliteResult<()> { + pub fn load_extension_disable(&self) -> Result<()> { self.db.borrow_mut().enable_load_extension(0) } @@ -519,9 +523,9 @@ impl Connection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{Connection, SqliteResult, SqliteLoadExtensionGuard}; + /// # use rusqlite::{Connection, Result, SqliteLoadExtensionGuard}; /// # use std::path::{Path}; - /// fn load_my_extension(conn: &Connection) -> SqliteResult<()> { + /// fn load_my_extension(conn: &Connection) -> Result<()> { /// let _guard = try!(SqliteLoadExtensionGuard::new(conn)); /// /// conn.load_extension("my_sqlite_extension", None) @@ -535,11 +539,11 @@ impl Connection { pub fn load_extension>(&self, dylib_path: P, entry_point: Option<&str>) - -> SqliteResult<()> { + -> Result<()> { self.db.borrow_mut().load_extension(dylib_path.as_ref(), entry_point) } - fn decode_result(&self, code: c_int) -> SqliteResult<()> { + fn decode_result(&self, code: c_int) -> Result<()> { self.db.borrow_mut().decode_result(code) } @@ -586,7 +590,7 @@ impl Default for SqliteOpenFlags { impl InnerConnection { fn open_with_flags(c_path: &CString, flags: SqliteOpenFlags) - -> SqliteResult { + -> Result { unsafe { let mut db: *mut ffi::sqlite3 = mem::uninitialized(); let r = ffi::sqlite3_open_v2(c_path.as_ptr(), &mut db, flags.bits(), ptr::null()); @@ -618,7 +622,7 @@ impl InnerConnection { self.db } - fn decode_result(&mut self, code: c_int) -> SqliteResult<()> { + fn decode_result(&mut self, code: c_int) -> Result<()> { if code == ffi::SQLITE_OK { Ok(()) } else { @@ -629,7 +633,7 @@ impl InnerConnection { unsafe fn decode_result_with_errmsg(&self, code: c_int, errmsg: *mut c_char) - -> SqliteResult<()> { + -> Result<()> { if code == ffi::SQLITE_OK { Ok(()) } else { @@ -642,7 +646,7 @@ impl InnerConnection { } } - fn close(&mut self) -> SqliteResult<()> { + fn close(&mut self) -> Result<()> { unsafe { let r = ffi::sqlite3_close(self.db()); self.db = ptr::null_mut(); @@ -650,7 +654,7 @@ impl InnerConnection { } } - fn execute_batch(&mut self, sql: &str) -> SqliteResult<()> { + fn execute_batch(&mut self, sql: &str) -> Result<()> { let c_sql = try!(str_to_cstring(sql)); unsafe { let mut errmsg: *mut c_char = mem::uninitialized(); @@ -664,13 +668,13 @@ impl InnerConnection { } #[cfg(feature = "load_extension")] - fn enable_load_extension(&mut self, onoff: c_int) -> SqliteResult<()> { + fn enable_load_extension(&mut self, onoff: c_int) -> Result<()> { let r = unsafe { ffi::sqlite3_enable_load_extension(self.db, onoff) }; self.decode_result(r) } #[cfg(feature = "load_extension")] - fn load_extension(&self, dylib_path: &Path, entry_point: Option<&str>) -> SqliteResult<()> { + fn load_extension(&self, dylib_path: &Path, entry_point: Option<&str>) -> Result<()> { let dylib_str = try!(path_to_cstring(dylib_path)); unsafe { let mut errmsg: *mut c_char = mem::uninitialized(); @@ -694,7 +698,7 @@ impl InnerConnection { fn prepare<'a>(&mut self, conn: &'a Connection, sql: &str) - -> SqliteResult> { + -> Result> { if sql.len() >= ::std::i32::MAX as usize { return Err(Error { code: ffi::SQLITE_TOOBIG, @@ -764,8 +768,8 @@ impl<'conn> SqliteStatement<'conn> { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{Connection, SqliteResult}; - /// fn update_rows(conn: &Connection) -> SqliteResult<()> { + /// # use rusqlite::{Connection, Result}; + /// fn update_rows(conn: &Connection) -> Result<()> { /// let mut stmt = try!(conn.prepare("UPDATE foo SET bar = 'baz' WHERE qux = ?")); /// /// try!(stmt.execute(&[&1i32])); @@ -779,14 +783,14 @@ impl<'conn> SqliteStatement<'conn> { /// /// Will return `Err` if binding parameters fails, the executed statement returns rows (in /// which case `query` should be used instead), or the underling SQLite call fails. - pub fn execute(&mut self, params: &[&ToSql]) -> SqliteResult { + pub fn execute(&mut self, params: &[&ToSql]) -> Result { unsafe { try!(self.bind_parameters(params)); self.execute_() } } - unsafe fn execute_(&mut self) -> SqliteResult { + unsafe fn execute_(&mut self) -> Result { let r = ffi::sqlite3_step(self.stmt); ffi::sqlite3_reset(self.stmt); match r { @@ -816,8 +820,8 @@ impl<'conn> SqliteStatement<'conn> { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{Connection, SqliteResult}; - /// fn get_names(conn: &Connection) -> SqliteResult> { + /// # use rusqlite::{Connection, Result}; + /// fn get_names(conn: &Connection) -> Result> { /// let mut stmt = try!(conn.prepare("SELECT name FROM people")); /// let mut rows = try!(stmt.query(&[])); /// @@ -834,7 +838,7 @@ impl<'conn> SqliteStatement<'conn> { /// # Failure /// /// Will return `Err` if binding parameters fails. - pub fn query<'a>(&'a mut self, params: &[&ToSql]) -> SqliteResult> { + pub fn query<'a>(&'a mut self, params: &[&ToSql]) -> Result> { self.reset_if_needed(); unsafe { @@ -857,7 +861,7 @@ impl<'conn> SqliteStatement<'conn> { pub fn query_map<'a, T, F>(&'a mut self, params: &[&ToSql], f: F) - -> SqliteResult> + -> Result> where F: FnMut(&SqliteRow) -> T { let row_iter = try!(self.query(params)); @@ -881,9 +885,9 @@ impl<'conn> SqliteStatement<'conn> { pub fn query_and_then<'a, T, E, F>(&'a mut self, params: &[&ToSql], f: F) - -> SqliteResult> + -> Result> where E: convert::From, - F: FnMut(&SqliteRow) -> Result + F: FnMut(&SqliteRow) -> result::Result { let row_iter = try!(self.query(params)); @@ -901,11 +905,11 @@ impl<'conn> SqliteStatement<'conn> { /// # Failure /// /// Will return `Err` if the underlying SQLite call fails. - pub fn finalize(mut self) -> SqliteResult<()> { + pub fn finalize(mut self) -> Result<()> { self.finalize_() } - unsafe fn bind_parameters(&mut self, params: &[&ToSql]) -> SqliteResult<()> { + 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), @@ -927,7 +931,7 @@ impl<'conn> SqliteStatement<'conn> { } } - fn finalize_(&mut self) -> SqliteResult<()> { + fn finalize_(&mut self) -> Result<()> { let r = unsafe { ffi::sqlite3_finalize(self.stmt) }; self.stmt = ptr::null_mut(); self.conn.decode_result(r) @@ -963,9 +967,9 @@ pub struct MappedRows<'stmt, F> { impl<'stmt, T, F> Iterator for MappedRows<'stmt, F> where F: FnMut(&SqliteRow) -> T { - type Item = SqliteResult; + type Item = Result; - fn next(&mut self) -> Option> { + fn next(&mut self) -> Option> { self.rows.next().map(|row_result| row_result.map(|row| (self.map)(&row))) } } @@ -979,9 +983,9 @@ pub struct AndThenRows<'stmt, F> { impl<'stmt, T, E, F> Iterator for AndThenRows<'stmt, F> where E: convert::From, - F: FnMut(&SqliteRow) -> Result + F: FnMut(&SqliteRow) -> result::Result { - type Item = Result; + type Item = result::Result; fn next(&mut self) -> Option { self.rows.next().map(|row_result| { @@ -1000,8 +1004,8 @@ where E: convert::From, /// iterator). For example: /// /// ```rust,no_run -/// # use rusqlite::{Connection, SqliteResult}; -/// fn bad_function_will_panic(conn: &Connection) -> SqliteResult { +/// # use rusqlite::{Connection, Result}; +/// fn bad_function_will_panic(conn: &Connection) -> Result { /// let mut stmt = try!(conn.prepare("SELECT id FROM my_table")); /// let mut rows = try!(stmt.query(&[])); /// @@ -1041,7 +1045,7 @@ impl<'stmt> SqliteRows<'stmt> { } } - fn get_expected_row(&mut self) -> SqliteResult> { + fn get_expected_row(&mut self) -> Result> { match self.next() { Some(row) => row, None => { @@ -1055,9 +1059,9 @@ impl<'stmt> SqliteRows<'stmt> { } impl<'stmt> Iterator for SqliteRows<'stmt> { - type Item = SqliteResult>; + type Item = Result>; - fn next(&mut self) -> Option>> { + fn next(&mut self) -> Option>> { if self.failed { return None; } @@ -1096,8 +1100,8 @@ impl<'stmt> SqliteRow<'stmt> { /// for example) this isn't an issue, but it means you cannot do something like this: /// /// ```rust,no_run - /// # use rusqlite::{Connection, SqliteResult}; - /// fn bad_function_will_panic(conn: &Connection) -> SqliteResult { + /// # use rusqlite::{Connection, Result}; + /// fn bad_function_will_panic(conn: &Connection) -> Result { /// let mut stmt = try!(conn.prepare("SELECT id FROM my_table")); /// let mut rows = try!(stmt.query(&[])); /// @@ -1129,7 +1133,7 @@ impl<'stmt> SqliteRow<'stmt> { /// /// Returns a `SQLITE_MISUSE`-coded `Error` if `idx` is outside the valid column range /// for this row or if this row is stale. - pub fn get_checked(&self, idx: c_int) -> SqliteResult { + pub fn get_checked(&self, idx: c_int) -> Result { if self.row_idx != self.current_row.get() { return Err(Error { code: ffi::SQLITE_MISUSE, @@ -1240,10 +1244,10 @@ mod test { let db = checked_memory_handle(); db.execute_batch("CREATE TABLE foo(x INTEGER)").unwrap(); - assert_eq!(db.execute("INSERT INTO foo(x) VALUES (?)", &[&1i32]).unwrap(), - 1); - assert_eq!(db.execute("INSERT INTO foo(x) VALUES (?)", &[&2i32]).unwrap(), - 1); + assert_eq!(1, + db.execute("INSERT INTO foo(x) VALUES (?)", &[&1i32]).unwrap()); + assert_eq!(1, + db.execute("INSERT INTO foo(x) VALUES (?)", &[&2i32]).unwrap()); assert_eq!(3i32, db.query_row("SELECT SUM(x) FROM foo", &[], |r| r.get(0)).unwrap()); @@ -1328,7 +1332,7 @@ mod test { db.execute_batch(sql).unwrap(); let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap(); - let results: SqliteResult> = query.query_map(&[], |row| row.get(1)) + let results: Result> = query.query_map(&[], |row| row.get(1)) .unwrap() .collect(); @@ -1425,7 +1429,7 @@ mod test { } impl fmt::Display for CustomError { - fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + fn fmt(&self, f: &mut fmt::Formatter) -> ::std::result::Result<(), fmt::Error> { match *self { CustomError::SomeError => write!(f, "{}", self.description()), CustomError::Sqlite(ref se) => write!(f, "{}: {}", self.description(), se), @@ -1451,7 +1455,7 @@ mod test { } } - type CustomResult = Result; + type CustomResult = ::std::result::Result; #[test] #[cfg_attr(rustfmt, rustfmt_skip)] @@ -1467,7 +1471,7 @@ mod test { db.execute_batch(sql).unwrap(); let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap(); - let results: SqliteResult> = query.query_and_then(&[], + let results: Result> = query.query_and_then(&[], |row| row.get_checked(1)) .unwrap() .collect(); @@ -1489,7 +1493,7 @@ mod test { db.execute_batch(sql).unwrap(); let mut query = db.prepare("SELECT x, y FROM foo ORDER BY x DESC").unwrap(); - let bad_type: SqliteResult> = query.query_and_then(&[], + let bad_type: Result> = query.query_and_then(&[], |row| row.get_checked(1)) .unwrap() .collect(); @@ -1500,7 +1504,7 @@ mod test { message: "Invalid column type".to_owned(), })); - let bad_idx: SqliteResult> = query.query_and_then(&[], + let bad_idx: Result> = query.query_and_then(&[], |row| row.get_checked(3)) .unwrap() .collect(); diff --git a/src/load_extension_guard.rs b/src/load_extension_guard.rs index 2c02798..bec82d1 100644 --- a/src/load_extension_guard.rs +++ b/src/load_extension_guard.rs @@ -1,13 +1,13 @@ -use {SqliteResult, Connection}; +use {Result, Connection}; /// RAII guard temporarily enabling SQLite extensions to be loaded. /// /// ## Example /// /// ```rust,no_run -/// # use rusqlite::{Connection, SqliteResult, SqliteLoadExtensionGuard}; +/// # use rusqlite::{Connection, Result, SqliteLoadExtensionGuard}; /// # use std::path::{Path}; -/// fn load_my_extension(conn: &Connection) -> SqliteResult<()> { +/// fn load_my_extension(conn: &Connection) -> Result<()> { /// let _guard = try!(SqliteLoadExtensionGuard::new(conn)); /// /// conn.load_extension(Path::new("my_sqlite_extension"), None) @@ -20,7 +20,7 @@ pub struct SqliteLoadExtensionGuard<'conn> { impl<'conn> SqliteLoadExtensionGuard<'conn> { /// Attempt to enable loading extensions. Loading extensions will be disabled when this /// guard goes out of scope. Cannot be meaningfully nested. - pub fn new(conn: &Connection) -> SqliteResult { + pub fn new(conn: &Connection) -> Result { conn.load_extension_enable().map(|_| SqliteLoadExtensionGuard { conn: conn }) } } diff --git a/src/named_params.rs b/src/named_params.rs index 0247c7f..9dd08a2 100644 --- a/src/named_params.rs +++ b/src/named_params.rs @@ -2,7 +2,7 @@ use libc::c_int; use super::ffi; -use {SqliteResult, Error, Connection, SqliteStatement, SqliteRows, SqliteRow, +use {Result, Error, Connection, SqliteStatement, SqliteRows, SqliteRow, str_to_cstring}; use types::ToSql; @@ -15,8 +15,8 @@ impl Connection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{Connection, SqliteResult}; - /// fn insert(conn: &Connection) -> SqliteResult { + /// # use rusqlite::{Connection, Result}; + /// fn insert(conn: &Connection) -> Result { /// conn.execute_named("INSERT INTO test (name) VALUES (:name)", &[(":name", &"one")]) /// } /// ``` @@ -25,7 +25,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 execute_named(&self, sql: &str, params: &[(&str, &ToSql)]) -> SqliteResult { + pub fn execute_named(&self, sql: &str, params: &[(&str, &ToSql)]) -> Result { self.prepare(sql).and_then(|mut stmt| stmt.execute_named(params)) } @@ -42,7 +42,7 @@ impl Connection { sql: &str, params: &[(&str, &ToSql)], f: F) - -> SqliteResult + -> Result where F: FnOnce(SqliteRow) -> T { let mut stmt = try!(self.prepare(sql)); @@ -59,7 +59,7 @@ impl<'conn> SqliteStatement<'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) -> SqliteResult> { + pub fn parameter_index(&self, name: &str) -> Result> { let c_name = try!(str_to_cstring(name)); let c_index = unsafe { ffi::sqlite3_bind_parameter_index(self.stmt, c_name.as_ptr()) }; Ok(match c_index { @@ -79,8 +79,8 @@ impl<'conn> SqliteStatement<'conn> { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{Connection, SqliteResult}; - /// fn insert(conn: &Connection) -> SqliteResult { + /// # use rusqlite::{Connection, Result}; + /// fn insert(conn: &Connection) -> Result { /// let mut stmt = try!(conn.prepare("INSERT INTO test (name) VALUES (:name)")); /// stmt.execute_named(&[(":name", &"one")]) /// } @@ -90,7 +90,7 @@ impl<'conn> SqliteStatement<'conn> { /// /// Will return `Err` if binding parameters fails, the executed statement 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)]) -> SqliteResult { + pub fn execute_named(&mut self, params: &[(&str, &ToSql)]) -> Result { try!(self.bind_parameters_named(params)); unsafe { self.execute_() @@ -105,8 +105,8 @@ impl<'conn> SqliteStatement<'conn> { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{Connection, SqliteResult, SqliteRows}; - /// fn query(conn: &Connection) -> SqliteResult<()> { + /// # use rusqlite::{Connection, Result, SqliteRows}; + /// 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")])); /// for row in rows { @@ -121,7 +121,7 @@ impl<'conn> SqliteStatement<'conn> { /// Will return `Err` if binding parameters fails. pub fn query_named<'a>(&'a mut self, params: &[(&str, &ToSql)]) - -> SqliteResult> { + -> Result> { self.reset_if_needed(); try!(self.bind_parameters_named(params)); @@ -129,7 +129,7 @@ impl<'conn> SqliteStatement<'conn> { Ok(SqliteRows::new(self)) } - fn bind_parameters_named(&mut self, params: &[(&str, &ToSql)]) -> SqliteResult<()> { + 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.conn.decode_result(unsafe { value.bind_parameter(self.stmt, i) })); diff --git a/src/trace.rs b/src/trace.rs index 9894d3f..eac7fc3 100644 --- a/src/trace.rs +++ b/src/trace.rs @@ -8,7 +8,7 @@ use std::str; use std::time::Duration; use super::ffi; -use {Error, SqliteResult, Connection}; +use {Error, Result, Connection}; /// Set up the process-wide SQLite error logging callback. /// This function is marked unsafe for two reasons: @@ -21,7 +21,7 @@ use {Error, SqliteResult, Connection}; /// * It must be threadsafe if SQLite is used in a multithreaded way. /// /// cf [The Error And Warning Log](http://sqlite.org/errlog.html). -pub unsafe fn config_log(callback: Option) -> SqliteResult<()> { +pub unsafe fn config_log(callback: Option) -> Result<()> { extern "C" fn log_callback(p_arg: *mut c_void, err: c_int, msg: *const c_char) { let c_slice = unsafe { CStr::from_ptr(msg).to_bytes() }; let callback: fn(c_int, &str) = unsafe { mem::transmute(p_arg) }; diff --git a/src/transaction.rs b/src/transaction.rs index a26cc9d..425535f 100644 --- a/src/transaction.rs +++ b/src/transaction.rs @@ -1,4 +1,4 @@ -use {SqliteResult, Connection}; +use {Result, Connection}; pub use SqliteTransactionBehavior::{SqliteTransactionDeferred, SqliteTransactionImmediate, SqliteTransactionExclusive}; @@ -22,10 +22,10 @@ pub enum SqliteTransactionBehavior { /// ## Example /// /// ```rust,no_run -/// # use rusqlite::{Connection, SqliteResult}; -/// # fn do_queries_part_1(conn: &Connection) -> SqliteResult<()> { Ok(()) } -/// # fn do_queries_part_2(conn: &Connection) -> SqliteResult<()> { Ok(()) } -/// fn perform_queries(conn: &Connection) -> SqliteResult<()> { +/// # use rusqlite::{Connection, Result}; +/// # fn do_queries_part_1(conn: &Connection) -> Result<()> { Ok(()) } +/// # fn do_queries_part_2(conn: &Connection) -> Result<()> { Ok(()) } +/// fn perform_queries(conn: &Connection) -> Result<()> { /// let tx = try!(conn.transaction()); /// /// try!(do_queries_part_1(conn)); // tx causes rollback if this fails @@ -45,7 +45,7 @@ impl<'conn> SqliteTransaction<'conn> { /// Begin a new transaction. Cannot be nested; see `savepoint` for nested transactions. pub fn new(conn: &Connection, behavior: SqliteTransactionBehavior) - -> SqliteResult { + -> Result { let query = match behavior { SqliteTransactionDeferred => "BEGIN DEFERRED", SqliteTransactionImmediate => "BEGIN IMMEDIATE", @@ -71,9 +71,9 @@ impl<'conn> SqliteTransaction<'conn> { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{Connection, SqliteResult}; + /// # use rusqlite::{Connection, Result}; /// # fn perform_queries_part_1_succeeds(conn: &Connection) -> bool { true } - /// fn perform_queries(conn: &Connection) -> SqliteResult<()> { + /// fn perform_queries(conn: &Connection) -> Result<()> { /// let tx = try!(conn.transaction()); /// /// { @@ -87,7 +87,7 @@ impl<'conn> SqliteTransaction<'conn> { /// tx.commit() /// } /// ``` - pub fn savepoint<'a>(&'a self) -> SqliteResult> { + pub fn savepoint<'a>(&'a self) -> Result> { self.conn.execute_batch("SAVEPOINT sp").map(|_| { SqliteTransaction { conn: self.conn, @@ -119,11 +119,11 @@ impl<'conn> SqliteTransaction<'conn> { } /// A convenience method which consumes and commits a transaction. - pub fn commit(mut self) -> SqliteResult<()> { + pub fn commit(mut self) -> Result<()> { self.commit_() } - fn commit_(&mut self) -> SqliteResult<()> { + fn commit_(&mut self) -> Result<()> { self.finished = true; self.conn.execute_batch(if self.depth == 0 { "COMMIT" @@ -133,11 +133,11 @@ impl<'conn> SqliteTransaction<'conn> { } /// A convenience method which consumes and rolls back a transaction. - pub fn rollback(mut self) -> SqliteResult<()> { + pub fn rollback(mut self) -> Result<()> { self.rollback_() } - fn rollback_(&mut self) -> SqliteResult<()> { + fn rollback_(&mut self) -> Result<()> { self.finished = true; self.conn.execute_batch(if self.depth == 0 { "ROLLBACK" @@ -151,11 +151,11 @@ impl<'conn> SqliteTransaction<'conn> { /// /// Functionally equivalent to the `Drop` implementation, but allows callers to see any /// errors that occur. - pub fn finish(mut self) -> SqliteResult<()> { + pub fn finish(mut self) -> Result<()> { self.finish_() } - fn finish_(&mut self) -> SqliteResult<()> { + fn finish_(&mut self) -> Result<()> { match (self.finished, self.commit) { (true, _) => Ok(()), (false, true) => self.commit_(), diff --git a/src/types.rs b/src/types.rs index 274e990..2e857f5 100644 --- a/src/types.rs +++ b/src/types.rs @@ -26,7 +26,7 @@ //! extern crate libc; //! //! use rusqlite::types::{FromSql, ToSql, sqlite3_stmt}; -//! use rusqlite::{SqliteResult}; +//! use rusqlite::{Result}; //! use libc::c_int; //! use time; //! @@ -34,7 +34,7 @@ //! //! impl FromSql for TimespecSql { //! unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -//! -> SqliteResult { +//! -> Result { //! let as_f64_result = FromSql::column_result(stmt, col); //! as_f64_result.map(|as_f64: f64| { //! TimespecSql(time::Timespec{ sec: as_f64.trunc() as i64, @@ -59,7 +59,7 @@ use std::ffi::CStr; use std::mem; use std::str; use super::ffi; -use super::{SqliteResult, Error, str_to_cstring}; +use super::{Result, Error, str_to_cstring}; pub use ffi::sqlite3_stmt; pub use ffi::sqlite3_column_type; @@ -75,7 +75,7 @@ pub trait ToSql { /// A trait for types that can be created from a SQLite value. pub trait FromSql: Sized { - unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> SqliteResult; + unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result; /// FromSql types can implement this method and use sqlite3_column_type to check that /// the type reported by SQLite matches a type suitable for Self. This method is used @@ -176,12 +176,12 @@ impl ToSql for Option { /// ```rust,no_run /// # extern crate libc; /// # extern crate rusqlite; -/// # use rusqlite::{Connection, SqliteResult}; +/// # use rusqlite::{Connection, Result}; /// # use rusqlite::types::{Null}; /// # use libc::{c_int}; /// fn main() { /// } -/// fn insert_null(conn: &Connection) -> SqliteResult { +/// fn insert_null(conn: &Connection) -> Result { /// conn.execute("INSERT INTO people (name) VALUES (?)", &[&Null]) /// } /// ``` @@ -197,7 +197,7 @@ impl ToSql for Null { macro_rules! raw_from_impl( ($t:ty, $f:ident, $c:expr) => ( impl FromSql for $t { - unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> SqliteResult<$t> { + unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result<$t> { Ok(ffi::$f(stmt, col)) } @@ -213,7 +213,7 @@ raw_from_impl!(i64, sqlite3_column_int64, ffi::SQLITE_INTEGER); raw_from_impl!(c_double, sqlite3_column_double, ffi::SQLITE_FLOAT); impl FromSql for bool { - unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> SqliteResult { + unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result { match ffi::sqlite3_column_int(stmt, col) { 0 => Ok(false), _ => Ok(true), @@ -226,7 +226,7 @@ impl FromSql for bool { } impl FromSql for String { - unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> SqliteResult { + unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result { let c_text = ffi::sqlite3_column_text(stmt, col); if c_text.is_null() { Ok("".to_string()) @@ -249,7 +249,7 @@ impl FromSql for String { } impl FromSql for Vec { - unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> SqliteResult> { + unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result> { use std::slice::from_raw_parts; let c_blob = ffi::sqlite3_column_blob(stmt, col); let len = ffi::sqlite3_column_bytes(stmt, col); @@ -269,7 +269,7 @@ impl FromSql for Vec { } impl FromSql for time::Timespec { - unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> SqliteResult { + unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result { let col_str = FromSql::column_result(stmt, col); col_str.and_then(|txt: String| { time::strptime(&txt, SQLITE_DATETIME_FMT) @@ -289,7 +289,7 @@ impl FromSql for time::Timespec { } impl FromSql for Option { - unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> SqliteResult> { + unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> Result> { if sqlite3_column_type(stmt, col) == ffi::SQLITE_NULL { Ok(None) } else { From ec654352d97facaad7f7e2957968e0ba6caf56af Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Sat, 12 Dec 2015 14:08:04 -0500 Subject: [PATCH 04/11] Rename `SqliteStatement` -> `Statement`. --- Changelog.md | 1 + src/lib.rs | 29 ++++++++++++++++------------- src/named_params.rs | 5 ++--- 3 files changed, 19 insertions(+), 16 deletions(-) diff --git a/Changelog.md b/Changelog.md index e9d7d56..bbb595a 100644 --- a/Changelog.md +++ b/Changelog.md @@ -4,6 +4,7 @@ * `SqliteConnection` is now `Connection` * `SqliteError` is now `Error` * `SqliteResult` is now `Result` + * `SqliteStatement` is now `Statement` The old, prefixed names are still exported should be considered deprecated. * Adds a variety of `..._named` methods for executing queries using named placeholder parameters. * Adds `backup` feature that exposes SQLite's online backup API. diff --git a/src/lib.rs b/src/lib.rs index eb43b04..b3c4a67 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -461,7 +461,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 prepare<'a>(&'a self, sql: &str) -> Result> { + pub fn prepare<'a>(&'a self, sql: &str) -> Result> { self.db.borrow_mut().prepare(self, sql) } @@ -698,7 +698,7 @@ impl InnerConnection { fn prepare<'a>(&mut self, conn: &'a Connection, sql: &str) - -> Result> { + -> Result> { if sql.len() >= ::std::i32::MAX as usize { return Err(Error { code: ffi::SQLITE_TOOBIG, @@ -715,7 +715,7 @@ impl InnerConnection { &mut c_stmt, ptr::null_mut()) }; - self.decode_result(r).map(|_| SqliteStatement::new(conn, c_stmt)) + self.decode_result(r).map(|_| Statement::new(conn, c_stmt)) } fn changes(&mut self) -> c_int { @@ -730,17 +730,20 @@ impl Drop for InnerConnection { } } +/// Old name for `Statement`. `SqliteStatement` is deprecated. +pub type SqliteStatement<'conn> = Statement<'conn>; + /// A prepared statement. -pub struct SqliteStatement<'conn> { +pub struct Statement<'conn> { conn: &'conn Connection, stmt: *mut ffi::sqlite3_stmt, needs_reset: bool, column_count: c_int, } -impl<'conn> SqliteStatement<'conn> { - fn new(conn: &Connection, stmt: *mut ffi::sqlite3_stmt) -> SqliteStatement { - SqliteStatement { +impl<'conn> Statement<'conn> { + fn new(conn: &Connection, stmt: *mut ffi::sqlite3_stmt) -> Statement { + Statement { conn: conn, stmt: stmt, needs_reset: false, @@ -938,13 +941,13 @@ impl<'conn> SqliteStatement<'conn> { } } -impl<'conn> fmt::Debug for SqliteStatement<'conn> { +impl<'conn> fmt::Debug for Statement<'conn> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let sql = unsafe { let c_slice = CStr::from_ptr(ffi::sqlite3_sql(self.stmt)).to_bytes(); str::from_utf8(c_slice) }; - f.debug_struct("SqliteStatement") + f.debug_struct("Statement") .field("conn", self.conn) .field("stmt", &self.stmt) .field("sql", &sql) @@ -952,7 +955,7 @@ impl<'conn> fmt::Debug for SqliteStatement<'conn> { } } -impl<'conn> Drop for SqliteStatement<'conn> { +impl<'conn> Drop for Statement<'conn> { #[allow(unused_must_use)] fn drop(&mut self) { self.finalize_(); @@ -1031,13 +1034,13 @@ where E: convert::From, /// functions which are useful (such as support for `for ... in ...` looping, `map`, `filter`, /// etc.). pub struct SqliteRows<'stmt> { - stmt: &'stmt SqliteStatement<'stmt>, + stmt: &'stmt Statement<'stmt>, current_row: Rc>, failed: bool, } impl<'stmt> SqliteRows<'stmt> { - fn new(stmt: &'stmt SqliteStatement<'stmt>) -> SqliteRows<'stmt> { + fn new(stmt: &'stmt Statement<'stmt>) -> SqliteRows<'stmt> { SqliteRows { stmt: stmt, current_row: Rc::new(Cell::new(0)), @@ -1086,7 +1089,7 @@ impl<'stmt> Iterator for SqliteRows<'stmt> { /// A single result row of a query. pub struct SqliteRow<'stmt> { - stmt: &'stmt SqliteStatement<'stmt>, + stmt: &'stmt Statement<'stmt>, current_row: Rc>, row_idx: c_int, } diff --git a/src/named_params.rs b/src/named_params.rs index 9dd08a2..64d8bf1 100644 --- a/src/named_params.rs +++ b/src/named_params.rs @@ -2,8 +2,7 @@ use libc::c_int; use super::ffi; -use {Result, Error, Connection, SqliteStatement, SqliteRows, SqliteRow, - str_to_cstring}; +use {Result, Error, Connection, Statement, SqliteRows, SqliteRow, str_to_cstring}; use types::ToSql; impl Connection { @@ -52,7 +51,7 @@ impl Connection { } } -impl<'conn> SqliteStatement<'conn> { +impl<'conn> Statement<'conn> { /// Return the index of an SQL parameter given its name. /// /// # Failure From b9326401816398c7661fc613dd85c974889a4f68 Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Sat, 12 Dec 2015 14:09:37 -0500 Subject: [PATCH 05/11] Rename `SqliteRows` -> `Rows`. --- Changelog.md | 1 + src/lib.rs | 23 +++++++++++++---------- src/named_params.rs | 8 ++++---- 3 files changed, 18 insertions(+), 14 deletions(-) diff --git a/Changelog.md b/Changelog.md index bbb595a..e76d415 100644 --- a/Changelog.md +++ b/Changelog.md @@ -5,6 +5,7 @@ * `SqliteError` is now `Error` * `SqliteResult` is now `Result` * `SqliteStatement` is now `Statement` + * `SqliteRows` is now `Rows` The old, prefixed names are still exported should be considered deprecated. * Adds a variety of `..._named` methods for executing queries using named placeholder parameters. * Adds `backup` feature that exposes SQLite's online backup API. diff --git a/src/lib.rs b/src/lib.rs index b3c4a67..a639fce 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -841,7 +841,7 @@ impl<'conn> Statement<'conn> { /// # Failure /// /// Will return `Err` if binding parameters fails. - pub fn query<'a>(&'a mut self, params: &[&ToSql]) -> Result> { + pub fn query<'a>(&'a mut self, params: &[&ToSql]) -> Result> { self.reset_if_needed(); unsafe { @@ -849,7 +849,7 @@ impl<'conn> Statement<'conn> { } self.needs_reset = true; - Ok(SqliteRows::new(self)) + Ok(Rows::new(self)) } /// Executes the prepared statement and maps a function over the resulting @@ -964,7 +964,7 @@ impl<'conn> Drop for Statement<'conn> { /// An iterator over the mapped resulting rows of a query. pub struct MappedRows<'stmt, F> { - rows: SqliteRows<'stmt>, + rows: Rows<'stmt>, map: F, } @@ -980,7 +980,7 @@ impl<'stmt, T, F> Iterator for MappedRows<'stmt, F> where F: FnMut(&SqliteRow) - /// An iterator over the mapped resulting rows of a query, with an Error type /// unifying with Error. pub struct AndThenRows<'stmt, F> { - rows: SqliteRows<'stmt>, + rows: Rows<'stmt>, map: F, } @@ -998,12 +998,15 @@ where E: convert::From, } } +/// Old name for `Rows`. `SqliteRows` is deprecated. +pub type SqliteRows<'stmt> = Rows<'stmt>; + /// An iterator over the resulting rows of a query. /// /// ## Warning /// /// Due to the way SQLite returns result rows of a query, it is not safe to attempt to get values -/// from a row after it has become stale (i.e., `next()` has been called again on the `SqliteRows` +/// from a row after it has become stale (i.e., `next()` has been called again on the `Rows` /// iterator). For example: /// /// ```rust,no_run @@ -1033,15 +1036,15 @@ where E: convert::From, /// no longer implement `Iterator`, and therefore you would lose access to the majority of /// functions which are useful (such as support for `for ... in ...` looping, `map`, `filter`, /// etc.). -pub struct SqliteRows<'stmt> { +pub struct Rows<'stmt> { stmt: &'stmt Statement<'stmt>, current_row: Rc>, failed: bool, } -impl<'stmt> SqliteRows<'stmt> { - fn new(stmt: &'stmt Statement<'stmt>) -> SqliteRows<'stmt> { - SqliteRows { +impl<'stmt> Rows<'stmt> { + fn new(stmt: &'stmt Statement<'stmt>) -> Rows<'stmt> { + Rows { stmt: stmt, current_row: Rc::new(Cell::new(0)), failed: false, @@ -1061,7 +1064,7 @@ impl<'stmt> SqliteRows<'stmt> { } } -impl<'stmt> Iterator for SqliteRows<'stmt> { +impl<'stmt> Iterator for Rows<'stmt> { type Item = Result>; fn next(&mut self) -> Option>> { diff --git a/src/named_params.rs b/src/named_params.rs index 64d8bf1..dccb531 100644 --- a/src/named_params.rs +++ b/src/named_params.rs @@ -2,7 +2,7 @@ use libc::c_int; use super::ffi; -use {Result, Error, Connection, Statement, SqliteRows, SqliteRow, str_to_cstring}; +use {Result, Error, Connection, Statement, Rows, SqliteRow, str_to_cstring}; use types::ToSql; impl Connection { @@ -104,7 +104,7 @@ impl<'conn> Statement<'conn> { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{Connection, Result, SqliteRows}; + /// # use rusqlite::{Connection, Result, Rows}; /// 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")])); @@ -120,12 +120,12 @@ impl<'conn> Statement<'conn> { /// Will return `Err` if binding parameters fails. pub fn query_named<'a>(&'a mut self, params: &[(&str, &ToSql)]) - -> Result> { + -> Result> { self.reset_if_needed(); try!(self.bind_parameters_named(params)); self.needs_reset = true; - Ok(SqliteRows::new(self)) + Ok(Rows::new(self)) } fn bind_parameters_named(&mut self, params: &[(&str, &ToSql)]) -> Result<()> { From ea5cb41bbf8dd83e94b7ea9a278f3bd27e685523 Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Sat, 12 Dec 2015 14:11:24 -0500 Subject: [PATCH 06/11] Rename `SqliteRow` -> `Row`. --- Changelog.md | 1 + README.md | 6 +++--- src/lib.rs | 31 +++++++++++++++++-------------- src/named_params.rs | 4 ++-- 4 files changed, 23 insertions(+), 19 deletions(-) diff --git a/Changelog.md b/Changelog.md index e76d415..85e04df 100644 --- a/Changelog.md +++ b/Changelog.md @@ -6,6 +6,7 @@ * `SqliteResult` is now `Result` * `SqliteStatement` is now `Statement` * `SqliteRows` is now `Rows` + * `SqliteRow` is now `Row` The old, prefixed names are still exported should be considered deprecated. * Adds a variety of `..._named` methods for executing queries using named placeholder parameters. * Adds `backup` feature that exposes SQLite's online backup API. diff --git a/README.md b/README.md index 05c8d98..9d78640 100644 --- a/README.md +++ b/README.md @@ -56,7 +56,7 @@ fn main() { } ``` -### Design of SqliteRows and SqliteRow +### Design of Rows and Row To retrieve the result rows from a query, SQLite requires you to call [sqlite3_step()](https://www.sqlite.org/c3ref/step.html) on a prepared statement. You can only @@ -67,7 +67,7 @@ satisfy the [Iterator](http://doc.rust-lang.org/std/iter/trait.Iterator.html) tr you cannot (as easily) loop over the rows, or use many of the helpful Iterator methods like `map` and `filter`. -Instead, Rusqlite's `SqliteRows` handle does conform to `Iterator`. It ensures safety by +Instead, Rusqlite's `Rows` handle does conform to `Iterator`. It ensures safety by performing checks at runtime to ensure you do not try to retrieve the values of a "stale" row, and will panic if you do so. A specific example that will panic: @@ -88,7 +88,7 @@ fn bad_function_will_panic(conn: &Connection) -> Result { ``` There are other, less obvious things that may result in a panic as well, such as calling -`collect()` on a `SqliteRows` and then trying to use the collected rows. +`collect()` on a `Rows` and then trying to use the collected rows. Strongly consider using the method `query_map()` instead, if you can. `query_map()` returns an iterator over rows-mapped-to-some-type. This diff --git a/src/lib.rs b/src/lib.rs index a639fce..2e7d78b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -379,7 +379,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(&self, sql: &str, params: &[&ToSql], f: F) -> Result - where F: FnOnce(SqliteRow) -> T + where F: FnOnce(Row) -> T { let mut stmt = try!(self.prepare(sql)); let mut rows = try!(stmt.query(params)); @@ -409,7 +409,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_and_then(&self, sql: &str, params: &[&ToSql], f: F) -> result::Result - where F: FnOnce(SqliteRow) -> result::Result, + where F: FnOnce(Row) -> result::Result, E: convert::From { let mut stmt = try!(self.prepare(sql)); @@ -438,7 +438,7 @@ impl Connection { /// This method should be considered deprecated. Use `query_row` instead, which now /// does exactly the same thing. pub fn query_row_safe(&self, sql: &str, params: &[&ToSql], f: F) -> Result - where F: FnOnce(SqliteRow) -> T + where F: FnOnce(Row) -> T { self.query_row(sql, params, f) } @@ -865,7 +865,7 @@ impl<'conn> Statement<'conn> { params: &[&ToSql], f: F) -> Result> - where F: FnMut(&SqliteRow) -> T + where F: FnMut(&Row) -> T { let row_iter = try!(self.query(params)); @@ -890,7 +890,7 @@ impl<'conn> Statement<'conn> { f: F) -> Result> where E: convert::From, - F: FnMut(&SqliteRow) -> result::Result + F: FnMut(&Row) -> result::Result { let row_iter = try!(self.query(params)); @@ -968,7 +968,7 @@ pub struct MappedRows<'stmt, F> { map: F, } -impl<'stmt, T, F> Iterator for MappedRows<'stmt, F> where F: FnMut(&SqliteRow) -> T +impl<'stmt, T, F> Iterator for MappedRows<'stmt, F> where F: FnMut(&Row) -> T { type Item = Result; @@ -986,7 +986,7 @@ pub struct AndThenRows<'stmt, F> { impl<'stmt, T, E, F> Iterator for AndThenRows<'stmt, F> where E: convert::From, - F: FnMut(&SqliteRow) -> result::Result + F: FnMut(&Row) -> result::Result { type Item = result::Result; @@ -1051,7 +1051,7 @@ impl<'stmt> Rows<'stmt> { } } - fn get_expected_row(&mut self) -> Result> { + fn get_expected_row(&mut self) -> Result> { match self.next() { Some(row) => row, None => { @@ -1065,9 +1065,9 @@ impl<'stmt> Rows<'stmt> { } impl<'stmt> Iterator for Rows<'stmt> { - type Item = Result>; + type Item = Result>; - fn next(&mut self) -> Option>> { + fn next(&mut self) -> Option>> { if self.failed { return None; } @@ -1075,7 +1075,7 @@ impl<'stmt> Iterator for Rows<'stmt> { ffi::SQLITE_ROW => { let current_row = self.current_row.get() + 1; self.current_row.set(current_row); - Some(Ok(SqliteRow { + Some(Ok(Row { stmt: self.stmt, current_row: self.current_row.clone(), row_idx: current_row, @@ -1090,17 +1090,20 @@ impl<'stmt> Iterator for Rows<'stmt> { } } +/// Old name for `Row`. `SqliteRow` is deprecated. +pub type SqliteRow<'stmt> = Row<'stmt>; + /// A single result row of a query. -pub struct SqliteRow<'stmt> { +pub struct Row<'stmt> { stmt: &'stmt Statement<'stmt>, current_row: Rc>, row_idx: c_int, } -impl<'stmt> SqliteRow<'stmt> { +impl<'stmt> Row<'stmt> { /// Get the value of a particular column of the result row. /// - /// Note that `SqliteRow` can panic at runtime if you use it incorrectly. When you are + /// Note that `Row` can panic at runtime if you use it incorrectly. When you are /// retrieving the rows of a query, a row becomes stale once you have requested the next row, /// and the values can no longer be retrieved. In general (when using looping over the rows, /// for example) this isn't an issue, but it means you cannot do something like this: diff --git a/src/named_params.rs b/src/named_params.rs index dccb531..d1dcdc9 100644 --- a/src/named_params.rs +++ b/src/named_params.rs @@ -2,7 +2,7 @@ use libc::c_int; use super::ffi; -use {Result, Error, Connection, Statement, Rows, SqliteRow, str_to_cstring}; +use {Result, Error, Connection, Statement, Rows, Row, str_to_cstring}; use types::ToSql; impl Connection { @@ -42,7 +42,7 @@ impl Connection { params: &[(&str, &ToSql)], f: F) -> Result - where F: FnOnce(SqliteRow) -> T + where F: FnOnce(Row) -> T { let mut stmt = try!(self.prepare(sql)); let mut rows = try!(stmt.query_named(params)); From 9cac56d6a2cd3bf3fef0864675e2f0d4f67771c7 Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Sat, 12 Dec 2015 14:13:29 -0500 Subject: [PATCH 07/11] Rename `SqliteOpenFlags` -> `OpenFlags`. --- Changelog.md | 1 + src/lib.rs | 17 ++++++++++------- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/Changelog.md b/Changelog.md index 85e04df..0a72e5e 100644 --- a/Changelog.md +++ b/Changelog.md @@ -7,6 +7,7 @@ * `SqliteStatement` is now `Statement` * `SqliteRows` is now `Rows` * `SqliteRow` is now `Row` + * `SqliteOpenFlags` is now `OpenFlags` The old, prefixed names are still exported should be considered deprecated. * Adds a variety of `..._named` methods for executing queries using named placeholder parameters. * Adds `backup` feature that exposes SQLite's online backup API. diff --git a/src/lib.rs b/src/lib.rs index 2e7d78b..df6cc21 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -232,7 +232,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: SqliteOpenFlags) + flags: OpenFlags) -> Result { let c_path = try!(path_to_cstring(path.as_ref())); InnerConnection::open_with_flags(&c_path, flags).map(|db| { @@ -251,7 +251,7 @@ impl Connection { /// # Failure /// /// Will return `Err` if the underlying SQLite open call fails. - pub fn open_in_memory_with_flags(flags: SqliteOpenFlags) -> Result { + pub fn open_in_memory_with_flags(flags: OpenFlags) -> Result { let c_memory = try!(str_to_cstring(":memory:")); InnerConnection::open_with_flags(&c_memory, flags).map(|db| { Connection { @@ -564,11 +564,14 @@ struct InnerConnection { db: *mut ffi::Struct_sqlite3, } +/// Old name for `OpenFlags`. `SqliteOpenFlags` is deprecated. +pub type SqliteOpenFlags = OpenFlags; + bitflags! { #[doc = "Flags for opening SQLite database connections."] #[doc = "See [sqlite3_open_v2](http://www.sqlite.org/c3ref/open.html) for details."] #[repr(C)] - flags SqliteOpenFlags: c_int { + flags OpenFlags: c_int { const SQLITE_OPEN_READ_ONLY = 0x00000001, const SQLITE_OPEN_READ_WRITE = 0x00000002, const SQLITE_OPEN_CREATE = 0x00000004, @@ -581,15 +584,15 @@ bitflags! { } } -impl Default for SqliteOpenFlags { - fn default() -> SqliteOpenFlags { +impl Default for OpenFlags { + fn default() -> OpenFlags { SQLITE_OPEN_READ_WRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_NO_MUTEX | SQLITE_OPEN_URI } } impl InnerConnection { fn open_with_flags(c_path: &CString, - flags: SqliteOpenFlags) + flags: OpenFlags) -> Result { unsafe { let mut db: *mut ffi::sqlite3 = mem::uninitialized(); @@ -1222,7 +1225,7 @@ mod test { #[test] fn test_open_with_flags() { - for bad_flags in [SqliteOpenFlags::empty(), + for bad_flags in [OpenFlags::empty(), SQLITE_OPEN_READ_ONLY | SQLITE_OPEN_READ_WRITE, SQLITE_OPEN_READ_ONLY | SQLITE_OPEN_CREATE] .iter() { From 3d15a8a15ce2a400c165dd3900db2b8f5621f17f Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Sat, 12 Dec 2015 14:17:43 -0500 Subject: [PATCH 08/11] Rename `SqliteTransaction*` -> `Transaction*`. --- Changelog.md | 4 +++- src/lib.rs | 16 ++++++++-------- src/transaction.rs | 40 +++++++++++++++++++++++----------------- src/types.rs | 2 +- 4 files changed, 35 insertions(+), 27 deletions(-) diff --git a/Changelog.md b/Changelog.md index 0a72e5e..771f3e4 100644 --- a/Changelog.md +++ b/Changelog.md @@ -8,7 +8,9 @@ * `SqliteRows` is now `Rows` * `SqliteRow` is now `Row` * `SqliteOpenFlags` is now `OpenFlags` - The old, prefixed names are still exported should be considered deprecated. + * `SqliteTransaction` is now `Transaction`. + * `SqliteTransactionBehavior` is now `TransactionBehavior`. + The old, prefixed names are still exported but are deprecated. * Adds a variety of `..._named` methods for executing queries using named placeholder parameters. * Adds `backup` feature that exposes SQLite's online backup API. * Adds `functions` feature that allows user-defined scalar functions to be added to diff --git a/src/lib.rs b/src/lib.rs index df6cc21..500e88a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -74,9 +74,9 @@ use libc::{c_int, c_void, c_char}; use types::{ToSql, FromSql}; -pub use transaction::SqliteTransaction; -pub use transaction::{SqliteTransactionBehavior, SqliteTransactionDeferred, -SqliteTransactionImmediate, SqliteTransactionExclusive}; +pub use transaction::Transaction; +pub use transaction::{TransactionBehavior, TransactionDeferred, + TransactionImmediate, TransactionExclusive}; #[cfg(feature = "load_extension")] pub use load_extension_guard::SqliteLoadExtensionGuard; @@ -285,8 +285,8 @@ impl Connection { /// # Failure /// /// Will return `Err` if the underlying SQLite call fails. - pub fn transaction<'a>(&'a self) -> Result> { - SqliteTransaction::new(self, SqliteTransactionDeferred) + pub fn transaction<'a>(&'a self) -> Result> { + Transaction::new(self, TransactionDeferred) } /// Begin a new transaction with a specified behavior. @@ -297,9 +297,9 @@ impl Connection { /// /// Will return `Err` if the underlying SQLite call fails. pub fn transaction_with_behavior<'a>(&'a self, - behavior: SqliteTransactionBehavior) - -> Result> { - SqliteTransaction::new(self, behavior) + behavior: TransactionBehavior) + -> Result> { + Transaction::new(self, behavior) } /// Convenience method to run multiple SQL statements (that cannot take any parameters). diff --git a/src/transaction.rs b/src/transaction.rs index 425535f..2ed671f 100644 --- a/src/transaction.rs +++ b/src/transaction.rs @@ -1,17 +1,23 @@ use {Result, Connection}; -pub use SqliteTransactionBehavior::{SqliteTransactionDeferred, SqliteTransactionImmediate, - SqliteTransactionExclusive}; +pub use TransactionBehavior::{TransactionDeferred, TransactionImmediate, TransactionExclusive}; + +/// Old name for `TransactionBehavior`. `SqliteTransactionBehavior` is deprecated. +pub type SqliteTransactionBehavior = TransactionBehavior; /// Options for transaction behavior. See [BEGIN /// TRANSACTION](http://www.sqlite.org/lang_transaction.html) for details. #[derive(Copy,Clone)] -pub enum SqliteTransactionBehavior { - SqliteTransactionDeferred, - SqliteTransactionImmediate, - SqliteTransactionExclusive, +pub enum TransactionBehavior { + TransactionDeferred, + TransactionImmediate, + TransactionExclusive, } +/// Old name for `Transaction`. `SqliteTransaction` is deprecated. +pub type SqliteTransaction<'conn> = Transaction<'conn>; + +/// /// Represents a transaction on a database connection. /// /// ## Note @@ -34,25 +40,25 @@ pub enum SqliteTransactionBehavior { /// tx.commit() /// } /// ``` -pub struct SqliteTransaction<'conn> { +pub struct Transaction<'conn> { conn: &'conn Connection, depth: u32, commit: bool, finished: bool, } -impl<'conn> SqliteTransaction<'conn> { +impl<'conn> Transaction<'conn> { /// Begin a new transaction. Cannot be nested; see `savepoint` for nested transactions. pub fn new(conn: &Connection, - behavior: SqliteTransactionBehavior) - -> Result { + behavior: TransactionBehavior) + -> Result { let query = match behavior { - SqliteTransactionDeferred => "BEGIN DEFERRED", - SqliteTransactionImmediate => "BEGIN IMMEDIATE", - SqliteTransactionExclusive => "BEGIN EXCLUSIVE", + TransactionDeferred => "BEGIN DEFERRED", + TransactionImmediate => "BEGIN IMMEDIATE", + TransactionExclusive => "BEGIN EXCLUSIVE", }; conn.execute_batch(query).map(|_| { - SqliteTransaction { + Transaction { conn: conn, depth: 0, commit: false, @@ -87,9 +93,9 @@ impl<'conn> SqliteTransaction<'conn> { /// tx.commit() /// } /// ``` - pub fn savepoint<'a>(&'a self) -> Result> { + pub fn savepoint<'a>(&'a self) -> Result> { self.conn.execute_batch("SAVEPOINT sp").map(|_| { - SqliteTransaction { + Transaction { conn: self.conn, depth: self.depth + 1, commit: false, @@ -165,7 +171,7 @@ impl<'conn> SqliteTransaction<'conn> { } #[allow(unused_must_use)] -impl<'conn> Drop for SqliteTransaction<'conn> { +impl<'conn> Drop for Transaction<'conn> { fn drop(&mut self) { self.finish_(); } diff --git a/src/types.rs b/src/types.rs index 2e857f5..f0852ab 100644 --- a/src/types.rs +++ b/src/types.rs @@ -79,7 +79,7 @@ pub trait FromSql: Sized { /// FromSql types can implement this method and use sqlite3_column_type to check that /// the type reported by SQLite matches a type suitable for Self. This method is used - /// by `SqliteRow::get_checked` to confirm that the column contains a valid type before + /// by `Row::get_checked` to confirm that the column contains a valid type before /// attempting to retrieve the value. unsafe fn column_has_valid_sqlite_type(_: *mut sqlite3_stmt, _: c_int) -> bool { true From b1cde705be7df222719f8b7b3ff55ae364b166f8 Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Sat, 12 Dec 2015 14:20:11 -0500 Subject: [PATCH 09/11] Rename `SqliteLoadExtensionGuard` -> `LoadExtensionGuard`. --- Changelog.md | 1 + src/lib.rs | 10 +++++----- src/load_extension_guard.rs | 17 ++++++++++------- 3 files changed, 16 insertions(+), 12 deletions(-) diff --git a/Changelog.md b/Changelog.md index 771f3e4..b593e07 100644 --- a/Changelog.md +++ b/Changelog.md @@ -10,6 +10,7 @@ * `SqliteOpenFlags` is now `OpenFlags` * `SqliteTransaction` is now `Transaction`. * `SqliteTransactionBehavior` is now `TransactionBehavior`. + * `SqliteLoadExtensionGuard` is now `LoadExtensionGuard`. The old, prefixed names are still exported but are deprecated. * Adds a variety of `..._named` methods for executing queries using named placeholder parameters. * Adds `backup` feature that exposes SQLite's online backup API. diff --git a/src/lib.rs b/src/lib.rs index 500e88a..666342d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -74,12 +74,12 @@ use libc::{c_int, c_void, c_char}; use types::{ToSql, FromSql}; -pub use transaction::Transaction; +pub use transaction::{SqliteTransaction, Transaction}; pub use transaction::{TransactionBehavior, TransactionDeferred, TransactionImmediate, TransactionExclusive}; #[cfg(feature = "load_extension")] -pub use load_extension_guard::SqliteLoadExtensionGuard; +pub use load_extension_guard::{SqliteLoadExtensionGuard, LoadExtensionGuard}; pub mod types; mod transaction; @@ -478,7 +478,7 @@ impl Connection { db.close() } - /// Enable loading of SQLite extensions. Strongly consider using `SqliteLoadExtensionGuard` + /// Enable loading of SQLite extensions. Strongly consider using `LoadExtensionGuard` /// instead of this function. /// /// ## Example @@ -523,10 +523,10 @@ impl Connection { /// ## Example /// /// ```rust,no_run - /// # use rusqlite::{Connection, Result, SqliteLoadExtensionGuard}; + /// # use rusqlite::{Connection, Result, LoadExtensionGuard}; /// # use std::path::{Path}; /// fn load_my_extension(conn: &Connection) -> Result<()> { - /// let _guard = try!(SqliteLoadExtensionGuard::new(conn)); + /// let _guard = try!(LoadExtensionGuard::new(conn)); /// /// conn.load_extension("my_sqlite_extension", None) /// } diff --git a/src/load_extension_guard.rs b/src/load_extension_guard.rs index bec82d1..7a02db4 100644 --- a/src/load_extension_guard.rs +++ b/src/load_extension_guard.rs @@ -1,32 +1,35 @@ use {Result, Connection}; +/// Old name for `LoadExtensionGuard`. `SqliteLoadExtensionGuard` is deprecated. +pub type SqliteLoadExtensionGuard<'conn> = LoadExtensionGuard<'conn>; + /// RAII guard temporarily enabling SQLite extensions to be loaded. /// /// ## Example /// /// ```rust,no_run -/// # use rusqlite::{Connection, Result, SqliteLoadExtensionGuard}; +/// # use rusqlite::{Connection, Result, LoadExtensionGuard}; /// # use std::path::{Path}; /// fn load_my_extension(conn: &Connection) -> Result<()> { -/// let _guard = try!(SqliteLoadExtensionGuard::new(conn)); +/// let _guard = try!(LoadExtensionGuard::new(conn)); /// /// conn.load_extension(Path::new("my_sqlite_extension"), None) /// } /// ``` -pub struct SqliteLoadExtensionGuard<'conn> { +pub struct LoadExtensionGuard<'conn> { conn: &'conn Connection, } -impl<'conn> SqliteLoadExtensionGuard<'conn> { +impl<'conn> LoadExtensionGuard<'conn> { /// Attempt to enable loading extensions. Loading extensions will be disabled when this /// guard goes out of scope. Cannot be meaningfully nested. - pub fn new(conn: &Connection) -> Result { - conn.load_extension_enable().map(|_| SqliteLoadExtensionGuard { conn: conn }) + pub fn new(conn: &Connection) -> Result { + conn.load_extension_enable().map(|_| LoadExtensionGuard { conn: conn }) } } #[allow(unused_must_use)] -impl<'conn> Drop for SqliteLoadExtensionGuard<'conn> { +impl<'conn> Drop for LoadExtensionGuard<'conn> { fn drop(&mut self) { self.conn.load_extension_disable(); } From 6bcc3edccdc5befa0fc715ff966a98c819a9a55c Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Sat, 12 Dec 2015 14:22:50 -0500 Subject: [PATCH 10/11] BREAKING CHANGE: Remove common prefix on TransactionBehavior case names. --- Changelog.md | 4 ++++ src/lib.rs | 6 ++---- src/transaction.rs | 14 ++++++-------- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/Changelog.md b/Changelog.md index b593e07..00f2b20 100644 --- a/Changelog.md +++ b/Changelog.md @@ -1,5 +1,9 @@ # Version UPCOMING (TBD) +* BREAKING CHANGE: `SqliteTransactionDeferred`, `SqliteTransactionImmediate`, and + `SqliteTransactionExclusive` are no longer exported. Instead, use + `TransactionBehavior::Deferred`, `TransactionBehavior::Immediate`, and + `TransactionBehavior::Exclusive`. * Removed `Sqlite` prefix on many types: * `SqliteConnection` is now `Connection` * `SqliteError` is now `Error` diff --git a/src/lib.rs b/src/lib.rs index 666342d..67fc19f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -74,9 +74,7 @@ use libc::{c_int, c_void, c_char}; use types::{ToSql, FromSql}; -pub use transaction::{SqliteTransaction, Transaction}; -pub use transaction::{TransactionBehavior, TransactionDeferred, - TransactionImmediate, TransactionExclusive}; +pub use transaction::{SqliteTransaction, Transaction, TransactionBehavior}; #[cfg(feature = "load_extension")] pub use load_extension_guard::{SqliteLoadExtensionGuard, LoadExtensionGuard}; @@ -286,7 +284,7 @@ impl Connection { /// /// Will return `Err` if the underlying SQLite call fails. pub fn transaction<'a>(&'a self) -> Result> { - Transaction::new(self, TransactionDeferred) + Transaction::new(self, TransactionBehavior::Deferred) } /// Begin a new transaction with a specified behavior. diff --git a/src/transaction.rs b/src/transaction.rs index 2ed671f..3adbdb2 100644 --- a/src/transaction.rs +++ b/src/transaction.rs @@ -1,7 +1,5 @@ use {Result, Connection}; -pub use TransactionBehavior::{TransactionDeferred, TransactionImmediate, TransactionExclusive}; - /// Old name for `TransactionBehavior`. `SqliteTransactionBehavior` is deprecated. pub type SqliteTransactionBehavior = TransactionBehavior; @@ -9,9 +7,9 @@ pub type SqliteTransactionBehavior = TransactionBehavior; /// TRANSACTION](http://www.sqlite.org/lang_transaction.html) for details. #[derive(Copy,Clone)] pub enum TransactionBehavior { - TransactionDeferred, - TransactionImmediate, - TransactionExclusive, + Deferred, + Immediate, + Exclusive, } /// Old name for `Transaction`. `SqliteTransaction` is deprecated. @@ -53,9 +51,9 @@ impl<'conn> Transaction<'conn> { behavior: TransactionBehavior) -> Result { let query = match behavior { - TransactionDeferred => "BEGIN DEFERRED", - TransactionImmediate => "BEGIN IMMEDIATE", - TransactionExclusive => "BEGIN EXCLUSIVE", + TransactionBehavior::Deferred => "BEGIN DEFERRED", + TransactionBehavior::Immediate => "BEGIN IMMEDIATE", + TransactionBehavior::Exclusive => "BEGIN EXCLUSIVE", }; conn.execute_batch(query).map(|_| { Transaction { From 71459ed03b124cd0b82efcb97a8503e11f86f259 Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Sat, 12 Dec 2015 15:50:44 -0500 Subject: [PATCH 11/11] Add to CONTRIBUTORS --- CONTRIBUTORS.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md index 39264b7..3fbb310 100644 --- a/CONTRIBUTORS.md +++ b/CONTRIBUTORS.md @@ -11,3 +11,4 @@ rusqlite contributors (sorted alphabetically) * [krdln](https://github.com/krdln) * [Ben Striegel](https://github.com/bstrie) * [Andrew Straw](https://github.com/astraw) +* [Ronald Kinard](https://github.com/Furyhunter)