simplify point lookup logic

Author: zaidoon1

src/any_tree.rs

@@ -19,11 +19,15 @@ pub enum AnyTree {
     Blob(BlobTree),
 }
 
-/// Unified ingestion builder over AnyTree
+/// Unified ingestion builder over `AnyTree`
+// Keep zero allocations and direct dispatch; boxing introduces heap indirection and `dyn` adds virtual dispatch.
+// Ingestion calls use `&mut self` in tight loops; the active variant is stable and branch prediction makes the match cheap.
+// Allowing this lint preserves hot-path performance at the cost of a larger enum size.
+#[allow(clippy::large_enum_variant)]
 pub enum AnyIngestion<'a> {
     /// Ingestion for a standard LSM-tree
     Standard(Ingestion<'a>),
-    /// Ingestion for a BlobTree with KV separation
+    /// Ingestion for a [`BlobTree`] with KV separation
     Blob(BlobIngestion<'a>),
 }
 

src/tree/mod.rs

@@ -84,30 +84,26 @@ impl AbstractTree for Tree {
         let version_history_lock = self.version_history.read().expect("lock is poisoned");
         let super_version = version_history_lock.get_version_for_snapshot(seqno);
 
-        // Track the newest visible version across all sources
-        let mut best: Option<InternalValue> = super_version.active_memtable.get(key, seqno);
+        // Active memtable has the newest writes; if present, it's definitive.
+        if let Some(entry) = super_version.active_memtable.get(key, seqno) {
+            return Ok(ignore_tombstone_value(entry));
+        }
 
+        // Sealed memtables are newer than any tables; return on first hit.
         if let Some(entry) =
             Self::get_internal_entry_from_sealed_memtables(&super_version, key, seqno)
         {
-            match &best {
-                Some(b) if b.key.seqno >= entry.key.seqno => {}
-                _ => best = Some(entry),
-            }
+            return Ok(ignore_tombstone_value(entry));
         }
 
-        // Merge with the newest version found in tables
+        // Otherwise consult tables (levels top-down, runs newest-first) and return first hit.
         if let Some(entry) =
             self.get_internal_entry_from_tables(&super_version.version, key, seqno)?
         {
-            match &best {
-                Some(b) if b.key.seqno >= entry.key.seqno => {}
-                _ => best = Some(entry),
-            }
+            return Ok(ignore_tombstone_value(entry));
         }
 
-        // Apply tombstone semantics after choosing the newest version
-        Ok(best.and_then(ignore_tombstone_value))
+        Ok(None)
     }
 
     fn current_version(&self) -> Version {
@@ -479,7 +475,6 @@ impl AbstractTree for Tree {
         self.current_version().level(idx).map(|x| x.table_count())
     }
 
-    #[expect(clippy::significant_drop_tightening)]
     fn approximate_len(&self) -> usize {
         let super_version = self
             .version_history
@@ -512,7 +507,6 @@ impl AbstractTree for Tree {
             .sum()
     }
 
-    #[expect(clippy::significant_drop_tightening)]
     fn get_highest_memtable_seqno(&self) -> Option<SeqNo> {
         let version = self
             .version_history