Allow describing an index from a given Type.

src/YesSql.Abstractions/Indexes/DescribeContext.cs

@@ -6,7 +6,7 @@ namespace YesSql.Indexes
 {
     public class DescribeContext<T> : IDescriptor
     {
-        private readonly Dictionary<Type, List<IDescribeFor>> _describes = new Dictionary<Type, List<IDescribeFor>>();
+        private readonly Dictionary<Type, List<IDescribeFor>> _describes = [];
 
         public IEnumerable<IndexDescriptor> Describe(params Type[] types)
         {
@@ -25,21 +25,37 @@ public IEnumerable<IndexDescriptor> Describe(params Type[] types)
                 });
         }
 
+        public IMapFor<T, IIndex> For(Type indexType)
+        {
+            return For<IIndex, object>(indexType);
+        }
+
         public IMapFor<T, TIndex> For<TIndex>() where TIndex : IIndex
         {
-            return For<TIndex, object>();
+            return For<TIndex, object>(typeof(TIndex));
         }
 
         public IMapFor<T, TIndex> For<TIndex, TKey>() where TIndex : IIndex
         {
+            return For<TIndex, object>(typeof(TIndex));
+        }
+
+        public IMapFor<T, TIndex> For<TIndex, TKey>(Type indexType) where TIndex : IIndex
+        {
+            ArgumentNullException.ThrowIfNull(indexType, nameof(indexType));
+
             List<IDescribeFor> descriptors;
 
             if (!_describes.TryGetValue(typeof(T), out descriptors))
             {
-                descriptors = _describes[typeof(T)] = new List<IDescribeFor>();
+                descriptors = _describes[typeof(T)] = [];
             }
 
-            var describeFor = new IndexDescriptor<T, TIndex, TKey>();
+            var describeFor = new IndexDescriptor<T, TIndex, TKey>()
+            {
+                IndexType = indexType,
+            };
+
             descriptors.Add(describeFor);
 
             return describeFor;

src/YesSql.Abstractions/Indexes/DescribeFor.cs

@@ -51,8 +51,9 @@ public class IndexDescriptor<T, TIndex, TKey> : IDescribeFor, IMapFor<T, TIndex>
         private Func<object, bool> _filter;
 
         public PropertyInfo GroupProperty { get; set; }
-        public Type IndexType { get { return typeof(TIndex); } }
 
+        public Type IndexType { get; internal set; } = typeof(TIndex);
+
         public Func<object, bool> Filter => _filter;
 
         public IGroupFor<TIndex> Map(Func<T, IEnumerable<TIndex>> map)

src/YesSql.Core/Commands/IndexCommand.cs

@@ -15,16 +15,16 @@ namespace YesSql.Commands
 {
     public abstract class IndexCommand : IIndexCommand
     {
+        private const string _separator = ", ";
         protected const string ParameterSuffix = "_$$$";
-
-        protected readonly IStore _store;
+        protected static PropertyInfo[] KeysProperties = [typeof(IIndex).GetProperty("Id")];
 
         private static readonly ConcurrentDictionary<PropertyInfo, PropertyInfoAccessor> PropertyAccessors = new();
         private static readonly ConcurrentDictionary<string, PropertyInfo[]> TypeProperties = new();
         private static readonly ConcurrentDictionary<CompoundKey, string> InsertsList = new();
         private static readonly ConcurrentDictionary<CompoundKey, string> UpdatesList = new();
 
-        protected static PropertyInfo[] KeysProperties = new[] { typeof(IIndex).GetProperty("Id") };
+        protected readonly IStore _store;
 
         public abstract int ExecutionOrder { get; }
 
@@ -102,7 +102,7 @@ protected string Inserts(Type type, ISqlDialect dialect)
                         sbColumnList.Append(dialect.QuoteForColumnName(property.Name));
                         if (i < allProperties.Length - 1)
                         {
-                            sbColumnList.Append(", ");
+                            sbColumnList.Append(_separator);
                         }
                     }
 
@@ -113,14 +113,14 @@ protected string Inserts(Type type, ISqlDialect dialect)
                         sbParameterList.Append("@").Append(property.Name).Append(ParameterSuffix);
                         if (i < allProperties.Length - 1)
                         {
-                            sbParameterList.Append(", ");
+                            sbParameterList.Append(_separator);
                         }
                     }
 
                     if (typeof(MapIndex).IsAssignableFrom(type))
                     {
                         // We can set the document id 
-                        sbColumnList.Append(", ").Append(dialect.QuoteForColumnName("DocumentId"));
+                        sbColumnList.Append(_separator).Append(dialect.QuoteForColumnName("DocumentId"));
                         sbParameterList.Append(", @DocumentId").Append(ParameterSuffix);
                     }
 
@@ -164,7 +164,7 @@ protected string Updates(Type type, ISqlDialect dialect)
                     values.Append(dialect.QuoteForColumnName(property.Name) + " = @" + property.Name + ParameterSuffix);
                     if (i < allProperties.Length - 1)
                     {
-                        values.Append(", ");
+                        values.Append(_separator);
                     }
                 }
 

