libdb 0.1.1

statically linked rust bindings for Berkeley DB
Documentation 
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

extern crate libdb;
extern crate tempdir;

use std::str;
use std::path::Path;
use tempdir::TempDir;
use libdb::Flags;

#[test]
fn open_close_open_test() {
    let dbdir     = TempDir::new("libdb-rs").expect("Expected temp dir");

    {
        let (env, db) = open_test_db(dbdir.path());
        let mut key   = String::from("key").into_bytes();
        let mut value = String::from("value").into_bytes();
        assert!(db.put(None, key.as_mut_slice(), value.as_mut_slice(), Flags::DB_NONE).is_ok());
    }

    {
        let (env, db) = open_test_db(dbdir.path());
        let mut key = String::from("key").into_bytes();
        assert_record_eq(&db, key.as_mut_slice(), "value");
    }
}

#[test]
fn test_transaction() {
    let dbdir     = TempDir::new("libdb-rs").expect("Expected temp dir");
    let (env, db) = open_test_db(dbdir.path());

    let mut key   = String::from("key").into_bytes();
    let mut value = String::from("value").into_bytes();

    // Test explicit abort
    {
        let txn = env.txn(None, Flags::DB_NONE).unwrap();
        let ret = db.put(Some(&txn), key.as_mut_slice(), value.as_mut_slice(), Flags::DB_NONE);
        print!("{:?}", ret);
        assert!(ret.is_ok());
        assert!(txn.abort().is_ok());
    }

    // Should have no record.
    assert_norecord(&db, key.as_mut_slice());

    // Test abort when out of scope
    {
        let txn = env.txn(None, Flags::DB_NONE).unwrap();
        db.put(Some(&txn), key.as_mut_slice(), value.as_mut_slice(), Flags::DB_NONE).expect("Failed to put");
    }

    // Should have no record.
    assert_norecord(&db, key.as_mut_slice());

    // Test commit
    {
        let txn = env.txn(None, Flags::DB_NONE).unwrap();
        db.put(Some(&txn), key.as_mut_slice(), value.as_mut_slice(), Flags::DB_NONE).expect("Failed to put");
        txn.commit(libdb::CommitType::Inherit).expect("Failed to commit");
    }

    // Should have record
    assert_record_eq(&db, key.as_mut_slice(), "value");
}

#[test]
fn test_cursor() {
    let dbdir     = TempDir::new("libdb-rs").expect("Expected temp dir");
    let (env, db) = open_test_db(dbdir.path());

    let mut key_a   = String::from("testkeyA").into_bytes();
    let mut value_a = String::from("testvalueA").into_bytes();
    let mut key_b   = String::from("testkeyB").into_bytes();
    let mut value_b = String::from("testvalueB").into_bytes();

    // commit test values
    {
        let txn = env.txn(None, Flags::DB_NONE).unwrap();
        db.put(Some(&txn), key_a.as_mut_slice(), value_a.as_mut_slice(), Flags::DB_NONE).expect("Failed to put");
        txn.commit(libdb::CommitType::Inherit).expect("Failed to commit");
    }
    {
        let txn = env.txn(None, Flags::DB_NONE).unwrap();
        db.put(Some(&txn), key_b.as_mut_slice(), value_b.as_mut_slice(), Flags::DB_NONE).expect("Failed to put");
        txn.commit(libdb::CommitType::Inherit).expect("Failed to commit");
    }

    // get cursor and iterate
    let mut cursor = db.cursor().expect("Failed to get cursor");
    {
        let (key_dbt, data_dbt) = cursor.next().expect("Could not walk cursor");
        assert_eq!("testkeyA", str::from_utf8(key_dbt.unwrap().as_slice()).unwrap());
        assert_eq!("testvalueA", str::from_utf8(data_dbt.unwrap().as_slice()).unwrap());
    }
    {
        let (key_dbt, data_dbt) = cursor.next().expect("Could not walk cursor");
        assert_eq!("testkeyB", str::from_utf8(key_dbt.unwrap().as_slice()).unwrap());
        assert_eq!("testvalueB", str::from_utf8(data_dbt.unwrap().as_slice()).unwrap());
    }
}

/// Helper to open a BDB environment for the test.
fn open_test_db(dir: &Path) -> (libdb::Environment, libdb::Database) {
    let env = libdb::EnvironmentBuilder::new()
        .home(dir)
        .flags(Flags::DB_CREATE | Flags::DB_RECOVER | Flags::DB_INIT_LOG | Flags::DB_INIT_TXN | Flags::DB_INIT_MPOOL)
        .open()
        .expect("Failed to open DB");

    let txn = env.txn(None, Flags::DB_NONE).unwrap();
    let ret = libdb::DatabaseBuilder::new()
        .transaction(&txn)
        .environment(&env)
        .file("db")
        .flags(Flags::DB_CREATE)
        .open();

    match ret.as_ref() {
        Ok(db) => txn.commit(libdb::CommitType::Inherit).expect("Commit failed"),
        Err(e) => { panic!("Error: {:?}", e) }
    }

    (env, ret.unwrap())
}

/// Helper to assert a record is missing in the database.
fn assert_norecord(db: &libdb::Database, key: &mut [u8]) {
    assert!(db.get(None, key, Flags::DB_NONE).unwrap().is_none());
}

/// Helper to assert a record has a specific value in the database.
fn assert_record_eq(db: &libdb::Database, key: &mut [u8], expected :&str) {
    match db.get(None, key, Flags::DB_NONE) {
        Ok(Some(value)) => assert_eq!(expected, str::from_utf8(value.as_slice()).unwrap()),
        _               => assert!(false)
    }
}