diff --git a/src/EFCore.InMemory/Query/Internal/InMemoryQueryExpression.cs b/src/EFCore.InMemory/Query/Internal/InMemoryQueryExpression.cs
index 7abfecc053d..31b864eb51f 100644
--- a/src/EFCore.InMemory/Query/Internal/InMemoryQueryExpression.cs
+++ b/src/EFCore.InMemory/Query/Internal/InMemoryQueryExpression.cs
@@ -600,7 +600,6 @@ public virtual GroupByShaperExpression ApplyGrouping(
 
         return new GroupByShaperExpression(
             groupingKey,
-            shaperExpression,
             new ShapedQueryExpression(
                 clonedInMemoryQueryExpression,
                 new QueryExpressionReplacingExpressionVisitor(this, clonedInMemoryQueryExpression).Visit(shaperExpression)));
diff --git a/src/EFCore.Relational/Query/EnumerableExpression.cs b/src/EFCore.Relational/Query/EnumerableExpression.cs
index 743136edeed..b1a75e49a73 100644
--- a/src/EFCore.Relational/Query/EnumerableExpression.cs
+++ b/src/EFCore.Relational/Query/EnumerableExpression.cs
@@ -2,8 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Runtime.CompilerServices;
+using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
 
-namespace Microsoft.EntityFrameworkCore.Query.SqlExpressions;
+namespace Microsoft.EntityFrameworkCore.Query;
 
 /// <summary>
 ///     <para>
@@ -16,8 +17,6 @@ namespace Microsoft.EntityFrameworkCore.Query.SqlExpressions;
 /// </summary>
 public class EnumerableExpression : Expression, IPrintableExpression
 {
-    private readonly List<OrderingExpression> _orderings = new();
-
     /// <summary>
     ///     Creates a new instance of the <see cref="EnumerableExpression" /> class.
     /// </summary>
@@ -25,59 +24,73 @@ public class EnumerableExpression : Expression, IPrintableExpression
     public EnumerableExpression(Expression selector)
     {
         Selector = selector;
+        IsDistinct = false;
+        Predicate = null;
+        Orderings = new List<OrderingExpression>();
+    }
+
+    private EnumerableExpression(
+        Expression selector,
+        bool distinct,
+        SqlExpression? predicate,
+        IReadOnlyList<OrderingExpression> orderings)
+    {
+        Selector = selector;
+        IsDistinct = distinct;
+        Predicate = predicate;
+        Orderings = orderings;
     }
 
     /// <summary>
     ///     The underlying expression being enumerated.
     /// </summary>
-    public virtual Expression Selector { get; private set; }
+    public virtual Expression Selector { get; }
 
     /// <summary>
     ///     The value indicating if distinct operator is applied on the enumerable or not.
     /// </summary>
-    public virtual bool IsDistinct { get; private set; }
+    public virtual bool IsDistinct { get; }
 
     /// <summary>
     ///     The value indicating any predicate applied on the enumerable.
     /// </summary>
-    public virtual SqlExpression? Predicate { get; private set;  }
+    public virtual SqlExpression? Predicate { get; }
 
     /// <summary>
     ///     The list of orderings to be applied to the enumerable.
     /// </summary>
-    public virtual IReadOnlyList<OrderingExpression> Orderings => _orderings;
+    public virtual IReadOnlyList<OrderingExpression> Orderings { get; }
 
 
     /// <summary>
     ///     Applies new selector to the <see cref="EnumerableExpression" />.
     /// </summary>
-    public virtual void ApplySelector(Expression expression)
-    {
-        Selector = expression;
-    }
+    /// <returns>The new expression with specified component updated.</returns>
+    public virtual EnumerableExpression ApplySelector(Expression expression)
+        => new(expression, IsDistinct, Predicate, Orderings);
 
     /// <summary>
     ///     Applies DISTINCT operator to the selector of the <see cref="EnumerableExpression" />.
     /// </summary>
-    public virtual void ApplyDistinct()
-    {
-        IsDistinct = true;
-    }
+    /// <returns>The new expression with specified component updated.</returns>
+    public virtual EnumerableExpression ApplyDistinct()
+        => new(Selector, distinct: true, Predicate, Orderings);
 
     /// <summary>
     ///     Applies filter predicate to the <see cref="EnumerableExpression" />.
     /// </summary>
     /// <param name="sqlExpression">An expression to use for filtering.</param>
-    public virtual void ApplyPredicate(SqlExpression sqlExpression)
+    /// <returns>The new expression with specified component updated.</returns>
+    public virtual EnumerableExpression ApplyPredicate(SqlExpression sqlExpression)
     {
         if (sqlExpression is SqlConstantExpression sqlConstant
             && sqlConstant.Value is bool boolValue
             && boolValue)
         {
-            return;
+            return this;
         }
 
-        Predicate = Predicate == null
+        var predicate = Predicate == null
             ? sqlExpression
             : new SqlBinaryExpression(
                 ExpressionType.AndAlso,
@@ -85,27 +98,41 @@ public virtual void ApplyPredicate(SqlExpression sqlExpression)
                 sqlExpression,
                 typeof(bool),
                 sqlExpression.TypeMapping);
+
+        return new(Selector, IsDistinct, predicate, Orderings);
     }
 
     /// <summary>
     ///     Applies ordering to the <see cref="EnumerableExpression" />. This overwrites any previous ordering specified.
     /// </summary>
     /// <param name="orderingExpression">An ordering expression to use for ordering.</param>
-    public virtual void ApplyOrdering(OrderingExpression orderingExpression)
+    /// <returns>The new expression with specified component updated.</returns>
+    public virtual EnumerableExpression ApplyOrdering(OrderingExpression orderingExpression)
     {
-        _orderings.Clear();
-        AppendOrdering(orderingExpression);
+        var orderings = new List<OrderingExpression>();
+        AppendOrdering(orderings, orderingExpression);
+
+        return new EnumerableExpression(Selector, IsDistinct, Predicate, orderings);
     }
 
     /// <summary>
     ///     Appends ordering to the existing orderings of the <see cref="EnumerableExpression" />.
     /// </summary>
     /// <param name="orderingExpression">An ordering expression to use for ordering.</param>
-    public virtual void AppendOrdering(OrderingExpression orderingExpression)
+    /// <returns>The new expression with specified component updated.</returns>
+    public virtual EnumerableExpression AppendOrdering(OrderingExpression orderingExpression)
+    {
+        var orderings = Orderings.ToList();
+        AppendOrdering(orderings, orderingExpression);
+
+        return new EnumerableExpression(Selector, IsDistinct, Predicate, orderings);
+    }
+
+    private static void AppendOrdering(List<OrderingExpression> orderings, OrderingExpression orderingExpression)
     {
-        if (!_orderings.Any(o => o.Expression.Equals(orderingExpression.Expression)))
+        if (!orderings.Any(o => o.Expression.Equals(orderingExpression.Expression)))
         {
-            _orderings.Add(orderingExpression.Update(orderingExpression.Expression));
+            orderings.Add(orderingExpression.Update(orderingExpression.Expression));
         }
     }
 
@@ -151,8 +178,32 @@ public virtual void Print(ExpressionPrinter expressionPrinter)
     }
 
     /// <inheritdoc />
-    public override bool Equals(object? obj) => ReferenceEquals(this, obj);
+    public override bool Equals(object? obj)
+        => obj != null
+            && (ReferenceEquals(this, obj)
+                || obj is EnumerableExpression enumerableExpression
+                && Equals(enumerableExpression));
+
+    private bool Equals(EnumerableExpression enumerableExpression)
+        => IsDistinct == enumerableExpression.IsDistinct
+        && (Predicate == null
+            ? enumerableExpression.Predicate == null
+            : Predicate.Equals(enumerableExpression.Predicate))
+        && ExpressionEqualityComparer.Instance.Equals(Selector, enumerableExpression.Selector)
+        && Orderings.SequenceEqual(enumerableExpression.Orderings);
 
     /// <inheritdoc />
-    public override int GetHashCode() => RuntimeHelpers.GetHashCode(this);
+    public override int GetHashCode()
+    {
+        var hashCode = new HashCode();
+        hashCode.Add(IsDistinct);
+        hashCode.Add(Selector);
+        hashCode.Add(Predicate);
+        foreach (var ordering in Orderings)
+        {
+            hashCode.Add(ordering);
+        }
+
+        return hashCode.ToHashCode();
+    }
 }
