The unreviewed increment — 18 patches across six axes

A third strand — cross-review and verification

One axis carries no band number. Each track reviews the other's patches, and separately Henson runs QA over the range: auditing the whole span before it is posted, producing the defect list, and re-judging that list against the code.

The tables in this note are that output. The 07-11 triage, 53 items, is the pre-commit defect list, and the evidence column in the burn-down is what was checked in the current tree rather than what the document claimed. The 07-24 audit swept the preceding eight commits (+1591/−730) and reported eight items, one of which was a wrong-results regression the suite did not catch — mergeConsecutiveVars merging a greedy quantifier with a following reluctant one and changing the preferred match, staying green because the committed tests only covered reluctant-first (A+? A). Jian's fix arrived the next day and is folded into 4004.

Verification is the same strand. The row-by-row comparison against Oracle 23ai and Trino 471, plus the Perl regex cross-check, is what backs the standard reading in 3002·3003·3004; and the rebase carried a clean build, the regression suites and pgindent at every patch. Finding the defects and confirming the fixes actually hold runs across both tracks rather than inside either.

The twelve open ones do not weigh the same

No correctness defect remains. The 07-26 audit found no path across the eight commits by which a query result differs from BASE, and the one wrong-results item, 07-24 #1, is closed in the patch that introduced it. What remains splits three ways.

#1 is the one that weighs differently. BASE's two negative-offset clamps were removed with nothing put in their place, so the subtractions in resolve_one_nav reach C undefined behaviour, and a plain EXPLAIN is enough to get there. A build with -ftrapv or UBSan aborts. 07-24 #4 only flagged the comment at :4270; the invariant that comment rests on was exactly the deleted clamp, so 07-24 #4 is the symptom and #1 the cause. Restoring the clamp on the non-validating path makes the comment true again. It belongs in 4001, which alone reaches the overflow, and since the posted branch is fixed it goes in with the next revision.

#3, #4 and #5 are record-keeping rather than code. All three changes are in the right direction, and none of them appears in a commit message or is pinned by a test. Under claim-based review a change with no claim gets no review, and 4002 is the illustration: the only message in the band with no design rationale, and all seven queries it adds are blind to the change it makes.

07-24 #7 is the different one. The others are known defects still standing; 07-24 #7 says the regression protection is empty. If the runtime outer-check ordering regresses again, every committed test still passes. Since 4001 rewrote that area wholesale, now is the moment to add the differentiating test.

07-24 #5 was set aside as not urgent, but the failure is timing-dependent: when the two definitions are live at once the second CREATE fails with function "rpr_srf_f" already exists, and when they are not it passes quietly. Renaming one of them settles it.

The 11 open items fall into two groups

Six in optimizer / window integration are the larger group. W2 and W3 both come from defineClause sitting outside the grouping pipeline; W7 is make_windowagg aliasing the clause without copying, so set_upper_references can overwrite shared list cells. W4 is a partial fix — two of three paths are closed, and the third is the constant-false pruning path still under discussion.

Three in deparse, of which D1 matters most: in a multi-RTE view a DEFINE Var is deparsed alias-qualified, so pg_get_viewdef output does not reparse and pg_dump / restore breaks. D2 depends on which shape CF 7056 takes upstream.

W2  GROUPING SETS/ROLLUP/CUBE + RPR    D1  multi-RTE view deparse unreparseable
W3  GROUP BY x+y + DEFINE x+y          D2  window name unquoted (CF 7056)
W5  run-condition block (needs Z4)     D3  deparse trailing space (cosmetic)
W6  remove_unused_subquery_outputs     G1  PERMUTE(A) accepted
W7  defineClause aliased without copy  R1  DEFINE names absent from queryId
W8  pull_var_clause O(cols x DEFINE)

partial   W4 volatile DEFINE bypass 2/3   R2 RPRPattern serialization 3/4
          PF1 quadratic re-read once spilled  (out of scope)
decision  Z3 phnullingrels variant (gates W2)   Z4 run-condition lift (gates W5)

PF1 is a read-pointer question, not an absorption one

That FIRST blocks context absorption is the correct rule, not a defect. Absorption presupposes that future behaviour is independent of where the match started, and FIRST looks back to match_start by definition, so the premise fails. A context with navFirstOffset set belongs out of the absorption candidates.

PF1 concerns the layer below that. Whether or not absorption happens, one tuplestore read pointer is shared by two positions that alternate:

ExecRPRNavGetSlot()  winobj = winstate->nav_winobj  <- near matchStart
rpr_prepare_row()    the same winobj                <- the frontier (pos)

window_gettupleslot repositions by relative tuplestore_skiptuples
  -> once spilled, two traversals of (pos - matchStart) tuples per row
  -> Theta(length^2) physical re-reads per match

The measurements separate the two explanations. PREV also blocks absorption, yet costs 1.7 ms spilled where FIRST costs 5358 ms (n=4000). If blocked absorption were the cause the two would be comparable. The only difference is whether the read pointer travels, and EXPLAIN (ANALYZE, BUFFERS) shows temp read=2,154,477 (n=2000) for those physical re-reads. Results are correct throughout (md5 identical).

A fix would not touch absorption either: splitting the read pointer into a frontier pointer (advancing one row at a time) and a nav pointer (parked near matchStart) makes each amortized O(1). The markptr floor (matchStartRow + navFirstOffset) is unchanged, so neither the retained window nor the absorption decision moves. It is out of scope here because correctness is unaffected; it is recorded for after the commit.

D2 is tied to CF 7056

CF 7056 — Fix quotation logic for unreserved keywords in window specifications. When a window name is an unreserved keyword, get_rule_windowspec() does not quote it, so pg_get_viewdef output fails to reparse and pg_dump / restore breaks. It reproduces on stock releases, predates RPR by many years, and is fixed in the same place RPR would fix D2.

RPR's D2 (pattern / after / initial / seek deparsed unquoted) is that same defect extended to the RPR keywords. Depending on the form upstream takes, D2 either closes automatically or needs a small addition on top:

07-10  Kwangwon Seo posts v1 (quotes the refname)
07-24  public review reply -- prefers the explicit-list variant
        -> a view from Tatsuo on the direction would unblock this
        -> and Kwangwon's answer on covering the RPR keywords

D1 is adjacent: same function family, but a Var-qualification problem.
D3 is a trailing space in the same function -- can ride along either way.

This is why the three deparse items are hard to start independently: D2 depends on the upstream outcome, and D1 and D3 touch the same function, so the order has to be agreed to avoid conflicts.

L10 is the evidence behind the RPR_DEPTH_MAX discussion

The suggestion on 07-23 was to lower RPR_DEPTH_MAX from 254 to 10. The reply argued that depth is the wrong variable: depth enters nfaStateSize only linearly, whereas the resource that actually grows is the number of live NFA states, driven by alternation, quantifier ranges and their combinations. A limit of 10 forbids a harmless depth of 253 while still admitting a {3,7}? combination at depth 5.

