feat(code): add sst iterator / day 2

Signed-off-by: Alex Chi <iskyzh@gmail.com>

mini-lsm/src/block/builder.rs

@@ -6,16 +6,16 @@ use super::{Block, SIZEOF_U16};
 pub struct BlockBuilder {
     offsets: Vec<u16>,
     data: Vec<u8>,
-    target_size: usize,
+    block_size: usize,
 }
 
 impl BlockBuilder {
     /// Creates a new block builder
-    pub fn new(target_size: usize) -> Self {
+    pub fn new(block_size: usize) -> Self {
         Self {
             offsets: Vec::new(),
             data: Vec::new(),
-            target_size,
+            block_size,
         }
     }
 
@@ -27,7 +27,8 @@ impl BlockBuilder {
     #[must_use]
     pub fn add(&mut self, key: &[u8], value: &[u8]) -> bool {
         assert!(!key.is_empty(), "key must not be empty");
-        if self.estimated_size() + key.len() + value.len() + SIZEOF_U16 * 3 > self.target_size
+        assert!(!value.is_empty(), "value must not be empty");
+        if self.estimated_size() + key.len() + value.len() + SIZEOF_U16 * 3 > self.block_size
             && !self.is_empty()
         {
             return false;

mini-lsm/src/block/iterator.rs

@@ -51,10 +51,6 @@ impl BlockIterator {
         self.seek_to(0);
     }
 
-    pub fn seek_to_last(&mut self) {
-        self.seek_to(self.block.offsets.len() - 1);
-    }
-
     pub fn len(&self) -> usize {
         self.block.offsets.len()
     }
@@ -106,5 +102,6 @@ impl BlockIterator {
                 std::cmp::Ordering::Equal => return,
             }
         }
+        self.seek_to(low);
     }
 }

mini-lsm/src/block/tests.rs

@@ -18,7 +18,7 @@ fn test_block_build_full() {
 }
 
 fn key_of(idx: usize) -> Vec<u8> {
-    format!("key_{:03}", idx).into_bytes()
+    format!("key_{:03}", idx * 5).into_bytes()
 }
 
 fn value_of(idx: usize) -> Vec<u8> {
@@ -67,23 +67,54 @@ fn as_bytes(x: &[u8]) -> Bytes {
 fn test_block_iterator() {
     let block = Arc::new(generate_block());
     let mut iter = BlockIterator::create_and_seek_to_first(block);
-    for i in 0..num_of_keys() {
-        let key = iter.key();
-        let value = iter.value();
-        assert_eq!(
-            key,
-            key_of(i),
-            "expected key: {:?}, actual key: {:?}",
-            as_bytes(&key_of(i)),
-            as_bytes(key)
-        );
-        assert_eq!(
-            value,
-            value_of(i),
-            "expected value: {:?}, actual value: {:?}",
-            as_bytes(&value_of(i)),
-            as_bytes(value)
-        );
-        iter.next();
+    for _ in 0..5 {
+        for i in 0..num_of_keys() {
+            let key = iter.key();
+            let value = iter.value();
+            assert_eq!(
+                key,
+                key_of(i),
+                "expected key: {:?}, actual key: {:?}",
+                as_bytes(&key_of(i)),
+                as_bytes(key)
+            );
+            assert_eq!(
+                value,
+                value_of(i),
+                "expected value: {:?}, actual value: {:?}",
+                as_bytes(&value_of(i)),
+                as_bytes(value)
+            );
+            iter.next();
+        }
+        iter.seek_to_first();
+    }
+}
+
+#[test]
+fn test_block_seek_key() {
+    let block = Arc::new(generate_block());
+    let mut iter = BlockIterator::create_and_seek_to_key(block, &key_of(0));
+    for offset in 1..=5 {
+        for i in 0..num_of_keys() {
+            let key = iter.key();
+            let value = iter.value();
+            assert_eq!(
+                key,
+                key_of(i),
+                "expected key: {:?}, actual key: {:?}",
+                as_bytes(&key_of(i)),
+                as_bytes(key)
+            );
+            assert_eq!(
+                value,
+                value_of(i),
+                "expected value: {:?}, actual value: {:?}",
+                as_bytes(&value_of(i)),
+                as_bytes(value)
+            );
+            iter.seek_to_key(&format!("key_{:03}", i * 5 + offset).into_bytes());
+        }
+        iter.seek_to_key(b"k");
     }
 }