edge iterator

src/db/iterator.rs

@@ -1018,7 +1018,7 @@ mod tests {
             };
             let it = OutputIterator::new(&it, &vals)?;
             for val in it {
-                println!("{}", val.unwrap());
+                println!("{}", val?);
             }
             let duration = start.elapsed();
             let duration2 = start2.elapsed();
@@ -1033,13 +1033,13 @@ mod tests {
             };
             {
                 for el in it.iter()? {
-                    println!("{:?}", el);
+                    println!("{:?}", el?);
                 }
             }
             println!("XXXXX");
             {
                 for el in it.iter()? {
-                    println!("{:?}", el);
+                    println!("{:?}", el?);
                 }
             }
             let mut it = sess.iter_node(tbl);
@@ -1102,7 +1102,7 @@ mod tests {
             let plan = sess.reify_output_plan(plan)?;
             println!("{:?}", plan);
             for val in plan.iter()? {
-                println!("{:?}", val)
+                println!("{}", val?)
             }
         }
         drop(engine);

src/db/plan.rs

@@ -139,32 +139,36 @@ impl<'a> Session<'a> {
         self.convert_select_data_to_plan(plan, select_data)
     }
     fn convert_from_data_to_plan(&self, mut from_data: Vec<FromEl>) -> Result<ExecPlan> {
-        let res = match from_data.pop().unwrap() {
-            FromEl::Simple(el) => {
-                // println!(
-                //     "{:#?}",
-                //     self.base_relation_to_accessor_map(&el.table, &el.binding, &el.info)
-                // );
-                match el.info.kind {
-                    DataKind::Node => {
-                        ExecPlan::NodeItPlan {
-                            it: IteratorSlot::Dummy,
-                            info: el.info,
-                            binding: el.binding,
+        let convert_el = |el|
+            match el {
+                FromEl::Simple(el) => {
+                    match el.info.kind {
+                        DataKind::Node => {
+                            Ok(ExecPlan::NodeItPlan {
+                                it: IteratorSlot::Dummy,
+                                info: el.info,
+                                binding: el.binding,
+                            })
                         }
-                    }
-                    DataKind::Edge => {
-                        ExecPlan::EdgeItPlan {
-                            it: IteratorSlot::Dummy,
-                            info: el.info,
-                            binding: el.binding,
+                        DataKind::Edge => {
+                            Ok(ExecPlan::EdgeItPlan {
+                                it: IteratorSlot::Dummy,
+                                info: el.info,
+                                binding: el.binding,
+                            })
                         }
+                        _ => Err(LogicError("Wrong type for table binding".to_string()))
                     }
-                    _ => return Err(LogicError("Wrong type for table binding".to_string()))
                 }
-            }
-            FromEl::Chain(_) => todo!(),
-        };
+                FromEl::Chain(_) => todo!(),
+            };
+        let mut from_data = from_data.into_iter();
+        let fst = from_data.next().ok_or_else(||
+            LogicError("Empty from clause".to_string()))?;
+        let res = convert_el(fst)?;
+        for _nxt in from_data {
+            // TODO build cartesian product
+        }
         Ok(res)
     }
     pub(crate) fn node_accessor_map(