restructure everything and add rules module

optd-types/src/lib.rs

@@ -1,14 +1,16 @@
-#![allow(unused)]
+#![allow(unused_variables)]
 
 pub mod expression;
 pub mod memo;
 pub mod operator;
 pub mod plan;
+pub mod rules;
 
 /// TODO make distinction between relational groups and scalar groups.
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct GroupId(u64);
 
 /// TODO Add docs.
+#[allow(dead_code)]
 pub struct ExprId(u64);

optd-types/src/memo/implementation.rs → optd-types/src/memo.rs

@@ -1,9 +1,7 @@
-use crate::expression::{relational::logical::LogicalExpr, Expr};
-use crate::plan::partial_logical_plan::PartialLogicalPlan;
-use crate::plan::partial_physical_plan::PartialPhysicalPlan;
+use crate::expression::Expr;
 use crate::{ExprId, GroupId};
 
-use super::Memo;
+pub struct Memo;
 
 impl Memo {
     pub async fn add_expr(&mut self, logical_expr: Expr) -> (ExprId, GroupId) {

optd-types/src/operator/mod.rs

@@ -1,4 +1,4 @@
-use std::{marker::PhantomData, sync::Arc};
+use std::marker::PhantomData;
 
 pub mod logical;
 pub mod physical;

optd-types/src/plan/physical_plan.rs

@@ -1,4 +1,4 @@
-use crate::operator::{logical::LogicalOperator, physical::PhysicalOperator, ScalarOperator};
+use crate::operator::{physical::PhysicalOperator, ScalarOperator};
 use std::sync::Arc;
 
 /// TODO Add docs.

optd-types/src/rules/implementation/hash_join.rs

@@ -0,0 +1,13 @@
+use super::*;
+
+pub struct HashJoinRule;
+
+impl ImplementationRule for HashJoinRule {
+    async fn check_pattern(&self, expr: Expr, memo: &Memo) -> Vec<PartialPhysicalPlan> {
+        todo!()
+    }
+
+    fn apply(&self, expr: PartialPhysicalPlan) -> Vec<Expr> {
+        todo!()
+    }
+}

optd-types/src/rules/implementation/mod.rs

@@ -0,0 +1,31 @@
+use crate::{expression::Expr, memo::Memo, plan::partial_physical_plan::PartialPhysicalPlan};
+
+#[allow(dead_code)]
+#[trait_variant::make(Send)]
+pub trait ImplementationRule {
+    /// Checks if the implementation rule matches the current expression and its children.
+    /// Returns a vector of partially materialized physical plans.
+    ///
+    /// This returns a vector because the rule matching the input root expression could have matched
+    /// with multiple child expressions.
+    ///
+    /// For example, let's say the input expression is `Filter(G1)`, and the group G1 has
+    /// two expressions `e1 = HashJoin(HashJoin(A, B), C)` and `e2 = HashJoin(A, HashJoin(B, C))`.
+    ///
+    /// If the rule wants to match against `Filter(HashJoin(?L, ?R))`, then this function will
+    /// partially materialize two expressions `Filter(e1)` and `Filter(e2)`. It is then up to the
+    /// memo table API to apply modifications to the partially materialized physical plans (for
+    /// example, a pushing a filter predicate into the condition of the `HashJoin`).
+    ///
+    /// TODO: Ideally this should return a `Stream` instead of a fully materialized Vector.
+    async fn check_pattern(&self, expr: Expr, memo: &Memo) -> Vec<PartialPhysicalPlan>;
+
+    /// Applys modifications to a partially materialized physical plan.
+    ///
+    /// These changes can create new expressions (logical, physical, and scalar).
+    fn apply(&self, expr: PartialPhysicalPlan) -> Vec<Expr>;
+}
+
+pub mod hash_join;
+pub mod physical_filter;
+pub mod table_scan;

optd-types/src/rules/implementation/physical_filter.rs

@@ -0,0 +1,13 @@
+use super::*;
+
+pub struct PhysicalFilterRule;
+
+impl ImplementationRule for PhysicalFilterRule {
+    async fn check_pattern(&self, expr: Expr, memo: &Memo) -> Vec<PartialPhysicalPlan> {
+        todo!()
+    }
+
+    fn apply(&self, expr: PartialPhysicalPlan) -> Vec<Expr> {
+        todo!()
+    }
+}

optd-types/src/rules/implementation/table_scan.rs

@@ -0,0 +1,13 @@
+use super::*;
+
+pub struct TableScanRule;
+
+impl ImplementationRule for TableScanRule {
+    async fn check_pattern(&self, expr: Expr, memo: &Memo) -> Vec<PartialPhysicalPlan> {
+        todo!()
+    }
+
+    fn apply(&self, expr: PartialPhysicalPlan) -> Vec<Expr> {
+        todo!()
+    }
+}

optd-types/src/rules/mod.rs

@@ -0,0 +1,5 @@
+//! This module rules.
+
+mod transformation;
+
+mod implementation;

optd-types/src/rules/transformation/join_associativity.rs

@@ -0,0 +1,13 @@
+use super::*;
+
+pub struct JoinAssociativityRule;
+
+impl TransformationRule for JoinAssociativityRule {
+    async fn check_pattern(&self, expr: LogicalExpr, memo: &Memo) -> Vec<PartialLogicalPlan> {
+        todo!()
+    }
+
+    fn apply(&self, expr: PartialLogicalPlan) -> Vec<Expr> {
+        todo!()
+    }
+}

optd-types/src/rules/transformation/join_commutativity.rs

@@ -0,0 +1,13 @@
+use super::*;
+
+pub struct JoinCommutativityRule;
+
+impl TransformationRule for JoinCommutativityRule {
+    async fn check_pattern(&self, expr: LogicalExpr, memo: &Memo) -> Vec<PartialLogicalPlan> {
+        todo!()
+    }
+
+    fn apply(&self, expr: PartialLogicalPlan) -> Vec<Expr> {
+        todo!()
+    }
+}

optd-types/src/rules/transformation/mod.rs

@@ -0,0 +1,35 @@
+use crate::{
+    expression::{relational::logical::LogicalExpr, Expr},
+    memo::Memo,
+    plan::partial_logical_plan::PartialLogicalPlan,
+};
+
+#[allow(dead_code)]
+#[trait_variant::make(Send)]
+pub trait TransformationRule {
+    /// Checks if the transformation rule matches the current expression and its children.
+    /// Returns a vector of partially materialized logical plans.
+    ///
+    /// This returns a vector because the rule matching the input root expression could have matched
+    /// with multiple child expressions.
+    ///
+    /// For example, let's say the input expression is `Filter(G1)`, and the group G1 has two
+    /// expressions `e1 = Join(Join(A, B), C)` and `e2 = Join(A, Join(B, C))`.
+    ///
+    /// If the rule wants to match against `Filter(Join(?L, ?R))`, then this function will partially
+    /// materialize two expressions `Filter(e1)` and `Filter(e2)`. It is then up to the memo table
+    /// API to apply modifications to the partially materialized logical plans (for example, a
+    /// filter pushdown under a `Join`).
+    ///
+    /// TODO: Ideally this should return a `Stream` instead of a fully materialized Vector.
+    async fn check_pattern(&self, expr: LogicalExpr, memo: &Memo) -> Vec<PartialLogicalPlan>;
+
+    /// Applys modifications to a partially materialized logical plan.
+    ///
+    /// These changes can create new logical or scalar expressions. However, note that
+    /// transformation rules will _not_ create new physical expressions.
+    fn apply(&self, expr: PartialLogicalPlan) -> Vec<Expr>;
+}
+
+pub mod join_associativity;
+pub mod join_commutativity;