diff --git a/src/EFCore.Relational/Query/RelationalGroupByShaperExpression.cs b/src/EFCore.Relational/Query/RelationalGroupByShaperExpression.cs
new file mode 100644
index 00000000000..fe752b73483
--- /dev/null
+++ b/src/EFCore.Relational/Query/RelationalGroupByShaperExpression.cs
@@ -0,0 +1,57 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.EntityFrameworkCore.Query;
+
+/// <summary>
+///     <para>
+///         An expression that represents creation of a grouping element in <see cref="ShapedQueryExpression.ShaperExpression" />
+///         for relational providers.
+///     </para>
+///     <para>
+///         This type is typically used by database providers (and other extensions). It is generally
+///         not used in application code.
+///     </para>
+/// </summary>
+public class RelationalGroupByShaperExpression : GroupByShaperExpression
+{
+    /// <summary>
+    ///     Creates a new instance of the <see cref="RelationalGroupByShaperExpression" /> class.
+    /// </summary>
+    /// <param name="keySelector">An expression representing key selector for the grouping result.</param>
+    /// <param name="elementSelector">An expression representing element selector for the grouping result.</param>
+    /// <param name="groupingEnumerable">An expression representing subquery for enumerable over the grouping result.</param>
+    public RelationalGroupByShaperExpression(
+        Expression keySelector,
+        Expression elementSelector,
+        ShapedQueryExpression groupingEnumerable)
+        : base(keySelector, groupingEnumerable)
+    {
+        ElementSelector = elementSelector;
+    }
+
+    /// <summary>
+    ///     The expression representing the element selector for this grouping result.
+    /// </summary>
+    public virtual Expression ElementSelector { get; }
+
+    /// <inheritdoc />
+    protected override Expression VisitChildren(ExpressionVisitor visitor)
+        => throw new InvalidOperationException(
+            CoreStrings.VisitIsNotAllowed($"{nameof(RelationalGroupByShaperExpression)}.{nameof(VisitChildren)}"));
+
+    /// <inheritdoc />
+    public override void Print(ExpressionPrinter expressionPrinter)
+    {
+        expressionPrinter.AppendLine($"{nameof(RelationalGroupByShaperExpression)}:");
+        expressionPrinter.Append("KeySelector: ");
+        expressionPrinter.Visit(KeySelector);
+        expressionPrinter.AppendLine(", ");
+        expressionPrinter.Append("ElementSelector: ");
+        expressionPrinter.Visit(ElementSelector);
+        expressionPrinter.AppendLine(", ");
+        expressionPrinter.Append("GroupingEnumerable:");
+        expressionPrinter.Visit(GroupingEnumerable);
+        expressionPrinter.AppendLine();
+    }
+}
diff --git a/src/EFCore.Relational/Query/RelationalSqlTranslatingExpressionVisitor.cs b/src/EFCore.Relational/Query/RelationalSqlTranslatingExpressionVisitor.cs
index 693995e67ba..fb1205c170f 100644
--- a/src/EFCore.Relational/Query/RelationalSqlTranslatingExpressionVisitor.cs
+++ b/src/EFCore.Relational/Query/RelationalSqlTranslatingExpressionVisitor.cs
@@ -503,7 +503,7 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp
         {
             if (methodCallExpression.Method.IsGenericMethod
                 && methodCallExpression.Method.GetGenericMethodDefinition() == QueryableMethods.AsQueryable
-                && methodCallExpression.Arguments[0] is GroupByShaperExpression groupByShaperExpression)
+                && methodCallExpression.Arguments[0] is RelationalGroupByShaperExpression groupByShaperExpression)
             {
                 return new EnumerableExpression(groupByShaperExpression.ElementSelector);
             }
