update week 2 starter code

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

mini-lsm-starter/src/compact.rs

@@ -23,13 +23,16 @@ pub enum CompactionTask {
     Leveled(LeveledCompactionTask),
     Tiered(TieredCompactionTask),
     Simple(SimpleLeveledCompactionTask),
-    ForceFullCompaction(Vec<usize>),
+    ForceFullCompaction {
+        l0_sstables: Vec<usize>,
+        l1_sstables: Vec<usize>,
+    },
 }
 
 impl CompactionTask {
     fn compact_to_bottom_level(&self) -> bool {
         match self {
-            CompactionTask::ForceFullCompaction(_) => true,
+            CompactionTask::ForceFullCompaction { .. } => true,
             CompactionTask::Leveled(task) => task.is_lower_level_bottom_level,
             CompactionTask::Simple(task) => task.is_lower_level_bottom_level,
             CompactionTask::Tiered(task) => task.bottom_tier_included,

mini-lsm-starter/src/iterators.rs

@@ -1,3 +1,4 @@
+pub mod concat_iterator;
 pub mod merge_iterator;
 pub mod two_merge_iterator;
 

mini-lsm-starter/src/iterators/concat_iterator.rs

@@ -0,0 +1,49 @@
+#![allow(unused_variables)] // TODO(you): remove this lint after implementing this mod
+#![allow(dead_code)] // TODO(you): remove this lint after implementing this mod
+
+use std::sync::Arc;
+
+use anyhow::Result;
+
+use super::StorageIterator;
+use crate::table::{SsTable, SsTableIterator};
+
+/// Concat multiple iterators ordered in key order and their key ranges do not overlap. We do not want to create the
+/// iterators when initializing this iterator to reduce the overhead of seeking.
+pub struct SstConcatIterator {
+    current: Option<SsTableIterator>,
+    next_sst_idx: usize,
+    sstables: Vec<Arc<SsTable>>,
+}
+
+impl SstConcatIterator {
+    pub fn create_and_seek_to_first(sstables: Vec<Arc<SsTable>>) -> Result<Self> {
+        unimplemented!()
+    }
+
+    pub fn create_and_seek_to_key(sstables: Vec<Arc<SsTable>>, key: &[u8]) -> Result<Self> {
+        unimplemented!()
+    }
+}
+
+impl StorageIterator for SstConcatIterator {
+    fn key(&self) -> &[u8] {
+        unimplemented!()
+    }
+
+    fn value(&self) -> &[u8] {
+        unimplemented!()
+    }
+
+    fn is_valid(&self) -> bool {
+        unimplemented!()
+    }
+
+    fn next(&mut self) -> Result<()> {
+        unimplemented!()
+    }
+
+    fn num_active_iterators(&self) -> usize {
+        1
+    }
+}

mini-lsm-starter/src/lsm_storage.rs

@@ -46,7 +46,8 @@ impl LsmStorageState {
                 ..=*max_levels)
                 .map(|level| (level, Vec::new()))
                 .collect::<Vec<_>>(),
-            CompactionOptions::Tiered(_) | CompactionOptions::NoCompaction => Vec::new(),
+            CompactionOptions::Tiered(_) => Vec::new(),
+            CompactionOptions::NoCompaction => vec![(0, Vec::new())],
         };
         Self {
             memtable: Arc::new(MemTable::create(0)),