L10 is the concrete case behind that argument. With an unbounded {m,} the counter never saturates at min, so states that are semantically identical keep splitting on the counter value alone and the frontier grows without bound. The answers stay correct — this is resource bounding, not correctness, which is why it sits outside this series. It is also the first consumer of the work_mem-style bound on peak NFA states that the reply proposed.

L07 and L08 are the ground for the next round

L07 (RPRContext consolidation) is the structural groundwork for accepting MATCH_RECOGNIZE syntax; it was deferred by agreement with Tatsuo on 2026-02-17 and is last because it is the largest. L08 (CLASSIFIER / row pattern variable storage) was posted as a design note on 07-04, leaving accumulator lifetime and winning-match replay as open engine-side questions; comment on those two would be welcome. Both are post-commit work, but naming them here explains some of the present design choices — for instance why the nav offsets are explicit arguments rather than reached through WindowClause.

07-26 #7 — CATALOG_VERSION_NO (false positive)

Not a defect. An in-development patch series does not bump this constant: doing so conflicts with every other patch in flight, so the committer handles it once at commit time. The audit called this one wrong.

grep -o '#define CATALOG_VERSION_NO.*' src/include/catalog/catversion.h

-- BASE
#define CATALOG_VERSION_NO	202607091

-- HEAD
#define CATALOG_VERSION_NO	202607091      -- unchanged

N1 · closed at/below 3XXX · identical

CREATE TEMP TABLE z_n1_t (id int, v text);
INSERT INTO z_n1_t VALUES (1,'A'),(2,'A'),(3,'A');

-- repro 1 (ALT branch head): expect 3,0,0 -- buggy engine returns 0,0,0
SELECT id, count(*) OVER w AS cnt FROM z_n1_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  AFTER MATCH SKIP PAST LAST ROW INITIAL
  PATTERN ((A+ | B){2}) DEFINE A AS v = 'A', B AS v = 'B');

-- repro 2 (optional VAR skipState, no ALT): expect 2,0 -- buggy: 0,0
SELECT id, count(*) OVER w AS cnt FROM z_n1_t WHERE id <= 2
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  AFTER MATCH SKIP PAST LAST ROW INITIAL
  PATTERN ((B? A+){2}) DEFINE A AS v = 'A', B AS v = 'B');

-- repro 3 (branch order independent): expect 3,0,0 -- buggy: 0,0,0
SELECT id, count(*) OVER w AS cnt FROM z_n1_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  AFTER MATCH SKIP PAST LAST ROW INITIAL
  PATTERN ((B | A+){2}) DEFINE A AS v = 'A', B AS v = 'B');

-- repro 4 (hand-unrolled; optimizer re-rolls to {2}): expect 3,0,0 -- buggy: 0,0,0
SELECT id, count(*) OVER w AS cnt FROM z_n1_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  AFTER MATCH SKIP PAST LAST ROW INITIAL
  PATTERN ((A+ | B) (A+ | B)) DEFINE A AS v = 'A', B AS v = 'B');

DROP TABLE z_n1_t;

-- BASE and HEAD identical; tail of the shared output
  1 |   3
  2 |   0
  3 |   0
(3 rows)
 id | cnt
----+-----
  1 |   3
  2 |   0
  3 |   0
(3 rows)

N2 · closed at/below 3XXX · identical

CREATE TEMP TABLE z_n2_t (id int, flags text[]);
INSERT INTO z_n2_t VALUES (1, ARRAY['B']), (2, ARRAY['B']);
-- Site 1 (nfa_route_to_elem optional VAR skip -> END): expected row1 cnt=2, buggy all 0
SELECT id, count(*) OVER w AS cnt
FROM z_n2_t
WINDOW w AS (
  ORDER BY id
  ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  AFTER MATCH SKIP PAST LAST ROW
  PATTERN ((B A?){2})
  DEFINE A AS 'A' = ANY(flags), B AS 'B' = ANY(flags)
);
-- Site 2 (nfa_advance_begin min=0 group skip -> END): expected row1 cnt=2, buggy all 0
SELECT id, count(*) OVER w AS cnt
FROM z_n2_t
WINDOW w AS (
  ORDER BY id
  ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  AFTER MATCH SKIP PAST LAST ROW
  PATTERN ((B (A C)?){2})
  DEFINE A AS 'A' = ANY(flags), B AS 'B' = ANY(flags), C AS 'C' = ANY(flags)
);
-- Title form: (UP DOWN?)+ with DOWN absent: expected row2 cnt=2, buggy all 0
CREATE TEMP TABLE z_n2_stock (id int, price int);
INSERT INTO z_n2_stock VALUES (1,100),(2,110),(3,120);
SELECT id, price, count(*) OVER w AS cnt
FROM z_n2_stock
WINDOW w AS (
  ORDER BY id
  ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  AFTER MATCH SKIP PAST LAST ROW
  INITIAL
  PATTERN ((UP DOWN?)+)
  DEFINE UP AS price > PREV(price), DOWN AS price < PREV(price)
);

-- BASE and HEAD identical; tail of the shared output
----+-----
  1 |   2
  2 |   0
(2 rows)
 id | price | cnt
----+-------+-----
  1 |   100 |   0
  2 |   110 |   2
  3 |   120 |   0
(3 rows)

N3 · closed at/below 3XXX · identical

CREATE TEMP TABLE z_N3_t(id int, val int);
INSERT INTO z_N3_t VALUES (1,-1);
-- Expected cnt=0 (A*'s empty match takes precedence over B's 1-row match), actual 1
SELECT id, count(*) OVER w AS cnt FROM z_N3_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             PATTERN (A* | B) DEFINE A AS val > 0, B AS val <= 0) ORDER BY id;
-- Control: expected cnt=1 (B is the first branch), actual 1 (correct) -> proves branch order is ignored
SELECT id, count(*) OVER w AS cnt FROM z_N3_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             PATTERN (B | A*) DEFINE A AS val > 0, B AS val <= 0) ORDER BY id;
-- SKIP contamination: expected 0,0,0 / actual 2,0,0 (the spurious 2-row match contaminates the skip position)
CREATE TEMP TABLE z_N3_k(id int, val int);
INSERT INTO z_N3_k VALUES (1,-1),(2,-1),(3,-1);
SELECT id, count(*) OVER w AS cnt FROM z_N3_k
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP PAST LAST ROW
             PATTERN (A* | B B) DEFINE A AS val > 0, B AS val <= 0) ORDER BY id;

-- BASE and HEAD identical; tail of the shared output
 id | cnt
----+-----
  1 |   1
(1 row)
 id | cnt
----+-----
  1 |   0
  2 |   0
  3 |   0
