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,7 @@ 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

@@ -16,6 +16,7 @@ namespace YesSql.Commands
     public abstract class IndexCommand : IIndexCommand
     {
         protected const string ParameterSuffix = "_$$$";
+        private const string _separator = ", ";
 
         protected readonly IStore _store;
 
@@ -24,7 +25,7 @@ public abstract class IndexCommand : IIndexCommand
         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 static PropertyInfo[] KeysProperties = [typeof(IIndex).GetProperty("Id")];
 
         public abstract int ExecutionOrder { get; }
 
@@ -102,7 +103,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 +114,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 +165,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/Indexes/PropertyIndex.cs

@@ -26,4 +26,20 @@ public override void Describe(DescribeContext<Property> context)
                 });
         }
     }
+
+    public class PropertyDynamicIndexProvider : IndexProvider<Property>
+    {
+        public override void Describe(DescribeContext<Property> context)
+        {
+            context
+                .For(typeof(PropertyIndex))
+                .Map(property => new PropertyIndex
+                {
+                    Name = property.Name,
+                    ForRent = property.ForRent,
+                    IsOccupied = property.IsOccupied,
+                    Location = property.Location
+                });
+        }
+    }
 }

test/YesSql.Tests/SqliteTests.cs

@@ -139,5 +139,50 @@ await builder
 
             await session.SaveAsync(property);
         }
+
+        [Fact]
+        public async Task ShouldDynamicIndexPropertyKeys()
+        {
+            await using (var connection = _store.Configuration.ConnectionFactory.CreateConnection())
+            {
+                await connection.OpenAsync();
+
+                await using var transaction = await connection.BeginTransactionAsync(_store.Configuration.IsolationLevel);
+                var builder = new SchemaBuilder(_store.Configuration, transaction);
+
+                await builder
+                    .DropMapIndexTableAsync<PropertyIndex>();
+
+                await builder
+                    .CreateMapIndexTableAsync<PropertyIndex>(column => column
+                        .Column<string>(nameof(PropertyIndex.Name), col => col.WithLength(4000))
+                        .Column<bool>(nameof(PropertyIndex.ForRent))
+                        .Column<bool>(nameof(PropertyIndex.IsOccupied))
+                        .Column<string>(nameof(PropertyIndex.Location), col => col.WithLength(4000))
+                    );
+
+                await builder
+                    .AlterTableAsync(nameof(PropertyIndex), table => table
+                        .CreateIndex("IDX_Property", "Name", "ForRent", "IsOccupied", "Location"));
+
+                await transaction.CommitAsync();
+            }
+
+            _store.RegisterIndexes<PropertyDynamicIndexProvider>();
+
+            await using var session = _store.CreateSession();
+            var property = new Property
+            {
+                Name = new string('*', 4000),
+                IsOccupied = true,
+                ForRent = true,
+                Location = new string('*', 4000)
+            };
+
+            await session.SaveAsync(property);
+            await session.SaveChangesAsync();
+            var idx = await session.Query<Property, PropertyIndex>(x => x.Id == 1).ListAsync();
+            Assert.NotEmpty(idx);
+        }
     }
 }