mace-kv 0.2.0

A pure-Rust lightweight alternative to RocksDB (in most cases)
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

pub(crate) mod builder;
mod entry;
pub(crate) mod guard;
mod manifest;
mod stat;
mod txn;

pub(crate) use guard::DeletionGuard;

use crate::map::buffer::BucketContext;
use crate::utils::interval::IntervalMap;
use crate::utils::options::ParsedOptions;
pub(crate) use entry::IMetaCodec;
pub use entry::{
    BucketDurableFrontier, BucketMeta, DelInterval, Delete, FileKind, IntervalPair, MemStat,
    MetaKind, MetaOp, PageTable, PersistStat, Sequences, StatInner, WalRecycleState,
};
pub(crate) use manifest::Manifest;
use parking_lot::RwLock;
pub(crate) use stat::{FileReader, JunkPermit, new_reader, try_new_reader};
use std::path::PathBuf;
pub(crate) use txn::Txn;

pub(crate) const BUCKET_MISC: &str = "misc";
pub(crate) const SEQUENCES_KEY: &str = "sequences";
pub(crate) const BUCKET_DATA_STAT: &str = "data_stat";
pub(crate) const BUCKET_BLOB_STAT: &str = "blob_stat";
pub(crate) const BUCKET_OBSOLETE_DATA: &str = "obsolete_data";
pub(crate) const BUCKET_OBSOLETE_BLOB: &str = "obsolete_blob";
pub(crate) const BUCKET_METAS: &str = "bucket_metas";
pub(crate) const BUCKET_PENDING_DEL: &str = "pending_del";
pub(crate) const BUCKET_FRONTIER: &str = "bucket_frontier";
pub(crate) const BUCKET_VERSION: &str = "version";
pub(crate) const MAX_BUCKETS: u64 = 1024;
pub(crate) const VERSION_KEY: &str = "current_version";
pub(crate) const OPTIONS_KEY: &str = "options";
pub(crate) const ORPHAN_DATA_MARKER_PREFIX: &str = "odf_";
pub(crate) const ORPHAN_BLOB_MARKER_PREFIX: &str = "obf_";
pub(crate) const WAL_RECYCLE_PREFIX: &str = "wrc_";
/// storage format version
pub(crate) const CURRENT_VERSION: u64 = 1;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct WalRecycleIntent {
    /// physical WAL stream id
    pub(crate) group_id: u8,
    pub(crate) from_file_id: u64,
    pub(crate) to_file_id: u64,
}

pub(crate) fn page_table_name(bucket_id: u64) -> String {
    format!("page_table_{}", bucket_id)
}

pub(crate) fn data_interval_name(bucket_id: u64) -> String {
    format!("data_interval_{}", bucket_id)
}

pub(crate) fn blob_interval_name(bucket_id: u64) -> String {
    format!("blob_interval_{}", bucket_id)
}

pub(crate) fn orphan_data_marker_key(file_id: u64) -> Vec<u8> {
    format!("{}{}", ORPHAN_DATA_MARKER_PREFIX, file_id).into_bytes()
}

pub(crate) fn orphan_blob_marker_key(file_id: u64) -> Vec<u8> {
    format!("{}{}", ORPHAN_BLOB_MARKER_PREFIX, file_id).into_bytes()
}

pub(crate) fn wal_recycle_key(group_id: u8) -> Vec<u8> {
    format!("{}{}", WAL_RECYCLE_PREFIX, group_id).into_bytes()
}

pub(crate) fn stat_bucket(kind: FileKind) -> &'static str {
    match kind {
        FileKind::Data => BUCKET_DATA_STAT,
        FileKind::Blob => BUCKET_BLOB_STAT,
    }
}

pub(crate) fn delete_meta_kind(kind: FileKind) -> MetaKind {
    match kind {
        FileKind::Data => MetaKind::DataDelete,
        FileKind::Blob => MetaKind::BlobDelete,
    }
}

pub(crate) fn delete_done_meta_kind(kind: FileKind) -> MetaKind {
    match kind {
        FileKind::Data => MetaKind::DataDeleteDone,
        FileKind::Blob => MetaKind::BlobDeleteDone,
    }
}

pub(crate) fn stat_file_path(opt: &ParsedOptions, kind: FileKind, file_id: u64) -> PathBuf {
    match kind {
        FileKind::Data => opt.data_file(file_id),
        FileKind::Blob => opt.blob_file(file_id),
    }
}

pub(crate) fn interval_bucket_name(kind: FileKind, bucket_id: u64) -> String {
    match kind {
        FileKind::Data => data_interval_name(bucket_id),
        FileKind::Blob => blob_interval_name(bucket_id),
    }
}

pub(crate) fn stat_intervals(kind: FileKind, ctx: &BucketContext) -> &RwLock<IntervalMap> {
    match kind {
        FileKind::Data => &ctx.data_intervals,
        FileKind::Blob => &ctx.blob_intervals,
    }
}

pub(crate) fn stat_handle_cache_capacity(opt: &ParsedOptions, kind: FileKind) -> usize {
    match kind {
        FileKind::Data => opt.data_handle_cache_capacity,
        FileKind::Blob => opt.blob_handle_cache_capacity,
    }
}