sequence accessors: DEFAULTs, loud classification, constant-context eval, window-over-derived, kv INSERT..SELECT sources

[EnRaiha]

Scope

Sequence accessors (nextval / currval / setval) end to end:

1. Per-row DEFAULTs on every engine — DEFAULT nextval('s') advances the control-plane registry once per inserted row on kv, columnar, document and strict collections; malformed or currval/setval DEFAULTs are rejected loudly instead of silently NULLing.

2. Loud classification everywhere else — an accessor in any row-scope context (SELECT list, WHERE, ORDER BY, GROUP BY, HAVING, UPDATE SET, JOIN ON, INSERT..SELECT) raises SQLSTATE 0A000 with a self-describing message; the registry entries, scalar-evaluator guard, exhaustive const-fold classification and end-to-end error plumbing (error code, msgpack tag, envelope + data-plane wire, pgwire/gateway maps) carry the typed code to the client.

3. Real evaluation in constant contexts — FROM-less SELECT nextval('s') and explicit VALUES cells evaluate through the registry at plan time, in expression order; setval sets and returns; a missing sequence raises a plan error naming it. Folded accessor plans are never admitted to the physical-plan cache, and EXPLAIN does not advance the registry.

4. kv SELECT projections evaluate — kv scans carry the SELECT projection list and computed columns like the other engines, so scalar expressions evaluate per row (SELECT 1 + 1 FROM kv no longer returns an empty column); plain projections stay full-row so clone-source merges keep the keys tombstone suppression needs.

5. Typed error lanes — executor paths that collapsed evaluation errors to division-by-zero or internal error now discriminate variants, so division keeps 22012 and accessors surface 0A000 through every scan/aggregate/join/routing path.

6. Runtime headroom — tokio worker stack raised to 16 MiB; deep DDL planning no longer dies with a silent SIGSEGV.

7. Typed unknown-sequence DEFAULTs — a DEFAULT naming a missing sequence
   raises SQLSTATE 42704 (undefined_object), matching PostgreSQL; other
   registry failures keep the plan-error class.

8. Window functions over derived tables — SUM(n) OVER (...),
   row_number() OVER (...), and every other window verb over a
   FROM (SELECT ...) body evaluate per row through the materialized-row
   scan instead of silently answering NULL (issue Expression errors fold silently over constant derived tables — 22012 raised on collection scans but not on FROM (SELECT ...) #295 window form). Window
   specs survive CTE inlining for Scan-bodied derived tables, and subquery
   fold + validation walk window expressions so catalog casts inside
   PARTITION BY / ORDER BY fold and validate.

9. kv INSERT..SELECT sources — INSERT INTO <target> SELECT ... FROM <kv source> copies rows through the KV materialize scan instead of
   silently reporting INSERT 0 0 (issue INSERT..SELECT with a kv-engine source silently NULLs expression cells #311). The copy orchestrator
   routes the source scan by engine, in-transaction copies read their own
   writes, and columnar sources refuse loudly until a columnar copy scan
   exists.

Rebased on current main (includes the primary-key NOT NULL / row-identity
change #310): DEFAULT expansion runs before identity resolution, so a
sequence-defaulted primary key is filled first and the NOT NULL
enforcement only rejects keys that are still NULL after defaults.

Tests

Wire suites: per-engine DEFAULT, expression-context (FROM-less, SELECT
list, WHERE, ORDER BY, VALUES, INSERT..SELECT, derived-table constants),
constant-context (advance, currval, setval, EXPLAIN, missing-sequence
errors), kv projection, a 60-case engine x accessor x context matrix
asserting loud 0A000, window-over-derived positive-value (SUM,
row_number) and division-by-zero, and kv INSERT..SELECT (autocommit and
in-transaction staged). Verified against the #310 suites on the merged
tree: sql_primary_key_nullability, sql_null_predicate_parity,
write_verdict_sqlstate, plus the division-by-zero and clone regressions.

Known boundaries

Row-scope sequence accessors stay loud by design until per-row evaluation lands (future work). The remaining #295 forms —
VALUES-derived and UNION-derived bodies plus the outer-expression case —
are tracked separately. index-DDL stack overflow (#312) is fixed here.

[Copilot]

Copilot was unable to review this pull request because the user who requested the review has reached their quota limit.

[farhan-syah]

Superseded by #316, which landed the sequence-accessor and DEFAULT work on main directly.

#316 covers, from this PR's scope:

Behaviour	Where it landed
nextval/currval/setval registered and resolved	SqlCatalog against the sequence registry
Sequence-backed DEFAULTs on every engine	One shared materializer, document, kv, columnar, vector-primary
Loud classification of an unevaluable DEFAULT	Typed Result, gated at CREATE COLLECTION with 42883
Constant-context evaluation	FROM-less SELECT, resolved via catalog_expr_fold
Session-scoped currval	Per-connection state on ConnSession

It also closes #298 and #313, and adds the volatility model that keeps a non-deterministic DEFAULT from freezing into a cached plan.

Two parts of this PR are not covered by #316 and stay open as their own issues:

• kv INSERT..SELECT expression cells — INSERT..SELECT with a kv-engine source silently NULLs expression cells #311
• window over a derived table — SEARCH synthetic columns are unresolvable from a derived table over a closed-schema collection #305

Closing to clear the conflicting branch, not to discard those. Thanks for the work here — the split you documented on #294 mapped the surface accurately, and the DEFAULT classification in particular matched where the defect actually was.