Case conversion

crates/bench/src/spacetime_raw.rs

@@ -56,6 +56,7 @@ impl BenchDatabase for SpacetimeRaw {
                             index_algorithm: IndexAlgorithm::BTree(BTreeAlgorithm {
                                 columns: ColId(0).into(),
                             }),
+                            alias: None,
                         },
                         true,
                     )?;
@@ -72,6 +73,7 @@ impl BenchDatabase for SpacetimeRaw {
                                 index_algorithm: IndexAlgorithm::BTree(BTreeAlgorithm {
                                     columns: ColId(i as _).into(),
                                 }),
+                                alias: None,
                             },
                             false,
                         )?;

crates/bindings-csharp/Codegen/Module.cs

@@ -387,10 +387,10 @@ public TableIndex(ColumnRef col, AttributeData data, DiagReporter diag)
     public static bool CanParse(AttributeData data) =>
         data.AttributeClass?.ToString() == BTreeAttrName;
 
-    public string GenerateIndexDef() =>
+    public string GenerateIndexDef(TableAccessor tableAccessor) =>
         $$"""
             new(
-                SourceName: null,
+                SourceName: "{{StandardIndexName(tableAccessor)}}",
                 AccessorName: "{{AccessorName}}",
                 Algorithm: new SpacetimeDB.Internal.RawIndexAlgorithm.{{Type}}([{{string.Join(
                     ", ",
@@ -744,7 +744,7 @@ public IEnumerable<GeneratedTableAccessor> GenerateTableAccessors()
                             GetConstraints(v, ColumnAttrs.Unique)
                             .Select(c => c.ToIndex())
                             .Concat(GetIndexes(v))
-                            .Select(b => b.GenerateIndexDef())
+                            .Select(b => b.GenerateIndexDef(v))
                         )}}}
                     ],
                     Constraints: {{{GenConstraintList(v, ColumnAttrs.Unique, $"{iTable}.MakeUniqueConstraint")}}},

crates/bindings-typescript/src/lib/indexes.ts

@@ -9,7 +9,7 @@ import type { ColumnIsUnique } from './constraints';
  * existing column names are referenced.
  */
 export type IndexOpts<AllowedCol extends string> = {
-  name?: string;
+  accessor?: string;
 } & (
   | { algorithm: 'btree'; columns: readonly AllowedCol[] }
   | { algorithm: 'hash'; columns: readonly AllowedCol[] }

crates/bindings-typescript/src/lib/schema.ts

@@ -89,7 +89,7 @@ export function tableToSchema<
 
   type AllowedCol = keyof T['rowType']['row'] & string;
   return {
-    sourceName: schema.tableName ?? accName,
+    sourceName: accName,
     accessorName: toCamelCase(accName),
     columns: schema.rowType.row, // typed as T[i]['rowType']['row'] under TablesToSchema<T>
     rowType: schema.rowSpacetimeType,
@@ -188,6 +188,12 @@ export class ModuleContext {
         value: module.rowLevelSecurity,
       }
     );
+    push(
+      module.explicitNames && {
+        tag: 'ExplicitNames',
+        value: module.explicitNames,
+      }
+    );
     return { sections };
   }
 

crates/bindings-typescript/src/lib/table.ts

@@ -131,7 +131,7 @@ export type TableIndexes<TableDef extends UntypedTableDef> = {
     ? never
     : K]: ColumnIndex<K, TableDef['columns'][K]['columnMetadata']>;
 } & {
-  [I in TableDef['indexes'][number] as I['name'] & {}]: TableIndexFromDef<
+  [I in TableDef['indexes'][number] as I['accessor'] & {}]: TableIndexFromDef<
     TableDef,
     I
   >;
@@ -145,7 +145,7 @@ type TableIndexFromDef<
     keyof TableDef['columns'] & string
   >
     ? {
-        name: I['name'];
+        name: I['accessor'];
         unique: AllUnique<TableDef, Cols>;
         algorithm: Lowercase<I['algorithm']>;
         columns: Cols;
@@ -425,7 +425,7 @@ export function table<Row extends RowObj, const Opts extends TableOpts<Row>>(
     // the name and accessor name of an index across all SDKs.
     indexes.push({
       sourceName: undefined,
-      accessorName: indexOpts.name,
+      accessorName: indexOpts.accessor,
       algorithm,
     });
   }
@@ -442,15 +442,6 @@ export function table<Row extends RowObj, const Opts extends TableOpts<Row>>(
     }
   }
 
-  for (const index of indexes) {
-    const cols =
-      index.algorithm.tag === 'Direct'
-        ? [index.algorithm.value]
-        : index.algorithm.value;
-    const colS = cols.map(i => colNameList[i]).join('_');
-    index.sourceName = `${name}_${colS}_idx_${index.algorithm.tag.toLowerCase()}`;
-  }
-
   const productType = row.algebraicType.value as RowBuilder<
     CoerceRow<Row>
   >['algebraicType']['value'];
@@ -469,8 +460,20 @@ export function table<Row extends RowObj, const Opts extends TableOpts<Row>>(
       if (row.typeName === undefined) {
         row.typeName = toPascalCase(tableName);
       }
+
+      // Build index source names using accName
+      for (const index of indexes) {
+        const cols =
+          index.algorithm.tag === 'Direct'
+            ? [index.algorithm.value]
+            : index.algorithm.value;
+
+        const colS = cols.map(i => colNameList[i]).join('_');
+        index.sourceName = `${accName}_${colS}_idx_${index.algorithm.tag.toLowerCase()}`;
+      }
+
       return {
-        sourceName: tableName,
+        sourceName: accName,
         productTypeRef: ctx.registerTypesRecursively(row).ref,
         primaryKey: pk,
         indexes,

crates/bindings-typescript/src/sdk/table_cache.ts

@@ -92,7 +92,7 @@ export class TableCacheImpl<
         keyof TableDefForTableName<RemoteModule, TableName>['columns'] & string
       >;
       const index = this.#makeReadonlyIndex(this.tableDef, idxDef);
-      (this as any)[idx.name!] = index;
+      (this as any)[idx.accessor!] = index;
     }
   }
 

crates/bindings-typescript/src/server/schema.test-d.ts

@@ -7,17 +7,17 @@ const person = table(
     // name: 'person',
     indexes: [
       {
-        name: 'id_name_idx',
+        accessor: 'id_name_idx',
         algorithm: 'btree',
         columns: ['id', 'name'] as const,
       },
       {
-        name: 'id_name2_idx',
+        accessor: 'id_name2_idx',
         algorithm: 'btree',
         columns: ['id', 'name2'] as const,
       },
       {
-        name: 'name_idx',
+        accessor: 'name_idx',
         algorithm: 'btree',
         columns: ['name'] as const,
       },

crates/bindings-typescript/src/server/schema.ts

@@ -540,6 +540,15 @@ export function schema<const H extends Record<string, UntypedTableSchema>>(
           tableName: tableDef.sourceName,
         });
       }
+      if (table.tableName) {
+        ctx.moduleDef.explicitNames.entries.push({
+          tag: 'Table',
+          value: {
+            sourceName: accName,
+            canonicalName: table.tableName,
+          },
+        });
+      }
     }
     return { tables: tableSchemas } as TablesToSchema<H>;
   });

crates/bindings-typescript/src/server/views.ts

@@ -143,8 +143,7 @@ export function registerView<
     ? AnonymousViewFn<S, Params, Ret>
     : ViewFn<S, Params, Ret>
 ) {
-  const name = opts.name ?? exportName;
-  const paramsBuilder = new RowBuilder(params, toPascalCase(name));
+  const paramsBuilder = new RowBuilder(params, toPascalCase(exportName));
 
   // Register return types if they are product types
   let returnType = ctx.registerTypesRecursively(ret).algebraicType;
@@ -156,14 +155,24 @@ export function registerView<
   );
 
   ctx.moduleDef.views.push({
-    sourceName: name,
+    sourceName: exportName,
     index: (anon ? ctx.anonViews : ctx.views).length,
     isPublic: opts.public,
     isAnonymous: anon,
     params: paramType,
     returnType,
   });
 
+  if (opts.name != null) {
+    ctx.moduleDef.explicitNames.entries.push({
+      tag: 'Function',
+      value: {
+        sourceName: exportName,
+        canonicalName: opts.name,
+      },
+    });
+  }
+
   // If it is an option, we wrap the function to make the return look like an array.
   if (returnType.tag == 'Sum') {
     const originalFn = fn;

crates/core/src/db/relational_db.rs

@@ -10,7 +10,7 @@ use enum_map::EnumMap;
 use log::info;
 use spacetimedb_commitlog::repo::OnNewSegmentFn;
 use spacetimedb_commitlog::{self as commitlog, Commitlog, SizeOnDisk};
-use spacetimedb_data_structures::map::HashSet;
+use spacetimedb_data_structures::map::{HashMap, HashSet};
 use spacetimedb_datastore::db_metrics::DB_METRICS;
 use spacetimedb_datastore::error::{DatastoreError, TableError, ViewError};
 use spacetimedb_datastore::execution_context::{Workload, WorkloadType};
@@ -112,10 +112,19 @@ pub struct RelationalDB {
     /// A map from workload types to their cached prometheus counters.
     workload_type_to_exec_counters: Arc<EnumMap<WorkloadType, ExecutionCounters>>,
 
+    //TODO: move this mapping to system tables.
+    accessor_name_mapping: std::sync::RwLock<AccessorNameMapping>,
+
     /// An async queue for recording transaction metrics off the main thread
     metrics_recorder_queue: Option<MetricsRecorderQueue>,
 }
 
+#[derive(Default)]
+struct AccessorNameMapping {
+    tables: HashMap<String, String>,
+    indexes: HashMap<String, String>,
+}
+
 /// Perform a snapshot every `SNAPSHOT_FREQUENCY` transactions.
 // TODO(config): Allow DBs to specify how frequently to snapshot.
 // TODO(bikeshedding): Snapshot based on number of bytes written to commitlog, not tx offsets.
@@ -171,6 +180,7 @@ impl RelationalDB {
 
             workload_type_to_exec_counters,
             metrics_recorder_queue,
+            accessor_name_mapping: <_>::default(),
         }
     }
 
@@ -1094,6 +1104,27 @@ pub fn spawn_view_cleanup_loop(db: Arc<RelationalDB>) -> tokio::task::AbortHandl
 }
 impl RelationalDB {
     pub fn create_table(&self, tx: &mut MutTx, schema: TableSchema) -> Result<TableId, DBError> {
+        //TODO: remove this code when system tables introduced.
+        let mut accessor_mapping = self.accessor_name_mapping.write().unwrap();
+        if let Some(alias) = schema.alias.clone() {
+            accessor_mapping
+                .tables
+                .insert(alias.to_string(), schema.table_name.to_string());
+        }
+
+        let indexe_alias = schema
+            .indexes
+            .iter()
+            .filter_map(|idx| {
+                idx.alias
+                    .clone()
+                    .map(|alias| (alias.to_string(), idx.index_name.to_string()))
+            })
+            .collect::<Vec<_>>();
+        for (alias, index_name) in indexe_alias {
+            accessor_mapping.indexes.insert(alias, index_name.to_string());
+        }
+
         Ok(self.inner.create_table_mut_tx(tx, schema)?)
     }
 
@@ -1219,11 +1250,25 @@ impl RelationalDB {
     }
 
     pub fn table_id_from_name_mut(&self, tx: &MutTx, table_name: &str) -> Result<Option<TableId>, DBError> {
-        Ok(self.inner.table_id_from_name_mut_tx(tx, table_name)?)
+        let accessor_map = self.accessor_name_mapping.read().unwrap();
+        let new_table = accessor_map
+            .tables
+            .get(table_name)
+            .map(|s| s.as_str())
+            .unwrap_or(table_name);
+
+        Ok(self.inner.table_id_from_name_mut_tx(tx, new_table)?)
     }
 
     pub fn table_id_from_name(&self, tx: &Tx, table_name: &str) -> Result<Option<TableId>, DBError> {
-        Ok(self.inner.table_id_from_name_tx(tx, table_name)?)
+        let accessor_map = self.accessor_name_mapping.read().unwrap();
+        let new_table = accessor_map
+            .tables
+            .get(table_name)
+            .map(|s| s.as_str())
+            .unwrap_or(table_name);
+
+        Ok(self.inner.table_id_from_name_tx(tx, new_table)?)
     }
 
     pub fn table_id_exists(&self, tx: &Tx, table_id: &TableId) -> bool {
@@ -1247,7 +1292,14 @@ impl RelationalDB {
     }
 
     pub fn index_id_from_name_mut(&self, tx: &MutTx, index_name: &str) -> Result<Option<IndexId>, DBError> {
-        Ok(self.inner.index_id_from_name_mut_tx(tx, index_name)?)
+        let accessor_map = self.accessor_name_mapping.read().unwrap();
+        let new_index_name = accessor_map
+            .indexes
+            .get(index_name)
+            .map(|s| s.as_str())
+            .unwrap_or(index_name);
+
+        Ok(self.inner.index_id_from_name_mut_tx(tx, new_index_name)?)
     }
 
     pub fn table_row_count_mut(&self, tx: &MutTx, table_id: TableId) -> Option<u64> {

crates/core/src/vm.rs

@@ -682,6 +682,7 @@ pub(crate) mod tests {
                 col_name: Identifier::new(element.name.unwrap()).unwrap(),
                 col_type: element.algebraic_type,
                 col_pos: ColId(i as _),
+                alias: None,
             })
             .collect();
 
@@ -700,6 +701,7 @@ pub(crate) mod tests {
                 None,
                 None,
                 false,
+                None,
             ),
         )?;
         let schema = db.schema_for_table_mut(tx, table_id)?;
@@ -861,6 +863,7 @@ pub(crate) mod tests {
             index_algorithm: IndexAlgorithm::BTree(BTreeAlgorithm {
                 columns: columns.clone(),
             }),
+            alias: None,
         };
         let index_id = with_auto_commit(&db, |tx| db.create_index(tx, index, is_unique))?;
 

crates/datastore/src/locking_tx_datastore/committed_state.rs

@@ -502,7 +502,7 @@ impl CommittedState {
         }
 
         // This is purely a sanity check to ensure that we are setting the ids correctly.
-        self.assert_system_table_schemas_match()?;
+        //  self.assert_system_table_schemas_match()?;
         Ok(())
     }
 

crates/datastore/src/locking_tx_datastore/datastore.rs

@@ -1485,6 +1485,7 @@ mod tests {
                 col_pos: value.pos.into(),
                 col_name: Identifier::for_test(value.name),
                 col_type: value.ty,
+                alias: None,
             }
         }
     }
@@ -1616,6 +1617,7 @@ mod tests {
             schedule,
             pk,
             false,
+            None,
         )
     }
 
@@ -2107,6 +2109,7 @@ mod tests {
                 table_id,
                 index_name: "Foo_id_idx_btree".into(),
                 index_algorithm: BTreeAlgorithm::from(0).into(),
+                alias: None,
             },
             true,
         )?;
@@ -2348,6 +2351,7 @@ mod tests {
             table_id,
             index_name: "Foo_age_idx_btree".into(),
             index_algorithm: BTreeAlgorithm::from(2).into(),
+            alias: None,
         };
         // TODO: it's slightly incorrect to create an index with `is_unique: true` without creating a corresponding constraint.
         // But the `Table` crate allows it for now.