Rusqlite

Rusqlite is an ergonomic wrapper for using SQLite from Rust. It attempts to expose an interface similar to rust-postgres. View the full API documentation.

```rust extern crate rusqlite; extern crate time;

use time::Timespec; use rusqlite::Connection;

[derive(Debug)]

struct Person { id: i32, name: String, time_created: Timespec, data: Option> }

fn main() { let conn = Connection::openinmemory().unwrap();

conn.execute("CREATE TABLE person (
              id              INTEGER PRIMARY KEY,
              name            TEXT NOT NULL,
              time_created    TEXT NOT NULL,
              data            BLOB
              )", &[]).unwrap();
let me = Person {
    id: 0,
    name: "Steven".to_string(),
    time_created: time::get_time(),
    data: None
};
conn.execute("INSERT INTO person (name, time_created, data)
              VALUES (?1, ?2, ?3)",
             &[&me.name, &me.time_created, &me.data]).unwrap();

let mut stmt = conn.prepare("SELECT id, name, time_created, data FROM person").unwrap();
let person_iter = stmt.query_map(&[], |row| {
    Person {
        id: row.get(0),
        name: row.get(1),
        time_created: row.get(2),
        data: row.get(3)
    }
}).unwrap();

for person in person_iter {
    println!("Found person {:?}", person.unwrap());
}

} ```

Supported SQLite Versions

The base rusqlite package supports SQLite version 3.6.8 or newer. If you need support for older versions, please file an issue. Some cargo features require a newer SQLite version; see details below.

Optional Features

Rusqlite provides several features that are behind Cargo features. They are:

• load_extension allows loading dynamic library-based SQLite extensions.
• backup allows use of SQLite's online backup API. Note: This feature requires SQLite 3.6.11 or later.
• functions allows you to load Rust closures into SQLite connections for use in queries. Note: This feature requires SQLite 3.7.3 or later.
• trace allows hooks into SQLite's tracing and profiling APIs. Note: This feature requires SQLite 3.6.23 or later.
• blob gives std::io::{Read, Write, Seek} access to SQL BLOBs. Note: This feature requires SQLite 3.7.4 or later.
• limits allows you to set and retrieve SQLite's per connection limits.
• chrono implements FromSql and ToSql for various types from the chrono crate.
• serde_json implements FromSql and ToSql for the Value type from the serde_json crate.
• bundled uses a bundled version of sqlite3. This is a good option for cases where linking to sqlite3 is complicated, such as Windows.

Author

John Gallagher, johnkgallagher@gmail.com

License

Rusqlite is available under the MIT license. See the LICENSE file for more info.