(3 rows)

N4 · closed at/below 3XXX · identical

CREATE TEMP TABLE z_N4_t (id int, v text);
INSERT INTO z_N4_t VALUES (1,'A'),(2,'A');
-- Direction 1: engine 1,1 / standard 2,0 (Perl /\A(?:A?){2}?/ on "AA" -> "AA")
SELECT id, count(*) OVER w AS cnt FROM z_N4_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP PAST LAST ROW INITIAL
             PATTERN ((A?){2}?) DEFINE A AS v = 'A') ORDER BY id;
-- Control (correct): ((A?){2}) -> 2,0
SELECT id, count(*) OVER w AS cnt FROM z_N4_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP PAST LAST ROW INITIAL
             PATTERN ((A?){2}) DEFINE A AS v = 'A') ORDER BY id;
-- Direction 2: engine 2,0 / standard 0,0 (Perl /\A(?:A??){2}/ on "AA" -> "")
SELECT id, count(*) OVER w AS cnt FROM z_N4_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP PAST LAST ROW INITIAL
             PATTERN ((A??){2}) DEFINE A AS v = 'A') ORDER BY id;
-- Range extension (T10 family): engine 1,1,1 / standard 2,2,1
CREATE TEMP TABLE z_N4_c (id int, flags text[]);
INSERT INTO z_N4_c VALUES (1,ARRAY['C']),(2,ARRAY['C']),(3,ARRAY['C']);
SELECT id, count(*) OVER w AS cnt FROM z_N4_c
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP TO NEXT ROW
             PATTERN ((C | C*){2,3}?) DEFINE C AS 'C' = ANY(flags)) ORDER BY id;

-- BASE and HEAD identical; tail of the shared output
----+-----
  1 |   0
  2 |   0
(2 rows)
 id | cnt
----+-----
  1 |   2
  2 |   2
  3 |   1
(3 rows)

N5 · closed at/below 3XXX · identical

CREATE TEMP TABLE z_N5_d4(id int, flags text[]);
INSERT INTO z_N5_d4 VALUES (1,ARRAY['A']),(2,ARRAY['B']);
SELECT id, count(*) OVER w AS cnt
FROM z_N5_d4
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP TO NEXT ROW
             PATTERN ((A? | B)*)
             DEFINE A AS 'A'=ANY(flags), B AS 'B'=ANY(flags))
ORDER BY id;
-- Expected cnt=1,0 / current (buggy) cnt=2,1

-- BASE and HEAD identical; tail of the shared output
 id | cnt
----+-----
  1 |   1
  2 |   0
(2 rows)

N6 · closed at/below 3XXX · identical

-- N6: empty-match stats misclassified for non-target contexts (instrumentation only)
-- Expected after fix: NFA: 4 matched (len 0/0/0.0), 0 mismatched / 0 pruned
-- Actual today:       NFA: 1 matched (len 0/0/0.0), 2 mismatched (len 2/3/2.5) / 1 pruned
EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, TIMING OFF, SUMMARY OFF)
SELECT count(*) OVER w FROM generate_series(1,4) AS s(v)
WINDOW w AS (ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP TO NEXT ROW
             PATTERN (A+ C | B*)
             DEFINE A AS v > 0, C AS v < 0, B AS v < 0);
-- Control (baseline, already correct): 4 matched (len 0/0/0.0), 0 mismatched / 0 pruned
EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, TIMING OFF, SUMMARY OFF)
SELECT count(*) OVER w FROM generate_series(1,4) AS s(v)
WINDOW w AS (ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP TO NEXT ROW
             PATTERN (B*)
             DEFINE B AS v < 0);
-- Mid-partition variant (proves independence from partition-end finalization)
-- Expected after fix: 4 matched (len 0/0/0.0) / 0 pruned; today: 2 matched / 1 mismatched / 1 pruned
EXPLAIN (ANALYZE, BUFFERS OFF, COSTS OFF, TIMING OFF, SUMMARY OFF)
SELECT count(*) OVER w FROM (VALUES (1),(1),(0),(0)) AS t(v)
WINDOW w AS (ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP TO NEXT ROW
             PATTERN (A+ B | C*)
             DEFINE A AS v > 0, B AS v > 1, C AS v > 9);
-- User-visible sanity: all rows count=0 regardless of fix
SELECT count(*) OVER w FROM generate_series(1,4) AS s(v)
WINDOW w AS (ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP TO NEXT ROW
             PATTERN (A+ C | B*)
             DEFINE A AS v > 0, C AS v < 0, B AS v < 0);

-- BASE and HEAD identical; tail of the shared output
   NFA: 4 matched (len 0/0/0.0), 0 mismatched
   ->  Values Scan on "*VALUES*" (actual rows=4.00 loops=1)
(9 rows)
 count
-------
     0
     0
     0
     0
(4 rows)

MR07 · closed at/below 3XXX · identical

CREATE TEMP TABLE z_MR07_t (id int, v int);
INSERT INTO z_MR07_t VALUES (1, 1), (2, 2), (3, 3);
-- A is false at every row: per ISO 19075-5 no row is ever tentatively
-- mapped to B, so B's condition must never be evaluated.  Expected: 3
-- unmatched rows (cnt=0).  Actual: ERROR division by zero.
SELECT id, v, count(*) OVER w AS cnt
FROM z_MR07_t
WINDOW w AS (
  ORDER BY id
  ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN (A B)
  DEFINE A AS v < 0, B AS 1 / (v - v) > 0
);
-- Single-row partition: B needs a second row, can never be tested.
CREATE TEMP TABLE z_MR07_t2 (id int, v int);
INSERT INTO z_MR07_t2 VALUES (1, 10);
SELECT id, v, count(*) OVER w AS cnt
FROM z_MR07_t2
WINDOW w AS (
  ORDER BY id
  ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN (A B)
  DEFINE A AS v = 10, B AS 10 / (v - 10) > 0
);
-- Control: CASE guard returns the correct result (cnt=0), proving the
-- error comes from eager evaluation of the never-tested variable.
SELECT id, v, count(*) OVER w AS cnt
FROM z_MR07_t2
WINDOW w AS (
  ORDER BY id
  ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN (A B)
  DEFINE A AS v = 10, B AS CASE WHEN v <> 10 THEN 10 / (v - 10) > 0 ELSE false END
);

-- BASE and HEAD identical; tail of the shared output
  3 | 3 |   0
(3 rows)
 id | v  | cnt
----+----+-----
  1 | 10 |   0
(1 row)
 id | v  | cnt
----+----+-----
  1 | 10 |   0
(1 row)

A1 · closed by 1026 · identical

CREATE TEMP TABLE z_A1_t (id int, v text);
INSERT INTO z_A1_t SELECT g, 'a' FROM generate_series(1, 10) g;
-- buggy: rows 2..9 unmatched (NULL); fixed: every row i matches [i,i]
SELECT id,
       first_value(id) OVER w AS match_start,
       last_value(id)  OVER w AS match_end
