rename many types

optd-types/src/lib.rs

@@ -1,16 +1,46 @@
 mod memo;
-pub use memo::MemoNode;
+pub use memo::MemoOperator;
 
 /// A type representing a transformation or implementation rule for query operators.
 ///
 /// TODO The variants are just placeholders.
 pub enum Rule {
     Transformation,
-    Implementation
+    Implementation,
 }
 
 pub struct GroupId(usize);
 
+pub struct LogicalExpression;
+
+pub struct PhysicalExpression;
+
+pub struct ScalarExpression;
+
+/// 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 {
+    LogicalExpression(LogicalExpression),
+    ScalarExpression(ScalarExpression),
+    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.
+///
+/// TODO Make this an actual tree with the correct modeling of types.
+pub enum PartialPhysicalExpression {
+    LogicalExpression(LogicalExpression),
+    PhysicalExpression(PhysicalExpression),
+    Scalar(ScalarExpression),
+    GroupId(GroupId),
+}
+
 /// 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

optd-types/src/memo/mod.rs

@@ -1,43 +1,14 @@
-use relation::{LogicalExpression, Relation};
-use scalar::Scalar;
-
-use crate::{GroupId, Rule};
+use crate::{PartialLogicalExpression, PartialPhysicalExpression, Rule};
+use relation::{LogicalOperator, RelationOperator};
+use scalar::ScalarOperator;
 
 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.
-///
-/// TODO Make this an actual tree with the correct modeling of types.
-pub enum PartialPhysicalExpression {
-    LogicalOperator(LogicalOperator),
-    PhysicalOperator(PhysicalOperator),
-    Scalar(Scalar),
-    GroupId(GroupId),
+pub enum MemoOperator {
+    RelationOperator(RelationOperator),
+    ScalarOperator(ScalarOperator),
 }
 
 pub struct Memo;
@@ -54,17 +25,17 @@ 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,
+        expr: LogicalOperator,
         rule: Rule,
     ) -> Vec<PartialLogicalExpression> {
         todo!()
     }
 
     pub async fn check_implementation(
         &self,
-        expr: LogicalExpression,
+        expr: LogicalOperator,
         rule: Rule,
     ) -> Vec<PartialPhysicalExpression> {
         todo!()
@@ -74,19 +45,19 @@ impl Memo {
         &mut self,
         expr: PartialLogicalExpression,
         rule: Rule,
-    ) -> Vec<MemoNode> {
+    ) -> Vec<MemoOperator> {
         todo!()
     }
 
     pub fn apply_implementation(
         &mut self,
         expr: PartialPhysicalExpression,
         rule: Rule,
-    ) -> Vec<MemoNode> {
+    ) -> Vec<MemoOperator> {
         todo!()
     }
 
-    pub fn add_expressions(&mut self, new_exprs: Vec<MemoNode>) {
+    pub fn add_expressions(&mut self, new_exprs: Vec<MemoOperator>) {
         todo!()
     }
 }

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

@@ -1,7 +1,7 @@
 use crate::GroupId;
 
 /// A type representing different kinds of logical expressions / operators.
-pub enum LogicalExpression {
+pub enum LogicalOperator {
     Scan(Scan),
     Filter(Filter),
     Join(Join),

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

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

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

@@ -1,7 +1,7 @@
 use crate::GroupId;
 
 /// A type representing different kinds of physical expressions / operators.
-pub enum PhysicalExpression {
+pub enum PhysicalOperator {
     TableScan(TableScan),
     PhysicalFilter(PhysicalFilter),
     SortMergeJoin(SortMergeJoin),
@@ -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

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