upgrade value-log

to use Slice::from_reader

Cargo.toml

@@ -2,7 +2,7 @@
 name = "lsm-tree"
 description = "A K.I.S.S. implementation of log-structured merge trees (LSM-trees/LSMTs)"
 license = "MIT OR Apache-2.0"
-version = "2.3.2"
+version = "2.3.3"
 edition = "2021"
 rust-version = "1.74.0"
 readme = "README.md"
@@ -37,7 +37,7 @@ quick_cache = { version = "0.6.5", default-features = false, features = [] }
 rustc-hash = "2.0.0"
 self_cell = "1.0.4"
 tempfile = "3.12.0"
-value-log = "1.1.1"
+value-log = "1.2.0"
 varint-rs = "2.2.0"
 xxhash-rust = { version = "0.8.12", features = ["xxh3"] }
 

src/blob_tree/mod.rs

@@ -326,6 +326,8 @@ impl AbstractTree for BlobTree {
             if item.is_tombstone() {
                 // NOTE: Still need to add tombstone to index tree
                 // But no blob to blob writer
+
+                // TODO: Slice::empty
                 segment_writer.write(InternalValue::new(item.key, vec![]))?;
                 continue;
             }

src/blob_tree/value.rs

@@ -70,9 +70,8 @@ impl Decode for MaybeInlineValue {
         match tag {
             TAG_INLINE => {
                 let len = reader.read_u32_varint()? as usize;
-                let mut bytes = vec![0; len];
-                reader.read_exact(&mut bytes)?;
-                Ok(Self::Inline(Slice::from(bytes)))
+                let slice = Slice::from_reader(reader, len)?;
+                Ok(Self::Inline(slice))
             }
             TAG_INDIRECT => {
                 let vhandle = ValueHandle::decode_from(reader)?;

src/key.rs

@@ -11,6 +11,7 @@ use std::{
     cmp::Reverse,
     io::{Read, Write},
 };
+use value_log::Slice;
 use varint_rs::{VarintReader, VarintWriter};
 
 #[derive(Clone, PartialEq, Eq)]
@@ -43,7 +44,7 @@ impl InternalKey {
 
         assert!(
             user_key.len() <= u16::MAX.into(),
-            "keys can be 65535 bytes in length"
+            "keys can be 65535 bytes in length",
         );
 
         Self {
@@ -83,8 +84,7 @@ impl Decode for InternalKey {
             .map_err(|()| DecodeError::InvalidTag(("ValueType", value_type)))?;
 
         let key_len = reader.read_u16_varint()?;
-        let mut key = vec![0; key_len.into()];
-        reader.read_exact(&mut key)?;
+        let key = Slice::from_reader(reader, key_len.into())?;
 
         Ok(Self::new(key, seqno, value_type))
     }

src/key_range.rs

@@ -160,14 +160,10 @@ impl Encode for KeyRange {
 impl Decode for KeyRange {
     fn decode_from<R: Read>(reader: &mut R) -> Result<Self, DecodeError> {
         let key_min_len = reader.read_u16::<BigEndian>()?;
-        let mut key_min = vec![0; key_min_len.into()];
-        reader.read_exact(&mut key_min)?;
-        let key_min: UserKey = Slice::from(key_min);
+        let key_min: UserKey = Slice::from_reader(reader, key_min_len.into())?;
 
         let key_max_len = reader.read_u16::<BigEndian>()?;
-        let mut key_max = vec![0; key_max_len.into()];
-        reader.read_exact(&mut key_max)?;
-        let key_max: UserKey = Slice::from(key_max);
+        let key_max: UserKey = Slice::from_reader(reader, key_max_len.into())?;
 
         Ok(Self::new((key_min, key_max)))
     }

src/value.rs

@@ -117,7 +117,6 @@ impl InternalValue {
     ///
     /// Panics if the key length is empty or greater than 2^16.
     pub fn new_tombstone<K: Into<UserKey>>(key: K, seqno: u64) -> Self {
-        let key = key.into();
         let key = InternalKey::new(key, seqno, ValueType::Tombstone);
         Self::new(key, vec![])
     }
@@ -128,7 +127,6 @@ impl InternalValue {
     ///
     /// Panics if the key length is empty or greater than 2^16.
     pub fn new_weak_tombstone<K: Into<UserKey>>(key: K, seqno: u64) -> Self {
-        let key = key.into();
         let key = InternalKey::new(key, seqno, ValueType::WeakTombstone);
         Self::new(key, vec![])
     }
@@ -187,19 +185,16 @@ impl Decode for InternalValue {
         if key.is_tombstone() {
             Ok(Self {
                 key,
+                // TODO: Slice::empty()
                 value: vec![].into(),
             })
         } else {
             // NOTE: Only read value if we are actually a value
 
             let value_len = reader.read_u32_varint()?;
-            let mut value = vec![0; value_len as usize];
-            reader.read_exact(&mut value)?;
+            let value = Slice::from_reader(reader, value_len as usize)?;
 
-            Ok(Self {
-                key,
-                value: value.into(),
-            })
+            Ok(Self { key, value })
         }
     }
 }