Printer for the plan, ie: EXPLAIN

* Improve output of plan
* Fix print of alias and the output of joins
* Allow the test utils of the plan to be used elsewhere
* Use the arrow only for nodes, make timing optional
* Apply new clippy hints and remove old test logic

Cargo.toml

@@ -155,6 +155,7 @@ enum-as-inner = "0.6"
 enum-map = "2.6.3"
 env_logger = "0.10"
 ethnum = { version = "1.5.0", features = ["serde"] }
+expect-test = "1.5.0"
 flate2 = "1.0.24"
 fs-err = "2.9.0"
 fs2 = "0.4.3"

crates/core/Cargo.toml

@@ -50,6 +50,7 @@ derive_more.workspace = true
 dirs.workspace = true
 enum-as-inner.workspace = true
 enum-map.workspace = true
+expect-test.workspace = true
 flate2.workspace = true
 fs2.workspace = true
 futures.workspace = true

crates/core/src/sql/ast.rs

@@ -977,7 +977,7 @@ pub(crate) fn compile_to_ast<T: TableSchemaView + StateView>(
 ) -> Result<Vec<SqlAst>, DBError> {
     // NOTE: The following ensures compliance with the 1.0 sql api.
     // Come 1.0, it will have replaced the current compilation stack.
-    compile_sql_stmt(sql_text, &SchemaViewer::new(tx, auth))?;
+    compile_sql_stmt(sql_text, &SchemaViewer::new(tx, auth), false)?;
 
     let dialect = PostgreSqlDialect {};
     let ast = Parser::parse_sql(&dialect, sql_text).map_err(|error| DBError::SqlParser {

crates/expr/src/check.rs

@@ -165,11 +165,17 @@ pub fn type_subscription(ast: SqlSelect, tx: &impl SchemaView) -> TypingResult<P
 }
 
 /// Parse and type check a *subscription* query into a `StatementCtx`
-pub fn compile_sql_sub<'a>(sql: &'a str, tx: &impl SchemaView) -> TypingResult<StatementCtx<'a>> {
+pub fn compile_sql_sub<'a>(sql: &'a str, tx: &impl SchemaView, with_timings: bool) -> TypingResult<StatementCtx<'a>> {
+    let planning_time = if with_timings {
+        Some(std::time::Instant::now())
+    } else {
+        None
+    };
     Ok(StatementCtx {
         statement: Statement::Select(ProjectList::Name(parse_and_type_sub(sql, tx)?)),
         sql,
         source: StatementSource::Subscription,
+        planning_time: planning_time.map(|t| t.elapsed()),
     })
 }
 

crates/expr/src/lib.rs

@@ -305,6 +305,7 @@ pub(crate) fn parse(value: &str, ty: &AlgebraicType) -> anyhow::Result<Algebraic
 }
 
 /// The source of a statement
+#[derive(Debug, Clone, Copy)]
 pub enum StatementSource {
     Subscription,
     Query,
@@ -317,4 +318,5 @@ pub struct StatementCtx<'a> {
     pub statement: Statement,
     pub sql: &'a str,
     pub source: StatementSource,
+    pub planning_time: Option<std::time::Duration>,
 }

crates/expr/src/statement.rs

@@ -419,12 +419,18 @@ pub fn parse_and_type_sql(sql: &str, tx: &impl SchemaView) -> TypingResult<State
 }
 
 /// Parse and type check a *general* query into a [StatementCtx].
-pub fn compile_sql_stmt<'a>(sql: &'a str, tx: &impl SchemaView) -> TypingResult<StatementCtx<'a>> {
+pub fn compile_sql_stmt<'a>(sql: &'a str, tx: &impl SchemaView, with_timings: bool) -> TypingResult<StatementCtx<'a>> {
+    let planning_time = if with_timings {
+        Some(std::time::Instant::now())
+    } else {
+        None
+    };
     let statement = parse_and_type_sql(sql, tx)?;
     Ok(StatementCtx {
         statement,
         sql,
         source: StatementSource::Query,
+        planning_time: planning_time.map(|t| t.elapsed()),
     })
 }
 

crates/physical-plan/Cargo.toml

@@ -9,6 +9,8 @@ description = "The physical query plan for the SpacetimeDB query engine"
 [dependencies]
 anyhow.workspace = true
 derive_more.workspace = true
+expect-test.workspace = true
+itertools.workspace = true
 spacetimedb-lib.workspace = true
 spacetimedb-primitives.workspace = true
 spacetimedb-schema.workspace = true

crates/physical-plan/src/compile.rs

@@ -5,8 +5,10 @@ use std::collections::HashMap;
 use crate::dml::{DeletePlan, MutationPlan, UpdatePlan};
 use crate::plan::{HashJoin, Label, PhysicalExpr, PhysicalPlan, ProjectListPlan, ProjectPlan, Semi, TupleField};
 