FROM z_A1_t
WINDOW w AS (
    ORDER BY id
    ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
    AFTER MATCH SKIP PAST LAST ROW
    PATTERN (A+ B | C)
    DEFINE A AS v = 'a', B AS v = 'b', C AS v = 'a'
)
ORDER BY id;

-- BASE and HEAD identical; tail of the shared output
  2 |           2 |         2
  3 |           3 |         3
  4 |           4 |         4
  5 |           5 |         5
  6 |           6 |         6
  7 |           7 |         7
  8 |           8 |         8
  9 |           9 |         9
 10 |          10 |        10
(10 rows)

A2 · not a defect · identical

-- A2: SKIP TO NEXT ROW + long match => quadratic runtime (values correct; timing-only repro)
CREATE TEMP TABLE z_A2_t AS SELECT g AS id FROM generate_series(1, 5000) g;
SELECT count(*) FROM (
  SELECT count(*) OVER w AS c
  FROM z_A2_t
  WINDOW w AS (
    ORDER BY id
    ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
    AFTER MATCH SKIP TO NEXT ROW
    INITIAL
    PATTERN (A B*)
    DEFINE A AS TRUE, B AS TRUE
  )) s;
TRUNCATE z_A2_t;
INSERT INTO z_A2_t SELECT g FROM generate_series(1, 10000) g;
SELECT count(*) FROM (
  SELECT count(*) OVER w AS c
  FROM z_A2_t
  WINDOW w AS (
    ORDER BY id
    ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
    AFTER MATCH SKIP TO NEXT ROW
    INITIAL
    PATTERN (A B*)
    DEFINE A AS TRUE, B AS TRUE
  )) s;
-- Expected: second run ~4x the elapsed time of the first (2x rows).
-- Prior measurements: 1.88s @5k -> 7.54s @10k; contrast SKIP PAST LAST ROW, which is near-linear.

-- BASE and HEAD identical; tail of the shared output
 count
-------
  5000
(1 row)
 count
-------
 10000
(1 row)

P1 · closed at/below 3XXX · identical

CREATE TEMP TABLE z_p1_t (id int, a bool, b bool);
INSERT INTO z_p1_t VALUES (1,true,false),(2,true,false),(3,true,false),(4,true,false);
-- merged by mergeConsecutiveAlts into (a+ | b){2}: returns 0/0/0/0 (all matches lost)
SELECT id, count(*) OVER w AS len FROM z_p1_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN ((A+ | B) (A+ | B)) DEFINE A AS a, B AS b) ORDER BY id;
-- renamed baseline, cannot merge: returns 4/0/0/0
SELECT id, count(*) OVER w AS len FROM z_p1_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN ((A+ | B) (C+ | D)) DEFINE A AS a, B AS b, C AS a, D AS b) ORDER BY id;
-- executor root proof: user-written rolled form also returns 0/0/0/0
SELECT id, count(*) OVER w AS len FROM z_p1_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN ((A+ | B){2}) DEFINE A AS a, B AS b) ORDER BY id;
-- minimal 2-row preferment case: merged 2/0 vs baseline 1/1
CREATE TEMP TABLE z_p1_u (id int, a bool, b bool);
INSERT INTO z_p1_u VALUES (1,false,true),(2,false,true);
SELECT id, count(*) OVER w AS len FROM z_p1_u
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN ((A? | B) (A? | B)) DEFINE A AS a, B AS b) ORDER BY id;
SELECT id, count(*) OVER w AS len FROM z_p1_u
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN ((A? | B) (C? | D)) DEFINE A AS a, B AS b, C AS a, D AS b) ORDER BY id;

-- BASE and HEAD identical; tail of the shared output
 id | len
----+-----
  1 |   0
  2 |   0
(2 rows)
 id | len
----+-----
  1 |   0
  2 |   0
(2 rows)

P2 · closed at/below 3XXX · identical

-- P2: consecutive GROUP merge preferment violation (rpr.c mergeConsecutiveGroups)
-- Mechanism A: reluctant inside body. Rows: B A B A A B A
CREATE TEMP TABLE z_P2_ba(id int, a bool, b bool);
INSERT INTO z_P2_ba VALUES
 (1,false,true),(2,true,false),(3,false,true),(4,true,false),
 (5,true,false),(6,false,true),(7,true,false);
-- merged to (b a+?){2,}: returns 4. Standard preferment: 7 = (B A)(B A A)(B A)
SELECT id, count(*) OVER w AS cnt
FROM z_P2_ba
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP PAST LAST ROW
             PATTERN ((B A+?)+ (B A+?)+)
             DEFINE A AS a, B AS b)
ORDER BY id;
-- control: alias-differentiated twin (merge cannot apply) -> 7
SELECT id, count(*) OVER w AS cnt
FROM z_P2_ba
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP PAST LAST ROW
             PATTERN ((B A+?)+ (D C+?)+)
             DEFINE A AS a, B AS b, C AS a, D AS b)
ORDER BY id;
-- Mechanism B: unequal-length alternatives in body. Rows: a ab b a
CREATE TEMP TABLE z_P2_ab(id int, val text);
INSERT INTO z_P2_ab VALUES (1,'a'),(2,'ab'),(3,'b'),(4,'a');
-- merged to (a | b{2}){2,}: returns 2. Standard preferment: 4 = A,BB,A
SELECT id, count(*) OVER w AS cnt
FROM z_P2_ab
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP PAST LAST ROW
             PATTERN ((A | B B)+ (A | B B)+)
             DEFINE A AS strpos(val,'a') > 0, B AS strpos(val,'b') > 0)
ORDER BY id;
-- control: alias-differentiated twin -> 4
SELECT id, count(*) OVER w AS cnt
FROM z_P2_ab
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP PAST LAST ROW
             PATTERN ((A | B B)+ (C | D D)+)
             DEFINE A AS strpos(val,'a') > 0, B AS strpos(val,'b') > 0,
                    C AS strpos(val,'a') > 0, D AS strpos(val,'b') > 0)
ORDER BY id;

-- BASE and HEAD identical; tail of the shared output
  3 |   0
  4 |   0
(4 rows)
 id | cnt
----+-----
  1 |   4
  2 |   0
  3 |   0
  4 |   0
(4 rows)

P3 · closed at/below 3XXX · identical

CREATE TEMP TABLE z_P3_t (rn int, kind text);
INSERT INTO z_P3_t VALUES (1,'a'),(2,'ab'),(3,'b'),(4,'a');
-- merged form: returns cnt=2 at rn=1 (WRONG)
SELECT rn, kind, count(*) OVER w AS cnt FROM z_P3_t
WINDOW w AS (ORDER BY rn ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN ((A | B B){1,2} (A | B B))
  DEFINE A AS kind LIKE '%a%', B AS kind LIKE '%b%');
