rename many types

optd-types/src/expression/mod.rs

@@ -0,0 +1,13 @@
+use relation::RelationExpression;
+use scalar::ScalarExpression;
+
+mod relation;
+mod scalar;
+
+pub use relation::{LogicalExpression, PhysicalExpression};
+
+/// A type representing an optimization operator in the memo table.
+pub enum Expression {
+    RelationExpression(RelationExpression),
+    ScalarExpression(ScalarExpression),
+}

optd-types/src/memo/relation/logical_expression.rs → optd-types/src/expression/relation/logical.rs

@@ -1,6 +1,6 @@
 use crate::GroupId;
 
-/// A type representing different kinds of logical expressions / operators.
+/// A type representing different kinds of logical expressions in the memo table.
 pub enum LogicalExpression {
     Scan(Scan),
     Filter(Filter),

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

@@ -0,0 +1,11 @@
+mod logical;
+pub use logical::LogicalExpression;
+
+mod physical;
+pub use physical::PhysicalExpression;
+
+/// A type representing logical or physical expressions in the memo table.
+pub enum RelationExpression {
+    LogicalExpression(LogicalExpression),
+    PhysicalExpression(PhysicalExpression),
+}

optd-types/src/memo/relation/physical_expression.rs → optd-types/src/expression/relation/physical.rs

@@ -1,6 +1,6 @@
 use crate::GroupId;
 
-/// A type representing different kinds of physical expressions / operators.
+/// A type representing different kinds of physical expressions in the memo table.
 pub enum PhysicalExpression {
     TableScan(TableScan),
     PhysicalFilter(PhysicalFilter),
@@ -18,7 +18,6 @@ struct PhysicalFilter {
     predicate: GroupId,
 }
 
-
 struct SortMergeJoin {
     left: GroupId,
     right: GroupId,
@@ -36,4 +35,3 @@ struct MergeSort {
     child: GroupId,
     sort_expr: GroupId,
 }
-

optd-types/src/memo/scalar.rs → optd-types/src/expression/scalar.rs

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

optd-types/src/lib.rs

@@ -1,15 +1,37 @@
+mod expression;
 mod memo;
-pub use memo::MemoNode;
 
-/// A type representing a transformation or implementation rule for query operators.
+pub struct GroupId(usize);
+
+pub struct LogicalOperator;
+
+pub struct PhysicalOperator;
+
+pub struct ScalarOperator;
+
+/// A type representing a tree of logical nodes, scalar nodes, and group IDs.
 ///
-/// TODO The variants are just placeholders.
-pub enum Rule {
-    Transformation,
-    Implementation
+/// Note that group IDs must be leaves of this tree.
+///
+/// TODO Make this an actual tree with the correct modeling of types.
+pub enum PartialLogicalPlan {
+    LogicalOperator(LogicalOperator),
+    ScalarOperator(ScalarOperator),
+    GroupId(GroupId),
 }
 
-pub struct GroupId(usize);
+/// 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 enum PartialPhysicalPlan {
+    LogicalOperator(LogicalOperator),
+    PhysicalOperator(PhysicalOperator),
+    ScalarOperator(ScalarOperator),
+    GroupId(GroupId),
+}
 
 /// An in-memory tree of logical operators. Used as the input / entrypoint of the optimizer.
 ///

optd-types/src/memo/mod.rs

@@ -1,43 +1,12 @@
-use relation::{LogicalExpression, Relation};
-use scalar::Scalar;
+use crate::expression::{Expression, LogicalExpression};
+use crate::{PartialLogicalPlan, PartialPhysicalPlan};
 
-use crate::{GroupId, Rule};
-
-mod relation;
-mod scalar;
-
-/// A type representing an optimization node / object in the memo table.
-pub enum MemoNode {
-    Relation(Relation),
-    Scalar(Scalar),
-}
-
-pub struct LogicalOperator;
-
-pub struct PhysicalOperator;
-
-/// 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 enum PartialLogicalExpression {
-    LogicalOperator(LogicalOperator),
-    Scalar(Scalar),
-    GroupId(GroupId),
-}
-
-/// 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.
+/// A type representing a transformation or implementation rule for query operators.
 ///
-/// TODO Make this an actual tree with the correct modeling of types.
-pub enum PartialPhysicalExpression {
-    LogicalOperator(LogicalOperator),
-    PhysicalOperator(PhysicalOperator),
-    Scalar(Scalar),
-    GroupId(GroupId),
+/// TODO The variants are just placeholders.
+pub enum Rule {
+    Transformation,
+    Implementation,
 }
 
 pub struct Memo;
@@ -54,39 +23,39 @@ impl Memo {
     ///
     /// If the rule wants to match against `Filter(Join(?L, ?R))`, then this function will partially
     /// materialize two expressions `Filter(e1)` and `Filter(e2)`.
-     pub async fn check_transformation(
+    pub async fn check_transformation(
         &self,
         expr: LogicalExpression,
         rule: Rule,
-    ) -> Vec<PartialLogicalExpression> {
+    ) -> Vec<PartialLogicalPlan> {
         todo!()
     }
 
     pub async fn check_implementation(
         &self,
         expr: LogicalExpression,
         rule: Rule,
-    ) -> Vec<PartialPhysicalExpression> {
+    ) -> Vec<PartialPhysicalPlan> {
         todo!()
     }
 
     pub fn apply_transformation(
         &mut self,
-        expr: PartialLogicalExpression,
+        expr: PartialLogicalPlan,
         rule: Rule,
-    ) -> Vec<MemoNode> {
+    ) -> Vec<Expression> {
         todo!()
     }
 
     pub fn apply_implementation(
         &mut self,
-        expr: PartialPhysicalExpression,
+        expr: PartialPhysicalPlan,
         rule: Rule,
-    ) -> Vec<MemoNode> {
+    ) -> Vec<Expression> {
         todo!()
     }
 
-    pub fn add_expressions(&mut self, new_exprs: Vec<MemoNode>) {
+    pub async fn add_expressions(&mut self, new_exprs: Vec<Expression>) {
         todo!()
     }
 }