1 files changed, 30 insertions, 16 deletions

diff --git a/log_db/src/memtable_secondary.rs b/log_db/src/memtable_secondary.rs
index 8300ada..3f9863b 100644
--- a/log_db/src/memtable_secondary.rs
+++ b/log_db/src/memtable_secondary.rs
@@ -1,15 +1,14 @@
 use super::*;
-use once_cell::sync::Lazy;
 use std::collections::BTreeMap;
 use std::collections::HashSet;
 
 pub struct SecondaryMemtable {
-    /// Map of records indexed by key. Values are non-empty sets of `LogKey` values.
-    records: BTreeMap<IndexableValue, LogKeySet>,
+    /// 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.
+    records: BTreeMap<IndexableValue, HashSet<IndexableValue>>,
 }
 
-static EMPTY_SET: Lazy<HashSet<LogKey>> = Lazy::new(|| HashSet::new());
-
 impl SecondaryMemtable {
     pub fn new() -> SecondaryMemtable {
         SecondaryMemtable {
@@ -17,12 +16,10 @@ impl SecondaryMemtable {
         }
     }
 
-    pub fn set(&mut self, key: &IndexableValue, value: &LogKey) {
+    pub fn set(&mut self, key: &IndexableValue, value: &IndexableValue) {
         debug!(
-            "Inserting/updating record in secondary memtable with key {:?} = segment {} index {}",
-            &key,
-            &value.segment_num(),
-            &value.index()
+            "Inserting/updating record in secondary memtable with key {:?} = {:?}",
+            &key, &value,
         );
 
         match self.records.get_mut(key) {
@@ -35,27 +32,44 @@ impl SecondaryMemtable {
             }
             None => {
                 debug!("No existing entry found, creating one.");
-                let set = LogKeySet::new_with_initial(&value);
+                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: &[LogKey]) {
+    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 set = LogKeySet::from_slice(values);
+        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, key: &IndexableValue) -> &HashSet<LogKey> {
+    pub fn find_all(
+        &mut self,
+        primary_memtable: &PrimaryMemtable,
+        key: &IndexableValue,
+    ) -> Vec<Record> {
         match self.records.get(key) {
-            Some(set) => set.log_keys(),
-            None => &EMPTY_SET,
+            None => vec![],
+            Some(set) => set
+                .iter()
+                .map(|key| {
+                    primary_memtable
+                        .get_without_update(key)
+                        .expect("Record not found")
+                        .clone()
+                })
+                .collect(),
         }
     }
 }