@@ -517,17 +517,24 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp
                     case nameof(Queryable.Average):
                         if (methodCallExpression.Arguments.Count == 2)
                         {
-                            ProcessSelector(enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote());
+                            enumerableExpression = ProcessSelector(
+                                enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote());
                         }
 
                         result = TranslateAggregate(methodCallExpression.Method, enumerableExpression);
                         break;
 
                     case nameof(Queryable.Count):
-                        if (methodCallExpression.Arguments.Count == 2
-                            && !ProcessPredicate(enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote()))
+                        if (methodCallExpression.Arguments.Count == 2)
                         {
-                            break;
+                            var newEnumerableExpression = ProcessPredicate(
+                                enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote());
+                            if (newEnumerableExpression == null)
+                            {
+                                break;
+                            }
+
+                            enumerableExpression = newEnumerableExpression;
                         }
 
                         result = TranslateAggregate(methodCallExpression.Method, enumerableExpression);
@@ -535,27 +542,25 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp
 
 
                     case nameof(Queryable.Distinct):
-                        if (enumerableExpression.Selector is EntityShaperExpression entityShaperExpression
-                            && entityShaperExpression.EntityType.FindPrimaryKey() != null)
-                        {
-                            result = enumerableExpression;
-                        }
-                        else if (!enumerableExpression.IsDistinct)
-                        {
-                            enumerableExpression.ApplyDistinct();
-                            result = enumerableExpression;
-                        }
-                        else
-                        {
-                            result = null;
-                        }
+                        result = enumerableExpression.Selector is EntityShaperExpression entityShaperExpression
+                            && entityShaperExpression.EntityType.FindPrimaryKey() != null
+                            ? enumerableExpression
+                            : !enumerableExpression.IsDistinct
+                                ? enumerableExpression.ApplyDistinct()
+                                : (Expression?)null;
                         break;
 
                     case nameof(Queryable.LongCount):
