huge refactor of persistent memo implementation

This commit completely refactors the memo table, removing the `Memo`
trait and instead placing all methods directly on the `PersistentMemo`
structure itself.

This also cleans up some code in other places.

Author: connortsui20

optd-mvp/src/entities/prelude.rs

@@ -1,5 +1,7 @@
 //! `SeaORM` Entity, @generated by sea-orm-codegen 1.1.0
 
+#![allow(unused_imports)]
+
 pub use super::cascades_group::Entity as CascadesGroup;
 pub use super::fingerprint::Entity as Fingerprint;
 pub use super::logical_children::Entity as LogicalChildren;

optd-mvp/src/expression/logical_expression.rs

@@ -4,31 +4,34 @@
 //! FIXME: Representation needs to know how to "rewrite" child group IDs to whatever a fingerprint
 //! will need.
 //!
-//! TODO figure out if each relation should be in a different submodule.
+//! TODO Remove dead code.
+//! TODO Figure out if each relation should be in a different submodule.
 //! TODO This entire file is a WIP.
 
+#![allow(dead_code)]
+
 use crate::entities::*;
 use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum LogicalExpression {
     Scan(Scan),
     Filter(Filter),
     Join(Join),
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct Scan {
     table_schema: String,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct Filter {
     child: i32,
     expression: String,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct Join {
     left: i32,
     right: i32,
@@ -94,24 +97,24 @@ pub use build::*;
 #[cfg(test)]
 mod build {
     use super::*;
-    use crate::expression::Expression;
+    use crate::expression::LogicalExpression;
 
-    pub fn scan(table_schema: String) -> Expression {
-        Expression::Logical(LogicalExpression::Scan(Scan { table_schema }))
+    pub fn scan(table_schema: String) -> LogicalExpression {
+        LogicalExpression::Scan(Scan { table_schema })
     }
 
-    pub fn filter(child_group: i32, expression: String) -> Expression {
-        Expression::Logical(LogicalExpression::Filter(Filter {
+    pub fn filter(child_group: i32, expression: String) -> LogicalExpression {
+        LogicalExpression::Filter(Filter {
             child: child_group,
             expression,
-        }))
+        })
     }
 
-    pub fn join(left_group: i32, right_group: i32, expression: String) -> Expression {
-        Expression::Logical(LogicalExpression::Join(Join {
+    pub fn join(left_group: i32, right_group: i32, expression: String) -> LogicalExpression {
+        LogicalExpression::Join(Join {
             left: left_group,
             right: right_group,
             expression,
-        }))
+        })
     }
 }

optd-mvp/src/expression/physical_expression.rs

@@ -2,31 +2,34 @@
 //!
 //! FIXME: All fields are placeholders, and group IDs are just represented as i32 for now.
 //!
-//! TODO figure out if each operator should be in a different submodule.
+//! TODO Remove dead code.
+//! TODO Figure out if each operator should be in a different submodule.
 //! TODO This entire file is a WIP.
 
+#![allow(dead_code)]
+
 use crate::entities::*;
 use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum PhysicalExpression {
     TableScan(TableScan),
     Filter(PhysicalFilter),
     HashJoin(HashJoin),
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct TableScan {
     table_schema: String,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct PhysicalFilter {
     child: i32,
     expression: String,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct HashJoin {
     left: i32,
     right: i32,
@@ -92,24 +95,24 @@ pub use build::*;
 #[cfg(test)]
 mod build {
     use super::*;
-    use crate::expression::Expression;
+    use crate::expression::PhysicalExpression;
 
-    pub fn table_scan(table_schema: String) -> Expression {
-        Expression::Physical(PhysicalExpression::TableScan(TableScan { table_schema }))
+    pub fn table_scan(table_schema: String) -> PhysicalExpression {
+        PhysicalExpression::TableScan(TableScan { table_schema })
     }
 
-    pub fn filter(child_group: i32, expression: String) -> Expression {
-        Expression::Physical(PhysicalExpression::Filter(PhysicalFilter {
+    pub fn filter(child_group: i32, expression: String) -> PhysicalExpression {
+        PhysicalExpression::Filter(PhysicalFilter {
             child: child_group,
             expression,
-        }))
+        })
     }
 
-    pub fn hash_join(left_group: i32, right_group: i32, expression: String) -> Expression {
-        Expression::Physical(PhysicalExpression::HashJoin(HashJoin {
+    pub fn hash_join(left_group: i32, right_group: i32, expression: String) -> PhysicalExpression {
+        PhysicalExpression::HashJoin(HashJoin {
             left: left_group,
             right: right_group,
             expression,
-        }))
+        })
     }
 }

optd-mvp/src/memo/interface.rs

@@ -3,7 +3,31 @@
 //!
 //! TODO more docs.
 
-mod persistent;
+use thiserror::Error;
+
+/// A new type of an integer identifying a unique group.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct GroupId(i32);
+
+/// A new type of an integer identifying a unique logical expression.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct LogicalExpressionId(i32);
 
-mod interface;
-pub use interface::{Memo, MemoError};
+/// A new type of an integer identifying a unique physical expression.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct PhysicalExpressionId(i32);
+
+/// The different kinds of errors that might occur while running operations on a memo table.
+#[derive(Error, Debug)]
+pub enum MemoError {
+    #[error("unknown group ID {0:?}")]
+    UnknownGroup(GroupId),
+    #[error("unknown logical expression ID {0:?}")]
+    UnknownLogicalExpression(LogicalExpressionId),
+    #[error("unknown physical expression ID {0:?}")]
+    UnknownPhysicalExpression(PhysicalExpressionId),
+    #[error("invalid expression encountered")]
+    InvalidExpression,
+}
+
+mod persistent;