Create st_constraints system table (#225)

* Create st_constraints

* Add constranints to bootstraping

* Clippy

Author: mamcx

crates/core/src/db/datastore/locking_tx_datastore/mod.rs

@@ -1,8 +1,10 @@
 use super::traits::{ColumnSchema, IndexSchema, SequenceId, SequenceSchema, TableId, TableSchema};
+use crate::db::datastore::traits::ConstraintSchema;
 use crate::error::{DBError, TableError};
 use once_cell::sync::Lazy;
 use spacetimedb_lib::auth::{StAccess, StTableType};
-use spacetimedb_sats::{product, AlgebraicType, AlgebraicValue, ProductType, ProductValue};
+use spacetimedb_lib::ColumnIndexAttribute;
+use spacetimedb_sats::{product, AlgebraicType, AlgebraicValue, ArrayValue, ProductType, ProductValue};
 
 /// The static ID of the table that defines tables
 pub(crate) const ST_TABLES_ID: TableId = TableId(0);
@@ -12,20 +14,65 @@ pub(crate) const ST_COLUMNS_ID: TableId = TableId(1);
 pub(crate) const ST_SEQUENCES_ID: TableId = TableId(2);
 /// The static ID of the table that defines indexes
 pub(crate) const ST_INDEXES_ID: TableId = TableId(3);
+/// The static ID of the table that defines constraints
+pub(crate) const ST_CONSTRAINTS_ID: TableId = TableId(4);
 
 pub(crate) const ST_TABLES_NAME: &str = "st_table";
 pub(crate) const ST_COLUMNS_NAME: &str = "st_columns";
 pub(crate) const ST_SEQUENCES_NAME: &str = "st_sequence";
 pub(crate) const ST_INDEXES_NAME: &str = "st_indexes";
+pub(crate) const ST_CONSTRAINTS_NAME: &str = "st_constraints";
 
 pub(crate) const TABLE_ID_SEQUENCE_ID: SequenceId = SequenceId(0);
 pub(crate) const SEQUENCE_ID_SEQUENCE_ID: SequenceId = SequenceId(1);
 pub(crate) const INDEX_ID_SEQUENCE_ID: SequenceId = SequenceId(2);
+pub(crate) const CONSTRAINT_ID_SEQUENCE_ID: SequenceId = SequenceId(3);
 
 pub(crate) const ST_TABLE_ID_INDEX_ID: u32 = 0;
 pub(crate) const ST_TABLE_NAME_INDEX_ID: u32 = 3;
 pub(crate) const ST_INDEX_ID_INDEX_ID: u32 = 1;
 pub(crate) const ST_SEQUENCE_ID_INDEX_ID: u32 = 2;
+pub(crate) const ST_CONSTRAINT_ID_INDEX_ID: u32 = 4;
+pub(crate) const ST_CONSTRAINT_ID_INDEX_HACK: u32 = 5;
+pub(crate) struct SystemTables {}
+
+impl SystemTables {
+    pub(crate) fn tables() -> [TableSchema; 5] {
+        [
+            st_table_schema(),
+            st_columns_schema(),
+            st_sequences_schema(),
+            st_indexes_schema(),
+            st_constraints_schema(),
+        ]
+    }
+
+    pub(crate) fn total_tables() -> usize {
+        Self::tables().len()
+    }
+
+    pub(crate) fn total_indexes() -> usize {
+        Self::tables().iter().flat_map(|x| x.indexes.iter()).count()
+    }
+
+    pub(crate) fn total_constraints_indexes() -> usize {
+        Self::tables()
+            .iter()
+            .flat_map(|x| x.constraints.iter().filter(|x| x.kind != ColumnIndexAttribute::UNSET))
+            .count()
+    }
+
+    pub(crate) fn total_sequences() -> usize {
+        Self::tables()
+            .iter()
+            .flat_map(|x| x.columns.iter().filter(|x| x.is_autoinc))
+            .count()
+    }
+
+    pub(crate) fn total_constraints() -> usize {
+        Self::tables().iter().flat_map(|x| x.constraints.iter()).count()
+    }
+}
 
 // WARNING: In order to keep a stable schema, don't change the discriminant of the fields
 #[derive(Debug)]
@@ -55,7 +102,7 @@ pub enum StColumnFields {
     ColId = 1,
     ColType = 2,
     ColName = 3,
-    ColIndexAttribute = 4,
+    IsAutoInc = 4,
 }
 
 impl StColumnFields {
@@ -66,7 +113,7 @@ impl StColumnFields {
             Self::ColId => "col_id",
             Self::ColType => "col_type",
             Self::ColName => "col_name",
-            Self::ColIndexAttribute => "col_idx_attr",
+            Self::IsAutoInc => "is_autoinc",
         }
     }
 }