-- control, same predicates renamed so no merge: cnt=4 at rn=1 (correct)
SELECT rn, kind, count(*) OVER w AS cnt FROM z_P3_t
WINDOW w AS (ORDER BY rn ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN ((A | B B){1,2} (C | D D))
  DEFINE A AS kind LIKE '%a%', B AS kind LIKE '%b%',
         C AS kind LIKE '%a%', D AS kind LIKE '%b%');
-- evidence of the fold
EXPLAIN (COSTS OFF)
SELECT count(*) OVER w FROM z_P3_t
WINDOW w AS (ORDER BY rn ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN ((A | B B){1,2} (A | B B))
  DEFINE A AS kind LIKE '%a%', B AS kind LIKE '%b%');
-- no-ALT variant: min<max quantifier alone diverges (5 vs 6)
CREATE TEMP TABLE z_P3_t2 (rn int, kind text);
INSERT INTO z_P3_t2 VALUES (1,'a'),(2,'b'),(3,'a'),(4,'b'),(5,'ab'),(6,'b');
SELECT rn, count(*) OVER w AS cnt FROM z_P3_t2
WINDOW w AS (ORDER BY rn ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN ((A B{1,2}){1,2} (A B{1,2}))
  DEFINE A AS kind LIKE '%a%', B AS kind LIKE '%b%');

-- BASE and HEAD identical; tail of the shared output
(7 rows)
 rn | cnt
----+-----
  1 |   6
  2 |   0
  3 |   0
  4 |   0
  5 |   0
  6 |   0
(6 rows)

P4 · closed at/below 3XXX · identical

CREATE TEMP TABLE z_P4_t (id int, v int);
INSERT INTO z_P4_t VALUES (1,1),(2,1),(3,1),(4,1),(5,0);
-- folded to a{2,6} (see EXPLAIN Pattern: line); match_end at id=1 is 4,
-- standard/Perl preferred match is rows 1-3 (match_end 3)
EXPLAIN (COSTS OFF)
SELECT count(*) OVER w FROM z_P4_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP TO NEXT ROW
             PATTERN ((A{2,3}){1,2}) DEFINE A AS v = 1);
SELECT id, v, first_value(id) OVER w AS match_start,
       last_value(id) OVER w AS match_end
FROM z_P4_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP TO NEXT ROW
             PATTERN ((A{2,3}){1,2}) DEFINE A AS v = 1);
-- fold-blocked semantically identical baseline (SEQ child): match_end at id=1 is 3
SELECT id, v, first_value(id) OVER w AS match_start,
       last_value(id) OVER w AS match_end
FROM z_P4_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP TO NEXT ROW
             PATTERN ((A{2} B?){1,2}) DEFINE A AS v = 1, B AS v = 1);

-- BASE and HEAD identical; tail of the shared output
  5 | 0 |             |
(5 rows)
 id | v | match_start | match_end
----+---+-------------+-----------
  1 | 1 |           1 |         3
  2 | 1 |           2 |         4
  3 | 1 |           3 |         4
  4 | 1 |             |
  5 | 0 |             |
(5 rows)

E3 · closed by 4XXX · no reproduction SQL

three NEXT_FIRST comments contradict the code -- not observable by execution

W2 · open · identical

CREATE TEMP TABLE z_W2_t (category text, val int);
INSERT INTO z_W2_t VALUES ('A',10),('A',20),('B',5);
-- control: plain GROUP BY + RPR -> works (A|2, B|0)
SELECT category, count(*) OVER w AS cnt
FROM z_W2_t
GROUP BY category
WINDOW w AS (ORDER BY category ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             PATTERN (A+) DEFINE A AS category >= 'A');
-- defect variant 1: ROLLUP (also CUBE / 2+ GROUPING SETS)
-- ERROR: wrong varnullingrels (b) (expected (b 2)) for Var 1/1
SELECT category, count(*) OVER w AS cnt
FROM z_W2_t
GROUP BY ROLLUP(category)
WINDOW w AS (ORDER BY category ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             PATTERN (A+) DEFINE A AS category >= 'A');
-- defect variant 2: VALUES source
-- ERROR: wrong phnullingrels (b) (expected (b 2)) for PlaceHolderVar 1
SELECT category, count(*) OVER w AS cnt
FROM (VALUES ('A',10),('A',20),('B',5)) v(category, val)
GROUP BY ROLLUP(category)
WINDOW w AS (ORDER BY category ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             PATTERN (A+) DEFINE A AS category >= 'A');
-- boundary: single grouping set collapses to plain GROUP BY -> works
SELECT category, count(*) OVER w AS cnt
FROM z_W2_t
GROUP BY GROUPING SETS ((category))
WINDOW w AS (ORDER BY category ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             PATTERN (A+) DEFINE A AS category >= 'A');

-- BASE and HEAD identical; tail of the shared output
 A        |   2
 B        |   0
(2 rows)
ERROR:  wrong varnullingrels (b) (expected (b 2)) for Var 1/1
ERROR:  wrong phnullingrels (b) (expected (b 2)) for PlaceHolderVar 1
 category | cnt
----------+-----
 A        |   2
 B        |   0
(2 rows)

W3 · open · identical

CREATE TEMP TABLE z_W3_gb (id int, val int);
INSERT INTO z_W3_gb VALUES (1,10),(2,25);
-- baseline (succeeds): non-RPR window over the same group expression
SELECT val/10 AS bucket, count(*) OVER (ORDER BY val/10) AS cnt
  FROM z_W3_gb GROUP BY val/10;
-- false rejection: DEFINE uses exactly the GROUP BY expression
SELECT val/10 AS bucket, count(*) OVER w AS cnt
  FROM z_W3_gb
 GROUP BY val/10
 WINDOW w AS (ORDER BY val/10
              ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
              PATTERN (A+)
              DEFINE A AS val/10 >= 0);

-- BASE and HEAD identical; tail of the shared output
 bucket | cnt
--------+-----
      1 |   1
      2 |   2
(2 rows)
ERROR:  column "z_w3_gb.val" must appear in the GROUP BY clause or be used in an aggregate function
LINE 7:               DEFINE A AS val/10 >= 0);
                                  ^

W5 · open · identical

-- W5 / opt-window F6
CREATE TEMP TABLE z_W5_stock (ts int, price int);
INSERT INTO z_W5_stock SELECT g, 100 + (g % 7) FROM generate_series(1, 1000) g;

-- 1) RPR window: Run Condition absent, filter degraded to Subquery Scan Filter
EXPLAIN (COSTS OFF)
SELECT * FROM (
  SELECT ts, row_number() OVER w AS rn FROM z_W5_stock
  WINDOW w AS (ORDER BY ts ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
               AFTER MATCH SKIP TO NEXT ROW INITIAL
               PATTERN (A+) DEFINE A AS price > PREV(price))
) s WHERE rn <= 10;

