Add more types to filterable table

Author: mamcx

crates/codegen/tests/snapshots/codegen__codegen_csharp.snap

@@ -1570,6 +1570,42 @@ namespace SpacetimeDB
 
             public readonly BlobIndex Blob;
 
+            public sealed class ConnectionIdIndex : BTreeIndexBase<SpacetimeDB.ConnectionId>
+            {
+                protected override SpacetimeDB.ConnectionId GetKey(Filterable row) => row.ConnectionId;
+
+                public ConnectionIdIndex(FilterableHandle table) : base(table) { }
+            }
+
+            public readonly ConnectionIdIndex ConnectionId;
+
+            public sealed class IdentityIndex : BTreeIndexBase<SpacetimeDB.Identity>
+            {
+                protected override SpacetimeDB.Identity GetKey(Filterable row) => row.Identity;
+
+                public IdentityIndex(FilterableHandle table) : base(table) { }
+            }
+
+            public readonly IdentityIndex Identity;
+
+            public sealed class StrIndex : BTreeIndexBase<string>
+            {
+                protected override string GetKey(Filterable row) => row.Str;
+
+                public StrIndex(FilterableHandle table) : base(table) { }
+            }
+
+            public readonly StrIndex Str;
+
+            public sealed class TestCIndex : BTreeIndexBase<NamespaceTestC>
+            {
+                protected override NamespaceTestC GetKey(Filterable row) => row.TestC;
+
+                public TestCIndex(FilterableHandle table) : base(table) { }
+            }
+
+            public readonly TestCIndex TestC;
+
             public sealed class TimeDurationIndex : BTreeIndexBase<SpacetimeDB.TimeDuration>
             {
                 protected override SpacetimeDB.TimeDuration GetKey(Filterable row) => row.TimeDuration;
@@ -1591,6 +1627,10 @@ namespace SpacetimeDB
             internal FilterableHandle(DbConnection conn) : base(conn)
             {
                 Blob = new(this);
+                ConnectionId = new(this);
+                Identity = new(this);
+                Str = new(this);
+                TestC = new(this);
                 TimeDuration = new(this);
                 Timestamp = new(this);
             }
@@ -2185,6 +2225,14 @@ namespace SpacetimeDB
     [DataContract]
     public sealed partial class Filterable
     {
+        [DataMember(Name = "str")]
+        public string Str;
+        [DataMember(Name = "identity")]
+        public SpacetimeDB.Identity Identity;
+        [DataMember(Name = "connection_id")]
+        public SpacetimeDB.ConnectionId ConnectionId;
+        [DataMember(Name = "test_c")]
+        public NamespaceTestC TestC;
         [DataMember(Name = "timestamp")]
         public SpacetimeDB.Timestamp Timestamp;
         [DataMember(Name = "time_duration")]
@@ -2193,18 +2241,27 @@ namespace SpacetimeDB
         public System.Collections.Generic.List<byte> Blob;
 
         public Filterable(
+            string Str,
+            SpacetimeDB.Identity Identity,
+            SpacetimeDB.ConnectionId ConnectionId,
+            NamespaceTestC TestC,
             SpacetimeDB.Timestamp Timestamp,
             SpacetimeDB.TimeDuration TimeDuration,
             System.Collections.Generic.List<byte> Blob
         )
         {
+            this.Str = Str;
+            this.Identity = Identity;
+            this.ConnectionId = ConnectionId;
+            this.TestC = TestC;
             this.Timestamp = Timestamp;
             this.TimeDuration = TimeDuration;
             this.Blob = Blob;
         }
 
         public Filterable()
         {
+            this.Str = "";
             this.Blob = new();
         }
     }

crates/codegen/tests/snapshots/codegen__codegen_rust.snap

@@ -814,6 +814,7 @@ use spacetimedb_sdk::__codegen::{
 	__ws,
 };
 use super::filterable_type::Filterable;
+use super::namespace_test_c_type::NamespaceTestC;
 
 /// Table handle for the table `filterable`.
 ///
@@ -916,10 +917,15 @@ use spacetimedb_sdk::__codegen::{
 	__ws,
 };
 
+use super::namespace_test_c_type::NamespaceTestC;
 
 #[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
 #[sats(crate = __lib)]
 pub struct Filterable {
+    pub str: String,
+    pub identity: __sdk::Identity,
+    pub connection_id: __sdk::ConnectionId,
+    pub test_c: NamespaceTestC,
     pub timestamp: __sdk::Timestamp,
     pub time_duration: __sdk::TimeDuration,
     pub blob: Vec::<u8>,
@@ -4615,9 +4621,9 @@ use spacetimedb_sdk::__codegen::{
 	__ws,
 };
 
+use super::namespace_test_c_type::NamespaceTestC;
 use super::test_a_type::TestA;
 use super::test_b_type::TestB;
-use super::namespace_test_c_type::NamespaceTestC;
 use super::namespace_test_f_type::NamespaceTestF;
 
 #[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]

crates/codegen/tests/snapshots/codegen__codegen_typescript.snap

@@ -554,6 +554,8 @@ import {
   type SubscriptionEventContextInterface,
 } from "@clockworklabs/spacetimedb-sdk";
 import { Filterable } from "./filterable_type";
+import { NamespaceTestC as __NamespaceTestC } from "./namespace_test_c_type";
+
 import { type EventContext, type Reducer, RemoteReducers, RemoteTables } from ".";
 
 /**
@@ -633,7 +635,13 @@ import {
   type ReducerEventContextInterface,
   type SubscriptionEventContextInterface,
 } from "@clockworklabs/spacetimedb-sdk";
+import { NamespaceTestC as __NamespaceTestC } from "./namespace_test_c_type";
+
 export type Filterable = {
+  str: string,
+  identity: Identity,
+  connectionId: ConnectionId,
+  testC: __NamespaceTestC,
   timestamp: Timestamp,
   timeDuration: TimeDuration,
   blob: Uint8Array,
@@ -649,6 +657,10 @@ export namespace Filterable {
   */
   export function getTypeScriptAlgebraicType(): AlgebraicType {
     return AlgebraicType.createProductType([
+      new ProductTypeElement("str", AlgebraicType.createStringType()),
+      new ProductTypeElement("identity", AlgebraicType.createIdentityType()),
+      new ProductTypeElement("connectionId", AlgebraicType.createConnectionIdType()),
+      new ProductTypeElement("testC", __NamespaceTestC.getTypeScriptAlgebraicType()),
       new ProductTypeElement("timestamp", AlgebraicType.createTimestampType()),
       new ProductTypeElement("timeDuration", AlgebraicType.createTimeDurationType()),
       new ProductTypeElement("blob", AlgebraicType.createArrayType(AlgebraicType.createU8Type())),
@@ -4037,9 +4049,9 @@ import {
   type SubscriptionEventContextInterface,
 } from "@clockworklabs/spacetimedb-sdk";
 
+import { NamespaceTestC as __NamespaceTestC } from "./namespace_test_c_type";
 import { TestA as __TestA } from "./test_a_type";
 import { TestB as __TestB } from "./test_b_type";
-import { NamespaceTestC as __NamespaceTestC } from "./namespace_test_c_type";
 import { NamespaceTestF as __NamespaceTestF } from "./namespace_test_f_type";
 
 export type Test = {

crates/lib/src/filterable_value.rs

@@ -19,6 +19,8 @@ use spacetimedb_sats::{hash::Hash, i256, u256, Serialize};
 /// - [`Identity`].
 /// - [`ConnectionId`].
 /// - [`Hash`](struct@Hash).
+/// - [`Timestamp`](struct@Timestamp).
+/// - [`TimeDuration`](struct@TimeDuration).
 /// - No-payload enums annotated with `#[derive(SpacetimeType)]`.
 ///   No-payload enums are sometimes called "plain," "simple" or "C-style."
 ///   They are enums where no variant has any payload data.

modules/module-test-cs/Lib.cs

@@ -175,6 +175,15 @@ public partial struct Player
 [Table(Name = "filterable")]
 public partial struct Filterable
 {
+    // Elided the trivial types as `int's, bool`...
+    [Index.BTree]
+    public String str;
+    [Index.BTree]
+    public Identity identity;
+    [Index.BTree]
+    public ConnectionId connection_id;
+    [Index.BTree]
+    public TestC test_c;
     [Index.BTree]
     public Timestamp timestamp;
     [Index.BTree]
@@ -429,10 +438,13 @@ public static void test_btree_index_args(ReducerContext ctx)
         ctx.Db.test_e.name.Delete("str");
 
         // Single-column indexes on `Filterable` table:
-        var _a1 = ctx.Db.filterable.timestamp.Filter(new Timestamp(0));
-        var _a2 = ctx.Db.filterable.time_duration.Filter(new TimeDuration(0));
-        var _a3 = ctx.Db.filterable.blob.Filter(new byte[] { 0x01, 0x02, 0x03 });
-
+        var _a1 = ctx.Db.filterable.str.Filter("string");
+        var _a2 = ctx.Db.filterable.identity.Filter(Identity.FromHexString("0x0"));
+        var _a3 = ctx.Db.filterable.test_c.Filter(TestC.Foo);
+        var _a4 = ctx.Db.filterable.connection_id.Filter(ConnectionId.Random());
+        var _a5 = ctx.Db.filterable.timestamp.Filter(new Timestamp(0));
+        var _a6 = ctx.Db.filterable.time_duration.Filter(new TimeDuration(0));
+        var _a7 = ctx.Db.filterable.blob.Filter([0x01, 0x02, 0x03]);
         // For the multi‑column index on points, assume the API offers overloads that accept ranges.
         var mci = ctx.Db.points.multi_column_index;
         var _a = mci.Filter(0L);

modules/module-test/src/lib.rs

@@ -161,9 +161,23 @@ pub struct Player {
     name: String,
 }
 
-/// Extra table for checking implementation of `FilterableValue` trait
+/// Extra table for checking implementation of `FilterableValue`.
+///
+/// See [`FilterableValue`](spacetimedb::spacetimedb_lib::FilterableValue) for more details.
 #[spacetimedb::table(name = filterable)]
 pub struct Filterable {
+    // Elided the trivial types as `int's, bool`...
+    #[index(btree)]
+    str: String,
+    #[index(btree)]
+    identity: Identity,
+    #[index(btree)]
+    connection_id: ConnectionId,
+    // Not available in C# yet, and we need to mirror the table definition.
+    // #[index(btree)]
+    // hash: Hash,
+    #[index(btree)]
+    test_c: TestC,
     #[index(btree)]
     timestamp: Timestamp,
     #[index(btree)]
@@ -380,6 +394,12 @@ fn test_btree_index_args(ctx: &ReducerContext) {
     // ctx.db.test_e().name().delete(string); // SHOULD FAIL
 
     // Single-column indexes on `Filterable` table:
+    let _ = ctx.db.filterable().str().filter("string");
+    let _ = ctx.db.filterable().identity().filter(Identity::ZERO);
+    let _ = ctx.db.filterable().identity().filter(&Identity::ZERO);
+    let _ = ctx.db.filterable().connection_id().filter(ConnectionId::ZERO);
+    let _ = ctx.db.filterable().connection_id().filter(&ConnectionId::ZERO);
+    let _ = ctx.db.filterable().test_c().filter(TestC::Foo);
     let _ = ctx
         .db
         .filterable()