temporary acessor fix

Author: Shubham8287

crates/bindings-macro/src/table.rs

@@ -47,6 +47,7 @@ struct ScheduledArg {
 }
 
 struct IndexArg {
+    is_inline: bool,
     accessor: Ident,
     //TODO: add canonical name
     // name: Option<LitStr>,
@@ -55,17 +56,27 @@ struct IndexArg {
 }
 
 impl IndexArg {
-    fn new(accessor: Ident, kind: IndexType) -> Self {
+    fn inline(accessor: Ident, kind: IndexType) -> Self {
         // We don't know if its unique yet.
         // We'll discover this once we have collected constraints.
         let is_unique = false;
         Self {
             accessor,
             is_unique,
             kind,
+            is_inline: true,
             //  name,
         }
     }
+    fn explicit(accessor: Ident, kind: IndexType) -> Self {
+        Self {
+            is_inline: false,
+            accessor,
+            is_unique: false,
+            kind,
+            // name: None,
+        }
+    }
 }
 
 enum IndexType {
@@ -206,7 +217,7 @@ impl IndexArg {
             )
         })?;
 
-        Ok(IndexArg::new(accessor, kind))
+        Ok(IndexArg::explicit(accessor, kind))
     }
 
     fn parse_columns(meta: &ParseNestedMeta) -> syn::Result<Option<Vec<Ident>>> {
@@ -266,7 +277,6 @@ impl IndexArg {
     /// Parses an inline `#[index(btree)]`, `#[index(hash)]`, or `#[index(direct)]` attribute on a field.
     fn parse_index_attr(field: &Ident, attr: &syn::Attribute) -> syn::Result<Self> {
         let mut kind = None;
-        let mut accessor: Option<Ident> = None;
         let mut _name: Option<LitStr> = None;
         attr.parse_nested_meta(|meta| {
             match_meta!(match meta {
@@ -286,10 +296,6 @@ impl IndexArg {
                     check_duplicate_msg(&kind, &meta, "index type specified twice")?;
                     kind = Some(IndexType::Direct { column: field.clone() })
                 }
-                sym::accessor => {
-                    check_duplicate(&accessor, &meta)?;
-                    accessor = Some(meta.value()?.parse()?);
-                }
                 sym::name => {
                     check_duplicate(&_name, &meta)?;
                     _name = Some(meta.value()?.parse()?);
@@ -301,8 +307,8 @@ impl IndexArg {
             kind.ok_or_else(|| syn::Error::new_spanned(&attr.meta, "must specify kind of index (`btree` , `direct`)"))?;
 
         // Default accessor = field name if not provided
-        let accessor = accessor.unwrap_or_else(|| field.clone());
-        Ok(IndexArg::new(accessor, kind))
+        let accessor = field.clone();
+        Ok(IndexArg::inline(accessor, kind))
     }
 
     fn validate<'a>(&'a self, table_name: &str, cols: &'a [Column<'a>]) -> syn::Result<ValidatedIndex<'a>> {
@@ -345,6 +351,7 @@ impl IndexArg {
             // as it is used in `index_id_from_name` abi.
             index_name: gen_index_name(),
             accessor_name: &self.accessor,
+            using_field_as_accessor: self.is_inline,
             kind,
         })
     }
@@ -402,6 +409,7 @@ impl AccessorType {
 struct ValidatedIndex<'a> {
     index_name: String,
     accessor_name: &'a Ident,
+    using_field_as_accessor: bool,
     is_unique: bool,
     kind: ValidatedIndexType<'a>,
 }
@@ -450,14 +458,16 @@ impl ValidatedIndex<'_> {
                 })
             }
         };