-- 2) Same shape without PATTERN/DEFINE: Run Condition appears
EXPLAIN (COSTS OFF)
SELECT * FROM (
  SELECT ts, row_number() OVER w AS rn FROM z_W5_stock
  WINDOW w AS (ORDER BY ts ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
) s WHERE rn <= 10;

-- 3) Full-unblock is UNSAFE: count(*) over an RPR window is non-monotonic
--    (sequence 2,0,0,2,0), so a DECREASING run condition "cnt > 0" would
--    stop at id=2 and silently drop the id=4 match.
CREATE TEMP TABLE z_W5_mono (id int, v int);
INSERT INTO z_W5_mono VALUES (1,1),(2,2),(3,1),(4,0),(5,5);
SELECT id, v, count(*) OVER w AS cnt
FROM z_W5_mono
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             AFTER MATCH SKIP PAST LAST ROW
             PATTERN (A B+) DEFINE B AS v > PREV(v));

-- BASE and HEAD identical; tail of the shared output
         ->  Seq Scan on z_w5_stock
(6 rows)
 id | v | cnt
----+---+-----
  1 | 1 |   2
  2 | 2 |   0
  3 | 1 |   0
  4 | 0 |   2
  5 | 5 |   0
(5 rows)

W6 · open · identical

CREATE TEMP TABLE z_W6_t (id int, val int);
INSERT INTO z_W6_t VALUES (1,10),(2,20),(3,15),(4,25),(5,5);
-- Case 1: bare unused RPR window function -> guard fires, WindowAgg retained
EXPLAIN (COSTS OFF)
SELECT count(*) FROM (
  SELECT count(*) OVER w AS c FROM z_W6_t
  WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
               PATTERN (A+) DEFINE A AS val > PREV(val))) t;
SELECT count(*) FROM (
  SELECT count(*) OVER w AS c FROM z_W6_t
  WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
               PATTERN (A+) DEFINE A AS val > PREV(val))) t;
-- Case 2: same window function nested in an expression -> guard bypassed,
-- WindowAgg dropped entirely, yet the result is identical and correct
EXPLAIN (COSTS OFF)
SELECT count(*) FROM (
  SELECT count(*) OVER w + 0 AS c FROM z_W6_t
  WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
               PATTERN (A+) DEFINE A AS val > PREV(val))) t;
SELECT count(*) FROM (
  SELECT count(*) OVER w + 0 AS c FROM z_W6_t
  WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
               PATTERN (A+) DEFINE A AS val > PREV(val))) t;

-- BASE and HEAD identical; tail of the shared output
(1 row)
        QUERY PLAN
--------------------------
 Aggregate
   ->  Seq Scan on z_w6_t
(2 rows)
 count
-------
     5
(1 row)

W7 · open · no reproduction SQL

defineClause aliased without copying -- code inspection

W8 · open · identical

CREATE TEMP TABLE z_w8_stock (company text, tdate date, price int);
INSERT INTO z_w8_stock VALUES
  ('c1','2024-01-01',100),('c1','2024-01-02',200),('c1','2024-01-03',150);
-- w2 is referenced by no window function: select_active_windows drops it and
-- no WindowAgg for w2 is planned, yet remove_unused_subquery_outputs keeps
-- the otherwise-unused column "price" in the subquery output solely because
-- w2's DEFINE references it.  (count(*) OVER w1 sets hasWindowFuncs and
-- blocks subquery pullup, so remove_unused_subquery_outputs actually runs.)
EXPLAIN (VERBOSE, COSTS OFF)
SELECT cnt FROM (
    SELECT count(*) OVER w1 AS cnt, price
    FROM z_w8_stock
    WINDOW w1 AS (ORDER BY tdate),
           w2 AS (ORDER BY tdate
        ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
        PATTERN (a b+)
        DEFINE b AS price > PREV(price))
) t;
-- Defect: the WindowAgg "Output:" line still carries "price" (and Sort /
-- Seq Scan below carry it too) although no plan node ever evaluates w2.
-- Fixed: price is replaced with NULL::integer and drops out of the lower
-- targetlists.  (The O(cols x DEFINE) facet is code-shape only; observe via
-- planning profile with a wide DEFINE and many removable output columns.)

-- BASE and HEAD identical; tail of the shared output
   Output: t.cnt
   ->  WindowAgg
         Output: count(*) OVER w1, z_w8_stock.price, z_w8_stock.tdate
         Window: w1 AS (ORDER BY z_w8_stock.tdate)
         ->  Sort
               Output: z_w8_stock.tdate, z_w8_stock.price
               Sort Key: z_w8_stock.tdate
               ->  Seq Scan on pg_temp.z_w8_stock
                     Output: z_w8_stock.tdate, z_w8_stock.price
(10 rows)

W9 · closed by 4XXX · no reproduction SQL

undocumented guards around pull_var_clause -- call-site comment

D1 · open · identical

CREATE TEMP TABLE z_D1_a (id int, price int);
CREATE TEMP TABLE z_D1_b (id int);
CREATE TEMP VIEW z_D1_v AS
SELECT a.id, count(*) OVER w AS cnt
FROM z_D1_a a JOIN z_D1_b b ON a.id = b.id
WINDOW w AS (ORDER BY a.id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             PATTERN (UP+) DEFINE UP AS price > PREV(price));
-- bug: DEFINE deparses as "up AS (a.price > PREV(a.price))"
SELECT pg_get_viewdef('z_D1_v');
-- reparsing the deparsed text fails:
CREATE TEMP VIEW z_D1_v_rt AS
 SELECT a.id, count(*) OVER w AS cnt
   FROM (z_D1_a a JOIN z_D1_b b ON ((a.id = b.id)))
  WINDOW w AS (ORDER BY a.id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  AFTER MATCH SKIP PAST LAST ROW INITIAL PATTERN (up+)
  DEFINE up AS (a.price > PREV(a.price)) );
DROP TABLE z_D1_a, z_D1_b CASCADE;

-- BASE and HEAD identical; tail of the shared output
   AFTER MATCH SKIP PAST LAST ROW                                              +
   INITIAL                                                                     +
   PATTERN (up+)                                                               +
   DEFINE                                                                      +
   up AS (a.price > PREV(a.price)) );
(1 row)
ERROR:  range variable qualified expression "a.price" is not allowed in DEFINE clause
LINE 6:   DEFINE up AS (a.price > PREV(a.price)) );
                        ^
NOTICE:  drop cascades to view z_d1_v

D2 · open · identical