@@ -125,6 +172,29 @@ impl StSequenceFields {
     }
 }
 
+// WARNING: In order to keep a stable schema, don't change the discriminant of the fields
+#[derive(Debug)]
+pub enum StConstraintFields {
+    ConstraintId = 0,
+    ConstraintName = 1,
+    Kind = 2,
+    TableId = 3,
+    Columns = 4,
+}
+
+impl StConstraintFields {
+    pub fn name(&self) -> &'static str {
+        // WARNING: Don't change the name of the fields
+        match self {
+            Self::ConstraintId => "constraint_id",
+            Self::ConstraintName => "constraint_name",
+            Self::Kind => "kind",
+            Self::TableId => "table_id",
+            Self::Columns => "columns",
+        }
+    }
+}
+
 /// System Table [ST_TABLES_NAME]
 ///
 /// | table_id: u32 | table_name: String | table_type: String | table_access: String |
@@ -180,6 +250,7 @@ pub fn st_table_schema() -> TableSchema {
                 is_autoinc: false,
             },
         ],
+        constraints: vec![],
         table_type: StTableType::System,
         table_access: StAccess::Public,
     }
@@ -202,40 +273,48 @@ pub fn st_columns_schema() -> TableSchema {
             // TODO(cloutiertyler): (table_id, col_id) should be have a unique constraint
             ColumnSchema {
                 table_id: ST_COLUMNS_ID.0,
-                col_id: 0,
-                col_name: "table_id".into(),
+                col_id: StColumnFields::TableId as u32,
+                col_name: StColumnFields::TableId.name().to_string(),
                 col_type: AlgebraicType::U32,
                 is_autoinc: false,
             },
             ColumnSchema {
                 table_id: ST_COLUMNS_ID.0,
-                col_id: 1,
-                col_name: "col_id".into(),
+                col_id: StColumnFields::ColId as u32,
+                col_name: StColumnFields::ColId.name().to_string(),
                 col_type: AlgebraicType::U32,
                 is_autoinc: false,
             },
             ColumnSchema {
                 table_id: ST_COLUMNS_ID.0,
-                col_id: 2,
-                col_name: "col_type".into(),
+                col_id: StColumnFields::ColType as u32,
+                col_name: StColumnFields::ColType.name().to_string(),
                 col_type: AlgebraicType::bytes(),
                 is_autoinc: false,
             },
             ColumnSchema {
                 table_id: ST_COLUMNS_ID.0,
-                col_id: 3,
-                col_name: "col_name".into(),
+                col_id: StColumnFields::ColName as u32,
+                col_name: StColumnFields::ColName.name().to_string(),
                 col_type: AlgebraicType::String,
                 is_autoinc: false,
             },
             ColumnSchema {
                 table_id: ST_COLUMNS_ID.0,
-                col_id: 4,
-                col_name: "is_autoinc".into(),
+                col_id: StColumnFields::IsAutoInc as u32,
+                col_name: StColumnFields::IsAutoInc.name().to_string(),
                 col_type: AlgebraicType::Bool,
                 is_autoinc: false,
             },
         ],
+        constraints: vec![ConstraintSchema {
+            constraint_id: ST_CONSTRAINT_ID_INDEX_HACK,
+            constraint_name: "ct_columns_table_id".to_string(),
+            kind: ColumnIndexAttribute::INDEXED,
+            table_id: ST_COLUMNS_ID.0,
+            //TODO: Change to multi-columns when PR for it land: StColumnFields::ColId as u32
+            columns: vec![StColumnFields::TableId as u32],
+        }],
         table_type: StTableType::System,
         table_access: StAccess::Public,
     }
@@ -298,6 +377,7 @@ pub fn st_indexes_schema() -> TableSchema {
                 is_autoinc: false,
             },
         ],
+        constraints: vec![],
         table_type: StTableType::System,
         table_access: StAccess::Public,
     }
