refactor: Add TableId to relvar type (#1803)

Cargo.toml

@@ -11,9 +11,9 @@ members = [
   "crates/core",
   "crates/data-structures",
   "crates/durability",
+  "crates/expr",
   "crates/fs-utils",
   "crates/lib",
-  "crates/planner",
   "crates/metrics",
   "crates/primitives",
   "crates/sats",
@@ -96,10 +96,10 @@ spacetimedb-commitlog = { path = "crates/commitlog", version = "1.0.0-rc1" }
 spacetimedb-core = { path = "crates/core", version = "1.0.0-rc1" }
 spacetimedb-data-structures = { path = "crates/data-structures", version = "1.0.0-rc1" }
 spacetimedb-durability = { path = "crates/durability", version = "1.0.0-rc1" }
+spacetimedb-expr = { path = "crates/expr", version = "1.0.0-rc1" }
 spacetimedb-lib = { path = "crates/lib", default-features = false, version = "1.0.0-rc1" }
 spacetimedb-metrics = { path = "crates/metrics", version = "1.0.0-rc1" }
 spacetimedb-primitives = { path = "crates/primitives", version = "1.0.0-rc1" }
-spacetimedb-query-planner = { path = "crates/planner", version = "1.0.0-rc1" }
 spacetimedb-sats = { path = "crates/sats", version = "1.0.0-rc1" }
 spacetimedb-schema = { path = "crates/schema", version = "1.0.0-rc1" }
 spacetimedb-standalone = { path = "crates/standalone", version = "1.0.0-rc1" }

crates/core/Cargo.toml

@@ -27,7 +27,7 @@ spacetimedb-schema.workspace = true
 spacetimedb-table.workspace = true
 spacetimedb-vm.workspace = true
 spacetimedb-snapshot.workspace = true
-spacetimedb-query-planner.workspace = true
+spacetimedb-expr.workspace = true
 
 anyhow = { workspace = true, features = ["backtrace"] }
 arrayvec.workspace = true

crates/core/src/error.rs

@@ -4,7 +4,7 @@ use std::path::PathBuf;
 use std::sync::{MutexGuard, PoisonError};
 
 use hex::FromHexError;
-use spacetimedb_query_planner::logical::errors::TypingError;
+use spacetimedb_expr::errors::TypingError;
 use spacetimedb_sats::AlgebraicType;
 use spacetimedb_schema::error::ValidationErrors;
 use spacetimedb_snapshot::SnapshotError;

crates/core/src/sql/ast.rs

@@ -1,13 +1,13 @@
 use crate::db::relational_db::{MutTx, RelationalDB, Tx};
 use crate::error::{DBError, PlanError};
 use spacetimedb_data_structures::map::{HashCollectionExt as _, IntMap};
+use spacetimedb_expr::check::SchemaView;
+use spacetimedb_expr::statement::parse_and_type_sql;
 use spacetimedb_lib::db::auth::StAccess;
 use spacetimedb_lib::db::error::RelationError;
 use spacetimedb_lib::identity::AuthCtx;
 use spacetimedb_lib::relation::{ColExpr, FieldName};
 use spacetimedb_primitives::ColId;
-use spacetimedb_query_planner::logical::bind::SchemaView;
-use spacetimedb_query_planner::logical::stmt::parse_and_type_sql;
 use spacetimedb_sats::{AlgebraicType, AlgebraicValue};
 use spacetimedb_schema::schema::{ColumnSchema, TableSchema};
 use spacetimedb_vm::errors::ErrorVm;
@@ -480,7 +480,7 @@ pub struct SchemaViewer<'a, T> {
 }
 
 impl<T: TableSchemaView> SchemaView for SchemaViewer<'_, T> {
-    fn schema(&self, name: &str, _: bool) -> Option<Arc<TableSchema>> {
+    fn schema(&self, name: &str) -> Option<Arc<TableSchema>> {
         let name = name.to_owned().into_boxed_str();
         let schema = self
             .tx

crates/core/src/subscription/module_subscription_actor.rs

@@ -15,9 +15,10 @@ use crate::vm::check_row_limit;
 use crate::worker_metrics::WORKER_METRICS;
 use parking_lot::RwLock;
 use spacetimedb_client_api_messages::websocket::FormatSwitch;
+use spacetimedb_expr::check::parse_and_type_sub;
+use spacetimedb_expr::ty::TyCtx;
 use spacetimedb_lib::identity::AuthCtx;
 use spacetimedb_lib::Identity;
-use spacetimedb_query_planner::logical::bind::parse_and_type_sub;
 use spacetimedb_vm::errors::ErrorVm;
 use spacetimedb_vm::expr::AuthAccess;
 use std::time::Duration;
@@ -88,7 +89,11 @@ impl ModuleSubscriptions {
             } else {
                 // NOTE: The following ensures compliance with the 1.0 sql api.
                 // Come 1.0, it will have replaced the current compilation stack.
-                parse_and_type_sub(sql, &SchemaViewer::new(&self.relational_db, &*tx, &auth))?;
+                parse_and_type_sub(
+                    &mut TyCtx::default(),
+                    sql,
+                    &SchemaViewer::new(&self.relational_db, &*tx, &auth),
+                )?;
 
                 let mut compiled = compile_read_only_query(&self.relational_db, &auth, &tx, sql)?;
                 // Note that no error path is needed here.
@@ -249,9 +254,9 @@ mod tests {
     use crate::error::DBError;
     use crate::execution_context::ExecutionContext;
     use spacetimedb_client_api_messages::websocket::Subscribe;
+    use spacetimedb_expr::errors::{TypingError, Unresolved};
     use spacetimedb_lib::db::auth::StAccess;
     use spacetimedb_lib::{error::ResultTest, AlgebraicType, Identity};
-    use spacetimedb_query_planner::logical::errors::{TypingError, Unresolved};
     use spacetimedb_sats::product;
     use std::time::Instant;
     use std::{sync::Arc, time::Duration};

crates/planner/Cargo.toml → crates/expr/Cargo.toml

@@ -1,8 +1,10 @@
 [package]
-name = "spacetimedb-query-planner"
+name = "spacetimedb-expr"
 version.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license-file = "LICENSE"
+description = "The logical expression representation for the SpacetimeDB query engine"
 
 [dependencies]
 derive_more.workspace = true

crates/planner/src/logical/bind.rs → crates/expr/src/check.rs

@@ -5,24 +5,26 @@ use spacetimedb_sql_parser::{
     ast::{
         self,
         sub::{SqlAst, SqlSelect},
-        SqlFrom,
+        SqlFrom, SqlIdent, SqlJoin,
     },
     parser::sub::parse_subscription,
 };
 
+use crate::ty::TyId;
+
 use super::{
     assert_eq_types,
     errors::{DuplicateName, TypingError, Unresolved, Unsupported},
     expr::{Expr, Let, RelExpr},
-    ty::{Symbol, TyCtx, TyEnv, TyId, Type},
+    ty::{Symbol, TyCtx, TyEnv},
     type_expr, type_proj, type_select,
 };
 
 /// The result of type checking and name resolution
 pub type TypingResult<T> = core::result::Result<T, TypingError>;
 
 pub trait SchemaView {
-    fn schema(&self, name: &str, case_sensitive: bool) -> Option<Arc<TableSchema>>;
+    fn schema(&self, name: &str) -> Option<Arc<TableSchema>>;
 }
 
 pub trait TypeChecker {
@@ -40,12 +42,12 @@ pub trait TypeChecker {
     ) -> TypingResult<(RelExpr, Option<Symbol>)> {
         match from {
             SqlFrom::Expr(expr, None) => Self::type_rel(ctx, expr, tx),
-            SqlFrom::Expr(expr, Some(alias)) => {
+            SqlFrom::Expr(expr, Some(SqlIdent(alias))) => {
                 let (expr, _) = Self::type_rel(ctx, expr, tx)?;
-                let symbol = ctx.gen_symbol(alias.name);
+                let symbol = ctx.gen_symbol(alias);
                 Ok((expr, Some(symbol)))
             }
-            SqlFrom::Join(r, alias, joins) => {
+            SqlFrom::Join(r, SqlIdent(alias), joins) => {
                 // The type environment with which to type the join expressions
                 let mut env = TyEnv::default();
                 // The lowered inputs to the join operator
@@ -57,33 +59,37 @@ pub trait TypeChecker {
 
                 let input = Self::type_rel(ctx, r, tx)?.0;
                 let ty = input.ty_id();
-                let name = ctx.gen_symbol(alias.name);
+                let name = ctx.gen_symbol(alias);
 
                 env.add(name, ty);
                 inputs.push(input);
                 types.push((name, ty));
 
-                for join in joins {
-                    let input = Self::type_rel(ctx, join.expr, tx)?.0;
+                for SqlJoin {
+                    expr,
+                    alias: SqlIdent(alias),
+                    on,
+                } in joins
+                {
+                    let input = Self::type_rel(ctx, expr, tx)?.0;
                     let ty = input.ty_id();
-                    let name = ctx.gen_symbol(&join.alias.name);
+                    let name = ctx.gen_symbol(&alias);
 
                     // New join variable is now in scope
                     if env.add(name, ty).is_some() {
-                        return Err(DuplicateName(join.alias.name).into());
+                        return Err(DuplicateName(alias.into_string()).into());
                     }
 
                     inputs.push(input);
                     types.push((name, ty));
 
                     // Type check join expression with current type environment
-                    if let Some(on) = join.on {
+                    if let Some(on) = on {
                         exprs.push(type_expr(ctx, &env, on, Some(TyId::BOOL))?);
                     }
                 }
 
-                let ty = Type::Row(types.clone().into_boxed_slice());
-                let ty = ctx.add(ty);
+                let ty = ctx.add_row_type(types.clone());
                 let input = RelExpr::Join(inputs.into(), ty);
                 let vars = types
                     .into_iter()
@@ -101,21 +107,19 @@ pub trait TypeChecker {
         tx: &impl SchemaView,
     ) -> TypingResult<(RelExpr, Option<Symbol>)> {
         match expr {
-            ast::RelExpr::Var(var) => {
+            ast::RelExpr::Var(SqlIdent(var)) => {
                 let schema = tx
-                    .schema(&var.name, var.case_sensitive)
-                    .ok_or_else(|| Unresolved::table(&var.name))
+                    .schema(&var)
+                    .ok_or_else(|| Unresolved::table(&var))
                     .map_err(TypingError::from)?;
                 let mut types = Vec::new();
                 for ColumnSchema { col_name, col_type, .. } in schema.columns() {
-                    let ty = Type::Alg(col_type.clone());
-                    let id = ctx.add(ty);
+                    let id = ctx.add_algebraic_type(col_type);
                     let name = ctx.gen_symbol(col_name);
                     types.push((name, id));
                 }
-                let ty = Type::Var(types.into_boxed_slice());
-                let id = ctx.add(ty);
-                let symbol = ctx.gen_symbol(var.name);
+                let id = ctx.add_var_type(schema.table_id, types);
+                let symbol = ctx.gen_symbol(var);
                 Ok((RelExpr::RelVar(schema, id), Some(symbol)))
             }
             ast::RelExpr::Ast(ast) => Ok((Self::type_ast(ctx, *ast, tx)?, None)),
@@ -170,10 +174,9 @@ impl TypeChecker for SubChecker {
 }
 
 /// Parse and type check a subscription query
-pub fn parse_and_type_sub(sql: &str, tx: &impl SchemaView) -> TypingResult<RelExpr> {
-    let mut ctx = TyCtx::default();
-    let expr = SubChecker::type_ast(&mut ctx, parse_subscription(sql)?, tx)?;
-    expect_table_type(&ctx, expr)
+pub fn parse_and_type_sub(ctx: &mut TyCtx, sql: &str, tx: &impl SchemaView) -> TypingResult<RelExpr> {
+    let expr = SubChecker::type_ast(ctx, parse_subscription(sql)?, tx)?;
+    expect_table_type(ctx, expr)
 }
 
 /// Returns an error if the input type is not a table type or relvar
@@ -192,6 +195,8 @@ mod tests {
     };
     use std::sync::Arc;
 
+    use crate::ty::TyCtx;
+
     use super::{parse_and_type_sub, SchemaView};
 
     fn module_def() -> ModuleDef {
@@ -222,7 +227,7 @@ mod tests {
     struct SchemaViewer(ModuleDef);
 
     impl SchemaView for SchemaViewer {
-        fn schema(&self, name: &str, _: bool) -> Option<Arc<TableSchema>> {
+        fn schema(&self, name: &str) -> Option<Arc<TableSchema>> {
             self.0.table(name).map(|def| {
                 Arc::new(TableSchema::from_module_def(
                     &self.0,
@@ -253,7 +258,7 @@ mod tests {
             "select * from (select t.* from t join (select u32 as a from s) s on t.u32 = s.a)",
             "select * from (select * from t union all select * from t)",
         ] {
-            let result = parse_and_type_sub(sql, &tx);
+            let result = parse_and_type_sub(&mut TyCtx::default(), sql, &tx);
             assert!(result.is_ok());
         }
     }
@@ -294,7 +299,7 @@ mod tests {
             // Union arguments are of different types
             "select * from (select * from t union all select * from s)",
         ] {
-            let result = parse_and_type_sub(sql, &tx);
+            let result = parse_and_type_sub(&mut TyCtx::default(), sql, &tx);
             assert!(result.is_err());
         }
     }

crates/planner/src/logical/errors.rs → crates/expr/src/errors.rs

@@ -2,7 +2,7 @@ use spacetimedb_sql_parser::{ast::BinOp, parser::errors::SqlParseError};
 use thiserror::Error;
 
 use super::{
-    stmt::InvalidVar,
+    statement::InvalidVar,
     ty::{InvalidTypeId, TypeWithCtx},
 };
 

crates/planner/src/logical/expr.rs → crates/expr/src/expr.rs

@@ -112,9 +112,8 @@ impl Expr {
     }
 
     /// Returns a string literal
-    pub fn str(v: String) -> Self {
-        let s = v.into_boxed_str();
-        Self::Lit(AlgebraicValue::String(s), TyId::STR)
+    pub fn str(v: Box<str>) -> Self {
+        Self::Lit(AlgebraicValue::String(v), TyId::STR)
     }
 
     /// The type id of this expression