Type Model (#4)

This PR models almost all of the types that will be necessary for
optimization. This includes:

- generic relational algebra operators that allow us to use the same
"type" for both expressions in the memo table and operators in the plans
- logical / physical plans
- scalar operators and expressions
- partially materialized logical plans for rule binding
- transformation rule + implementation rule trait and some empty structs
that implement them

I've named the crate itself `optd-core`. This can be subject to change,
but I feel this is a reasonable default for now.

~~TODO: need to wait on #3 and #12 to be merged before proper CI checks
can happen~~

Edit: I removed the `cargo rustdoc` check because its creating more
problem than it would solve, see #14

---------

Co-authored-by: Alexis Schlomer <aschlome@andrew.cmu.edu>

Author: connortsui20

.github/workflows/check.yml

@@ -75,23 +75,6 @@ jobs:
   #         components: rustfmt
   #     - name: cargo-semver-checks
   #       uses: obi1kenobi/cargo-semver-checks-action@v2
-  doc:
-    # run docs generation on nightly rather than stable. This enables features like
-    # https://doc.rust-lang.org/beta/unstable-book/language-features/doc-cfg.html which allows an
-    # API be documented as only available in some specific platforms.
-    runs-on: ubuntu-latest
-    name: nightly / doc
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-      - name: Install nightly
-        uses: dtolnay/rust-toolchain@nightly
-      - name: Install cargo-docs-rs
-        uses: dtolnay/install@cargo-docs-rs
-      - name: cargo docs-rs
-        # TODO: Once we figure out the crates, rename this.
-        run: cargo docs-rs -p optd-tmp
   hack:
     # cargo-hack checks combinations of feature flags to ensure that features are all additive
     # which is required for feature unification

Cargo.lock

@@ -1,3 +1,3 @@
 [workspace]
-members = ["optd-tmp"]
+members = ["optd-core"]
 resolver = "2"

Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "optd-core"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+trait-variant = "0.1.2"
+
+# Pin more recent versions for `-Zminimal-versions`.
+proc-macro2 = "1.0.60" # For a missing feature (https://github.com/rust-lang/rust/issues/113152).

optd-core/Cargo.toml

@@ -0,0 +1,17 @@
+//! Types for logical and physical expressions in the optimizer.
+
+use crate::memo::GroupId;
+use crate::operator::relational::logical::LogicalOperator;
+use crate::operator::relational::physical::PhysicalOperator;
+
+/// A logical expression in the memo table.
+///
+/// References children using [`GroupId`]s for expression sharing
+/// and memoization.
+pub type LogicalExpression = LogicalOperator<GroupId, GroupId>;
+
+/// A physical expression in the memo table.
+///
+/// Like [`LogicalExpression`] but with specific implementation
+/// strategies.
+pub type PhysicalExpression = PhysicalOperator<GroupId, GroupId>;

optd-core/src/expression.rs

@@ -0,0 +1,5 @@
+pub mod expression;
+pub mod memo;
+pub mod operator;
+pub mod plan;
+pub mod rules;

optd-core/src/lib.rs

@@ -0,0 +1,65 @@
+//! Memo table implementation for query optimization.
+//!
+//! The memo table is a core data structure that stores expressions and their logical equivalences
+//! during query optimization. It serves two main purposes:
+//!
+//! - Avoiding redundant optimization by memoizing already explored expressions
+//! - Grouping logically equivalent expressions together to enable rule-based optimization
+//!
+//! # Structure
+//!
+//! - Each unique expression is assigned an expression ID (either [`LogicalExpressionId`],
+//!   [`PhysicalExpressionId`], or [`ScalarExpressionId`])
+//! - Logically equivalent expressions are grouped together under a [`GroupId`]
+//! - Logically equivalent scalar expressions are grouped toegether under a [`ScalarGroupId`]
+//!
+//! # Usage
+//!
+//! The memo table provides methods to:
+//! - Add new expressions and get their IDs
+//! - Add expressions to existing groups
+//! - Retrieve expressions in a group
+//! - Look up group membership of expressions
+//! - Create new groups for expressions
+
+use crate::expression::LogicalExpression;
+
+/// A unique identifier for a logical expression in the memo table.
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct LogicalExpressionId(u64);
+
+/// A unique identifier for a physical expression in the memo table.
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct PhysicalExpressionId(u64);
+
+/// A unique identifier for a scalar expression in the memo table.
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ScalarExpressionId(u64);
+
+/// A unique identifier for a group of relational expressions in the memo table.
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct GroupId(u64);
+
+/// A unique identifier for a group of scalar expressions in the memo table.
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ScalarGroupId(u64);
+
+/// TODO(alexis) Add fields & link to storage layer.
+pub struct Memo;
+
+/// TODO(alexis) Stabilize API by first expanding the Python code.
+impl Memo {
+    /// TODO(alexis) Add docs.
+    pub async fn add_logical_expr_to_group(
+        &mut self,
+        _group_id: GroupId,
+        _logical_expr: LogicalExpression,
+    ) -> LogicalExpressionId {
+        todo!()
+    }
+}

optd-core/src/memo.rs

@@ -0,0 +1,5 @@
+//! This module contains type definitions related to query plan operators, both relational (logical
+//! / physical) and scalar.
+
+pub mod relational;
+pub mod scalar;

optd-core/src/operator/mod.rs

@@ -0,0 +1,8 @@
+/// Logical filter operator that selects rows matching a condition.
+///
+/// Takes input relation (`Relation`) and filters rows using a boolean predicate (`Scalar`).
+#[derive(Clone)]
+pub struct Filter<Relation, Scalar> {
+    pub child: Relation,
+    pub predicate: Scalar,
+}

optd-core/src/operator/relational/logical/filter.rs

@@ -0,0 +1,11 @@
+/// Logical join operator that combines rows from two relations.
+///
+/// Takes left and right relations (`Relation`) and joins their rows using a join condition
+/// (`Scalar`).
+#[derive(Clone)]
+pub struct Join<Relation, Scalar> {
+    pub join_type: String,
+    pub left: Relation,
+    pub right: Relation,
+    pub condition: Scalar,
+}