pageman 0.1.0

Disk-based page manager/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

use crate::{store::Store, Page};
use eyre::Result;
use generic_array::typenum::U64;
use std::{iter::repeat_with, num::NonZeroUsize, path::PathBuf};
use tinyvec::ArrayVec;

const SEED: u64 = 5;
const CC: usize = 5;
const LC: usize = 7;

type Pg = ArrayVec<[(u32, u32); LC]>;

impl Page for Pg {
    type Size = U64;
}

#[test]
fn basic() -> Result<()> {
    let mut rng = fastrand::Rng::with_seed(SEED);
    let mut in_kvs = Vec::from_iter(
        repeat_with(|| {
            let k = rng.u32(..);
            let v = rng.u32(..);
            (k, v)
        })
        .take(10000),
    );

    // Add all leaves to the store
    let mut store = Store::<Pg>::new(
        PathBuf::from("data/test/store_basic"),
        NonZeroUsize::new(CC).unwrap(),
    )?;
    let mut pids = Vec::with_capacity(in_kvs.len().div_ceil(LC));
    for chunk in in_kvs.chunks(LC) {
        let leaf = Pg::from_iter(chunk.iter().copied());
        pids.push(store.save(leaf)?)
    }
    store.flush_all()?;

    // Pop all leaves, and check if the key-values are intact
    let mut out_kvs = Vec::with_capacity(in_kvs.len());
    for pid in pids {
        let leaf = store.pop(pid)?;
        out_kvs.extend(leaf)
    }

    assert_eq!(
        in_kvs.len(),
        out_kvs.len(),
        "number of key-val pairs returned is not the same as original"
    );

    in_kvs.sort_unstable_by_key(|(k, _)| *k);
    out_kvs.sort_unstable_by_key(|(k, _)| *k);
    in_kvs
        .iter()
        .zip(out_kvs.iter())
        .for_each(|(input, output)| assert_eq!(input, output));

    store.flush_all()?;
    Ok(())
}