improve version selection logic and comments in get_internal_entry

Author: zaidoon1

src/tree/mod.rs

@@ -81,39 +81,54 @@ impl AbstractTree for Tree {
 
     #[expect(clippy::significant_drop_tightening)]
     fn get_internal_entry(&self, key: &[u8], seqno: SeqNo) -> crate::Result<Option<InternalValue>> {
+        // Returns the newest visible version (`entry.seqno < seqno`) across all sources
+        // for the given snapshot watermark `seqno`:
+        // - Active memtable
+        // - Sealed memtables (newest-first)
+        // - Tables (newest-first)
+        // Ingestion can write newer versions directly to tables with an explicit `seqno`,
+        // so we compare seqnos across sources and keep the maximal visible version, then
+        // apply tombstone semantics once to that winner.
+
         let version_history_lock = self.version_history.read().expect("lock is poisoned");
         let super_version = version_history_lock.get_version_for_snapshot(seqno);
+        // Avoid holding the read lock across potential I/O in table lookups
+        drop(version_history_lock);
 
-        // Track best candidate by seqno across all sources
+        // 1) Active memtable (in-memory)
+        //    If it yields the maximal visible seqno (seqno-1), no source can be newer.
         let mut best: Option<InternalValue> = super_version.active_memtable.get(key, seqno);
-        // If the memtable hit matches the snapshot seqno, it's the maximal visible version
-        if let Some(ref entry) = best {
-            if entry.key.seqno == seqno {
-                return Ok(ignore_tombstone_value(entry.clone()));
+        if let Some(ref b) = best {
+            if seqno > 0 && b.key.seqno + 1 == seqno {
+                return Ok(ignore_tombstone_value(b.clone()));
             }
         }
 
-        // Sealed memtables are older than active; only consult them on miss
+        // 2) Sealed memtables (in-memory, newest-first)
+        //    If active memtable already has a hit, sealed memtables cannot be newer.
         if best.is_none() {
             if let Some(entry) =
                 Self::get_internal_entry_from_sealed_memtables(&super_version, key, seqno)
             {
+                // Early-exit if sealed provided the maximal visible seqno.
+                if seqno > 0 && entry.key.seqno + 1 == seqno {
+                    return Ok(ignore_tombstone_value(entry));
+                }
                 best = Some(entry);
             }
         }
 
+        // 3) Tables (on-disk), scanned newest-first within each level/run
         if let Some(entry) =
             self.get_internal_entry_from_tables(&super_version.version, key, seqno)?
         {
-            if let Some(b) = best {
-                if b.key.seqno >= entry.key.seqno {
-                    return Ok(ignore_tombstone_value(b));
-                }
+            match &best {
+                Some(b) if b.key.seqno >= entry.key.seqno => {}
+                _ => best = Some(entry),
             }
-            return Ok(ignore_tombstone_value(entry));
         }
 
-        // Apply tombstone semantics after selecting the newest version
+        // Apply tombstone semantics after selecting the newest visible version
         Ok(best.and_then(ignore_tombstone_value))
     }