hand-crafted queries

src/db/plan.rs

@@ -187,7 +187,7 @@ mod tests {
                 FromEl::Simple(s) => s,
                 FromEl::Chain(_) => panic!()
             };
-            let s = "where e.id >= 100, e.id <= 105";
+            let s = "where e.id >= 100, e.id <= 105 || e.id == 110";
             let p = Parser::parse(Rule::where_pattern, s).unwrap().next().unwrap();
             let where_pat = sess.parse_where_pattern(p).unwrap();
 
@@ -197,10 +197,12 @@ mod tests {
             let p = Parser::parse(Rule::select_pattern, s).unwrap().next().unwrap();
             let sel_pat = sess.parse_select_pattern(p).unwrap();
             let amap = sess.base_relation_to_accessor_map(&from_pat.table, &from_pat.binding, &from_pat.info);
-            let (_, vals) = sess.partial_eval(sel_pat.vals,& Default::default(), &amap).unwrap();
-            let (_, where_vals) = sess.partial_eval(where_pat,& Default::default(), &amap).unwrap();
-            let (vals, mut rel_tbls) = vals.extract_relevant_tables().unwrap();
-            let (where_vals, _) = where_vals.extract_relevant_tables().unwrap();
+            let (_, vals) = sess.partial_eval(sel_pat.vals, &Default::default(), &amap).unwrap();
+            let (_, where_vals) = sess.partial_eval(where_pat, &Default::default(), &amap).unwrap();
+            let (vcoll, mut rel_tbls) = Value::extract_relevant_tables([vals, where_vals].into_iter()).unwrap();
+            let mut vcoll = vcoll.into_iter();
+            let vals = vcoll.next().unwrap();
+            let where_vals = vcoll.next().unwrap();
             println!("VALS AFTER 2  {} {}", vals, where_vals);
 
             println!("{:?}", from_pat);
@@ -225,18 +227,17 @@ mod tests {
                             println!("{}", extracted);
                         }
                         Value::Null |
-                        Value::Bool(_) => {},
+                        Value::Bool(_) => {}
                         _ => panic!("Bad type")
                     }
                     it.next();
                 } else {
-                    break
+                    break;
                 }
             }
             let duration = start.elapsed();
             let duration2 = start2.elapsed();
             println!("Time elapsed {:?} {:?}", duration, duration2);
-
         }
         drop(engine);
         let _ = fs::remove_dir_all(db_path);

src/relation/value.rs

@@ -176,9 +176,12 @@ impl<'a> Value<'a> {
         Value::from_pair(pair)
     }
 
-    pub fn extract_relevant_tables(self) -> Result<(Self, Vec<TableId>)> {
+    pub fn extract_relevant_tables<T: Iterator<Item=Self>>(data: T) -> Result<(Vec<Self>, Vec<TableId>)> {
         let mut coll = vec![];
-        let res = self.do_extract_relevant_tables(&mut coll)?;
+        let mut res = Vec::with_capacity(data.size_hint().1.unwrap_or(0));
+        for v in data {
+            res.push(v.do_extract_relevant_tables(&mut coll)?);
+        }
         Ok((res, coll))
     }
 
@@ -310,11 +313,11 @@ impl<'a> From<BTreeMap<Cow<'a, str>, Value<'a>>> for Value<'a> {
 impl<'a> Display for Value<'a> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            Value::Null => { f.write_str("null")?; }
-            Value::Bool(b) => { f.write_str(if *b { "true" } else { "false" })?; }
-            Value::Int(i) => { f.write_str(&i.to_string())?; }
-            Value::Float(n) => { f.write_str(&format!("{:e}", n.into_inner()))?; }
-            Value::Uuid(u) => { f.write_str(&u.to_string())?; }
+            Value::Null => { write!(f, "null")?; }
+            Value::Bool(b) => { write!(f, "{}", if *b { "true" } else { "false" })?; }
+            Value::Int(i) => { write!(f, "{}", i)?; }
+            Value::Float(n) => { write!(f, "{}", n.into_inner())?; }
+            Value::Uuid(u) => { write!(f, "{}", u)?; }
             Value::Text(t) => {
                 f.write_char('"')?;
                 for char in t.chars() {