-                        if (methodCallExpression.Arguments.Count == 2
-                            && !ProcessPredicate(enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote()))
+                        if (methodCallExpression.Arguments.Count == 2)
                         {
-                            break;
+                            var newEnumerableExpression = ProcessPredicate(
+                                enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote());
+                            if (newEnumerableExpression == null)
+                            {
+                                break;
+                            }
+
+                            enumerableExpression = newEnumerableExpression;
                         }
 
                         result = TranslateAggregate(methodCallExpression.Method, enumerableExpression);
@@ -564,7 +569,8 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp
                     case nameof(Queryable.Max):
                         if (methodCallExpression.Arguments.Count == 2)
                         {
-                            ProcessSelector(enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote());
+                            enumerableExpression = ProcessSelector(
+                                enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote());
                         }
 
                         result = TranslateAggregate(methodCallExpression.Method, enumerableExpression);
@@ -573,42 +579,31 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp
                     case nameof(Queryable.Min):
                         if (methodCallExpression.Arguments.Count == 2)
                         {
-                            ProcessSelector(enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote());
+                            enumerableExpression = ProcessSelector(
+                                enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote());
                         }
 
                         result = TranslateAggregate(methodCallExpression.Method, enumerableExpression);
                         break;
 
                     case nameof(Queryable.OrderBy):
-                        if (ProcessOrderByThenBy(
-                            enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote(), thenBy: false, ascending: true))
-                        {
-                            result = enumerableExpression;
-                        }
+                        result = ProcessOrderByThenBy(
+                            enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote(), thenBy: false, ascending: true);
                         break;
 
                     case nameof(Queryable.OrderByDescending):
-                        if (ProcessOrderByThenBy(
-                            enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote(), thenBy: false, ascending: false))
-                        {
-                            result = enumerableExpression;
-                        }
+                        result = ProcessOrderByThenBy(
+                            enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote(), thenBy: false, ascending: false);
                         break;
 
                     case nameof(Queryable.ThenBy):
-                        if (ProcessOrderByThenBy(
-                            enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote(), thenBy: true, ascending: true))
-                        {
-                            result = enumerableExpression;
-                        }
+                        result = ProcessOrderByThenBy(
+                            enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote(), thenBy: true, ascending: true);
                         break;
 
                     case nameof(Queryable.ThenByDescending):
-                        if (ProcessOrderByThenBy(
-                            enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote(), thenBy: true, ascending: false))
-                        {
-                            result = enumerableExpression;
-                        }
+                        result = ProcessOrderByThenBy(
+                            enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote(), thenBy: true, ascending: false);
                         break;
 
                     case nameof(Queryable.Select):
