@quereus/quereus 4.10.0 → 4.12.0

package/dist/src/planner/building/mutation-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-context.js","sourceRoot":"","sources":["../../../../src/planner/building/mutation-context.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAuC,MAAM,uBAAuB,CAAC;AACtF,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG5D,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAmBnD;;;;;GAKG;AACH,SAAS,wBAAwB,CAAC,IAA8B;IAC/D,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;IACrC,OAAO,IAAI,YAAY,CACtB,UAAU,IAAI,CAAC,UAAU,yCAAyC,OAAO,KAAK;QAC9E,iCAAiC,OAAO,QAAQ,EAChD,UAAU,CAAC,KAAK,CAChB,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,mBAAmB,CAC3B,cAAgE;IAEhE,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAiC,CAAC;IAC1D,KAAK,MAAM,UAAU,IAAI,cAAc,IAAI,EAAE,EAAE,CAAC;QAC/C,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;QAC1C,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,YAAY,CACrB,8BAA8B,UAAU,CAAC,IAAI,2BAA2B,EACxE,UAAU,CAAC,KAAK,CAChB,CAAC;QACH,CAAC;QACD,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,QAAQ,CAAC;AACjB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,8BAA8B,CAC7C,WAAwB,EACxB,cAAgE;IAEhE,+EAA+E;IAC/E,wDAAwD;IACxD,MAAM,aAAa,GAAG,mBAAmB,CAAC,cAAc,CAAC,CAAC;IAE1D,MAAM,QAAQ,GAAG,WAAW,CAAC,eAAe,CAAC;IAC7C,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAElD,MAAM,UAAU,GAAG,GAAG,WAAW,CAAC,UAAU,IAAI,WAAW,CAAC,IAAI,EAAE,CAAC;IAEnE,OAAO,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QAClC,EAAE,EAAE,QAAQ,CAAC,UAAU,EAAE;QACzB,IAAI,EAAE,UAAU,CAAC,IAAI;QACrB,IAAI,EAAE;YACL,SAAS,EAAE,QAAiB;YAC5B,kFAAkF;YAClF,mFAAmF;YACnF,gFAAgF;YAChF,iFAAiF;YACjF,+DAA+D;YAC/D,WAAW,EAAE,UAAU,CAAC,WAAW;YACnC,QAAQ,EAAE,CAAC,UAAU,CAAC,OAAO;YAC7B,UAAU,EAAE,IAAI;SAChB;QACD,cAAc,EAAE,WAAW,WAAW,CAAC,IAAI,EAAE;QAC7C,UAAU;QACV,UAAU;QACV,QAAQ,EAAE,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;KAC1D,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,8BAA8B,CAC7C,KAAsB,EACtB,iBAA0D;IAE1D,iBAAiB,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE;QACnD,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;QAExD,MAAM,SAAS,GAAsB,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO;YAC7E,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,mBAAmB,CAAC,CAAC,EAAE,GAAqB,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,eAAe,CAAC;YACpG,CAAC,CAAC,GAAG,EAAE,GAAG,MAAM,wBAAwB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAEnD,KAAK,CAAC,cAAc,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;QAC9C,KAAK,CAAC,cAAc,CAAC,WAAW,YAAY,EAAE,EAAE,SAAS,CAAC,CAAC;IAC5D,CAAC,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CACtC,iBAA0D;IAE1D,OAAO,IAAI,GAAG,CAAC,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;AACnF,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,0BAA0B,CACzC,GAAoB,EACpB,iBAA0D,EAC1D,cAAgE;IAEhE,MAAM,MAAM,GAAG,IAAI,GAAG,EAA0B,CAAC;IACjD,IAAI,iBAAiB,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,MAAM,CAAC;IAElD,MAAM,QAAQ,GAAG,mBAAmB,CAAC,cAAc,CAAC,CAAC;IAErD,KAAK,MAAM,IAAI,IAAI,iBAAiB,EAAE,CAAC;QACtC,MAAM,UAAU,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;QACpE,MAAM,SAAS,GAAmB,UAAU;YAC3C,CAAC,CAAC,UAAU,CAAC,KAAK;YAClB,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QACpC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,eAAe,CAAC,GAAG,EAAE,SAAS,CAAmB,CAAC,CAAC;IAC1E,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC"}

