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
mod reader;
mod wal;
mod writer;
#[cfg(all(
test,
any(
all_orderwal_tests,
test_swmr_constructor,
test_swmr_insert,
test_swmr_get,
test_swmr_iters,
)
))]
mod tests;
/// The ordered write-ahead log without multiple version support.
pub mod base {
use dbutils::checksum::Crc32;
use super::{reader, writer};
#[cfg(feature = "std")]
use crate::memtable::linked::Table as BaseLinkedTable;
use crate::memtable::{
alternative::Table as BaseAlternativeTable, arena::Table as BaseArenaTable,
};
pub use crate::{
memtable::arena::TableOptions as ArenaTableOptions,
types::base::{Entry, Key, Value},
wal::base::{Iter, Keys, RangeKeys, RangeValues, Reader, Writer},
};
/// An memory table for [`OrderWal`] or [`OrderWalReader`] based on [`linked::Table`](BaseLinkedTable).
#[cfg(feature = "std")]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
pub type LinkedTable<K, V> = BaseLinkedTable<K, V>;
/// An memory table for [`OrderWal`] or [`OrderWalReader`] based on [`arena::Table`](BaseArenaTable).
pub type ArenaTable<K, V> = BaseArenaTable<K, V>;
/// An memory table for [`OrderWal`] or [`OrderWalReader`] based on [`alternative::Table`](BaseAlternativeTable).
pub type AlternativeTable<K, V> = BaseAlternativeTable<K, V>;
/// The default memory table used by [`OrderWal`] or [`OrderWalReader`].
#[cfg(feature = "std")]
pub type DefaultTable<K, V> = LinkedTable<K, V>;
/// The default memory table used by [`OrderWal`] or [`OrderWalReader`].
#[cfg(not(feature = "std"))]
pub type DefaultTable<K, V> = ArenaTable<K, V>;
/// A generic ordered write-ahead log implementation for multiple threads environments.
///
/// ```text
/// +----------------------+-------------------------+--------------------+
/// | magic text (6 bytes) | magic version (2 bytes) | header (8 bytes) |
/// +----------------------+-------------------------+--------------------+---------------------+-----------------+--------------------+
/// | flag (1 byte) | key len (4 bytes) | key (n bytes) | value len (4 bytes) | value (n bytes) | checksum (8 bytes) |
/// +----------------------+-------------------------+--------------------+---------------------+-----------------|--------------------+
/// | flag (1 byte) | key len (4 bytes) | key (n bytes) | value len (4 bytes) | value (n bytes) | checksum (8 bytes) |
/// +----------------------+-------------------------+--------------------+---------------------+-----------------+--------------------+
/// | flag (1 byte) | key len (4 bytes) | key (n bytes) | value len (4 bytes) | value (n bytes) | checksum (8 bytes) |
/// +----------------------+-------------------------+--------------------+---------------------+-----------------+--------------------+
/// | ... | ... | ... | ... | ... | ... |
/// +----------------------+-------------------------+--------------------+---------------------+-----------------+--------------------+
/// | ... | ... | ... | ... | ... | ... |
/// +----------------------+-------------------------+--------------------+---------------------+-----------------+--------------------+
/// ```
pub type OrderWal<K, V, M = DefaultTable<K, V>, S = Crc32> = writer::OrderWal<K, V, M, S>;
/// Immutable reader for the generic ordered write-ahead log [`OrderWal`].
pub type OrderWalReader<K, V, M = DefaultTable<K, V>, S = Crc32> =
reader::OrderWalReader<K, V, M, S>;
}
/// A multiple version ordered write-ahead log implementation for multiple threads environments.
pub mod multiple_version {
use dbutils::checksum::Crc32;
use super::{reader, writer};
#[cfg(feature = "std")]
use crate::memtable::linked::MultipleVersionTable as BaseLinkedTable;
use crate::memtable::{
alternative::MultipleVersionTable as BaseAlternativeTable,
arena::MultipleVersionTable as BaseArenaTable,
};
pub use crate::{
memtable::arena::TableOptions as ArenaTableOptions,
types::multiple_version::{Entry, Key, Value, VersionedEntry},
wal::multiple_version::{
Iter, IterAll, Keys, RangeAll, RangeKeys, RangeValues, Reader, Writer,
},
};
/// An memory table for multiple version [`OrderWal`] or [`OrderWalReader`] based on [`linked::MultipleVersionTable`](BaseLinkedTable).
#[cfg(feature = "std")]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
pub type LinkedTable<K, V> = BaseLinkedTable<K, V>;
/// An memory table for multiple version [`OrderWal`] or [`OrderWalReader`] based on [`arena::MultipleVersionTable`](BaseArenaTable).
pub type ArenaTable<K, V> = BaseArenaTable<K, V>;
/// An memory table for multiple version [`OrderWal`] or [`OrderWalReader`] based on [`alternative::MultipleVersionTable`](BaseAlternativeTable).
pub type AlternativeTable<K, V> = BaseAlternativeTable<K, V>;
/// The default memory table used by [`OrderWal`] or [`OrderWalReader`].
#[cfg(feature = "std")]
pub type DefaultTable<K, V> = LinkedTable<K, V>;
/// The default memory table used by [`OrderWal`] or [`OrderWalReader`].
#[cfg(not(feature = "std"))]
pub type DefaultTable<K, V> = ArenaTable<K, V>;
/// A multiple versioned generic ordered write-ahead log implementation for multiple threads environments.
///
/// ```text
/// +----------------------+-------------------------+--------------------+
/// | magic text (6 bytes) | magic version (2 bytes) | header (8 bytes) |
/// +----------------------+-------------------------+--------------------+---------------------+---------------------+-----------------+--------------------+
/// | flag (1 byte) | version (8 bytes) | key len (4 bytes) | key (n bytes) | value len (4 bytes) | value (n bytes) | checksum (8 bytes) |
/// +----------------------+-------------------------+--------------------+---------------------+---------------------+-----------------+--------------------+
/// | flag (1 byte) | version (8 bytes) | key len (4 bytes) | key (n bytes) | value len (4 bytes) | value (n bytes) | checksum (8 bytes) |
/// +----------------------+-------------------------+--------------------+---------------------+---------------------+-----------------+--------------------+
/// | flag (1 byte) | version (8 bytes) | key len (4 bytes) | key (n bytes) | value len (4 bytes) | value (n bytes) | checksum (8 bytes) |
/// +----------------------+-------------------------+--------------------+---------------------+---------------------+-----------------+--------------------+
/// | ... | ... | ... | ... | ... | ... | ,,, |
/// +----------------------+-------------------------+--------------------+---------------------+---------------------+-----------------+--------------------+
/// ```
pub type OrderWal<K, V, M = DefaultTable<K, V>, S = Crc32> = writer::OrderWal<K, V, M, S>;
/// Immutable reader for the multiple versioned generic ordered write-ahead log [`OrderWal`].
pub type OrderWalReader<K, V, M = DefaultTable<K, V>, S = Crc32> =
reader::OrderWalReader<K, V, M, S>;
}