dustdata 1.3.2

A data concurrency control storage engine to Rustbase
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

pub mod bloom;
mod dustdata;
pub mod storage;

pub use self::{
    dustdata::DustData, dustdata::DustDataConfig, dustdata::Error, dustdata::ErrorCode,
    dustdata::LsmConfig, dustdata::Result, dustdata::Size, storage::lsm::snapshots,
};
pub use bson;

/// Initialize the database
/// # Arguments
/// * `config` - A configuration object
/// # Returns
/// - DustData object
pub fn initialize(config: dustdata::DustDataConfig) -> dustdata::DustData {
    dustdata::DustData::new(config)
}

#[cfg(test)]
mod dustdata_tests {
    use super::*;

    fn get_default_config() -> DustDataConfig {
        DustDataConfig {
            path: std::path::Path::new("./test_data/dustdata").to_path_buf(),
            lsm_config: LsmConfig {
                flush_threshold: Size::Megabytes(128),
            },
        }
    }

    #[test]
    fn insert_document() {
        let config = get_default_config();

        let mut dd = initialize(config);

        let now = std::time::SystemTime::now();
        dd.insert(
            "insert_doc",
            bson::bson!({
                "test": "test"
            }),
        )
        .unwrap();
        println!("Insert took: {:?}", now.elapsed().unwrap());

        let now = std::time::SystemTime::now();
        assert!(dd.get("insert_doc").unwrap().is_some());
        println!("Get took: {:?}", now.elapsed().unwrap());

        dd.delete("insert_doc").unwrap(); // delete the test document
    }

    #[test]
    fn update_document() {
        let config = get_default_config();

        let mut dd = initialize(config);
        dd.insert(
            "update_doc",
            bson::bson!({
                "test": "test"
            }),
        )
        .unwrap();

        let now = std::time::SystemTime::now();
        dd.update(
            "update_doc",
            bson::bson! ({
                "test": "test2"
            }),
        )
        .unwrap();
        println!("Update took: {:?}", now.elapsed().unwrap());

        let ls = dd.list_keys().unwrap();

        let get = dd.get("update_doc").unwrap().unwrap();
        let get = get.as_document().unwrap();

        let get = get.get("test").unwrap().as_str().unwrap();

        assert_eq!(get, "test2");
        assert!(ls.contains(&"update_doc".to_string()));

        dd.delete("update_doc").unwrap(); // delete the test document
    }

    #[test]
    fn reading_on_sstable() {
        let config = get_default_config();

        let mut dd = initialize(config);

        dd.insert(
            "read_sstable",
            bson::bson!({
                "test": "test"
            }),
        )
        .unwrap();

        // flush the sstable
        dd.flush().unwrap();

        let ls = dd.list_keys().unwrap();

        let now = std::time::SystemTime::now();
        let get = dd.get("read_sstable").unwrap().unwrap();
        println!("SSTable Get took: {:?}", now.elapsed().unwrap());
        let get = get.as_document().unwrap();

        let get = get.get("test").unwrap().as_str().unwrap();

        assert_eq!(get, "test");
        assert!(ls.contains(&"read_sstable".to_string()));

        dd.delete("read_sstable").unwrap(); // delete the test document
    }
}