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
|
use super::*;
use std::collections::BTreeMap;
use std::collections::HashSet;
use std::fmt::Debug;
pub struct SecondaryMemtable<Field: Eq + Clone + Debug> {
pub field: Field,
field_index: usize,
primary_key_index: usize,
/// Map of records indexed by key. The value is the set of primary key values of records
/// that have the secondary key value. The actual `Record` objects are stored in the
/// primary memtable, which acts as the shared heap.
pub records: BTreeMap<IndexableValue, HashSet<IndexableValue>>,
}
impl<Field: Eq + Clone + Debug> SecondaryMemtable<Field> {
pub fn new(
field_schema: &Vec<(Field, RecordField)>,
field: &Field,
primary_key_index: usize,
) -> SecondaryMemtable<Field> {
let field_index = field_schema
.iter()
.position(|(f, _)| f == field)
.expect("Field not found in schema");
SecondaryMemtable {
field: field.clone(),
field_index,
primary_key_index,
records: BTreeMap::new(),
}
}
pub fn set(&mut self, key: &IndexableValue, value: &IndexableValue) {
debug!(
"Inserting/updating record in secondary memtable with key {:?} = {:?}",
&key, &value,
);
match self.records.get_mut(key) {
Some(existing) => {
debug!(
"Existing entry found with {} records in the set",
&existing.len()
);
existing.insert(value.clone());
}
None => {
debug!("No existing entry found, creating one.");
let mut set = HashSet::with_capacity(1);
set.insert(value.clone());
self.records.insert(key.clone(), set);
}
}
}
pub fn set_all(&mut self, key: &IndexableValue, values: &[IndexableValue]) {
debug!(
"Replacing set of records in secondary memtable with key {:?} ({} values)",
&key,
&values.len(),
);
let mut set = HashSet::with_capacity(values.len());
values.iter().for_each(|value| {
set.insert(value.clone());
});
self.records.insert(key.clone(), set);
}
pub fn find_all(
&mut self,
primary_memtable: &PrimaryMemtable,
key: &IndexableValue,
) -> Vec<Record> {
match self.records.get(key) {
None => vec![],
Some(set) => set
.iter()
.map(|key| {
primary_memtable
.get_without_update(key)
.expect("Record not found")
.clone()
})
.collect(),
}
}
pub fn remove(&mut self, record: &Record) {
let key = record.values[self.field_index]
.as_indexable()
.expect("Field is not indexable");
let primary_key = record.values[self.primary_key_index]
.as_indexable()
.expect("Primary key is not indexable");
match self.records.get_mut(&key) {
Some(set) => {
set.remove(&primary_key);
}
None => {
panic!("Record not found in secondary memtable");
}
}
}
}
|