CREATE TEMP TABLE z_D2_t (v int);
CREATE TEMP VIEW z_D2_v AS
  SELECT count(*) OVER w2 FROM z_D2_t
  WINDOW "pattern" AS (PARTITION BY v), w2 AS ("pattern" ORDER BY v);
SELECT pg_get_viewdef('z_D2_v', true);
-- deparsed text as pg_dump would emit it: fails to re-parse
SELECT count(*) OVER w2 AS count
   FROM z_D2_t
  WINDOW pattern AS (PARTITION BY v), w2 AS (pattern ORDER BY v);

-- BASE and HEAD identical; tail of the shared output
                          pg_get_viewdef
-------------------------------------------------------------------
  SELECT count(*) OVER w2 AS count                                +
    FROM z_d2_t                                                   +
   WINDOW pattern AS (PARTITION BY v), w2 AS (pattern ORDER BY v);
(1 row)
ERROR:  syntax error at or near "ORDER"
LINE 3: ...INDOW pattern AS (PARTITION BY v), w2 AS (pattern ORDER BY v...
                                                             ^

G1 · open · identical

CREATE TEMP TABLE z_g1_t (rn int, v int);
INSERT INTO z_g1_t VALUES (1, 10), (2, 20), (3, 30);
-- silently parsed as VAR(permute) then GROUP(A): shows "Pattern: permute a"
EXPLAIN (COSTS OFF, VERBOSE)
SELECT rn, v, first_value(v) OVER w FROM z_g1_t
WINDOW w AS (ORDER BY rn
  ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN (PERMUTE(A)) DEFINE A AS v > 0);
-- diverges from standard PERMUTE(A) == A: one 2-row match vs three 1-row matches
SELECT rn, v, count(*) OVER w FROM z_g1_t
WINDOW w AS (ORDER BY rn
  ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN (PERMUTE(A)) DEFINE A AS v > 0);
SELECT rn, v, count(*) OVER w FROM z_g1_t
WINDOW w AS (ORDER BY rn
  ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  PATTERN (A) DEFINE A AS v > 0);

-- BASE and HEAD identical; tail of the shared output
  1 | 10 |     2
  2 | 20 |     0
  3 | 30 |     0
(3 rows)
 rn | v  | count
----+----+-------
  1 | 10 |     1
  2 | 20 |     1
  3 | 30 |     1
(3 rows)

G2 · not a defect · identical

CREATE TEMP TABLE z_g2_t (id int, val int);
CREATE TEMP VIEW z_g2_glued AS
SELECT count(*) OVER w FROM z_g2_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             PATTERN (A*|B*|C)
             DEFINE A AS val > 20, B AS val <= 20, C AS val = 0);
CREATE TEMP VIEW z_g2_spaced AS
SELECT count(*) OVER w FROM z_g2_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             PATTERN (A* | B* | C)
             DEFINE A AS val > 20, B AS val <= 20, C AS val = 0);
-- deparse text identical (flat canonical form)
SELECT pg_get_viewdef('z_g2_glued'::regclass)
     = pg_get_viewdef('z_g2_spaced'::regclass) AS same_deparse_text;
-- BUG: stored parse trees differ (glued built nested ALT(A*, ALT(B*, C)))
SELECT (SELECT ev_action FROM pg_rewrite WHERE ev_class = 'z_g2_glued'::regclass)
     = (SELECT ev_action FROM pg_rewrite WHERE ev_class = 'z_g2_spaced'::regclass)
       AS same_stored_tree;
-- node count: glued 5 vs spaced 4 (the extra node is the synthesized inner ALT)
SELECT (SELECT (length(ev_action) - length(replace(ev_action,'RPRPATTERNNODE','')))/14
        FROM pg_rewrite WHERE ev_class = 'z_g2_glued'::regclass)  AS glued_nodes,
       (SELECT (length(ev_action) - length(replace(ev_action,'RPRPATTERNNODE','')))/14
        FROM pg_rewrite WHERE ev_class = 'z_g2_spaced'::regclass) AS spaced_nodes;

-- BASE and HEAD identical; tail of the shared output
 t
(1 row)
 same_stored_tree
------------------
 f
(1 row)
 glued_nodes | spaced_nodes
-------------+--------------
           5 |            4
(1 row)

R1 · open · identical

SET compute_query_id = on;
CREATE TEMP TABLE z_R1_t (id int, p int);
INSERT INTO z_R1_t VALUES (1, 60), (2, 40), (3, 70), (4, 30);
-- Query 1: A means p>50 -> PATTERN (A B) = high then low; returns counts 2,0,2,0
SELECT id, p, count(*) OVER w FROM z_R1_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  AFTER MATCH SKIP PAST LAST ROW INITIAL
  PATTERN (A B) DEFINE A AS p > 50, B AS p < 50);
-- Query 2: names swapped -> PATTERN (A B) = low then high; returns counts 0,2,0,0
SELECT id, p, count(*) OVER w FROM z_R1_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  AFTER MATCH SKIP PAST LAST ROW INITIAL
  PATTERN (A B) DEFINE B AS p > 50, A AS p < 50);
-- Both EXPLAINs print the SAME "Query Identifier:" line despite different semantics
EXPLAIN (VERBOSE, COSTS OFF)
SELECT id, p, count(*) OVER w FROM z_R1_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  AFTER MATCH SKIP PAST LAST ROW INITIAL
  PATTERN (A B) DEFINE A AS p > 50, B AS p < 50);
EXPLAIN (VERBOSE, COSTS OFF)
SELECT id, p, count(*) OVER w FROM z_R1_t
WINDOW w AS (ORDER BY id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  AFTER MATCH SKIP PAST LAST ROW INITIAL
  PATTERN (A B) DEFINE B AS p > 50, A AS p < 50);

