@quereus/quereus 4.3.0 → 4.3.2

package/dist/src/core/database-materialized-views-analysis.js

@@ -0,0 +1,502 @@
+/**
+ * Materialized-view maintenance — plan-tree analysis helpers.
+ *
+ * The stateless utilities the maintenance plan builders lean on: recursive plan-tree
+ * walks (find/count node types, collect table refs + attribute provenance), the
+ * collation/determinism/replicability gates, the create-time rejection diagnostics, and
+ * the single-source scalar-expression evaluator. Split out of
+ * `database-materialized-views.ts` so the manager class and its plan builders read on
+ * their own; every function here is a pure move (no `MaterializedViewManager` state).
+ */
+import { QuereusError } from '../common/errors.js';
+import { StatusCode } from '../common/types.js';
+import { isRelationalNode, isScalarNode } from '../planner/nodes/plan-node.js';
+import { ColumnReferenceNode, TableReferenceNode } from '../planner/nodes/reference.js';
+import { FilterNode } from '../planner/nodes/filter.js';
+import { AggregateNode } from '../planner/nodes/aggregate-node.js';
+import { TableFunctionCallNode } from '../planner/nodes/table-function-call.js';
+import { PlanNodeType } from '../planner/nodes/plan-node-type.js';
+import { checkDeterministic } from '../planner/validation/determinism-validator.js';
+import { emitPlanNode } from '../runtime/emitters.js';
+import { EmissionContext } from '../runtime/emission-context.js';
+import { Scheduler } from '../runtime/scheduler.js';
+import { RowContextMap } from '../runtime/context-helpers.js';
+import { normalizeCollationName } from '../util/comparison.js';
+import { uniqueEnforcementCollations } from '../schema/unique-enforcement.js';
+/** True for the default (binary) collation: an absent name or a case-insensitive
+ *  `BINARY`. Non-binary collations gate off the prefix-scan fast path (see
+ *  {@link MaterializedViewManager.tryBuildCoveringPrefix}). */
+export function isBinaryCollation(collation) {
+    return collation === undefined || collation.toUpperCase() === 'BINARY';
+}
+/** Canonical upper-case collation name (absent ⇒ `BINARY`). Used to compare a backing-PK
+ *  column's collation against its source PK column's at plan-build (see
+ *  {@link MaterializedViewManager.buildLateralTvfPrefixDeletePlan}). */
+export function normalizeCollation(collation) {
+    return (collation ?? 'BINARY').toUpperCase();
+}
+export function mvKey(schemaName, name) {
+    return `${schemaName}.${name}`.toLowerCase();
+}
+/** Every source base (lowercased `schema.table`) a plan must be indexed under in
+ *  `rowTimeBySource`. Single-source arms read one base; the 1:1-join arm also reads
+ *  the lookup base, so a write to `P` fires maintenance too; the full-rebuild floor reads
+ *  every source its body touches (set-op legs, all join sources). */
+export function planSourceBases(plan) {
+    if (plan.kind === 'full-rebuild') {
+        return plan.sourceBases;
+    }
+    if (plan.kind === 'join-residual' && plan.lookupBase !== plan.sourceBase) {
+        return [plan.sourceBase, plan.lookupBase];
+    }
+    return [plan.sourceBase];
+}
+/** Walk the whole plan; return the string form of the first non-deterministic scalar
+ *  expression (a `random()`/`now()`/volatile UDF, anywhere in the body), or `undefined`
+ *  when the body is fully deterministic. The full-rebuild floor's whole-body determinism
+ *  gate uses this — a non-deterministic body can never be kept equal to its plain view.
+ *  `physical.deterministic` is computed lazily and propagates from leaves, so checking each
+ *  scalar node is sound on either the pre-physical or optimized plan. */
+export function findNonDeterministic(node) {
+    if (isScalarNode(node)) {
+        const det = checkDeterministic(node);
+        if (!det.valid)
+            return det.expression ?? node.toString();
+    }
+    for (const child of node.getChildren()) {
+        const found = findNonDeterministic(child);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+/** Walk the whole plan; return the NAME of the first function whose schema is not declared
+ *  REPLICABLE (bit-identical across peers/platforms/app-versions — built-ins auto-qualify),
+ *  or `undefined` when every function in the body qualifies. Mirrors {@link findNonDeterministic}'s
+ *  `getChildren()` recursion so nested calls (a UDF inside a builtin inside a UDF) and the
+ *  WHERE / GROUP BY / aggregate-arg / TVF-arg positions are all reached. The structural
+ *  `'functionSchema' in node` test covers all four function-bearing node kinds uniformly —
+ *  scalar (`function.ts`), aggregate (`aggregate-function.ts`), TVF call
+ *  (`table-function-call.ts`), and TVF reference (`reference.ts`) — without per-type imports.
+ *  Window functions live in a separate builtin-only registry with no UDF registration path and
+ *  carry no scalar/aggregate/TVF `functionSchema` on these nodes, so they are inherently
+ *  replicable and are never flagged. Consumed only when the backing host declares
+ *  `requiresReplicableDerivations` (see {@link MaterializedViewManager.buildMaintenancePlan}). */
+export function findNonReplicableFunction(node) {
+    if ('functionSchema' in node) {
+        const schema = node.functionSchema;
+        if (schema.replicable !== true)
+            return schema.name;
+    }
+    for (const child of node.getChildren()) {
+        const found = findNonReplicableFunction(child);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+/** The built-in collation names. These are pure JS string operations (`<`/`>`,
+ *  locale-independent `toLowerCase()`, ASCII-space trim), so they are bit-identical
+ *  across peers' JS engines and auto-qualify as REPLICABLE — exactly parallel to why
+ *  built-in functions do. A custom collation must opt in with `replicable: true` at
+ *  registration. Short-circuiting on name (regardless of `collationSource`) keeps the
+ *  walk free of rank reasoning: a `default` BINARY and an `explicit` NOCASE both pass;
+ *  only a custom name is ever subjected to `_isCollationReplicable`. */
+const BUILTIN_COLLATION_NAMES = new Set(['BINARY', 'NOCASE', 'RTRIM']);
+/** True when `collation` is a non-builtin name the database does not assert REPLICABLE.
+ *  `undefined`/builtin/replicable ⇒ not offending. */
+function collationIsOffending(collation, db) {
+    if (collation === undefined)
+        return false;
+    const norm = normalizeCollationName(collation);
+    if (BUILTIN_COLLATION_NAMES.has(norm))
+        return false;
+    return !db._isCollationReplicable(norm);
+}
+/**
+ * The collation analogue of {@link findNonReplicableFunction}: return the NAME of the
+ * first collation that governs derived bytes and is neither built-in nor declared
+ * REPLICABLE, or `undefined` when every collation qualifies. Two sources, soundness-first
+ * (any non-builtin non-replicable collation anywhere rejects — see the soundness note in
+ * `replicable-collation-class`):
+ *
+ *  1. **Body scalars** — every fold/order/key site (explicit `COLLATE`, a declared/default
+ *     column collation, a comparison's effective collation, ORDER BY / GROUP BY / DISTINCT
+ *     keys) resolves through some scalar node whose `getType().collationName` carries the
+ *     name. One `getChildren()` walk reading that field uniformly reaches them all, including
+ *     nested COLLATE, subquery/CTE/set-op legs, and MV-over-MV bodies (whose source columns
+ *     carry the producing backing's published collation).
+ *  2. **Backing key** — a custom collation can govern the backing key MERGE without appearing
+ *     on any body scalar type (a maintained table declared with an explicit
+ *     `UNIQUE (… COLLATE custom)` or PK collation the SELECT body never names). The body walk
+ *     alone would miss it, so the maintained table's own PK column collations + declared
+ *     secondary UNIQUE per-column enforcement collations (resolving an index-derived override
+ *     via {@link uniqueEnforcementCollations}) are checked directly — the robust closure.
+ *
+ * Consumed only when the backing host declares `requiresReplicableDerivations`.
+ */
+export function findNonReplicableCollation(node, mv, db) {
+    const bodyOffender = findNonReplicableBodyCollation(node, db);
+    if (bodyOffender !== undefined)
+        return bodyOffender;
+    return findNonReplicableKeyCollation(mv, db);
+}
+/** Source 1: walk the plan; first scalar node whose resolved `collationName` is a
+ *  non-builtin non-replicable collation. Mirrors {@link findNonReplicableFunction}'s
+ *  recursion so every body position is reached. */
+function findNonReplicableBodyCollation(node, db) {
+    if (isScalarNode(node)) {
+        const collation = node.getType().collationName;
+        if (collationIsOffending(collation, db))
+            return normalizeCollationName(collation);
+    }
+    for (const child of node.getChildren()) {
+        const found = findNonReplicableBodyCollation(child, db);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+/** Source 2: the maintained table's backing-key collations — PK column collations and
+ *  declared secondary UNIQUE per-column enforcement collations. First non-builtin
+ *  non-replicable name returns. */
+function findNonReplicableKeyCollation(mv, db) {
+    for (const pk of mv.primaryKeyDefinition) {
+        if (collationIsOffending(pk.collation, db))
+            return normalizeCollationName(pk.collation);
+    }
+    for (const uc of mv.uniqueConstraints ?? []) {
+        for (const collation of uniqueEnforcementCollations(mv, uc)) {
+            if (collationIsOffending(collation, db))
+                return normalizeCollationName(collation);
+        }
+    }
+    return undefined;
+}
+/** Canonical, order-stable, bigint-safe string for a key tuple — used to dedup the
+ *  distinct affected backing keys of a single change in the residual-recompute arm. */
+export function canonKeyValues(values) {
+    return JSON.stringify(values, (_k, v) => (typeof v === 'bigint' ? `${v}n` : v));
+}
+/** Aggregate node types (logical + physical) — the analyzed plan may carry any. */
+const AGGREGATE_NODE_TYPES = new Set([
+    PlanNodeType.Aggregate,
+    PlanNodeType.StreamAggregate,
+    PlanNodeType.HashAggregate,
+]);
+/** Find the first aggregate node anywhere in the plan. */
+export function findAggregate(node) {
+    if (AGGREGATE_NODE_TYPES.has(node.nodeType))
+        return node;
+    for (const child of node.getChildren()) {
+        const found = findAggregate(child);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+/**
+ * Join-bearing PlanNodeTypes (logical + physical). `optimizeForAnalysis` stops
+ * before physical join selection, so the analyzed plan carries the logical
+ * {@link PlanNodeType.Join}; the physical variants are included so the
+ * eligibility gate stays correct if analysis ever surfaces them.
+ */
+const JOIN_NODE_TYPES = new Set([
+    PlanNodeType.Join,
+    PlanNodeType.NestedLoopJoin,
+    PlanNodeType.HashJoin,
+    PlanNodeType.MergeJoin,
+    PlanNodeType.FanOutLookupJoin,
+    PlanNodeType.AsofScan,
+]);
+/** True if any node in the plan has the given type (recursive `getChildren` walk). */
+export function containsNodeType(node, type) {
+    if (node.nodeType === type)
+        return true;
+    for (const child of node.getChildren()) {
+        if (containsNodeType(child, type))
+            return true;
+    }
+    return false;
+}
+/** True if the plan carries any join node (logical or physical). Used by the
+ *  row-time gate, which is single-source — any join is ineligible. */
+export function containsAnyJoin(node) {
+    for (const t of JOIN_NODE_TYPES) {
+        if (containsNodeType(node, t))
+            return true;
+    }
+    return false;
+}
+/** Count nodes of the given type (recursive `getChildren` walk). Used by the
+ *  lateral-TVF gate to reject nested/multiple TVFs. */
+export function countNodeType(node, type) {
+    let n = node.nodeType === type ? 1 : 0;
+    for (const child of node.getChildren())
+        n += countNodeType(child, type);
+    return n;
+}
+/** Count join nodes (logical + physical) in the plan — used to reject a chained
+ *  lateral join (the admitted lateral-TVF shape carries exactly one). */
+export function countJoins(node) {
+    let n = 0;
+    for (const t of JOIN_NODE_TYPES)
+        n += countNodeType(node, t);
+    return n;
+}
+/** Find the first {@link TableFunctionCallNode} anywhere in the plan, or `undefined`. */
+export function findTableFunctionCall(node) {
+    if (node instanceof TableFunctionCallNode)
+        return node;
+    for (const child of node.getChildren()) {
+        const found = findTableFunctionCall(child);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+/** Collect `relationKey → TableReferenceNode` over a plan. */
+export function collectTableRefs(node, out = new Map()) {
+    if (node instanceof TableReferenceNode) {
+        const base = `${node.tableSchema.schemaName}.${node.tableSchema.name}`.toLowerCase();
+        out.set(`${base}#${node.id ?? 'unknown'}`, node);
+    }
+    for (const child of node.getChildren())
+        collectTableRefs(child, out);
+    return out;
+}
+/**
+ * Merge attribute provenance (output attr id → producing scalar expr) from every
+ * node that exposes it. Physical aggregates expose `getProducingExprs()`; the
+ * logical {@link AggregateNode} present in the pre-physical analyzed plan does
+ * not, so its group-by → output-attr mapping is reconstructed directly here.
+ */
+export function collectProducingExprs(node, out = new Map()) {
+    const fn = node.getProducingExprs;
+    if (typeof fn === 'function') {
+        for (const [attrId, expr] of fn.call(node)) {
+            if (!out.has(attrId))
+                out.set(attrId, expr);
+        }
+    }
+    else if (node instanceof AggregateNode) {
+        const attrs = node.getAttributes();
+        node.groupBy.forEach((expr, i) => {
+            const attr = attrs[i];
+            if (attr && !out.has(attr.id))
+                out.set(attr.id, expr);
+        });
+        node.aggregates.forEach((agg, i) => {
+            const attr = attrs[node.groupBy.length + i];
+            if (attr && !out.has(attr.id))
+                out.set(attr.id, agg.expression);
+        });
+    }
+    for (const child of node.getChildren())
+        collectProducingExprs(child, out);
+    return out;
+}
+/**
+ * Transitive provenance: chase an output-attr → producing `ColumnReference` chain (a
+ * Project-over-Aggregate or a passthrough-through-Join adds a hop the single-hop
+ * {@link resolveSourceCol} cannot follow) until landing on a base-source column, or
+ * `undefined` (e.g. a TVF-output column with no base-source identity). Shared by the
+ * aggregate-residual and lateral-TVF arms.
+ */
+export function resolveTransitiveSourceCol(attrId, sourceAttrToCol, producingByAttrId) {
+    const seen = new Set();
+    let cur = attrId;
+    while (cur !== undefined && !seen.has(cur)) {
+        seen.add(cur);
+        const direct = sourceAttrToCol.get(cur);
+        if (direct !== undefined)
+            return direct;
+        const expr = producingByAttrId.get(cur);
+        if (expr instanceof ColumnReferenceNode) {
+            cur = expr.attributeId;
+            continue;
+        }
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * True iff the analyzed join body's WHERE references the lookup table `P` (or any base other
+ * than the driving `T`) — the classification the join-residual arm uses to decide whether the
+ * lookup side must be delete-capable (see {@link MaterializedViewManager.buildJoinResidualPlan}).
+ * The body WHERE — possibly split by predicate-pushdown — surfaces as one or more
+ * {@link FilterNode}s above/around the join; the join's own `ON` condition lives inside the
+ * JoinNode (not a Filter) and so is excluded. Each column a filter predicate references is
+ * resolved against `T`'s attribute→source-column map (transitively); a reference that does NOT
+ * resolve to a `T` column is a `P` (the arm requires exactly two base refs, `T` and `P`) — or
+ * otherwise non-`T` — reference. Conservative by construction: an unresolved reference counts as
+ * lookup-referencing, so the cheaper `T`-only upsert-only path is taken only when **every**
+ * filter column provably belongs to `T`.
+ */
+export function bodyWhereReferencesLookup(analyzed, tAttrToCol, producingByAttrId) {
+    const filterAttrs = new Set();
+    collectFilterPredicateAttrs(analyzed, filterAttrs);
+    for (const attrId of filterAttrs) {
+        if (resolveTransitiveSourceCol(attrId, tAttrToCol, producingByAttrId) === undefined)
+            return true;
+    }
+    return false;
+}
+/** Collect every attribute id referenced by a ColumnReferenceNode inside any {@link FilterNode}
+ *  predicate in the plan (the body WHERE; the join `ON` condition is not a Filter). */
+function collectFilterPredicateAttrs(node, out) {
+    if (node instanceof FilterNode)
+        collectColumnRefAttrs(node.predicate, out);
+    for (const child of node.getChildren())
+        collectFilterPredicateAttrs(child, out);
+}
+/** Collect every {@link ColumnReferenceNode} attribute id in a scalar subtree. */
+function collectColumnRefAttrs(node, out) {
+    if (node instanceof ColumnReferenceNode)
+        out.add(node.attributeId);
+    for (const child of node.getChildren())
+        collectColumnRefAttrs(child, out);
+}
+/**
+ * True iff any {@link FilterNode} predicate in the body (the body WHERE) is non-deterministic.
+ * The join-residual arm embeds the body WHERE in every residual (forward, in-scope reverse, and
+ * — when delete-capable — membership), so a volatile predicate (`random()`/`now()`/a volatile
+ * UDF) would make them irreproducible and diverge from the plain view. The arm therefore declines
+ * such a body (returns `null` → the full-rebuild floor, which applies the **pragma-gated**
+ * whole-body determinism reject — rejected without `pragma nondeterministic_schema`, accepted as a
+ * wholesale rebuild with it), preserving the pre-WHERE-widening behavior rather than building an
+ * unsound bounded-delta residual.
+ */
+export function bodyWhereIsNonDeterministic(analyzed) {
+    const visit = (node) => {
+        if (node instanceof FilterNode && !checkDeterministic(node.predicate).valid)
+            return true;
+        for (const child of node.getChildren()) {
+            if (visit(child))
+                return true;
+        }
+        return false;
+    };
+    return visit(analyzed);
+}
+/** Read the output attributes of a block's final relational statement. */
+export function relationalAttributes(block) {
+    const children = block.getChildren();
+    for (let i = children.length - 1; i >= 0; i--) {
+        const child = children[i];
+        if (typeof child.getAttributes === 'function')
+            return child.getAttributes();
+    }
+    return undefined;
+}
+/** The root relational node of a block's final relational statement — the node whose
+ *  attributes {@link relationalAttributes} reads — or `undefined`. Feeds the shared
+ *  coverage-prover join predicates ({@link proveOneToOneJoin}) for the join-residual arm. */
+export function rootRelationalNode(block) {
+    const children = block.getChildren();
+    for (let i = children.length - 1; i >= 0; i--) {
+        const child = children[i];
+        if (isRelationalNode(child))
+            return child;
+    }
+    return undefined;
+}
+/**
+ * The diagnostic for a create-time **hard** reject — one of the four non-shape rejections
+ * the cost-gated-with-floor model keeps (non-determinism, bag/no-key, no relational output,
+ * size). Names the MV and steers to a plain `view` (live re-evaluation) or
+ * `create table ... as <body>` (a one-off snapshot) — never a refresh policy, never an
+ * internal implementation detail. Used by the arm builders (for their arm-specific
+ * determinism diagnostic) and by {@link MaterializedViewManager.buildFullRebuildPlan}.
+ */
+export function cannotMaterialize(mvName, detail) {
+    return new QuereusError(`materialized view '${mvName}' cannot be materialized: ${detail}. For this body, use a `
+        + `plain 'create view' (live re-evaluation) or 'create table ... as <body>' (a one-off snapshot)`, StatusCode.UNSUPPORTED);
+}
+/**
+ * The diagnostic for the create-time **replicable-determinism** reject — distinct from
+ * {@link cannotMaterialize} because the fix here is not "use a plain view": the body is
+ * fine, it just calls a function the backing host requires be REPLICABLE. So this names the
+ * function and steers to declaring it `replicable: true` at registration (built-ins qualify
+ * automatically). Fires only when the resolved backing host declares
+ * `requiresReplicableDerivations`. `StatusCode.UNSUPPORTED`.
+ */
+export function nonReplicableDerivationError(mvName, fnName) {
+    return new QuereusError(`materialized view '${mvName}' cannot be materialized on this backing host: it calls non-replicable `
+        + `function '${fnName}'. This host requires every function in the body to be bit-identical across `
+        + `peers/platforms; declare the function \`replicable: true\` at registration (built-in functions `
+        + `qualify automatically)`, StatusCode.UNSUPPORTED);
+}
+/**
+ * The diagnostic for the create-time **replicable-collation** reject — the collation
+ * analogue of {@link nonReplicableDerivationError}. The body is fine; it just folds or
+ * orders (comparison / ORDER BY / GROUP BY / DISTINCT / backing key) under a collation the
+ * backing host requires be bit-identical across peers — so this does NOT steer to a plain
+ * view. It names the collation and steers to declaring it `replicable: true` at registration
+ * (built-in collations qualify automatically). Fires only when the resolved backing host
+ * declares `requiresReplicableDerivations`. `StatusCode.UNSUPPORTED`.
+ */
+export function nonReplicableCollationDerivationError(mvName, collationName) {
+    return new QuereusError(`materialized view '${mvName}' cannot be materialized on this backing host: it folds or orders under `
+        + `non-replicable collation '${collationName}'. This host requires every collation in the body to be `
+        + `bit-identical across peers/platforms; declare the collation \`replicable: true\` at registration `
+        + `(built-in collations qualify automatically)`, StatusCode.UNSUPPORTED);
+}
+/**
+ * True iff a computed projection expression can be evaluated as a pure function of the
+ * changed source row — i.e. it contains no subquery / relational subtree (cross-row) and
+ * every column reference resolves to a source column (no correlated / outer reference).
+ * This is the "shape" gate distinct from the determinism gate (a determinism failure is
+ * caught earlier by `checkDeterministic`); a `false` here is a `null` fall-through to the
+ * full-rebuild floor, not a hard reject.
+ */
+export function isSingleRowEvaluable(expr, sourceDescriptor) {
+    const visit = (node) => {
+        if (node !== expr && isRelationalNode(node))
+            return false; // a subquery / relational subtree
+        if (node instanceof ColumnReferenceNode && sourceDescriptor[node.attributeId] === undefined) {
+            return false; // references a value outside the source row
+        }
+        for (const child of node.getChildren()) {
+            if (!visit(child))
+                return false;
+        }
+        return true;
+    };
+    return visit(expr);
+}
+/**
+ * Compile a deterministic scalar plan node into a per-source-row evaluator by reusing
+ * the runtime: emit the node once, then run it against a row context that maps each
+ * source attribute id to its column index in the changed row. Reusing the runtime
+ * (rather than a hand-rolled scalar interpreter) guarantees a computed backing value is
+ * byte-for-byte what `select <body>` would produce — the materialized-view ≡ view
+ * contract. The gated forms (deterministic scalars over a single row, no subqueries —
+ * see {@link assertSingleRowEvaluable}) resolve synchronously; a Promise result would
+ * signal an unsupported async form and is surfaced loudly rather than silently awaited.
+ */
+export function compileSourceRowEvaluator(db, expr, sourceDescriptor) {
+    const instruction = emitPlanNode(expr, new EmissionContext(db));
+    const scheduler = new Scheduler(instruction);
+    const context = new RowContextMap();
+    let currentRow = [];
+    // Installed once; the getter reads the closed-over `currentRow`, refreshed per call.
+    context.set(sourceDescriptor, () => currentRow);
+    const rctx = {
+        db,
+        stmt: undefined,
+        params: {},
+        context,
+        tableContexts: new Map(),
+        enableMetrics: false,
+    };
+    return (row) => {
+        currentRow = row;
+        const result = scheduler.run(rctx);
+        if (result instanceof Promise) {
+            throw new QuereusError('a row-time projection expression evaluated asynchronously (unexpected for a gated single-row scalar)', StatusCode.INTERNAL);
+        }
+        return result;
+    };
+}
+//# sourceMappingURL=database-materialized-views-analysis.js.map

package/dist/src/core/database-materialized-views-analysis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-materialized-views-analysis.js","sourceRoot":"","sources":["../../../src/core/database-materialized-views-analysis.ts"],"names":[],"mappings":"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"}