package/dist/src/planner/building/select-aggregates.d.ts

@@ -20,66 +20,28 @@ export declare function buildAggregatePhase(input: RelationalPlanNode, stmt: AST
     groupByExpressions?: ScalarPlanNode[];
     hasHavingOnlyAggregates?: boolean;
     hasOrderByOnlyAggregates?: boolean;
-    orderByHasAggregates?: boolean;
+    orderByNeedsPostAggregateSort?: boolean;
     aggregatesContext?: PlanningContext['aggregates'];
+    groupedRedirectContext?: GroupedRedirectContext;
 };
 /**
- * What a grouped query's rows are allowed to expose: the attribute ids reachable
- * after aggregation, plus the canonical AST strings of the GROUP BY expressions
- * themselves.
+ * What a GROUPED query's post-aggregate builders need in order to run their
+ * expressions over the AggregateNode's own rows: the rebuilt SELECT list
+ * ({@link buildFinalAggregateProjections}), the window phase's specifications and
+ * function arguments, the HAVING predicate, and the sort keys.
  *
- * Two flavours of attribute id are legal, and both matter depending on where the
- * expression being checked was built. An expression built against the
- * *pre-aggregate* scope (the SELECT list, before the final projection) names base
- * source attributes, so the ids of the GROUP BY key expressions cover it. A HAVING
- * predicate resolves through a hybrid scope and may name either the AggregateNode's
- * own output attributes or, via the source-column fallback, base ones — so the
- * output ids must be admitted too, passed in `groupedOutputAttributes`.
- *
- * The window phase of a grouped query has its own check
- * ({@link assertGroupedWindowCoverage}); it needs to descend into subqueries and to
- * tell a correlated reference from an ungrouped local one, neither of which this
- * coverage set can express.
- *
- * The fingerprint set covers whole grouped subtrees (`select id+1 … group by
- * id+1`) and, incidentally, the qualifier mismatch between `group by t.a` and a
- * later bare `a`. Fingerprints fold identifier case (see
- * {@link expressionToIdentityString}), so `group by A || '!'` covers a later
- * `a || '!'`; quoted literals stay byte-exact, so `a || 'X'` does not.
- */
-export interface GroupByCoverage {
-    readonly attrIds: ReadonlySet<number>;
-    readonly fingerprints: ReadonlySet<string>;
-}
-/**
- * Builds the coverage test for a grouped query. `groupedOutputAttributes` is the
- * AggregateNode's output attributes (group keys followed by aggregate results),
- * needed only when the expressions to be checked were built against the aggregate
- * output scope.
- */
-export declare function buildGroupByCoverage(groupByExpressions: readonly ScalarPlanNode[], groupedOutputAttributes?: readonly Attribute[]): GroupByCoverage;
-/**
- * Raises the standard GROUP BY coverage error when `node` reads a column the
- * grouped rows do not carry. Used by the SELECT-list check below; the window
- * phase raises the same message from {@link assertGroupedWindowCoverage}.
- */
-export declare function assertGroupByCoverage(node: PlanNode, coverage: GroupByCoverage): void;
-/**
- * What the window phase of a GROUPED query needs in order to run its window
- * specifications and function arguments over the AggregateNode's own rows.
- *
- * The WindowNode sits ABOVE the AggregateNode, so it can read only what the
- * aggregate's output row carries: the grouping keys and the aggregate results.
- * But the scope those expressions are built against falls through to the
- * pre-aggregate select scope, so several perfectly legal spellings of a grouping
- * key (`wg.a` against `group by a`, or the whole `a || '!'` against `group by a
- * || '!'`) bind to a *base-table* attribute the aggregate row never had. This
- * context supplies both halves of the answer: the two maps let
- * {@link redirectToGroupKeys} rewrite such a subtree onto the aggregate's own
- * output column, and the two attribute-id sets let
- * {@link assertGroupedWindowCoverage} reject what survives.
+ * All of them sit ABOVE the AggregateNode, so all of them can read only what the
+ * aggregate's output row carries: the grouping keys and the aggregate results. But the
+ * scope those expressions are built against falls through to the pre-aggregate select
+ * scope, so several perfectly legal spellings of a grouping key (`wg.a` against
+ * `group by a`, or the whole `a || '!'` against `group by a || '!'`) bind to a
+ * *base-table* attribute the aggregate row never had. This context supplies both halves
+ * of the answer: the two maps let {@link redirectPostAggregate} — the ONE entry point
+ * every such expression goes through — rewrite such a subtree onto the aggregate's own
+ * output column, and the two attribute-id sets let {@link assertGroupedPlanCoverage}
+ * reject what survives, once, over the finished plan.
  */
