Use newtypes ColId, TableId, IndexId, SequenceId everywhere (*) (#408)

* Use newtypes ColId, TableId, IndexId, SequenceId everywhere (*)

* Addressing some PR comments

---------

Co-authored-by: Mario Alejandro Montoya Cortés <[email protected]>

Author: Centril

Cargo.lock

@@ -15,6 +15,7 @@ members = [
   "crates/sdk",
   "crates/client-api-messages",
   "crates/sqltest",
+  "crates/primitives",
   "modules/rust-wasm-test",
   "modules/benchmarks",
   "modules/spacetimedb-quickstart",

Cargo.toml

@@ -25,6 +25,7 @@ spacetimedb-core = { path = "../core" }
 spacetimedb-standalone = { path = "../standalone" }
 spacetimedb-client-api = { path = "../client-api" }
 spacetimedb-testing = { path = "../testing" }
+spacetimedb-primitives = { path = "../primitives" }
 
 ahash.workspace = true
 log.workspace = true

crates/bench/Cargo.toml

@@ -122,7 +122,7 @@ fn bench_harness<
 
 #[inline(never)]
 fn empty<DB: BenchDatabase>(g: &mut Group, db: &mut DB) -> ResultBench<()> {
-    let id = format!("empty");
+    let id = "empty".to_string();
     g.bench_function(&id, |b| {
         bench_harness(
             b,
@@ -159,11 +159,11 @@ fn insert_1<DB: BenchDatabase, T: BenchTable + RandomTable>(
                 let mut data = data.clone();
                 db.clear_table(table_id)?;
                 let row = data.pop().unwrap();
-                db.insert_bulk(&table_id, data)?;
+                db.insert_bulk(table_id, data)?;
                 Ok(row)
             },
             |db, row| {
-                db.insert(&table_id, row)?;
+                db.insert(table_id, row)?;
                 Ok(())
             },
         )
@@ -196,12 +196,12 @@ fn insert_bulk<DB: BenchDatabase, T: BenchTable + RandomTable>(
                 db.clear_table(table_id)?;
                 let to_insert = data.split_off(load as usize);
                 if !data.is_empty() {
-                    db.insert_bulk(&table_id, data)?;
+                    db.insert_bulk(table_id, data)?;
                 }
                 Ok(to_insert)
             },
             |db, to_insert| {
-                db.insert_bulk(&table_id, to_insert)?;
+                db.insert_bulk(table_id, to_insert)?;
                 Ok(())
             },
         )
@@ -269,7 +269,7 @@ fn filter<DB: BenchDatabase, T: BenchTable + RandomTable>(
 
     let data = create_sequential::<T>(0xdeadbeef, load, buckets as u64);
 
-    db.insert_bulk(&table_id, data.clone())?;
+    db.insert_bulk(table_id, data.clone())?;
 
     // Each iteration performs a single transaction.
     g.throughput(criterion::Throughput::Elements(1));
@@ -290,7 +290,7 @@ fn filter<DB: BenchDatabase, T: BenchTable + RandomTable>(
                 Ok(value)
             },
             |db, value| {
-                db.filter::<T>(&table_id, column_index, value)?;
+                db.filter::<T>(table_id, column_index, value)?;
                 Ok(())
             },
         )
@@ -319,7 +319,7 @@ fn find<DB: BenchDatabase, T: BenchTable + RandomTable>(
 
     let data = create_sequential::<T>(0xdeadbeef, load, buckets as u64);
 
-    db.insert_bulk(&table_id, data.clone())?;
+    db.insert_bulk(table_id, data.clone())?;
 
     // Each iteration performs a single transaction.
     g.throughput(criterion::Throughput::Elements(1));
@@ -339,7 +339,7 @@ fn find<DB: BenchDatabase, T: BenchTable + RandomTable>(
                 Ok(value)
             },
             |db, value| {
-                db.filter::<T>(&table_id, column_id, value)?;
+                db.filter::<T>(table_id, column_id, value)?;
                 Ok(())
             },
         )

crates/bench/benches/generic.rs

@@ -3,9 +3,10 @@ use crate::{
     schemas::{table_name, BenchTable, IndexStrategy},
     ResultBench,
 };
-use spacetimedb::db::datastore::traits::{ColId, IndexDef, TableDef};
+use spacetimedb::db::datastore::traits::{IndexDef, TableDef};
 use spacetimedb::db::relational_db::{open_db, RelationalDB};
 use spacetimedb_lib::sats::AlgebraicValue;
+use spacetimedb_primitives::{ColId, TableId};
 use std::hint::black_box;
 use tempdir::TempDir;
 
@@ -15,11 +16,12 @@ pub struct SpacetimeRaw {
     db: RelationalDB,
     _temp_dir: TempDir,
 }
+
 impl BenchDatabase for SpacetimeRaw {
     fn name() -> &'static str {
         "stdb_raw"
     }
-    type TableId = u32;
+    type TableId = TableId;
 
     fn build(in_memory: bool, fsync: bool) -> ResultBench<Self>
     where
@@ -43,14 +45,14 @@ impl BenchDatabase for SpacetimeRaw {
             match index_strategy {
                 IndexStrategy::Unique => {
                     self.db
-                        .create_index(tx, IndexDef::new("id".to_string(), table_id, 0, true))?;
+                        .create_index(tx, IndexDef::new("id".to_string(), table_id, 0.into(), true))?;
                 }
                 IndexStrategy::NonUnique => (),
                 IndexStrategy::MultiIndex => {
                     for (i, column) in T::product_type().elements.iter().enumerate() {
                         self.db.create_index(
                             tx,
-                            IndexDef::new(column.name.clone().unwrap(), table_id, i as u32, false),
+                            IndexDef::new(column.name.clone().unwrap(), table_id, i.into(), false),
                         )?;
                     }
                 }

crates/bench/src/spacetime_raw.rs

@@ -533,8 +533,8 @@ fn spacetimedb_tabletype_impl(item: syn::DeriveInput) -> syn::Result<TokenStream
     let mut columns = Vec::<Column>::new();
 
     let get_table_id_func = quote! {
-        fn table_id() -> u32 {
-            static TABLE_ID: spacetimedb::rt::OnceCell<u32> = spacetimedb::rt::OnceCell::new();
+        fn table_id() -> spacetimedb::TableId {
+            static TABLE_ID: spacetimedb::rt::OnceCell<spacetimedb::TableId> = spacetimedb::rt::OnceCell::new();
             *TABLE_ID.get_or_init(|| {
                 spacetimedb::get_table_id(<Self as spacetimedb::TableType>::TABLE_NAME)
             })

crates/bindings-macro/src/lib.rs

@@ -11,3 +11,4 @@ bench = false
 
 [dependencies]
 getrandom = {workspace = true, optional = true}
+spacetimedb-primitives = { path = "../primitives" }

crates/bindings-sys/Cargo.toml

@@ -13,9 +13,12 @@ use std::ptr;
 
 use alloc::boxed::Box;
 
+use spacetimedb_primitives::{ColId, TableId};
+
 /// Provides a raw set of sys calls which abstractions can be built atop of.
 pub mod raw {
     use core::mem::ManuallyDrop;
+    use spacetimedb_primitives::{ColId, TableId};
 
     // this module identifier determines the abi version that modules built with this crate depend
     // on. Any non-breaking additions to the abi surface should be put in a new `extern {}` block
@@ -33,7 +36,7 @@ pub mod raw {
             name_len: usize,
             schema: *const u8,
             schema_len: usize,
-            out: *mut u32,
+            out: *mut TableId,
         ) -> u16;
         */
 
@@ -47,7 +50,7 @@ pub mod raw {
         /// - the slice `(name, name_len)` is not valid UTF-8
         /// - `name + name_len` overflows a 64-bit address.
         /// - writing to `out` overflows a 32-bit integer
-        pub fn _get_table_id(name: *const u8, name_len: usize, out: *mut u32) -> u16;
+        pub fn _get_table_id(name: *const u8, name_len: usize, out: *mut TableId) -> u16;
 
         /// Creates an index with the name `index_name` and type `index_type`,
         /// on a product of the given columns in `col_ids`
@@ -69,7 +72,7 @@ pub mod raw {
         pub fn _create_index(
             index_name: *const u8,
             index_name_len: usize,
-            table_id: u32,
+            table_id: TableId,
             index_type: u8,
             col_ids: *const u8,
             col_len: usize,
@@ -92,7 +95,13 @@ pub mod raw {
         /// - `(val, val_len)` cannot be decoded to an `AlgebraicValue`
         ///   typed at the `AlgebraicType` of the column,
         /// - `val + val_len` overflows a 64-bit integer
-        pub fn _iter_by_col_eq(table_id: u32, col_id: u32, val: *const u8, val_len: usize, out: *mut Buffer) -> u16;
+        pub fn _iter_by_col_eq(
+            table_id: TableId,
+            col_id: ColId,
+            val: *const u8,
+            val_len: usize,
+            out: *mut Buffer,
+        ) -> u16;
 
         /// Inserts a row into the table identified by `table_id`,
         /// where the row is read from the byte slice `row` in WASM memory,
@@ -109,7 +118,7 @@ pub mod raw {
         /// - `row + row_len` overflows a 64-bit integer
         /// - `(row, row_len)` doesn't decode from BSATN to a `ProductValue`
         ///   according to the `ProductType` that the table's schema specifies.
-        pub fn _insert(table_id: u32, row: *mut u8, row_len: usize) -> u16;
+        pub fn _insert(table_id: TableId, row: *mut u8, row_len: usize) -> u16;
 
         /// Deletes all rows in the table identified by `table_id`
         /// where the column identified by `col_id` matches the byte string,
@@ -128,7 +137,13 @@ pub mod raw {
         ///   according to the `AlgebraicType` that the table's schema specifies for `col_id`.
         /// - `value + value_len` overflows a 64-bit integer
         /// - writing to `out` would overflow a 32-bit integer
-        pub fn _delete_by_col_eq(table_id: u32, col_id: u32, value: *const u8, value_len: usize, out: *mut u32) -> u16;
+        pub fn _delete_by_col_eq(
+            table_id: TableId,
+            col_id: ColId,
+            value: *const u8,
+            value_len: usize,
+            out: *mut u32,
+        ) -> u16;
 
         /// Start iteration on each row, as bytes, of a table identified by `table_id`.
         ///
@@ -137,7 +152,7 @@ pub mod raw {
         ///
         /// Returns an error if
         /// - a table with the provided `table_id` doesn't exist
-        pub fn _iter_start(table_id: u32, out: *mut BufferIter) -> u16;
+        pub fn _iter_start(table_id: TableId, out: *mut BufferIter) -> u16;
 
         /// Like [`_iter_start`], start iteration on each row,
         /// as bytes, of a table identified by `table_id`.
@@ -152,7 +167,12 @@ pub mod raw {
         /// - a table with the provided `table_id` doesn't exist
         /// - `(filter, filter_len)` doesn't decode to a filter expression
         /// - `filter + filter_len` overflows a 64-bit integer
-        pub fn _iter_start_filtered(table_id: u32, filter: *const u8, filter_len: usize, out: *mut BufferIter) -> u16;
+        pub fn _iter_start_filtered(
+            table_id: TableId,
+            filter: *const u8,
+            filter_len: usize,
+            out: *mut BufferIter,
+        ) -> u16;
 
         /// Advances the registered iterator with the index given by `iter_key`.
         ///
@@ -471,7 +491,7 @@ unsafe fn call<T>(f: impl FnOnce(*mut T) -> u16) -> Result<T, Errno> {
 ///
 /// Returns an error if the table does not exist.
 #[inline]
-pub fn get_table_id(name: &str) -> Result<u32, Errno> {
+pub fn get_table_id(name: &str) -> Result<TableId, Errno> {
     unsafe { call(|out| raw::_get_table_id(name.as_ptr(), name.len(), out)) }
 }
 
@@ -488,7 +508,7 @@ pub fn get_table_id(name: &str) -> Result<u32, Errno> {
 ///
 /// Traps if `index_type == 1` or `col_ids.len() != 1`.
 #[inline]
-pub fn create_index(index_name: &str, table_id: u32, index_type: u8, col_ids: &[u8]) -> Result<(), Errno> {
+pub fn create_index(index_name: &str, table_id: TableId, index_type: u8, col_ids: &[u8]) -> Result<(), Errno> {
     cvt(unsafe {
         raw::_create_index(
             index_name.as_ptr(),
@@ -518,7 +538,7 @@ pub fn create_index(index_name: &str, table_id: u32, index_type: u8, col_ids: &[
 /// - `val` cannot be BSATN-decoded to an `AlgebraicValue`
 ///   typed at the `AlgebraicType` of the column
 #[inline]
-pub fn iter_by_col_eq(table_id: u32, col_id: u32, val: &[u8]) -> Result<Buffer, Errno> {
+pub fn iter_by_col_eq(table_id: TableId, col_id: ColId, val: &[u8]) -> Result<Buffer, Errno> {
     unsafe { call(|out| raw::_iter_by_col_eq(table_id, col_id, val.as_ptr(), val.len(), out)) }
 }
 
@@ -535,7 +555,7 @@ pub fn iter_by_col_eq(table_id: u32, col_id: u32, val: &[u8]) -> Result<Buffer,
 /// - `row` doesn't decode from BSATN to a `ProductValue`
 ///   according to the `ProductType` that the table's schema specifies.
 #[inline]
-pub fn insert(table_id: u32, row: &mut [u8]) -> Result<(), Errno> {
+pub fn insert(table_id: TableId, row: &mut [u8]) -> Result<(), Errno> {
     cvt(unsafe { raw::_insert(table_id, row.as_mut_ptr(), row.len()) })
 }
 
@@ -552,7 +572,7 @@ pub fn insert(table_id: u32, row: &mut [u8]) -> Result<(), Errno> {
 /// - no columns were deleted
 /// - `col_id` does not identify a column of the table
 #[inline]
-pub fn delete_by_col_eq(table_id: u32, col_id: u32, value: &[u8]) -> Result<u32, Errno> {
+pub fn delete_by_col_eq(table_id: TableId, col_id: ColId, value: &[u8]) -> Result<u32, Errno> {
     unsafe { call(|out| raw::_delete_by_col_eq(table_id, col_id, value.as_ptr(), value.len(), out)) }
 }
 
@@ -568,7 +588,7 @@ pub fn delete_by_col_eq(table_id: u32, col_id: u32, value: &[u8]) -> Result<u32,
 /// - a table with the provided `table_id` doesn't exist
 /// - `Some(filter)` doesn't decode to a filter expression
 #[inline]
-pub fn iter(table_id: u32, filter: Option<&[u8]>) -> Result<BufferIter, Errno> {
+pub fn iter(table_id: TableId, filter: Option<&[u8]>) -> Result<BufferIter, Errno> {
     unsafe {
         call(|out| match filter {
             None => raw::_iter_start(table_id, out),

crates/bindings-sys/src/lib.rs

@@ -19,6 +19,7 @@ getrandom = ["spacetimedb-bindings-sys/getrandom"]
 spacetimedb-bindings-sys = { path = "../bindings-sys", version = "0.7.1" }
 spacetimedb-lib = { path = "../lib", default-features = false, version = "0.7.1"}
 spacetimedb-bindings-macro = { path = "../bindings-macro", version = "0.7.1"}
+spacetimedb-primitives = { path = "../primitives", version = "0.7.1" }
 
 derive_more.workspace = true
 log.workspace = true