keyed union

src/db/plan.rs

@@ -275,7 +275,46 @@ impl<'a> Iterator for KeyedUnionIterator<'a> {
     type Item = Result<MegaTuple>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        todo!()
+        let mut left_cache = match self.left.next() {
+            None => return None,
+            Some(Err(e)) => return Some(Err(e)),
+            Some(Ok(t)) => t
+        };
+
+        let mut right_cache = match self.right.next() {
+            None => return None,
+            Some(Err(e)) => return Some(Err(e)),
+            Some(Ok(t)) => t
+        };
+
+        loop {
+            let cmp_res = left_cache.all_keys_cmp(&right_cache);
+            match cmp_res {
+                Ordering::Equal => {
+                    return Some(Ok(left_cache));
+                }
+                Ordering::Less => {
+                    // Advance the left one
+                    match self.left.next() {
+                        None => return None,
+                        Some(Err(e)) => return Some(Err(e)),
+                        Some(Ok(t)) => {
+                            left_cache = t;
+                        }
+                    };
+                }
+                Ordering::Greater => {
+                    // Advance the right one
+                    match self.right.next() {
+                        None => return None,
+                        Some(Err(e)) => return Some(Err(e)),
+                        Some(Ok(t)) => {
+                            right_cache = t;
+                        }
+                    };
+                }
+            }
+        }
     }
 }
 

src/relation/table.rs

@@ -1,3 +1,4 @@
+use std::cmp::Ordering;
 use crate::relation::tuple::{CowTuple};
 use crate::relation::typing::Typing;
 
@@ -57,4 +58,24 @@ impl MegaTuple {
         self.keys.extend(other.keys);
         self.vals.extend(other.vals);
     }
+    pub fn all_keys_eq(&self, other: &Self) -> bool {
+        if self.keys.len() != other.keys.len() {
+            return false;
+        }
+        for (l, r) in self.keys.iter().zip(&other.keys) {
+            if !l.key_part_eq(r) {
+                return false;
+            }
+        }
+        true
+    }
+    pub fn all_keys_cmp(&self, other: &Self) -> Ordering {
+        for (l, r) in self.keys.iter().zip(&other.keys) {
+            match l.key_part_cmp(r) {
+                Ordering::Equal => {},
+                v => return v
+            }
+        }
+        Ordering::Equal
+    }
 }