relational algebra not dyn trait

src/algebra/op/filter.rs

@@ -1,5 +1,5 @@
 use crate::algebra::op::RelationalAlgebra;
-use crate::algebra::parser::{assert_rule, build_relational_expr, AlgebraParseError};
+use crate::algebra::parser::{assert_rule, build_relational_expr, AlgebraParseError, RaBox};
 use crate::context::TempDbContext;
 use crate::data::expr::{Expr, StaticExpr};
 use crate::data::op::OpAnd;
@@ -16,7 +16,7 @@ pub(crate) const NAME_WHERE: &str = "Where";
 
 pub(crate) struct WhereFilter<'a> {
     ctx: &'a TempDbContext<'a>,
-    source: Box<dyn RelationalAlgebra + 'a>,
+    pub(crate) source: RaBox<'a>,
     condition: StaticExpr,
 }
 
@@ -29,7 +29,7 @@ pub(crate) enum FilterError {
 impl<'a> WhereFilter<'a> {
     pub(crate) fn build(
         ctx: &'a TempDbContext<'a>,
-        prev: Option<Box<dyn RelationalAlgebra + 'a>>,
+        prev: Option<RaBox<'a>>,
         mut args: Pairs,
     ) -> Result<Self> {
         let not_enough_args = || AlgebraParseError::NotEnoughArguments(NAME_WHERE.to_string());

src/algebra/op/from.rs

@@ -1,5 +1,5 @@
-use crate::algebra::op::{RelationalAlgebra, TableScan};
-use crate::algebra::parser::{assert_rule, AlgebraParseError};
+use crate::algebra::op::{TableScan};
+use crate::algebra::parser::{assert_rule, AlgebraParseError, RaBox};
 use crate::context::TempDbContext;
 use crate::data::uuid::random_uuid_v1;
 use crate::parser::text_identifier::build_name_in_def;
@@ -11,9 +11,9 @@ pub(crate) const NAME_FROM: &str = "From";
 
 pub(crate) fn build_from_clause<'a>(
     ctx: &'a TempDbContext<'a>,
-    prev: Option<Box<dyn RelationalAlgebra + 'a>>,
+    prev: Option<RaBox<'a>>,
     mut args: Pairs,
-) -> Result<Box<dyn RelationalAlgebra + 'a>> {
+) -> Result<RaBox<'a>> {
     if !matches!(prev, None) {
         return Err(AlgebraParseError::Unchainable(NAME_FROM.to_string()).into());
     }
@@ -26,7 +26,7 @@ pub(crate) fn build_from_clause<'a>(
         .ok_or_else(not_enough_args)?;
     let mut chain = parse_chain(chain)?.into_iter();
     let mut last_el = chain.next().ok_or_else(not_enough_args)?;
-    let mut ret = Box::new(TableScan::build(ctx, &last_el, true)?);
+    let mut ret = RaBox::TableScan(Box::new(TableScan::build(ctx, &last_el, true)?));
     for el in chain {
         todo!()
     }

src/algebra/op/insert.rs

@@ -1,7 +1,7 @@
 use crate::algebra::op::{
     build_binding_map_from_info, InterpretContext, KeyBuilderSet, RelationalAlgebra,
 };
-use crate::algebra::parser::{assert_rule, build_relational_expr, AlgebraParseError};
+use crate::algebra::parser::{assert_rule, build_relational_expr, AlgebraParseError, RaBox};
 use crate::context::TempDbContext;
 use crate::data::expr::{Expr, StaticExpr};
 use crate::data::parser::parse_scoped_dict;
@@ -24,7 +24,7 @@ pub(crate) const NAME_UPSERT: &str = "Upsert";
 
 pub(crate) struct Insertion<'a> {
     ctx: &'a TempDbContext<'a>,
-    source: Box<dyn RelationalAlgebra + 'a>,
+    pub(crate) source: RaBox<'a>,
     binding: String,
     target_info: TableInfo,
     assoc_infos: Vec<AssocInfo>,
@@ -36,7 +36,7 @@ pub(crate) struct Insertion<'a> {
 impl<'a> Insertion<'a> {
     pub(crate) fn build(
         ctx: &'a TempDbContext<'a>,
-        prev: Option<Box<dyn RelationalAlgebra + 'a>>,
+        prev: Option<RaBox<'a>>,
         mut args: Pairs,
         upsert: bool,
     ) -> Result<Self> {

src/algebra/op/select.rs

@@ -1,5 +1,5 @@
 use crate::algebra::op::RelationalAlgebra;
-use crate::algebra::parser::{assert_rule, build_relational_expr, AlgebraParseError};
+use crate::algebra::parser::{assert_rule, build_relational_expr, AlgebraParseError, RaBox};
 use crate::context::TempDbContext;
 use crate::data::expr::{Expr, StaticExpr};
 use crate::data::parser::{parse_keyed_dict, parse_scoped_dict};
@@ -18,7 +18,7 @@ pub(crate) const NAME_SELECT: &str = "Select";
 
 pub(crate) struct SelectOp<'a> {
     ctx: &'a TempDbContext<'a>,
-    source: Box<dyn RelationalAlgebra + 'a>,
+    pub(crate) source: RaBox<'a>,
     binding: String,
     extract_map: StaticExpr,
 }
@@ -26,7 +26,7 @@ pub(crate) struct SelectOp<'a> {
 impl<'a> SelectOp<'a> {
     pub(crate) fn build(
         ctx: &'a TempDbContext<'a>,
-        prev: Option<Box<dyn RelationalAlgebra + 'a>>,
+        prev: Option<RaBox<'a>>,
         mut args: Pairs,
     ) -> Result<Self> {
         let not_enough_args = || AlgebraParseError::NotEnoughArguments(NAME_SELECT.to_string());
@@ -121,7 +121,7 @@ impl<'b> RelationalAlgebra for SelectOp<'b> {
         Ok(BTreeMap::from([(self.binding.clone(), extract_map)]))
     }
 
-    fn iter<'a>(&'a self) -> Result<Box<dyn Iterator<Item = Result<TupleSet>> + 'a>> {
+    fn iter<'a>(&'a self) -> Result<Box<dyn Iterator<Item=Result<TupleSet>> + 'a>> {
         let source_map = self.source.binding_map()?;
         let binding_ctx = BindingMapEvalContext {
             map: &source_map,

src/algebra/op/tagged.rs

@@ -1,5 +1,5 @@
 use crate::algebra::op::{RelationalAlgebra, TableInfoByIdCache, TableInfoByNameCache};
-use crate::algebra::parser::{assert_rule, AlgebraParseError};
+use crate::algebra::parser::{assert_rule, AlgebraParseError, RaBox};
 use crate::context::TempDbContext;
 use crate::data::expr::Expr;
 use crate::data::tuple::{DataKind, OwnTuple};
@@ -26,7 +26,6 @@ type TaggedInsertionSet = (
 
 pub(crate) struct TaggedInsertion<'a> {
     ctx: &'a TempDbContext<'a>,
-    // source: Box<Vec<StaticValue>>,
     values: BTreeMap<TableId, Vec<TaggedInsertionSet>>,
     tally: BTreeMap<String, usize>,
     binding: String,
@@ -36,7 +35,7 @@ pub(crate) struct TaggedInsertion<'a> {
 impl<'a> TaggedInsertion<'a> {
     pub(crate) fn build(
         ctx: &'a TempDbContext<'a>,
-        prev: Option<Box<dyn RelationalAlgebra + 'a>>,
+        prev: Option<RaBox<'a>>,
         mut args: Pairs,
         upsert: bool,
     ) -> Result<Self> {

src/algebra/op/values.rs

@@ -1,5 +1,5 @@
 use crate::algebra::op::RelationalAlgebra;
-use crate::algebra::parser::{assert_rule, AlgebraParseError};
+use crate::algebra::parser::{assert_rule, AlgebraParseError, RaBox};
 use crate::context::TempDbContext;
 use crate::data::expr::Expr;
 use crate::data::tuple::{DataKind, OwnTuple};
@@ -21,7 +21,7 @@ pub(crate) struct RelationFromValues {
 impl RelationFromValues {
     pub(crate) fn build<'a>(
         ctx: &'a TempDbContext<'a>,
-        prev: Option<Box<dyn RelationalAlgebra + 'a>>,
+        prev: Option<RaBox<'a>>,
         mut args: Pairs,
     ) -> Result<Self> {
         if !matches!(prev, None) {

src/algebra/parser.rs

@@ -1,14 +1,13 @@
-use crate::algebra::op::{
-    build_from_clause, Insertion, RelationFromValues, RelationalAlgebra, SelectOp, TaggedInsertion,
-    WhereFilter, NAME_FROM, NAME_INSERTION, NAME_RELATION_FROM_VALUES, NAME_SELECT,
-    NAME_TAGGED_INSERTION, NAME_TAGGED_UPSERT, NAME_UPSERT, NAME_WHERE,
-};
+use std::collections::BTreeSet;
+use std::error::Error;
+use crate::algebra::op::{build_from_clause, Insertion, RelationFromValues, RelationalAlgebra, SelectOp, TaggedInsertion, WhereFilter, NAME_FROM, NAME_INSERTION, NAME_RELATION_FROM_VALUES, NAME_SELECT, NAME_TAGGED_INSERTION, NAME_TAGGED_UPSERT, NAME_UPSERT, NAME_WHERE, TableScan};
 use crate::context::TempDbContext;
 use crate::data::tuple::OwnTuple;
-use crate::data::tuple_set::TableId;
+use crate::data::tuple_set::{BindingMap, TableId, TupleSet};
 use crate::data::value::StaticValue;
 use crate::parser::{Pair, Rule};
 use anyhow::Result;
+use crate::ddl::reify::TableInfo;
 
 #[derive(thiserror::Error, Debug)]
 pub(crate) enum AlgebraParseError {
@@ -52,34 +51,114 @@ pub(crate) fn assert_rule(pair: &Pair, rule: Rule, name: &str, u: usize) -> Resu
             u,
             format!("{:?}", pair.as_rule()),
         )
-        .into())
+            .into())
+    }
+}
+
+// this looks stupid but is the easiest way to get downcasting
+pub(crate) enum RaBox<'a> {
+    Insertion(Box<Insertion<'a>>),
+    TaggedInsertion(Box<TaggedInsertion<'a>>),
+    FromValues(Box<RelationFromValues>),
+    TableScan(Box<TableScan<'a>>),
+    WhereFilter(Box<WhereFilter<'a>>),
+    SelectOp(Box<SelectOp<'a>>),
+}
+
+impl<'a> RaBox<'a> {
+    pub(crate) fn sources(&self) -> Vec<&RaBox> {
+        match self {
+            RaBox::Insertion(inner) => vec![&inner.source],
+            RaBox::TaggedInsertion(_inner) => vec![],
+            RaBox::FromValues(_inner) => vec![],
+            RaBox::TableScan(_inner) => vec![],
+            RaBox::WhereFilter(inner) => vec![&inner.source],
+            RaBox::SelectOp(inner) => vec![&inner.source]
+        }
+    }
+}
+
+impl<'b> RelationalAlgebra for RaBox<'b> {
+    fn name(&self) -> &str {
+        match self {
+            RaBox::Insertion(inner) => inner.name(),
+            RaBox::TaggedInsertion(inner) => inner.name(),
+            RaBox::FromValues(inner) => inner.name(),
+            RaBox::TableScan(inner) => inner.name(),
+            RaBox::WhereFilter(inner) => inner.name(),
+            RaBox::SelectOp(inner) => inner.name(),
+        }
+    }
+
+    fn bindings(&self) -> Result<BTreeSet<String>> {
+        match self {
+            RaBox::Insertion(inner) => inner.bindings(),
+            RaBox::TaggedInsertion(inner) => inner.bindings(),
+            RaBox::FromValues(inner) => inner.bindings(),
+            RaBox::TableScan(inner) => inner.bindings(),
+            RaBox::WhereFilter(inner) => inner.bindings(),
+            RaBox::SelectOp(inner) => inner.bindings(),
+        }
+    }
+
+    fn binding_map(&self) -> Result<BindingMap> {
+        match self {
+            RaBox::Insertion(inner) => inner.binding_map(),
+            RaBox::TaggedInsertion(inner) => inner.binding_map(),
+            RaBox::FromValues(inner) => inner.binding_map(),
+            RaBox::TableScan(inner) => inner.binding_map(),
+            RaBox::WhereFilter(inner) => inner.binding_map(),
+            RaBox::SelectOp(inner) => inner.binding_map(),
+        }
+    }
+
+    fn iter<'a>(&'a self) -> Result<Box<dyn Iterator<Item=Result<TupleSet>> + 'a>> {
+        match self {
+            RaBox::Insertion(inner) => inner.iter(),
+            RaBox::TaggedInsertion(inner) => inner.iter(),
+            RaBox::FromValues(inner) => inner.iter(),
+            RaBox::TableScan(inner) => inner.iter(),
+            RaBox::WhereFilter(inner) => inner.iter(),
+            RaBox::SelectOp(inner) => inner.iter(),
+        }
+    }
+
+    fn identity(&self) -> Option<TableInfo> {
+        match self {
+            RaBox::Insertion(inner) => inner.identity(),
+            RaBox::TaggedInsertion(inner) => inner.identity(),
+            RaBox::FromValues(inner) => inner.identity(),
+            RaBox::TableScan(inner) => inner.identity(),
+            RaBox::WhereFilter(inner) => inner.identity(),
+            RaBox::SelectOp(inner) => inner.identity(),
+        }
     }
 }
 
 pub(crate) fn build_relational_expr<'a>(
     ctx: &'a TempDbContext,
     pair: Pair,
-) -> Result<Box<dyn RelationalAlgebra + 'a>> {
-    let mut built: Option<Box<dyn RelationalAlgebra>> = None;
+) -> Result<RaBox<'a>> {
+    let mut built: Option<RaBox> = None;
     for pair in pair.into_inner() {
         let mut pairs = pair.into_inner();
         match pairs.next().unwrap().as_str() {
-            NAME_INSERTION => built = Some(Box::new(Insertion::build(ctx, built, pairs, false)?)),
-            NAME_UPSERT => built = Some(Box::new(Insertion::build(ctx, built, pairs, true)?)),
+            NAME_INSERTION => built = Some(RaBox::Insertion(Box::new(Insertion::build(ctx, built, pairs, false)?))),
+            NAME_UPSERT => built = Some(RaBox::Insertion(Box::new(Insertion::build(ctx, built, pairs, true)?))),
             NAME_TAGGED_INSERTION => {
-                built = Some(Box::new(TaggedInsertion::build(ctx, built, pairs, false)?))
+                built = Some(RaBox::TaggedInsertion(Box::new(TaggedInsertion::build(ctx, built, pairs, false)?)))
             }
             NAME_TAGGED_UPSERT => {
-                built = Some(Box::new(TaggedInsertion::build(ctx, built, pairs, true)?))
+                built = Some(RaBox::TaggedInsertion(Box::new(TaggedInsertion::build(ctx, built, pairs, true)?)))
             }
             NAME_RELATION_FROM_VALUES => {
-                built = Some(Box::new(RelationFromValues::build(ctx, built, pairs)?));
+                built = Some(RaBox::FromValues(Box::new(RelationFromValues::build(ctx, built, pairs)?)));
             }
             NAME_FROM => {
                 built = Some(build_from_clause(ctx, built, pairs)?);
             }
-            NAME_WHERE => built = Some(Box::new(WhereFilter::build(ctx, built, pairs)?)),
-            NAME_SELECT => built = Some(Box::new(SelectOp::build(ctx, built, pairs)?)),
+            NAME_WHERE => built = Some(RaBox::WhereFilter(Box::new(WhereFilter::build(ctx, built, pairs)?))),
+            NAME_SELECT => built = Some(RaBox::SelectOp(Box::new(SelectOp::build(ctx, built, pairs)?))),
             _ => unimplemented!(),
         }
     }