Add support for index sort order (descending) (#27210)

Closes #4150

src/EFCore.Abstractions/IndexAttribute.cs

@@ -15,8 +15,9 @@ namespace Microsoft.EntityFrameworkCore;
 [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
 public sealed class IndexAttribute : Attribute
 {
- private bool? _isUnique;
  private string? _name;
+ private bool? _isUnique;
+ private bool[]? _isDescending;
 
  /// <summary>
  /// Initializes a new instance of the <see cref="IndexAttribute" /> class.
@@ -54,6 +55,24 @@ public bool IsUnique
  set => _isUnique = value;
  }
 
+ /// <summary>
+ /// A set of values indicating whether each corresponding index column has descending sort order.
+ /// </summary>
+ public bool[]? IsDescending
+ {
+ get => _isDescending;
+ set
+ {
+ if (value is not null && value.Length != PropertyNames.Count)
+ {
+ throw new ArgumentException(
+ AbstractionsStrings.InvalidNumberOfIndexSortOrderValues(value.Length, PropertyNames.Count), nameof(IsDescending));
+ }
+
+ _isDescending = value;
+ }
+ }
+
  /// <summary>
  /// Checks whether <see cref="IsUnique" /> has been explicitly set to a value.
  /// </summary>

src/EFCore.Abstractions/Properties/AbstractionsStrings.resx

@@ -129,4 +129,7 @@
  <data name="CollectionArgumentIsEmpty" xml:space="preserve">
  <value>The collection argument '{argumentName}' must contain at least one element.</value>
  </data>
+ <data name="InvalidNumberOfIndexSortOrderValues" xml:space="preserve">
+ <value>Invalid number of index sort order values: {numValues} values were provided, but the index has {numProperties} properties.</value>
+ </data>
 </root>

src/EFCore.Design/Migrations/Design/CSharpMigrationOperationGenerator.cs

@@ -911,6 +911,14 @@ protected virtual void Generate(CreateIndexOperation operation, IndentedStringBu
  .Append("unique: true");
  }
 
+ if (operation.IsDescending is not null)
+ {
+ builder
+ .AppendLine(",")
+ .Append("descending: ")
+ .Append(Code.Literal(operation.IsDescending));
+ }
+
  if (operation.Filter != null)
  {
  builder

src/EFCore.Design/Migrations/Design/CSharpSnapshotGenerator.cs

@@ -634,6 +634,15 @@ protected virtual void GenerateIndex(
  .Append(".IsUnique()");
  }
 
+ if (index.IsDescending is not null)
+ {
+ stringBuilder
+ .AppendLine()
+ .Append(".IsDescending(")
+ .Append(string.Join(", ", index.IsDescending.Select(Code.Literal)))
+ .Append(')');
+ }
+
  GenerateIndexAnnotations(indexBuilderName, index, stringBuilder);
  }
 

src/EFCore.Design/Scaffolding/Internal/CSharpDbContextGenerator.cs

@@ -567,6 +567,11 @@ private void GenerateIndex(IIndex index)
  lines.Add($".{nameof(IndexBuilder.IsUnique)}()");
  }
 
+ if (index.IsDescending is not null)
+ {
+ lines.Add($".{nameof(IndexBuilder.IsDescending)}({string.Join(", ", index.IsDescending.Select(d => _code.Literal(d)))})");
+ }
+
  GenerateAnnotations(index, annotations, lines);
 
  AppendMultiLineFluentApi(index.DeclaringEntityType, lines);

src/EFCore.Design/Scaffolding/Internal/CSharpEntityTypeGenerator.cs

@@ -212,6 +212,11 @@ private void GenerateIndexAttributes(IEntityType entityType)
  indexAttribute.AddParameter($"{nameof(IndexAttribute.IsUnique)} = {_code.Literal(index.IsUnique)}");
  }
 
+ if (index.IsDescending is not null)
+ {
+ indexAttribute.AddParameter($"{nameof(IndexAttribute.IsDescending)} = {_code.UnknownLiteral(index.IsDescending)}");
+ }
+
  _sb.AppendLine(indexAttribute.ToString());
  }
  }

src/EFCore.Design/Scaffolding/Internal/RelationalScaffoldingModelFactory.cs

