Add support for INCLUDE clause in indexes

src/EFCore.PG/Design/Internal/NpgsqlAnnotationCodeGenerator.cs

@@ -137,6 +137,8 @@ public override MethodCallCodeFragment GenerateFluentApi(IIndex index, IAnnotati
  return new MethodCallCodeFragment(nameof(NpgsqlIndexBuilderExtensions.ForNpgsqlHasMethod), annotation.Value);
  if (annotation.Name == NpgsqlAnnotationNames.IndexOperators)
  return new MethodCallCodeFragment(nameof(NpgsqlIndexBuilderExtensions.ForNpgsqlHasOperators), annotation.Value);
+ if (annotation.Name == NpgsqlAnnotationNames.IndexInclude)
+ return new MethodCallCodeFragment(nameof(NpgsqlIndexBuilderExtensions.ForNpgsqlInclude), annotation.Value);
 
  return null;
  }

src/EFCore.PG/Extensions/NpgsqlEntityTypeBuilderExtensions.cs

@@ -1,7 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Linq.Expressions;
 using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Internal;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Utilities;
 
 // ReSharper disable once CheckNamespace
@@ -136,5 +140,40 @@ public static EntityTypeBuilder<TEntity> ForCockroachDbInterleaveInParent<TEntit
  => (EntityTypeBuilder<TEntity>)ForCockroachDbInterleaveInParent((EntityTypeBuilder)entityTypeBuilder, parentTableType, interleavePrefix);
 
  #endregion CockroachDB Interleave-in-parent
+
+ #region Generic Index
+
+ /// <summary>
+ /// Configures an index on the specified properties. If there is an existing index on the given
+ /// set of properties, then the existing index will be returned for configuration.
+ /// </summary>
+ /// <typeparam name="TEntity"> The entity type being configured. </typeparam>
+ /// <param name="entityTypeBuilder"> The builder for the entity type being configured. </param>
+ /// <param name="indexExpression">
+ /// <para>
+ /// A lambda expression representing the property(s) to be included in the index
+ /// (<c>blog => blog.Url</c>).
+ /// </para>
+ /// <para>
+ /// If the index is made up of multiple properties then specify an anonymous type including the
+ /// properties (<c>post => new { post.Title, post.BlogId }</c>).
+ /// </para>
+ /// </param>
+ /// <returns> An object that can be used to configure the index. </returns>
+ public static IndexBuilder<TEntity> ForNpgsqlHasIndex<TEntity>(
+ [NotNull] this EntityTypeBuilder<TEntity> entityTypeBuilder,
+ [NotNull] Expression<Func<TEntity, object>> indexExpression)
+ where TEntity : class
+ {
+ Check.NotNull(entityTypeBuilder, nameof(entityTypeBuilder));
+ Check.NotNull(indexExpression, nameof(indexExpression));
+
+ var builder = ((IInfrastructure<InternalEntityTypeBuilder>)entityTypeBuilder).GetInfrastructure();
+
+ return new IndexBuilder<TEntity>(
+ builder.HasIndex(indexExpression.GetPropertyAccessList(), ConfigurationSource.Explicit));
+ }
+
+ #endregion
  }
 }

src/EFCore.PG/Extensions/NpgsqlIndexBuilderExtensions.cs

@@ -1,4 +1,9 @@
-using JetBrains.Annotations;
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Runtime.CompilerServices;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Internal;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Utilities;
 
@@ -19,7 +24,9 @@ public static class NpgsqlIndexBuilderExtensions
  /// <param name="indexBuilder"> The builder for the index being configured. </param>
  /// <param name="method"> The name of the index. </param>
  /// <returns> A builder to further configure the index. </returns>
