Cover predicate counts and the grouping projected alongside an aggregate

- Add Elements_and_predicate_counts: Count and LongCount with a predicate
  are windowed as COUNT(CASE ...) OVER (...) (COUNT_BIG on SQL Server),
  with the grouping still carrying every row
- Add Grouping_itself_and_aggregate_is_not_translated: projecting the
  grouping itself alongside an aggregate fails translation the same way
  with and without the opt-in

Part of #12747

Author: benedict-odonovan

test/EFCore.Relational.Specification.Tests/Query/WindowFunctionQueryRelationalTestBase.cs

@@ -190,6 +190,44 @@ public virtual async Task Elements_and_float_sum()
             });
     }
 
+    /// <summary>
+    ///     Count and LongCount with a predicate: the predicate goes into the aggregate rather than filtering the rows, which the grouping
+    ///     still carries all of.
+    /// </summary>
+    [Fact]
+    public virtual async Task Elements_and_predicate_counts()
+    {
+        var contextFactory = await InitializeAsync(useWindowFunctionAggregates: true);
+        await using var context = contextFactory.CreateDbContext();
+
+        var results = await context.Employees
+            .GroupBy(e => e.DepartmentName)
+            .Select(
+                g => new
+                {
+                    g.Key,
+                    Names = g.Select(e => e.Name).ToList(),
+                    HighEarners = g.Count(e => e.Salary > 100),
+                    LongHighEarners = g.LongCount(e => e.Salary > 100)
+                })
+            .ToListAsync();
+
+        Assert.Collection(
+            results.OrderBy(r => r.Key),
+            engineering =>
+            {
+                Assert.Equal(["Alice", "Bob", "Cheng"], engineering.Names.Order());
+                Assert.Equal(2, engineering.HighEarners);
+                Assert.Equal(2L, engineering.LongHighEarners);
+            },
+            sales =>
+            {
+                Assert.Equal(["Dara", "Emre"], sales.Names.Order());
+                Assert.Equal(0, sales.HighEarners);
+                Assert.Equal(0L, sales.LongHighEarners);
+            });
+    }
+
     [Fact]
     public virtual async Task Projected_elements_and_aggregate()
     {
@@ -450,6 +488,27 @@ public virtual async Task Elements_without_aggregate()
             sales => Assert.Equal(2, sales.Employees.Count));
     }
 
+    /// <summary>
+    ///     The grouping projected as itself alongside an aggregate has no translation, with or without the opt-in: there are no
+    ///     elements to carry window values on, and exposing the grouping would mean exposing the rows which carry them.
+    /// </summary>
+    [Theory, InlineData(false), InlineData(true)]
+    public virtual async Task Grouping_itself_and_aggregate_is_not_translated(bool useWindowFunctionAggregates)
+    {
+        var contextFactory = await InitializeAsync(useWindowFunctionAggregates);
+        await using var context = contextFactory.CreateDbContext();
+
+        var exception = await Assert.ThrowsAsync<InvalidOperationException>(
+            () => context.Employees
+                .GroupBy(e => e.DepartmentName)
+                .Select(g => new { Group = g, Count = g.Count() })
+                .ToListAsync());
+
+        Assert.Contains(
+            CoreStrings.TranslationFailedWithDetails("", CoreStrings.QuerySelectContainsGrouping)[21..],
+            exception.Message);
+    }
+
     /// <summary>
     ///     COUNT(DISTINCT ...) OVER (...) isn't supported by SQL Server, so a distinct aggregate keeps the GROUP BY translation.
     /// </summary>

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

@@ -82,6 +82,22 @@ ORDER BY [e1].[DepartmentName]
 """);
     }
 
+    public override async Task Elements_and_predicate_counts()
+    {
+        await base.Elements_and_predicate_counts();
+
+        AssertSql(
+            """
+SELECT [e].[DepartmentName], DENSE_RANK() OVER(ORDER BY [e].[DepartmentName]), [e].[Name], COUNT(CASE
+    WHEN [e].[Salary] > 100 THEN 1
+END) OVER(PARTITION BY [e].[DepartmentName]), COUNT_BIG(CASE
+    WHEN [e].[Salary] > 100 THEN 1
+END) OVER(PARTITION BY [e].[DepartmentName])
+FROM [Employees] AS [e]
+ORDER BY [e].[DepartmentName]
+""");
+    }
+
     public override async Task Projected_elements_and_aggregate()
     {
         await base.Projected_elements_and_aggregate();
@@ -212,6 +228,13 @@ ORDER BY [e].[DepartmentName]
 """);
     }
 
+    public override async Task Grouping_itself_and_aggregate_is_not_translated(bool useWindowFunctionAggregates)
+    {
+        await base.Grouping_itself_and_aggregate_is_not_translated(useWindowFunctionAggregates);
+
+        AssertSql();
+    }
+
     public override async Task Distinct_aggregate_is_not_lifted()
     {
         await base.Distinct_aggregate_is_not_lifted();

test/EFCore.Sqlite.FunctionalTests/Query/WindowFunctionQuerySqliteTest.cs

@@ -82,6 +82,22 @@ ORDER BY "e1"."DepartmentName"
 """);
     }
 
+    public override async Task Elements_and_predicate_counts()
+    {
+        await base.Elements_and_predicate_counts();
+
+        AssertSql(
+            """
+SELECT "e"."DepartmentName", DENSE_RANK() OVER(ORDER BY "e"."DepartmentName"), "e"."Name", COUNT(CASE
+    WHEN "e"."Salary" > 100 THEN 1
+END) OVER(PARTITION BY "e"."DepartmentName"), COUNT(CASE
+    WHEN "e"."Salary" > 100 THEN 1
+END) OVER(PARTITION BY "e"."DepartmentName")
+FROM "Employees" AS "e"
+ORDER BY "e"."DepartmentName"
+""");
+    }
+
     public override async Task Projected_elements_and_aggregate()
     {
         await base.Projected_elements_and_aggregate();
@@ -217,6 +233,13 @@ ORDER BY "e"."DepartmentName"
 """);
     }
 
+    public override async Task Grouping_itself_and_aggregate_is_not_translated(bool useWindowFunctionAggregates)
+    {
+        await base.Grouping_itself_and_aggregate_is_not_translated(useWindowFunctionAggregates);
+
+        AssertSql();
+    }
+
     public override async Task Distinct_aggregate_is_not_lifted()
     {
         await base.Distinct_aggregate_is_not_lifted();