Merge pull request #2 from bobtwinkles/optimize_relation_merge

Improve performance of Relation::merge

Author: frankmcsherry

src/lib.rs

@@ -13,6 +13,7 @@
 
 use std::rc::Rc;
 use std::cell::RefCell;
+use std::cmp::Ordering;
 
 mod map;
 mod join;
@@ -34,27 +35,51 @@ impl<Tuple: Ord> Relation<Tuple> {
         let mut elements1 = self.elements;
         let mut elements2 = other.elements;
 
-        // Ensure elements1.cap() >= elements2.cap().
-        if elements1.capacity() < elements2.capacity() {
-            ::std::mem::swap(&mut elements1, &mut elements2);
+        // If one of the element lists is zero-length, we don't need to do any work
+        if elements1.len() == 0 {
+            return Relation { elements: elements2 };
+        }
+        if elements2.len() == 0 {
+            return Relation { elements: elements1 };
+        }
+
+        // Make sure that elements1 starts with the lower element
+        // Will not panic since both collections must have at least 1 element at this point
+        if elements1[0] > elements2[0] {
+            std::mem::swap(&mut elements1, &mut elements2);
         }
 
-        // Merge results either in spare capacity or new vector.
-        let mut elements =
-        if elements1.len() + elements2.len() < elements1.capacity() {
+        // Fast path for when all the new elements are after the exiting ones
+        if elements1[elements1.len() - 1] < elements2[0] {
             elements1.extend(elements2.into_iter());
-            elements1
+            // println!("fast path");
+            return Relation { elements: elements1 };
         }
-        else {
-            let mut vec = Vec::with_capacity(elements1.len() + elements2.len());
-            vec.extend(elements1.into_iter());
-            vec.extend(elements2.into_iter());
-            vec
-        };
-
-        // Sort, dedup, and return.
-        elements.sort();
-        elements.dedup();
+
+        let mut elements = Vec::with_capacity(elements1.len() + elements2.len());
+        let mut elements1 = elements1.drain(..);
+        let mut elements2 = elements2.drain(..).peekable();
+
+        elements.push(elements1.next().unwrap());
+        if &elements[0] == elements2.peek().unwrap() {
+            elements2.next();
+        }
+
+        for elem in elements1 {
+            while elements2.peek().map(|x| x.cmp(&elem)) == Some(Ordering::Less) {
+                elements.push(elements2.next().unwrap());
+            }
+            if elements2.peek().map(|x| x.cmp(&elem)) == Some(Ordering::Equal) {
+                elements2.next();
+            }
+            elements.push(elem);
+        }
+
+        // Finish draining second list
+        for elem in elements2 {
+            elements.push(elem);
+        }
+
         Relation { elements }
     }