Allow converting new ModuleDef to old TableSchema (#1630)

Author: kazimuth

Cargo.lock

@@ -155,6 +155,7 @@ fn serialize_benchmarks<
         );
     });
 
+    #[allow(deprecated)]
     let mut table = spacetimedb_table::table::Table::new(
         TableSchema::from_def(0.into(), RawTableDefV8::from_product(name, T::product_type().clone())).into(),
         spacetimedb_table::indexes::SquashedOffset::COMMITTED_STATE,

crates/bench/benches/special.rs

@@ -267,6 +267,7 @@ pub fn autogen_csharp_tuple(ctx: &GenCtx, name: &str, tuple: &ProductType, names
     autogen_csharp_product_table_common(ctx, name, tuple, None, namespace)
 }
 
+#[allow(deprecated)]
 pub fn autogen_csharp_table(ctx: &GenCtx, table: &TableDesc, namespace: &str) -> String {
     let tuple = ctx.typespace[table.data].as_product().unwrap();
     autogen_csharp_product_table_common(

crates/cli/src/subcommands/generate/csharp.rs

@@ -324,6 +324,7 @@ fn find_product_type(ctx: &GenCtx, ty: AlgebraicTypeRef) -> &ProductType {
 
 /// Generate a file which defines a `struct` corresponding to the `table`'s `ProductType`,
 /// and implements `spacetimedb_sdk::table::TableType` for it.
+#[allow(deprecated)]
 pub fn autogen_rust_table(ctx: &GenCtx, table: &TableDesc) -> String {
     let mut output = CodeIndenter::new(String::new());
     let out = &mut output;
@@ -847,6 +848,7 @@ fn print_spacetime_module_struct_defn(ctx: &GenCtx, out: &mut Indenter, items: &
 /// Define the `handle_table_update` method,
 /// which dispatches on the table name in a `TableUpdate` message
 /// to call an appropriate method on the `ClientCache`.
+#[allow(deprecated)]
 fn print_handle_table_update_defn(_ctx: &GenCtx, out: &mut Indenter, items: &[GenItem]) {
     out.delimited_block(
         "fn handle_table_update(&self, table_update: TableUpdate, client_cache: &mut ClientCache, callbacks: &mut RowCallbackReminders) {",

crates/cli/src/subcommands/generate/rust.rs

@@ -498,6 +498,7 @@ fn typescript_field_name(field_name: String) -> String {
 pub fn autogen_typescript_tuple(ctx: &GenCtx, name: &str, tuple: &ProductType) -> String {
     autogen_typescript_product_table_common(ctx, name, tuple, None)
 }
+#[allow(deprecated)]
 pub fn autogen_typescript_table(ctx: &GenCtx, table: &TableDesc) -> String {
     let tuple = ctx.typespace[table.data].as_product().unwrap();
     autogen_typescript_product_table_common(

crates/cli/src/subcommands/generate/typescript.rs

@@ -84,6 +84,7 @@ impl MutTxId {
             return Err(TableError::System(table_schema.table_name.clone()).into());
         }
 
+        #[allow(deprecated)]
         TableSchema::from_def(0.into(), table_schema.clone())
             .validated()
             .map_err(|err| DBError::Schema(SchemaErrors(err)))?;
@@ -111,6 +112,7 @@ impl MutTxId {
             .read_col(StTableFields::TableId)?;
 
         // Generate the full definition of the table, with the generated indexes, constraints, sequences...
+        #[allow(deprecated)]
         let table_schema = TableSchema::from_def(table_id, table_schema);
 
         // Insert the columns into `st_columns`
@@ -346,6 +348,7 @@ impl MutTxId {
             .read_col(StIndexFields::IndexId)?;
 
         // Construct the index schema.
+        #[allow(deprecated)]
         let mut index = IndexSchema::from_def(table_id, index.clone());
         index.index_id = index_id;
 
@@ -637,6 +640,7 @@ impl MutTxId {
         // TODO: Can we return early here?
 
         let (table, ..) = self.get_or_create_insert_table_mut(table_id)?;
+        #[allow(deprecated)]
         let mut constraint = ConstraintSchema::from_def(table_id, constraint);
         constraint.constraint_id = constraint_id;
         // This won't clone-write when creating a table but likely to otherwise.

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

@@ -245,6 +245,7 @@ st_fields_enum!(enum StScheduledFields {
 /// |----------|-------------|----------- |------------- |
 /// | 4        | "customers" | "user"     | "public"     |
 fn st_table_schema() -> TableSchema {
+    #[allow(deprecated)]
     TableSchema::from_def(
         ST_TABLE_ID,
         RawTableDefV8::new(
@@ -268,6 +269,7 @@ fn st_table_schema() -> TableSchema {
 /// |----------|---------|----------|--------------------|
 /// | 1        | 0       | "id"     | AlgebraicType::U32 |
 fn st_column_schema() -> TableSchema {
+    #[allow(deprecated)]
     TableSchema::from_def(
         ST_COLUMN_ID,
         RawTableDefV8::new(
@@ -293,6 +295,7 @@ fn st_column_schema() -> TableSchema {
 /// |----------|----------|-------------|---------|-----------|------------|
 /// | 1        |          | "ix_sample" | [1]     | false     | "btree"    |
 fn st_index_schema() -> TableSchema {
+    #[allow(deprecated)]
     TableSchema::from_def(
         ST_INDEX_ID,
         RawTableDefV8::new(
@@ -318,6 +321,7 @@ fn st_index_schema() -> TableSchema {
 /// |-------------|-------------------|-----------|-------|-----------|-----------|----------|--------|-----------|
 /// | 1           | "seq_customer_id" | 1         | 100   | 10        | 1200      | 1        | 1      | 200       |
 fn st_sequence_schema() -> TableSchema {
+    #[allow(deprecated)]
     TableSchema::from_def(
         ST_SEQUENCE_ID,
         RawTableDefV8::new(
@@ -346,6 +350,7 @@ fn st_sequence_schema() -> TableSchema {
 /// |---------------|-------------------- -|-------------|-------|------------|
 /// | 1             | "unique_customer_id" | 1           | 100   | [1, 4]     |
 fn st_constraint_schema() -> TableSchema {
+    #[allow(deprecated)]
     TableSchema::from_def(
         ST_CONSTRAINT_ID,
         RawTableDefV8::new(
@@ -381,6 +386,7 @@ fn st_constraint_schema() -> TableSchema {
 /// |------------------|----------------|---------------|---------------|---------------------|
 /// | <bytes>          | <bytes>        |  0            | <bytes>       | <bytes>             |
 pub(crate) fn st_module_schema() -> TableSchema {
+    #[allow(deprecated)]
     TableSchema::from_def(
         ST_MODULE_ID,
         RawTableDefV8::new(
@@ -403,6 +409,7 @@ pub(crate) fn st_module_schema() -> TableSchema {
 // -----------------------------------------------------------------------------------------+--------------------------------------------------------
 //  (__identity_bytes = 0x7452047061ea2502003412941d85a42f89b0702588b823ab55fc4f12e9ea8363) | (__address_bytes = 0x6bdea3ab517f5857dc9b1b5fe99e1b14)
 fn st_client_schema() -> TableSchema {
+    #[allow(deprecated)]
     TableSchema::from_def(
         ST_CLIENT_ID,
         RawTableDefV8::new(
@@ -418,6 +425,7 @@ fn st_client_schema() -> TableSchema {
 }
 
 fn st_scheduled_schema() -> TableSchema {
+    #[allow(deprecated)]
     TableSchema::from_def(
         ST_SCHEDULED_ID,
         RawTableDefV8::new(
@@ -438,6 +446,7 @@ fn st_scheduled_schema() -> TableSchema {
 /// |-------------|-----------|
 /// | "row_limit" | (U64 = 5) |
 pub fn st_var_schema() -> TableSchema {
+    #[allow(deprecated)]
     TableSchema::from_def(
         ST_VAR_ID,
         RawTableDefV8::new(

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

@@ -213,6 +213,7 @@ pub fn schema_updates(
                 known_schema.table_access,
                 known_schema.scheduled.clone(),
             );
+            #[allow(deprecated)]
             let proposed_schema = TableSchema::from_def(known_schema.table_id, proposed_schema_def);
 
             let (schema_is_incompatible, known_schema, proposed_schema) =
@@ -438,6 +439,7 @@ mod tests {
 
     #[test]
     fn test_updates_schema_mismatch() {
+        #[allow(deprecated)]
         let current = [Arc::new(TableSchema::from_def(
             42.into(),
             RawTableDefV8::new(
@@ -468,6 +470,7 @@ mod tests {
 
     #[test]
     fn test_updates_orphaned_table() {
+        #[allow(deprecated)]
         let current = [Arc::new(TableSchema::from_def(
             42.into(),
             RawTableDefV8::new(
@@ -498,6 +501,7 @@ mod tests {
                 col_type: AlgebraicType::String,
             }],
         );
+        #[allow(deprecated)]
         let current = [Arc::new(TableSchema::from_def(42.into(), table_def.clone()))];
         let proposed = vec![table_def.with_column_index(ColId(0), false)];
 
@@ -548,6 +552,7 @@ mod tests {
 
     #[test]
     fn test_updates_add_constraint() {
+        #[allow(deprecated)]
         let current = [Arc::new(TableSchema::from_def(
             42.into(),
             RawTableDefV8::new(
@@ -572,6 +577,7 @@ mod tests {
 
     #[test]
     fn test_updates_drop_constraint() {
+        #[allow(deprecated)]
         let current = [Arc::new(TableSchema::from_def(
             42.into(),
             RawTableDefV8::new(

crates/core/src/db/update.rs

@@ -408,34 +408,30 @@ impl RawModuleDefV9Builder {
     }
 
     /// Build a new table with a product type.
-    ///
-    /// This is a convenience method for tests, since in real modules, the product type is initialized via the `SpacetimeType` trait.
-    #[cfg(feature = "test")]
-    pub fn build_table_for_tests(
+    /// Adds the type to the module.
+    pub fn build_table_with_new_type(
         &mut self,
         table_name: impl Into<RawIdentifier>,
         product_type: spacetimedb_sats::ProductType,
         custom_ordering: bool,
     ) -> RawTableDefBuilder {
         let table_name = table_name.into();
-        let product_type_ref = self.add_type_for_tests([], table_name.clone(), product_type.into(), custom_ordering);
+        let product_type_ref = self.add_algebraic_type([], table_name.clone(), product_type.into(), custom_ordering);
 
         self.build_table(table_name, product_type_ref)
     }
 
     /// Add a type to the typespace, along with a type alias declaring its name.
+    /// This method should only be use for `AlgebraicType`s not corresponding to a Rust
+    /// type that implements `SpacetimeType`.
     ///
     /// Returns a reference to the newly-added type.
     ///
     /// NOT idempotent, calling this twice with the same name will cause errors during
     /// validation.
     ///
     /// You must set `custom_ordering` if you're not using the default element ordering.
-    ///
-    /// This is a convenience method for tests, since in real modules, types are added to the
-    /// typespace via the `SpacetimeType` trait.
-    #[cfg(feature = "test")]
-    pub fn add_type_for_tests(
+    pub fn add_algebraic_type(
         &mut self,
         scope: impl IntoIterator<Item = RawIdentifier>,
         name: impl Into<RawIdentifier>,

crates/lib/src/db/raw_def/v9.rs

@@ -211,6 +211,13 @@ impl Constraints {
         Self::new(self.attr | other.attr)
     }
 
+    /// Add auto-increment constraint to the existing constraints.
+    /// Returns Err if the result would not be valid.
+    #[allow(clippy::result_unit_err)]
+    pub fn push_auto_inc(self) -> Result<Self, ()> {
+        Self::try_from(self.attr | ColumnAttribute::AUTO_INC)
+    }
+
     /// Returns the bits representing the constraints.
     pub const fn bits(&self) -> u8 {
         self.attr.bits()