@memberjunction/codegen-lib 6.1.0-edge.1 → 6.1.0-edge.3

package/dist/Database/materializationAnalysis.js

@@ -0,0 +1,415 @@
+import { SQLParser } from '@memberjunction/sql-parser';
+import { isObject, nodeType, qualifiedColumn, identifiersEqual, isSetOperationRoot, soleStatement, } from './materializationSqlAst.js';
+/**
+ * Name of the synthetic surrogate key column added to every query-materialized table in v1.
+ * Namespaced to avoid colliding with a query's own output columns.
+ */
+export const MATERIALIZATION_SURROGATE_COLUMN = '__mj_MaterializedRowID';
+/** Default surrogate column SQL type (SQL Server). Callers on other engines pass their own. */
+export const DEFAULT_SURROGATE_SQL_TYPE = 'int IDENTITY(1,1)';
+/**
+ * Analyzes a query for v1 materialization. Pure function — no DB/IO — so it is fully unit-testable.
+ *
+ * Qualifying rule (§9 / §10, asymmetric-risk: default to NOT materializable when unsure):
+ *   - parameterized queries do not qualify in v1 (deferred);
+ *   - a query with no declared output fields does not qualify (run query analysis first);
+ *   - a query whose output already contains a column named like the surrogate does not qualify
+ *     (we won't silently shadow it).
+ *
+ * On success, returns the column spec with a synthetic surrogate PK prepended; the query's
+ * own output columns are emitted as nullable snapshot columns (a snapshot may contain NULLs).
+ */
+export function analyzeQueryForMaterialization(opts) {
+    const surrogateColumnName = MATERIALIZATION_SURROGATE_COLUMN;
+    const surrogateSQLType = opts.surrogateSQLType ?? DEFAULT_SURROGATE_SQL_TYPE;
+    const fail = (reason) => ({ qualifies: false, reason, columns: [], surrogateColumnName });
+    if (opts.isParameterized) {
+        return fail(`query "${opts.queryName}" is parameterized — not materializable in v1 (deferred to Phase 2)`);
+    }
+    if (!opts.fields || opts.fields.length === 0) {
+        return fail(`query "${opts.queryName}" has no declared output fields — run query field analysis before materializing`);
+    }
+    if (opts.fields.some((f) => f.Name.trim().toLowerCase() === surrogateColumnName.toLowerCase())) {
+        return fail(`query "${opts.queryName}" already has an output column named "${surrogateColumnName}" — cannot add the surrogate key without shadowing it`);
+    }
+    const surrogate = {
+        Name: surrogateColumnName,
+        SQLType: surrogateSQLType,
+        Nullable: false,
+        IsPrimaryKey: true,
+    };
+    // Query output columns become nullable snapshot columns (the result set may contain NULLs).
+    const dataColumns = opts.fields.map((f) => ({
+        Name: f.Name,
+        SQLType: f.SQLFullType,
+        Nullable: true,
+        IsPrimaryKey: false,
+    }));
+    return { qualifies: true, columns: [surrogate, ...dataColumns], surrogateColumnName };
+}
+/**
+ * Phase 2 read-time-injectable operators — the SAFE whitelist. A `column <op> value` predicate in this
+ * set can be faithfully re-applied against the broad materialized table with a bound parameter (§3 of the
+ * Phase-2 plan). `LIKE`/`IS`/`BETWEEN` and their negations are intentionally EXCLUDED in v1 (subtler
+ * pattern/null/two-operand semantics) — a query using them stays live-only, which is harmless (§10).
+ */
+export const SAFE_READ_FILTER_OPERATORS = new Set([
+    '=', '!=', '<>', '<', '>', '<=', '>=', 'IN', 'NOT IN',
+]);
+/**
+ * Decides the {@link ParamMode} for a (possibly parameterized) query from its per-param
+ * classifications — the §9 qualifying rule under the §10 asymmetric-risk posture
+ * (**default to NOT materializable unless every param is provably safe**). Pure — no DB/IO/LLM.
+ *
+ * Rules:
+ *  - no params → `None` (qualifies; caller materializes the static query).
+ *  - any `Unbounded` param (Bucket 3) → refuse (author can bind it to a fixed value → BoundFixed,
+ *    which arrives here as effectively unparameterized).
+ *  - `RowFilter` (Bucket 1) → the `filterColumn` MUST be present in the materialized output, else
+ *    refuse (filtering on a projected-away column would be unsound).
+ *  - `Structural` (Bucket 2) → only when `allowPerValueCache` is enabled AND the verifier bounded
+ *    the domain; otherwise refuse (recompute live). Open decision §17 — defaults OFF.
+ *  - a mix of row-filter and structural params is not modeled in v1 → refuse.
+ */
+export function qualifyParameterizedQuery(opts) {
+    const { queryName, params, outputColumns } = opts;
+    const allowPerValueCache = opts.allowPerValueCache ?? false;
+    const allowRowFilterBroad = opts.allowRowFilterBroad ?? false;
+    const refuse = (reason) => ({ qualifies: false, reason, paramMode: 'None', rowFilterColumns: [], readFilterSpec: [] });
+    if (!params || params.length === 0) {
+        return { qualifies: true, paramMode: 'None', rowFilterColumns: [], readFilterSpec: [] };
+    }
+    const outputSet = new Set(outputColumns.map((c) => c.trim().toLowerCase()));
+    const rowFilterColumns = [];
+    const readFilterSpec = [];
+    let hasStructural = false;
+    for (const p of params) {
+        if (p.role === 'Unbounded') {
+            return refuse(`query "${queryName}" param "${p.name}" is unbounded/arbitrary structural (Bucket 3) — not materializable; bind it to a fixed value (BoundFixed) to materialize a specific instance`);
+        }
+        if (p.role === 'Structural') {
+            hasStructural = true;
+            if (!allowPerValueCache) {
+                return refuse(`query "${queryName}" param "${p.name}" is structural (Bucket 2) and per-value cache is disabled — recompute live, not materializable`);
+            }
+            if (!p.boundedDomain || p.boundedDomain.length === 0) {
+                return refuse(`query "${queryName}" param "${p.name}" is structural with no bounded domain — cannot enumerate a per-value cache safely`);
+            }
+            continue;
+        }
+        // RowFilter (Bucket 1): the filter column must be physically present in the materialized output (§9/§10).
+        if (!p.filterColumn) {
+            return refuse(`query "${queryName}" param "${p.name}" classified RowFilter but no filter column was resolved — refusing under uncertainty`);
+        }
+        if (!outputSet.has(p.filterColumn.trim().toLowerCase())) {
+            return refuse(`query "${queryName}" param "${p.name}" filters on column "${p.filterColumn}", which is not in the materialized output — disqualify (or project that column into the query)`);
+        }
+        // Phase 2 read-time-safety gate: only mint a RowFilterBroad materialization when the operator is
+        // provably reconstructable against the broad table with a bound param (§3). Anything outside the
+        // whitelist (LIKE/IS/BETWEEN, or an unresolved operator) stays live-only — harmless (§10).
+        const op = p.filterOperator;
+        if (!op || !SAFE_READ_FILTER_OPERATORS.has(op)) {
+            return refuse(`query "${queryName}" param "${p.name}" filters on "${p.filterColumn}" with operator "${op ?? '(unresolved)'}", which is not in the read-time-safe operator set {${[...SAFE_READ_FILTER_OPERATORS].join(', ')}} — deferred; the query stays live-only`);
+        }
+        // Operator/value-shape consistency: IN/NOT IN must carry a list value; every other op a scalar.
+        // A mismatch means our AST reading is inconsistent → refuse under uncertainty rather than guess.
+        const isListOp = op === 'IN' || op === 'NOT IN';
+        const expectedKind = isListOp ? 'list' : 'scalar';
+        if (p.filterKind !== expectedKind) {
+            return refuse(`query "${queryName}" param "${p.name}" operator "${op}" expects a ${expectedKind} value but the verifier reported "${p.filterKind ?? '(none)'}" — refusing under uncertainty`);
+        }
+        // Qualifier-aware binding proof: the predicate's SOURCE column must provably be the very column the
+        // identically-named materialized OUTPUT column carries. A bare-name match is not that proof (join
+        // collision / alias rebinding) — and neither is broad-render's removal count, which is exactly 1 in
+        // both wrong cases. Without the rendered SQL there is nothing to prove it with → refuse (§10).
+        if (!opts.sql || !opts.dialect) {
+            return refuse(`query "${queryName}" param "${p.name}" filters on "${p.filterColumn}" but no rendered SQL was supplied to prove that predicate binds to the materialized output column of the same name — refusing under uncertainty (the query stays live-only)`);
+        }
+        const binding = proveFilterColumnBinding({ sql: opts.sql, dialect: opts.dialect, filterColumn: p.filterColumn });
+        if (!binding.provable) {
+            return refuse(`query "${queryName}" param "${p.name}" filters on "${p.filterColumn}" but that predicate cannot be proven to bind to the materialized output column of the same name: ${binding.reason} — a materialized read would filter a different column than the live query. Refusing (the query stays live-only).`);
+        }
+        rowFilterColumns.push(p.filterColumn);
+        readFilterSpec.push({ column: p.filterColumn, operator: op, paramName: p.name, kind: expectedKind });
+    }
+    if (rowFilterColumns.length > 0 && hasStructural) {
+        return refuse(`query "${queryName}" mixes row-filter and structural params — not modeled in v1; refusing under uncertainty`);
+    }
+    if (hasStructural) {
+        return { qualifies: true, paramMode: 'PerValueCache', rowFilterColumns: [], readFilterSpec: [] };
+    }
+    if (!allowRowFilterBroad) {
+        // Enablement switch (Phase 2). When off, refuse row-filter queries to live-only — a defense-in-depth
+        // kill switch even though the read-time predicate injection is now implemented in the provider.
+        return refuse(`query "${queryName}" has row-filter parameter(s) on [${rowFilterColumns.join(', ')}] (Bucket 1 / RowFilterBroad) — parameterized row-filter materialization is not enabled in this build; the query stays live-only`);
+    }
+    return { qualifies: true, paramMode: 'RowFilterBroad', rowFilterColumns, readFilterSpec };
+}
+// AST-walking primitives are shared with the param verifier + broad-render via ./materializationSqlAst
+// (single source of truth — see that module's header). extractGroupByTerms is GROUP-BY-specific and stays here.
+/**
+ * Extracts the top-level GROUP BY term nodes, normalizing node-sql-parser's dialect-varying shapes.
+ * Returns `[]` (→ no key → full rebuild) for anything it cannot read as a single plain SELECT's GROUP BY.
+ *
+ * **Set-operation refusal (soundness-critical).** A `UNION` / `UNION ALL` / `EXCEPT` / `INTERSECT` parses to
+ * a SINGLE `select` root carrying `set_op`/`_next`, whose `groupby` and `columns` describe **only the first
+ * branch** (see {@link isSetOperationRoot}). Reading that root would report the first branch's grouping
+ * columns as the key of the WHOLE query — but the combined result legitimately contains one row per
+ * (branch × group), so those "key" columns are NOT unique across the result. The caller would then hash the
+ * key into the surrogate PK and pick the MERGE-upsert Incremental path, where the branches collide on the
+ * same hash and one silently overwrites the other — permanently wrong aggregates with no error. Refuse.
+ */
+function extractGroupByTerms(stmt) {
+    const gb = stmt.groupby;
+    if (isObject(gb) && Array.isArray(gb.columns))
+        return gb.columns; // observed shape: { columns: [...] }
+    if (Array.isArray(gb))
+        return gb; // some dialects emit a bare array
+    if (isObject(gb) && Array.isArray(gb.value))
+        return gb.value; // …or { value: [...] }
+    return [];
+}
+/**
+ * Parses `sql` and returns its sole plain-SELECT statement root, or null when that is not what it is —
+ * unparseable, multi-statement, a non-SELECT, or a SET OPERATION (see {@link isSetOperationRoot}, whose
+ * first-branch-only view every analyzer here must refuse). Every analyzer in this module goes through
+ * this one gate so no future reader can reintroduce a bare `ast[0]` set-op blind spot.
+ */
+function parseSoleSelectRoot(sql, dialect) {
+    const parsed = SQLParser.Astify(sql, dialect);
+    if (!parsed.astParsed || parsed.ast == null)
+        return null;
+    const stmt = soleStatement(parsed.ast);
+    if (!isObject(stmt) || nodeType(stmt) !== 'select')
+        return null;
+    if (isSetOperationRoot(stmt))
+        return null;
+    return stmt;
+}
+/** Number of relations in a SELECT's FROM clause (each JOIN / comma source counts). 0 when unreadable. */
+function fromSourceCount(stmt) {
+    return Array.isArray(stmt.from) ? stmt.from.length : 0;
+}
+/**
+ * Whether a SELECT-list column reference and another reference to the same bare name (a GROUP BY term, a
+ * WHERE predicate operand) provably denote the SAME source column.
+ *
+ * With a SINGLE FROM relation, every reference to a given name necessarily resolves to that one relation,
+ * so the qualifier carries no information and the bare-name match is already a proof. With a JOIN the bare
+ * name is ambiguous — `o.Status` and `c.Status` are different columns — so BOTH sides must carry the same
+ * explicit qualifier; an unqualified reference on either side is unprovable and refuses (§10).
+ */
+function sourceRefsMatch(selectQualifier, refQualifier, singleSource) {
+    if (singleSource)
+        return true;
+    return identifiersEqual(selectQualifier, refQualifier);
+}
+/**
+ * Collects the table qualifiers of every reference to `column` inside an AST subtree, in encounter order.
+ * A `null` entry means an unqualified reference. Used to read the WHERE clause's view of a filter column.
+ */
+function collectColumnQualifiers(node, column, found) {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            collectColumnQualifiers(child, column, found);
+        return;
+    }
+    if (!isObject(node))
+        return;
+    const qc = qualifiedColumn(node);
+    if (qc != null) {
+        if (identifiersEqual(qc.column, column))
+            found.push(qc.qualifier);
+        return; // a column_ref has no further column_ref descendants
+    }
+    for (const [k, v] of Object.entries(node)) {
+        if (k !== 'loc')
+            collectColumnQualifiers(v, column, found);
+    }
+}
+/**
+ * Proves that a verified row-filter predicate on `filterColumn` refers to **exactly** the materialized
+ * output column of that same name — the gap a bare-name `outputColumns.includes(filterColumn)` check leaves
+ * open, and which nothing downstream can close.
+ *
+ * Two silently-wrong-data cases motivate it, both of which pass every existing guard (in particular the
+ * broad-render count guard, since exactly ONE predicate is stripped in each):
+ *
+ *  - **Join collision** — `SELECT o.ID, c.Status FROM Orders o JOIN Customers c … WHERE o.Status = {{s}}`.
+ *    The output `Status` is the CUSTOMER's; the predicate is the ORDER's. The materialized read emits
+ *    `WHERE [Status] = @p0` against the customer's value.
+ *  - **Alias rebinding** — `SELECT ID, ShipRegion AS BillRegion FROM Orders WHERE BillRegion = {{r}}` on a
+ *    table that has BOTH columns. The materialized `BillRegion` column holds `ShipRegion` values, so the
+ *    read filters `ShipRegion = 'East'` while live filters `BillRegion = 'East'`.
+ *
+ * Refuses (never guesses) unless ALL of the following hold — falling back to the live query, always correct:
+ *  1. `sql` parses to a single plain SELECT (not multi-statement, not a set operation — a `UNION` root
+ *     exposes only its first branch, so nothing about the whole result can be proven from it);
+ *  2. the SELECT list is readable and not a wildcard (`SELECT *` hides the real output↔source mapping);
+ *  3. exactly ONE output column is named `filterColumn` (two would make the read-time predicate ambiguous);
+ *  4. that output column is a plain column reference, not a computed expression;
+ *  5. it projects the SAME source column name (no alias rebinding);
+ *  6. the WHERE clause references `filterColumn` under a single, consistent qualifier; and
+ *  7. that qualifier provably denotes the same relation as the output column's — trivially true for a
+ *     single-relation FROM, otherwise both must carry the same explicit qualifier ({@link sourceRefsMatch}).
+ *
+ * Pure — no DB/IO.
+ */
+export function proveFilterColumnBinding(opts) {
+    const { sql, dialect, filterColumn } = opts;
+    const refuse = (reason) => ({ provable: false, reason });
+    if (!sql || sql.trim().length === 0)
+        return refuse('no rendered SQL to analyze');
+    let root;
+    let selectCols;
+    try {
+        root = parseSoleSelectRoot(sql, dialect);
+        selectCols = SQLParser.ExtractSelectColumns(sql, dialect);
+    }
+    catch {
+        return refuse('the rendered SQL could not be parsed');
+    }
+    if (root == null) {
+        return refuse('the rendered SQL is not a single plain SELECT (multi-statement, non-SELECT, or a UNION/EXCEPT/INTERSECT whose branches are not all visible)');
+    }
+    const outputCheck = resolveProvableOutputColumn(selectCols, filterColumn);
+    if (!outputCheck.provable)
+        return refuse(outputCheck.reason);
+    const output = outputCheck.column;
+    const qualifiers = [];
+    collectColumnQualifiers(root.where, filterColumn, qualifiers);
+    if (qualifiers.length === 0) {
+        return refuse(`the WHERE clause of the rendered SQL has no reference to a column named "${filterColumn}"`);
+    }
+    const distinct = new Set(qualifiers.map((q) => (q == null ? '' : q.trim().toLowerCase())));
+    if (distinct.size > 1) {
+        return refuse(`the WHERE clause references "${filterColumn}" under ${distinct.size} different table qualifiers — the parameter's predicate cannot be attributed to one of them`);
+    }
+    const predicateQualifier = qualifiers[0];
+    const singleSource = fromSourceCount(root) === 1;
+    if (!singleSource && (predicateQualifier == null || output.TableQualifier == null)) {
+        return refuse(`the query reads ${fromSourceCount(root)} relations and the ${predicateQualifier == null ? 'WHERE predicate on' : 'SELECT-list projection of'} "${filterColumn}" is unqualified, so the name cannot be attributed to a single source`);
+    }
+    if (!sourceRefsMatch(output.TableQualifier, predicateQualifier, singleSource)) {
+        return refuse(`the WHERE predicate filters "${predicateQualifier}.${filterColumn}" but the output column "${filterColumn}" projects "${output.TableQualifier}.${filterColumn}" — a different source column`);
+    }
+    return { provable: true };
+}
+/**
+ * Resolves the single SELECT-list output column that a read-time filter on `filterColumn` would target,
+ * or the reason it is not provably that source column (wildcard projection, duplicate/absent name,
+ * computed expression, or an alias rebinding a differently-named source column).
+ */
+function resolveProvableOutputColumn(selectCols, filterColumn) {
+    const no = (reason) => ({ provable: false, reason });
+    if (!selectCols || selectCols.length === 0) {
+        return no('the SELECT list could not be read');
+    }
+    if (selectCols.some((c) => c.OutputName === '*')) {
+        return no('the query projects a wildcard (SELECT *), so the output-to-source column mapping is unknown');
+    }
+    const matches = selectCols.filter((c) => identifiersEqual(c.OutputName, filterColumn));
+    if (matches.length === 0) {
+        return no(`no SELECT-list output column is named "${filterColumn}"`);
+    }
+    if (matches.length > 1) {
+        return no(`the SELECT list projects ${matches.length} output columns named "${filterColumn}"`);
+    }
+    const output = matches[0];
+    if (output.IsExpression) {
+        return no(`the output column "${filterColumn}" is a computed expression, not a plain projection of a source column`);
+    }
+    if (!identifiersEqual(output.SourceColumn, filterColumn)) {
+        return no(`the output column "${filterColumn}" is an ALIAS over source column "${output.SourceColumn}", so filtering the materialized "${filterColumn}" is not the same predicate as the live "${filterColumn}"`);
+    }
+    return { provable: true, column: output };
+}
+/**
+ * Phase 3: detect the combined KEY of an aggregation query (for the surrogate hash). Conservative and
+ * safe-by-default — returns the grouping columns as the key ONLY when it can confidently identify an
+ * aggregation whose key is expressible in the materialized output; ANY ambiguity → null, and the caller
+ * then uses the synthetic surrogate + full rebuild (always correct, just not incrementally optimizable —
+ * the §10 "refuse under uncertainty" bias applied to keying). See the inline comment for the exact rules;
+ * the key is built from the AST GROUP BY terms (not a SELECT-list split), so grouping expressions and
+ * grouped-but-unprojected columns both refuse rather than silently producing a too-narrow key.
+ */
+export function detectAggregationKeyColumns(opts) {
+    const { sql, dialect, fields } = opts;
+    if (!/\bgroup\s+by\b/i.test(sql))
+        return null; // no GROUP BY → not an aggregation key
+    // AST-level GROUP BY extraction (the "hardening follow-up" the heuristic promised) — robust vs. splitting
+    // the SELECT list, which can't tell a grouping EXPRESSION apart from an aggregate measure. Rules, all
+    // biased to refuse (null → synthetic surrogate + full rebuild, always correct; §10 "refuse under
+    // uncertainty"): (1) every grouping term must be a bare column reference — an expression grouping term
+    // (YEAR(date), a+b, CAST(…)) can't be reconstructed from the materialized output columns; (2) there must
+    // be at least one aggregate measure; (3) every grouping column must map to exactly one PROJECTED output
+    // column (so the key is expressible in the materialized table — a grouped-but-unprojected column would
+    // make the surrogate key too narrow and collide).
+    let root;
+    let selectCols;
+    try {
+        root = parseSoleSelectRoot(sql, dialect);
+        selectCols = SQLParser.ExtractSelectColumns(sql, dialect);
+    }
+    catch {
+        return null; // unparseable → not keyed (safe: synthetic surrogate + full rebuild)
+    }
+    if (root == null)
+        return null; // multi-statement / non-SELECT / set operation → refuse
+    const groupByTerms = extractGroupByTerms(root);
+    if (groupByTerms.length === 0 || !selectCols || selectCols.length === 0)
+        return null;
+    if (groupByTerms.some((t) => nodeType(t) !== 'column_ref'))
+        return null; // expression grouping → bail
+    if (!selectCols.some((c) => c.IsExpression))
+        return null; // no aggregate measure → not an aggregation
+    // (4) A grouping term is matched to a projected output column by SOURCE COLUMN NAME — which is ambiguous
+    // across a join (`GROUP BY o.Region` vs. a projected `c.Region` are different columns). Require the table
+    // qualifiers to agree whenever there is more than one FROM relation; see sourceRefsMatch.
+    const singleSource = fromSourceCount(root) === 1;
+    const fieldByOutput = new Map(fields.map((f) => [f.Name.trim().toLowerCase(), f]));
+    const key = [];
+    for (const term of groupByTerms) {
+        const gb = qualifiedColumn(term);
+        if (gb == null)
+            return null;
+        // The projected (non-expression) SELECT column whose pre-alias source column IS this grouping column.
+        const projected = selectCols.filter((c) => !c.IsExpression
+            && identifiersEqual(c.SourceColumn, gb.column)
+            && sourceRefsMatch(c.TableQualifier, gb.qualifier, singleSource));
+        if (projected.length !== 1)
+            return null; // unprojected (0) or ambiguous (>1) → bail
+        const f = fieldByOutput.get(projected[0].OutputName.trim().toLowerCase());
+        if (!f)
+            return null; // output column not in the materialized field set → bail
+        key.push({ name: f.Name, type: f.SQLFullType });
+    }
+    return key.length > 0 ? key : null;
+}
+/**
+ * Phase 4: is an aggregation's measure set PURELY ADDITIVE (only SUM / plain COUNT)? Drives the
+ * refresh-strategy choice: additive keyed aggregations use the MERGE-upsert `Incremental` path
+ * (in-place measure update, no row churn), non-additive ones use `DirtyGroupRecompute` (whole-group
+ * delete+reinsert). Conservative and safe-by-default: returns false on ANY sign of a non-additive
+ * aggregate (`AVG`/`MIN`/`MAX`/`STDEV*`/`VAR*`/`MEDIAN`/`PERCENTILE`/`*_AGG`, or `COUNT(DISTINCT …)`),
+ * and requires at least one additive aggregate to be present — anything ambiguous → false (the caller
+ * then uses DirtyGroupRecompute, which is correct for all measure types). Regex-based because the SQL
+ * parser doesn't expose per-measure expression text; the bias is toward the safe (non-additive) answer.
+ */
+export function detectAdditiveMeasures(sql) {
+    if (!sql)
+        return false;
+    const s = sql.replace(/\s+/g, ' ');
+    // Any non-additive aggregate present → not purely additive.
+    const nonAdditive = /\b(AVG|MIN|MAX|STDEV|STDEVP|VAR|VARP|VARIANCE|MEDIAN|PERCENTILE_CONT|PERCENTILE_DISC|STRING_AGG|ARRAY_AGG|GROUP_CONCAT)\s*\(/i;
+    if (nonAdditive.test(s))
+        return false;
+    // SUM(DISTINCT ...) and COUNT(DISTINCT ...) are non-additive — their per-group value can't be delta-combined
+    // for an in-place incremental upsert — even though SUM(x)/COUNT(*) are. (AVG/MIN/MAX/etc. are already
+    // rejected above regardless of DISTINCT.)
+    if (/\b(SUM|COUNT)\s*\(\s*DISTINCT\b/i.test(s))
+        return false;
+    // Require at least one genuinely additive aggregate.
+    return /\b(SUM|COUNT)\s*\(/i.test(s);
+}
+//# sourceMappingURL=materializationAnalysis.js.map

package/dist/Database/materializationAnalysis.js.map

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

package/dist/Database/materializationBroadRender.d.ts

@@ -0,0 +1,67 @@
+import type { SQLParserDialect } from '@memberjunction/sql-dialect';
+/**
+ * Phase 2d — broad-render for row-filter materialization
+ * (plan /plans/query-entity-materialization.md §6.4 "materialize broad, filter at read").
+ *
+ * A parameterized query classified `RowFilterBroad` (by Phase 2b/2c) is materialized **broad** —
+ * every row the query could return for any value of the row-filter parameter — and the filter is
+ * re-applied at read time as an ordinary predicate on the (projected) filter column. This module
+ * produces that broad source SQL by **removing** the row-filter predicate from a rendered query.
+ *
+ * **Why this is sound:** the verifier only classifies a parameter `RowFilter(column)` when its value
+ * varies a literal at a *clean top-level conjunctive* `WHERE` predicate on a single column, and the
+ * qualifier only accepts it when that column is in the materialized output. A top-level conjunctive
+ * `WHERE` predicate on a projected (for GROUP-BY queries, grouped) column commutes with the rest of
+ * the query, so stripping it and re-applying it as an outer filter is algebraically identical to
+ * running the query with that value.
+ *
+ * **The isolation hazard, and how we refuse it:** this matcher works on *rendered* SQL (the parameter
+ * is already a concrete literal) and is qualifier-blind, so it cannot by itself tell a parameter
+ * predicate apart from (a) a *static* predicate on the same column (`… WHERE Region = {{r}} AND Region
+ * <> 'Internal'`) or (b) a same-named column on another table (`o.Region = {{r}} AND c.Region = 'X'`).
+ * Blindly stripping every match would broaden the materialization beyond what the live query can ever
+ * return. Guard: the caller passes `expectedRemovals` = the number of row-filter *parameter* predicates
+ * the classifier found, and we strip only when the match count equals it **exactly**. Any deviation
+ * sets `ambiguous: true` and the caller refuses (query stays live-only) — the §10 "refuse under
+ * uncertainty" bias. So we remove **exactly** the parameter predicates, or we decline.
+ *
+ * Pure — parses with @memberjunction/sql-parser, mutates the WHERE AST, re-emits. No DB/IO.
+ */
+/** Outcome of stripping row-filter predicates from a rendered query. */
+export interface BroadRenderResult {
+    /** The broad SQL (row-filter predicates removed). Equals the input when nothing was removed. */
+    sql: string;
+    /** How many top-level conjunctive predicates on the row-filter columns were removed. */
+    removedCount: number;
+    /**
+     * True when `removedCount` does NOT equal the caller-supplied `expectedRemovals` (the number of
+     * row-filter *parameter* predicates the classifier identified). This means broad-render either
+     * matched MORE predicates than there are parameters (a static predicate on the same column, or a
+     * same-named column on another table — this matcher is qualifier-blind) or FEWER (a parameter
+     * predicate it could not find). In either case the parameter predicate cannot be cleanly isolated,
+     * so re-applying only the filter column at read time would include/exclude rows the live query
+     * never would — the caller MUST refuse to materialize. Always false when `expectedRemovals` is
+     * omitted (the matcher makes no exact-count claim).
+     */
+    ambiguous: boolean;
+}
+/**
+ * Produces the broad source SQL for a row-filter materialization by removing the top-level
+ * conjunctive `WHERE` predicate(s) on `rowFilterColumns` from a **rendered** (concrete, non-templated)
+ * query. Other conjuncts are preserved; if the row-filter predicates were the only ones, the `WHERE`
+ * is dropped entirely.
+ *
+ * Returns the input unchanged with `removedCount: 0` when the SQL cannot be parsed as a single
+ * simple SELECT, or when no matching predicate is found — the caller should treat `removedCount: 0`
+ * on a query it believes is RowFilterBroad as an anomaly worth refusing (a broad materialization
+ * that still carries the filter would be wrong).
+ *
+ * When `expectedRemovals` is supplied (the classifier's row-filter *parameter* count), the result's
+ * `ambiguous` flag is set whenever the actual match count differs from it — and when ambiguous, the
+ * original SQL is returned **unmodified** (never a partially/over-stripped query), so a caller that
+ * ignores the flag fails safe (it would then still carry the filter, which is refused upstream rather
+ * than silently broadened). Omit `expectedRemovals` to keep the legacy "strip all matches" behavior
+ * with `ambiguous` always false.
+ */
+export declare function buildBroadRowFilterSQL(renderedSQL: string, rowFilterColumns: string[], dialect: SQLParserDialect, expectedRemovals?: number): BroadRenderResult;
+//# sourceMappingURL=materializationBroadRender.d.ts.map

package/dist/Database/materializationBroadRender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"materializationBroadRender.d.ts","sourceRoot":"","sources":["../../src/Database/materializationBroadRender.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAMpE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,wEAAwE;AACxE,MAAM,WAAW,iBAAiB;IAC9B,gGAAgG;IAChG,GAAG,EAAE,MAAM,CAAC;IACZ,wFAAwF;IACxF,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;;;;;OASG;IACH,SAAS,EAAE,OAAO,CAAC;CACtB;AAsDD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAClC,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,EAAE,EAC1B,OAAO,EAAE,gBAAgB,EACzB,gBAAgB,CAAC,EAAE,MAAM,GAC1B,iBAAiB,CAoCnB"}

package/dist/Database/materializationBroadRender.js

@@ -0,0 +1,104 @@
+import { SQLParser } from '@memberjunction/sql-parser';
+import { COMPARISON_OPS, isObject, nodeType, isLiteralNode, columnName, isAllLiteralBag, } from './materializationSqlAst.js';
+/** Flattens a top-level AND-chain into its individual conjuncts (non-AND leaves). */
+function collectConjuncts(node) {
+    if (nodeType(node) === 'binary_expr' && isObject(node) && node.operator === 'AND') {
+        return [...collectConjuncts(node.left), ...collectConjuncts(node.right)];
+    }
+    return [node];
+}
+/**
+ * True when a conjunct is a removable row-filter predicate: a comparison `column <op> value`
+ * (or `column IN/BETWEEN (literals)`) where the column is one of `cols` and the other side is a
+ * literal / all-literal bag. Anything else (OR-expr, function, column=column, subquery) is kept.
+ */
+function isRemovablePredicate(conjunct, cols) {
+    if (nodeType(conjunct) !== 'binary_expr' || !isObject(conjunct)) {
+        return false;
+    }
+    const op = conjunct.operator;
+    if (typeof op !== 'string' || !COMPARISON_OPS.has(op)) {
+        return false;
+    }
+    const leftCol = columnName(conjunct.left);
+    const rightCol = columnName(conjunct.right);
+    const leftMatches = leftCol != null && cols.has(leftCol.trim().toLowerCase());
+    const rightMatches = rightCol != null && cols.has(rightCol.trim().toLowerCase());
+    if (leftMatches && !rightMatches) {
+        return isLiteralNode(conjunct.right) || isAllLiteralBag(conjunct.right);
+    }
+    if (rightMatches && !leftMatches) {
+        return isLiteralNode(conjunct.left) || isAllLiteralBag(conjunct.left);
+    }
+    return false;
+}
+/** Rebuilds a left-deep AND-chain from kept conjuncts, or null when none remain. */
+function rebuildWhere(kept) {
+    if (kept.length === 0) {
+        return null;
+    }
+    let node = kept[0];
+    for (let i = 1; i < kept.length; i++) {
+        node = { type: 'binary_expr', operator: 'AND', left: node, right: kept[i] };
+    }
+    return node;
+}
+/** Returns the sole statement of an AST, or null if it is not exactly one statement. */
+function soleStatement(ast) {
+    const node = Array.isArray(ast) ? (ast.length === 1 ? ast[0] : null) : ast;
+    return isObject(node) ? node : null;
+}
+/**
+ * Produces the broad source SQL for a row-filter materialization by removing the top-level
+ * conjunctive `WHERE` predicate(s) on `rowFilterColumns` from a **rendered** (concrete, non-templated)
+ * query. Other conjuncts are preserved; if the row-filter predicates were the only ones, the `WHERE`
+ * is dropped entirely.
+ *
+ * Returns the input unchanged with `removedCount: 0` when the SQL cannot be parsed as a single
+ * simple SELECT, or when no matching predicate is found — the caller should treat `removedCount: 0`
+ * on a query it believes is RowFilterBroad as an anomaly worth refusing (a broad materialization
+ * that still carries the filter would be wrong).
+ *
+ * When `expectedRemovals` is supplied (the classifier's row-filter *parameter* count), the result's
+ * `ambiguous` flag is set whenever the actual match count differs from it — and when ambiguous, the
+ * original SQL is returned **unmodified** (never a partially/over-stripped query), so a caller that
+ * ignores the flag fails safe (it would then still carry the filter, which is refused upstream rather
+ * than silently broadened). Omit `expectedRemovals` to keep the legacy "strip all matches" behavior
+ * with `ambiguous` always false.
+ */
+export function buildBroadRowFilterSQL(renderedSQL, rowFilterColumns, dialect, expectedRemovals) {
+    // ambiguous is only ever asserted when the caller told us how many parameter predicates to expect.
+    const verdict = (sql, removedCount) => ({
+        sql,
+        removedCount,
+        ambiguous: expectedRemovals != null && removedCount !== expectedRemovals,
+    });
+    if (!rowFilterColumns || rowFilterColumns.length === 0) {
+        return verdict(renderedSQL, 0);
+    }
+    const parsed = SQLParser.Astify(renderedSQL, dialect);
+    if (!parsed.astParsed || parsed.ast == null) {
+        return verdict(renderedSQL, 0);
+    }
+    const stmt = soleStatement(parsed.ast);
+    if (stmt == null || nodeType(stmt) !== 'select' || stmt.where == null) {
+        return verdict(renderedSQL, 0);
+    }
+    const cols = new Set(rowFilterColumns.map((c) => c.trim().toLowerCase()));
+    const conjuncts = collectConjuncts(stmt.where);
+    const kept = conjuncts.filter((c) => !isRemovablePredicate(c, cols));
+    const removedCount = conjuncts.length - kept.length;
+    if (removedCount === 0) {
+        return verdict(renderedSQL, 0);
+    }
+    // Fail safe: when the match count doesn't match the expected parameter count, the parameter
+    // predicate can't be cleanly isolated — return the ORIGINAL SQL (unstripped) and flag ambiguous
+    // so an inattentive caller carries the filter (refused upstream) rather than materializing broad.
+    if (expectedRemovals != null && removedCount !== expectedRemovals) {
+        return verdict(renderedSQL, removedCount);
+    }
+    stmt.where = rebuildWhere(kept);
+    const sql = SQLParser.SqlifyAST(parsed.ast, dialect);
+    return verdict(sql, removedCount);
+}
+//# sourceMappingURL=materializationBroadRender.js.map

package/dist/Database/materializationBroadRender.js.map

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