Implement bulk delete

Following dotnet/efcore#28492

Part of #2450

src/EFCore.PG/Extensions/NpgsqlServiceCollectionExtensions.cs

@@ -105,6 +105,7 @@ public static IServiceCollection AddEntityFrameworkNpgsql(this IServiceCollectio
             .TryAdd<IHistoryRepository, NpgsqlHistoryRepository>()
             .TryAdd<ICompiledQueryCacheKeyGenerator, NpgsqlCompiledQueryCacheKeyGenerator>()
             .TryAdd<IExecutionStrategyFactory, NpgsqlExecutionStrategyFactory>()
+            .TryAdd<IQueryableMethodTranslatingExpressionVisitorFactory, NpgsqlQueryableMethodTranslatingExpressionVisitorFactory>()
             .TryAdd<IMethodCallTranslatorProvider, NpgsqlMethodCallTranslatorProvider>()
             .TryAdd<IAggregateMethodCallTranslatorProvider, NpgsqlAggregateMethodCallTranslatorProvider>()
             .TryAdd<IMemberTranslatorProvider, NpgsqlMemberTranslatorProvider>()

src/EFCore.PG/Query/Expressions/Internal/PostgresDeleteExpression.cs

@@ -0,0 +1,85 @@
+namespace Npgsql.EntityFrameworkCore.PostgreSQL.Query.Expressions.Internal;
+
+public sealed class PostgresDeleteExpression : Expression, IPrintableExpression
+{
+    /// <summary>
+    ///     The tables that rows are to be deleted from.
+    /// </summary>
+    public TableExpression Table { get; }
+
+    /// <summary>
+    ///     Additional tables which can be referenced in the predicate.
+    /// </summary>
+    public IReadOnlyList<TableExpressionBase> FromItems { get; }
+
+    /// <summary>
+    ///     The WHERE predicate for the DELETE.
+    /// </summary>
+    public SqlExpression? Predicate { get; }
+
+    public PostgresDeleteExpression(TableExpression table, IReadOnlyList<TableExpressionBase> fromItems, SqlExpression? predicate)
+        => (Table, FromItems, Predicate) = (table, fromItems, predicate);
+
+    /// <inheritdoc />
+    public override Type Type
+        => typeof(object);
+
+    /// <inheritdoc />
+    public override ExpressionType NodeType
+        => ExpressionType.Extension;
+
+    protected override Expression VisitChildren(ExpressionVisitor visitor)
+        => Predicate is null
+            ? this
+            : Update((SqlExpression?)visitor.Visit(Predicate));
+
+    public PostgresDeleteExpression Update(SqlExpression? predicate)
+        => predicate == Predicate
+            ? this
+            : new PostgresDeleteExpression(Table, FromItems, predicate);
+
+    public void Print(ExpressionPrinter expressionPrinter)
+    {
+        expressionPrinter.AppendLine($"DELETE FROM {Table.Name} AS {Table.Alias}");
+
+        if (FromItems.Count > 0)
+        {
+            var first = true;
+            foreach (var fromItem in FromItems)
+            {
+                if (first)
+                {
+                    expressionPrinter.Append("USING ");
+                    first = false;
+                }
+                else
+                {
+                    expressionPrinter.Append(", ");
+                }
+
+                expressionPrinter.Visit(fromItem);
+            }
+        }
+
+        if (Predicate is not null)
+        {
+            expressionPrinter.Append("WHERE ");
+            expressionPrinter.Visit(Predicate);
+        }
+    }
+
+    /// <inheritdoc />
+    public override bool Equals(object? obj)
+        => obj != null
+            && (ReferenceEquals(this, obj)
+                || obj is PostgresDeleteExpression pgDeleteExpression
+                && Equals(pgDeleteExpression));
+
+    private bool Equals(PostgresDeleteExpression pgDeleteExpression)
+        => Table == pgDeleteExpression.Table
+            && FromItems.SequenceEqual(pgDeleteExpression.FromItems)
+            && (Predicate is null ? pgDeleteExpression.Predicate is null : Predicate.Equals(pgDeleteExpression.Predicate));
+
+    /// <inheritdoc />
+    public override int GetHashCode() => Table.GetHashCode();
+}

src/EFCore.PG/Query/Internal/NonQueryConvertingExpressionVisitor.cs

@@ -0,0 +1,86 @@
+using Npgsql.EntityFrameworkCore.PostgreSQL.Query.Expressions.Internal;
+
+namespace Npgsql.EntityFrameworkCore.PostgreSQL.Query.Internal;
+
+/// <summary>
+///     Converts the relational <see cref="NonQueryExpression" /> into a PG-specific <see cref="PostgresDeleteExpression" />, which
+///     precisely models a DELETE statement in PostgreSQL. This is done to handle the PG-specific USING syntax for table joining.
+/// </summary>
+public class NonQueryConvertingExpressionVisitor : ExpressionVisitor
+{
+    public virtual Expression Process(Expression node)
+        => node switch
+        {
+            DeleteExpression deleteExpression => VisitDelete(deleteExpression),
+
+            _ => node
+        };
+
+    protected virtual Expression VisitDelete(DeleteExpression deleteExpression)
+    {
+        var selectExpression = deleteExpression.SelectExpression;
+
+        if (selectExpression.Offset != null
+            || selectExpression.Limit != null
+            || selectExpression.Having != null
+            || selectExpression.Orderings.Count > 0
+            || selectExpression.GroupBy.Count > 0
+            || selectExpression.Projection.Count > 0)
+        {
+            throw new InvalidOperationException(
+                RelationalStrings.ExecuteOperationWithUnsupportedOperatorInSqlGeneration(
+                    nameof(RelationalQueryableExtensions.ExecuteDelete)));
+        }
+
+        var fromItems = new List<TableExpressionBase>();
+        SqlExpression? joinPredicates = null;
+
+        // The SelectExpression also contains the target table being modified (same as deleteExpression.Table).
+        // If it has additional inner joins, use the PostgreSQL-specific USING syntax to express the join.
+        // Note that the non-join TableExpression isn't necessary the target table - through projection the last table being
+        // joined may be the one being modified.
+        foreach (var tableBase in selectExpression.Tables)
+        {
+            switch (tableBase)
+            {
+                case TableExpression tableExpression:
+                    if (tableExpression != deleteExpression.Table)
+                    {
+                        fromItems.Add(tableExpression);
+                    }
+
+                    break;
+
+                case InnerJoinExpression { Table: { } tableExpression } innerJoinExpression:
+                    if (tableExpression != deleteExpression.Table)
+                    {
+                        fromItems.Add(tableExpression);
+                    }
+
+                    joinPredicates = joinPredicates is null
+                        ? innerJoinExpression.JoinPredicate
+                        : new SqlBinaryExpression(
+                            ExpressionType.AndAlso, joinPredicates, innerJoinExpression.JoinPredicate, typeof(bool),
+                            innerJoinExpression.JoinPredicate.TypeMapping);
+                    break;
+
+                default:
+                    throw new InvalidOperationException(
+                        RelationalStrings.ExecuteOperationWithUnsupportedOperatorInSqlGeneration(
+                            nameof(RelationalQueryableExtensions.ExecuteDelete)));
+            }
+        }
+
+        // Combine the join predicates (if any) before the user-provided predicate
+        var predicate = (joinPredicates, selectExpression.Predicate) switch
+        {
+            (null, not null) => selectExpression.Predicate,
+            (not null, null) => joinPredicates,
+            (null, null) => null,
+            (not null, not null) => new SqlBinaryExpression(
+                ExpressionType.AndAlso, joinPredicates, selectExpression.Predicate, typeof(bool), joinPredicates.TypeMapping)
+        };
+
+        return new PostgresDeleteExpression(deleteExpression.Table, fromItems, predicate);
+    }
+}

src/EFCore.PG/Query/Internal/NpgsqlParameterBasedSqlProcessor.cs

@@ -9,6 +9,18 @@ public NpgsqlParameterBasedSqlProcessor(
     {
     }
 
+    public override Expression Optimize(
+        Expression queryExpression,
+        IReadOnlyDictionary<string, object?> parametersValues,
+        out bool canCache)
+    {
+        queryExpression = base.Optimize(queryExpression, parametersValues, out canCache);
+
+        queryExpression = new NonQueryConvertingExpressionVisitor().Process(queryExpression);
+
+        return queryExpression;
+    }
+
     /// <inheritdoc />
     protected override Expression ProcessSqlNullability(
         Expression selectExpression, IReadOnlyDictionary<string, object?> parametersValues, out bool canCache)

src/EFCore.PG/Query/Internal/NpgsqlQuerySqlGenerator.cs

@@ -44,6 +44,7 @@ protected override Expression VisitExtension(Expression extensionExpression)
             PostgresAnyExpression anyExpression                     => VisitArrayAny(anyExpression),
             PostgresArrayIndexExpression arrayIndexExpression       => VisitArrayIndex(arrayIndexExpression),
             PostgresBinaryExpression binaryExpression               => VisitPostgresBinary(binaryExpression),
+            PostgresDeleteExpression deleteExpression               => VisitPostgresDelete(deleteExpression),
             PostgresFunctionExpression functionExpression           => VisitPostgresFunction(functionExpression),
             PostgresILikeExpression iLikeExpression                 => VisitILike(iLikeExpression),
             PostgresJsonTraversalExpression jsonTraversalExpression => VisitJsonPathTraversal(jsonTraversalExpression),
@@ -206,6 +207,45 @@ protected override Expression VisitSqlBinary(SqlBinaryExpression binary)
         }
     }
 