@@ -627,9 +627,14 @@ protected virtual EntityTypeBuilder VisitIndexes(EntityTypeBuilder builder, ICol
 
  indexBuilder = indexBuilder.IsUnique(index.IsUnique);
 
+ if (index.IsDescending.Any(desc => desc))
+ {
+ indexBuilder = indexBuilder.IsDescending(index.IsDescending.ToArray());
+ }
+
  if (index.Filter != null)
  {
- indexBuilder.HasFilter(index.Filter);
+ indexBuilder = indexBuilder.HasFilter(index.Filter);
  }
 
  indexBuilder.Metadata.AddAnnotations(index.GetAnnotations());

src/EFCore.Relational/Metadata/ITableIndex.cs

@@ -39,6 +39,11 @@ public interface ITableIndex : IAnnotatable
  /// </summary>
  bool IsUnique { get; }
 
+ /// <summary>
+ /// A set of values indicating whether each corresponding index column has descending sort order.
+ /// </summary>
+ IReadOnlyList<bool>? IsDescending { get; }
+
  /// <summary>
  /// Gets the expression used as the index filter.
  /// </summary>
@@ -70,8 +75,21 @@ string ToDebugString(MetadataDebugStringOptions options = MetadataDebugStringOpt
 
  builder
  .Append(Name)
- .Append(' ')
- .Append(ColumnBase.Format(Columns));
+ .Append(" {")
+ .AppendJoin(
+ ", ",
+ Enumerable.Range(0, Columns.Count)
+ .Select(
+ i =>
+ $@"'{Columns[i].Name}'{(
+ MappedIndexes.First() is not RuntimeIndex
+ && IsDescending is not null
+ && i < IsDescending.Count
+ && IsDescending[i]
+ ? " Desc"
+ : ""
+ )}"))
+ .Append('}');
 
  if (IsUnique)
  {

src/EFCore.Relational/Metadata/Internal/RelationalIndexExtensions.cs

@@ -32,9 +32,9 @@ public static bool AreCompatible(
  {
  throw new InvalidOperationException(
  RelationalStrings.DuplicateIndexTableMismatch(
- index.Properties.Format(),
+ index.DisplayName(),
  index.DeclaringEntityType.DisplayName(),
- duplicateIndex.Properties.Format(),
+ duplicateIndex.DisplayName(),
  duplicateIndex.DeclaringEntityType.DisplayName(),
  index.GetDatabaseName(storeObject),
  index.DeclaringEntityType.GetSchemaQualifiedTableName(),
@@ -50,9 +50,9 @@ public static bool AreCompatible(
  {
  throw new InvalidOperationException(
  RelationalStrings.DuplicateIndexColumnMismatch(
- index.Properties.Format(),
+ index.DisplayName(),
  index.DeclaringEntityType.DisplayName(),
- duplicateIndex.Properties.Format(),
+ duplicateIndex.DisplayName(),
  duplicateIndex.DeclaringEntityType.DisplayName(),
  index.DeclaringEntityType.GetSchemaQualifiedTableName(),
  index.GetDatabaseName(storeObject),
@@ -69,9 +69,29 @@ public static bool AreCompatible(
  {
  throw new InvalidOperationException(
  RelationalStrings.DuplicateIndexUniquenessMismatch(
- index.Properties.Format(),
+ index.DisplayName(),
  index.DeclaringEntityType.DisplayName(),
- duplicateIndex.Properties.Format(),
+ duplicateIndex.DisplayName(),
+ duplicateIndex.DeclaringEntityType.DisplayName(),
+ index.DeclaringEntityType.GetSchemaQualifiedTableName(),
+ index.GetDatabaseName(storeObject)));
+ }
+
+ return false;
+ }
+
+ if (index.IsDescending is null != duplicateIndex.IsDescending is null
+ || (index.IsDescending is not null
+ && duplicateIndex.IsDescending is not null
+ && !index.IsDescending.SequenceEqual(duplicateIndex.IsDescending)))
+ {
+ if (shouldThrow)
+ {
+ throw new InvalidOperationException(
+ RelationalStrings.DuplicateIndexSortOrdersMismatch(
+ index.DisplayName(),
+ index.DeclaringEntityType.DisplayName(),
+ duplicateIndex.DisplayName(),
  duplicateIndex.DeclaringEntityType.DisplayName(),
  index.DeclaringEntityType.GetSchemaQualifiedTableName(),
  index.GetDatabaseName(storeObject)));
@@ -82,16 +102,21 @@ public static bool AreCompatible(
 
  if (index.GetFilter(storeObject) != duplicateIndex.GetFilter(storeObject))
  {
- throw new InvalidOperationException(
- RelationalStrings.DuplicateIndexFiltersMismatch(
- index.Properties.Format(),
- index.DeclaringEntityType.DisplayName(),
- duplicateIndex.Properties.Format(),
- duplicateIndex.DeclaringEntityType.DisplayName(),
- index.DeclaringEntityType.GetSchemaQualifiedTableName(),
- index.GetDatabaseName(storeObject),
- index.GetFilter(),
- duplicateIndex.GetFilter()));
+ if (shouldThrow)
+ {
+ throw new InvalidOperationException(
+ RelationalStrings.DuplicateIndexFiltersMismatch(
+ index.DisplayName(),
+ index.DeclaringEntityType.DisplayName(),
+ duplicateIndex.DisplayName(),
+ duplicateIndex.DeclaringEntityType.DisplayName(),
+ index.DeclaringEntityType.GetSchemaQualifiedTableName(),
+ index.GetDatabaseName(storeObject),
+ index.GetFilter(),
+ duplicateIndex.GetFilter()));
+ }
+
+ return false;
  }
 
  return true;

src/EFCore.Relational/Metadata/Internal/TableIndex.cs

@@ -68,6 +68,10 @@ public override bool IsReadOnly
  /// <inheritdoc />
  public virtual bool IsUnique { get; }
 
+ /// <inheritdoc />
+ public virtual IReadOnlyList<bool>? IsDescending
+ => MappedIndexes.First().IsDescending;
+
  /// <inheritdoc />
  public virtual string? Filter
  => MappedIndexes.First().GetFilter(StoreObjectIdentifier.Table(Table.Name, Table.Schema));

src/EFCore.Relational/Migrations/Internal/MigrationsModelDiffer.cs

@@ -1393,6 +1393,10 @@ protected virtual IEnumerable<MigrationOperation> Diff(
 
  private bool IndexStructureEquals(ITableIndex source, ITableIndex target, DiffContext diffContext)
  => source.IsUnique == target.IsUnique
+ && ((source.IsDescending is null && target.IsDescending is null)
+ || (source.IsDescending is not null
+ && target.IsDescending is not null
+ && source.IsDescending.SequenceEqual(target.IsDescending)))
  && source.Filter == target.Filter
  && !HasDifferences(source.GetAnnotations(), target.GetAnnotations())
  && source.Columns.Select(p => p.Name).SequenceEqual(

src/EFCore.Relational/Migrations/MigrationBuilder.cs

@@ -601,21 +601,27 @@ public virtual AlterOperationBuilder<AlterTableOperation> AlterTable(
  /// <param name="schema">The schema that contains the table, or <see langword="null" /> to use the default schema.</param>
  /// <param name="unique">Indicates whether or not the index enforces uniqueness.</param>
  /// <param name="filter">The filter to apply to the index, or <see langword="null" /> for no filter.</param>
+ /// <param name="descending">
+ /// A set of values indicating whether each corresponding index column has descending sort order.
+ /// If <see langword="null" />, all columns will have ascending order.
+ /// </param>
  /// <returns>A builder to allow annotations to be added to the operation.</returns>
  public virtual OperationBuilder<CreateIndexOperation> CreateIndex(
  string name,
  string table,
  string column,
  string? schema = null,
  bool unique = false,
- string? filter = null)
+ string? filter = null,
+ bool[]? descending = null)
  => CreateIndex(
  name,
  table,
  new[] { Check.NotEmpty(column, nameof(column)) },
  schema,
  unique,
- filter);
+ filter,
+ descending);
 
  /// <summary>
  /// Builds a <see cref="CreateIndexOperation" /> to create a new composite (multi-column) index.
@@ -629,14 +635,19 @@ public virtual OperationBuilder<CreateIndexOperation> CreateIndex(
  /// <param name="schema">The schema that contains the table, or <see langword="null" /> to use the default schema.</param>
  /// <param name="unique">Indicates whether or not the index enforces uniqueness.</param>
  /// <param name="filter">The filter to apply to the index, or <see langword="null" /> for no filter.</param>
+ /// <param name="descending">
+ /// A set of values indicating whether each corresponding index column has descending sort order.
+ /// If <see langword="null" />, all columns will have ascending order.
+ /// </param>
  /// <returns>A builder to allow annotations to be added to the operation.</returns>
  public virtual OperationBuilder<CreateIndexOperation> CreateIndex(
  string name,
  string table,
  string[] columns,
  string? schema = null,
  bool unique = false,
- string? filter = null)
+ string? filter = null,
+ bool[]? descending = null)
  {
  Check.NotEmpty(name, nameof(name));
  Check.NotEmpty(table, nameof(table));
@@ -649,8 +660,10 @@ public virtual OperationBuilder<CreateIndexOperation> CreateIndex(
  Name = name,
  Columns = columns,
  IsUnique = unique,
+ IsDescending = descending,
  Filter = filter
  };
+
  Operations.Add(operation);
 
  return new OperationBuilder<CreateIndexOperation>(operation);