vsdb 13.1.0

A std-collection-like database
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
139
140
141
142
143
144
145
146
147
148

use super::*;
use ruc::*;

macro_rules! s {
    ($i: expr) => {{ $i.as_bytes().to_vec() }};
}

#[test]
fn dagmaprawkey_functions() {
    let mut i0 = DagMapRawKey::new(&mut Orphan::new(None)).unwrap();
    i0.insert("k0", &s!("v0"));
    assert_eq!(i0.get("k0").unwrap(), s!("v0"));
    assert!(i0.get("k1").is_none());
    let mut i0_raw = Orphan::new(Some(i0.into_inner()));

    let mut i1 = DagMapRawKey::new(&mut i0_raw).unwrap();
    i1.insert("k1", &s!("v1"));
    assert_eq!(i1.get("k1").unwrap(), s!("v1"));
    assert_eq!(i1.get("k0").unwrap(), s!("v0"));
    let mut i1_raw = Orphan::new(Some(i1.into_inner()));

    let mut i2 = DagMapRawKey::new(&mut i1_raw).unwrap();
    i2.insert("k2", &s!("v2"));
    assert_eq!(i2.get("k2").unwrap(), s!("v2"));
    assert_eq!(i2.get("k1").unwrap(), s!("v1"));
    assert_eq!(i2.get("k0").unwrap(), s!("v0"));
    i2.insert("k2", &s!("v2x"));
    assert_eq!(i2.get("k2").unwrap(), s!("v2x"));
    assert_eq!(i2.get("k1").unwrap(), s!("v1"));
    assert_eq!(i2.get("k0").unwrap(), s!("v0"));
    i2.insert("k1", &s!("v1x"));
    assert_eq!(i2.get("k2").unwrap(), s!("v2x"));
    assert_eq!(i2.get("k1").unwrap(), s!("v1x"));
    assert_eq!(i2.get("k0").unwrap(), s!("v0"));
    i2.insert("k0", &s!("v0x"));
    assert_eq!(i2.get("k2").unwrap(), s!("v2x"));
    assert_eq!(i2.get("k1").unwrap(), s!("v1x"));
    assert_eq!(i2.get("k0").unwrap(), s!("v0x"));

    assert!(i1_raw.get_value().unwrap().get("k2").is_none());
    assert_eq!(
        i1_raw.get_value().unwrap().get("k1").unwrap(),
        s!("v1").encode()
    );
    assert_eq!(
        i1_raw.get_value().unwrap().get("k0").unwrap(),
        s!("v0").encode()
    );

    assert!(i0_raw.get_value().unwrap().get("k2").is_none());
    assert!(i0_raw.get_value().unwrap().get("k1").is_none());
    assert_eq!(
        i0_raw.get_value().unwrap().get("k0").unwrap(),
        s!("v0").encode()
    );

    let mut head = i2.prune().unwrap();
    sleep_ms!(1000); // give some time to the async cleaner

    assert_eq!(head.get("k2").unwrap(), s!("v2x"));
    assert_eq!(head.get("k1").unwrap(), s!("v1x"));
    assert_eq!(head.get("k0").unwrap(), s!("v0x"));

    assert!(i1_raw.get_value().is_none());
    assert!(i1_raw.get_value().is_none());
    assert!(i1_raw.get_value().is_none());

    assert!(i0_raw.get_value().is_none());
    assert!(i0_raw.get_value().is_none());
    assert!(i0_raw.get_value().is_none());

    // prune with deep stack
    for i in 10u8..=255 {
        head.insert(i.to_be_bytes(), &i.to_be_bytes().to_vec());
        head = DagMapRawKey::new(&mut Orphan::new(Some(head.into_inner()))).unwrap();
    }

    let mut head = head.prune().unwrap();
    sleep_ms!(1000); // give some time to the async cleaner

    for i in 10u8..=255 {
        assert_eq!(head.get(i.to_be_bytes()).unwrap(), i.to_be_bytes().to_vec());
    }

    for i in 0u8..=254 {
        head.remove(i.to_be_bytes());
        assert!(head.get(i.to_be_bytes()).is_none());
    }

    *(head.get_mut(255u8.to_be_bytes()).unwrap()) = 0u8.to_be_bytes().to_vec();
    assert_eq!(
        head.get(255u8.to_be_bytes()).unwrap().as_slice(),
        0u8.to_be_bytes()
    );
}

#[test]
fn test_save_and_from_meta() {
    let mut dag: DagMapRawKey<Vec<u8>> =
        DagMapRawKey::new(&mut Orphan::new(None)).unwrap();
    dag.insert("k1", &s!("v1"));
    dag.insert("k2", &s!("v2"));

    let id = dag.save_meta().unwrap();
    assert_eq!(id, dag.instance_id());

    let restored: DagMapRawKey<Vec<u8>> = DagMapRawKey::from_meta(id).unwrap();
    assert_eq!(restored.get("k1").unwrap(), s!("v1"));
    assert_eq!(restored.get("k2").unwrap(), s!("v2"));
}

/// Postcard serde roundtrip for DagMapRawKey (delegates to DagMapRaw).
#[test]
fn test_serde_roundtrip() {
    let mut dag: DagMapRawKey<Vec<u8>> =
        DagMapRawKey::new(&mut Orphan::new(None)).unwrap();
    dag.insert("x", &s!("X"));
    dag.insert("y", &s!("Y"));

    let bytes = postcard::to_allocvec(&dag).unwrap();
    let restored: DagMapRawKey<Vec<u8>> = postcard::from_bytes(&bytes).unwrap();

    assert_eq!(restored.get("x").unwrap(), s!("X"));
    assert_eq!(restored.get("y").unwrap(), s!("Y"));
}

/// from_meta nonexistent.
#[test]
fn test_from_meta_nonexistent() {
    assert!(DagMapRawKey::<Vec<u8>>::from_meta(u64::MAX).is_err());
}

/// Restore meta with parent-child lineage.
#[test]
fn test_meta_with_parent_child() {
    let mut p = DagMapRawKey::<Vec<u8>>::new(&mut Orphan::new(None)).unwrap();
    p.insert("pk", &s!("pv"));

    let mut c =
        DagMapRawKey::<Vec<u8>>::new(&mut Orphan::new(Some(p.into_inner()))).unwrap();
    c.insert("ck", &s!("cv"));

    let id = c.save_meta().unwrap();
    let restored: DagMapRawKey<Vec<u8>> = DagMapRawKey::from_meta(id).unwrap();

    assert_eq!(restored.get("ck").unwrap(), s!("cv"));
    assert_eq!(restored.get("pk").unwrap(), s!("pv"));
}