Do not add rows before OFFSET to result if possible

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

@@ -302,8 +302,9 @@ public class Select extends Query {
         return condition;
     }
 
-    private LazyResult queryGroupSorted(int columnCount, ResultTarget result) {
+    private LazyResult queryGroupSorted(int columnCount, ResultTarget result, long offset, boolean quickOffset) {
         LazyResultGroupSorted lazyResult = new LazyResultGroupSorted(expressionArray, columnCount);
+        skipOffset(lazyResult, offset, quickOffset);
         if (result == null) {
             return lazyResult;
         }
@@ -428,7 +429,7 @@ public class Select extends Query {
         return condition == null || condition.getBooleanValue(session);
     }
 
-    private void queryGroup(int columnCount, LocalResult result) {
+    private void queryGroup(int columnCount, LocalResult result, long offset, boolean quickOffset) {
         groupByData = new HashMap<>();
         currentGroupByExprData = null;
         currentGroupsKey = null;
@@ -494,6 +495,10 @@ public class Select extends Query {
                 if (isHavingNullOrFalse(row)) {
                     continue;
                 }
+                if (quickOffset && offset > 0) {
+                    offset--;
+                    continue;
+                }
                 row = keepOnlyDistinct(row, columnCount);
                 result.addRow(row);
             }
@@ -586,7 +591,8 @@ public class Select extends Query {
         return null;
     }
 
-    private void queryDistinct(ResultTarget result, long offset, long limitRows, boolean withTies) {
+    private void queryDistinct(ResultTarget result, long offset, long limitRows, boolean withTies,
+            boolean quickOffset) {
         if (limitRows > 0 && offset > 0) {
             limitRows += offset;
             if (limitRows < 0) {
@@ -600,8 +606,11 @@ public class Select extends Query {
         SearchRow first = null;
         int columnIndex = index.getColumns()[0].getColumnId();
         int sampleSize = getSampleSizeValue(session);
+        if (!quickOffset) {
+            offset = 0;
+        }
         while (true) {
-            setCurrentRowNumber(rowNumber + 1);
+            setCurrentRowNumber(++rowNumber);
             Cursor cursor = index.findNext(session, first, null);
             if (!cursor.next()) {
                 break;
@@ -612,9 +621,12 @@ public class Select extends Query {
                 first = topTableFilter.getTable().getTemplateSimpleRow(true);
             }
             first.setValue(columnIndex, value);
+            if (offset > 0) {
+                offset--;
+                continue;
+            }
             Value[] row = { value };
             result.addRow(row);
-            rowNumber++;
             if ((sort == null || sortUsingIndex) && limitRows > 0 &&
                     rowNumber >= limitRows && !withTies) {
                 break;
@@ -625,7 +637,8 @@ public class Select extends Query {
         }
     }
 
-    private LazyResult queryFlat(int columnCount, ResultTarget result, long offset, long limitRows, boolean withTies) {
+    private LazyResult queryFlat(int columnCount, ResultTarget result, long offset, long limitRows, boolean withTies,
+            boolean quickOffset) {
         if (limitRows > 0 && offset > 0) {
             limitRows += offset;
             if (limitRows < 0) {
@@ -637,6 +650,7 @@ public class Select extends Query {
         int sampleSize = getSampleSizeValue(session);
         LazyResultQueryFlat lazyResult = new LazyResultQueryFlat(expressionArray,
                 sampleSize, columnCount);
+        skipOffset(lazyResult, offset, quickOffset);
         if (result == null) {
             return lazyResult;
         }
@@ -655,13 +669,23 @@ public class Select extends Query {
         return null;
     }
 
-    private void queryQuick(int columnCount, ResultTarget result) {
+    private static void skipOffset(LazyResultSelect lazyResult, long offset, boolean quickOffset) {
+        if (quickOffset) {
+            while (offset > 0 && lazyResult.next()) {
+                offset--;
+            }
+        }
+    }
+
+    private void queryQuick(int columnCount, ResultTarget result, boolean skipResult) {
         Value[] row = new Value[columnCount];
         for (int i = 0; i < columnCount; i++) {
             Expression expr = expressions.get(i);
             row[i] = expr.getValue(session);
         }
-        result.addRow(row);
+        if (!skipResult) {
+            result.addRow(row);
+        }
     }
 
     @Override
@@ -702,16 +726,22 @@ public class Select extends Query {
                 !session.getDatabase().getSettings().optimizeInsertFromSelect)) {
             result = createLocalResult(result);
         }
+        boolean quickOffset = true;
         if (sort != null && (!sortUsingIndex || isAnyDistinct() || withTies)) {
             result = createLocalResult(result);
             result.setSortOrder(sort);
+            if (!sortUsingIndex) {
+                quickOffset = false;
+            }
         }
         if (distinct) {
             if (!isDistinctQuery) {
+                quickOffset = false;
                 result = createLocalResult(result);
                 result.setDistinct();
             }
         } else if (distinctExpressions != null) {
+            quickOffset = false;
             result = createLocalResult(result);
             result.setDistinct(distinctIndexes);
         }
@@ -746,17 +776,20 @@ public class Select extends Query {
         if (limitRows != 0) {
             try {
                 if (isQuickAggregateQuery) {
-                    queryQuick(columnCount, to);
+                    queryQuick(columnCount, to, quickOffset && offset > 0);
                 } else if (isGroupQuery) {
                     if (isGroupSortedQuery) {
-                        lazyResult = queryGroupSorted(columnCount, to);
+                        lazyResult = queryGroupSorted(columnCount, to, offset, quickOffset);
                     } else {
-                        queryGroup(columnCount, result);
+                        queryGroup(columnCount, result, offset, quickOffset);
                     }
                 } else if (isDistinctQuery) {
-                    queryDistinct(to, offset, limitRows, withTies);
+                    queryDistinct(to, offset, limitRows, withTies, quickOffset);
                 } else {
-                    lazyResult = queryFlat(columnCount, to, offset, limitRows, withTies);
+                    lazyResult = queryFlat(columnCount, to, offset, limitRows, withTies, quickOffset);
+                }
+                if (quickOffset) {
+                    offset = 0;
                 }
             } finally {
                 if (!lazy) {

h2/src/test/org/h2/test/scripts/dml/select.sql

@@ -148,3 +148,18 @@ SELECT A, B FROM TEST ORDER  BY A FETCH FIRST 1 ROW WITH TIES;
 
 DROP TABLE TEST;
 > ok
+
+CREATE TABLE TEST(A INT, B INT);
+> ok
+
+INSERT INTO TEST VALUES (1, 1), (1, 2), (2, 1), (2, 2), (2, 3);
+> update count: 5
+
+SELECT A, COUNT(B) FROM TEST GROUP BY A OFFSET 1;
+> A COUNT(B)
+> - --------
+> 2 3
+> rows: 1
+
+DROP TABLE TEST;
+> ok