feat: two_merge_iterator done

Author: eR3R3

src/iterator.rs

@@ -1,4 +1,5 @@
 pub(crate) mod merge_iterator;
+mod two_merge_iterator;
 
 pub trait StorageIterator {
     // type KeyType<'a>: PartialEq + Eq + PartialOrd + Ord where Self: 'a;

src/iterator/merge_iterator.rs

@@ -74,26 +74,44 @@ impl<T: StorageIterator> MergeIterator<T> {
 }
 
 impl<T: StorageIterator> StorageIterator for MergeIterator<T> {
+    // the right way to think about this is just:
+    // keys in iter1: a, c, d;
+    // keys in iter2: a, b, c;
+    // keys in iter3: b, c ,d;
+    // since iter1 is the most recent mem_table iterator, we take a from iter1, detect that the next iter
+    // has the equal, then call .next() for iter2, then call .next() for the current iterator
+    // the situation will turn into this:
+    // keys in iter1: c, d;
+    // keys in iter2: b, c;
+    // keys in iter3: b, c ,d;
+    // but the binary heap will keep the order for you, so the real one is like this:
+    // keys in iter2: b, c;
+    // keys in iter3: b, c ,d;
+    // keys in iter1: c, d;
+    // then we can take b
     fn next(&mut self) -> anyhow::Result<()> {
         let current = self.current.as_mut().unwrap();
-        // Pop the item out of the heap if they have the same value.
+        // Pop the item out of the heap if they have the same value using while.
         while let Some(mut inner_iter) = self.iters.peek_mut() {
             debug_assert!(
                 inner_iter.1.key() >= current.1.key(),
                 "heap invariant violated"
             );
             if inner_iter.1.key() == current.1.key() {
-                // Case 1: an error occurred when calling `next`.
+                // call next in the mem_table iterator that is coming up since they have the
+                // same key
                 if let e @ Err(_) = inner_iter.1.next() {
                     PeekMut::pop(inner_iter);
                     return e;
                 }
 
-                // Case 2: iter is no longer valid.
+                // deal with it when iter is no longer valid.
                 if !inner_iter.1.is_valid() {
                     PeekMut::pop(inner_iter);
                 }
             } else {
+                // break the loop when something with bigger key appears
+                // it maybe from a different mem_table iterator
                 break;
             }
         }

src/iterator/two_merge_iterator.rs

@@ -0,0 +1,76 @@
+use crate::iterator::StorageIterator;
+use anyhow::Result;
+pub struct TwoMergeIterator<A: StorageIterator, B: StorageIterator> {
+    a: A,
+    b: B,
+    choose_a: bool,
+}
+
+impl<A: StorageIterator, B: StorageIterator> TwoMergeIterator<A, B> {
+    fn choose_a(a: &A, b: &B) -> bool {
+        if !a.is_valid() {
+            return false;
+        }
+        if !b.is_valid() {
+            return true;
+        }
+        a.key() < b.key()
+    }
+
+    fn skip_b(&mut self) -> Result<()> {
+        if self.a.is_valid() {
+            if self.b.is_valid() && self.b.key() == self.a.key() {
+                self.b.next()?;
+            }
+        }
+        Ok(())
+    }
+
+    pub fn create(a: A, b: B) -> Result<Self> {
+        let mut iter = Self {
+            choose_a: false,
+            a,
+            b,
+        };
+        iter.skip_b()?;
+        iter.choose_a = Self::choose_a(&iter.a, &iter.b);
+        Ok(iter)
+    }
+}
+
+impl<A: StorageIterator, B: StorageIterator> StorageIterator for TwoMergeIterator<A, B> {
+    fn key(&self) -> &[u8] {
+        if self.choose_a {
+            self.a.key()
+        } else {
+            self.b.key()
+        }
+    }
+
+    fn value(&self) -> &[u8] {
+        if self.choose_a {
+            self.a.value()
+        } else {
+            self.b.value()
+        }
+    }
+
+    fn is_valid(&self) -> bool {
+        if self.choose_a {
+            self.a.is_valid()
+        } else {
+            self.b.is_valid()
+        }
+    }
+
+    fn next(&mut self) -> Result<()> {
+        if self.choose_a {
+            self.a.next()?;
+        } else {
+            self.b.next()?;
+        }
+        self.skip_b()?;
+        self.choose_a = Self::choose_a(&self.a, &self.b);
+        Ok(())
+    }
+}

src/mem_table.rs

@@ -77,7 +77,7 @@ impl MemTable {
 // 2. the reason I use Arc to wrap the original skipmap is that we need the ownership to move one thing
 // into another thread, also, it is efficient to clone Arc.
 // 3. the reason I use self-reference is that the Rust compiler cannot make sure the skipmap always
-// exist when I try to use the iterator that points to it. (Note we can also use 'a here, but it can be
+// exist when I try to use the iterator that points to it. (Note we can also use 'a here, but it can
 // become quite complicated)
 type SkipMapRangeIter<'a> = crossbeam_skiplist::map::Range<'a, Bytes, (Bound<Bytes>, Bound<Bytes>), Bytes, Bytes>;