Query: Support for GroupBy entity type

Resolves #17653

src/EFCore.InMemory/Query/Internal/InMemoryQueryExpression.cs

@@ -870,6 +870,22 @@ private static Expression GetGroupingKey(Expression key, List<Expression> groupi
 
  return memberInitExpression.Update(updatedNewExpression, memberBindings);
 
+ case EntityShaperExpression entityShaperExpression
+ when entityShaperExpression.ValueBufferExpression is ProjectionBindingExpression projectionBindingExpression:
+ var entityProjectionExpression = (EntityProjectionExpression)((InMemoryQueryExpression)projectionBindingExpression.QueryExpression)
+ .GetProjection(projectionBindingExpression);
+ var readExpressions = new Dictionary<IProperty, MethodCallExpression>();
+ foreach (var property in GetAllPropertiesInHierarchy(entityProjectionExpression.EntityType))
+ {
+ readExpressions[property] = (MethodCallExpression)GetGroupingKey(
+ entityProjectionExpression.BindProperty(property),
+ groupingExpressions,
+ groupingKeyAccessExpression);
+ }
+
+ return entityShaperExpression.Update(
+ new EntityProjectionExpression(entityProjectionExpression.EntityType, readExpressions));
+
  default:
  var index = groupingExpressions.Count;
  groupingExpressions.Add(key);

src/EFCore.InMemory/Query/Internal/InMemoryQueryableMethodTranslatingExpressionVisitor.cs

@@ -455,6 +455,10 @@ private static ShapedQueryExpression CreateShapedQueryExpressionStatic(IEntityTy
 
  return memberInitExpression.Update(updatedNewExpression, newBindings);
 
+ case EntityShaperExpression entityShaperExpression
+ when entityShaperExpression.ValueBufferExpression is ProjectionBindingExpression projectionBindingExpression:
+ return entityShaperExpression;
+
  default:
  var translation = TranslateExpression(expression);
  if (translation == null)

src/EFCore.Relational/Query/RelationalQueryableMethodTranslatingExpressionVisitor.cs

@@ -450,7 +450,16 @@ private static ShapedQueryExpression CreateShapedQueryExpression(IEntityType ent
  var translatedKey = TranslateGroupingKey(remappedKeySelector);
  if (translatedKey == null)
  {
- return null;
+ // This could be group by entity type
+ if (remappedKeySelector is not EntityShaperExpression
+ { ValueBufferExpression : ProjectionBindingExpression })
+ {
+ // ValueBufferExpression can be JsonQuery, ProjectionBindingExpression, EntityProjection
+ // We only allow ProjectionBindingExpression which represents a regular entity
+ return null;
+ }
+
+ translatedKey = remappedKeySelector;
  }
 
  if (elementSelector != null)

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

@@ -1857,6 +1857,23 @@ private static void PopulateGroupByTerms(
  PopulateGroupByTerms(unaryExpression.Operand, groupByTerms, groupByAliases, name);
  break;
 
+ case EntityShaperExpression entityShaperExpression
+ when entityShaperExpression.ValueBufferExpression is ProjectionBindingExpression projectionBindingExpression:
+ var entityProjectionExpression = (EntityProjectionExpression)((SelectExpression)projectionBindingExpression.QueryExpression)
+ .GetProjection(projectionBindingExpression);
+ foreach (var property in GetAllPropertiesInHierarchy(entityProjectionExpression.EntityType))
+ {
+ PopulateGroupByTerms(entityProjectionExpression.BindProperty(property), groupByTerms, groupByAliases, name: null);
+ }
+
+ if (entityProjectionExpression.DiscriminatorExpression != null)
+ {
+ PopulateGroupByTerms(
+ entityProjectionExpression.DiscriminatorExpression, groupByTerms, groupByAliases, name: DiscriminatorColumnAlias);
+ }
+
+ break;
+
  default:
  throw new InvalidOperationException(RelationalStrings.InvalidKeySelectorForGroupBy(keySelector, keySelector.GetType()));
  }

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

@@ -2688,6 +2688,19 @@ public virtual Task GroupBy_selecting_grouping_key_list(bool async)
  AssertCollection(e.Data, a.Data);
  });
 
+ [ConditionalTheory]
+ [MemberData(nameof(IsAsyncData))]
+ public virtual Task Select_GroupBy_SelectMany(bool async)
+ // Entity equality. Issue #15938.
+ => AssertTranslationFailed(
+ () => AssertQuery(
+ async,
+ ss => ss.Set<Order>().Select(
+ o => new ProjectedType { Order = o.OrderID, Customer = o.CustomerID })
+ .GroupBy(p => p.Customer)
+ .SelectMany(g => g),
+ elementSorter: g => g.Order));
+
  #endregion
 
  #region GroupBySelectFirst
@@ -2788,81 +2801,73 @@ public virtual Task GroupBy_select_grouping_composed_list_2(bool async)
 
  #region GroupByEntityType
 
- [ConditionalTheory]
- [MemberData(nameof(IsAsyncData))]
- public virtual Task Select_GroupBy_SelectMany(bool async)
- // Entity equality. Issue #15938.
- => AssertTranslationFailed(
- () => AssertQuery(
- async,
- ss => ss.Set<Order>().Select(
- o => new ProjectedType { Order = o.OrderID, Customer = o.CustomerID })
- .GroupBy(p => p.Customer)
- .SelectMany(g => g),
- elementSorter: g => g.Order));
-
  [ConditionalTheory]
  [MemberData(nameof(IsAsyncData))]
  public virtual Task GroupBy_with_group_key_being_navigation(bool async)
- // Entity equality. Issue #15938.
- => AssertTranslationFailed(
- () => AssertQuery(
- async,
- ss => ss.Set<OrderDetail>()
- .GroupBy(od => od.Order)
- .Select(g => new { g.Key, Aggregate = g.Sum(od => od.OrderID) }),
- elementSorter: e => e.Key));
+ => AssertQuery(
+ async,
+ ss => ss.Set<OrderDetail>()
+ .GroupBy(od => od.Order)
+ .Select(g => new { g.Key, Aggregate = g.Sum(od => od.OrderID) }),
+ elementSorter: e => e.Key.OrderID,
+ elementAsserter: (e, a) =>
+ {
+ AssertEqual(e.Key, a.Key);
+ AssertEqual(e.Aggregate, a.Aggregate);
+ },
+ entryCount: 830);
 
  [ConditionalTheory]
  [MemberData(nameof(IsAsyncData))]
  public virtual Task GroupBy_with_group_key_being_nested_navigation(bool async)
- // Entity equality. Issue #15938.
- => AssertTranslationFailed(
- () => AssertQuery(
- async,
- ss => ss.Set<OrderDetail>()
- .GroupBy(od => od.Order.Customer)
- .Select(g => new { g.Key, Aggregate = g.Sum(od => od.OrderID) }),
- elementSorter: e => e.Key));
+ => AssertQuery(
+ async,
+ ss => ss.Set<OrderDetail>()
+ .GroupBy(od => od.Order.Customer)
+ .Select(g => new { g.Key, Aggregate = g.Sum(od => od.OrderID) }),
+ elementSorter: e => e.Key.CustomerID,
+ elementAsserter: (e, a) =>
+ {
+ AssertEqual(e.Key, a.Key);
+ AssertEqual(e.Aggregate, a.Aggregate);
+ },
+ entryCount: 89);
 
  [ConditionalTheory]
  [MemberData(nameof(IsAsyncData))]
  public virtual Task GroupBy_with_group_key_being_navigation_with_entity_key_projection(bool async)
- // Entity equality. Issue #15938.
- => AssertTranslationFailed(
- () => AssertQuery(
- async,
- ss => ss.Set<OrderDetail>()
- .GroupBy(od => od.Order)
- .Select(g => g.Key)));
+ => AssertQuery(
+ async,
+ ss => ss.Set<OrderDetail>()
+ .GroupBy(od => od.Order)
+ .Select(g => g.Key),
+ entryCount: 830);
 
- [ConditionalTheory]
+ [ConditionalTheory(Skip = "Issue#29014")]
  [MemberData(nameof(IsAsyncData))]
  public virtual Task GroupBy_with_group_key_being_navigation_with_complex_projection(bool async)
- // Entity equality. Issue #15938.
- => AssertTranslationFailed(
- () => AssertQuery(
- async,
- ss => ss.Set<OrderDetail>()
- .GroupBy(od => od.Order)
- .Select(
- g => new
- {
- g.Key,
- Id1 = g.Key.CustomerID,
- Id2 = g.Key.Customer.CustomerID,
- Id3 = g.Key.OrderID,
- Aggregate = g.Sum(od => od.OrderID)
- }),
- elementSorter: e => e.Id3,
- elementAsserter: (e, a) =>
- {
- AssertEqual(e.Key, a.Key);
- Assert.Equal(e.Id1, a.Id1);
- Assert.Equal(e.Id2, a.Id2);
- Assert.Equal(e.Id3, a.Id3);
- Assert.Equal(e.Aggregate, a.Aggregate);
- }));
+ => AssertQuery(
+ async,
+ ss => ss.Set<OrderDetail>()
+ .GroupBy(od => od.Order)
+ .Select(
+ g => new
+ {
+ g.Key,
+ Id1 = g.Key.CustomerID,
+ Id2 = g.Key.Customer.CustomerID,
+ Id3 = g.Key.OrderID,
+ Aggregate = g.Sum(od => od.OrderID)
+ }),
+ elementSorter: e => e.Id3,
+ elementAsserter: (e, a) =>
+ {
+ AssertEqual(e.Key, a.Key);
+ Assert.Equal(e.Id1, a.Id1);
+ Assert.Equal(e.Id2, a.Id2);
+ Assert.Equal(e.Id3, a.Id3);
+ Assert.Equal(e.Aggregate, a.Aggregate);
+ });
 
  #endregion
 

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

@@ -2464,21 +2464,34 @@ public override async Task GroupBy_with_group_key_being_navigation(bool async)
  {
  await base.GroupBy_with_group_key_being_navigation(async);
 
- AssertSql();
+ AssertSql(
+ @"SELECT [o0].[OrderID], [o0].[CustomerID], [o0].[EmployeeID], [o0].[OrderDate], COALESCE(SUM([o].[OrderID]), 0) AS [Aggregate]
+FROM [Order Details] AS [o]
+INNER JOIN [Orders] AS [o0] ON [o].[OrderID] = [o0].[OrderID]
+GROUP BY [o0].[OrderID], [o0].[CustomerID], [o0].[EmployeeID], [o0].[OrderDate]");
  }
 
  public override async Task GroupBy_with_group_key_being_nested_navigation(bool async)
  {
  await base.GroupBy_with_group_key_being_nested_navigation(async);
 
- AssertSql();
+ AssertSql(
+ @"SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region], COALESCE(SUM([o].[OrderID]), 0) AS [Aggregate]
+FROM [Order Details] AS [o]
+INNER JOIN [Orders] AS [o0] ON [o].[OrderID] = [o0].[OrderID]
+LEFT JOIN [Customers] AS [c] ON [o0].[CustomerID] = [c].[CustomerID]
+GROUP BY [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName], [c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone], [c].[PostalCode], [c].[Region]");
  }
 
  public override async Task GroupBy_with_group_key_being_navigation_with_entity_key_projection(bool async)
  {
  await base.GroupBy_with_group_key_being_navigation_with_entity_key_projection(async);
 
- AssertSql();
+ AssertSql(
+ @"SELECT [o0].[OrderID], [o0].[CustomerID], [o0].[EmployeeID], [o0].[OrderDate]
+FROM [Order Details] AS [o]
+INNER JOIN [Orders] AS [o0] ON [o].[OrderID] = [o0].[OrderID]
+GROUP BY [o0].[OrderID], [o0].[CustomerID], [o0].[EmployeeID], [o0].[OrderDate]");
  }
 
  public override async Task GroupBy_with_group_key_being_navigation_with_complex_projection(bool async)