matdb 0.1.0

An experimental embedded SQL-like DBMS
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

use std::collections::BTreeMap;

use matdb::{Db, Value};
use rand::{seq::IteratorRandom, SeedableRng};
use rand_chacha::ChaCha12Rng;

fn setup() -> (BTreeMap<i64, i64>, Db) {
    let mut db = Db::open_memory().unwrap();

    db.run(
        "CREATE TABLE t0 ( c0 INT PRIMARY KEY, c1 INT );",
        Vec::new(),
    )
    .unwrap();

    let mut our = BTreeMap::new();

    for (k, v) in (0..1000i64).zip((0..1000i64).rev()) {
        our.insert(k, v);
        db.run(
            &format!("INSERT INTO t0 (c0, c1) VALUES ({k}, {v});"),
            Vec::new(),
        )
        .unwrap();
    }

    (our, db)
}

fn cleanup(our: BTreeMap<i64, i64>, mut db: Db) {
    assert!(our.is_empty());
    assert!(db
        .run("SELECT c0, c1 FROM t0;", Vec::new())
        .unwrap()
        .unwrap()
        .rows
        .is_empty());
}

#[test]
fn delete_sequnetial_rising() {
    let (mut our, mut db) = setup();

    for k in 0..1000i64 {
        our.remove(&k);
        db.run(&format!("DELETE FROM t0 WHERE c0 = {k};"), Vec::new())
            .unwrap();

        for (row, our_pair) in db
            .run("SELECT c0, c1 FROM t0;", Vec::new())
            .unwrap()
            .unwrap()
            .rows
            .iter()
            .zip(our.iter())
        {
            assert_eq!(row.as_slice()[0], Value::Int(*our_pair.0));
            assert_eq!(row.as_slice()[1], Value::Int(*our_pair.1));
        }
    }

    cleanup(our, db);
}

#[test]
fn delete_sequnetial_decreasing() {
    let (mut our, mut db) = setup();

    for k in (0..1000i64).rev() {
        our.remove(&k);
        db.run(&format!("DELETE FROM t0 WHERE c0 = {k};"), Vec::new())
            .unwrap();

        for (row, our_pair) in db
            .run("SELECT c0, c1 FROM t0;", Vec::new())
            .unwrap()
            .unwrap()
            .rows
            .iter()
            .zip(our.iter())
        {
            assert_eq!(row.as_slice()[0], Value::Int(*our_pair.0));
            assert_eq!(row.as_slice()[1], Value::Int(*our_pair.1));
        }
    }

    cleanup(our, db);
}

#[test]
fn delete_seeded_random() {
    for seed in [2524, 8131, 3600, 1082, 6081, 6583] {
        let (mut our, mut db) = setup();

        let mut rng = ChaCha12Rng::seed_from_u64(seed);

        while let Some(k) = our.keys().choose(&mut rng).cloned() {
            our.remove(&k);
            db.run(&format!("DELETE FROM t0 WHERE c0 = {k};"), Vec::new())
                .unwrap();

            for (row, our_pair) in db
                .run("SELECT c0, c1 FROM t0;", Vec::new())
                .unwrap()
                .unwrap()
                .rows
                .iter()
                .zip(our.iter())
            {
                assert_eq!(row.as_slice()[0], Value::Int(*our_pair.0));
                assert_eq!(row.as_slice()[1], Value::Int(*our_pair.1));
            }
        }

        cleanup(our, db);
    }
}