Reduce code duplication

h2/src/main/org/h2/expression/aggregate/AbstractAggregate.java

@@ -36,8 +36,22 @@ public abstract class AbstractAggregate extends Expression {
 
     protected Window over;
 
+    private SortOrder overOrderBySort;
+
     private int lastGroupRowId;
 
+    protected static SortOrder createOrder(Session session, ArrayList<SelectOrderBy> orderBy, int offset) {
+        int size = orderBy.size();
+        int[] index = new int[size];
+        int[] sortType = new int[size];
+        for (int i = 0; i < size; i++) {
+            SelectOrderBy o = orderBy.get(i);
+            index[i] = i + offset;
+            sortType[i] = o.sortType;
+        }
+        return new SortOrder(session.getDatabase(), index, sortType, null);
+    }
+
     AbstractAggregate(Select select, boolean distinct) {
         this.select = select;
         this.distinct = distinct;
@@ -73,6 +87,17 @@ public abstract class AbstractAggregate extends Expression {
         }
     }
 
+    @Override
+    public Expression optimize(Session session) {
+        if (over != null) {
+            ArrayList<SelectOrderBy> orderBy = over.getOrderBy();
+            if (orderBy != null) {
+                overOrderBySort = createOrder(session, orderBy, getNumExpressions());
+            }
+        }
+        return this;
+    }
+
     @Override
     public void setEvaluatable(TableFilter tableFilter, boolean b) {
         if (filterCondition != null) {
@@ -309,8 +334,7 @@ public abstract class AbstractAggregate extends Expression {
             ArrayList<Value[]> orderedData = (ArrayList<Value[]>) data;
             int ne = getNumExpressions();
             int last = ne + over.getOrderBy().size();
-            SortOrder sortOrder = createOrder(session, ne);
-            orderedData.sort(sortOrder);
+            orderedData.sort(overOrderBySort);
             Object aggregateData = createAggregateData();
             for (Value[] row : orderedData) {
                 updateFromExpressions(session, aggregateData, row);
@@ -320,19 +344,6 @@ public abstract class AbstractAggregate extends Expression {
         return result.get(groupData.getCurrentGroupRowId());
     }
 
-    private SortOrder createOrder(Session session, int ne) {
-        ArrayList<SelectOrderBy> orderBy = over.getOrderBy();
-        int size = orderBy.size();
-        int[] index = new int[size];
-        int[] sortType = new int[size];
-        for (int i = 0; i < size; i++) {
-            SelectOrderBy o = orderBy.get(i);
-            index[i] = i + ne;
-            sortType[i] = o.sortType;
-        }
-        return new SortOrder(session.getDatabase(), index, sortType, null);
-    }
-
     protected StringBuilder appendTailConditions(StringBuilder builder) {
         if (filterCondition != null) {
             builder.append(" FILTER (WHERE ").append(filterCondition.getSQL()).append(')');

h2/src/main/org/h2/expression/aggregate/Aggregate.java

@@ -256,18 +256,6 @@ public class Aggregate extends AbstractAggregate {
         this.groupConcatSeparator = separator;
     }
 
-    private SortOrder initOrder(Session session) {
-        int size = orderByList.size();
-        int[] index = new int[size];
-        int[] sortType = new int[size];
-        for (int i = 0; i < size; i++) {
-            SelectOrderBy o = orderByList.get(i);
-            index[i] = i + 1;
-            sortType[i] = o.sortType;
-        }
-        return new SortOrder(session.getDatabase(), index, sortType, null);
-    }
-
     private void sortWithOrderBy(Value[] array) {
         final SortOrder sortOrder = orderBySort;
         if (sortOrder != null) {
@@ -489,6 +477,7 @@ public class Aggregate extends AbstractAggregate {
 
     @Override
     public Expression optimize(Session session) {
+        super.optimize(session);
         if (on != null) {
             on = on.optimize(session);
             dataType = on.getType();
@@ -500,7 +489,7 @@ public class Aggregate extends AbstractAggregate {
             for (SelectOrderBy o : orderByList) {
                 o.expression = o.expression.optimize(session);
             }
-            orderBySort = initOrder(session);
+            orderBySort = createOrder(session, orderByList, 1);
         }
         if (groupConcatSeparator != null) {
             groupConcatSeparator = groupConcatSeparator.optimize(session);

h2/src/main/org/h2/expression/aggregate/JavaAggregate.java

@@ -116,6 +116,7 @@ public class JavaAggregate extends AbstractAggregate {
 
     @Override
     public Expression optimize(Session session) {
+        super.optimize(session);
         userConnection = session.createConnection(false);
         int len = args.length;
         argTypes = new int[len];