first draft of attempt at modeling optimization with persistent memo

optd-types/src/lib.rs

@@ -1,14 +1,37 @@
-pub fn add(left: u64, right: u64) -> u64 {
-    left + right
+mod memo;
+pub use memo::MemoNode;
+
+/// A type representing a transformation or implementation rule for query operators.
+///
+/// TODO The variants are just placeholders.
+pub enum Rule {
+    Transformation,
+    Implementation
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+pub struct GroupId(usize);
+
+/// An in-memory tree of logical operators. Used as the input / entrypoint of the optimizer.
+///
+/// TODO The variants are just placeholders. The actual type will look more similar to
+/// https://docs.rs/substrait/latest/substrait/proto/rel/enum.RelType.html
+pub enum LogicalPlan {
+    Scan(String),
+    Filter(Box<LogicalPlan>),
+    Sort(Box<LogicalPlan>),
+    Join(Box<LogicalPlan>),
+}
 
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
+/// An in-memory tree of physical operators. Used as the final materialized output of the optimizer.
+///
+/// TODO The variants are just placeholders. The actual type will look more similar to
+/// https://docs.rs/substrait/latest/substrait/proto/rel/enum.RelType.html
+pub enum PhysicalPlan {
+    TableScan(String),
+    IndexScan(String),
+    PhysicalFilter(Box<PhysicalPlan>),
+    NestedLoopJoin(Box<PhysicalPlan>),
+    SortMergeJoin(Box<PhysicalPlan>),
+    HashJoin(Box<PhysicalPlan>),
+    MergeSort(Box<PhysicalPlan>),
 }

optd-types/src/memo/mod.rs

@@ -0,0 +1,60 @@
+use relation::{LogicalExpression, Relation};
+use scalar::Scalar;
+
+use crate::Rule;
+
+mod relation;
+mod scalar;
+
+/// A type representing an optimization node / object in the memo table.
+pub enum MemoNode {
+    Relation(Relation),
+    Scalar(Scalar),
+}
+
+/// A type representing a tree of logical nodes, scalar nodes, and group IDs.
+///
+/// Note that group IDs must be leaves of this tree.
+///
+/// TODO Make this an actual tree with the correct modeling of types.
+pub struct PartialLogicalExpression;
+
+/// A type representing a tree of logical nodes, physical nodes, scalar nodes, and group IDs.
+///
+/// Note that group IDs must be leaves of this tree, and that physical nodes cannot have children
+/// that are logical nodes.
+///
+/// TODO Make this an actual tree with the correct modeling of types.
+pub struct PartialPhysicalExpression;
+
+pub struct Memo;
+
+impl Memo {
+    pub async fn check_transformation(
+        &self,
+        expr: LogicalExpression,
+        rule: Rule,
+    ) -> Vec<PartialLogicalExpression> {
+        todo!()
+    }
+
+    pub async fn check_implementation(
+        &self,
+        expr: LogicalExpression,
+        rule: Rule,
+    ) -> Vec<PartialPhysicalExpression> {
+        todo!()
+    }
+
+    pub fn apply_transformation(&mut self, expr: PartialLogicalExpression, rule: Rule) -> Vec<MemoNode> {
+        todo!()
+    }
+
+    pub fn apply_implementation(&mut self, expr: PartialPhysicalExpression, rule: Rule) -> Vec<MemoNode> {
+        todo!()
+    }
+
+    pub fn add_expressions(&mut self, new_exprs: Vec<MemoNode>) {
+        todo!()
+    }
+}

optd-types/src/memo/relation/logical_expression.rs

@@ -0,0 +1,29 @@
+use crate::GroupId;
+
+/// A type representing different kinds of logical expressions / operators.
+pub enum LogicalExpression {
+    Scan(Scan),
+    Filter(Filter),
+    Join(Join),
+    Sort(Sort),
+}
+
+struct Scan {
+    table_name: String,
+}
+
+struct Filter {
+    child: GroupId,
+    predicate: GroupId,
+}
+
+struct Join {
+    left: GroupId,
+    right: GroupId,
+    condition: GroupId,
+}
+
+struct Sort {
+    child: GroupId,
+    sort_expr: GroupId,
+}

optd-types/src/memo/relation/mod.rs

@@ -0,0 +1,11 @@
+mod logical_expression;
+pub use logical_expression::LogicalExpression;
+
+mod physical_expression;
+pub use physical_expression::PhysicalExpression;
+
+/// A type representing logical or physical operators in a relational algebraic query plan.
+pub enum Relation {
+    Logical(LogicalExpression),
+    Physical(PhysicalExpression),
+}

optd-types/src/memo/relation/physical_expression.rs

@@ -0,0 +1,39 @@
+use crate::GroupId;
+
+/// A type representing different kinds of physical expressions / operators.
+pub enum PhysicalExpression {
+    TableScan(TableScan),
+    PhysicalFilter(PhysicalFilter),
+    SortMergeJoin(SortMergeJoin),
+    HashJoin(HashJoin),
+    MergeSort(MergeSort),
+}
+
+struct TableScan {
+    table_name: String,
+}
+
+struct PhysicalFilter {
+    child: GroupId,
+    predicate: GroupId,
+}
+
+
+struct SortMergeJoin {
+    left: GroupId,
+    right: GroupId,
+    condition: GroupId,
+    sort_expr: GroupId,
+}
+
+struct HashJoin {
+    left: GroupId,
+    right: GroupId,
+    condition: GroupId,
+}
+
+struct MergeSort {
+    child: GroupId,
+    sort_expr: GroupId,
+}
+

optd-types/src/memo/scalar.rs

@@ -0,0 +1,4 @@
+/// A type that represent scalar SQL expression / predicates.
+///
+/// TODO Add fields to this type.
+pub struct Scalar;