+    protected override void GenerateRootCommand(Expression rootExpression)
+    {
+        switch (rootExpression)
+        {
+            case PostgresDeleteExpression pgDeleteExpression:
+                VisitPostgresDelete(pgDeleteExpression);
+                return;
+
+            default:
+                base.GenerateRootCommand(rootExpression);
+                return;
+        }
+    }
+
+    // NonQueryConvertingExpressionVisitor converts the relational DeleteExpression to PostgresDeleteExpression, so we should never
+    // get here
+    protected override Expression VisitDelete(DeleteExpression deleteExpression)
+        => throw new InvalidOperationException("Inconceivable!");
+
+    protected virtual Expression VisitPostgresDelete(PostgresDeleteExpression pgDeleteExpression)
+    {
+        Sql.Append("DELETE FROM ");
+        Visit(pgDeleteExpression.Table);
+
+        if (pgDeleteExpression.FromItems.Count > 0)
+        {
+            Sql.AppendLine().Append("USING ");
+            GenerateList(pgDeleteExpression.FromItems, t => Visit(t), sql => sql.Append(", "));
+        }
+
+        if (pgDeleteExpression.Predicate != null)
+        {
+            Sql.AppendLine().Append("WHERE ");
+            Visit(pgDeleteExpression.Predicate);
+        }
+
+        return pgDeleteExpression;
+    }
+
     protected virtual Expression VisitPostgresNewArray(PostgresNewArrayExpression postgresNewArrayExpression)
     {
         Debug.Assert(postgresNewArrayExpression.TypeMapping is not null);
@@ -769,4 +809,22 @@ public virtual Expression VisitPostgresFunction(PostgresFunctionExpression e)
 
     private static bool RequiresBrackets(SqlExpression expression)
         => expression is SqlBinaryExpression || expression is LikeExpression || expression is PostgresBinaryExpression;
+
+    private void GenerateList<T>(
+        IReadOnlyList<T> items,
+        Action<T> generationAction,
+        Action<IRelationalCommandBuilder>? joinAction = null)
+    {
+        joinAction ??= (isb => isb.Append(", "));
+
+        for (var i = 0; i < items.Count; i++)
+        {
+            if (i > 0)
+            {
+                joinAction(Sql);
+            }
+
+            generationAction(items[i]);
+        }
+    }
 }

