Merge remote-tracking branch 'jgallagher/master' into vtab

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rusqlite"
-version = "0.7.2"
+version = "0.7.3"
 authors = ["John Gallagher <jgallagher@bignerdranch.com>"]
 description = "Ergonomic wrapper for SQLite"
 repository = "https://github.com/jgallagher/rusqlite"
@@ -26,7 +26,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 }
 

Changelog.md

@@ -3,6 +3,14 @@
 * BREAKING CHANGE: The `FromSql` trait has been redesigned. It now requires a single, safe
   method instead of the previous definition which required implementing one or two unsafe
   methods.
+* 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)
 

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"

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<i64> {
-        // 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 => Ok(self.conn.last_insert_rowid()),
-            1 if prev_rowid == new_rowid => Err(Error::StatementFailedToInsertRow),
             _ => 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();
+        db.execute_batch(r"
-        let mut insert = db.prepare("INSERT INTO foo (x) VALUES (?)").unwrap();
+            CREATE TABLE foo(x INTEGER);
-        let mut update = db.prepare("UPDATE foo SET x = ?").unwrap();
+            CREATE TABLE bar(x INTEGER);
+        ")
+            .unwrap();
 
-        assert_eq!(insert.insert(&[&1i32]).unwrap(), 1);
+        assert_eq!(db.prepare("INSERT INTO foo VALUES (10)").unwrap().insert(&[]).unwrap(),
-
+                   1);
-        match update.insert(&[&2i32]) {
+        assert_eq!(db.prepare("INSERT INTO bar VALUES (10)").unwrap().insert(&[]).unwrap(),
-            Err(Error::StatementFailedToInsertRow) => (),
+                   1);
-            r => panic!("Unexpected result {:?}", r),
-        }
     }
 
     #[test]

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")]
@@ -111,7 +108,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"),
@@ -144,7 +140,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",
@@ -171,8 +166,7 @@ impl error::Error for Error {
             Error::InvalidColumnName(_) |
             Error::InvalidColumnType |
             Error::InvalidPath(_) |
-            Error::StatementChangedRows(_) |
+            Error::StatementChangedRows(_) => None,
-            Error::StatementFailedToInsertRow => None,
 
             #[cfg(feature = "functions")]
             Error::InvalidFunctionParameterType => None,

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;
@@ -106,6 +104,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<T> = Result<T>;
 
 /// A typedef of the result returned by many methods.
@@ -152,6 +151,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.
@@ -368,6 +368,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<T, F>(&self, sql: &str, params: &[&ToSql], f: F) -> Result<T>
         where F: FnOnce(Row) -> T
     {
@@ -508,6 +509,7 @@ struct InnerConnection {
 }
 
 /// Old name for `OpenFlags`. `SqliteOpenFlags` is deprecated.
+#[deprecated(since = "0.6.0", note = "Use OpenFlags instead")]
 pub type SqliteOpenFlags = OpenFlags;
 
 bitflags! {
@@ -679,6 +681,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.
@@ -884,10 +887,7 @@ impl<'conn> Statement<'conn> {
         for (i, p) in params.iter().enumerate() {
             try!(unsafe {
                 self.conn.decode_result(
-                    // This should be
+                    p.bind_parameter(self.stmt.ptr(), (i + 1) as c_int)
-                    // `p.bind_parameter(self.stmt.ptr(), (i + 1) as c_int)`
-                    // but that doesn't compile until Rust 1.9 due to a compiler bug.
-                    ToSql::bind_parameter(*p, self.stmt.ptr(), (i + 1) as c_int)
                 )
             });
         }
@@ -968,6 +968,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.
@@ -1032,6 +1033,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.
@@ -1122,12 +1124,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");
-
+                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(&[])
+                }
+
             }
             _ => unreachable!("sqlite3_column_type returned invalid value")
         }

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.

src/named_params.rs

@@ -205,10 +205,7 @@ impl<'conn> Statement<'conn> {
         for &(name, value) in params {
             if let Some(i) = try!(self.parameter_index(name)) {
                 try!(self.conn.decode_result(unsafe {
-                    // This should be
+                    value.bind_parameter(self.stmt.ptr(), i)
-                    // `value.bind_parameter(self.stmt.ptr(), i)`
-                    // but that doesn't compile until Rust 1.9 due to a compiler bug.
-                    ToSql::bind_parameter(value, self.stmt.ptr(), i)
                 }));
             } else {
                 return Err(Error::InvalidParameterName(name.into()));

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.

src/types/mod.rs

@@ -130,6 +130,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<u8> = 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();