Translate conversions around lifted aggregates on the server

- Record a conversion around an aggregate as part of the aggregate, so it
  is translated with it rather than applied on the client: a cast such as
  (decimal)g.Average(...) rounds on SQL Server, and moving it to the
  client changed the result with the opt-in on (1.3333... instead of 1.33)
- Such a conversion translates to a CAST around the function, which can't
  carry a window, so the projection keeps the GROUP BY translation; a
  conversion the server doesn't need, such as to a nullable type,
  translates to nothing and the aggregate is still windowed
- Add tests for a decimal-converted average, with the opt-in off and on,
  and a nullable-converted count

Part of #12747

Author: benedict-odonovan

src/EFCore.Relational/Query/RelationalQueryableMethodTranslatingExpressionVisitor.cs

@@ -1776,7 +1776,11 @@ public Expression Rewrite(Expression projection, ParameterExpression groupingPar
                     return _groupingParameter is null ? expression : RewriteAggregate(aggregateIndex);
                 }
 
-                if (_groupingParameter is null && IsAggregateOverGrouping(expression))
+                // A conversion around the aggregate is part of it, and gets translated with it: on the server it can be a CAST with
+                // semantics of its own (a decimal cast rounds), which moving it to the client would lose. If it translates to a CAST
+                // around the function, the aggregate can't carry a window and the projection keeps the GROUP BY translation; a conversion
+                // the server doesn't need, such as to a nullable type, translates to nothing and the aggregate is windowed as usual.
+                if (_groupingParameter is null && IsAggregateOverGrouping(RemoveConversions(expression)))
                 {
                     _aggregates.Add(expression);
 
@@ -1872,6 +1876,16 @@ private bool TryMatchElements(
             return true;
         }
 
+        private static Expression RemoveConversions(Expression expression)
+        {
+            while (expression is UnaryExpression { NodeType: ExpressionType.Convert or ExpressionType.ConvertChecked } conversion)
+            {
+                expression = conversion.Operand;
+            }
+
+            return expression;
+        }
+
         /// <summary>
         ///     Checks whether the given expression is an aggregate applied directly to the grouping, e.g. <c>g.Sum(e => e.Value)</c>.
         /// </summary>

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

@@ -228,6 +228,69 @@ public virtual async Task Elements_and_predicate_counts()
             });
     }
 