src/EFCore.PG/Query/Internal/NpgsqlQueryableMethodTranslatingExpressionVisitor.cs

@@ -0,0 +1,57 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Npgsql.EntityFrameworkCore.PostgreSQL.Query.Internal;
+
+public class NpgsqlQueryableMethodTranslatingExpressionVisitor : RelationalQueryableMethodTranslatingExpressionVisitor
+{
+    public NpgsqlQueryableMethodTranslatingExpressionVisitor(
+        QueryableMethodTranslatingExpressionVisitorDependencies dependencies,
+        RelationalQueryableMethodTranslatingExpressionVisitorDependencies relationalDependencies,
+        QueryCompilationContext queryCompilationContext)
+        : base(dependencies, relationalDependencies, queryCompilationContext)
+    {
+    }
+
+    protected override bool IsValidSelectExpressionForExecuteDelete(
+        SelectExpression selectExpression,
+        EntityShaperExpression entityShaperExpression,
+        [NotNullWhen(true)] out TableExpression? tableExpression)
+    {
+        // The default relational behavior is to allow only single-table expressions, and the only permitted feature is a predicate.
+        // Here we extend this to also inner joins to tables, which we generate via the PostgreSQL-specific USING construct.
+        if (selectExpression.Offset == null
+            && selectExpression.Limit == null
+            // If entity type has primary key then Distinct is no-op
+            && (!selectExpression.IsDistinct || entityShaperExpression.EntityType.FindPrimaryKey() != null)
+            && selectExpression.GroupBy.Count == 0
+            && selectExpression.Having == null
+            && selectExpression.Orderings.Count == 0)
+        {
+            TableExpressionBase? table = null;
+            if (selectExpression.Tables.Count == 1)
+            {
+                table = selectExpression.Tables[0];
+            }
+            else if (selectExpression.Tables.All(t => t is TableExpression or InnerJoinExpression))
+            {
+                var projectionBindingExpression = (ProjectionBindingExpression)entityShaperExpression.ValueBufferExpression;
+                var entityProjectionExpression = (EntityProjectionExpression)selectExpression.GetProjection(projectionBindingExpression);
+                var column = entityProjectionExpression.BindProperty(entityShaperExpression.EntityType.GetProperties().First());
+                table = column.Table;
+                if (table is JoinExpressionBase joinExpressionBase)
+                {
+                    table = joinExpressionBase.Table;
+                }
+            }
+
+            if (table is TableExpression te)
+            {
+                tableExpression = te;
+                return true;
+            }
+        }
+
+        tableExpression = null;
+        return false;
+    }
+}

