fix read path after compaction

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

mini-lsm/src/bin/compaction_simulator.rs

@@ -30,7 +30,7 @@ enum Args {
         #[clap(long)]
         dump_real_id: bool,
         #[clap(long, default_value = "3")]
-        level0_file_num_compaction_trigger: usize,
+        num_tiers: usize,
         #[clap(long, default_value = "200")]
         max_size_amplification_percent: usize,
         #[clap(long, default_value = "1")]
@@ -316,7 +316,7 @@ fn main() {
         }
         Args::Tiered {
             dump_real_id,
-            level0_file_num_compaction_trigger,
+            num_tiers: level0_file_num_compaction_trigger,
             max_size_amplification_percent,
             size_ratio,
             min_merge_width,

mini-lsm/src/bin/mini_lsm_cli.rs

@@ -1,19 +1,65 @@
+use std::path::PathBuf;
+
 use anyhow::Result;
-use mini_lsm::compact::{CompactionOptions, SimpleLeveledCompactionOptions};
+use bytes::Bytes;
+use clap::{Parser, ValueEnum};
+
+use mini_lsm::compact::{
+    CompactionOptions, LeveledCompactionOptions, SimpleLeveledCompactionOptions,
+    TieredCompactionOptions,
+};
+use mini_lsm::iterators::StorageIterator;
 use mini_lsm::lsm_storage::{LsmStorageOptions, MiniLsm};
 
+#[derive(Debug, Clone, ValueEnum)]
+enum CompactionStrategy {
+    Simple,
+    Leveled,
+    Tiered,
+}
+
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    #[arg(long, default_value = "mini-lsm.db")]
+    path: PathBuf,
+    #[arg(long, default_value = "leveled")]
+    compaction: CompactionStrategy,
+    #[arg(long)]
+    enable_wal: bool,
+}
+
 fn main() -> Result<()> {
+    let args = Args::parse();
     let lsm = MiniLsm::open(
-        "mini-lsm.db",
+        args.path,
         LsmStorageOptions {
             block_size: 4096,
-            target_sst_size: 2 << 20,
-            compaction_options: CompactionOptions::Simple(SimpleLeveledCompactionOptions {
-                size_ratio_percent: 200,
-                level0_file_num_compaction_trigger: 2,
-                max_levels: 4,
-            }),
-            enable_wal: false,
+            target_sst_size: 2 << 20, // 2MB
+            compaction_options: match args.compaction {
+                CompactionStrategy::Simple => {
+                    CompactionOptions::Simple(SimpleLeveledCompactionOptions {
+                        size_ratio_percent: 200,
+                        level0_file_num_compaction_trigger: 2,
+                        max_levels: 4,
+                    })
+                }
+                CompactionStrategy::Tiered => CompactionOptions::Tiered(TieredCompactionOptions {
+                    num_tiers: 3,
+                    max_size_amplification_percent: 200,
+                    size_ratio: 1,
+                    min_merge_width: 2,
+                }),
+                CompactionStrategy::Leveled => {
+                    CompactionOptions::Leveled(LeveledCompactionOptions {
+                        level0_file_num_compaction_trigger: 2,
+                        max_levels: 4,
+                        base_level_size_mb: 128,
+                        level_size_multiplier: 2,
+                    })
+                }
+            },
+            enable_wal: args.enable_wal,
         },
     )?;
     let mut epoch = 0;
@@ -51,6 +97,29 @@ fn main() -> Result<()> {
             } else {
                 println!("{} not exist", key);
             }
+        } else if line.starts_with("scan ") {
+            let Some((_, rest)) = line.split_once(' ') else {
+                println!("invalid command");
+                continue;
+            };
+            let Some((begin_key, end_key)) = rest.split_once(' ') else {
+                println!("invalid command");
+                continue;
+            };
+            let mut iter = lsm.scan(
+                std::ops::Bound::Included(begin_key.as_bytes()),
+                std::ops::Bound::Included(end_key.as_bytes()),
+            )?;
+            while iter.is_valid() {
+                println!(
+                    "{:?}={:?}",
+                    Bytes::copy_from_slice(iter.key()),
+                    Bytes::copy_from_slice(iter.value()),
+                );
+                iter.next()?;
+            }
+        } else if line == "dump" {
+            lsm.dump_structure();
         } else if line == "flush" {
             lsm.force_flush()?;
         } else if line == "quit" {