@@ -618,17 +613,15 @@ protected override Expression VisitMethodCall(MethodCallExpression methodCallExp
                     case nameof(Queryable.Sum):
                         if (methodCallExpression.Arguments.Count == 2)
                         {
-                            ProcessSelector(enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote());
+                            enumerableExpression = ProcessSelector(
+                                enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote());
                         }
 
                         result = TranslateAggregate(methodCallExpression.Method, enumerableExpression);
                         break;
 
                     case nameof(Queryable.Where):
-                        if (ProcessPredicate(enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote()))
-                        {
-                            result = enumerableExpression;
-                        }
+                        result = ProcessPredicate(enumerableExpression, methodCallExpression.Arguments[1].UnwrapLambdaFromQuote());
                         break;
                 }
 
@@ -1151,46 +1144,34 @@ private static Expression RemapLambda(EnumerableExpression enumerableExpression,
         => ReplacingExpressionVisitor.Replace(lambdaExpression.Parameters[0], enumerableExpression.Selector, lambdaExpression.Body);
 
     private static EnumerableExpression ProcessSelector(EnumerableExpression enumerableExpression, LambdaExpression lambdaExpression)
-    {
-        var selectorBody = RemapLambda(enumerableExpression, lambdaExpression);
-        enumerableExpression.ApplySelector(selectorBody);
-        return enumerableExpression;
-    }
+        => enumerableExpression.ApplySelector(RemapLambda(enumerableExpression, lambdaExpression));
 
-    private bool ProcessOrderByThenBy(
+    private EnumerableExpression? ProcessOrderByThenBy(
         EnumerableExpression enumerableExpression, LambdaExpression lambdaExpression, bool thenBy, bool ascending)
     {
         var lambdaBody = RemapLambda(enumerableExpression, lambdaExpression);
         var keySelector = TranslateInternal(lambdaBody);
         if (keySelector == null)
         {
-            return false;
+            return null;
         }
 
         var orderingExpression = new OrderingExpression(keySelector, ascending);
-        if (thenBy)
-        {
-            enumerableExpression.AppendOrdering(orderingExpression);
-        }
-        else
-        {
-            enumerableExpression.ApplyOrdering(orderingExpression);
-        }
-
-        return true;
+        return thenBy
+            ? enumerableExpression.AppendOrdering(orderingExpression)
+            : enumerableExpression.ApplyOrdering(orderingExpression);
     }
 
-    private bool ProcessPredicate(EnumerableExpression enumerableExpression, LambdaExpression lambdaExpression)
+    private EnumerableExpression? ProcessPredicate(EnumerableExpression enumerableExpression, LambdaExpression lambdaExpression)
     {
         var lambdaBody = RemapLambda(enumerableExpression, lambdaExpression);
         var predicate = TranslateInternal(lambdaBody);
         if (predicate == null)
         {
-            return false;
+            return null;
         }
 
-        enumerableExpression.ApplyPredicate(predicate);
-        return true;
+        return enumerableExpression.ApplyPredicate(predicate);
     }
 
     private SqlExpression? TranslateAggregate(MethodInfo methodInfo, EnumerableExpression enumerableExpression)
diff --git a/src/EFCore.Relational/Query/SqlExpressions/SelectExpression.cs b/src/EFCore.Relational/Query/SqlExpressions/SelectExpression.cs
index dfd08191308..53373a1dc7f 100644
--- a/src/EFCore.Relational/Query/SqlExpressions/SelectExpression.cs
+++ b/src/EFCore.Relational/Query/SqlExpressions/SelectExpression.cs
@@ -1456,13 +1456,13 @@ public void ApplyGrouping(Expression keySelector)
     }
 
     /// <summary>
-    ///     Applies grouping from given key selector and generate <see cref="GroupByShaperExpression" /> to shape results.
+    ///     Applies grouping from given key selector and generate <see cref="RelationalGroupByShaperExpression" /> to shape results.
     /// </summary>
     /// <param name="keySelector">An key selector expression for the GROUP BY.</param>
     /// <param name="shaperExpression">The shaper expression for current query.</param>
     /// <param name="sqlExpressionFactory">The sql expression factory to use.</param>
-    /// <returns>A <see cref="GroupByShaperExpression" /> which represents the result of the grouping operation.</returns>
-    public GroupByShaperExpression ApplyGrouping(
+    /// <returns>A <see cref="RelationalGroupByShaperExpression" /> which represents the result of the grouping operation.</returns>
+    public RelationalGroupByShaperExpression ApplyGrouping(
         Expression keySelector,
         Expression shaperExpression,
         ISqlExpressionFactory sqlExpressionFactory)
@@ -1524,7 +1524,7 @@ public GroupByShaperExpression ApplyGrouping(
             }
         }
 
-        return new GroupByShaperExpression(
+        return new RelationalGroupByShaperExpression(
             keySelector,
             shaperExpression,
             new ShapedQueryExpression(
diff --git a/src/EFCore/Query/GroupByShaperExpression.cs b/src/EFCore/Query/GroupByShaperExpression.cs
index 078791d5532..456208b643b 100644
--- a/src/EFCore/Query/GroupByShaperExpression.cs
+++ b/src/EFCore/Query/GroupByShaperExpression.cs
@@ -22,15 +22,12 @@ public class GroupByShaperExpression : Expression, IPrintableExpression
     ///     Creates a new instance of the <see cref="GroupByShaperExpression" /> class.
     /// </summary>
     /// <param name="keySelector">An expression representing key selector for the grouping result.</param>
-    /// <param name="elementSelector">An expression representing element selector for the grouping result.</param>
     /// <param name="groupingEnumerable">An expression representing subquery for enumerable over the grouping result.</param>
     public GroupByShaperExpression(
         Expression keySelector,
-        Expression elementSelector,
         ShapedQueryExpression groupingEnumerable)
     {
         KeySelector = keySelector;
-        ElementSelector = elementSelector;
         GroupingEnumerable = groupingEnumerable;
     }
 
@@ -39,11 +36,6 @@ public GroupByShaperExpression(
     /// </summary>
     public virtual Expression KeySelector { get; }
 
-    /// <summary>
-    ///     The expression representing the element selector for this grouping result.
-    /// </summary>
-    public virtual Expression ElementSelector { get; }
-
     /// <summary>
     ///     The expression representing the subquery for the enumerable over this grouping result.
     /// </summary>
@@ -59,19 +51,32 @@ public sealed override ExpressionType NodeType
 
     /// <inheritdoc />
     protected override Expression VisitChildren(ExpressionVisitor visitor)
-        => throw new InvalidOperationException(
-            CoreStrings.VisitIsNotAllowed($"{nameof(GroupByShaperExpression)}.{nameof(VisitChildren)}"));
+    {
+        var keySelector = visitor.Visit(KeySelector);
+        var groupingEnumerable = (ShapedQueryExpression)visitor.Visit(GroupingEnumerable);
+
+        return Update(keySelector, groupingEnumerable);
+    }
+
+    /// <summary>
+    ///     Creates a new expression that is like this one, but using the supplied children. If all of the children are the same, it will
+    ///     return this expression.
+    /// </summary>
+    /// <param name="keySelector">The <see cref="KeySelector" /> property of the result.</param>
+    /// <param name="groupingEnumerable">The <see cref="GroupingEnumerable" /> property of the result.</param>
+    /// <returns>This expression if no children changed, or an expression with the updated children.</returns>
+    public virtual GroupByShaperExpression Update(Expression keySelector, ShapedQueryExpression groupingEnumerable)
+        => keySelector != KeySelector || groupingEnumerable != GroupingEnumerable
+            ? new GroupByShaperExpression(keySelector, groupingEnumerable)
+            : this;
 
     /// <inheritdoc />
-    void IPrintableExpression.Print(ExpressionPrinter expressionPrinter)
+    public virtual void Print(ExpressionPrinter expressionPrinter)
     {
         expressionPrinter.AppendLine($"{nameof(GroupByShaperExpression)}:");
         expressionPrinter.Append("KeySelector: ");
         expressionPrinter.Visit(KeySelector);
         expressionPrinter.AppendLine(", ");
-        expressionPrinter.Append("ElementSelector: ");
-        expressionPrinter.Visit(ElementSelector);
-        expressionPrinter.AppendLine(", ");
         expressionPrinter.Append("GroupingEnumerable:");
         expressionPrinter.Visit(GroupingEnumerable);
         expressionPrinter.AppendLine();