feat: stabilize memo goals (#33)

## Problem

Due to the need to handle physical property, the physical expression is
now organized to be memoized based on an optimization _goal_, which
represents a (group, required_physical_properties) pair instead of a
group alone.

Admittedly, we could share expressions among the different goals for the
same group. However, it is hard to consider sharing expressions for all
potential goals (a different combination of properties). It is likely in
practice we will share an expression only with the default goal (with no
required properties).

## Summary of changes


**Memo**
- stabilize Memo API `create_or_get_goal`, `add_physical_expr_to_goal`,
`get_goal`, and `get_winner_physical_expr_in_goal`.

**Storage**
- A new `goals` table that mimics the `relation_groups` table for
physical optimizations.

_Misc_

-  fix some clippy lints for `optd-dsl`

---------

Signed-off-by: Yuchen Liang <yuchenl3@andrew.cmu.edu>

Author: yliang412

optd-core/src/cascades/expressions.rs

@@ -5,13 +5,14 @@ use crate::operators::scalar::ScalarOperator;
 use crate::{operators::relational::logical::LogicalOperator, values::OptdValue};
 use serde::Deserialize;
 
+use super::goal::GoalId;
 use super::groups::{RelationalGroupId, ScalarGroupId};
 
 /// A logical expression in the memo table.
 pub type LogicalExpression = LogicalOperator<OptdValue, RelationalGroupId, ScalarGroupId>;
 
 /// A physical expression in the memo table.
-pub type PhysicalExpression = PhysicalOperator<OptdValue, RelationalGroupId, ScalarGroupId>;
+pub type PhysicalExpression = PhysicalOperator<OptdValue, GoalId, ScalarGroupId>;
 
 /// A scalar expression in the memo table.
 pub type ScalarExpression = ScalarOperator<OptdValue, ScalarGroupId>;

optd-core/src/cascades/goal.rs

@@ -1,5 +1,7 @@
 use serde::Deserialize;
 
+use super::{groups::RelationalGroupId, properties::PhysicalProperties};
+
 /// A unique identifier for a goal in the memo table.
 #[repr(transparent)]
 #[derive(
@@ -20,7 +22,6 @@ pub struct GoalId(pub i64);
 
 /// The optimization status of a group or a physical expression with a goal in the memo table.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, sqlx::Type)]
-#[repr(i32)]
 pub enum OptimizationStatus {
     /// The group or the physical expression has not been explored.
     Unoptimized,
@@ -32,6 +33,13 @@ pub enum OptimizationStatus {
 
 #[derive(Debug, Clone, PartialEq, sqlx::FromRow)]
 pub struct Goal {
-    pub id: GoalId,
+    /// The identifier of the goal.
+    pub representative_goal_id: GoalId,
+    /// The identifier of the group that the goal is associated with.
+    pub group_id: RelationalGroupId,
+    /// The required physical properties for the goal.
+    #[sqlx(json)]
+    pub required_physical_properties: PhysicalProperties,
+    /// The optimization status of the goal.
     pub optimization_status: OptimizationStatus,
 }

optd-core/src/cascades/groups.rs

@@ -1,5 +1,3 @@
-use serde::Deserialize;
-
 /// A unique identifier for a group of relational expressions in the memo table.
 #[repr(transparent)]
 #[derive(
@@ -13,7 +11,7 @@ use serde::Deserialize;
     Hash,
     sqlx::Type,
     serde::Serialize,
-    Deserialize,
+    serde::Deserialize,
 )]
 #[sqlx(transparent)]
 pub struct RelationalGroupId(pub i64);
@@ -31,14 +29,13 @@ pub struct RelationalGroupId(pub i64);
     Hash,
     sqlx::Type,
     serde::Serialize,
-    Deserialize,
+    serde::Deserialize,
 )]
 #[sqlx(transparent)]
 pub struct ScalarGroupId(pub i64);
 
 /// The exploration status of a group or a logical expression in the memo table.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, sqlx::Type)]
-#[repr(i32)]
 pub enum ExplorationStatus {
     /// The group or the logical expression has not been explored.
     Unexplored,

optd-core/src/cascades/memo.rs

@@ -9,25 +9,30 @@
 
 use std::sync::Arc;
 
+use crate::cost_model::Cost;
+
 use super::{
     expressions::{
         LogicalExpression, LogicalExpressionId, PhysicalExpression, PhysicalExpressionId,
         ScalarExpression, ScalarExpressionId,
     },
-    goal::Goal,
+    goal::{Goal, GoalId},
     groups::{RelationalGroupId, ScalarGroupId},
-    properties::PhysicalProperty,
+    properties::PhysicalProperties,
 };
 use anyhow::Result;
 
 #[trait_variant::make(Send)]
 pub trait Memoize: Send + Sync + 'static {
     /// Creates or get an optimization goal for a group with some required physical properties.
-    async fn create_or_get_relation_group_goal(
+    async fn create_or_get_goal(
         &self,
         group_id: RelationalGroupId,
-        required_physical_props: Vec<PhysicalProperty>,
-    ) -> Result<Goal>;
+        required_physical_props: PhysicalProperties,
+    ) -> Result<GoalId>;
+
+    /// Gets the metadata that describes a goal.
+    async fn get_goal(&self, goal_id: GoalId) -> Result<Arc<Goal>>;
 
     /// Gets all logical expressions in a group.
     async fn get_all_logical_exprs_in_group(
@@ -80,16 +85,26 @@ pub trait Memoize: Send + Sync + 'static {
         to: ScalarGroupId,
     ) -> Result<ScalarGroupId>;
 
-    /// Gets all logical expressions in a group.
-    async fn get_all_physical_exprs_in_group(
+    async fn merge_goal(&self, from: GoalId, to: GoalId) -> Result<GoalId>;
+
+    /// Gets the winner physical expression.
+    async fn get_winner_physical_expr_in_goal(
         &self,
-        group_id: RelationalGroupId,
+        goal_id: GoalId,
+    ) -> Result<Option<(PhysicalExpressionId, Arc<PhysicalExpression>, Cost)>>;
+
+    /// Gets all physical expressions in a goal.
+    async fn get_all_physical_exprs_in_goal(
+        &self,
+        goal_id: GoalId,
     ) -> Result<Vec<(PhysicalExpressionId, Arc<PhysicalExpression>)>>;
 
-    /// Adds a physical expression to an existing group in the memo table.
-    async fn add_physical_expr_to_group(
+    /// Adds a physical expression to a goal in the memo table.
+    // TODO: cost and statistics probably is also added here.
+    async fn add_physical_expr_to_goal(
         &self,
         physical_expr: &PhysicalExpression,
-        group_id: RelationalGroupId,
-    ) -> Result<RelationalGroupId>;
+        cost: Cost,
+        goal_id: GoalId,
+    ) -> Result<GoalId>;
 }