For version 0.15.0 and above, see Releases page.
ToSql implementation for time::Timespec uses RFC 3339 (%Y-%m-%dT%H:%M:%S.%fZ). Previous format was %Y-%m-%d %H:%M:%S:%f %Z.Sendable and 'static.free_boxed_hook does not work for fn.sqlite3_update_hook (#260, #328), sqlite3_commit_hook and sqlite3_rollback_hook.unlock_notify feature (#294, #331).Statement::column_index case insensitive (#330).&mut Connection in Transaction.tyvar_behind_raw_pointer warnings.Connection::open documentation (#332)sqlite3_get_autocommit and sqlite3_stmt_busy.sqlite3_busy_timeout and sqlite3_busy_handler.sqlite3_expanded_sql.rerun-if-env-changed in libsqlite3-sys (#329).InvalidQuery error when SQL is not read only.sqlcipher feature allows linking against SQLCipher instead of SQLite.ToSql impls for str and [u8].FromSql and ToSql impls for isize. Documents why usize and u64 are not included.bundled SQLite version to 3.17.0.bindgen. This should improve build times and no longer require a new-ish Clang. See the README for more details.ErrorCode enum from libsqlite3-sys.version() and version_number() functions for querying the version of SQLite in use.limits feature, exposing limit() and set_limit() methods on Connection.libsqlite3-sys 0.7.0, which runs rust-bindgen at build-time instead of assuming the precense of all expected SQLite constants and functions.rusqlite::bypass_sqlite_initialization(). This is technically a breaking change but is unlikely to affect anyone in practice, since prior to this version the check that rusqlite was using would cause a segfault if linked against a SQLite older than 3.7.0.rusqlite::bypass_sqlite_version_check().libc dependency in favor of using std::os::rawClone, Debug, and PartialEq to ToSqlOutput.ToSqlOutput itself implement ToSql.FromSql impl for i32 now returns an error instead of truncating if the underlying SQLite value is out of i32's range.FromSql and ToSql impls for i8, i16, u8, u16, and u32. i32 and i64 already had impls. u64 is omitted because their range cannot be represented by i64, which is the type we use to communicate with SQLite.Connection::close() now returns a Result<(), (Connection, Error)> instead of a Result<(), Error> so callers get the still-open connection back on failure.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.ToSql trait has been redesigned. It can now be implemented without unsafe, and implementors can choose to return either borrowed or owned results.query_row, query_row_and_then, query_row_safe, and query_row_named now expects a &Row instead of a Row. The vast majority of calls to these functions will probably not need to change; see https://github.com/jgallagher/rusqlite/pull/184.Error enum have sprouted additional information (e.g., FromSqlConversionFailure now also includes the column index and the type returned by SQLite).#[deprecated(since = "...", note = "...")] flags (new in Rust 1.9 for libraries) to all deprecated APIs.query_row convenience function to Statement.bundled feature which will build SQLite from source instead of attempting to link against a SQLite that already exists on the system.DatabaseBusy; see https://github.com/jgallagher/rusqlite/issues/186.insert() convenience function when back-to-back inserts to different tables both returned the same row ID (#171).Rows no longer implements Iterator. It still has a next() method, but the lifetime of the returned Row is now tied to the lifetime of the vending Rows object. This behavior is more correct. Previously there were runtime checks to prevent misuse, but other changes in this release to reset statements as soon as possible introduced yet another hazard related to the lack of these lifetime connections. We were already recommending the use of query_map and query_and_then over raw query; both of theose still return handles that implement Iterator.Transaction::savepoint() now returns a Savepoint instead of another Transaction. Unlike Transaction, Savepoints can be rolled back while keeping the current savepoint active.Connection or savepoints from a Transaction now take &mut self instead of &self to correctly represent that transactions within a connection are inherently nested. While a transaction is alive, the parent connection or transaction is unusable, so Transaction now implements Deref<Target=Connection>, giving access to Connection's methods via the Transaction itself.Transaction::set_commit and Transaction::set_rollback have been replaced by Transaction::set_drop_behavior.Connection::prepare_cached. Connection now keeps an internal cache of any statements prepared via this method. The size of this cache defaults to 16 (prepare_cached will always work but may re-prepare statements if more are prepared than the cache holds), and can be controlled via Connection::set_prepared_statement_cache_capacity.query_map_named and query_and_then_named to Statement.insert convenience method to Statement which returns the row ID of an inserted row.exists convenience method returning whether a query finds one or more rows.serde_json crate. Requires the serde_json feature.chrono crate. Requires the chrono feature.load_extension feature from libsqlite3-sys. load_extension is still available on rusqlite itself.trace feature.clippy feature and addresses issues it found.column_count() method to Statement and Row.types::Value for dynamic column types.functions Cargo feature).RowIndex trait allowing columns to be fetched via index (as before) or name (new).ZeroBlob type under the blob module/feature exposing SQLite's zeroblob API.handle() method to Connection. Please file an issue if you actually use it.SqliteError is now an enum instead of a struct. Previously, we were (ab)using the error code and message to send back both underlying SQLite errors and errors that occurred at the Rust level. Now those have been separated out; SQLite errors are returned as SqliteFailure cases (which still include the error code but also include a Rust-friendlier enum as well), and rusqlite-level errors are captured in other cases. Because of this change, SqliteError no longer implements PartialEq.SqliteTransactionDeferred, SqliteTransactionImmediate, and SqliteTransactionExclusive are no longer exported. Instead, use TransactionBehavior::Deferred, TransactionBehavior::Immediate, and TransactionBehavior::Exclusive.Sqlite prefix on many types:SqliteConnection is now ConnectionSqliteError is now ErrorSqliteResult is now ResultSqliteStatement is now StatementSqliteRows is now RowsSqliteRow is now RowSqliteOpenFlags is now OpenFlagsSqliteTransaction is now Transaction.SqliteTransactionBehavior is now TransactionBehavior.SqliteLoadExtensionGuard is now LoadExtensionGuard. The old, prefixed names are still exported but are deprecated...._named methods for executing queries using named placeholder parameters.backup feature that exposes SQLite's online backup API.blob feature that exposes SQLite's Incremental I/O for BLOB API.functions feature that allows user-defined scalar functions to be added to open SqliteConnections.trace feature that allows the use of SQLite's logging, tracing, and profiling hooks.query_map and query_and_then:'static requirement on the closure's output type.&SqliteRow instead of a SqliteRow.SQLITE3_LIB_DIR now takes precedence over pkg-config.pkg-config is not available, we will try to find libsqlite3 in /usr/lib.SqliteResults.libc dependency to 0.2, fixing builds on ARM for Rust 1.6 or newer.Sized bound to FromSql trait as required by RFC 1214.get_opt. Use get_checked instead.query_row_and_then and query_and_then convenience functions. These are analogous to query_row and query_map but allow functions that can fail by returning Results.P: AsRef<...> from &P to P.execute when query was intended.SqliteStatement and SqliteConnection.get_checked to correctly indicate that it returns errors (not panics) when given invalid types or column indices.column_names() to SqliteStatement.SQLITE_OPEN_NO_MUTEX and SQLITE_OPEN_URI flags when opening a new conneciton.sqlite3_exec was wrong).sqlite3_destructor_type to define SQLITE_STATIC and SQLITE_TRANSIENT.query_row to return a Result instead of unwrapping.query_row_safe (use query_row instead).query_map.get_checked, which asks SQLite to do some basic type-checking of columns.stable branch. Development continues on master and still requires a nightly version of Rust.Send.libc crate).sqlite3_stmt from libsqlite3-sys for easier impl-ing of ToSql and FromSql.open now expects a Path rather than a str. There is a separate open_in_memory constructor for opening in-memory databases.load_extension Cargo feature, because not all builds of sqlite3 include this ability. Notably the default libsqlite3 that ships with OS X 10.10 does not support extensions.Error trait for SqliteError.query_row_safe, a SqliteResult-returning variant of query_row.std::c_str -> std::ffi).sqlite3_busy_timeout.std::vec::raw::from_buf.time crate.