View resolution in sql (#3570)

# Description of Changes

Not many changes were required for the query compiler to be able to
resolve views. This is because the query engine can always assume a view
is materialized and therefore has a backing table. So from the
perspective of the query engine, a view is just another table with one
small caveat: The physical table in the datastore has two internal
metadata columns - `sender` and `arg_id`. These columns are not user
facing and so should be hidden from name resolution/type checking.

# API and ABI breaking changes

None

# Expected complexity level and risk

1.5

# Testing

<!-- Describe any testing you've done, and any testing you'd like your
reviewers to do,
so that you're confident that all the changes work as expected! -->

- [x] SQL type checking tests

Author: joshua-spacetime

crates/core/src/sql/ast.rs

@@ -12,7 +12,7 @@ use spacetimedb_primitives::{ColId, TableId};
 use spacetimedb_sats::{AlgebraicType, AlgebraicValue};
 use spacetimedb_schema::def::error::RelationError;
 use spacetimedb_schema::relation::{ColExpr, FieldName};
-use spacetimedb_schema::schema::{ColumnSchema, TableSchema};
+use spacetimedb_schema::schema::{ColumnSchema, TableOrViewSchema, TableSchema};
 use spacetimedb_vm::errors::ErrorVm;
 use spacetimedb_vm::expr::{Expr, FieldExpr, FieldOp};
 use spacetimedb_vm::operator::{OpCmp, OpLogic, OpQuery};
@@ -503,12 +503,14 @@ impl<T: StateView> SchemaView for SchemaViewer<'_, T> {
             .map(|schema| schema.table_id)
     }
 
