diff --git a/Cargo.toml b/Cargo.toml index df70e47..c5a156b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "rusqlite" -version = "0.7.2" +version = "0.7.3" authors = ["John Gallagher "] description = "Ergonomic wrapper for SQLite" repository = "https://github.com/jgallagher/rusqlite" @@ -24,7 +24,6 @@ time = "~0.1.0" bitflags = "0.7" lru-cache = "0.0.7" libc = "~0.2" -clippy = {version = "~0.0.58", optional = true} chrono = { version = "~0.2", optional = true } serde_json = { version = "0.6", optional = true } diff --git a/Changelog.md b/Changelog.md index ed9b14d..ea4b6f8 100644 --- a/Changelog.md +++ b/Changelog.md @@ -5,6 +5,14 @@ methods. * BREAKING CHANGE: The `ToSql` trait has been redesigned. It can now be implemented without `unsafe`, and implementors can choose to return either borrowed or owned results. +* Added `#[deprecated(since = "...", note = "...")]` flags (new in Rust 1.9 for libraries) to + all deprecated APIs. + +# Version 0.7.3 (2016-06-01) + +* Fixes an incorrect failure from the `insert()` convenience function when back-to-back inserts to + different tables both returned the same row ID + ([#171](https://github.com/jgallagher/rusqlite/issues/171)). # Version 0.7.2 (2016-05-19) diff --git a/appveyor.yml b/appveyor.yml index e15cb90..50054f6 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -1,5 +1,5 @@ environment: - TARGET: 1.8.0-x86_64-pc-windows-gnu + TARGET: 1.9.0-x86_64-pc-windows-gnu MSYS2_BITS: 64 install: - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-${env:TARGET}.exe" diff --git a/src/convenient.rs b/src/convenient.rs index 5f867b4..22817a5 100644 --- a/src/convenient.rs +++ b/src/convenient.rs @@ -4,18 +4,20 @@ use types::ToSql; impl<'conn> Statement<'conn> { /// Execute an INSERT and return the ROWID. /// + /// # Note + /// + /// This function is a convenience wrapper around `execute()` intended for queries that + /// insert a single item. It is possible to misuse this function in a way that it cannot + /// detect, such as by calling it on a statement which _updates_ a single item rather than + /// inserting one. Please don't do that. + /// /// # Failure + /// /// Will return `Err` if no row is inserted or many rows are inserted. pub fn insert(&mut self, params: &[&ToSql]) -> Result { - // Some non-insertion queries could still return 1 change (an UPDATE, for example), so - // to guard against that we can check that the connection's last_insert_rowid() changes - // after we execute the statement. - let prev_rowid = self.conn.last_insert_rowid(); let changes = try!(self.execute(params)); - let new_rowid = self.conn.last_insert_rowid(); match changes { - 1 if prev_rowid != new_rowid => Ok(new_rowid), - 1 if prev_rowid == new_rowid => Err(Error::StatementFailedToInsertRow), + 1 => Ok(self.conn.last_insert_rowid()), _ => Err(Error::StatementChangedRows(changes)), } } @@ -57,18 +59,19 @@ mod test { } #[test] - fn test_insert_failures() { + fn test_insert_different_tables() { + // Test for https://github.com/jgallagher/rusqlite/issues/171 let db = Connection::open_in_memory().unwrap(); - db.execute_batch("CREATE TABLE foo(x INTEGER UNIQUE)").unwrap(); - let mut insert = db.prepare("INSERT INTO foo (x) VALUES (?)").unwrap(); - let mut update = db.prepare("UPDATE foo SET x = ?").unwrap(); + db.execute_batch(r" + CREATE TABLE foo(x INTEGER); + CREATE TABLE bar(x INTEGER); + ") + .unwrap(); - assert_eq!(insert.insert(&[&1i32]).unwrap(), 1); - - match update.insert(&[&2i32]) { - Err(Error::StatementFailedToInsertRow) => (), - r => panic!("Unexpected result {:?}", r), - } + assert_eq!(db.prepare("INSERT INTO foo VALUES (10)").unwrap().insert(&[]).unwrap(), + 1); + assert_eq!(db.prepare("INSERT INTO bar VALUES (10)").unwrap().insert(&[]).unwrap(), + 1); } #[test] diff --git a/src/error.rs b/src/error.rs index 1d6ccd4..a8794bf 100644 --- a/src/error.rs +++ b/src/error.rs @@ -6,6 +6,7 @@ use libc::c_int; use {ffi, errmsg_to_string}; /// Old name for `Error`. `SqliteError` is deprecated. +#[deprecated(since = "0.6.0", note = "Use Error instead")] pub type SqliteError = Error; /// Enum listing possible errors from rusqlite. @@ -55,10 +56,6 @@ pub enum Error { /// Error when a query that was expected to insert one row did not insert any or insert many. StatementChangedRows(c_int), - /// Error when a query that was expected to insert a row did not change the connection's - /// last_insert_rowid(). - StatementFailedToInsertRow, - /// Error returned by `functions::Context::get` when the function argument cannot be converted /// to the requested type. #[cfg(feature = "functions")] @@ -105,7 +102,6 @@ impl fmt::Display for Error { Error::InvalidColumnName(ref name) => write!(f, "Invalid column name: {}", name), Error::InvalidColumnType => write!(f, "Invalid column type"), Error::StatementChangedRows(i) => write!(f, "Query changed {} rows", i), - Error::StatementFailedToInsertRow => write!(f, "Statement failed to insert new row"), #[cfg(feature = "functions")] Error::InvalidFunctionParameterType => write!(f, "Invalid function parameter type"), @@ -136,7 +132,6 @@ impl error::Error for Error { Error::InvalidColumnName(_) => "invalid column name", Error::InvalidColumnType => "invalid column type", Error::StatementChangedRows(_) => "query inserted zero or more than one row", - Error::StatementFailedToInsertRow => "statement failed to insert new row", #[cfg(feature = "functions")] Error::InvalidFunctionParameterType => "invalid function parameter type", @@ -161,8 +156,7 @@ impl error::Error for Error { Error::InvalidColumnName(_) | Error::InvalidColumnType | Error::InvalidPath(_) | - Error::StatementChangedRows(_) | - Error::StatementFailedToInsertRow => None, + Error::StatementChangedRows(_) => None, #[cfg(feature = "functions")] Error::InvalidFunctionParameterType => None, diff --git a/src/functions.rs b/src/functions.rs index 033f9a5..9710e84 100644 --- a/src/functions.rs +++ b/src/functions.rs @@ -59,8 +59,6 @@ use libc::{c_int, c_char, c_void}; use ffi; use ffi::sqlite3_context; use ffi::sqlite3_value; -use ffi::sqlite3_value_type; -use ffi::sqlite3_value_numeric_type; use types::{ToSql, ToSqlOutput, FromSql, ValueRef}; diff --git a/src/lib.rs b/src/lib.rs index d08130d..780cb7f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -50,8 +50,6 @@ //! } //! } //! ``` -#![cfg_attr(feature="clippy", feature(plugin))] -#![cfg_attr(feature="clippy", plugin(clippy))] extern crate libc; extern crate libsqlite3_sys as ffi; @@ -105,6 +103,7 @@ mod raw_statement; const STATEMENT_CACHE_DEFAULT_CAPACITY: usize = 16; /// Old name for `Result`. `SqliteResult` is deprecated. +#[deprecated(since = "0.6.0", note = "Use Result instead")] pub type SqliteResult = Result; /// A typedef of the result returned by many methods. @@ -151,6 +150,7 @@ impl<'a> DatabaseName<'a> { } /// Old name for `Connection`. `SqliteConnection` is deprecated. +#[deprecated(since = "0.6.0", note = "Use Connection instead")] pub type SqliteConnection = Connection; /// A connection to a SQLite database. @@ -367,6 +367,7 @@ impl Connection { /// /// This method should be considered deprecated. Use `query_row` instead, which now /// does exactly the same thing. + #[deprecated(since = "0.1.0", note = "Use query_row instead")] pub fn query_row_safe(&self, sql: &str, params: &[&ToSql], f: F) -> Result where F: FnOnce(Row) -> T { @@ -507,6 +508,7 @@ struct InnerConnection { } /// Old name for `OpenFlags`. `SqliteOpenFlags` is deprecated. +#[deprecated(since = "0.6.0", note = "Use OpenFlags instead")] pub type SqliteOpenFlags = OpenFlags; bitflags! { @@ -678,6 +680,7 @@ impl Drop for InnerConnection { } /// Old name for `Statement`. `SqliteStatement` is deprecated. +#[deprecated(since = "0.6.0", note = "Use Statement instead")] pub type SqliteStatement<'conn> = Statement<'conn>; /// A prepared statement. @@ -1013,6 +1016,7 @@ impl<'stmt, T, E, F> Iterator for AndThenRows<'stmt, F> } /// Old name for `Rows`. `SqliteRows` is deprecated. +#[deprecated(since = "0.6.0", note = "Use Rows instead")] pub type SqliteRows<'stmt> = Rows<'stmt>; /// An handle for the resulting rows of a query. @@ -1077,6 +1081,7 @@ impl<'stmt> Drop for Rows<'stmt> { } /// Old name for `Row`. `SqliteRow` is deprecated. +#[deprecated(since = "0.6.0", note = "Use Row instead")] pub type SqliteRow<'a, 'stmt> = Row<'a, 'stmt>; /// A single result row of a query. @@ -1168,14 +1173,17 @@ impl<'a> ValueRef<'a> { } ffi::SQLITE_BLOB => { let blob = ffi::sqlite3_column_blob(raw, col); - assert!(!blob.is_null(), - "unexpected SQLITE_BLOB column type with NULL data"); let len = ffi::sqlite3_column_bytes(raw, col); - assert!(len >= 0, - "unexpected negative return from sqlite3_column_bytes"); + assert!(len >= 0, "unexpected negative return from sqlite3_column_bytes"); + if len > 0 { + assert!(!blob.is_null(), "unexpected SQLITE_BLOB column type with NULL data"); + ValueRef::Blob(from_raw_parts(blob as *const u8, len as usize)) + } else { + // The return value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer. + ValueRef::Blob(&[]) + } - ValueRef::Blob(from_raw_parts(blob as *const u8, len as usize)) } _ => unreachable!("sqlite3_column_type returned invalid value"), } diff --git a/src/load_extension_guard.rs b/src/load_extension_guard.rs index 7a02db4..92db69b 100644 --- a/src/load_extension_guard.rs +++ b/src/load_extension_guard.rs @@ -1,6 +1,7 @@ use {Result, Connection}; /// Old name for `LoadExtensionGuard`. `SqliteLoadExtensionGuard` is deprecated. +#[deprecated(since = "0.6.0", note = "Use LoadExtensionGuard instead")] pub type SqliteLoadExtensionGuard<'conn> = LoadExtensionGuard<'conn>; /// RAII guard temporarily enabling SQLite extensions to be loaded. diff --git a/src/transaction.rs b/src/transaction.rs index e678215..347f5cb 100644 --- a/src/transaction.rs +++ b/src/transaction.rs @@ -2,6 +2,7 @@ use std::ops::Deref; use {Result, Connection}; /// Old name for `TransactionBehavior`. `SqliteTransactionBehavior` is deprecated. +#[deprecated(since = "0.6.0", note = "Use TransactionBehavior instead")] pub type SqliteTransactionBehavior = TransactionBehavior; /// Options for transaction behavior. See [BEGIN @@ -28,6 +29,7 @@ pub enum DropBehavior { } /// Old name for `Transaction`. `SqliteTransaction` is deprecated. +#[deprecated(since = "0.6.0", note = "Use Transaction instead")] pub type SqliteTransaction<'conn> = Transaction<'conn>; /// Represents a transaction on a database connection. diff --git a/src/types/mod.rs b/src/types/mod.rs index 0a199c7..42ba5db 100644 --- a/src/types/mod.rs +++ b/src/types/mod.rs @@ -112,6 +112,17 @@ mod test { assert_eq!(v, v1234); } + #[test] + fn test_empty_blob() { + let db = checked_memory_handle(); + + let empty = vec![]; + db.execute("INSERT INTO foo(b) VALUES (?)", &[&empty]).unwrap(); + + let v: Vec = db.query_row("SELECT b FROM foo", &[], |r| r.get(0)).unwrap(); + assert_eq!(v, empty); + } + #[test] fn test_str() { let db = checked_memory_handle();