Optimize MIN/MAX on DISTINCT EnumerableExpressions

Author: ranma42

src/EFCore.Relational/Query/EnumerableExpression.cs

@@ -74,6 +74,13 @@ public virtual EnumerableExpression ApplySelector(Expression expression)
     public virtual EnumerableExpression ApplyDistinct()
         => new(Selector, distinct: true, Predicate, Orderings);
 
+    /// <summary>
+    ///     Drops DISTINCT operator on the selector of the <see cref="EnumerableExpression" />.
+    /// </summary>
+    /// <returns>The new expression with specified component updated.</returns>
+    public virtual EnumerableExpression DropDistinct()
+        => new(Selector, distinct: false, Predicate, Orderings);
+
     /// <summary>
     ///     Applies filter predicate to the <see cref="EnumerableExpression" />.
     /// </summary>

src/EFCore.Relational/Query/RelationalSqlTranslatingExpressionVisitor.cs

@@ -1362,12 +1362,15 @@ protected virtual bool TryTranslateAggregateMethodCall(
             {
                 switch (genericMethod.Name)
                 {
-                    case nameof(Queryable.Average)
-                        when QueryableMethods.IsAverageWithoutSelector(genericMethod):
                     case nameof(Queryable.Max)
                         when genericMethod == QueryableMethods.MaxWithoutSelector:
                     case nameof(Queryable.Min)
                         when genericMethod == QueryableMethods.MinWithoutSelector:
+                        enumerableExpression = enumerableExpression.DropDistinct();
+                        break;
+
+                    case nameof(Queryable.Average)
+                        when QueryableMethods.IsAverageWithoutSelector(genericMethod):
                     case nameof(Queryable.Sum)
                         when QueryableMethods.IsSumWithoutSelector(genericMethod):
                     case nameof(Queryable.Count)
@@ -1376,12 +1379,16 @@ when QueryableMethods.IsSumWithoutSelector(genericMethod):
                         when genericMethod == QueryableMethods.LongCountWithoutPredicate:
                         break;
 
-                    case nameof(Queryable.Average)
-                        when QueryableMethods.IsAverageWithSelector(genericMethod):
                     case nameof(Queryable.Max)
                         when genericMethod == QueryableMethods.MaxWithSelector:
                     case nameof(Queryable.Min)
                         when genericMethod == QueryableMethods.MinWithSelector:
+                        enumerableExpression = enumerableExpression.DropDistinct();
+                        enumerableExpression = ProcessSelector(enumerableExpression, arguments[1].UnwrapLambdaFromQuote());
+                        break;
+
+                    case nameof(Queryable.Average)
+                        when QueryableMethods.IsAverageWithSelector(genericMethod):
                     case nameof(Queryable.Sum)
                         when QueryableMethods.IsSumWithSelector(genericMethod):
                         enumerableExpression = ProcessSelector(enumerableExpression, arguments[1].UnwrapLambdaFromQuote());