Ergonomic bindings to SQLite for Rust
Go to file
2017-02-09 20:23:17 -05:00
benches Add benchmarks for statement cache. 2015-12-20 09:46:05 +01:00
libsqlite3-sys Manually insert SQLITE_DETERMINISTIC flag in bindgen output if needed. 2017-02-08 21:41:34 -05:00
src Clarify support of older SQLite versions. 2017-02-09 20:23:17 -05:00
tests Clarify support of older SQLite versions. 2017-02-09 20:23:17 -05:00
.gitignore gitignore doc/ 2014-10-20 20:22:15 -04:00
.travis.yml Manually insert SQLITE_DETERMINISTIC flag in bindgen output if needed. 2017-02-08 21:41:34 -05:00
appveyor.yml Update appveyor.yml 2017-02-08 20:55:29 -05:00
Cargo.toml Clarify support of older SQLite versions. 2017-02-09 20:23:17 -05:00
Changelog.md Clarify support of older SQLite versions. 2017-02-09 20:23:17 -05:00
clippy.toml Teach clippy about allowed doc markdown identifiers 2016-05-19 15:01:22 -05:00
CONTRIBUTORS.md Add to CONTRIBUTORS 2017-01-25 17:40:49 -05:00
LICENSE Add LICENSE and README 2014-11-04 11:32:06 -05:00
publish-ghp-docs.sh Update feature list in doc-publishing script 2016-05-19 20:26:18 -05:00
README.md Clarify support of older SQLite versions. 2017-02-09 20:23:17 -05:00

Rusqlite

Travis Build Status AppVeyor Build Status Latest Version

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.

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<Vec<u8>>
}

fn main() {
    let conn = Connection::open_in_memory().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.