-        let accessor_name = ident_to_litstr(self.accessor_name);
-        let index_name = &self.index_name;
+        let accessor_name = if self.using_field_as_accessor {
+            self.index_name.clone()
+        } else {
+            ident_to_litstr(self.accessor_name).value()
+        };
         // Note: we do not pass the index_name through here.
         // We trust the schema validation logic to reconstruct the name we've stored in `self.name`.
         //TODO(shub): pass generated index name instead of accessor name as source_name
         quote!(spacetimedb::table::IndexDesc {
             source_name: #accessor_name,
-            index_name: #index_name,
             algo: #algo,
         })
     }
@@ -849,6 +859,7 @@ pub(crate) fn table_impl(mut args: TableArgs, item: &syn::DeriveInput) -> syn::R
         let accessor = unique_col.ident.clone();
         let columns = vec![accessor.clone()];
         args.indices.push(IndexArg {
+            is_inline: true,
             accessor,
             //name: None,
             is_unique: true,

crates/bindings/src/table.rs

@@ -139,7 +139,6 @@ pub trait TableInternal: Sized {
 #[derive(Clone, Copy)]
 pub struct IndexDesc<'a> {
     pub source_name: &'a str,
-    pub index_name: &'a str,
     pub algo: IndexAlgo<'a>,
 }
 

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,29 @@ 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);
+
+        println!("replaced table name {table_name} with {new_table}");
+
+        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);
+
+        println!("replaced table name {table_name} with {new_table}");
+
+        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 +1296,16 @@ 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);
+
+        println!("replaced index name {index_name} with {new_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

@@ -700,6 +700,7 @@ pub(crate) mod tests {
                 None,
                 None,
                 false,
+                None,
             ),
         )?;
         let schema = db.schema_for_table_mut(tx, table_id)?;

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

@@ -1616,6 +1616,7 @@ mod tests {
             schedule,
             pk,
             false,
+            None,
         )
     }
 

crates/datastore/src/locking_tx_datastore/state_view.rs

@@ -186,6 +186,8 @@ pub trait StateView {
             schedule,
             table_primary_key,
             is_event,
+            //TODO: fetch it from system table
+            None,
         ))
     }
 

crates/datastore/src/system_tables.rs

@@ -981,6 +981,7 @@ impl From<StColumnRow> for ColumnSchema {
             col_pos: column.col_pos,
             col_name: column.col_name,
             col_type: column.col_type.0,
+            alias: None,
         }
     }
 }
@@ -1148,6 +1149,7 @@ impl From<StIndexRow> for IndexSchema {
             table_id: x.table_id,
             index_name: x.index_name,
             index_algorithm: x.index_algorithm.into(),
+            alias: None,
         }
     }
 }

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

@@ -390,6 +390,7 @@ pub struct RawSequenceDefV10 {
 pub struct RawIndexDefV10 {
     /// In the future, the user may FOR SOME REASON want to override this.
     /// Even though there is ABSOLUTELY NO REASON TO.
+    /// TODO: Remove Option, must not be empty.
     pub source_name: Option<RawIdentifier>,
 
     // not to be used in v10

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

@@ -23,7 +23,6 @@ use spacetimedb_sats::Typespace;
 use crate::db::auth::StAccess;
 use crate::db::auth::StTableType;
 use crate::db::raw_def::v10::RawConstraintDefV10;
-use crate::db::raw_def::v10::RawIndexDefV10;
 use crate::db::raw_def::v10::RawScopedTypeNameV10;
 use crate::db::raw_def::v10::RawSequenceDefV10;
 use crate::db::raw_def::v10::RawTypeDefV10;
@@ -1071,16 +1070,6 @@ impl From<RawScopedTypeNameV10> for RawScopedTypeNameV9 {
     }
 }
 
-impl From<RawIndexDefV10> for RawIndexDefV9 {
-    fn from(raw: RawIndexDefV10) -> Self {
-        RawIndexDefV9 {
-            accessor_name: raw.source_name,
-            algorithm: raw.algorithm,
-            name: None,
-        }
-    }
-}
-
 impl From<RawConstraintDefV10> for RawConstraintDefV9 {
     fn from(raw: RawConstraintDefV10) -> Self {
         RawConstraintDefV9 {