Optimize window aggregates with AND UNBOUNDED FOLLOWING and no exclusions

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

@@ -98,15 +98,22 @@ public abstract class AbstractAggregate extends DataAnalysisOperation {
             aggregateFastPartition(session, result, ordered, rowIdColumn, grouped);
             return;
         }
-        if (frame.getStarting().getType() == WindowFrameBoundType.UNBOUNDED_PRECEDING
-                && frame.getExclusion() == WindowFrameExclusion.EXCLUDE_NO_OTHERS) {
+        if (frame.getExclusion() == WindowFrameExclusion.EXCLUDE_NO_OTHERS) {
             WindowFrameBound following = frame.getFollowing();
-            if (following != null && following.getType() == WindowFrameBoundType.UNBOUNDED_FOLLOWING) {
-                aggregateWholePartition(session, result, ordered, rowIdColumn);
-            } else {
-                aggregateFastPartition(session, result, ordered, rowIdColumn, grouped);
+            boolean unboundedFollowing = following != null
+                    && following.getType() == WindowFrameBoundType.UNBOUNDED_FOLLOWING;
+            if (frame.getStarting().getType() == WindowFrameBoundType.UNBOUNDED_PRECEDING) {
+                if (unboundedFollowing) {
+                    aggregateWholePartition(session, result, ordered, rowIdColumn);
+                } else {
+                    aggregateFastPartition(session, result, ordered, rowIdColumn, grouped);
+                }
+                return;
+            }
+            if (unboundedFollowing) {
+                aggregateFastPartitionInReverse(session, result, ordered, rowIdColumn, grouped);
+                return;
             }
-            return;
         }
         // All other types of frames (slow)
         int size = ordered.size();
@@ -138,6 +145,28 @@ public abstract class AbstractAggregate extends DataAnalysisOperation {
         }
     }
 
+    private void aggregateFastPartitionInReverse(Session session, HashMap<Integer, Value> result,
+            ArrayList<Value[]> ordered, int rowIdColumn, boolean grouped) {
+        Object aggregateData = createAggregateData();
+        int firstIncludedRow = ordered.size();
+        for (int i = firstIncludedRow - 1; i >= 0;) {
+            int newLast = over.getWindowFrame().getStartIndex(session, ordered, getOverOrderBySort(), i);
+            assert newLast <= firstIncludedRow;
+            if (newLast < firstIncludedRow) {
+                for (int j = firstIncludedRow - 1; j >= newLast; j--) {
+                    updateFromExpressions(session, aggregateData, ordered.get(j));
+                }
+                firstIncludedRow = newLast;
+            }
+            Value[] lastRowInGroup = ordered.get(i), currentRowInGroup = lastRowInGroup;
+            Value r = getAggregatedValue(session, aggregateData);
+            do {
+                result.put(currentRowInGroup[rowIdColumn].getInt(), r);
+            } while (--i >= 0 && grouped
+                    && overOrderBySort.compare(lastRowInGroup, currentRowInGroup = ordered.get(i)) == 0);
+        }
+    }
+
     private int processGroup(Session session, HashMap<Integer, Value> result, ArrayList<Value[]> ordered,
             int rowIdColumn, int i, int size, Object aggregateData, boolean grouped) {
         Value[] firstRowInGroup = ordered.get(i), currentRowInGroup = firstRowInGroup;

h2/src/main/org/h2/expression/analysis/WindowFrame.java

@@ -424,6 +424,32 @@ public final class WindowFrame {
                 : plainIterator(orderedRows, startIndex, endIndex, reverse);
     }
 
+    /**
+     * Returns start index of this frame,
+     *
+     * @param session
+     *            the session
+     * @param orderedRows
+     *            ordered rows
+     * @param sortOrder
+     *            sort order
+     * @param currentRow
+     *            index of the current row
+     * @return start index
+     * @throws UnsupportedOperationException
+     *             if exclusion clause is not EXCLUDE NO OTHERS
+     */
+    public int getStartIndex(Session session, ArrayList<Value[]> orderedRows, SortOrder sortOrder, int currentRow) {
+        if (exclusion != WindowFrameExclusion.EXCLUDE_NO_OTHERS) {
+            throw new UnsupportedOperationException();
+        }
+        int startIndex = getIndex(session, orderedRows, sortOrder, currentRow, starting, false);
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+        return startIndex;
+    }
+
     /**
      * Returns end index of this frame,
      *

h2/src/test/org/h2/test/scripts/functions/aggregate/array-agg.sql

@@ -371,7 +371,7 @@ SELECT *,
     ARRAY_AGG(ID) OVER (ORDER BY VALUE GROUPS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) U_P,
     ARRAY_AGG(ID) OVER (ORDER BY VALUE GROUPS BETWEEN 2 PRECEDING AND 1 PRECEDING) P,
     ARRAY_AGG(ID) OVER (ORDER BY VALUE GROUPS BETWEEN 1 FOLLOWING AND 2 FOLLOWING) F,
-    ARRAY_AGG(ID) OVER (ORDER BY VALUE GROUPS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING) U_F
+    ARRAY_AGG(ID ORDER BY ID) OVER (ORDER BY VALUE GROUPS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING) U_F
     FROM TEST;
 > ID VALUE U_P                P            F               U_F
 > -- ----- ------------------ ------------ --------------- ------------------
@@ -451,11 +451,11 @@ SELECT ID, VALUE, ARRAY_AGG(ID) OVER (ORDER BY VALUE RANGE BETWEEN 2 PRECEDING A
 
 SELECT ID, VALUE,
     ARRAY_AGG(ID) OVER (ORDER BY VALUE ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) CP,
-    ARRAY_AGG(ID) OVER (ORDER BY VALUE ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) CF,
+    ARRAY_AGG(ID ORDER BY ID) OVER (ORDER BY VALUE ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) CF,
     ARRAY_AGG(ID) OVER (ORDER BY VALUE RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) RP,
-    ARRAY_AGG(ID) OVER (ORDER BY VALUE RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) RF,
+    ARRAY_AGG(ID ORDER BY ID) OVER (ORDER BY VALUE RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) RF,
     ARRAY_AGG(ID) OVER (ORDER BY VALUE GROUPS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) GP,
-    ARRAY_AGG(ID) OVER (ORDER BY VALUE GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) GF
+    ARRAY_AGG(ID ORDER BY ID) OVER (ORDER BY VALUE GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) GF
     FROM TEST;
 > ID VALUE CP                       CF                       RP                       RF                       GP                       GF
 > -- ----- ------------------------ ------------------------ ------------------------ ------------------------ ------------------------ ------------------------
@@ -545,11 +545,11 @@ SELECT ID, VALUE, ARRAY_AGG(ID) OVER (ORDER BY VALUE RANGE BETWEEN 1 FOLLOWING A
 
 SELECT ID, VALUE,
     ARRAY_AGG(ID) OVER (ORDER BY VALUE ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) CP,
-    ARRAY_AGG(ID) OVER (ORDER BY VALUE ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) CF,
+    ARRAY_AGG(ID ORDER BY ID) OVER (ORDER BY VALUE ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) CF,
     ARRAY_AGG(ID) OVER (ORDER BY VALUE RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) RP,
-    ARRAY_AGG(ID) OVER (ORDER BY VALUE RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) RF,
+    ARRAY_AGG(ID ORDER BY ID) OVER (ORDER BY VALUE RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) RF,
     ARRAY_AGG(ID) OVER (ORDER BY VALUE GROUPS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) GP,
-    ARRAY_AGG(ID) OVER (ORDER BY VALUE GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) GF
+    ARRAY_AGG(ID ORDER BY ID) OVER (ORDER BY VALUE GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) GF
     FROM TEST;
 > ID VALUE CP                       CF                       RP                       RF                       GP                       GF
 > -- ----- ------------------------ ------------------------ ------------------------ ------------------------ ------------------------ ------------------------