btree-store 0.1.6

A persistent, embedded key-value storage engine in Rust featuring a Copy-On-Write (COW) B-Tree, ACID compliance, and crash safety with multi-bucket support
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

use btree_store::BTree;
use tempfile::TempDir;

#[test]
fn test_bucket_iterator() {
    let temp_dir = TempDir::new().unwrap();
    let db_path = temp_dir.path().join("iterator.db");
    let tree = BTree::open(&db_path).unwrap();

    let mut expected = std::collections::BTreeMap::new();
    tree.exec("my_bucket", |txn| {
        for i in 0..100 {
            let key = format!("key_{:03}", i).into_bytes();
            let value = format!("val_{:03}", i).into_bytes();
            txn.put(&key, &value).unwrap();
            expected.insert(key, value);
        }
        Ok(())
    })
    .unwrap();

    tree.view("my_bucket", |txn| {
        let mut iter = txn.iter();
        let mut key_buf = Vec::new();
        let mut val_buf = Vec::new();
        let mut count = 0;
        while iter.next_ref(&mut key_buf, &mut val_buf) {
            assert_eq!(
                expected.get(key_buf.as_slice()).map(|ev| ev.as_slice()),
                Some(val_buf.as_slice())
            );
            count += 1;
        }
        assert_eq!(count, 100);
        Ok(())
    })
    .unwrap();
}

#[test]
fn test_btree_buckets_list() {
    let temp_dir = TempDir::new().unwrap();
    let db_path = temp_dir.path().join("buckets.db");
    let tree = BTree::open(&db_path).unwrap();

    let bucket_names = vec!["bucket_1", "bucket_2", "bucket_3"];
    for name in &bucket_names {
        tree.exec(*name, |_txn| Ok(())).unwrap();
    }

    let mut buckets = tree.buckets().unwrap();
    buckets.sort();
    assert_eq!(buckets, vec!["bucket_1", "bucket_2", "bucket_3"]);

    for name in &buckets {
        tree.exec(name, |txn| {
            txn.put(b"k", b"v").unwrap();
            assert_eq!(txn.get(b"k").unwrap(), b"v".to_vec());
            Ok(())
        })
        .unwrap();
    }
}

#[test]
fn test_empty_bucket_iterator() {
    let temp_dir = TempDir::new().unwrap();
    let db_path = temp_dir.path().join("empty_iter.db");
    let tree = BTree::open(&db_path).unwrap();

    tree.exec("empty_bucket", |_txn| Ok(())).unwrap();

    tree.view("empty_bucket", |txn| {
        let mut iter = txn.iter();
        let mut k = Vec::new();
        let mut v = Vec::new();
        assert!(!iter.next_ref(&mut k, &mut v));
        Ok(())
    })
    .unwrap();
}

#[test]
fn test_iterator_after_reopen() {
    let temp_dir = TempDir::new().unwrap();
    let db_path = temp_dir.path().join("reopen_iter.db");

    {
        let tree = BTree::open(&db_path).unwrap();
        tree.exec("data", |txn| {
            txn.put(b"k1", b"v1").unwrap();
            txn.put(b"k2", b"v2").unwrap();
            Ok(())
        })
        .unwrap();
    }

    {
        let tree = BTree::open(&db_path).unwrap();
        tree.view("data", |txn| {
            let mut iter = txn.iter();
            let mut key_buf = Vec::new();
            let mut val_buf = Vec::new();
            let mut kv = Vec::new();
            while iter.next_ref(&mut key_buf, &mut val_buf) {
                kv.push((key_buf.clone(), val_buf.clone()));
            }
            kv.sort();
            assert_eq!(kv.len(), 2);
            assert_eq!(kv[0], (b"k1".to_vec(), b"v1".to_vec()));
            assert_eq!(kv[1], (b"k2".to_vec(), b"v2".to_vec()));
            Ok(())
        })
        .unwrap();
    }
}