Relations now support computed fields in secondary indexes.

Bobris · Bobris · commit 5a99700b23af · 2024-06-10T01:16:39.000+02:00
diff --git a/BTDB.SourceGenerator.Test/MetadataTests.StaticMembersMustBeSkippedInMetadata#TestNamespace.Person.g.verified.cs b/BTDB.SourceGenerator.Test/MetadataTests.StaticMembersMustBeSkippedInMetadata#TestNamespace.Person.g.verified.cs
@@ -0,0 +1,24 @@
+﻿//HintName: TestNamespace.Person.g.cs
+// <auto-generated/>
+#pragma warning disable 612,618
+using System;
+using System.Runtime.CompilerServices;
+
+namespace TestNamespace;
+
+[CompilerGenerated]
+static file class PersonRegistration
+{
+    [ModuleInitializer]
+    internal static unsafe void Register4BTDB()
+    {
+        global::BTDB.IOC.IContainer.RegisterFactory(typeof(global::TestNamespace.Person), (container, ctx) =>
+        {
+            return (container2, ctx2) =>
+            {
+                var res = new global::TestNamespace.Person();
+                return res;
+            };
+        });
+    }
+}
diff --git a/BTDB.SourceGenerator.Test/MetadataTests.cs b/BTDB.SourceGenerator.Test/MetadataTests.cs
@@ -24,6 +24,22 @@ public class Person
             """);
     }
 
+    [Fact]
+    public Task StaticMembersMustBeSkippedInMetadata()
+    {
+        // language=cs
+        return VerifySourceGenerator("""
+            namespace TestNamespace;
+
+            [BTDB.Generate]
+            public class Person
+            {
+                public static string Name { get; set; } = "";
+                public static int Age;
+            }
+            """);
+    }
+
     [Fact]
     public Task VerifyCollectionMetadata()
     {
diff --git a/BTDB/ODBLayer/RelationBuilder.cs b/BTDB/ODBLayer/RelationBuilder.cs
@@ -130,6 +130,12 @@ RelationVersionInfo CreateVersionInfoByReflection()
 
             if (actualPKAttribute != null)
             {
+                if (!pi.CanWrite)
+                {
+                    RelationInfoResolver.ActualOptions.ThrowBTDBException(
+                        $"Key field {pi.Name} must have setter, cannot be computed");
+                }
+
                 var fieldInfo = TableFieldInfo.Build(_name, pi, RelationInfoResolver.FieldHandlerFactory,
                     FieldHandlerOptions.Orderable, actualPKAttribute.InKeyValue);
                 if (fieldInfo.Handler!.NeedsCtx())
@@ -141,6 +147,12 @@ RelationVersionInfo CreateVersionInfoByReflection()
             var sks = pi.GetCustomAttributes(typeof(SecondaryKeyAttribute), true);
             var id = (int)(-actualPKAttribute?.Order ?? secondaryKeyFields.Count);
             List<SecondaryKeyAttribute> currentList = null;
+            if (sks.Length == 0 && !pi.CanWrite)
+            {
+                RelationInfoResolver.ActualOptions.ThrowBTDBException(
+                    $"Property {pi.Name} because it is not part of some secondary key must have setter, cannot be computed");
+            }
+
             for (var i = 0; i < sks.Length; i++)
             {
                 if (actualPKAttribute?.InKeyValue ?? false)
@@ -170,7 +182,7 @@ RelationVersionInfo CreateVersionInfoByReflection()
                     FieldHandlerOptions.None, false));
         }
 
-        return new RelationVersionInfo(primaryKeys, secondaryKeys, secondaryKeyFields.ToArray(), fields.ToArray());
+        return new(primaryKeys, secondaryKeys, secondaryKeyFields.ToArray(), fields.ToArray());
     }
 
     int RegisterLoadType(Type itemType)
diff --git a/BTDB/ODBLayer/RelationDBManipulator.cs b/BTDB/ODBLayer/RelationDBManipulator.cs
@@ -1423,8 +1423,7 @@ public unsafe object CreateInstanceFromSecondaryKey(RelationInfo.ItemLoaderInfo
         uint remappedSecondaryKeyIndex,
         in ReadOnlySpan<byte> secondaryKey)
     {
-        Span<byte> pkBuffer = stackalloc byte[512];
-        var pkWriter = MemWriter.CreateFromStackAllocatedSpan(pkBuffer);
+        var pkWriter = MemWriter.CreateFromStackAllocatedSpan(stackalloc byte[4096]);
         WriteRelationPKPrefix(ref pkWriter);
         fixed (void* _ = secondaryKey)
         {
@@ -1504,53 +1503,117 @@ void AddIntoSecondaryIndexes(T obj, ref MemWriter writer)
         }
     }
 
+    [SkipLocalsInit]
     bool UpdateSecondaryIndexes(in ReadOnlySpan<byte> oldKey, in ReadOnlySpan<byte> oldValue,
         in ReadOnlySpan<byte> newValue)
     {
         var changed = false;
-        foreach (var (key, _) in _relationInfo.ClientRelationVersionInfo.SecondaryKeys)
+        if (_relationInfo.ClientRelationVersionInfo.HasComputedField)
         {
-            var newKeyBytes = WriteSecondaryKeyKey(key, oldKey, newValue);
-            var oldKeyBytes = WriteSecondaryKeyKey(key, oldKey, oldValue);
-            if (oldKeyBytes.SequenceEqual(newKeyBytes))
-                continue;
-            //remove old index
-            EraseOldSecondaryKey(oldKey, oldKeyBytes, key);
-            //insert new value
-            _kvtr.CreateOrUpdateKeyValue(newKeyBytes, new());
-            changed = true;
+            var writer = MemWriter.CreateFromStackAllocatedSpan(stackalloc byte[4096]);
+            var writerOld = MemWriter.CreateFromStackAllocatedSpan(stackalloc byte[4096]);
+            var objOld = _relationInfo.ItemLoaderInfos[0].CreateInstance(_transaction, oldKey, oldValue);
+            var objNew = _relationInfo.ItemLoaderInfos[0].CreateInstance(_transaction, oldKey, newValue);
+
+            foreach (var (key, _) in _relationInfo.ClientRelationVersionInfo.SecondaryKeys)
+            {
+                writer.Reset();
+                writerOld.Reset();
+                var newKeyBytes = WriteSecondaryKeyKey(key, Unsafe.As<T>(objNew), ref writer);
+                var oldKeyBytes = WriteSecondaryKeyKey(key, Unsafe.As<T>(objOld), ref writerOld);
+                if (oldKeyBytes.SequenceEqual(newKeyBytes))
+                    continue;
+                //remove old index
+                EraseOldSecondaryKey(oldKey, oldKeyBytes, key);
+                //insert new value
+                _kvtr.CreateOrUpdateKeyValue(newKeyBytes, new());
+                changed = true;
+            }
+        }
+        else
+        {
+            foreach (var (key, _) in _relationInfo.ClientRelationVersionInfo.SecondaryKeys)
+            {
+                var newKeyBytes = WriteSecondaryKeyKey(key, oldKey, newValue);
+                var oldKeyBytes = WriteSecondaryKeyKey(key, oldKey, oldValue);
+                if (oldKeyBytes.SequenceEqual(newKeyBytes))
+                    continue;
+                //remove old index
+                EraseOldSecondaryKey(oldKey, oldKeyBytes, key);
+                //insert new value
+                _kvtr.CreateOrUpdateKeyValue(newKeyBytes, new());
+                changed = true;
+            }
         }
 
         return changed;
     }
 
+    [SkipLocalsInit]
     bool UpdateSecondaryIndexes(T newValue, in ReadOnlySpan<byte> oldKey, in ReadOnlySpan<byte> oldValue,
         ref MemWriter writer)
     {
         var changed = false;
-        foreach (var (key, _) in _relationInfo.ClientRelationVersionInfo.SecondaryKeys)
+        if (_relationInfo.ClientRelationVersionInfo.HasComputedField)
         {
-            writer.Reset();
-            var newKeyBytes = WriteSecondaryKeyKey(key, newValue, ref writer);
-            var oldKeyBytes = WriteSecondaryKeyKey(key, oldKey, oldValue);
-            if (oldKeyBytes.SequenceEqual(newKeyBytes))
-                continue;
-            //remove old index
-            EraseOldSecondaryKey(oldKey, oldKeyBytes, key);
-            //insert new value
-            _kvtr.CreateOrUpdateKeyValue(newKeyBytes, new());
-            changed = true;
+            var writerOld = MemWriter.CreateFromStackAllocatedSpan(stackalloc byte[4096]);
+            var obj = _relationInfo.ItemLoaderInfos[0].CreateInstance(_transaction, oldKey, oldValue);
+            foreach (var (key, _) in _relationInfo.ClientRelationVersionInfo.SecondaryKeys)
+            {
+                writer.Reset();
+                writerOld.Reset();
+                var newKeyBytes = WriteSecondaryKeyKey(key, newValue, ref writer);
+                var oldKeyBytes = WriteSecondaryKeyKey(key, Unsafe.As<T>(obj), ref writerOld);
+                if (oldKeyBytes.SequenceEqual(newKeyBytes))
+                    continue;
+                //remove old index
+                EraseOldSecondaryKey(oldKey, oldKeyBytes, key);
+                //insert new value
+                _kvtr.CreateOrUpdateKeyValue(newKeyBytes, new());
+                changed = true;
+            }
+        }
+        else
+        {
+            foreach (var (key, _) in _relationInfo.ClientRelationVersionInfo.SecondaryKeys)
+            {
+                writer.Reset();
+                var newKeyBytes = WriteSecondaryKeyKey(key, newValue, ref writer);
+                var oldKeyBytes = WriteSecondaryKeyKey(key, oldKey, oldValue);
+                if (oldKeyBytes.SequenceEqual(newKeyBytes))
+                    continue;
+                //remove old index
+                EraseOldSecondaryKey(oldKey, oldKeyBytes, key);
+                //insert new value
+                _kvtr.CreateOrUpdateKeyValue(newKeyBytes, new());
+                changed = true;
+            }
         }
 
         return changed;
     }
 
+    [SkipLocalsInit]
     void RemoveSecondaryIndexes(in ReadOnlySpan<byte> oldKey, in ReadOnlySpan<byte> oldValue)
     {
-        foreach (var (key, _) in _relationInfo.ClientRelationVersionInfo.SecondaryKeys)
+        if (_relationInfo.ClientRelationVersionInfo.HasComputedField)
         {
-            var keyBytes = WriteSecondaryKeyKey(key, oldKey, oldValue);
-            EraseOldSecondaryKey(oldKey, keyBytes, key);
+            var writer = MemWriter.CreateFromStackAllocatedSpan(stackalloc byte[4096]);
+            var obj = _relationInfo.ItemLoaderInfos[0].CreateInstance(_transaction, oldKey, oldValue);
+            foreach (var (key, _) in _relationInfo.ClientRelationVersionInfo.SecondaryKeys)
+            {
+                writer.Reset();
+                var keyBytes = WriteSecondaryKeyKey(key, Unsafe.As<T>(obj), ref writer);
+                EraseOldSecondaryKey(oldKey, keyBytes, key);
+            }
+        }
+        else
+        {
+            foreach (var (key, _) in _relationInfo.ClientRelationVersionInfo.SecondaryKeys)
+            {
+                var keyBytes = WriteSecondaryKeyKey(key, oldKey, oldValue);
+                EraseOldSecondaryKey(oldKey, keyBytes, key);
+            }
         }
     }
 
diff --git a/BTDB/ODBLayer/RelationInfo.cs b/BTDB/ODBLayer/RelationInfo.cs
@@ -101,6 +101,26 @@ internal unsafe object CreateInstance(IInternalObjectDBTransaction tr, in ReadOn
             }
         }
 
+        internal unsafe object CreateInstance(IInternalObjectDBTransaction tr, in ReadOnlySpan<byte> keyBytes,
+            in ReadOnlySpan<byte> valueBytes)
+        {
+            fixed (void* pKeyBytes = keyBytes)
+            {
+                var reader = new MemReader(pKeyBytes, keyBytes.Length);
+                reader.Skip1Byte(); // 3
+                reader.SkipVUInt64(); // RelationId
+                var obj = _primaryKeysLoader(tr, ref reader);
+                if (_primaryKeyIsEnough) return obj;
+                fixed (void* _ = valueBytes)
+                {
+                    reader = MemReader.CreateFromPinnedSpan(valueBytes);
+                    var version = reader.ReadVUInt32();
+                    GetValueLoader(version)(tr, ref reader, obj);
+                    return obj;
+                }
+            }
+        }
+
         internal readonly RelationLoaderFunc _primaryKeysLoader;
         internal readonly bool _primaryKeyIsEnough;
         readonly RelationLoader?[] _valueLoaders;
@@ -113,8 +133,15 @@ internal RelationLoader GetValueLoader(uint version)
             {
                 res = _valueLoaders[version];
                 if (res != null) return res;
+                StructList<TableFieldInfo> filteredFields = new();
+                foreach (var tableFieldInfo in _owner._relationVersions[version]!.Fields.Span)
+                {
+                    if (tableFieldInfo.Computed) continue;
+                    filteredFields.Add(tableFieldInfo);
+                }
+
                 res = CreateLoader(_itemType,
-                    _owner._relationVersions[version]!.Fields.Span,
+                    filteredFields,
                     $"RelationValueLoader_{_owner.Name}_{version}_{_itemType.ToSimpleName()}");
             } while (Interlocked.CompareExchange(ref _valueLoaders[version], res, null) != null);
 
@@ -741,11 +768,10 @@ void CalculateSecondaryKey(IInternalObjectDBTransaction tr,
                 keyWriter.WriteBlock(PrefixSecondary);
                 keyWriter.WriteUInt8((byte)indexes[i].Key);
                 keySavers[i](tr, ref keyWriter, obj!);
-                var keyBytes = keyWriter.GetSpan();
+                var keyBytes = keyWriter.GetSpanAndReset();
 
                 if (!tr.KeyValueDBTransaction.CreateOrUpdateKeyValue(keyBytes, new ReadOnlySpan<byte>()))
                     throw new BTDBException("Internal error, secondary key bytes must be always unique.");
-                keyWriter.Reset();
             }
         }
     }
@@ -809,7 +835,14 @@ void ResolveVersionInfos()
 
     void CreateCreatorLoadersAndSavers()
     {
-        _valueSaver = CreateSaver(ClientRelationVersionInfo.Fields.Span, $"RelationValueSaver_{Name}", false);
+        StructList<TableFieldInfo> filteredFields = new();
+        foreach (var tableFieldInfo in ClientRelationVersionInfo.Fields.Span)
+        {
+            if (tableFieldInfo.Computed) continue;
+            filteredFields.Add(tableFieldInfo);
+        }
+
+        _valueSaver = CreateSaver(filteredFields, $"RelationValueSaver_{Name}", false);
         _primaryKeysSaver = CreateSaver(ClientRelationVersionInfo.PrimaryKeyFields.Span,
             $"RelationKeySaver_{Name}", true);
         _beforeRemove = CreateBeforeRemove($"RelationBeforeRemove_{Name}");
diff --git a/BTDB/ODBLayer/RelationVersionInfo.cs b/BTDB/ODBLayer/RelationVersionInfo.cs
@@ -56,6 +56,7 @@ public class RelationVersionInfo
     ReadOnlyMemory<TableFieldInfo> _secondaryKeyFields;
     IDictionary<string, uint> _secondaryKeysNames;
     IDictionary<uint, SecondaryKeyInfo> _secondaryKeys;
+    public bool HasComputedField;
 
     public RelationVersionInfo(Dictionary<uint, TableFieldInfo> primaryKeyFields, //order -> info
         List<Tuple<int, IList<SecondaryKeyAttribute>>>
@@ -82,6 +83,13 @@ public RelationVersionInfo(Dictionary<uint, TableFieldInfo> primaryKeyFields, //
         _secondaryKeyFields = secondaryKeyFields;
         CreateSecondaryKeyInfo(secondaryKeys, primaryKeyFields);
         Fields = fields;
+        HasComputedField = false;
+        foreach (var tableFieldInfo in fields.Span)
+        {
+            if (!tableFieldInfo.Computed) continue;
+            HasComputedField = true;
+            break;
+        }
     }
 
     void CreateSecondaryKeyInfo(List<Tuple<int, IList<SecondaryKeyAttribute>>> attributes,
@@ -168,6 +176,13 @@ internal RelationVersionInfo(ReadOnlyMemory<TableFieldInfo> primaryKeyFields,
 
         _secondaryKeyFields = secondaryKeyFields;
         Fields = fields;
+        HasComputedField = false;
+        foreach (var tableFieldInfo in fields.Span)
+        {
+            if (!tableFieldInfo.Computed) continue;
+            HasComputedField = true;
+            break;
+        }
     }
 
     internal TableFieldInfo? this[string name]
@@ -332,7 +347,7 @@ public static RelationVersionInfo LoadUnresolved(ref MemReader reader, string re
             fieldInfos[i] = UnresolvedTableFieldInfo.Load(ref reader, relationName, FieldHandlerOptions.None);
         }
 
-        return new RelationVersionInfo(primaryKeyFields, secondaryKeys, secondaryKeyFields, fieldInfos);
+        return new(primaryKeyFields, secondaryKeys, secondaryKeyFields, fieldInfos);
     }
 
     public void ResolveFieldHandlers(IFieldHandlerFactory fieldHandlerFactory)
diff --git a/BTDB/ODBLayer/TableFieldInfo.cs b/BTDB/ODBLayer/TableFieldInfo.cs
diff --git a/BTDBTest/ObjectDbTableTest.cs b/BTDBTest/ObjectDbTableTest.cs
