fix kv example for real

examples/kv/src/main.rs

@@ -1,6 +1,6 @@
 mod wal;
 
-use lsm_tree::{AbstractTree, Config, SequenceNumberCounter, Tree, Value};
+use lsm_tree::{AbstractTree, Config, InternalValue, SequenceNumberCounter, Tree};
 use nanoid::nanoid;
 use std::{
     path::Path,
@@ -30,7 +30,7 @@ impl KvStore {
             start.elapsed().as_secs_f32()
         );
 
-        let seqno = SequenceNumberCounter::new(memtable.get_lsn().unwrap_or_default());
+        let seqno = SequenceNumberCounter::new(memtable.get_highest_seqno().unwrap_or_default());
 
         tree.set_active_memtable(memtable);
 
@@ -47,7 +47,11 @@ impl KvStore {
                 loop {
                     eprintln!("Maybe compact");
                     let strategy = lsm_tree::compaction::Levelled::default();
-                    tree.compact(Arc::new(strategy))?;
+
+                    // NOTE: This is not tracking lowest safe seqno, so old versions will
+                    // not be GC'ed
+                    tree.compact(Arc::new(strategy), 0)?;
+
                     std::thread::sleep(Duration::from_secs(1));
                 }
                 Ok::<_, lsm_tree::Error>(())
@@ -81,12 +85,12 @@ impl KvStore {
         let value = value.as_ref().as_bytes();
         let seqno = self.seqno.next();
 
-        self.wal.write(Value {
-            key: key.into(),
-            value: value.into(),
+        self.wal.write(InternalValue::from_components(
+            key,
+            value,
             seqno,
-            value_type: lsm_tree::ValueType::Value,
-        })?;
+            lsm_tree::ValueType::Value,
+        ))?;
 
         let (_, memtable_size) = self.tree.insert(key, value, seqno);
         self.maintenance(memtable_size)?;
@@ -98,12 +102,7 @@ impl KvStore {
         let key = key.as_ref().as_bytes();
         let seqno = self.seqno.next();
 
-        self.wal.write(Value {
-            key: key.into(),
-            value: [].into(),
-            seqno,
-            value_type: lsm_tree::ValueType::Tombstone,
-        })?;
+        self.wal.write(InternalValue::new_tombstone(key, seqno))?;
 
         let (_, memtable_size) = self.tree.remove(key, seqno);
         self.maintenance(memtable_size)?;

examples/kv/src/wal.rs

@@ -1,4 +1,4 @@
-use lsm_tree::{MemTable, SeqNo, Value, ValueType};
+use lsm_tree::{InternalValue, MemTable, SeqNo, ValueType};
 use serde::{Deserialize, Serialize};
 use std::io::{Seek, Write};
 use std::sync::Mutex;
@@ -24,28 +24,28 @@ pub struct WalEntry {
     value_type: u8,
 }
 
-impl From<WalEntry> for Value {
+impl From<WalEntry> for InternalValue {
     fn from(entry: WalEntry) -> Self {
-        Self {
-            key: entry.key.into(),
-            value: entry.value.into(),
-            seqno: entry.seqno,
-            value_type: ValueType::from(entry.value_type),
-        }
+        Self::from_components(
+            entry.key,
+            entry.value,
+            entry.seqno,
+            ValueType::from(entry.value_type),
+        )
     }
 }
 
-impl From<Value> for WalEntry {
-    fn from(entry: Value) -> Self {
+impl From<InternalValue> for WalEntry {
+    fn from(entry: InternalValue) -> Self {
         Self {
-            key: std::str::from_utf8(&entry.key)
+            key: std::str::from_utf8(&entry.key.user_key)
                 .expect("should be valid utf-8")
                 .into(),
             value: std::str::from_utf8(&entry.value)
                 .expect("should be valid utf-8")
                 .into(),
-            seqno: entry.seqno,
-            value_type: entry.value_type.into(),
+            seqno: entry.key.seqno,
+            value_type: entry.key.value_type.into(),
         }
     }
 }
@@ -81,7 +81,7 @@ impl Wal {
         }
     }
 
-    pub fn write(&mut self, value: Value) -> lsm_tree::Result<()> {
+    pub fn write(&mut self, value: InternalValue) -> lsm_tree::Result<()> {
         let mut writer = self.writer.lock().expect("lock is poisoned");
 
         let wal_entry: WalEntry = value.into();