Ergonomic bindings to SQLite for Rust
Go to file
2016-05-19 15:01:22 -05:00
benches Add benchmarks for statement cache. 2015-12-20 09:46:05 +01:00
libsqlite3-sys Remove load_extension feature from the binding 2016-02-13 10:51:24 +08:00
src Merge pull request #155 from jgallagher/fix-nightly-test-failures 2016-05-19 14:57:16 -05: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 Remove cache feature 2016-05-17 12:01:55 -05:00
appveyor.yml Remove cache feature 2016-05-17 12:01:55 -05:00
build.rs Use new hyphen-less extern crate name 2015-03-26 15:49:13 -04:00
Cargo.toml Use a real LruCache instead of a VecDeque. 2016-05-17 13:35:23 -05:00
Changelog.md Merge branch 'master' into remove-rows-iterator-impl 2016-05-19 14:06:56 -05: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 Add blob feature to doc-publishing script 2016-01-07 11:32:56 -05:00
README.md Remove scary lifetime-of-rows-may-panic from README. 2016-02-01 14:30:51 -05: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.

Author

John Gallagher, johnkgallagher@gmail.com

License

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