+    /// <summary>
+    ///     A conversion around an aggregate is translated with it. A decimal cast rounds on SQL Server (to decimal(18,2)), so it has to
+    ///     stay on the server, inside the aggregate's translation; there it's a CAST around the function, which can't carry a window, and
+    ///     the projection keeps the GROUP BY translation whether the option is on or off.
+    /// </summary>
+    [Theory, InlineData(false), InlineData(true)]
+    public virtual async Task Elements_and_decimal_converted_aggregate(bool useWindowFunctionAggregates)
+    {
+        var contextFactory = await InitializeAsync(useWindowFunctionAggregates);
+        await using var context = contextFactory.CreateDbContext();
+        context.Employees.AddRange(
+            new Employee { Name = "Gus", DepartmentName = "Support", Salary = 1 },
+            new Employee { Name = "Hana", DepartmentName = "Support", Salary = 1 },
+            new Employee { Name = "Ivo", DepartmentName = "Support", Salary = 2 });
+        await context.SaveChangesAsync();
+
+        ClearLog();
+
+        var results = await context.Employees
+            .Where(e => e.DepartmentName == "Support")
+            .GroupBy(e => e.DepartmentName)
+            .Select(g => new { Names = g.Select(e => e.Name).ToList(), AverageSalary = (decimal)g.Average(e => e.Salary) })
+            .ToListAsync();
+
+        var support = Assert.Single(results);
+        Assert.Equal(["Gus", "Hana", "Ivo"], support.Names.Order());
+        Assert.Equal(DecimalAverageOfOneOneTwo, support.AverageSalary);
+    }
+
+    /// <summary>
+    ///     The average of 1, 1 and 2 after the provider's conversion to decimal: rounded where the database converts to a fixed scale.
+    /// </summary>
+    protected virtual decimal DecimalAverageOfOneOneTwo
+        => 1.33m;
+
+    /// <summary>
+    ///     A conversion the server doesn't need, such as to a nullable type, translates to nothing, so the aggregate is windowed as usual.
+    /// </summary>
+    [Fact]
+    public virtual async Task Elements_and_nullable_converted_count()
+    {
+        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(), Count = (int?)g.Count() })
+            .ToListAsync();
+
+        Assert.Collection(
+            results.OrderBy(r => r.Key),
+            engineering =>
+            {
+                Assert.Equal(["Alice", "Bob", "Cheng"], engineering.Names.Order());
+                Assert.Equal(3, engineering.Count);
+            },
+            sales =>
+            {
+                Assert.Equal(["Dara", "Emre"], sales.Names.Order());
+                Assert.Equal(2, sales.Count);
+            });
+    }
+
     [Fact]
     public virtual async Task Projected_elements_and_aggregate()
     {

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

@@ -98,6 +98,40 @@ ORDER BY [e].[DepartmentName]
 """);
     }
 
+    public override async Task Elements_and_decimal_converted_aggregate(bool useWindowFunctionAggregates)
+    {
+        await base.Elements_and_decimal_converted_aggregate(useWindowFunctionAggregates);
+
+        AssertSql(
+            """
+SELECT [e1].[DepartmentName], [e2].[Name], [e2].[Id], [e1].[c]
+FROM (
+    SELECT CAST(AVG(CAST([e].[Salary] AS float)) AS decimal(18,2)) AS [c], [e].[DepartmentName]
+    FROM [Employees] AS [e]
+    WHERE [e].[DepartmentName] = N'Support'
+    GROUP BY [e].[DepartmentName]
+) AS [e1]
+LEFT JOIN (
+    SELECT [e0].[Name], [e0].[Id], [e0].[DepartmentName]
+    FROM [Employees] AS [e0]
+    WHERE [e0].[DepartmentName] = N'Support'
+) AS [e2] ON [e1].[DepartmentName] = [e2].[DepartmentName]
+ORDER BY [e1].[DepartmentName]
+""");
+    }
+
+    public override async Task Elements_and_nullable_converted_count()
+    {
+        await base.Elements_and_nullable_converted_count();
+
+        AssertSql(
+            """
+SELECT [e].[DepartmentName], DENSE_RANK() OVER(ORDER BY [e].[DepartmentName]), [e].[Name], COUNT(*) 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();

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

@@ -98,6 +98,40 @@ ORDER BY "e"."DepartmentName"
 """);
     }
 
+    // SQLite converts to decimal without a fixed scale, so nothing is rounded.
+    protected override decimal DecimalAverageOfOneOneTwo
+        => 1.3333333333333333m;
+
+    public override async Task Elements_and_decimal_converted_aggregate(bool useWindowFunctionAggregates)
+    {
+        await base.Elements_and_decimal_converted_aggregate(useWindowFunctionAggregates);
+
+        AssertSql(
+            """
+SELECT "e1"."DepartmentName", "e0"."Name", "e0"."Id", "e1"."c"
+FROM (
+    SELECT CAST(AVG(CAST("e"."Salary" AS REAL)) AS TEXT) AS "c", "e"."DepartmentName"
+    FROM "Employees" AS "e"
+    WHERE "e"."DepartmentName" = 'Support'
+    GROUP BY "e"."DepartmentName"
+) AS "e1"
+LEFT JOIN "Employees" AS "e0" ON "e1"."DepartmentName" = "e0"."DepartmentName" AND "e0"."DepartmentName" = 'Support'
+ORDER BY "e1"."DepartmentName"
+""");
+    }
+
+    public override async Task Elements_and_nullable_converted_count()
+    {
+        await base.Elements_and_nullable_converted_count();
+
+        AssertSql(
+            """
+SELECT "e"."DepartmentName", DENSE_RANK() OVER(ORDER BY "e"."DepartmentName"), "e"."Name", COUNT(*) 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();