-    fn schema_for_table(&self, table_id: TableId) -> Option<Arc<TableSchema>> {
+    fn schema_for_table(&self, table_id: TableId) -> Option<Arc<TableOrViewSchema>> {
         let AuthCtx { owner, caller } = self.auth;
         self.tx
             .get_schema(table_id)
             .filter(|schema| schema.table_access == StAccess::Public || caller == owner)
-            .cloned()
+            .map(Arc::clone)
+            .map(TableOrViewSchema::from)
+            .map(Arc::new)
     }
 
     fn rls_rules_for_table(&self, table_id: TableId) -> anyhow::Result<Vec<Box<str>>> {

crates/core/src/vm.rs

@@ -686,6 +686,7 @@ pub(crate) mod tests {
             TableSchema::new(
                 TableId::SENTINEL,
                 table_name.into(),
+                None,
                 columns,
                 vec![],
                 vec![],

crates/datastore/src/locking_tx_datastore/datastore.rs

@@ -1576,6 +1576,7 @@ mod tests {
         TableSchema::new(
             TableId::SENTINEL,
             "Foo".into(),
+            None,
             cols.into(),
             indices.into(),
             constraints.into(),

crates/datastore/src/locking_tx_datastore/state_view.rs

@@ -123,6 +123,7 @@ pub trait StateView {
         Ok(TableSchema::new(
             table_id,
             table_name,
+            None,
             columns,
             indexes,
             constraints,

crates/expr/src/check.rs

@@ -7,7 +7,7 @@ use crate::expr::{Expr, ProjectList, ProjectName, Relvar};
 use spacetimedb_lib::identity::AuthCtx;
 use spacetimedb_lib::AlgebraicType;
 use spacetimedb_primitives::TableId;
-use spacetimedb_schema::schema::TableSchema;
+use spacetimedb_schema::schema::TableOrViewSchema;
 use spacetimedb_sql_parser::ast::BinOp;
 use spacetimedb_sql_parser::{
     ast::{sub::SqlSelect, SqlFrom, SqlIdent, SqlJoin},
@@ -26,19 +26,19 @@ pub type TypingResult<T> = core::result::Result<T, TypingError>;
 /// A view of the database schema
 pub trait SchemaView {
     fn table_id(&self, name: &str) -> Option<TableId>;
-    fn schema_for_table(&self, table_id: TableId) -> Option<Arc<TableSchema>>;
+    fn schema_for_table(&self, table_id: TableId) -> Option<Arc<TableOrViewSchema>>;
     fn rls_rules_for_table(&self, table_id: TableId) -> anyhow::Result<Vec<Box<str>>>;
 
-    fn schema(&self, name: &str) -> Option<Arc<TableSchema>> {
+    fn schema(&self, name: &str) -> Option<Arc<TableOrViewSchema>> {
         self.table_id(name).and_then(|table_id| self.schema_for_table(table_id))
     }
 }
 
 #[derive(Default)]
-pub struct Relvars(HashMap<Box<str>, Arc<TableSchema>>);
+pub struct Relvars(HashMap<Box<str>, Arc<TableOrViewSchema>>);
 
 impl Deref for Relvars {
-    type Target = HashMap<Box<str>, Arc<TableSchema>>;
+    type Target = HashMap<Box<str>, Arc<TableOrViewSchema>>;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
@@ -116,7 +116,7 @@ pub trait TypeChecker {
         }
     }
 
-    fn type_relvar(tx: &impl SchemaView, name: &str) -> TypingResult<Arc<TableSchema>> {
+    fn type_relvar(tx: &impl SchemaView, name: &str) -> TypingResult<Arc<TableOrViewSchema>> {
         tx.schema(name)
             .ok_or_else(|| Unresolved::table(name))
             .map_err(TypingError::from)
@@ -180,7 +180,7 @@ pub mod test_utils {
     use spacetimedb_primitives::TableId;
     use spacetimedb_schema::{
         def::ModuleDef,
-        schema::{Schema, TableSchema},
+        schema::{Schema, TableOrViewSchema, TableSchema},
     };
     use std::sync::Arc;
 
@@ -205,7 +205,7 @@ pub mod test_utils {
             }
         }
 
-        fn schema_for_table(&self, table_id: TableId) -> Option<Arc<TableSchema>> {
+        fn schema_for_table(&self, table_id: TableId) -> Option<Arc<TableOrViewSchema>> {
             match table_id.idx() {
                 0 => Some((TableId(0), "t")),
                 1 => Some((TableId(1), "s")),
@@ -215,6 +215,8 @@ pub mod test_utils {
                 self.0
                     .table(name)
                     .map(|def| Arc::new(TableSchema::from_module_def(&self.0, def, (), table_id)))
+                    .map(TableOrViewSchema::from)
+                    .map(Arc::new)
             })
         }
 

crates/expr/src/errors.rs

@@ -122,6 +122,12 @@ pub struct DuplicateName(pub String);
 #[error("`filter!` does not support column projections; Must return table rows")]
 pub struct FilterReturnType;
 
+#[derive(Debug, Error)]
+#[error("`{view_name}` is a view; DML on views is not supported")]
+pub struct DmlOnView {
+    pub view_name: Box<str>,
+}
+
 #[derive(Error, Debug)]
 pub enum TypingError {
     #[error(transparent)]
@@ -137,6 +143,8 @@ pub enum TypingError {
     #[error(transparent)]
     ParseError(#[from] SqlParseError),
 
+    #[error(transparent)]
+    DmlOnView(#[from] DmlOnView),
     #[error(transparent)]
     InvalidOp(#[from] InvalidOp),
     #[error(transparent)]

crates/expr/src/expr.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use spacetimedb_lib::{query::Delta, AlgebraicType, AlgebraicValue};
 use spacetimedb_primitives::TableId;
-use spacetimedb_schema::schema::TableSchema;
+use spacetimedb_schema::schema::TableOrViewSchema;
 use spacetimedb_sql_parser::ast::{BinOp, LogOp};
 
 /// A projection is the root of any relational expression.
@@ -42,10 +42,10 @@ impl ProjectName {
         }
     }
 
-    /// The [TableSchema] of the returned rows.
+    /// The [`TableOrViewSchema`] of the returned rows.
     /// Note this expression returns rows from a relvar.
     /// Hence it this method should never return [None].
-    pub fn return_table(&self) -> Option<&TableSchema> {
+    pub fn return_table(&self) -> Option<&TableOrViewSchema> {
         match self {
             Self::None(input) => input.return_table(),
             Self::Some(input, alias) => input.find_table_schema(alias),
@@ -65,7 +65,7 @@ impl ProjectName {
     /// Iterate over the returned column names and types
     pub fn for_each_return_field(&self, mut f: impl FnMut(&str, &AlgebraicType)) {
         if let Some(schema) = self.return_table() {
-            for schema in schema.columns() {
+            for schema in schema.public_columns() {
                 f(&schema.col_name, &schema.col_type);
             }
         }
@@ -148,9 +148,9 @@ pub enum AggType {
 
 impl ProjectList {
     /// Does this expression project a single relvar?
-    /// If so, we return it's [TableSchema].
+    /// If so, we return it's [`TableOrViewSchema`].
     /// If not, it projects a list of columns, so we return [None].
-    pub fn return_table(&self) -> Option<&TableSchema> {
+    pub fn return_table(&self) -> Option<&TableOrViewSchema> {
         match self {
             Self::Name(project) => project.first().and_then(|expr| expr.return_table()),
             Self::Limit(input, _) => input.return_table(),
@@ -205,7 +205,7 @@ pub enum RelExpr {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Relvar {
     /// The table schema of this relvar
-    pub schema: Arc<TableSchema>,
+    pub schema: Arc<TableOrViewSchema>,
     /// The name of this relvar
     pub alias: Box<str>,
     /// Does this relvar represent a delta table?
@@ -259,8 +259,8 @@ impl RelExpr {
         }
     }
 
-    /// Return the [TableSchema] for a relvar in the expression
-    pub fn find_table_schema(&self, alias: &str) -> Option<&TableSchema> {
+    /// Return the [`TableOrViewSchema`] for a relvar in the expression
+    pub fn find_table_schema(&self, alias: &str) -> Option<&TableOrViewSchema> {
         match self {
             Self::RelVar(relvar) if relvar.alias.as_ref() == alias => Some(&relvar.schema),
             Self::Select(input, _) => input.find_table_schema(alias),
@@ -278,8 +278,8 @@ impl RelExpr {
     }
 
     /// Does this expression return a single relvar?
-    /// If so, return it's [TableSchema], otherwise return [None].
-    pub fn return_table(&self) -> Option<&TableSchema> {
+    /// If so, return it's [`TableOrViewSchema`], otherwise return [None].
+    pub fn return_table(&self) -> Option<&TableOrViewSchema> {
         match self {
             Self::RelVar(Relvar { schema, .. }) => Some(schema),
             Self::Select(input, _) => input.return_table(),

crates/expr/src/rls.rs

@@ -476,7 +476,7 @@ mod tests {
     use spacetimedb_primitives::TableId;
     use spacetimedb_schema::{
         def::ModuleDef,
-        schema::{Schema, TableSchema},
+        schema::{Schema, TableOrViewSchema, TableSchema},
     };
     use spacetimedb_sql_parser::ast::BinOp;
 
@@ -499,7 +499,7 @@ mod tests {
             }
         }
 
-        fn schema_for_table(&self, table_id: TableId) -> Option<Arc<TableSchema>> {
+        fn schema_for_table(&self, table_id: TableId) -> Option<Arc<TableOrViewSchema>> {
             match table_id.idx() {
                 0 => Some((TableId(0), "users")),
                 1 => Some((TableId(1), "admins")),
@@ -510,6 +510,8 @@ mod tests {
                 self.0
                     .table(name)
                     .map(|def| Arc::new(TableSchema::from_module_def(&self.0, def, (), table_id)))
+                    .map(TableOrViewSchema::from)
+                    .map(Arc::new)
             })
         }