-- BASE and HEAD identical; tail of the shared output
   Window: w AS (ORDER BY z_r1_t.id ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
   Pattern: a b
   Nav Mark Lookback: 0
   ->  Sort
         Output: id, p
         Sort Key: z_r1_t.id
         ->  Seq Scan on pg_temp.z_r1_t
               Output: id, p
 Query Identifier: N
(11 rows)

R2 · partial · no reproduction SQL

three of four hand-written serialization contracts -- code inspection

R3 · not a defect · identical

-- z_R3_: RPRPattern serialization roundtrip smoke (assert build only)
SET debug_write_read_parse_plan_trees = on;
SET debug_copy_parse_plan_trees = on;
CREATE TEMP TABLE z_R3_t (id int, v int);
INSERT INTO z_R3_t VALUES (1,10),(2,20),(3,15),(4,25),(5,30);
SELECT id, v, first_value(id) OVER w AS m
FROM z_R3_t
WINDOW w AS (
  ORDER BY id
  ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
  AFTER MATCH SKIP PAST LAST ROW
  INITIAL
  PATTERN (STRT UP+ DOWN+)
  DEFINE UP AS v > PREV(v), DOWN AS v < PREV(v)
);
RESET debug_write_read_parse_plan_trees;
RESET debug_copy_parse_plan_trees;

-- BASE and HEAD identical; tail of the shared output
 id | v  | m
----+----+---
  1 | 10 | 1
  2 | 20 |
  3 | 15 |
  4 | 25 |
  5 | 30 |
(5 rows)

PF1 · out of scope · identical

-- PF1: spill + FIRST nav quadratic repro (creates no objects, self-contained)
SET work_mem='64kB';
-- Spill: n=2000 ~0.83s, n=4000 ~5.4s (4-6.5x per doubling)
SELECT count(*) FROM (
  SELECT id, count(*) OVER w cnt
  FROM (SELECT g AS id, repeat('x', 50) AS pad, (g % 11) AS v
        FROM generate_series(0, 3999) g) t
  WINDOW w AS (ORDER BY id
    ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
    AFTER MATCH SKIP PAST LAST ROW
    PATTERN (S A+) DEFINE S AS TRUE, A AS v >= FIRST(v))
) s WHERE cnt > 0;
RESET work_mem;
-- Control 1: same query in-memory ~1.3ms
SELECT count(*) FROM (
  SELECT id, count(*) OVER w cnt
  FROM (SELECT g AS id, repeat('x', 50) AS pad, (g % 11) AS v
        FROM generate_series(0, 3999) g) t
  WINDOW w AS (ORDER BY id
    ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
    AFTER MATCH SKIP PAST LAST ROW
    PATTERN (S A+) DEFINE S AS TRUE, A AS v >= FIRST(v))
) s WHERE cnt > 0;
-- Control 2: even with spill, PREV takes ~1.7ms (FIRST alone is the trigger)
SET work_mem='64kB';
SELECT count(*) FROM (
  SELECT id, count(*) OVER w cnt
  FROM (SELECT g AS id, repeat('x', 50) AS pad, (g % 11) AS v
        FROM generate_series(0, 3999) g) t
  WINDOW w AS (ORDER BY id
    ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
    AFTER MATCH SKIP PAST LAST ROW
    PATTERN (S A+) DEFINE S AS TRUE, A AS v >= PREV(v))
) s WHERE cnt > 0;
RESET work_mem;

-- BASE and HEAD identical; tail of the shared output
     1
(1 row)
 count
-------
     1
(1 row)
 count
-------
   364
(1 row)

Q1 · closed by 4XXX · no reproduction SQL

four allStatesAbsorbable comments corrected

Q3 · closed by 4XXX · no reproduction SQL

markpos initialized to -1 per convention -- no behaviour change

Q4 · closed by 4XXX · no reproduction SQL

executor init writes into a cached plan tree -- code inspection

Z2 · not a defect · identical

-- z_Z2_ verification query (proof of absence): the stock catalogs contain no volatile cast function at all
SELECT c.castsource::regtype, c.casttarget::regtype, c.castcontext, p.provolatile
FROM pg_cast c JOIN pg_proc p ON p.oid = c.castfunc
WHERE p.provolatile = 'v';
-- Expected: 0 rows (0 not only for implicit 'i' but across all contexts, including assignment/explicit)

-- BASE and HEAD identical; tail of the shared output
 castsource | casttarget | castcontext | provolatile
------------+------------+-------------+-------------
(0 rows)

Z3 · open · identical

-- Z3 core: phnullingrels variant (VALUES input), self-contained
SELECT count(*) OVER w
FROM (VALUES ('A',1),('A',2),('B',3)) t(category, id)
GROUP BY GROUPING SETS ((category), ())
WINDOW w AS (ORDER BY category ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             PATTERN (P+) DEFINE P AS category = 'A');
-- expected on current tip: ERROR:  wrong phnullingrels (b) (expected (b 2)) for PlaceHolderVar 1

-- companion: varnullingrels variant (real table)
CREATE TEMP TABLE z_Z3_g1 (category text, id int);
INSERT INTO z_Z3_g1 VALUES ('A',1),('A',2),('B',3);
SELECT count(*) OVER w FROM z_Z3_g1
GROUP BY GROUPING SETS ((category), ())
WINDOW w AS (ORDER BY category ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
             PATTERN (P+) DEFINE P AS category = 'A');
-- expected: ERROR:  wrong varnullingrels (b) (expected (b 2)) for Var 1/1

-- BASE and HEAD identical; tail of the shared output
ERROR:  wrong phnullingrels (b) (expected (b 2)) for PlaceHolderVar 1
ERROR:  wrong varnullingrels (b) (expected (b 2)) for Var 1/1

Z4 · open · identical

-- Z4 / opt-window F6: run-condition blanket block on RPR windows
CREATE TEMP TABLE z_Z4_t (ts int, price int);
INSERT INTO z_Z4_t SELECT g, (g * 37) % 11 FROM generate_series(1, 30) g;

-- (1) Symptom: RPR window -> no "Run Condition:" line, filter degraded to
--     a Filter above the WindowAgg (full-partition NFA matching forced).
EXPLAIN (COSTS OFF)
SELECT * FROM (
  SELECT ts, row_number() OVER w AS rn FROM z_Z4_t
  WINDOW w AS (ORDER BY ts ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
               AFTER MATCH SKIP TO NEXT ROW INITIAL
               PATTERN (a+) DEFINE a AS price > PREV(price))) s
WHERE rn <= 10;

-- (2) Non-RPR baseline: "Run Condition: (row_number() OVER w <= 10)" present.
EXPLAIN (COSTS OFF)
SELECT * FROM (
  SELECT ts, row_number() OVER w AS rn FROM z_Z4_t
  WINDOW w AS (ORDER BY ts ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)) s
WHERE rn <= 10;

-- (3) Why blanket unblock is unsafe: count(*) claims MONOTONICFUNC_DECREASING
--     from frameOptions alone (int8.c), but over RPR reduced frames cnt is
--     match-dependent and non-monotonic (drops to 0 on unmatched rows, rises
--     again on later matches).  Under an unblocked build this query would get
--     a run condition and silently lose all matches after the first unmatched
--     row; on the current tree it returns every cnt>0 row (correct).
SELECT * FROM (
  SELECT ts, price, count(*) OVER w AS cnt FROM z_Z4_t
  WINDOW w AS (ORDER BY ts ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
               PATTERN (b+) DEFINE b AS price > PREV(price))) s
WHERE cnt > 0 ORDER BY ts;

-- BASE and HEAD identical; tail of the shared output
  7 |     6 |   2
 10 |     7 |   1
 12 |     4 |   2
 15 |     5 |   2
 18 |     6 |   2
 21 |     7 |   1
 23 |     4 |   2
 26 |     5 |   2
 29 |     6 |   2
(11 rows)

Z5 · not a defect · no reproduction SQL

runCondition likewise unfinalized but structurally masked