Improve the de duplication in the ORDER BY clause (#211)

Author: ChrisJollyAU

src/EFCore.Jet/Query/Internal/JetLiftOrderByPostprocessor.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
@@ -55,15 +56,26 @@ public virtual Expression Process(Expression expression)
         switch (expression)
         {
             case ShapedQueryExpression shapedQueryExpression:
-                return shapedQueryExpression.UpdateQueryExpression(Visit(shapedQueryExpression.QueryExpression));
+                shapedQueryExpression = shapedQueryExpression.UpdateQueryExpression(Visit(shapedQueryExpression.QueryExpression));
+                shapedQueryExpression = shapedQueryExpression.UpdateShaperExpression(Visit(shapedQueryExpression.ShaperExpression));
+                return shapedQueryExpression;
+            case RelationalSplitCollectionShaperExpression relationalSplitCollectionShaperExpression:
+                var newSelect = Visit(relationalSplitCollectionShaperExpression.SelectExpression);
+                var newInner = Visit(relationalSplitCollectionShaperExpression.InnerShaper);
+                relationalSplitCollectionShaperExpression = relationalSplitCollectionShaperExpression.Update(
+                    relationalSplitCollectionShaperExpression.ParentIdentifier,
+                    relationalSplitCollectionShaperExpression.ChildIdentifier, (SelectExpression)newSelect, newInner);
+                return relationalSplitCollectionShaperExpression;
+            case NonQueryExpression nonQueryExpression:
+                return nonQueryExpression;
             case SelectExpression selectExpression:
                 {
                     Dictionary<int, (int? indexcol, OrderingExpression? orderexp, bool ascend, bool rewrite, bool referstocurouter)> columnsToRewrite = new();
                     bool isscalarselect = selectExpression is { Limit: SqlConstantExpression { Value: 1 }, Projection.Count: 1 };
                     for (int i = 0; i < selectExpression.Orderings.Count; i++)
                     {
                         var sqlExpression = selectExpression.Orderings[i].Expression;
-                        if (sqlExpression is not ColumnExpression)
+                        if (sqlExpression is not ColumnExpression && sqlExpression is not SqlConstantExpression && sqlExpression is not SqlParameterExpression)
                         {
                             var locate = new JetLocateScalarSubqueryVisitor(_typeMappingSource, _sqlExpressionFactory);
                             var locatedExpression = locate.Visit(sqlExpression);
@@ -72,24 +84,26 @@ public virtual Expression Process(Expression expression)
                             {
                                 int index = selectExpression.AddToProjection(sqlExpression);
                                 columnsToRewrite.Add(i, (index, null, selectExpression.Orderings[i].IsAscending, true, false));
+                                continue;
+                            }
+
+                            var existingIndex = selectExpression.Projection.ToList().FindIndex(pe => pe.Expression.Equals(sqlExpression));
+                            if (existingIndex != -1)
+                            {
+                                columnsToRewrite.Add(i, (existingIndex, null, selectExpression.Orderings[i].IsAscending, true, false));
                             }
                         }
                         else
                         {
-                            var foundproj = selectExpression.Projection.FirstOrDefault(p =>
-                                p.Expression.Equals(sqlExpression));
-                            if (foundproj == null && sqlExpression is ColumnExpression colexp && !selectExpression.Tables.Contains(colexp.Table))
-                            {
-                                var ix = selectExpression.AddToProjection(sqlExpression);
-                                columnsToRewrite.Add(i, (ix, null, selectExpression.Orderings[i].IsAscending, false, false));
-                            }
-                            else
+                            var existingIndex = selectExpression.Projection.ToList().FindIndex(pe => pe.Expression.Equals(sqlExpression));
+                            if (existingIndex != -1)
                             {
                                 bool referouter = sqlExpression is ColumnExpression colexp1 &&
-                                                  selectExpression.Tables.Contains(colexp1.Table);
+                                    selectExpression.Tables.Contains(colexp1.Table);
                                 columnsToRewrite.Add(i,
-                                    (null, selectExpression.Orderings[i], selectExpression.Orderings[i].IsAscending, false, referouter));
+                                    (existingIndex, selectExpression.Orderings[i], selectExpression.Orderings[i].IsAscending, false, referouter));
                             }
+                            
                         }
                     }
 
@@ -98,20 +112,21 @@ public virtual Expression Process(Expression expression)
                         return base.Visit(expression);
                     }
 
-                    for (int A = 0; A < columnsToRewrite.Count; A++)
+                    selectExpression.ClearOrdering();
+                    //Keep the limit in parent expression
+                    if (selectExpression.Limit != null)
                     {
-                        if (!columnsToRewrite[A].referstocurouter)
-                        {
-                            continue;
-                        }
-                        var col = columnsToRewrite[A].orderexp!.Expression as ColumnExpression;
-                        var colitem = columnsToRewrite[A];
-                        colitem.indexcol = selectExpression.AddToProjection(col!);
-                        columnsToRewrite[A] = colitem;
+                        var limit = selectExpression.Limit;
+                        selectExpression = selectExpression.Update(selectExpression.Projection, selectExpression.Tables,
+                            selectExpression.Predicate, selectExpression.GroupBy, selectExpression.Having,
+                            selectExpression.Orderings, null, null);
+                        selectExpression.PushdownIntoSubquery();
+                        selectExpression.ApplyLimit(limit);
+                    }
+                    else
+                    {
+                        selectExpression.PushdownIntoSubquery();
                     }
-
-                    selectExpression.ClearOrdering();
-                    selectExpression.PushdownIntoSubquery();
 
                     for (int j = 0; j < columnsToRewrite.Count; j++)
                     {