Merge table cache into table handle (#139)

RReverser · web-flow · commit 23332824a9e3 · 2024-10-01T17:37:42.000+01:00
## Description of Changes

Merges cache into the table handle as suggested on the original PR +
hides most table methods that shouldn't be part of the stable API.

Few remaining methods will need a codegen change to be available only to
subclasses, so for now that's out of scope.

Same for merging ClientCache into RemoteTables - we shouldn't need a
separate collection, and instead could autogenerate a switch expression
over table name.

## API

 - [ ] This is an API breaking change to the SDK

*If the API is breaking, please state below what will break*


## Requires SpacetimeDB PRs
*List any PRs here that are required for this SDK change to work*
diff --git a/src/ClientCache.cs b/src/ClientCache.cs
@@ -6,74 +6,22 @@
 
 namespace SpacetimeDB
 {
+    // TODO: merge this into `RemoteTables`.
+    // It should just provide auto-generated `GetTable` and `GetTables` methods.
     public class ClientCache
     {
-        public interface ITableCache : IEnumerable<KeyValuePair<byte[], IDatabaseRow>>
-        {
-            Type ClientTableType { get; }
-            bool InsertEntry(byte[] rowBytes, IDatabaseRow value);
-            bool DeleteEntry(byte[] rowBytes);
-            IDatabaseRow DecodeValue(byte[] bytes);
-            IRemoteTableHandle Handle { get; }
-        }
-
-        public class TableCache<Row> : ITableCache
-            where Row : IDatabaseRow, new()
-        {
-            public TableCache(IRemoteTableHandle handle) => Handle = handle;
-
-            public IRemoteTableHandle Handle { get; init; }
-
-            public Type ClientTableType => typeof(Row);
-
-            public readonly Dictionary<byte[], Row> Entries = new(ByteArrayComparer.Instance);
-
-            /// <summary>
-            /// Inserts the value into the table. There can be no existing value with the provided BSATN bytes.
-            /// </summary>
-            /// <param name="rowBytes">The BSATN encoded bytes of the row to retrieve.</param>
-            /// <param name="value">The parsed row encoded by the <paramref>rowBytes</paramref>.</param>
-            /// <returns>True if the row was inserted, false if the row wasn't inserted because it was a duplicate.</returns>
-            public bool InsertEntry(byte[] rowBytes, IDatabaseRow value) => Entries.TryAdd(rowBytes, (Row)value);
-
-            /// <summary>
-            /// Deletes a value from the table.
-            /// </summary>
-            /// <param name="rowBytes">The BSATN encoded bytes of the row to remove.</param>
-            /// <returns>True if and only if the value was previously resident and has been deleted.</returns>
-            public bool DeleteEntry(byte[] rowBytes)
-            {
-                if (Entries.Remove(rowBytes))
-                {
-                    return true;
-                }
-
-                Log.Warn("Deleting value that we don't have (no cached value available)");
-                return false;
-            }
-
-            // The function to use for decoding a type value.
-            public IDatabaseRow DecodeValue(byte[] bytes) => BSATNHelpers.Decode<Row>(bytes);
-
-            public IEnumerator<KeyValuePair<byte[], IDatabaseRow>> GetEnumerator() => Entries.Select(kv => new KeyValuePair<byte[], IDatabaseRow>(kv.Key, kv.Value)).GetEnumerator();
-
-            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-        }
-
-        private readonly Dictionary<string, ITableCache> tables = new();
+        private readonly Dictionary<string, IRemoteTableHandle> tables = new();
 
-        public void AddTable<Row>(string name, IRemoteTableHandle handle)
+        public void AddTable<Row>(string name, IRemoteTableHandle table)
             where Row : IDatabaseRow, new()
         {
-            var cache = new TableCache<Row>(handle);
-            handle.SetCache(cache);
-            if (!tables.TryAdd(name, cache))
+            if (!tables.TryAdd(name, table))
             {
                 Log.Error($"Table with name already exists: {name}");
             }
         }
 
-        public ITableCache? GetTable(string name)
+        public IRemoteTableHandle? GetTable(string name)
         {
             if (tables.TryGetValue(name, out var table))
             {
@@ -84,6 +32,6 @@ public void AddTable<Row>(string name, IRemoteTableHandle handle)
             return null;
         }
 
-        public IEnumerable<ITableCache> GetTables() => tables.Values;
+        public IEnumerable<IRemoteTableHandle> GetTables() => tables.Values;
     }
 }
diff --git a/src/SpacetimeDBClient.cs b/src/SpacetimeDBClient.cs
@@ -87,10 +87,10 @@ public abstract class DbConnectionBase<DbConnection, Reducer> : IDbConnection
     {
         public static DbConnectionBuilder<DbConnection, Reducer> Builder() => new();
 
-        struct DbValue
+        readonly struct DbValue
         {
-            public IDatabaseRow value;
-            public byte[] bytes;
+            public readonly IDatabaseRow value;
+            public readonly byte[] bytes;
 
             public DbValue(IDatabaseRow value, byte[] bytes)
             {
@@ -101,7 +101,7 @@ public DbValue(IDatabaseRow value, byte[] bytes)
 
         struct DbOp
         {
-            public ClientCache.ITableCache table;
+            public IRemoteTableHandle table;
             public DbValue? delete;
             public DbValue? insert;
         }
@@ -193,12 +193,14 @@ struct PreProcessedMessage
         private readonly CancellationTokenSource _preProcessCancellationTokenSource = new();
         private CancellationToken _preProcessCancellationToken => _preProcessCancellationTokenSource.Token;
 
-        static DbValue Decode(ClientCache.ITableCache table, EncodedValue value) => value switch
+        static DbValue Decode(IRemoteTableHandle table, EncodedValue value, out object? primaryKey)
         {
-            EncodedValue.Binary(var bin) => new DbValue(table.DecodeValue(bin), bin),
-            EncodedValue.Text(var text) => throw new InvalidOperationException("JavaScript messages aren't supported."),
-            _ => throw new InvalidOperationException(),
-        };
+            // We expect only binary messages here; let type cast exception take care of any others.
+            var bin = ((EncodedValue.Binary)value).Binary_;
+            var obj = table.DecodeValue(bin);
+            primaryKey = table.GetPrimaryKey(obj);
+            return new(obj, bin);
+        }
 
         private static readonly Status Committed = new Status.Committed(default);
         private static readonly Status OutOfEnergy = new Status.OutOfEnergy(default);
@@ -337,8 +339,7 @@ HashSet<byte[]> GetInsertHashSet(System.Type tableType, int tableSize)
 
                                 foreach (var row in update.Inserts)
                                 {
-                                    var op = new DbOp { table = table, insert = Decode(table, row) };
-                                    var pk = table.Handle.GetPrimaryKey(op.insert.Value.value);
+                                    var op = new DbOp { table = table, insert = Decode(table, row, out var pk) };
                                     if (pk != null)
                                     {
                                         // Compound key that we use for lookup.
@@ -373,8 +374,7 @@ HashSet<byte[]> GetInsertHashSet(System.Type tableType, int tableSize)
 
                                 foreach (var row in update.Deletes)
                                 {
-                                    var op = new DbOp { table = table, delete = Decode(table, row) };
-                                    var pk = table.Handle.GetPrimaryKey(op.delete.Value.value);
+                                    var op = new DbOp { table = table, delete = Decode(table, row, out var pk) };
                                     if (pk != null)
                                     {
                                         // Compound key that we use for lookup.
@@ -454,7 +454,7 @@ ProcessedMessage CalculateStateDiff(PreProcessedMessage preProcessedMessage)
                         continue;
                     }
 
-                    foreach (var (rowBytes, oldValue) in table.Where(kv => !hashSet.Contains(kv.Key)))
+                    foreach (var (rowBytes, oldValue) in table.IterEntries().Where(kv => !hashSet.Contains(kv.Key)))
                     {
                         processed.dbOps.Add(new DbOp
                         {
@@ -523,7 +523,7 @@ private void OnMessageProcessCompleteUpdate(IEventContext eventContext, List<DbO
                 {
                     try
                     {
-                        update.table.Handle.InvokeBeforeDelete(eventContext, oldValue);
+                        update.table.InvokeBeforeDelete(eventContext, oldValue);
                     }
                     catch (Exception e)
                     {
@@ -542,7 +542,7 @@ private void OnMessageProcessCompleteUpdate(IEventContext eventContext, List<DbO
                 {
                     if (update.table.DeleteEntry(delete.bytes))
                     {
-                        update.table.Handle.InternalInvokeValueDeleted(delete.value);
+                        update.table.InternalInvokeValueDeleted(delete.value);
                     }
                     else
                     {
@@ -555,7 +555,7 @@ private void OnMessageProcessCompleteUpdate(IEventContext eventContext, List<DbO
                 {
                     if (update.table.InsertEntry(insert.bytes, insert.value))
                     {
-                        update.table.Handle.InternalInvokeValueInserted(insert.value);
+                        update.table.InternalInvokeValueInserted(insert.value);
                     }
                     else
                     {
@@ -573,17 +573,15 @@ private void OnMessageProcessCompleteUpdate(IEventContext eventContext, List<DbO
                     switch (dbOp)
                     {
                         case { insert: { value: var newValue }, delete: { value: var oldValue } }:
-                            {
-                                dbOp.table.Handle.InvokeUpdate(eventContext, oldValue, newValue);
-                                break;
-                            }
+                            dbOp.table.InvokeUpdate(eventContext, oldValue, newValue);
+                            break;
 
                         case { insert: { value: var newValue } }:
-                            dbOp.table.Handle.InvokeInsert(eventContext, newValue);
+                            dbOp.table.InvokeInsert(eventContext, newValue);
                             break;
 
                         case { delete: { value: var oldValue } }:
-                            dbOp.table.Handle.InvokeDelete(eventContext, oldValue);
+                            dbOp.table.InvokeDelete(eventContext, oldValue);
                             break;
                     }
                 }
diff --git a/src/Table.cs b/src/Table.cs
@@ -20,53 +20,89 @@ protected RemoteBase(DbConnection conn)
 
     public interface IRemoteTableHandle
     {
-        void SetCache(ClientCache.ITableCache cache);
-
+        // These methods need to be overridden by autogen.
         object? GetPrimaryKey(IDatabaseRow row);
-
         void InternalInvokeValueInserted(IDatabaseRow row);
         void InternalInvokeValueDeleted(IDatabaseRow row);
-        void InvokeInsert(IEventContext context, IDatabaseRow row);
-        void InvokeDelete(IEventContext context, IDatabaseRow row);
-        void InvokeBeforeDelete(IEventContext context, IDatabaseRow row);
-        void InvokeUpdate(IEventContext context, IDatabaseRow oldRow, IDatabaseRow newRow);
+
+        // These are provided by RemoteTableHandle.
+        internal Type ClientTableType { get; }
+        internal IEnumerable<KeyValuePair<byte[], IDatabaseRow>> IterEntries();
+        internal bool InsertEntry(byte[] rowBytes, IDatabaseRow value);
+        internal bool DeleteEntry(byte[] rowBytes);
+        internal IDatabaseRow DecodeValue(byte[] bytes);
+
+        internal void InvokeInsert(IEventContext context, IDatabaseRow row);
+        internal void InvokeDelete(IEventContext context, IDatabaseRow row);
+        internal void InvokeBeforeDelete(IEventContext context, IDatabaseRow row);
+        internal void InvokeUpdate(IEventContext context, IDatabaseRow oldRow, IDatabaseRow newRow);
     }
 
     public abstract class RemoteTableHandle<EventContext, Row> : IRemoteTableHandle
         where EventContext : class, IEventContext
         where Row : IDatabaseRow, new()
     {
-        public void SetCache(ClientCache.ITableCache cache) => Cache = (ClientCache.TableCache<Row>)cache;
+        // These methods need to be overridden by autogen.
+        public virtual object? GetPrimaryKey(IDatabaseRow row) => null;
+        public virtual void InternalInvokeValueInserted(IDatabaseRow row) { }
+        public virtual void InternalInvokeValueDeleted(IDatabaseRow row) { }
+
+        // These are provided by RemoteTableHandle.
+        Type IRemoteTableHandle.ClientTableType => typeof(Row);
+
+        private readonly Dictionary<byte[], Row> Entries = new(Internal.ByteArrayComparer.Instance);
+
+        IEnumerable<KeyValuePair<byte[], IDatabaseRow>> IRemoteTableHandle.IterEntries() =>
+            Entries.Select(kv => new KeyValuePair<byte[], IDatabaseRow>(kv.Key, kv.Value));
+
+        /// <summary>
+        /// Inserts the value into the table. There can be no existing value with the provided BSATN bytes.
+        /// </summary>
+        /// <param name="rowBytes">The BSATN encoded bytes of the row to retrieve.</param>
+        /// <param name="value">The parsed row encoded by the <paramref>rowBytes</paramref>.</param>
+        /// <returns>True if the row was inserted, false if the row wasn't inserted because it was a duplicate.</returns>
+        bool IRemoteTableHandle.InsertEntry(byte[] rowBytes, IDatabaseRow value) => Entries.TryAdd(rowBytes, (Row)value);
 
-        internal ClientCache.TableCache<Row>? Cache;
+        /// <summary>
+        /// Deletes a value from the table.
+        /// </summary>
+        /// <param name="rowBytes">The BSATN encoded bytes of the row to remove.</param>
+        /// <returns>True if and only if the value was previously resident and has been deleted.</returns>
+        bool IRemoteTableHandle.DeleteEntry(byte[] rowBytes)
+        {
+            if (Entries.Remove(rowBytes))
+            {
+                return true;
+            }
+
+            Log.Warn("Deleting value that we don't have (no cached value available)");
+            return false;
+        }
+
+        // The function to use for decoding a type value.
+        IDatabaseRow IRemoteTableHandle.DecodeValue(byte[] bytes) => BSATNHelpers.Decode<Row>(bytes);
 
         public event Action<EventContext, Row>? OnInsert;
         public event Action<EventContext, Row>? OnDelete;
         public event Action<EventContext, Row>? OnBeforeDelete;
         public event Action<EventContext, Row, Row>? OnUpdate;
 
-        public virtual object? GetPrimaryKey(IDatabaseRow row) => null;
-
-        public virtual void InternalInvokeValueInserted(IDatabaseRow row) { }
-
-        public virtual void InternalInvokeValueDeleted(IDatabaseRow row) { }
-
-        public int Count => Cache!.Entries.Count;
+        public int Count => Entries.Count;
 
-        public IEnumerable<Row> Iter() => Cache!.Entries.Values;
+        public IEnumerable<Row> Iter() => Entries.Values;
 
-        public IEnumerable<Row> Query(Func<Row, bool> filter) => Iter().Where(filter);
+        protected IEnumerable<Row> Query(Func<Row, bool> filter) => Iter().Where(filter);
 
-        public void InvokeInsert(IEventContext context, IDatabaseRow row) =>
+        void IRemoteTableHandle.InvokeInsert(IEventContext context, IDatabaseRow row) =>
             OnInsert?.Invoke((EventContext)context, (Row)row);
 
-        public void InvokeDelete(IEventContext context, IDatabaseRow row) =>
+        void IRemoteTableHandle.InvokeDelete(IEventContext context, IDatabaseRow row) =>
             OnDelete?.Invoke((EventContext)context, (Row)row);
 
-        public void InvokeBeforeDelete(IEventContext context, IDatabaseRow row) =>
+        void IRemoteTableHandle.InvokeBeforeDelete(IEventContext context, IDatabaseRow row) =>
             OnBeforeDelete?.Invoke((EventContext)context, (Row)row);
 
-        public void InvokeUpdate(IEventContext context, IDatabaseRow oldRow, IDatabaseRow newRow) =>
+        void IRemoteTableHandle.InvokeUpdate(IEventContext context, IDatabaseRow oldRow, IDatabaseRow newRow) =>
             OnUpdate?.Invoke((EventContext)context, (Row)oldRow, (Row)newRow);
     }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -87,10 +87,10 @@ public abstract class DbConnectionBase<DbConnection, Reducer> : IDbConnection`
`87`	`87`	`{`
`88`	`88`	`public static DbConnectionBuilder<DbConnection, Reducer> Builder() => new();`
`89`	`89`
`90`		`- struct DbValue`
	`90`	`+ readonly struct DbValue`
`91`	`91`	`{`
`92`		`- public IDatabaseRow value;`
`93`		`- public byte[] bytes;`
	`92`	`+ public readonly IDatabaseRow value;`
	`93`	`+ public readonly byte[] bytes;`
`94`	`94`
`95`	`95`	`public DbValue(IDatabaseRow value, byte[] bytes)`
`96`	`96`	`{`
`@@ -101,7 +101,7 @@ public DbValue(IDatabaseRow value, byte[] bytes)`
`101`	`101`
`102`	`102`	`struct DbOp`
`103`	`103`	`{`
`104`		`- public ClientCache.ITableCache table;`
	`104`	`+ public IRemoteTableHandle table;`
`105`	`105`	`public DbValue? delete;`
`106`	`106`	`public DbValue? insert;`
`107`	`107`	`}`
`@@ -193,12 +193,14 @@ struct PreProcessedMessage`
`193`	`193`	`private readonly CancellationTokenSource _preProcessCancellationTokenSource = new();`
`194`	`194`	`private CancellationToken _preProcessCancellationToken => _preProcessCancellationTokenSource.Token;`
`195`	`195`
`196`		`- static DbValue Decode(ClientCache.ITableCache table, EncodedValue value) => value switch`
	`196`	`+ static DbValue Decode(IRemoteTableHandle table, EncodedValue value, out object? primaryKey)`
`197`	`197`	`{`
`198`		`- EncodedValue.Binary(var bin) => new DbValue(table.DecodeValue(bin), bin),`
`199`		`- EncodedValue.Text(var text) => throw new InvalidOperationException("JavaScript messages aren't supported."),`
`200`		`- _ => throw new InvalidOperationException(),`
`201`		`- };`
	`198`	`+ // We expect only binary messages here; let type cast exception take care of any others.`
	`199`	`+ var bin = ((EncodedValue.Binary)value).Binary_;`
	`200`	`+ var obj = table.DecodeValue(bin);`
	`201`	`+ primaryKey = table.GetPrimaryKey(obj);`
	`202`	`+ return new(obj, bin);`
	`203`	`+ }`
`202`	`204`
`203`	`205`	`private static readonly Status Committed = new Status.Committed(default);`
`204`	`206`	`private static readonly Status OutOfEnergy = new Status.OutOfEnergy(default);`
`@@ -337,8 +339,7 @@ HashSet<byte[]> GetInsertHashSet(System.Type tableType, int tableSize)`
`337`	`339`
`338`	`340`	`foreach (var row in update.Inserts)`
`339`	`341`	`{`
`340`		`- var op = new DbOp { table = table, insert = Decode(table, row) };`
`341`		`- var pk = table.Handle.GetPrimaryKey(op.insert.Value.value);`
	`342`	`+ var op = new DbOp { table = table, insert = Decode(table, row, out var pk) };`
`342`	`343`	`if (pk != null)`
`343`	`344`	`{`
`344`	`345`	`// Compound key that we use for lookup.`
`@@ -373,8 +374,7 @@ HashSet<byte[]> GetInsertHashSet(System.Type tableType, int tableSize)`
`373`	`374`
`374`	`375`	`foreach (var row in update.Deletes)`
`375`	`376`	`{`
`376`		`- var op = new DbOp { table = table, delete = Decode(table, row) };`
`377`		`- var pk = table.Handle.GetPrimaryKey(op.delete.Value.value);`
	`377`	`+ var op = new DbOp { table = table, delete = Decode(table, row, out var pk) };`
`378`	`378`	`if (pk != null)`
`379`	`379`	`{`
`380`	`380`	`// Compound key that we use for lookup.`
`@@ -454,7 +454,7 @@ ProcessedMessage CalculateStateDiff(PreProcessedMessage preProcessedMessage)`
`454`	`454`	`continue;`
`455`	`455`	`}`
`456`	`456`
`457`		`- foreach (var (rowBytes, oldValue) in table.Where(kv => !hashSet.Contains(kv.Key)))`
	`457`	`+ foreach (var (rowBytes, oldValue) in table.IterEntries().Where(kv => !hashSet.Contains(kv.Key)))`
`458`	`458`	`{`
`459`	`459`	`processed.dbOps.Add(new DbOp`
`460`	`460`	`{`
`@@ -523,7 +523,7 @@ private void OnMessageProcessCompleteUpdate(IEventContext eventContext, List<DbO`
`523`	`523`	`{`
`524`	`524`	`try`
`525`	`525`	`{`
`526`		`- update.table.Handle.InvokeBeforeDelete(eventContext, oldValue);`
	`526`	`+ update.table.InvokeBeforeDelete(eventContext, oldValue);`
`527`	`527`	`}`
`528`	`528`	`catch (Exception e)`
`529`	`529`	`{`
`@@ -542,7 +542,7 @@ private void OnMessageProcessCompleteUpdate(IEventContext eventContext, List<DbO`
`542`	`542`	`{`
`543`	`543`	`if (update.table.DeleteEntry(delete.bytes))`
`544`	`544`	`{`
`545`		`- update.table.Handle.InternalInvokeValueDeleted(delete.value);`
	`545`	`+ update.table.InternalInvokeValueDeleted(delete.value);`
`546`	`546`	`}`
`547`	`547`	`else`
`548`	`548`	`{`
`@@ -555,7 +555,7 @@ private void OnMessageProcessCompleteUpdate(IEventContext eventContext, List<DbO`
`555`	`555`	`{`
`556`	`556`	`if (update.table.InsertEntry(insert.bytes, insert.value))`
`557`	`557`	`{`
`558`		`- update.table.Handle.InternalInvokeValueInserted(insert.value);`
	`558`	`+ update.table.InternalInvokeValueInserted(insert.value);`
`559`	`559`	`}`
`560`	`560`	`else`
`561`	`561`	`{`
`@@ -573,17 +573,15 @@ private void OnMessageProcessCompleteUpdate(IEventContext eventContext, List<DbO`
`573`	`573`	`switch (dbOp)`
`574`	`574`	`{`
`575`	`575`	`case { insert: { value: var newValue }, delete: { value: var oldValue } }:`
`576`		`- {`
`577`		`- dbOp.table.Handle.InvokeUpdate(eventContext, oldValue, newValue);`
`578`		`- break;`
`579`		`- }`
	`576`	`+ dbOp.table.InvokeUpdate(eventContext, oldValue, newValue);`
	`577`	`+ break;`
`580`	`578`
`581`	`579`	`case { insert: { value: var newValue } }:`
`582`		`- dbOp.table.Handle.InvokeInsert(eventContext, newValue);`
	`580`	`+ dbOp.table.InvokeInsert(eventContext, newValue);`
`583`	`581`	`break;`
`584`	`582`
`585`	`583`	`case { delete: { value: var oldValue } }:`
`586`		`- dbOp.table.Handle.InvokeDelete(eventContext, oldValue);`
	`584`	`+ dbOp.table.InvokeDelete(eventContext, oldValue);`
`587`	`585`	`break;`
`588`	`586`	`}`
`589`	`587`	`}`