Bug#31361748 ASSERTION `W->FRAME_BUFFER()->S->DB_TYPE()->DB_TYPE ==

             DB_TYPE_INNODB || CNT <= 1 || (W->LAST_ROW_OUTPUT() == 0
              && W->FRAME()->M_FROM->M_BORDER_TYPE == WBT_VALUE_FOLLOWING)
             || FOR_NTH_VALUE' FAILED.

Problem:
Only seen in debug mode with RANGE frame. While evaluating the
previous row, we had a frame containing no rows. While evaluating the
current row (mysql#3 in the minimal repro given in added test), we find
that all possible rows falls *before* the frame boundaries, so we
still have a frame containing no rows. In this case, we could move the
possible boundaries

   [first_rowno_in_range_frame, last_rowno_in_range_frame]

one row forward for the set of rows that will fit in the frame when
evaluating the next (last) row, but we didn't update them to reflect
this. In production code, this will lead to reading more rows than
strictly necessary when evaluating the frame rows for the next current
row, which is not optimal, but will work. In the debug code, we assert
when we need to read more than one row to position correctly in the
frame buffer, hence the issue.

Solution:
Update m_first_rowno_in_range_frame and m_last_rowno_in_range_frame
also in this case.

Reviewed by: Chaithra Gopalareddy <[email protected]>

Author: Dag Wanvik

mysql-test/r/window_functions.result

@@ -9430,6 +9430,51 @@ a	SUM(a) OVER (ROWS BETWEEN
 4	NULL
 DROP TABLE t;
 #
+# Bug#31361748 ASSERTION `W->FRAME_BUFFER()->S->DB_TYPE()->DB_TYPE..
+#
+# Minimal repro
+CREATE TABLE t(a INT);
+INSERT INTO t VALUES (3), (10), (100), (103);
+SELECT a, COUNT(a) OVER (ORDER BY a RANGE
+BETWEEN 4 FOLLOWING AND 6 FOLLOWING)
+FROM t;
+a	COUNT(a) OVER (ORDER BY a RANGE
+BETWEEN 4 FOLLOWING AND 6 FOLLOWING)
+3	0
+10	0
+100	0
+103	0
+DROP TABLE t;
+# Original repro
+CREATE TABLE t (a INT,b INT);
+INSERT INTO t(a) VALUES(2147483647),(0),(-2),(-1),(0);
+INSERT INTO t(a) VALUES(5430600),(0),(-91),(2147483647),(0);
+INSERT INTO t(a) VALUES(-1),(0),(-26164),(37583),(-1),(79);
+SELECT LAST_VALUE(b) RESPECT NULLS
+OVER (PARTITION BY b ORDER BY a
+RANGE BETWEEN 253 FOLLOWING AND 118 FOLLOWING)
+FROM t;
+LAST_VALUE(b) RESPECT NULLS
+OVER (PARTITION BY b ORDER BY a
+RANGE BETWEEN 253 FOLLOWING AND 118 FOLLOWING)
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+NULL
+DROP TABLE t;
+#
 # Bug#31393719: SIGFPE, ARITHMETIC EXCEPTION IN ITEM_NTILE::VAL_INT
 #
 DO NTILE(MAX(NOT 1)) OVER();

mysql-test/t/window_functions.test

@@ -4172,6 +4172,28 @@ FROM t;
 
 DROP TABLE t;
 
+--echo #
+--echo # Bug#31361748 ASSERTION `W->FRAME_BUFFER()->S->DB_TYPE()->DB_TYPE..
+--echo #
+
+--echo # Minimal repro
+CREATE TABLE t(a INT);
+INSERT INTO t VALUES (3), (10), (100), (103);
+SELECT a, COUNT(a) OVER (ORDER BY a RANGE
+                         BETWEEN 4 FOLLOWING AND 6 FOLLOWING)
+FROM t;
+DROP TABLE t;
+
+--echo # Original repro
+CREATE TABLE t (a INT,b INT);
+INSERT INTO t(a) VALUES(2147483647),(0),(-2),(-1),(0);
+INSERT INTO t(a) VALUES(5430600),(0),(-91),(2147483647),(0);
+INSERT INTO t(a) VALUES(-1),(0),(-26164),(37583),(-1),(79);
+SELECT LAST_VALUE(b) RESPECT NULLS
+          OVER (PARTITION BY b ORDER BY a
+                RANGE BETWEEN 253 FOLLOWING AND 118 FOLLOWING)
+FROM t;
+DROP TABLE t;
 
 # Local Variables:
 # mode: sql

sql/sql_executor.cc

@@ -5890,6 +5890,8 @@ bool process_buffered_windowing_record(THD *thd, Temp_table_param *param,
         row. Now evaluate over any new rows within range of the current row.
       */
       const int64 first = w.last_rowno_in_range_frame() + 1;
+      const bool empty =
+          w.last_rowno_in_range_frame() < w.first_rowno_in_range_frame();
       bool row_added = false;
 
       for (rowno = first; rowno <= upper; rowno++) {
@@ -5933,6 +5935,19 @@ bool process_buffered_windowing_record(THD *thd, Temp_table_param *param,
         row_added = true;
       }
 
+      if (w.before_frame() && empty) {
+        DBUG_ASSERT(!row_added && !found_first);
+        // This row's value is too low to fit in frame. We already had an empty
+        // set of frame rows when evaluating for the previous row, and the set
+        // is still empty.  So, we can move the possible boundaries for the
+        // set of frame rows for the next row to be evaluated one row ahead.
+        // We need only update last_rowno_in_range_frame here, first_row
+        // no_in_range_frame will be adjusted below to be one higher, cf.
+        // "maintain invariant" comment.
+        w.set_last_rowno_in_range_frame(
+            min(w.last_rowno_in_range_frame() + 1, upper));
+      }
+
       if (rowno > upper && row_added)
         w.set_last_rowno_in_range_frame(rowno - 1);