forest_db 0.1.0

Database types used in Forest
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

// Copyright 2020 ChainSafe Systems
// SPDX-License-Identifier: Apache-2.0, MIT

use db::Store;

pub fn write<DB>(db: &DB)
where
    DB: Store,
{
    let key = [1];
    let value = [1];
    db.write(key, value).unwrap();
}

pub fn read<DB>(db: &DB)
where
    DB: Store,
{
    let key = [0];
    let value = [1];
    db.write(key.clone(), value.clone()).unwrap();
    let res = db.read(key).unwrap().unwrap();
    assert_eq!(value.as_ref(), res.as_slice());
}

pub fn exists<DB>(db: &DB)
where
    DB: Store,
{
    let key = [0];
    let value = [1];
    db.write(key.clone(), value.clone()).unwrap();
    let res = db.exists(key).unwrap();
    assert_eq!(res, true);
}

pub fn does_not_exist<DB>(db: &DB)
where
    DB: Store,
{
    let key = [0];
    let res = db.exists(key).unwrap();
    assert_eq!(res, false);
}

pub fn delete<DB>(db: &DB)
where
    DB: Store,
{
    let key = [0];
    let value = [1];
    db.write(key.clone(), value.clone()).unwrap();
    let res = db.exists(key.clone()).unwrap();
    assert_eq!(res, true);
    db.delete(key.clone()).unwrap();
    let res = db.exists(key.clone()).unwrap();
    assert_eq!(res, false);
}

pub fn bulk_write<DB>(db: &DB)
where
    DB: Store,
{
    let values = [([0], [0]), ([1], [1]), ([2], [2])];
    db.bulk_write(&values).unwrap();
    for (k, _) in values.iter() {
        let res = db.exists(k.clone()).unwrap();
        assert_eq!(res, true);
    }
}

pub fn bulk_read<DB>(db: &DB)
where
    DB: Store,
{
    let keys = [[0], [1], [2]];
    let values = [[0], [1], [2]];
    let kvs: Vec<_> = keys.iter().zip(values.iter()).collect();
    db.bulk_write(&kvs).unwrap();
    let results = db.bulk_read(&keys).unwrap();
    for (result, value) in results.iter().zip(values.iter()) {
        match result {
            Some(v) => assert_eq!(v, value),
            None => panic!("No values found!"),
        }
    }
}

pub fn bulk_delete<DB>(db: &DB)
where
    DB: Store,
{
    let keys = [[0], [1], [2]];
    let values = [[0], [1], [2]];
    let kvs: Vec<_> = keys.iter().zip(values.iter()).collect();
    db.bulk_write(&kvs).unwrap();
    db.bulk_delete(&keys).unwrap();
    for k in keys.iter() {
        let res = db.exists(k.clone()).unwrap();
        assert_eq!(res, false);
    }
}