Query: Lift GroupByAggregate when correlation predicate matches (#27108)

Earlier, we didn't match on exact predicate

Also fix bug in LikeExpression.Equals

Resolves #27102

src/EFCore.Relational/Query/RelationalQueryableMethodTranslatingExpressionVisitor.cs

@@ -1960,6 +1960,10 @@ private SqlExpression CombineGroupByAggregateTerms(SelectExpression selectExpres
  selector = _sqlExpressionFactory.Case(
  new List<CaseWhenClause> { new(predicate, selector) },
  elseResult: null);
+ if (!(AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue27102", out var enabled) && enabled))
+ {
+ selectExpression.UpdatePredicate(_groupingElementCorrelationalPredicate!);
+ }
  }
 
  if (selectExpression.IsDistinct)

src/EFCore.Relational/Query/SqlExpressions/LikeExpression.cs

@@ -116,7 +116,9 @@ private bool Equals(LikeExpression likeExpression)
  => base.Equals(likeExpression)
  && Match.Equals(likeExpression.Match)
  && Pattern.Equals(likeExpression.Pattern)
- && EscapeChar?.Equals(likeExpression.EscapeChar) == true;
+ && (EscapeChar == null
+ ? likeExpression.EscapeChar == null
+ : EscapeChar.Equals(likeExpression.EscapeChar));
 
  /// <inheritdoc />
  public override int GetHashCode()

src/EFCore.Relational/Query/SqlExpressions/SelectExpression.Helper.cs

@@ -782,6 +782,7 @@ private sealed class CloningExpressionVisitor : ExpressionVisitor
  var newOrderings = selectExpression._orderings.Select(Visit).ToList<OrderingExpression>();
  var offset = (SqlExpression?)Visit(selectExpression.Offset);
  var limit = (SqlExpression?)Visit(selectExpression.Limit);
+ var groupingCorrelationPredicate = (SqlExpression?)Visit(selectExpression._groupingCorrelationPredicate);
 
  var newSelectExpression = new SelectExpression(
  selectExpression.Alias, newProjections, newTables, newTableReferences, newGroupBy, newOrderings)
@@ -793,7 +794,8 @@ private sealed class CloningExpressionVisitor : ExpressionVisitor
  IsDistinct = selectExpression.IsDistinct,
  Tags = selectExpression.Tags,
  _usedAliases = selectExpression._usedAliases.ToHashSet(),
- _projectionMapping = newProjectionMappings
+ _projectionMapping = newProjectionMappings,
+ _groupingCorrelationPredicate = groupingCorrelationPredicate
  };
 
  newSelectExpression._tptLeftJoinTables.AddRange(selectExpression._tptLeftJoinTables);
@@ -865,7 +867,9 @@ public GroupByAggregateLiftingExpressionVisitor(SelectExpression selectExpressio
  if (subquery.Limit == null
  && subquery.Offset == null
  && subquery._groupBy.Count == 0
- && subquery.Predicate != null)
+ && subquery.Predicate != null
+ && ((AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue27102", out var enabled) && enabled)
+ || subquery.Predicate.Equals(subquery._groupingCorrelationPredicate)))
  {
  var initialTableCounts = 0;
  var potentialTableCount = Math.Min(_selectExpression._tables.Count, subquery._tables.Count);

src/EFCore.Relational/Query/SqlExpressions/SelectExpression.cs

@@ -61,6 +61,7 @@ public sealed partial class SelectExpression : TableExpressionBase
  private List<Expression> _clientProjections = new();
  private readonly List<string?> _aliasForClientProjections = new();
 
+ private SqlExpression? _groupingCorrelationPredicate;
  private CloningExpressionVisitor? _cloningExpressionVisitor;
 
  private SelectExpression(
@@ -528,6 +529,7 @@ static void UpdateLimit(SelectExpression selectExpression)
  || shapedQueryExpression.ResultCardinality == ResultCardinality.SingleOrDefault:
  {
  var innerSelectExpression = (SelectExpression)shapedQueryExpression.QueryExpression;
+ innerSelectExpression._groupingCorrelationPredicate = null;
  var innerShaperExpression = shapedQueryExpression.ShaperExpression;
  if (innerSelectExpression._clientProjections.Count == 0)
  {
@@ -599,6 +601,7 @@ static Expression RemoveConvert(Expression expression)
  when shapedQueryExpression.ResultCardinality == ResultCardinality.Enumerable:
  {
  var innerSelectExpression = (SelectExpression)shapedQueryExpression.QueryExpression;
+ innerSelectExpression._groupingCorrelationPredicate = null;
  if (_identifier.Count == 0
  || innerSelectExpression._identifier.Count == 0)
  {
@@ -1144,6 +1147,11 @@ public void ApplyPredicate(SqlExpression sqlExpression)
  }
  }
 
+ internal void UpdatePredicate(SqlExpression predicate)
+ {
+ Predicate = predicate;
+ }
+
  /// <summary>
  /// Applies grouping from given key selector.
  /// </summary>
@@ -1254,6 +1262,10 @@ public GroupByShaperExpression ApplyGrouping(
  .Aggregate((l, r) => sqlExpressionFactory.AndAlso(l, r));
  clonedSelectExpression._groupBy.Clear();
  clonedSelectExpression.ApplyPredicate(correlationPredicate);
+ if (!(AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue27102", out var enabled) && enabled))
+ {
+ clonedSelectExpression._groupingCorrelationPredicate = clonedSelectExpression.Predicate;
+ }
 
  if (!_identifier.All(e => _groupBy.Contains(e.Column)))
  {
@@ -3354,6 +3366,7 @@ protected override Expression VisitChildren(ExpressionVisitor visitor)
 
  Offset = (SqlExpression?)visitor.Visit(Offset);
  Limit = (SqlExpression?)visitor.Visit(Limit);
+ _groupingCorrelationPredicate = (SqlExpression?)visitor.Visit(_groupingCorrelationPredicate);
 
  var identifier = VisitList(_identifier.Select(e => e.Column).ToList(), inPlace: true, out _)
  .Zip(_identifier, (a, b) => (a, b.Comparer))
@@ -3432,6 +3445,9 @@ protected override Expression VisitChildren(ExpressionVisitor visitor)
  var limit = (SqlExpression?)visitor.Visit(Limit);
  changed |= limit != Limit;
 
+ var groupingCorrelationPredicate = (SqlExpression?)visitor.Visit(_groupingCorrelationPredicate);
+ changed |= groupingCorrelationPredicate != _groupingCorrelationPredicate;
+
  var identifier = VisitList(_identifier.Select(e => e.Column).ToList(), inPlace: false, out var identifierChanged);
  changed |= identifierChanged;
 
@@ -3453,7 +3469,8 @@ protected override Expression VisitChildren(ExpressionVisitor visitor)
  Limit = limit,
  IsDistinct = IsDistinct,
  Tags = Tags,
- _usedAliases = _usedAliases
+ _usedAliases = _usedAliases,
+ _groupingCorrelationPredicate = groupingCorrelationPredicate
  };
 
  newSelectExpression._tptLeftJoinTables.AddRange(_tptLeftJoinTables);

test/EFCore.Specification.Tests/Query/NorthwindGroupByQueryTestBase.cs

@@ -447,6 +447,22 @@ public virtual Task GroupBy_with_aggregate_through_navigation_property(bool asyn
  elementSorter: e => e.max);
  }
 
+ [ConditionalTheory]
+ [MemberData(nameof(IsAsyncData))]
+ public virtual Task GroupBy_with_aggregate_containing_complex_where(bool async)
+ {
+ return AssertQuery(
+ async,
+ ss => from o in ss.Set<Order>()
+ group o.OrderID by o.EmployeeID into tg
+ select new
+ {
+ tg.Key,
+ Max = ss.Set<Order>().Where(e => e.EmployeeID == tg.Max() * 6).Max(t => (int?)t.OrderID)
+ },
+ elementSorter: e => e.Key);
+ }
+
  #endregion
 
  #region GroupByAnonymousAggregate

test/EFCore.SqlServer.FunctionalTests/Query/NorthwindGroupByQuerySqlServerTest.cs

@@ -1884,6 +1884,25 @@ FROM [Orders] AS [o]
 GROUP BY [o].[EmployeeID]");
  }
 
+ public override async Task GroupBy_with_aggregate_containing_complex_where(bool async)
+ {
+ await base.GroupBy_with_aggregate_containing_complex_where(async);
+
+ AssertSql(
+ @"SELECT [o].[EmployeeID] AS [Key], (
+ SELECT MAX([o0].[OrderID])
+ FROM [Orders] AS [o0]
+ WHERE (CAST([o0].[EmployeeID] AS bigint) = CAST(((
+ SELECT MAX([o1].[OrderID])
+ FROM [Orders] AS [o1]
+ WHERE ([o].[EmployeeID] = [o1].[EmployeeID]) OR ([o].[EmployeeID] IS NULL AND [o1].[EmployeeID] IS NULL)) * 6) AS bigint)) OR ([o0].[EmployeeID] IS NULL AND (
+ SELECT MAX([o1].[OrderID])
+ FROM [Orders] AS [o1]
+ WHERE ([o].[EmployeeID] = [o1].[EmployeeID]) OR ([o].[EmployeeID] IS NULL AND [o1].[EmployeeID] IS NULL)) IS NULL)) AS [Max]
+FROM [Orders] AS [o]
+GROUP BY [o].[EmployeeID]");
+ }
+
  public override async Task GroupBy_Shadow(bool async)
  {
  await base.GroupBy_Shadow(async);