shunyadb 0.1.0

A correctness-first embedded storage engine written in Rust, built around WAL, immutable LSM pages, MVCC, and deterministic crash recovery.
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

use std::fs;
use std::path::Path;

fn clean_dir(path: &Path) {
    if path.exists() {
        fs::remove_dir_all(path).unwrap();
    }
    fs::create_dir_all(path).unwrap();
}

use std::collections::BTreeMap;
use shunyadb::storage::record::FieldValue;

fn value(i: usize) -> BTreeMap<String, FieldValue> {
    let mut map = BTreeMap::new();
    map.insert(
        "value".to_string(),
        FieldValue::Str(format!("val_{}", i)),
    );
    map
}

use shunyadb::engine::engine::Engine;
use shunyadb::engine::seqno::current;

#[test]
fn persist_1000_entries_to_disk() {
    let base = std::path::Path::new("test_data/shunyadb_engine_test");
    clean_dir(base);

    let mut engine = Engine::open(base).expect("engine open failed");

    for i in 0..1000 {
        engine
            .put(i.to_string(), value(i))
            .expect("put failed");
    }

    let snap_before_flush = current();

    engine.flush().expect("flush failed");

    // Verify files exist
    assert!(base.join("wal.log").exists());
    assert!(base.join("meta.json").exists());

    let page_count = std::fs::read_dir(base)
        .unwrap()
        .filter(|e| {
            e.as_ref()
                .unwrap()
                .file_name()
                .to_string_lossy()
                .starts_with("page_")
        })
        .count();

    assert!(page_count > 0, "no pages written to disk");

    // Verify reads still work after flush
    for i in 0..1000 {
        let rec = engine
            .get(&i.to_string(), snap_before_flush)
            .expect("missing record");

        let v = rec.data.get("value").unwrap();
        assert_eq!(v, &FieldValue::Str(format!("val_{}", i)));
    }
}


#[test]
fn restart_engine_reads_from_disk() {
    let base = std::path::Path::new("test_data/shunyadb_engine_test");

    // Restart (new Engine instance)
    let mut engine = Engine::open(base).expect("engine reopen failed");

    let snapshot = shunyadb::engine::seqno::current();

    for i in 0..1000 {
        let rec = engine
            .get(&i.to_string(), snapshot)
            .expect("record missing after restart");

        let v = rec.data.get("value").unwrap();
        assert_eq!(v, &FieldValue::Str(format!("val_{}", i)));
    }
}


#[test]
fn update_and_delete_after_restart() {
    let base = std::path::Path::new("test_data/shunyadb_engine_test");
    let mut engine = Engine::open(base).unwrap();

    // Update half
    for i in 0..500 {
        engine
            .put(i.to_string(), value(i + 10_000))
            .unwrap();
    }

    // Delete quarter
    for i in 500..750 {
        engine.delete(i.to_string()).unwrap();
    }

    let snap = shunyadb::engine::seqno::current();
    engine.flush().unwrap();

    // Restart again
    let mut engine = Engine::open(base).unwrap();

    // Updated records
    for i in 0..500 {
        let rec = engine.get(&i.to_string(), snap).unwrap();
        let v = rec.data.get("value").unwrap();
        assert_eq!(v, &FieldValue::Str(format!("val_{}", i + 10_000)));
    }

    // Deleted records
    for i in 500..750 {
        assert!(engine.get(&i.to_string(), snap).is_none());
    }

    // Untouched records
    for i in 750..1000 {
        let rec = engine.get(&i.to_string(), snap).unwrap();
        let v = rec.data.get("value").unwrap();
        assert_eq!(v, &FieldValue::Str(format!("val_{}", i)));
    }
}