Add experimental implementation of grouped window queries

h2/src/main/org/h2/command/dml/Select.java

@@ -356,29 +356,34 @@ public class Select extends Query {
     }
 
     private void queryWindow(int columnCount, LocalResult result, long offset, boolean quickOffset) {
+        if (isGroupQuery) {
+            queryGroupWindow(columnCount, result, offset, quickOffset);
+            return;
+        }
         if (groupData == null) {
             groupData = SelectGroups.getInstance(session, expressions, isGroupQuery, groupIndex);
         }
         groupData.reset();
         try {
-            int rowNumber = 0;
-            setCurrentRowNumber(0);
-            int sampleSize = getSampleSizeValue(session);
-            while (topTableFilter.next()) {
-                setCurrentRowNumber(rowNumber + 1);
-                if (isConditionMet()) {
-                    rowNumber++;
-                    groupData.nextSource();
-                    updateAgg(columnCount, true);
-                    if (sampleSize > 0 && rowNumber >= sampleSize) {
-                        break;
-                    }
-                }
+            gatherGroup(columnCount, true);
+            processGroupResult(columnCount, result, offset, quickOffset);
+        } finally {
+            groupData.reset();
+        }
+    }
+
+    private void queryGroupWindow(int columnCount, LocalResult result, long offset, boolean quickOffset) {
+        if (groupData == null) {
+            groupData = SelectGroups.getInstance(session, expressions, isGroupQuery, groupIndex);
+        }
+        groupData.reset();
+        try {
+            gatherGroup(columnCount, false);
+            while (groupData.next() != null) {
+                updateAgg(columnCount, true);
             }
             groupData.done();
-            for (ValueArray currentGroupsKey; (currentGroupsKey = groupData.next()) != null;) {
-                offset = processGroupedRow(columnCount, result, offset, quickOffset, currentGroupsKey);
-            }
+            processGroupResult(columnCount, result, offset, quickOffset);
         } finally {
             groupData.reset();
         }
@@ -390,29 +395,31 @@ public class Select extends Query {
         }
         groupData.reset();
         try {
-            int rowNumber = 0;
-            setCurrentRowNumber(0);
-            int sampleSize = getSampleSizeValue(session);
-            while (topTableFilter.next()) {
-                setCurrentRowNumber(rowNumber + 1);
-                if (isConditionMet()) {
-                    rowNumber++;
-                    groupData.nextSource();
-                    updateAgg(columnCount, false);
-                    if (sampleSize > 0 && rowNumber >= sampleSize) {
-                        break;
-                    }
-                }
-            }
-            groupData.done();
-            for (ValueArray currentGroupsKey; (currentGroupsKey = groupData.next()) != null;) {
-                offset = processGroupedRow(columnCount, result, offset, quickOffset, currentGroupsKey);
-            }
+            gatherGroup(columnCount, false);
+            processGroupResult(columnCount, result, offset, quickOffset);
         } finally {
             groupData.reset();
         }
     }
 
+    private void gatherGroup(int columnCount, boolean window) {
+        int rowNumber = 0;
+        setCurrentRowNumber(0);
+        int sampleSize = getSampleSizeValue(session);
+        while (topTableFilter.next()) {
+            setCurrentRowNumber(rowNumber + 1);
+            if (isConditionMet()) {
+                rowNumber++;
+                groupData.nextSource();
+                updateAgg(columnCount, window);
+                if (sampleSize > 0 && rowNumber >= sampleSize) {
+                    break;
+                }
+            }
+        }
+        groupData.done();
+    }
+
     private void updateAgg(int columnCount, boolean window) {
         for (int i = 0; i < columnCount; i++) {
             if (groupByExpression == null || !groupByExpression[i]) {
@@ -422,30 +429,30 @@ public class Select extends Query {
         }
     }
 
-    private long processGroupedRow(int columnCount, LocalResult result, long offset, boolean quickOffset,
-            ValueArray currentGroupsKey) {
-        Value[] keyValues = currentGroupsKey.getList();
-        Value[] row = new Value[columnCount];
-        for (int j = 0; groupIndex != null && j < groupIndex.length; j++) {
-            row[groupIndex[j]] = keyValues[j];
-        }
-        for (int j = 0; j < columnCount; j++) {
-            if (groupByExpression != null && groupByExpression[j]) {
+    private void processGroupResult(int columnCount, LocalResult result, long offset, boolean quickOffset) {
+        for (ValueArray currentGroupsKey; (currentGroupsKey = groupData.next()) != null;) {
+            Value[] keyValues = currentGroupsKey.getList();
+            Value[] row = new Value[columnCount];
+            for (int j = 0; groupIndex != null && j < groupIndex.length; j++) {
+                row[groupIndex[j]] = keyValues[j];
+            }
+            for (int j = 0; j < columnCount; j++) {
+                if (groupByExpression != null && groupByExpression[j]) {
+                    continue;
+                }
+                Expression expr = expressions.get(j);
+                row[j] = expr.getValue(session);
+            }
+            if (isHavingNullOrFalse(row)) {
                 continue;
             }
-            Expression expr = expressions.get(j);
-            row[j] = expr.getValue(session);
-        }
-        if (isHavingNullOrFalse(row)) {
-            return offset;
-        }
-        if (quickOffset && offset > 0) {
-            offset--;
-            return offset;
+            if (quickOffset && offset > 0) {
+                offset--;
+                continue;
+            }
+            row = keepOnlyDistinct(row, columnCount);
+            result.addRow(row);
         }
-        row = keepOnlyDistinct(row, columnCount);
-        result.addRow(row);
-        return offset;
     }
 
     /**
@@ -746,7 +753,11 @@ public class Select extends Query {
                 if (isQuickAggregateQuery) {
                     queryQuick(columnCount, to, quickOffset && offset > 0);
                 } else if (isWindowQuery) {
-                    queryWindow(columnCount, result, offset, quickOffset);
+                    if (isGroupQuery) {
+                        queryGroupWindow(columnCount, result, offset, quickOffset);
+                    } else {
+                        queryWindow(columnCount, result, offset, quickOffset);
+                    }
                 } else if (isGroupQuery) {
                     if (isGroupSortedQuery) {
                         lazyResult = queryGroupSorted(columnCount, to, offset, quickOffset);
@@ -943,10 +954,6 @@ public class Select extends Query {
             throw DbException.get(ErrorCode.WITH_TIES_WITHOUT_ORDER_BY);
         }
 
-        if (isWindowQuery && isGroupQuery) {
-            throw DbException.getUnsupportedException("Window functions in group query are not currently supported.");
-        }
-
         Database db = session.getDatabase();
 
         // first the select list (visible columns),
@@ -1437,6 +1444,24 @@ public class Select extends Query {
         return isQuickAggregateQuery;
     }
 
+    /**
+     * Checks if this query is a group query.
+     *
+     * @return whether this query is a group query.
+     */
+    public boolean isGroupQuery() {
+        return isGroupQuery;
+    }
+
+    /**
+     * Checks if this query contains window functions.
+     *
+     * @return whether this query contains window functions
+     */
+    public boolean isWindowQuery() {
+        return isWindowQuery;
+    }
+
     @Override
     public void addGlobalCondition(Parameter param, int columnId,
             int comparisonType) {

h2/src/main/org/h2/command/dml/SelectGroups.java

@@ -127,6 +127,7 @@ public abstract class SelectGroups {
             if (cursor.hasNext()) {
                 Map.Entry<ValueArray, Object[]> entry = cursor.next();
                 currentGroupByExprData = entry.getValue();
+                currentGroupRowId++;
                 return entry.getKey();
             }
             return null;

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

@@ -291,6 +291,15 @@ public class Aggregate extends AbstractAggregate {
     @Override
     public void updateAggregate(Session session, boolean window) {
         if (window != (over != null)) {
+            if (!window && select.isWindowQuery()) {
+                if (on != null) {
+                    on.updateAggregate(session, false);
+                }
+                if (filterCondition != null) {
+                    filterCondition.updateAggregate(session, false);
+                }
+                over.updateAggregate(session, false);
+            }
             return;
         }
         // TODO aggregates: check nested MIN(MAX(ID)) and so on
@@ -311,7 +320,9 @@ public class Aggregate extends AbstractAggregate {
         lastGroupRowId = groupRowId;
 
         if (over != null) {
-            over.updateAggregate(session, true);
+            if (!select.isGroupQuery()) {
+                over.updateAggregate(session, true);
+            }
         }
         if (filterCondition != null) {
             if (!filterCondition.getBooleanValue(session)) {

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

@@ -119,10 +119,44 @@ SELECT ARRAY_AGG(ID) FILTER (WHERE ID < 3 OR ID > 4) OVER (PARTITION BY NAME), N
 > rows (ordered): 6
 
 SELECT ARRAY_AGG(SUM(ID)) OVER () FROM TEST;
-> exception FEATURE_NOT_SUPPORTED_1
+> ARRAY_AGG(SUM(ID)) OVER ()
+> --------------------------
+> (21)
+> rows: 1
 
 SELECT ARRAY_AGG(ID) OVER() FROM TEST GROUP BY ID;
-> exception FEATURE_NOT_SUPPORTED_1
+> ARRAY_AGG(ID) OVER ()
+> ---------------------
+> (1, 2, 3, 4, 5, 6)
+> (1, 2, 3, 4, 5, 6)
+> (1, 2, 3, 4, 5, 6)
+> (1, 2, 3, 4, 5, 6)
+> (1, 2, 3, 4, 5, 6)
+> (1, 2, 3, 4, 5, 6)
+> rows: 6
+
+SELECT ARRAY_AGG(NAME) OVER(PARTITION BY NAME) FROM TEST GROUP BY NAME;
+> ARRAY_AGG(NAME) OVER (PARTITION BY NAME)
+> ----------------------------------------
+> (a)
+> (b)
+> (c)
+> rows: 3
+
+SELECT ARRAY_AGG(ARRAY_AGG(ID)) OVER (PARTITION BY NAME), NAME FROM TEST GROUP BY NAME;
+> ARRAY_AGG(ARRAY_AGG(ID)) OVER (PARTITION BY NAME) NAME
+> ------------------------------------------------- ----
+> ((1, 2))                                          a
+> ((3))                                             b
+> ((4, 5, 6))                                       c
+> rows: 3
+
+SELECT ARRAY_AGG(ARRAY_AGG(ID)) OVER (PARTITION BY NAME), NAME FROM TEST GROUP BY NAME OFFSET 1 ROW;
+> ARRAY_AGG(ARRAY_AGG(ID)) OVER (PARTITION BY NAME) NAME
+> ------------------------------------------------- ----
+> ((3))                                             b
+> ((4, 5, 6))                                       c
+> rows: 2
 
 DROP TABLE TEST;
 > ok

h2/src/test/org/h2/test/scripts/functions/aggregate/sum.sql

@@ -40,3 +40,11 @@ select sum(v) from test;
 
 drop table test;
 > ok
+
+SELECT X, COUNT(*), SUM(COUNT(*)) OVER() FROM VALUES (1), (1), (1), (1), (2), (2), (3) T(X) GROUP BY X;
+> X COUNT(*) SUM(COUNT(*)) OVER ()
+> - -------- ---------------------
+> 1 4        7
+> 2 2        7
+> 3 1        7
+> rows: 3