@@ -388,6 +468,7 @@ pub(crate) fn st_sequences_schema() -> TableSchema {
                 is_autoinc: false,
             },
         ],
+        constraints: vec![],
         table_type: StTableType::System,
         table_access: StAccess::Public,
     }
@@ -396,6 +477,69 @@ pub(crate) fn st_sequences_schema() -> TableSchema {
 pub static ST_SEQUENCE_ROW_TYPE: Lazy<ProductType> =
     Lazy::new(|| ProductType::from_iter(st_sequences_schema().columns.iter().map(|c| c.col_type.clone())));
 
+/// System Table [ST_CONSTRAINTS_NAME]
+///
+/// | constraint_id | constraint_name      | kind | table_id | columns |
+/// |---------------|-------------------- -|-----------|-------|-----------|
+/// | 1             | "unique_customer_id" | 1         | 100   | [1, 4]        |
+pub(crate) fn st_constraints_schema() -> TableSchema {
+    TableSchema {
+        table_id: ST_CONSTRAINTS_ID.0,
+        table_name: ST_CONSTRAINTS_NAME.into(),
+        // TODO: Unique constraint on sequence name?
+        indexes: vec![IndexSchema {
+            index_id: ST_CONSTRAINT_ID_INDEX_ID,
+            table_id: ST_CONSTRAINTS_ID.0,
+            col_id: 0,
+            index_name: "constraint_id_idx".into(),
+            is_unique: true,
+        }],
+        columns: vec![
+            ColumnSchema {
+                table_id: ST_CONSTRAINTS_ID.0,
+                col_id: StConstraintFields::ConstraintId as u32,
+                col_name: StConstraintFields::ConstraintId.name().into(),
+                col_type: AlgebraicType::U32,
+                is_autoinc: true,
+            },
+            ColumnSchema {
+                table_id: ST_CONSTRAINTS_ID.0,
+                col_id: StConstraintFields::ConstraintName as u32,
+                col_name: StConstraintFields::ConstraintName.name().into(),
+                col_type: AlgebraicType::String,
+                is_autoinc: false,
+            },
+            ColumnSchema {
+                table_id: ST_CONSTRAINTS_ID.0,
+                col_id: StConstraintFields::Kind as u32,
+                col_name: StConstraintFields::Kind.name().into(),
+                col_type: AlgebraicType::U32,
+                is_autoinc: false,
+            },
+            ColumnSchema {
+                table_id: ST_CONSTRAINTS_ID.0,
+                col_id: StConstraintFields::TableId as u32,
+                col_name: StConstraintFields::TableId.name().into(),
+                col_type: AlgebraicType::U32,
+                is_autoinc: false,
+            },
+            ColumnSchema {
+                table_id: ST_CONSTRAINTS_ID.0,
+                col_id: StConstraintFields::Columns as u32,
+                col_name: StConstraintFields::Columns.name().into(),
+                col_type: AlgebraicType::array(AlgebraicType::U32),
+                is_autoinc: false,
+            },
+        ],
+        constraints: vec![],
+        table_type: StTableType::System,
+        table_access: StAccess::Public,
+    }
+}
+
+pub static ST_CONSTRAINT_ROW_TYPE: Lazy<ProductType> =
+    Lazy::new(|| ProductType::from_iter(st_constraints_schema().columns.iter().map(|c| c.col_type.clone())));
+
 pub(crate) fn table_name_is_system(table_name: &str) -> bool {
     table_name.starts_with("st_")
 }
@@ -497,7 +641,7 @@ impl<'a> TryFrom<&'a ProductValue> for StColumnRow<&'a str> {
             AlgebraicType::decode(&mut &bytes[..]).map_err(|e| TableError::InvalidSchema(table_id, e.into()))?;
 
         let col_name = row.field_as_str(StColumnFields::ColName as usize, None)?;
-        let is_autoinc = row.field_as_bool(StColumnFields::ColIndexAttribute as usize, None)?;
+        let is_autoinc = row.field_as_bool(StColumnFields::IsAutoInc as usize, None)?;
 
         Ok(StColumnRow {
             table_id,
@@ -660,3 +804,61 @@ impl<'a> From<&StSequenceRow<&'a str>> for SequenceSchema {
         }
     }
 }
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct StConstraintRow<Name: AsRef<str>> {
+    pub(crate) constraint_id: u32,
+    pub(crate) constraint_name: Name,
+    pub(crate) kind: ColumnIndexAttribute,
+    pub(crate) table_id: u32,
+    pub(crate) columns: Vec<u32>,
+}
+
+impl StConstraintRow<&str> {
+    pub fn to_owned(&self) -> StConstraintRow<String> {
+        StConstraintRow {
+            constraint_id: self.constraint_id,
+            constraint_name: self.constraint_name.to_string(),
+            kind: self.kind,
+            table_id: self.table_id,
+            columns: self.columns.clone(),
+        }
+    }
+}
+
+impl<'a> TryFrom<&'a ProductValue> for StConstraintRow<&'a str> {
+    type Error = DBError;
+    fn try_from(row: &'a ProductValue) -> Result<StConstraintRow<&'a str>, DBError> {
+        let constraint_id = row.field_as_u32(StConstraintFields::ConstraintId as usize, None)?;
+        let constraint_name = row.field_as_str(StConstraintFields::ConstraintName as usize, None)?;
+        let kind = row.field_as_u8(StConstraintFields::Kind as usize, None)?;
+        let kind = ColumnIndexAttribute::try_from(kind).expect("Fail to decode ColumnIndexAttribute");
+        let table_id = row.field_as_u32(StConstraintFields::TableId as usize, None)?;
+        let columns = row.field_as_array(StConstraintFields::Columns as usize, None)?;
+        let columns = if let ArrayValue::U32(x) = columns {
+            x.clone()
+        } else {
+            panic!()
+        };
+
+        Ok(StConstraintRow {
+            constraint_id,
+            constraint_name,
+            kind,
+            table_id,
+            columns,
+        })
+    }
+}
+
+impl<Name: AsRef<str>> From<&StConstraintRow<Name>> for ProductValue {
+    fn from(x: &StConstraintRow<Name>) -> Self {
+        product![
+            AlgebraicValue::U32(x.constraint_id),
+            AlgebraicValue::String(x.constraint_name.as_ref().to_string()),
+            AlgebraicValue::U8(x.kind.bits()),
+            AlgebraicValue::U32(x.table_id),
+            AlgebraicValue::ArrayOf(x.columns.clone())
+        ]
+    }
+}

crates/core/src/db/datastore/system_tables.rs

@@ -2,7 +2,7 @@ use crate::db::relational_db::ST_TABLES_ID;
 use core::fmt;
 use spacetimedb_lib::auth::{StAccess, StTableType};
 use spacetimedb_lib::relation::{DbTable, FieldName, FieldOnly, Header, TableField};
-use spacetimedb_lib::DataKey;
+use spacetimedb_lib::{ColumnIndexAttribute, DataKey};
 use spacetimedb_sats::{AlgebraicType, AlgebraicValue, ProductType, ProductTypeElement, ProductValue};
 use spacetimedb_vm::expr::SourceExpr;
 use std::{ops::RangeBounds, sync::Arc};
@@ -158,12 +158,31 @@ impl From<ColumnSchema> for ColumnDef {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConstraintSchema {
+    pub(crate) constraint_id: u32,
+    pub(crate) constraint_name: String,
+    pub(crate) kind: ColumnIndexAttribute,
+    pub(crate) table_id: u32,
+    pub(crate) columns: Vec<u32>,
+}
+
+/// This type is just the [ConstraintSchema] without the autoinc fields
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConstraintDef {
+    pub(crate) constraint_name: String,
+    pub(crate) kind: ColumnIndexAttribute,
+    pub(crate) table_id: u32,
+    pub(crate) columns: Vec<u32>,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct TableSchema {
     pub(crate) table_id: u32,
     pub(crate) table_name: String,
     pub(crate) columns: Vec<ColumnSchema>,
     pub(crate) indexes: Vec<IndexSchema>,
+    pub(crate) constraints: Vec<ConstraintSchema>,
     pub(crate) table_type: StTableType,
     pub(crate) table_access: StAccess,
 }

crates/core/src/db/datastore/traits.rs

@@ -614,7 +614,7 @@ pub(crate) mod tests {
                 table_id: 2,
                 col_id: 0,
                 increment: 1,
-                start: 3,
+                start: 4,
                 min_value: 1,
                 max_value: 4294967295,
                 allocated: 4096,