Do not sort window data if ORDER BY is not specified

h2/src/main/org/h2/command/Parser.java

@@ -3049,40 +3049,7 @@ public class Parser {
         }
         Window over = null;
         if (readIf("OVER")) {
-            read(OPEN_PAREN);
-            ArrayList<Expression> partitionBy = null;
-            if (readIf("PARTITION")) {
-                read("BY");
-                partitionBy = Utils.newSmallArrayList();
-                do {
-                    Expression expr = readExpression();
-                    partitionBy.add(expr);
-                } while (readIf(COMMA));
-            }
-            ArrayList<SelectOrderBy> orderBy = null;
-            if (readIf(ORDER)) {
-                read("BY");
-                orderBy = parseSimpleOrderList();
-            } else if (!isAggregate) {
-                orderBy = new ArrayList<>(0);
-            }
-            WindowFrame frame;
-            if (aggregate instanceof WindowFunction) {
-                WindowFunction w = (WindowFunction) aggregate;
-                switch (w.getFunctionType()) {
-                case FIRST_VALUE:
-                case LAST_VALUE:
-                case NTH_VALUE:
-                    frame = readWindowFrame();
-                    break;
-                default:
-                    frame = null;
-                }
-            } else {
-                frame = readWindowFrame();
-            }
-            read(CLOSE_PAREN);
-            over = new Window(partitionBy, orderBy, frame);
+            over = readWindowSpecification(aggregate);
             aggregate.setOverCondition(over);
             currentSelect.setWindowQuery();
         } else if (!isAggregate) {
@@ -3092,6 +3059,41 @@ public class Parser {
         }
     }
 
+    private Window readWindowSpecification(AbstractAggregate aggregate) {
+        read(OPEN_PAREN);
+        ArrayList<Expression> partitionBy = null;
+        if (readIf("PARTITION")) {
+            read("BY");
+            partitionBy = Utils.newSmallArrayList();
+            do {
+                Expression expr = readExpression();
+                partitionBy.add(expr);
+            } while (readIf(COMMA));
+        }
+        ArrayList<SelectOrderBy> orderBy = null;
+        if (readIf(ORDER)) {
+            read("BY");
+            orderBy = parseSimpleOrderList();
+        }
+        WindowFrame frame;
+        if (aggregate instanceof WindowFunction) {
+            WindowFunction w = (WindowFunction) aggregate;
+            switch (w.getFunctionType()) {
+            case FIRST_VALUE:
+            case LAST_VALUE:
+            case NTH_VALUE:
+                frame = readWindowFrame();
+                break;
+            default:
+                frame = null;
+            }
+        } else {
+            frame = readWindowFrame();
+        }
+        read(CLOSE_PAREN);
+        return new Window(partitionBy, orderBy, frame);
+    }
+
     private WindowFrame readWindowFrame() {
         WindowFrameUnits units;
         if (readIf("ROWS")) {

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

@@ -118,6 +118,8 @@ public abstract class AbstractAggregate extends Expression {
             ArrayList<SelectOrderBy> orderBy = over.getOrderBy();
             if (orderBy != null) {
                 overOrderBySort = createOrder(session, orderBy, getNumExpressions());
+            } else if (!isAggregate()) {
+                overOrderBySort = new SortOrder(session.getDatabase(), new int[getNumExpressions()], new int[0], null);
             }
         }
         return this;
@@ -176,7 +178,7 @@ public abstract class AbstractAggregate extends Expression {
         }
         if (over != null) {
             ArrayList<SelectOrderBy> orderBy = over.getOrderBy();
-            if (orderBy != null) {
+            if (orderBy != null || !isAggregate()) {
                 updateOrderedAggregate(session, groupData, groupRowId, orderBy);
                 return;
             }
@@ -359,7 +361,7 @@ public abstract class AbstractAggregate extends Expression {
                 data = partition.getData();
             }
         }
-        if (over.getOrderBy() != null) {
+        if (over.getOrderBy() != null || !isAggregate()) {
             return getOrderedResult(session, groupData, partition, data);
         }
         Value result = partition.getResult();
@@ -384,10 +386,11 @@ public abstract class AbstractAggregate extends Expression {
     private void updateOrderedAggregate(Session session, SelectGroups groupData, int groupRowId,
             ArrayList<SelectOrderBy> orderBy) {
         int ne = getNumExpressions();
-        int size = orderBy.size();
+        int size = orderBy != null ? orderBy.size() : 0;
         Value[] array = new Value[ne + size + 1];
         rememberExpressions(session, array);
         for (int i = 0; i < size; i++) {
+            @SuppressWarnings("null")
             SelectOrderBy o = orderBy.get(i);
             array[ne++] = o.expression.getValue(session);
         }
@@ -395,7 +398,6 @@ public abstract class AbstractAggregate extends Expression {
         @SuppressWarnings("unchecked")
         ArrayList<Value[]> data = (ArrayList<Value[]>) getData(session, groupData, false, true);
         data.add(array);
-        return;
     }
 
     private Value getOrderedResult(Session session, SelectGroups groupData, PartitionData partition, Object data) {
@@ -404,9 +406,12 @@ public abstract class AbstractAggregate extends Expression {
             result = new HashMap<>();
             @SuppressWarnings("unchecked")
             ArrayList<Value[]> orderedData = (ArrayList<Value[]>) data;
-            int ne = getNumExpressions();
-            int rowIdColumn = ne + over.getOrderBy().size();
-            Collections.sort(orderedData, overOrderBySort);
+            int rowIdColumn = getNumExpressions();
+            ArrayList<SelectOrderBy> orderBy = over.getOrderBy();
+            if (orderBy != null) {
+                rowIdColumn += orderBy.size();
+                Collections.sort(orderedData, overOrderBySort);
+            }
             getOrderedResultLoop(session, result, orderedData, rowIdColumn);
             partition.setOrderedResult(result);
         }