adjust leveled compaction

Author: marvin-j97

src/compaction/leveled/mod.rs

@@ -277,6 +277,36 @@ impl CompactionStrategy for Strategy {
     fn choose(&self, version: &Version, _: &Config, state: &CompactionState) -> Choice {
         assert!(version.level_count() == 7, "should have exactly 7 levels");
 
+        // Trivial move into Lmax
+        'trivial_lmax: {
+            let l0 = version.level(0).expect("first level should exist");
+
+            if !l0.is_empty() && l0.is_disjoint() {
+                let lmax_index = version.level_count() - 1;
+
+                if (1..lmax_index)
+                    .any(|idx| !version.level(idx).expect("level should exist").is_empty())
+                {
+                    // There are intermediary levels with data, cannot trivially move to Lmax
+                    break 'trivial_lmax;
+                }
+
+                let lmax = version.level(lmax_index).expect("last level should exist");
+
+                if !lmax
+                    .aggregate_key_range()
+                    .overlaps_with_key_range(&l0.aggregate_key_range())
+                {
+                    return Choice::Move(CompactionInput {
+                        table_ids: l0.list_ids(),
+                        dest_level: lmax_index as u8,
+                        canonical_level: 1,
+                        target_size: self.target_size,
+                    });
+                }
+            }
+        }
+
         // Find the level that corresponds to L1
         #[expect(clippy::map_unwrap_or)]
         let first_non_empty_level = version

src/compaction/leveled/test.rs

@@ -1,4 +1,4 @@
-use super::Strategy;
+use super::*;
 use crate::{AbstractTree, Config, SequenceNumberCounter};
 use std::sync::Arc;
 use test_log::test;
@@ -137,6 +137,7 @@ fn leveled_l0_reached_limit_disjoint_l1() -> crate::Result<()> {
 }
 
 #[test]
+#[expect(clippy::unwrap_used)]
 fn leveled_sequential_inserts() -> crate::Result<()> {
     let dir = tempfile::tempdir()?;
     let tree = Config::new(
@@ -146,18 +147,30 @@ fn leveled_sequential_inserts() -> crate::Result<()> {
     )
     .open()?;
 
-    for (table_count, k) in ('a'..='z').enumerate() {
-        let table_count = table_count + 1;
+    let strategy = Arc::new(Strategy {
+        target_size: 1,
+        ..Default::default()
+    });
 
-        // NOTE: Tables need to overlap
-        tree.insert(k.to_string(), "", 0);
+    let mut table_count = 0;
+
+    for k in 0u64..100 {
+        table_count += 1;
+
+        tree.insert(k.to_be_bytes(), "", 0);
         tree.flush_active_memtable(0)?;
 
         assert_eq!(table_count, tree.table_count());
-
-        let strategy = Arc::new(Strategy::default());
-        tree.compact(strategy, 0)?;
+        tree.compact(strategy.clone(), 0)?;
         assert_eq!(table_count, tree.table_count());
+
+        for idx in 1..=5 {
+            assert_eq!(
+                0,
+                tree.current_version().level(idx).unwrap().len(),
+                "no tables should be in intermediary level (L{idx})",
+            );
+        }
     }
 
     Ok(())

tests/leveled_trivial_move.rs

@@ -18,17 +18,17 @@ fn leveled_trivial_move_into_l1() -> lsm_tree::Result<()> {
     tree.insert("a", "a", 0);
     tree.flush_active_memtable(0)?;
     tree.compact(compaction.clone(), 0)?;
-    assert_eq!(1, tree.level_table_count(0).unwrap_or_default());
+    assert_eq!(1, tree.level_table_count(6).unwrap_or_default());
 
     tree.insert("b", "b", 0);
     tree.flush_active_memtable(0)?;
     tree.compact(compaction.clone(), 0)?;
-    assert_eq!(2, tree.level_table_count(0).unwrap_or_default());
+    assert_eq!(2, tree.level_table_count(6).unwrap_or_default());
 
     tree.insert("c", "c", 0);
     tree.flush_active_memtable(0)?;
     tree.compact(compaction.clone(), 0)?;
-    assert_eq!(3, tree.level_table_count(0).unwrap_or_default());
+    assert_eq!(3, tree.level_table_count(6).unwrap_or_default());
 
     tree.insert("d", "d", 0);
     tree.flush_active_memtable(0)?;