test/YesSql.Tests/CoreTests.cs

@@ -6296,6 +6296,92 @@ await session.SaveAsync(new Article
             Assert.Equal(10, result);
         }
 
+        [Fact]
+        public async Task PopulateIndexUsingGenericType()
+        {
+            var  _configuration1 = CreateConfiguration();
+            var store1 = await StoreFactory.CreateAndInitializeAsync(_configuration1);
+            await using (var connection = store1.Configuration.ConnectionFactory.CreateConnection())
+            {
+                await connection.OpenAsync();
+
+                await using var transaction = await connection.BeginTransactionAsync(store1.Configuration.IsolationLevel);
+                var builder = new SchemaBuilder(store1.Configuration, transaction);
+
+                await builder
+                    .DropMapIndexTableAsync<PropertyIndex>();
+
+                await builder
+                    .CreateMapIndexTableAsync<PropertyIndex>(column => column
+                        .Column<string>(nameof(PropertyIndex.Name), col => col.WithLength(254))
+                        .Column<bool>(nameof(PropertyIndex.ForRent))
+                        .Column<bool>(nameof(PropertyIndex.IsOccupied))
+                        .Column<string>(nameof(PropertyIndex.Location), col => col.WithLength(500))
+                    );
+
+                await builder
+                    .AlterTableAsync(nameof(PropertyIndex), table => table
+                        .CreateIndex("IDX_Property", "Name", "ForRent", "IsOccupied"));
+
+                await transaction.CommitAsync();
+            }
+
+            store1.RegisterIndexes<PropertyDynamicIndexProvider>();
+
+            var typeDef = new DynamicTypeDef()
+            {
+                NameSpace = "TestDynamicIndexNameSpace",
+                ClassName = "PropertyIndex",
+                Fields = new[] {
+                    new DynamicField { Name="Name",FieldType=typeof(string)},
+                    new DynamicField { Name="ForRent",FieldType=typeof(bool)},
+                    new DynamicField { Name="IsOccupied",FieldType=typeof(bool)},
+                    new DynamicField { Name = "Location", FieldType = typeof(string)}
+                }
+            };
+
+            var dynamicType = DynamicTypeGeneratorSample.GenType(typeDef);
+
+            PropertyDynamicIndexProvider.IndexTypeCache[dynamicType.FullName] = dynamicType;
+
+            await using var session = store1.CreateSession();
+            var property = new Property
+            {
+                Name = new string('*', 40),
+                IsOccupied = true,
+                ForRent = true,
+                Location = new string('*', 500)
+            };
+
+            await session.SaveAsync(property);
+            await session.SaveChangesAsync();
+            var testProperties = await session.Query<Property, PropertyIndex>(x => x.Id == 1).ListAsync();
+            Assert.NotEmpty(testProperties);
+
+            // Emulating the usage scenario in OrchardCore, the store may be initialized multiple times
+
+            var _configuration2 = CreateConfiguration();
+            var store2 = await StoreFactory.CreateAndInitializeAsync(_configuration2);
+            store2.RegisterIndexes<PropertyDynamicIndexProvider>();
+
+            // In production environment, we may change this type at any time
+            var changedType = DynamicTypeGeneratorSample.GenType(typeDef);
+
+            Assert.NotEqual(changedType, dynamicType);
+
+            PropertyDynamicIndexProvider.IndexTypeCache[dynamicType.FullName] = changedType;
+
+            await using var session2 = store2.CreateSession();
+            var testPropEntity = testProperties.FirstOrDefault();
+            await session2.SaveAsync(testPropEntity);
+            await session2.SaveChangesAsync();
+            var testProperties2 = await session2.Query<Property, PropertyIndex>().ListAsync();
+            Assert.NotEmpty(testProperties2);
+
+        }
+
+
+
         #region FilterTests
 
         [Fact]