+use crate::{PhysicalCtx, PlanCtx};
 use spacetimedb_expr::expr::{Expr, FieldProject, LeftDeepJoin, ProjectList, ProjectName, RelExpr, Relvar};
-use spacetimedb_expr::statement::DML;
+use spacetimedb_expr::statement::{Statement, DML};
+use spacetimedb_expr::StatementCtx;
 
 pub trait VarLabel {
     fn label(&mut self, name: &str) -> Label;
@@ -121,6 +123,12 @@ struct NamesToIds {
     map: HashMap<String, usize>,
 }
 
+impl NamesToIds {
+    fn into_map(self) -> HashMap<String, usize> {
+        self.map
+    }
+}
+
 impl VarLabel for NamesToIds {
     fn label(&mut self, name: &str) -> Label {
         if let Some(id) = self.map.get(name) {
@@ -143,7 +151,11 @@ pub fn compile_select(project: ProjectName) -> ProjectPlan {
 /// Note, this utility is applicable to a generic selections.
 /// In particular, it supports explicit column projections.
 pub fn compile_select_list(project: ProjectList) -> ProjectListPlan {
-    compile_project_list(&mut NamesToIds::default(), project)
+    compile_select_list_raw(&mut NamesToIds::default(), project)
+}
+
+pub fn compile_select_list_raw(var: &mut impl VarLabel, project: ProjectList) -> ProjectListPlan {
+    compile_project_list(var, project)
 }
 
 /// Converts a logical DML statement into a physical plan,
@@ -155,3 +167,19 @@ pub fn compile_dml_plan(stmt: DML) -> MutationPlan {
         DML::Update(update) => MutationPlan::Update(UpdatePlan::compile(update)),
     }
 }
+
+pub fn compile(ast: StatementCtx<'_>) -> PhysicalCtx<'_> {
+    let mut vars = NamesToIds::default();
+    let plan = match ast.statement {
+        Statement::Select(project) => PlanCtx::ProjectList(compile_select_list_raw(&mut vars, project)),
+        Statement::DML(stmt) => PlanCtx::DML(compile_dml_plan(stmt)),
+    };
+
+    PhysicalCtx {
+        plan,
+        sql: ast.sql,
+        vars: vars.into_map(),
+        source: ast.source,
+        planning_time: None,
+    }
+}

crates/physical-plan/src/dml.rs

@@ -12,6 +12,7 @@ use spacetimedb_schema::schema::TableSchema;
 use crate::{compile::compile_select, plan::ProjectPlan};
 
 /// A plan for mutating a table in the database
+#[derive(Debug)]
 pub enum MutationPlan {
     Insert(InsertPlan),
     Delete(DeletePlan),
@@ -30,6 +31,7 @@ impl MutationPlan {
 }
 
 /// A plan for inserting rows into a table
+#[derive(Debug)]
 pub struct InsertPlan {
     pub table: Arc<TableSchema>,
     pub rows: Vec<ProductValue>,
@@ -44,6 +46,7 @@ impl From<TableInsert> for InsertPlan {
 }
 
 /// A plan for deleting rows from a table
+#[derive(Debug)]
 pub struct DeletePlan {
     pub table: Arc<TableSchema>,
     pub filter: ProjectPlan,
@@ -77,6 +80,7 @@ impl DeletePlan {
 }
 
 /// A plan for updating rows in a table
+#[derive(Debug)]
 pub struct UpdatePlan {
     pub table: Arc<TableSchema>,
     pub columns: Vec<(ColId, AlgebraicValue)>,

crates/physical-plan/src/lib.rs

@@ -1,4 +1,46 @@
+use crate::dml::MutationPlan;
+use crate::plan::ProjectListPlan;
+use anyhow::Result;
+use spacetimedb_expr::StatementSource;
+use std::collections::HashMap;
+
 pub mod compile;
 pub mod dml;
 pub mod plan;
+pub mod printer;
 pub mod rules;
+
+#[derive(Debug)]
+pub enum PlanCtx {
+    ProjectList(ProjectListPlan),
+    DML(MutationPlan),
+}
+
+impl PlanCtx {
+    pub(crate) fn optimize(self) -> Result<PlanCtx> {
+        Ok(match self {
+            Self::ProjectList(plan) => Self::ProjectList(plan.optimize()?),
+            Self::DML(plan) => Self::DML(plan.optimize()?),
+        })
+    }
+}
+
+/// A physical context for the result of a query compilation.
+#[derive(Debug)]
+pub struct PhysicalCtx<'a> {
+    pub plan: PlanCtx,
+    pub sql: &'a str,
+    // A map from table names to their labels
+    pub vars: HashMap<String, usize>,
+    pub source: StatementSource,
+    pub planning_time: Option<std::time::Duration>,
+}
+
+impl PhysicalCtx<'_> {
+    pub fn optimize(self) -> Result<Self> {
+        Ok(Self {
+            plan: self.plan.optimize()?,
+            ..self
+        })
+    }
+}