- public static IndexBuilder ForNpgsqlHasMethod([NotNull] this IndexBuilder indexBuilder, [CanBeNull] string method)
+ public static IndexBuilder ForNpgsqlHasMethod(
+ [NotNull] this IndexBuilder indexBuilder,
+ [CanBeNull] string method)
  {
  Check.NotNull(indexBuilder, nameof(indexBuilder));
  Check.NullButNotEmpty(method, nameof(method));
@@ -38,7 +45,9 @@ public static IndexBuilder ForNpgsqlHasMethod([NotNull] this IndexBuilder indexB
  /// <param name="indexBuilder"> The builder for the index being configured. </param>
  /// <param name="operators"> The operators to use for each column. </param>
  /// <returns> A builder to further configure the index. </returns>
- public static IndexBuilder ForNpgsqlHasOperators([NotNull] this IndexBuilder indexBuilder, [CanBeNull] params string[] operators)
+ public static IndexBuilder ForNpgsqlHasOperators(
+ [NotNull] this IndexBuilder indexBuilder,
+ [CanBeNull, ItemNotNull] params string[] operators)
  {
  Check.NotNull(indexBuilder, nameof(indexBuilder));
  Check.NullButNotEmpty(operators, nameof(operators));
@@ -47,5 +56,58 @@ public static IndexBuilder ForNpgsqlHasOperators([NotNull] this IndexBuilder ind
 
  return indexBuilder;
  }
+
+ /// <summary>
+ /// Adds an INCLUDE clause to the index definition with the specified property names.
+ /// This clause specifies a list of columns which will be included as a non-key part in the index.
+ /// </summary>
+ /// <remarks>
+ /// https://www.postgresql.org/docs/current/sql-createindex.html
+ /// </remarks>
+ /// <param name="indexBuilder"> The builder for the index being configured. </param>
+ /// <param name="propertyNames"> An array of property names to be used in INCLUDE clause. </param>
+ /// <returns> A builder to further configure the index. </returns>
+ public static IndexBuilder ForNpgsqlInclude(
+ [NotNull] this IndexBuilder indexBuilder,
+ [CanBeNull, ItemNotNull] params string[] propertyNames)
+ {
+ Check.NotNull(indexBuilder, nameof(indexBuilder));
+ Check.NullButNotEmpty(propertyNames, nameof(propertyNames));
+
+ indexBuilder.Metadata.Npgsql().IncludeProperties = propertyNames;
+
+ return indexBuilder;
+ }
+
+ /// <summary>
+ /// Adds an INCLUDE clause to the index definition with property names from the specified expression.
+ /// This clause specifies a list of columns which will be included as a non-key part in the index.
+ /// </summary>
+ /// <remarks>
+ /// https://www.postgresql.org/docs/current/sql-createindex.html
+ /// </remarks>
+ /// <param name="indexBuilder"> The builder for the index being configured. </param>
+ /// <param name="includeExpression">
+ /// <para>
+ /// A lambda expression representing the property(s) to be included in the INCLUDE clause
+ /// (<c>blog => blog.Url</c>).
+ /// </para>
+ /// <para>
+ /// If multiple properties are to be included then specify an anonymous type including the
+ /// properties (<c>post => new { post.Title, post.BlogId }</c>).
+ /// </para>
+ /// </param>
+ /// <returns> A builder to further configure the index. </returns>
+ public static IndexBuilder<TEntity> ForNpgsqlInclude<TEntity>(
+ [NotNull] this IndexBuilder<TEntity> indexBuilder,
+ [NotNull] Expression<Func<TEntity, object>> includeExpression)
+ {
+ Check.NotNull(indexBuilder, nameof(indexBuilder));
+ Check.NotNull(includeExpression, nameof(includeExpression));
+
+ indexBuilder.ForNpgsqlInclude(includeExpression.GetPropertyAccessList().Select(x => x.Name).ToArray());
+
+ return indexBuilder;
+ }
  }
 }

src/EFCore.PG/Metadata/INpgsqlIndexAnnotations.cs

@@ -14,11 +14,19 @@ public interface INpgsqlIndexAnnotations : IRelationalIndexAnnotations
  string Method { get; }
 
  /// <summary>
- /// The PostgreSQL index operators to be used.
+ /// The PostgreSQL index operators to be used, or <c>null</c> if they have not been specified.
  /// </summary>
  /// <remarks>
  /// https://www.postgresql.org/docs/current/static/indexes-opclass.html
  /// </remarks>
  IReadOnlyList<string> Operators { get; }
+
+ /// <summary>
+ /// The PostgreSQL included property names, or <c>null</c> if they have not been specified.
+ /// </summary>
+ /// <remarks>
+ /// https://www.postgresql.org/docs/current/sql-createindex.html
+ /// </remarks>
+ IReadOnlyList<string> IncludeProperties { get; }
  }
 }

src/EFCore.PG/Metadata/Internal/NpgsqlAnnotationNames.cs

@@ -11,6 +11,7 @@ public static class NpgsqlAnnotationNames
  public const string HiLoSequenceSchema = Prefix + "HiLoSequenceSchema";
  public const string IndexMethod = Prefix + "IndexMethod";
  public const string IndexOperators = Prefix + "IndexOperators";
+ public const string IndexInclude = Prefix + "IndexInclude";
  public const string PostgresExtensionPrefix = Prefix + "PostgresExtension:";
  public const string EnumPrefix = Prefix + "Enum:";
  public const string RangePrefix = Prefix + "Range:";

src/EFCore.PG/Metadata/NpgsqlIndexAnnotations.cs

@@ -30,7 +30,7 @@ public string Method
  }
 
  /// <summary>
- /// The PostgreSQL index operators to be used.
+ /// The PostgreSQL index operators to be used, or <c>null</c> if they have not been specified.
  /// </summary>
  /// <remarks>
  /// https://www.postgresql.org/docs/current/static/indexes-opclass.html
@@ -43,10 +43,27 @@ public string[] Operators
 
  IReadOnlyList<string> INpgsqlIndexAnnotations.Operators => Operators;
 