test/YesSql.Tests/Indexes/DynamicTypeGeneratorSample.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Reflection.Emit;
+using YesSql.Indexes;
+
+namespace YesSql.Tests.Indexes
+{
+    public class DynamicTypeGeneratorSample
+    {
+        public static Type GenType(DynamicTypeDef dynamicTypeDef)
+        {
+            var nameSpace = dynamicTypeDef.NameSpace;
+            var indexTypeFullName = dynamicTypeDef.NameSpace + "." + dynamicTypeDef.ClassName;
+            var assemblyName = "DynamicTypesAssembly";
+            // Create the dynamic assembly
+            AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(
+                new AssemblyName(assemblyName), AssemblyBuilderAccess.Run);
+
+            // Create a dynamic module in the assembly
+            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(nameSpace);
+            // Define the type
+            TypeBuilder typeBuilder = moduleBuilder.DefineType(indexTypeFullName, TypeAttributes.Public);
+
+            typeBuilder.SetParent(typeof(MapIndex));
+
+            foreach (var item in dynamicTypeDef.Fields)
+            {
+                BuildProperties(typeBuilder, item);
+            }
+            // Create the type
+            Type dynamicType = typeBuilder.CreateType();
+            // Return the dynamic type
+            return dynamicType;
+        }
+
+
+
+        private static PropertyBuilder BuildProperties(TypeBuilder typeBuilder, DynamicField item)
+        {
+            var propertyName = item.Name;
+            var propType = item.FieldType;
+
+            // Define the property
+            PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(propertyName, PropertyAttributes.None, propType, null);
+            FieldBuilder fieldBuilder = typeBuilder.DefineField("_" + propertyName, propType, FieldAttributes.Private);
+
+            // 使用 IL API 生成类型属性访问器
+            // Define the getter method
+            MethodBuilder getterBuilder = typeBuilder.DefineMethod("get_" + propertyName,
+                MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propType, Type.EmptyTypes);
+
+            ILGenerator getterIL = getterBuilder.GetILGenerator();
+            getterIL.Emit(OpCodes.Ldarg_0);
+            getterIL.Emit(OpCodes.Ldfld, fieldBuilder);
+            getterIL.Emit(OpCodes.Ret);
+
+
+            // Define the setter method
+            MethodBuilder setterBuilder = typeBuilder.DefineMethod("set_" + propertyName,
+                MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new[] { propType });
+            // Define the setter method
+            ILGenerator setterIL = setterBuilder.GetILGenerator();
+            setterIL.Emit(OpCodes.Ldarg_0);
+            setterIL.Emit(OpCodes.Ldarg_1);
+            setterIL.Emit(OpCodes.Stfld, fieldBuilder);
+            setterIL.Emit(OpCodes.Ret);
+
+            // Set the getter and setter methods for the property
+            propertyBuilder.SetGetMethod(getterBuilder);
+            propertyBuilder.SetSetMethod(setterBuilder);
+            return propertyBuilder;
+        }
+    }
+
+    public class DynamicTypeDef
+    {
+        public string NameSpace { get; set; }
+        public string ClassName { get; set; }
+        public IEnumerable<DynamicField> Fields { get; set; }
+    }
+    public class DynamicField
+    {
+        public string Name { get; set; }
+        public Type FieldType { get; set; }
+    }
+}

test/YesSql.Tests/Indexes/PropertyIndex.cs

@@ -1,3 +1,6 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using YesSql.Indexes;
 using YesSql.Tests.Models;
 
@@ -24,6 +27,48 @@ public override void Describe(DescribeContext<Property> context)
                     IsOccupied = property.IsOccupied,
                     Location = property.Location
                 });
+        }
+    }
+
+    public class PropertyDynamicIndexProvider : IndexProvider<Property>
+    {
+        public static Dictionary<string, Type> IndexTypeCache = new Dictionary<string, Type>();
+        public override void Describe(DescribeContext<Property> context)
+        {
+            foreach (var dynamicType in IndexTypeCache.Values)
+            {
+                context
+                 .For(dynamicType)
+                 .Map(property =>
+                 {
+                     // It's just a test. We only have one type
+                     var obj = Activator.CreateInstance(dynamicType);
+                     foreach (var prop in dynamicType.GetProperties())
+                     {
+                         switch (prop.Name)
+                         {
+                             case "Name":
+                                 prop.SetValue(obj, property.Name);
+                                 break;
+                             case "ForRent":
+                                 prop.SetValue(obj, property.ForRent);
+                                 break;
+                             case "IsOccupied":
+                                 prop.SetValue(obj, property.IsOccupied);
+                                 break;
+                             case "Location":
+                                 prop.SetValue(obj, property.Location);
+                                 break;
+                         }
+                     }
+
+                     return (MapIndex)obj;
+                 });
+            }
+
+
+
+
         }
     }
 }