better tombstone value

README.md

@@ -41,3 +41,5 @@ I have known about Bitcask for a while, and I wanted to learn it by building a w
 - [ ] clean up merging code
 - [ ] clean up datamodel around records/entrypointers/mergepointers
 - [ ] more research into how async drop interacts with disk writes/buffer flushes
+- [x] investigate a better, less ambiguous tombstone value
+- [ ] move record write_insert and write_delete into Record

src/base.rs

@@ -1,7 +1,7 @@
 use crate::keydir::{EntryPointer, EntryWithLiveness, Keydir, Liveness};
 use crate::loadable::Loadable;
 use crate::merge_pointer::MergePointer;
-use crate::record::Tombstone;
+use crate::record::Record;
 use crate::Options;
 use crate::{error, FlushBehavior};
 use serde::de::DeserializeOwned;
@@ -395,10 +395,7 @@ where
             source: e,
         })?;
 
-        let encoded_value = bincode::serialize(&Tombstone).map_err(|e| error::SerializeError {
-            msg: "unable to serialize to bincode".to_string(),
-            source: e,
-        })?;
+        let encoded_value = Record::tombstone();
 
         let key_size = encoded_key.len();
 
@@ -412,7 +409,7 @@ where
         payload.extend_from_slice(&encoded_key_size);
         payload.extend_from_slice(&encoded_value_size);
         payload.extend_from_slice(&encoded_key);
-        payload.extend_from_slice(&encoded_value);
+        payload.extend_from_slice(encoded_value);
 
         let hash = blake3::hash(&payload);
         let hash = hash.as_bytes();

src/record.rs

@@ -1,15 +1,12 @@
 use std::sync::OnceLock;
 
 use crate::keydir::Liveness;
-use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use serde::de::DeserializeOwned;
 use tokio::io::{AsyncRead, AsyncReadExt};
 
-// TODO thse should probably something else.
-// I think they serialize to `[]`, which is probably not good
-#[derive(Serialize, Deserialize)]
-pub(crate) struct Tombstone;
+const TOMBSTONE_BYTES: &[u8] = b"bitcask_tombstone";
 
-pub(crate) static TOMBSTONE: OnceLock<Vec<u8>> = OnceLock::new();
+static TOMBSTONE: OnceLock<Vec<u8>> = OnceLock::new();
 
 /// A record is a "header" and a "body"
 /// The header is (in on-disk and in-memory order):
@@ -64,13 +61,19 @@ impl Record {
     }
 
     pub(crate) fn liveness(&self) -> Liveness {
-        if self.value_bytes() == TOMBSTONE.get_or_init(|| bincode::serialize(&Tombstone).unwrap()) {
+        if self.value_bytes()
+            == TOMBSTONE.get_or_init(|| bincode::serialize(&TOMBSTONE_BYTES).unwrap())
+        {
             Liveness::Deleted
         } else {
             Liveness::Live
         }
     }
 
+    pub(crate) fn tombstone() -> &'static [u8] {
+        TOMBSTONE.get_or_init(|| bincode::serialize(&TOMBSTONE_BYTES).unwrap())
+    }
+
     pub(crate) fn key_bytes(&self) -> &[u8] {
         let start = 0;
         let end = self.key_size() as usize;