sqlite 0.14.0

The package provides an interface to SQLite.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

extern crate sqlite;
extern crate temporary;

macro_rules! ok(
    ($result:expr) => ($result.unwrap());
);

#[test]
fn workflow() {
    use sqlite::State;

    macro_rules! pair(
        ($one:expr, $two:expr) => (($one, Some($two)));
    );

    let connection = ok!(sqlite::open(":memory:"));

    let sql = "CREATE TABLE `users` (id INTEGER, name VARCHAR(255), age REAL);";
    ok!(connection.execute(sql));

    {
        let sql = "INSERT INTO `users` (id, name, age) VALUES (?, ?, ?);";
        let mut statement = ok!(connection.prepare(sql));
        ok!(statement.bind(1, 1i64));
        ok!(statement.bind(2, "Alice"));
        ok!(statement.bind(3, 20.99));
        assert!(ok!(statement.step()) == State::Done);
    }

    {
        let mut done = false;
        let sql = "SELECT * FROM `users`;";
        ok!(connection.process(sql, |pairs| {
            assert!(pairs.len() == 3);
            assert!(pairs[0] == pair!("id", "1"));
            assert!(pairs[1] == pair!("name", "Alice"));
            assert!(pairs[2] == pair!("age", "20.99"));
            done = true;
            true
        }));
        assert!(done);
    }

    {
        let sql = "SELECT * FROM `users`;";
        let mut statement = ok!(connection.prepare(sql));
        assert!(ok!(statement.step()) == State::Row);
        assert!(ok!(statement.read::<i64>(0)) == 1);
        assert!(ok!(statement.read::<String>(1)) == String::from("Alice"));
        assert!(ok!(statement.read::<f64>(2)) == 20.99);
        assert!(ok!(statement.step()) == State::Done);
    }
}

#[test]
fn stress() {
    use sqlite::State;
    use std::path::PathBuf;
    use std::thread;
    use temporary::Directory;

    let directory = ok!(Directory::new("sqlite"));
    let path = directory.path().join("database.sqlite3");

    let connection = ok!(sqlite::open(&path));
    let sql = "CREATE TABLE `users` (id INTEGER, name VARCHAR(255), age REAL);";
    ok!(connection.execute(sql));

    let guards = (0..100).map(|_| {
        let path = PathBuf::from(&path);
        thread::spawn(move || {
            let mut connection = ok!(sqlite::open(&path));
            ok!(connection.set_busy_handler(|_| true));
            let sql = "INSERT INTO `users` (id, name, age) VALUES (?, ?, ?);";
            let mut statement = ok!(connection.prepare(sql));
            ok!(statement.bind(1, 1i64));
            ok!(statement.bind(2, "Alice"));
            ok!(statement.bind(3, 20.99));
            assert!(ok!(statement.step()) == State::Done);
            true
        })
    }).collect::<Vec<_>>();

    for guard in guards {
        assert!(guard.join().unwrap());
    }
}