From 23b053eef59e8e48c356d0d38aa75a71398d822b Mon Sep 17 00:00:00 2001 From: Henson Choi Date: Thu, 19 Nov 2026 13:30:33 +0900 Subject: [PATCH v3 4/4] Use absolute tuplestore positions in WindowAgg WindowAgg kept its own idea of where each read pointer was (seekpos) and moved the pointers by relative skips. WinSetMarkPosition() could skip the read pointer past the stored rows, leaving it at EOF. An active pointer at EOF follows later writes while seekpos does not, so window_gettupleslot() then failed with "unexpected end of tuplestore". Remove seekpos and position the pointers with tuplestore_tell() and tuplestore_seek(). WinSetMarkPosition() never seeks past the stored rows, so a WindowObject's pointer never reaches EOF. Bug: #19911 Reported-by: Robins Tharakan Discussion: https://postgr.es/m/19911-991c431cc0ba50d1@postgresql.org --- src/backend/executor/nodeWindowAgg.c | 94 +++++++++------------------- src/test/regress/expected/window.out | 12 ++++ src/test/regress/sql/window.sql | 8 +++ 3 files changed, 48 insertions(+), 66 deletions(-) diff --git a/src/backend/executor/nodeWindowAgg.c b/src/backend/executor/nodeWindowAgg.c index 8d80f2cc023..fa204cb6313 100644 --- a/src/backend/executor/nodeWindowAgg.c +++ b/src/backend/executor/nodeWindowAgg.c @@ -70,8 +70,7 @@ typedef struct WindowObjectData void *localmem; /* WinGetPartitionLocalMemory's chunk */ int markptr; /* tuplestore mark pointer for this fn */ int readptr; /* tuplestore read pointer for this fn */ - int64 markpos; /* row that markptr is positioned on */ - int64 seekpos; /* row that readptr is positioned on */ + int64 markpos; /* oldest row fn may still fetch */ uint8 **notnull_info; /* not null info for each func args */ int64 *num_notnull_info; /* track size (number of tuples in * partition) of the notnull_info array @@ -1304,16 +1303,15 @@ begin_partition(WindowAggState *winstate) { WindowObject agg_winobj = winstate->agg_winobj; - /* reset mark and see positions for aggregate functions */ + /* reset mark position for aggregate functions */ agg_winobj->markpos = -1; - agg_winobj->seekpos = -1; /* Also reset the row counters for aggregates */ winstate->aggregatedbase = 0; winstate->aggregatedupto = 0; } - /* reset mark and seek positions for each real window function */ + /* reset mark position for each real window function */ for (int i = 0; i < numfuncs; i++) { WindowStatePerFunc perfuncstate = &(winstate->perfunc[i]); @@ -1323,7 +1321,6 @@ begin_partition(WindowAggState *winstate) WindowObject winobj = perfuncstate->winobj; winobj->markpos = -1; - winobj->seekpos = -1; /* reset null map */ if (winobj->ignore_nulls == IGNORE_NULLS || @@ -3307,59 +3304,21 @@ window_gettupleslot(WindowObject winobj, int64 pos, TupleTableSlot *slot) tuplestore_select_read_pointer(winstate->buffer, winobj->readptr); /* - * Advance or rewind until we are within one tuple of the one we want. + * Position the read pointer on the wanted row by its absolute number; the + * partition's rows are numbered from 0 in the tuplestore. */ - if (winobj->seekpos < pos - 1) - { - if (!tuplestore_skiptuples(winstate->buffer, - pos - 1 - winobj->seekpos, - true)) - elog(ERROR, "unexpected end of tuplestore"); - winobj->seekpos = pos - 1; - } - else if (winobj->seekpos > pos + 1) - { - if (!tuplestore_skiptuples(winstate->buffer, - winobj->seekpos - (pos + 1), - false)) - elog(ERROR, "unexpected end of tuplestore"); - winobj->seekpos = pos + 1; - } - else if (winobj->seekpos == pos) - { - /* - * There's no API to refetch the tuple at the current position. We - * have to move one tuple forward, and then one backward. (We don't - * do it the other way because we might try to fetch the row before - * our mark, which isn't allowed.) XXX this case could stand to be - * optimized. - */ - tuplestore_advance(winstate->buffer, true); - winobj->seekpos++; - } + if (tuplestore_tell(winstate->buffer) != pos && + !tuplestore_seek(winstate->buffer, pos)) + elog(ERROR, "unexpected end of tuplestore"); + Assert(!tuplestore_ateof(winstate->buffer)); /* - * Now we should be on the tuple immediately before or after the one we - * want, so just fetch forwards or backwards as appropriate. - * * Notice that we tell tuplestore_gettupleslot to make a physical copy of * the fetched tuple. This ensures that the slot's contents remain valid * through manipulations of the tuplestore, which some callers depend on. */ - if (winobj->seekpos > pos) - { - if (!tuplestore_gettupleslot(winstate->buffer, false, true, slot)) - elog(ERROR, "unexpected end of tuplestore"); - winobj->seekpos--; - } - else - { - if (!tuplestore_gettupleslot(winstate->buffer, true, true, slot)) - elog(ERROR, "unexpected end of tuplestore"); - winobj->seekpos++; - } - - Assert(winobj->seekpos == pos); + if (!tuplestore_gettupleslot(winstate->buffer, true, true, slot)) + elog(ERROR, "unexpected end of tuplestore"); MemoryContextSwitchTo(oldcontext); @@ -3776,28 +3735,31 @@ void WinSetMarkPosition(WindowObject winobj, int64 markpos) { WindowAggState *winstate; + int64 target; Assert(WindowObjectIsValid(winobj)); winstate = winobj->winstate; if (markpos < winobj->markpos) elog(ERROR, "cannot move WindowObject's mark position backward"); + winobj->markpos = markpos; + + /* + * Leave each pointer just after the mark row, so that tuplestore_trim + * keeps it. Don't go past the rows stored so far; a pointer left behind + * only keeps a few more rows. + */ + target = Min(markpos + 1, tuplestore_tuple_count(winstate->buffer)); tuplestore_select_read_pointer(winstate->buffer, winobj->markptr); - if (markpos > winobj->markpos) - { - tuplestore_skiptuples(winstate->buffer, - markpos - winobj->markpos, - true); - winobj->markpos = markpos; - } + Assert(tuplestore_tell(winstate->buffer) <= target); + if (!tuplestore_seek(winstate->buffer, target)) + elog(ERROR, "unexpected end of tuplestore"); + Assert(!tuplestore_ateof(winstate->buffer)); tuplestore_select_read_pointer(winstate->buffer, winobj->readptr); - if (markpos > winobj->seekpos) - { - tuplestore_skiptuples(winstate->buffer, - markpos - winobj->seekpos, - true); - winobj->seekpos = markpos; - } + if (tuplestore_tell(winstate->buffer) < target && + !tuplestore_seek(winstate->buffer, target)) + elog(ERROR, "unexpected end of tuplestore"); + Assert(!tuplestore_ateof(winstate->buffer)); } /* diff --git a/src/test/regress/expected/window.out b/src/test/regress/expected/window.out index 112551c350b..061caa685d7 100644 --- a/src/test/regress/expected/window.out +++ b/src/test/regress/expected/window.out @@ -1452,6 +1452,18 @@ FROM tenk1 WHERE unique1 < 10; | 7 | 3 (10 rows) +-- frame head on the next row, not yet stored, when the tuplestore spills +SET work_mem = '64kB'; +SELECT count(*), sum(s) FROM + (SELECT sum(i) OVER (ORDER BY i ROWS BETWEEN 2000 FOLLOWING + AND UNBOUNDED FOLLOWING) s + FROM generate_series(1, 2002) i) t; + count | sum +-------+------ + 2002 | 6005 +(1 row) + +RESET work_mem; -- RANGE offset PRECEDING/FOLLOWING tests SELECT sum(unique1) over (order by four range between 2::int8 preceding and 1::int2 preceding), unique1, four diff --git a/src/test/regress/sql/window.sql b/src/test/regress/sql/window.sql index e848557174b..c4ff185d815 100644 --- a/src/test/regress/sql/window.sql +++ b/src/test/regress/sql/window.sql @@ -356,6 +356,14 @@ SELECT sum(unique1) over (ORDER BY four groups between 9223372036854775807 follo unique1, four FROM tenk1 WHERE unique1 < 10; +-- frame head on the next row, not yet stored, when the tuplestore spills +SET work_mem = '64kB'; +SELECT count(*), sum(s) FROM + (SELECT sum(i) OVER (ORDER BY i ROWS BETWEEN 2000 FOLLOWING + AND UNBOUNDED FOLLOWING) s + FROM generate_series(1, 2002) i) t; +RESET work_mem; + -- RANGE offset PRECEDING/FOLLOWING tests SELECT sum(unique1) over (order by four range between 2::int8 preceding and 1::int2 preceding), -- 2.54.0 (Apple Git-157)