Update SQL AST in accordance with the SQL spec (#1623)

Co-authored-by: joshua-spacetime <josh@clockworklabs.io>

Author: mamcx

Cargo.lock

@@ -20,6 +20,7 @@ members = [
   "crates/sdk",
   "crates/snapshot",
   "crates/sqltest",
+  "crates/sql-parser",
   "crates/standalone",
   "crates/table",
   "crates/testing",
@@ -100,6 +101,7 @@ spacetimedb-primitives = { path = "crates/primitives", version = "0.12.0" }
 spacetimedb-sats = { path = "crates/sats", version = "0.12.0" }
 spacetimedb-schema = { path = "crates/schema", version = "0.12.0" }
 spacetimedb-standalone = { path = "crates/standalone", version = "0.12.0" }
+spacetimedb-sql-parser = { path = "crates/sql-parser", version = "0.12.0" }
 spacetimedb-table = { path = "crates/table", version = "0.12.0" }
 spacetimedb-vm = { path = "crates/vm", version = "0.12.0" }
 spacetimedb-fs-utils = { path = "crates/fs-utils", version = "0.12.0" }
@@ -247,14 +249,14 @@ wasmtime = { version = "15", default-features = false, features = ["cranelift",
 # and reconnecting, from the tracy client to the database.
 # TODO(George): Need to be able to remove "broadcast" in some build configurations.
 tracing-tracy = { version = "0.10.4", features = [
-  "enable",
-  "system-tracing",
-  "context-switch-tracing",
-  "sampling",
-  "code-transfer",
-  "broadcast",
-  "ondemand",
-] }
+   "enable",
+   "system-tracing",
+   "context-switch-tracing",
+   "sampling",
+   "code-transfer",
+   "broadcast",
+   "ondemand",
+ ] }
 
 # Vendor the openssl we rely on, rather than depend on a
 # potentially very old system version.

Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "spacetimedb-sql-parser"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license-file = "LICENSE"
+description = "The SpacetimeDB SQL AST and Parser"
+
+[dependencies]
+derive_more.workspace = true
+sqlparser.workspace = true
+thiserror.workspace = true

crates/sql-parser/Cargo.toml

@@ -0,0 +1,99 @@
+use sqlparser::ast::Ident;
+
+pub mod sql;
+pub mod sub;
+
+/// The FROM clause is either a [RelExpr] or a JOIN
+pub enum SqlFrom<Ast> {
+    Expr(RelExpr<Ast>, Option<SqlIdent>),
+    Join(RelExpr<Ast>, SqlIdent, Vec<SqlJoin<Ast>>),
+}
+
+/// A RelExpr is an expression that produces a relation
+pub enum RelExpr<Ast> {
+    Var(SqlIdent),
+    Ast(Box<Ast>),
+}
+
+/// An inner join in a FROM clause
+pub struct SqlJoin<Ast> {
+    pub expr: RelExpr<Ast>,
+    pub alias: SqlIdent,
+    pub on: Option<SqlExpr>,
+}
+
+/// A projection expression in a SELECT clause
+pub struct ProjectElem(pub SqlExpr, pub Option<SqlIdent>);
+
+/// A SQL SELECT clause
+pub enum Project {
+    /// SELECT *
+    /// SELECT a.*
+    Star(Option<SqlIdent>),
+    /// SELECT a, b
+    Exprs(Vec<ProjectElem>),
+}
+
+/// A scalar SQL expression
+pub enum SqlExpr {
+    /// A constant expression
+    Lit(SqlLiteral),
+    /// Unqualified column ref
+    Var(SqlIdent),
+    /// Qualified column ref
+    Field(SqlIdent, SqlIdent),
+    /// A binary infix expression
+    Bin(Box<SqlExpr>, Box<SqlExpr>, BinOp),
+}
+
+/// A SQL identifier or named reference
+#[derive(Clone)]
+pub struct SqlIdent {
+    pub name: String,
+    pub case_sensitive: bool,
+}
+
+impl From<Ident> for SqlIdent {
+    fn from(value: Ident) -> Self {
+        match value {
+            Ident {
+                value: name,
+                quote_style: None,
+            } => SqlIdent {
+                name,
+                case_sensitive: false,
+            },
+            Ident {
+                value: name,
+                quote_style: Some(_),
+            } => SqlIdent {
+                name,
+                case_sensitive: true,
+            },
+        }
+    }
+}
+
+/// A SQL constant expression
+pub enum SqlLiteral {
+    /// A boolean constant
+    Bool(bool),
+    /// A hex value like 0xFF or x'FF'
+    Hex(String),
+    /// An integer or float value
+    Num(String),
+    /// A string value
+    Str(String),
+}
+
+/// Binary infix operators
+pub enum BinOp {
+    Eq,
+    Ne,
+    Lt,
+    Gt,
+    Lte,
+    Gte,
+    And,
+    Or,
+}

crates/sql-parser/src/ast/mod.rs

@@ -0,0 +1,73 @@
+use super::{Project, SqlExpr, SqlFrom, SqlIdent, SqlLiteral};
+
+/// The AST for the SQL DML and query language
+pub enum SqlAst {
+    /// SELECT ...
+    Query(QueryAst),
+    /// INSERT INTO ...
+    Insert(SqlInsert),
+    /// UPDATE ...
+    Update(SqlUpdate),
+    /// DELETE FROM ...
+    Delete(SqlDelete),
+    /// SET var TO ...
+    Set(SqlSet),
+    /// SHOW var
+    Show(SqlShow),
+}
+
+/// The AST for the SQL query language
+pub struct QueryAst {
+    pub query: SqlSetOp,
+    pub order: Vec<OrderByElem>,
+    pub limit: Option<SqlLiteral>,
+}
+
+/// Set operations in the SQL query language
+pub enum SqlSetOp {
+    /// SELECT
+    Select(SqlSelect),
+    /// ORDER/LIMIT
+    Query(Box<QueryAst>),
+    /// UNION
+    Union(Box<SqlSetOp>, Box<SqlSetOp>, bool),
+    /// EXCEPT
+    Minus(Box<SqlSetOp>, Box<SqlSetOp>, bool),
+}
+
+/// A SELECT statement in the SQL query language
+pub struct SqlSelect {
+    pub project: Project,
+    pub distinct: bool,
+    pub from: SqlFrom<QueryAst>,
+    pub filter: Option<SqlExpr>,
+}
+
+/// ORDER BY cols [ ASC | DESC ]
+pub struct OrderByElem(pub SqlExpr, pub bool);
+
+/// INSERT INTO table cols VALUES literals
+pub struct SqlInsert {
+    pub table: SqlIdent,
+    pub fields: Vec<SqlIdent>,
+    pub values: SqlValues,
+}
+
+/// VALUES literals
+pub struct SqlValues(pub Vec<Vec<SqlLiteral>>);
+
+/// UPDATE table SET cols [ WHERE predicate ]
+pub struct SqlUpdate {
+    pub table: SqlIdent,
+    pub assignments: Vec<SqlSet>,
+    pub filter: Option<SqlExpr>,
+}
+
+/// DELETE FROM table [ WHERE predicate ]
+pub struct SqlDelete(pub SqlIdent, pub Option<SqlExpr>);
+
+/// SET var '=' literal
+pub struct SqlSet(pub SqlIdent, pub SqlLiteral);
+
+/// SHOW var
+pub struct SqlShow(pub SqlIdent);

crates/sql-parser/src/ast/sql.rs

@@ -0,0 +1,17 @@
+use super::{Project, SqlExpr, SqlFrom};
+
+/// The AST for the SQL subscription language
+pub enum SqlAst {
+    Select(SqlSelect),
+    /// UNION ALL
+    Union(Box<SqlAst>, Box<SqlAst>),
+    /// EXCEPT ALL
+    Minus(Box<SqlAst>, Box<SqlAst>),
+}
+
+/// A SELECT statement in the SQL subscription language
+pub struct SqlSelect {
+    pub project: Project,
+    pub from: SqlFrom<SqlAst>,
+    pub filter: Option<SqlExpr>,
+}

crates/sql-parser/src/ast/sub.rs

@@ -0,0 +1,2 @@
+pub mod ast;
+pub mod parser;

crates/sql-parser/src/lib.rs

@@ -0,0 +1,89 @@
+use std::fmt::Display;
+
+use sqlparser::{
+    ast::{BinaryOperator, Expr, ObjectName, Query, Select, SelectItem, SetExpr, TableFactor, TableWithJoins, Value},
+    parser::ParserError,
+};
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum SubscriptionUnsupported {
+    #[error("Unsupported SELECT: {0}")]
+    Select(Select),
+    #[error("Unsupported: {0}")]
+    Feature(String),
+    #[error("Unsupported: Non-SELECT queries")]
+    Dml,
+}
+
+impl SubscriptionUnsupported {
+    pub(crate) fn feature(expr: impl Display) -> Self {
+        Self::Feature(format!("{expr}"))
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum SqlUnsupported {
+    #[error("Unsupported literal expression: {0}")]
+    Literal(Value),
+    #[error("Unsupported LIMIT expression: {0}")]
+    Limit(Expr),
+    #[error("Unsupported expression: {0}")]
+    Expr(Expr),
+    #[error("Unsupported binary operator: {0}")]
+    BinOp(BinaryOperator),
+    #[error("Unsupported projection: {0}")]
+    Projection(SelectItem),
+    #[error("Unsupported FROM expression: {0}")]
+    From(TableFactor),
+    #[error("Unsupported set operation: {0}")]
+    SetOp(SetExpr),
+    #[error("Unsupported INSERT expression: {0}")]
+    Insert(Query),
+    #[error("Unsupported INSERT value: {0}")]
+    InsertValue(Expr),
+    #[error("Unsupported table expression in DELETE: {0}")]
+    DeleteTable(TableWithJoins),
+    #[error("Unsupported column/variable assignment expression: {0}")]
+    Assignment(Expr),
+    #[error("Multi-part names are not supported: {0}")]
+    MultiPartName(ObjectName),
+    #[error("Unsupported: {0}")]
+    Feature(String),
+    #[error("Non-inner joins are not supported")]
+    JoinType,
+    #[error("Implicit joins are not supported")]
+    ImplicitJoins,
+    #[error("Mixed wildcard projections are not supported")]
+    MixedWildcardProject,
+    #[error("Multiple SQL statements are not supported")]
+    MultiStatement,
+    #[error("Multi-table DELETE is not supported")]
+    MultiTableDelete,
+}
+
+impl SqlUnsupported {
+    pub(crate) fn feature(expr: impl Display) -> Self {
+        Self::Feature(format!("{expr}"))
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum SqlRequired {
+    #[error("A FROM clause is required")]
+    From,
+    #[error("Aliases are required for JOIN")]
+    JoinAlias,
+}
+
+#[derive(Error, Debug)]
+pub enum SqlParseError {
+    #[error(transparent)]
+    SqlUnsupported(#[from] SqlUnsupported),
+    #[error(transparent)]
+    SubscriptionUnsupported(#[from] SubscriptionUnsupported),
+    #[error(transparent)]
+    SqlRequired(#[from] SqlRequired),
+    #[error(transparent)]
+    ParserError(#[from] ParserError),
+}