change logic of create_seek_to_key() of SsTableIterator

Author: Zhou-jw

mini-lsm-starter/src/compact.rs

@@ -136,25 +136,25 @@ impl LsmStorageInner {
             let builder_inner = sst_builder.as_mut().unwrap();
 
             if is_same_as_prevkey && iter.key().ts() < min_ts {
-                println!(
-                    "prev_key: {:?}, iter.key(): {:?}, ts: {:?}, min_ts: {:?}",
-                    prev_key,
-                    iter.key(),
-                    iter.key().ts(),
-                    min_ts
-                );
+                // println!(
+                //     "prev_key: {:?}, iter.key(): {:?}, ts: {:?}, min_ts: {:?}",
+                //     prev_key,
+                //     iter.key(),
+                //     iter.key().ts(),
+                //     min_ts
+                // );
                 iter.next()?;
                 continue;
             }
 
             if !is_same_as_prevkey && iter.key().ts() <= min_ts && iter.value().is_empty() {
-                println!(
-                    "delete key: {:?}, value: {:?}, ts: {:?}, min_ts: {:?}",
-                    iter.key(),
-                    iter.value(),
-                    iter.key().ts(),
-                    min_ts
-                );
+                // println!(
+                //     "delete key: {:?}, value: {:?}, ts: {:?}, min_ts: {:?}",
+                //     iter.key(),
+                //     iter.value(),
+                //     iter.key().ts(),
+                //     min_ts
+                // );
                 prev_key.clear();
                 prev_key.extend(iter.key().key_ref());
                 iter.next()?;

mini-lsm-starter/src/mvcc/watermark.rs

@@ -34,3 +34,9 @@ impl Watermark {
         self.readers.len()
     }
 }
+
+impl Default for Watermark {
+    fn default() -> Self {
+        Self::new()
+    }
+}

mini-lsm-starter/src/table.rs

@@ -257,26 +257,22 @@ impl SsTable {
     /// Note: You may want to make use of the `first_key` stored in `BlockMeta`.
     /// You may also assume the key-value pairs stored in each consecutive block are sorted.
     pub fn find_block_idx(&self, key: KeySlice) -> usize {
-        // self.block_meta
-        //     .partition_point(|meta| meta.first_key.as_key_slice() <= key)
-        //     .saturating_sub(1)
-        let mut final_idx: usize = 0;
-        let mut prevmeta_lastkey = KeySlice::from(key);
-        for meta in self.block_meta.iter() {
-            if meta.first_key.as_key_slice() <= key {
-                final_idx += 1;
-            } else if meta.first_key.key_ref() <= key.key_ref() && prevmeta_lastkey < key {
-                final_idx += 1;
-            } else {
-                // println!("key is {:?} ts={:?}, meta.first_key is {:?} ts={:?}, meta.last_key is {:?} ts={:?}", key.to_key_vec().into_key_bytes(), key.ts(), meta.first_key, meta.first_key.ts(), meta.last_key, meta.last_key.ts());
-                break;
-            }
-            prevmeta_lastkey = meta.last_key.as_key_slice();
-        }
-        match final_idx {
-            0 => 0,
-            _ => final_idx - 1,
-        }
+        self.block_meta
+            .partition_point(|meta| meta.first_key.as_key_slice() <= key)
+            .saturating_sub(1)
+        // let mut final_idx: usize = 0;
+        // for meta in self.block_meta.iter() {
+        //     if meta.first_key.as_key_slice() <= key {
+        //         final_idx += 1;
+        //     } else {
+        //         println!("key is {:?} ts={:?}, meta.first_key is {:?} ts={:?}, meta.last_key is {:?} ts={:?}", key.to_key_vec().into_key_bytes(), key.ts(), meta.first_key, meta.first_key.ts(), meta.last_key, meta.last_key.ts());
+        //         break;
+        //     }
+        // }
+        // match final_idx {
+        //     0 => 0,
+        //     _ => final_idx - 1,
+        // }
     }
 
     /// Get number of data blocks.

mini-lsm-starter/src/table/iterator.rs

@@ -53,9 +53,16 @@ impl SsTableIterator {
 
     /// Create a new iterator and seek to the first key-value pair which >= `key`.
     pub fn create_and_seek_to_key(table: Arc<SsTable>, key: KeySlice) -> Result<Self> {
-        let blk_idx = table.find_block_idx(key);
+        let mut blk_idx = table.find_block_idx(key);
         let block = table.read_block_cached(blk_idx)?;
-        let block_iter = BlockIterator::create_and_seek_to_key(block, key);
+        let mut block_iter = BlockIterator::create_and_seek_to_key(block, key);
+        if !block_iter.is_valid() {
+            blk_idx += 1;
+            if blk_idx < table.num_of_blocks() {
+                block_iter =
+                    BlockIterator::create_and_seek_to_key(table.read_block_cached(blk_idx)?, key);
+            }
+        }
         Ok(Self {
             table,
             blk_iter: block_iter,