-export interface GroupedWindowContext {
+export interface GroupedRedirectContext {
     /** Where each GROUP BY key lives on the AggregateNode's output row. */
     readonly groupKeys: GroupKeyIndex;
     /** AggregateNode output attributes: group keys in GROUP BY order, then aggregate results. */
@@ -101,8 +63,8 @@ export interface GroupedWindowContext {
     readonly aggregateInputAttrIds: ReadonlySet<number>;
     /**
      * Legal AFTER redirection: AggregateNode output attribute ids ONLY. Once
-     * {@link redirectToGroupKeys} has run, an aggregate-input attribute id still
-     * present anywhere in a window expression is an ungrouped reference.
+     * {@link redirectPostAggregate} has run, an aggregate-input attribute id still
+     * present anywhere in a post-aggregate expression is an ungrouped reference.
      */
     readonly outputAttrIds: ReadonlySet<number>;
 }
@@ -111,9 +73,9 @@ export interface GroupedWindowContext {
  * later expression may reach it by: the whole grouped expression written out again, or
  * (for a bare-column key) the base column under any qualifier.
  *
- * Shared by the window phase's {@link redirectToGroupKeys} and by the select list's
- * {@link buildFinalAggregateProjections}, which resolve the same question about
- * different expressions.
+ * Shared by {@link redirectToGroupKeys} (via {@link redirectPostAggregate}) and by
+ * the select list's {@link buildFinalAggregateProjections}, which resolve the same
+ * question about different expressions.
  */
 export interface GroupKeyIndex {
     /** Identity fingerprint of each GROUP BY expression → its output column index. */
@@ -122,83 +84,56 @@ export interface GroupKeyIndex {
     readonly byBaseAttrId: ReadonlyMap<number, number>;
 }
 /**
- * Builds the {@link GroupKeyIndex} for a grouped query's GROUP BY list. The output
- * column index is the key's position in that list, which is its position on the
- * AggregateNode's output row.
- */
-export declare function indexGroupKeys(groupByExpressions: readonly ScalarPlanNode[]): GroupKeyIndex;
-/**
- * Builds the {@link GroupedWindowContext} for a grouped, windowed query.
- * `outputAttributes` is the AggregateNode's attribute list (group keys in GROUP BY
- * order, then the aggregate results); `aggregateInput` is the AggregateNode's
- * source relation, whose whole subtree defines
- * {@link GroupedWindowContext.aggregateInputAttrIds}.
- */
-export declare function buildGroupedWindowContext(groupByExpressions: readonly ScalarPlanNode[], outputAttributes: readonly Attribute[], aggregateInput: PlanNode): GroupedWindowContext;
-/**
- * Rewrites every subtree of a window specification / window-function argument that
- * IS a grouping key into a reference to the AggregateNode's output column for that
- * key, so the expression reads the grouped row instead of a base-table column that
- * row does not carry.
- *
- * Two match rules, in order at each node:
+ * The ONE entry point through which every post-aggregate expression of a GROUPED
+ * query reaches the grouping-key redirect: the rebuilt SELECT list, the window
+ * phase's specifications and function arguments, the HAVING predicate, and every
+ * post-aggregate sort key. A builder that constructs an expression above the
+ * AggregateNode calls this rather than remembering the rewrite itself — forgetting
+ * is how the SELECT-list and ORDER BY bugs shipped
+ * (complete/bug-qualified-group-key-in-select-list-breaks-window-query,
+ * complete/bug-order-by-grouping-key-spelling-breaks-window-query).
  *
- * 1. The whole subtree's identity fingerprint equals a GROUP BY expression's — covers
- *    `group by a || '!'` + `over (order by a || '!')`, and nested occurrences such
- *    as `over (order by upper(a || '!'))` because the walk recurses. Identifier case
- *    is folded, so `group by A || '!'` matches too; quoted literals are byte-exact,
- *    so `a || 'X'` and `a || 'x'` remain different keys.
- *
- *    Unconditional above any subquery, where the expression is written in this query's
- *    own scope. INSIDE a subquery it is guarded by {@link readsOnlyAggregateInput} —
- *    every column reference in the subtree must be a pre-grouping column of THIS query
- *    — because there the same text can name something else entirely: under `group by
- *    a`, a bare `a` written inside `over (order by (select … where t.a = a))` names the
- *    subquery's own `t.a` and yet fingerprints as `a`, so an unguarded rule 1 would
- *    silently rewrite it into the outer group column and change what the query means.
- *    The guard cannot replace the top-level case: `group by (select max(t.b) from wg t
- *    where t.a = wg.a)` repeated verbatim in the specification is a legal grouping key
- *    whose subtree also reads the subquery's own columns.
- * 2. The node is a column reference whose attribute id is the *base* attribute id of
- *    a bare-column grouping key — covers `group by a` + `over (order by wg.a)` and
- *    `over (order by w.a)`. Both spellings fall through to the same base attribute
- *    the group key was built from, so the match is qualifier-independent. It needs no
- *    guard at any depth: attribute ids are minted per relation instance, so only a
- *    reference that genuinely resolves to this query's grouping column can match.
- *
- * Otherwise recurse into every child, relational ones included, rebuilding through
- * `withChildren` — a correlated reference to a grouping key can live arbitrarily deep
- * inside a subquery in the window specification, and it must be redirected there too
- * or it reaches the runtime as a base-table attribute the grouped row never carried.
- *
- * NOTE: rule 1 matches by AST text, so a subtree that *reads* like a grouping key but
- * resolves to something else could be redirected wrongly. Within one query the guard
- * above closes that off; the residue is a subtree of ENCLOSING-query references that
- * happens to spell a grouping key (`group by a` in an inner query whose window spec
- * says `outer_alias.a`… only when that fingerprints identically). This is the same
- * limitation the select list already carries through the shared {@link GroupKeyIndex};
- * fixing it means comparing resolved attribute identity rather than text, for both
- * callers at once.
+ * A pass-through when `context` is absent (the query has no GROUP BY keys), and when
+ * the expression contains nothing to redirect. That gate is load-bearing, not an
+ * optimization: {@link redirectToGroupKeys} matches a subtree by AST text, so under
+ * `group by a` an ungated pass would also fingerprint a plain `order by a` that
+ * already bound correctly to a projection/window/aggregate OUTPUT attribute — the
+ * clearest hazard being an alias that shadows a grouping key (`select upper(a) as a …
+ * group by a order by a` must sort by the projected `upper(a)`). Only an expression
+ * that actually fell through to a pre-grouping attribute has anything to fix, and
+ * only such an expression is walked.
  */
-export declare function redirectToGroupKeys(node: ScalarPlanNode, context: GroupedWindowContext, scope: Scope): ScalarPlanNode;
+export declare function redirectPostAggregate(expr: ScalarPlanNode, context: GroupedRedirectContext | undefined, scope: Scope): ScalarPlanNode;
 /**
- * Raises the GROUP BY coverage error for a window specification / window-function
- * argument of a GROUPED query that still reads a pre-grouping column after
- * {@link redirectToGroupKeys} has run.
+ * Boundary check over a GROUPED query's finished plan: no node ABOVE the
+ * AggregateNode may reference an aggregate-input attribute id that is absent from
+ * the aggregate's output. Called once per grouped query, from the end of
+ * `buildSelectStmt`, walking the operator spine from the query root down to — and
+ * stopping at — the AggregateNode itself (whose own input subtree legally reads
+ * pre-grouping columns). Each scalar expression hanging off a spine operator gets
+ * the subquery-aware per-expression check ({@link assertPostAggregateCoverage}).
  *
- * Distinct from {@link assertGroupByCoverage} in exactly two ways, both required by
- * the fact that a window expression may contain a subquery:
+ * This is what turns "a builder forgot to call {@link redirectPostAggregate}" from a
+ * runtime `No row context found for column …` internal error into the user-facing
+ * GROUP BY message at plan time — the SELECT-list and ORDER BY escapes both shipped
+ * exactly that way. It also rejects, at plan time, a post-aggregate expression that
+ * genuinely reads an ungrouped column (directly, or correlated through a subquery).
  *
- * - it descends into relational children, so a correlated reference buried in a
- *   subquery is checked rather than skipped;
- * - it flags a column reference only when the attribute id is one of THIS query's
- *   pre-grouping columns. A reference to anything else — the subquery's own columns,
- *   or a correlated reference to an enclosing query — is legal here and is left alone.
+ * NOTE: the stop condition is node IDENTITY, so it holds only while `buildSelectStmt`
+ * *wraps* the aggregate rather than rebuilding it. A future post-aggregate step that
+ * rebuilds the spine through `withChildren` would mint a new AggregateNode, the walk
+ * would run straight past it into the aggregate's own input, and every legal
+ * pre-grouping reference down there (a WHERE conjunct, a join condition) would be
+ * rejected with a user-facing GROUP BY error. If such a step is ever added, locate
+ * the aggregate by node id instead of by reference.
  *
- * The aggregate exemption is likewise narrowed to this query's OWN aggregates; see
- * {@link findUngroupedWindowColumnRef}.
+ * NOTE: one extra walk of the post-aggregate plan per grouped query per prepare, on
+ * top of the redirect's own walk (see {@link redirectNode}). Measured end-to-end, not
+ * isolated: compiling a six-column grouped query costs ~0.6-0.8 ms against ~0.5 ms for
+ * a comparable ungrouped one, so this walk is bounded well below the surrounding
+ * planning cost. Revisit if preparing grouped queries ever shows up as slow.
  */
-export declare function assertGroupedWindowCoverage(node: PlanNode, context: GroupedWindowContext): void;
+export declare function assertGroupedPlanCoverage(node: PlanNode, aggregateNode: PlanNode, context: GroupedRedirectContext): void;
 /**
  * Every aggregate function call inside an AST expression, in source order.
  * Does not descend into an aggregate's own arguments (nested aggregates are
@@ -207,10 +142,16 @@ export declare function assertGroupedWindowCoverage(node: PlanNode, context: Gro
  */
 export declare function collectAggregateFunctionExprs(expr: AST.Expression, ctx: PlanningContext): AST.FunctionExpr[];
 /**
- * Builds final projections for the complete SELECT list in aggregate context
+ * Builds final projections for the complete SELECT list in aggregate context.
+ *
+ * `groupedContext` is supplied whenever the query HAS a GROUP BY (it is `undefined`
+ * for an aggregate query without one, which has no grouping keys to redirect onto).
+ * It is what makes a select-list reference to a grouping key name the AggregateNode's
+ * OWN group output column, whatever spelling the reference used — see
+ * {@link redirectPostAggregate} and the note on the rebuild below.
  */
 export declare function buildFinalAggregateProjections(stmt: AST.SelectStmt, selectContext: PlanningContext, aggregateOutputScope: RegisteredScope, aggregateNode: RelationalPlanNode, aggregates: {
     expression: ScalarPlanNode;
     alias: string;
-}[], groupByExpressions: ScalarPlanNode[], starProjectionsByColumn?: ReadonlyMap<AST.ResultColumn, readonly Projection[]>): Projection[];
+}[], groupByExpressions: ScalarPlanNode[], starProjectionsByColumn?: ReadonlyMap<AST.ResultColumn, readonly Projection[]>, groupedContext?: GroupedRedirectContext): Projection[];
 //# sourceMappingURL=select-aggregates.d.ts.map

package/dist/src/planner/building/select-aggregates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"select-aggregates.d.ts","sourceRoot":"","sources":["../../../../src/planner/building/select-aggregates.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"select-aggregates.d.ts","sourceRoot":"","sources":["../../../../src/planner/building/select-aggregates.ts"],"names":[],"mappings":"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"}