+ /// <summary>
+ /// The PostgreSQL included property names, or <c>null</c> if they have not been specified.
+ /// </summary>
+ /// <remarks>
+ /// https://www.postgresql.org/docs/current/sql-createindex.html
+ /// </remarks>
+ public string[] IncludeProperties
+ {
+ get => (string[]) Annotations.Metadata[NpgsqlAnnotationNames.IndexInclude];
+ set => SetIncludeProperties(value);
+ }
+
+ IReadOnlyList<string> INpgsqlIndexAnnotations.IncludeProperties => IncludeProperties;
+
  protected virtual bool SetMethod(string value)
  => Annotations.SetAnnotation(NpgsqlAnnotationNames.IndexMethod, value);
 
  protected virtual bool SetOperators(string[] value)
  => Annotations.SetAnnotation(NpgsqlAnnotationNames.IndexOperators, value);
+
+ protected virtual bool SetIncludeProperties(string[] value)
+ => Annotations.SetAnnotation(NpgsqlAnnotationNames.IndexInclude, value);
  }
 }

src/EFCore.PG/Migrations/Internal/NpgsqlMigrationsAnnotationProvider.cs

@@ -49,6 +49,8 @@ public override IEnumerable<IAnnotation> For(IIndex index)
  yield return new Annotation(NpgsqlAnnotationNames.IndexMethod, index.Npgsql().Method);
  if (index.Npgsql().Operators != null)
  yield return new Annotation(NpgsqlAnnotationNames.IndexOperators, index.Npgsql().Operators);
+ if (index.Npgsql().IncludeProperties != null)
+ yield return new Annotation(NpgsqlAnnotationNames.IndexInclude, index.Npgsql().IncludeProperties);
  }
 
  public override IEnumerable<IAnnotation> For(IModel model)

src/EFCore.PG/Migrations/NpgsqlMigrationsSqlGenerator.cs

@@ -112,8 +112,7 @@ protected override void Generate(
  }
 
  // Comment on the table
- var comment = operation[NpgsqlAnnotationNames.Comment] as string;
- if (comment != null)
+ if (operation[NpgsqlAnnotationNames.Comment] is string comment && comment.Length > 0)
  {
  builder.AppendLine(';');
 
@@ -245,8 +244,7 @@ protected override void Generate(
 
  base.Generate(operation, model, builder, terminate: false);
 
- var comment = operation[NpgsqlAnnotationNames.Comment] as string;
- if (comment != null)
+ if (operation[NpgsqlAnnotationNames.Comment] is string comment && comment.Length > 0)
  {
  builder.AppendLine(';');
 
@@ -535,9 +533,6 @@ protected override void Generate(
  Check.NotNull(operation, nameof(operation));
  Check.NotNull(builder, nameof(builder));
 
- var method = (string)operation[NpgsqlAnnotationNames.IndexMethod];
- var operators = (string[])operation[NpgsqlAnnotationNames.IndexOperators];
-
  builder.Append("CREATE ");
 
  if (operation.IsUnique)
@@ -551,30 +546,40 @@ protected override void Generate(
  .Append(" ON ")
  .Append(Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Table, operation.Schema));
 
- if (method != null)
+ if (operation[NpgsqlAnnotationNames.IndexMethod] is string method && method.Length > 0)
  {
  builder
  .Append(" USING ")
  .Append(method);
  }
 
+ var operators = operation[NpgsqlAnnotationNames.IndexOperators] as string[];
+
  builder
  .Append(" (")
  .Append(IndexColumnList(operation.Columns, operators))
  .Append(")");
 
- if (!string.IsNullOrEmpty(operation.Filter))
- {
- builder
- .Append(" WHERE ")
- .Append(operation.Filter);
- }
+ IndexOptions(operation, model, builder);
 
  builder.AppendLine(';');
 
  EndStatement(builder);
  }
 
+ protected override void IndexOptions(CreateIndexOperation operation, IModel model, MigrationCommandListBuilder builder)
+ {
+ if (operation[NpgsqlAnnotationNames.IndexInclude] is string[] includeProperties && includeProperties.Length > 0)
+ {
+ builder
+ .Append(" INCLUDE (")
+ .Append(ColumnList(includeProperties))
+ .Append(")");
+ }
+
+ base.IndexOptions(operation, model, builder);
+ }
+
  protected override void Generate(EnsureSchemaOperation operation, [CanBeNull] IModel model, MigrationCommandListBuilder builder)
  {
  Check.NotNull(operation, nameof(operation));

test/EFCore.PG.FunctionalTests/NpgsqlMigrationSqlGeneratorTest.cs

@@ -633,6 +633,23 @@ public void CreateIndexOperation_operations()
  Sql);
  }
 
+ [Fact]
+ public void CreateIndexOperation_includes()
+ {
+ Generate(
+ new CreateIndexOperation
+ {
+ Name = "IX_People_Name",
+ Table = "People",
+ Columns = new[] { "Name" },
+ [NpgsqlAnnotationNames.IndexInclude] = new[] { "FirstName", "LastName" }
+ });
+
+ Assert.Equal(
+ "CREATE INDEX \"IX_People_Name\" ON \"People\" (\"Name\") INCLUDE (\"FirstName\", \"LastName\");" + EOL,
+ Sql);
+ }
+
  [Fact]
  public void CreateIndexOperation_schema_qualified_operations()
  {