Limit update() to only work on primary keys (#4279)

## Summary
- Restricts `update()` across all three server-side SDKs (Rust, C#,
TypeScript) to only work on primary key columns, not all unique columns
- Calling `update()` on a non-PK unique column is semantically a
delete+insert — clients won't see it as a row update unless the primary
key stays the same
- Fresh re-implementation of #1862, extended to cover C# and TypeScript
bindings

### Design principle

Primary key is a constraint on columns, not a property of indexes. An
index is unique or not unique — whether `update()` is available is
derived from the column's attributes at the point of use, not stored on
the index.

This differs from #1862 which introduced a `Uniqueness` enum (`No |
Unique | PrimaryKey`) on the index itself. Instead, we keep `is_unique:
bool` and check the column metadata where needed.

### Rust changes
- Add `PrimaryKey` marker trait and `where Col: PrimaryKey` bound on
`UniqueColumn::update()`
- `marker_type()` receives `primary_key_column` and checks the column
directly — no `is_pk` field on the index
- `sdk-test` unique tables use `update_non_pk_by` (delete+insert)
instead of `update_by`
- Benchmarks that used `update()` on `#[unique]` columns changed to
either `#[primary_key]` or delete+insert

### C# changes
- Only emit `Update()` on `UniqueIndex` when the column has `PrimaryKey`
attrs
- Update `unique_*` test reducers in `sdk-test-cs` to use
`Delete()`+`Insert()` instead

### TypeScript changes
- `UniqueIndex` now has only `find` + `delete` (no `update`)
- `AllColumnsPrimaryKey` type-level helper checks column metadata from
the `TableDef`
- `Index` routing conditionally intersects `{ update() }` when columns
are PK
- Runtime only attaches `update` method for PK unique indexes
- `sdk-test-ts` unique tables use delete+insert instead of update
- Type-level test in `schema.test-d.ts` verifies `id.update()` compiles
(PK) and `name2.update` errors (non-PK unique)

## Test plan
- [x] C# codegen tests pass (`dotnet test
crates/bindings-csharp/Codegen.Tests`)
- [x] Rust SDK test module compiles
- [x] Benchmarks compile
- [x] TypeScript type checks pass (`npx tsc --noEmit`)
- [ ] CI passes

Closes #1862

Author: cloutiertyler

crates/bindings-csharp/Codegen.Tests/fixtures/diag/snapshots/Module#FFI.verified.cs

@@ -1256,8 +1256,6 @@ internal BarUniqueIndex()
             // C# generics don't play well with nullable types and can't accept both struct-type-based and class-type-based
             // `globalName` in one generic definition, leading to buggy `Row?` expansion for either one or another.
             public global::MultiTableRow? Find(uint key) => FindSingle(key);
-
-            public global::MultiTableRow Update(global::MultiTableRow row) => DoUpdate(row);
         }
 
         public BarUniqueIndex Bar => new();
@@ -1482,10 +1480,6 @@ internal Unique1UniqueIndex()
             // `globalName` in one generic definition, leading to buggy `Row?` expansion for either one or another.
             public global::RegressionMultipleUniqueIndexesHadSameName? Find(uint key) =>
                 FindSingle(key);
-
-            public global::RegressionMultipleUniqueIndexesHadSameName Update(
-                global::RegressionMultipleUniqueIndexesHadSameName row
-            ) => DoUpdate(row);
         }
 
         internal Unique1UniqueIndex Unique1 => new();
@@ -1506,10 +1500,6 @@ internal Unique2UniqueIndex()
             // `globalName` in one generic definition, leading to buggy `Row?` expansion for either one or another.
             public global::RegressionMultipleUniqueIndexesHadSameName? Find(uint key) =>
                 FindSingle(key);
-
-            public global::RegressionMultipleUniqueIndexesHadSameName Update(
-                global::RegressionMultipleUniqueIndexesHadSameName row
-            ) => DoUpdate(row);
         }
 
         internal Unique2UniqueIndex Unique2 => new();

crates/bindings-csharp/Codegen.Tests/fixtures/server/snapshots/Module#FFI.verified.cs

@@ -498,14 +498,17 @@ public IEnumerable<string> GenerateTableAccessorFilters(TableAccessor tableAcces
                 continue;
             }
             var standardIndexName = ct.ToIndex().StandardIndexName(tableAccessor);
+            var updateMethod = ct.Attr.HasFlag(ColumnAttrs.PrimaryKey)
+                ? $"public {globalName} Update({globalName} row) => DoUpdate(row);"
+                : "";
             yield return $$"""
                 {{vis}} sealed class {{f.Name}}UniqueIndex : {{uniqueIndexBase}}<{{tableAccessor.Name}}, {{globalName}}, {{f.Type.Name}}, {{f.Type.BSATNName}}> {
                     internal {{f.Name}}UniqueIndex() : base("{{standardIndexName}}") {}
                     // Important: don't move this to the base class.
                     // C# generics don't play well with nullable types and can't accept both struct-type-based and class-type-based
                     // `globalName` in one generic definition, leading to buggy `Row?` expansion for either one or another.
                     public {{globalName}}? Find({{f.Type.Name}} key) => FindSingle(key);
-                    public {{globalName}} Update({{globalName}} row) => DoUpdate(row);
+                    {{updateMethod}}
                 }
                 {{vis}} {{f.Name}}UniqueIndex {{f.Name}} => new();
                 """;

crates/bindings-csharp/Codegen/Module.cs

@@ -499,7 +499,12 @@ impl ValidatedIndex<'_> {
         }
     }
 
-    fn marker_type(&self, vis: &syn::Visibility, tablehandle_ident: &Ident) -> TokenStream {
+    fn marker_type(
+        &self,
+        vis: &syn::Visibility,
+        tablehandle_ident: &Ident,
+        primary_key_column: Option<&Column<'_>>,
+    ) -> TokenStream {
         let index_ident = self.accessor_name;
         let index_name = &self.index_name;
 
@@ -560,6 +565,9 @@ impl ValidatedIndex<'_> {
                     }
                 }
             });
+            if primary_key_column.is_some_and(|pk| col.ident == pk.ident) {
+                decl.extend(quote!(impl spacetimedb::table::PrimaryKey for #index_ident {}));
+            }
         }
         decl
     }
@@ -824,7 +832,10 @@ pub(crate) fn table_impl(mut args: TableArgs, item: &syn::DeriveInput) -> syn::R
     let index_accessors_ro = indices
         .iter()
         .map(|index| index.accessor(vis, original_struct_ident, &tablehandle_ident, AccessorType::Read));
-    let index_marker_types = indices.iter().map(|index| index.marker_type(vis, &tablehandle_ident));
+    let index_marker_types: Vec<_> = indices
+        .iter()
+        .map(|index| index.marker_type(vis, &tablehandle_ident, primary_key_column.as_ref()))
+        .collect();
 
     // Generate `integrate_generated_columns`
     // which will integrate all generated auto-inc col values into `_row`.

crates/bindings-macro/src/table.rs

@@ -47,15 +47,35 @@ export type Indexes<
   [k in keyof I]: Index<TableDef, I[k]>;
 };
 
+/**
+ * Check whether every column in an index is a primary key column.
+ */
+type AllColumnsPrimaryKey<
+  TableDef extends UntypedTableDef,
+  Columns extends readonly string[],
+> = Columns extends readonly [
+  infer Head extends keyof TableDef['columns'] & string,
+  ...infer Tail extends readonly string[],
+]
+  ? TableDef['columns'][Head]['columnMetadata'] extends { isPrimaryKey: true }
+    ? AllColumnsPrimaryKey<TableDef, Tail>
+    : false
+  : true;
+
 /**
  * A type representing a database index,
  * which can either be unique or filter for a single value or range of values.
+ * Unique indexes on primary key columns additionally support `update`.
  */
 export type Index<
   TableDef extends UntypedTableDef,
   I extends UntypedIndex<keyof TableDef['columns'] & string>,
 > = I['unique'] extends true
-  ? UniqueIndex<TableDef, I>
+  ? AllColumnsPrimaryKey<TableDef, I['columns']> extends true
+    ? UniqueIndex<TableDef, I> & {
+        update(row: Prettify<RowType<TableDef>>): Prettify<RowType<TableDef>>;
+      }
+    : UniqueIndex<TableDef, I>
   : I['algorithm'] extends 'hash'
     ? PointIndex<TableDef, I>
     : RangedIndex<TableDef, I>;
@@ -103,7 +123,6 @@ export interface UniqueIndex<
   I extends UntypedIndex<keyof TableDef['columns'] & string>,
 > extends ReadonlyUniqueIndex<TableDef, I> {
   delete(colVal: IndexVal<TableDef, I>): boolean;
-  update(colVal: Prettify<RowType<TableDef>>): Prettify<RowType<TableDef>>;
 }
 
 /**

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

@@ -538,6 +538,11 @@ function makeTableView(
       .filter(x => x.data.tag === 'Unique')
       .some(x => columnSet.isSubsetOf(new Set(x.data.value.columns)));
 
+    const isPrimaryKey =
+      isUnique &&
+      column_ids.length === table.primaryKey.length &&
+      column_ids.every((id, i) => table.primaryKey[i] === id);
+
     const indexSerializers = column_ids.map(id =>
       AlgebraicType.makeSerializer(
         rowType.value.elements[id].algebraicType,
@@ -574,7 +579,7 @@ function makeTableView(
     let index: Index<any, any>;
     if (isUnique && serializeSinglePoint) {
       // numColumns == 1, unique index
-      index = {
+      const base = {
         find: (colVal: IndexVal<any, any>): RowType<any> | null => {
           const buf = LEAF_BUF;
           const point_len = serializeSinglePoint(buf, colVal);
@@ -595,7 +600,9 @@ function makeTableView(
           );
           return num > 0;
         },
-        update: (row: RowType<any>): RowType<any> => {
+      };
+      if (isPrimaryKey) {
+        (base as any).update = (row: RowType<any>): RowType<any> => {
           const buf = LEAF_BUF;
           BINARY_WRITER.reset(buf);
           serializeRow(BINARY_WRITER, row);
@@ -607,11 +614,12 @@ function makeTableView(
           );
           integrateGeneratedColumns?.(row, buf.view);
           return row;
-        },
-      } as UniqueIndex<any, any>;
+        };
+      }
+      index = base as UniqueIndex<any, any>;
     } else if (isUnique) {
       // numColumns != 1, unique index
-      index = {
+      const base = {
         find: (colVal: IndexVal<any, any>): RowType<any> | null => {
           if (colVal.length !== numColumns) {
             throw new TypeError('wrong number of elements');
@@ -638,7 +646,9 @@ function makeTableView(
           );
           return num > 0;
         },
-        update: (row: RowType<any>): RowType<any> => {
+      };
+      if (isPrimaryKey) {
+        (base as any).update = (row: RowType<any>): RowType<any> => {
           const buf = LEAF_BUF;
           BINARY_WRITER.reset(buf);
           serializeRow(BINARY_WRITER, row);
@@ -650,8 +660,9 @@ function makeTableView(
           );
           integrateGeneratedColumns?.(row, buf.view);
           return row;
-        },
-      } as UniqueIndex<any, any>;
+        };
+      }
+      index = base as UniqueIndex<any, any>;
     } else if (serializeSinglePoint) {
       // numColumns == 1
       const rawIndex = {

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

@@ -45,4 +45,18 @@ spacetimedb.init(ctx => {
   const _id2 = ctx.db.person.id2;
 
   ctx.db.person.id.find(2);
+
+  // update() is allowed on primary key indexes
+  ctx.db.person.id.update({
+    id: 1,
+    name: '',
+    name2: '',
+    married: false,
+    id2: '' as any,
+    age: 0,
+    age2: 0,
+  });
+
+  // @ts-expect-error update() is NOT allowed on non-PK unique indexes
+  const _update = ctx.db.person.name2.update;
 });

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

@@ -274,6 +274,11 @@ pub trait Column {
     fn get_field(row: &<Self::Table as Table>::Row) -> &Self::ColType;
 }
 
+/// A marker trait for columns that are the primary key of their table.
+///
+/// This is used to restrict [`UniqueColumn::update`] to only work on primary key columns.
+pub trait PrimaryKey {}
+
 /// A handle to a unique index on a column.
 /// Available for `#[unique]` and `#[primary_key]` columns.
 ///
@@ -358,13 +363,21 @@ impl<Tbl: Table, Col: Index + Column<Table = Tbl>> UniqueColumn<Tbl, Col::ColTyp
     /// Deletes the row where the value in the unique column matches that in the corresponding field of `new_row`, and
     /// then inserts the `new_row`.
     ///
-    /// Returns the new row as actually inserted, with  computed values substituted for any auto-inc placeholders.
+    /// Returns the new row as actually inserted, with computed values substituted for any auto-inc placeholders.
+    ///
+    /// This method can only be called on primary key columns, not any unique column.
+    /// This prevents confusion regarding what constitutes a row update vs. a delete+insert.
+    /// To perform this operation for a non-primary unique column, call
+    /// `.delete(key)` followed by `.insert(row)`.
     ///
     /// # Panics
     /// Panics if no row was previously present with the matching value in the unique column,
     /// or if either the delete or the insertion would violate a constraint.
     #[track_caller]
-    pub fn update(&self, new_row: Tbl::Row) -> Tbl::Row {
+    pub fn update(&self, new_row: Tbl::Row) -> Tbl::Row
+    where
+        Col: PrimaryKey,
+    {
         let buf = IterBuf::take();
         update::<Tbl>(Col::index_id(), new_row, buf)
     }

crates/bindings/src/table.rs

@@ -281,9 +281,9 @@ ulong current_time_ms
         targetable.quad = new_hash;
         ctx.Db.game_targetable_state.entity_id.Update(targetable);
 
-        if (ctx.Db.game_live_targetable_state.entity_id.Find(entity_id) is not null)
+        if (ctx.Db.game_live_targetable_state.entity_id.Delete(entity_id))
         {
-            ctx.Db.game_live_targetable_state.entity_id.Update(new(entity_id, new_hash));
+            ctx.Db.game_live_targetable_state.Insert(new(entity_id, new_hash));
         }
 
         GameMobileEntityState mobile_entity =

modules/benchmarks-cs/ia_loop.cs

@@ -9,7 +9,7 @@ public static partial class synthetic
     [SpacetimeDB.Table(Name = "unique_0_u32_u64_str")]
     public partial struct unique_0_u32_u64_str_t
     {
-        [Unique]
+        [PrimaryKey]
         public uint id;
         public ulong age;
         public string name;
@@ -39,7 +39,7 @@ public partial struct btree_each_column_u32_u64_str_t
     [SpacetimeDB.Table(Name = "unique_0_u32_u64_u64")]
     public partial struct unique_0_u32_u64_u64_t
     {
-        [Unique]
+        [PrimaryKey]
         public uint id;
         public ulong x;
         public ulong y;