src/EFCore.PG/Query/Internal/NpgsqlQueryableMethodTranslatingExpressionVisitorFactory.cs

@@ -0,0 +1,19 @@
+namespace Npgsql.EntityFrameworkCore.PostgreSQL.Query.Internal;
+
+public class NpgsqlQueryableMethodTranslatingExpressionVisitorFactory : IQueryableMethodTranslatingExpressionVisitorFactory
+{
+    public NpgsqlQueryableMethodTranslatingExpressionVisitorFactory(
+        QueryableMethodTranslatingExpressionVisitorDependencies dependencies,
+        RelationalQueryableMethodTranslatingExpressionVisitorDependencies relationalDependencies)
+    {
+        Dependencies = dependencies;
+        RelationalDependencies = relationalDependencies;
+    }
+
+    protected virtual QueryableMethodTranslatingExpressionVisitorDependencies Dependencies { get; }
+
+    protected virtual RelationalQueryableMethodTranslatingExpressionVisitorDependencies RelationalDependencies { get; }
+
+    public virtual QueryableMethodTranslatingExpressionVisitor Create(QueryCompilationContext queryCompilationContext)
+        => new NpgsqlQueryableMethodTranslatingExpressionVisitor(Dependencies, RelationalDependencies, queryCompilationContext);
+}

test/EFCore.PG.FunctionalTests/BulkUpdates/FiltersInheritanceBulkUpdatesNpgsqlFixture.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Npgsql.EntityFrameworkCore.PostgreSQL.BulkUpdates;
+
+public class FiltersInheritanceBulkUpdatesNpgsqlFixture : InheritanceBulkUpdatesNpgsqlFixture
+{
+    protected override bool EnableFilters
+        => true;
+}