Ergonomic bindings to SQLite for Rust
Go to file
2016-12-04 10:18:56 +01:00
benches Add benchmarks for statement cache. 2015-12-20 09:46:05 +01:00
libsqlite3-sys Bump to version 0.7.0. 2016-05-19 20:26:18 -05:00
src Fix clippy warnings 2016-12-04 10:18:56 +01:00
tests Add test and check for SQLite being in single-threaded mode 2015-12-16 23:56:21 -05:00
.gitignore gitignore doc/ 2014-10-20 20:22:15 -04:00
.travis.yml Merge remote-tracking branch 'jgallagher/master' into vtab 2016-05-19 21:24:17 +02:00
appveyor.yml Merge remote-tracking branch 'jgallagher/master' into vtab 2016-07-02 11:51:42 +02:00
build.rs Use new hyphen-less extern crate name 2015-03-26 15:49:13 -04:00
Cargo.toml Upgrade lru-cache dependency 2016-12-04 10:17:53 +01:00
Changelog.md Merge branch 'release-0.7' into merge-0.7.3 2016-06-01 21:31:26 -04:00
clippy.toml Teach clippy about allowed doc markdown identifiers 2016-05-19 15:01:22 -05:00
CONTRIBUTORS.md Add supsuper to CONTRIBUTORS 2016-03-29 16:37:36 -04: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 Add new features to README. 2016-05-19 20:26:18 -05:00
test.csv First minimalist test for csvtab implementation. 2016-02-11 19:16:05 +01:00

Rusqlite

Travis Build Status AppVeyor Build Status

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 mut 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());
    }
}

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.
  • functions allows you to load Rust closures into SQLite connections for use in queries.
  • trace allows hooks into SQLite's tracing and profiling APIs.
  • blob gives std::io::{Read, Write, Seek} access to SQL BLOBs.
  • 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.

Author

John Gallagher, johnkgallagher@gmail.com

License

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