siamesedb 0.1.23

The simple local key-value store.
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

use siamesedb::filedb::{CheckFileDbMap, FileBufSizeParam, FileDbParams};

fn main() -> std::io::Result<()> {
    let args: Vec<String> = std::env::args().collect();
    match args[1].as_str() {
        "-s" => check_string(&args[2])?,
        "-b" => check_bytes(&args[2])?,
        "-u" => check_dbint(&args[2])?,
        _ => {
            eprintln!("[usage] {} {{-s|-b|-u}} path", args[0]);
        }
    }
    Ok(())
}

#[derive(Debug, Default, Clone, Copy)]
struct CheckC {
    check: bool,
    f_mst: bool,
    f_graph: bool,
}

fn check_string(db_name: &str) -> std::io::Result<()> {
    let db = siamesedb::open_file(db_name).unwrap();
    let db_map = db
        .db_map_string_with_params(
            "some_map1",
            FileDbParams {
                key_buf_size: FileBufSizeParam::PerMille(1000),
                idx_buf_size: FileBufSizeParam::PerMille(1000),
                ..Default::default()
            },
        )
        .unwrap();
    _print_check_db_map(
        &db_map,
        CheckC {
            check: true,
            f_mst: true,
            f_graph: false,
            /*
            check: false,
            f_mst: false,
            f_graph: true,
            */
        },
    );
    //
    Ok(())
}

fn check_bytes(db_name: &str) -> std::io::Result<()> {
    let db = siamesedb::open_file(db_name).unwrap();
    let db_map = db
        .db_map_bytes_with_params(
            "some_map1",
            FileDbParams {
                key_buf_size: FileBufSizeParam::PerMille(1000),
                idx_buf_size: FileBufSizeParam::PerMille(1000),
                ..Default::default()
            },
        )
        .unwrap();
    _print_check_db_map(
        &db_map,
        CheckC {
            check: true,
            f_mst: true,
            f_graph: false,
            /*
            check: false,
            f_mst: false,
            f_graph: true,
            */
        },
    );
    //
    Ok(())
}

fn check_dbint(db_name: &str) -> std::io::Result<()> {
    let db = siamesedb::open_file(db_name).unwrap();
    let db_map = db
        .db_map_int_with_params(
            "some_map1",
            FileDbParams {
                key_buf_size: FileBufSizeParam::PerMille(1000),
                idx_buf_size: FileBufSizeParam::PerMille(1000),
                ..Default::default()
            },
        )
        .unwrap();
    _print_check_db_map(
        &db_map,
        CheckC {
            check: true,
            f_mst: true,
            f_graph: false,
            /*
            check: false,
            f_mst: false,
            f_graph: true,
            */
        },
    );
    //
    Ok(())
}

fn _print_check_db_map(db_map: &dyn CheckFileDbMap, check_cnf: CheckC) {
    if check_cnf.f_graph {
        println!("{}", db_map.graph_string_with_key_string().unwrap());
    }
    if check_cnf.check {
        #[cfg(feature = "htx")]
        {
            let (ht_size, count) = db_map.ht_size_and_count().unwrap();
            println!("count / ht: {}/{}", count, ht_size);
        }
        //
        println!(
            "key piece free: {:?}",
            db_map.count_of_free_key_piece().unwrap()
        );
        let (key_rec_v, val_rec_v, node_v) = db_map.count_of_used_node().unwrap();
        println!("key piece used: {:?}", key_rec_v);
        println!(
            "value piece free: {:?}",
            db_map.count_of_free_value_piece().unwrap()
        );
        println!("value piece used: {:?}", val_rec_v);
        println!("node free: {:?}", db_map.count_of_free_node().unwrap());
        println!("node used: {:?}", node_v);
        //
        println!(
            "db_map.depth_of_node_tree(): {}",
            db_map.depth_of_node_tree().unwrap()
        );
        println!("db_map.is_balanced(): {}", db_map.is_balanced().unwrap());
        println!("db_map.is_dense(): {}", db_map.is_dense().unwrap());
        #[cfg(feature = "buf_stats")]
        println!("db_map.buf_stats(): {:?}", db_map.buf_stats());
        //
        println!(
            "key_piece_size_stats(): {}",
            db_map.key_piece_size_stats().unwrap()
        );
        println!(
            "value_piece_size_stats(): {}",
            db_map.value_piece_size_stats().unwrap()
        );
        println!("keys_count_stats(): {}", db_map.keys_count_stats().unwrap());
        println!("key_length_stats(): {}", db_map.key_length_stats().unwrap());
        println!(
            "value_length_stats(): {}",
            db_map.value_length_stats().unwrap()
        );
        #[cfg(feature = "htx")]
        {
            let (count, per_mill) = db_map.htx_filling_rate_per_mill().unwrap();
            println!(
                "htx_filling_rate(): {:.2}%, count: {}",
                per_mill as f64 / 10.0,
                count
            );
        }
    }
    if check_cnf.f_mst {
        println!("db_map.is_mst_valid(): {}", db_map.is_mst_valid().unwrap());
    }
}