block-db 0.2.0

Local, multi-threaded, durable byte DB.
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

// Authors: Robert Lopez

use crate::tests::{
    test_db::TestDB,
    util::{random_bytes, random_max_file_size},
};

#[tokio::test]
async fn horizontal_stress() {
    let chunk_size = 100;
    let max_file_size = 1_000;

    let mut test_db = TestDB::open("horizontal_stress", Some(chunk_size), Some(max_file_size))
        .await
        .unwrap();

    let mut block_keys = vec![];

    for _ in 0..1_000 {
        let bytes = random_bytes(random_max_file_size(max_file_size));
        let block_key = test_db.write(&bytes, true).await.unwrap();

        block_keys.push((block_key, bytes));
    }

    let (block_keys_split_one, block_keys_split_two) = block_keys.split_at(block_keys.len() / 2);

    for (block_key, bytes) in block_keys_split_one.iter() {
        test_db.free(block_key, bytes).await.unwrap();
    }

    test_db
        .compact(
            None,
            block_keys_split_one
                .iter()
                .map(|(_, b)| b)
                .collect::<Vec<&Vec<u8>>>(),
        )
        .await
        .unwrap();

    for (block_key, _) in block_keys_split_one {
        test_db.read(block_key, None).await.unwrap();
    }

    let block_keys_split_two = block_keys_split_two.to_vec();
    let mut block_keys_split_two_free_batch = vec![];
    for (block_key, bytes) in block_keys_split_two.iter() {
        block_keys_split_two_free_batch.push((block_key, bytes));
    }

    test_db
        .batch(vec![], block_keys_split_two_free_batch, 0)
        .await
        .unwrap();

    test_db
        .compact(
            None,
            block_keys_split_two
                .iter()
                .map(|(_, b)| b)
                .collect::<Vec<&Vec<u8>>>(),
        )
        .await
        .unwrap();

    for (block_key, _) in block_keys {
        test_db.read(&block_key, None).await.unwrap();
    }

    test_db.cleanup().await.unwrap();
}