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

package/dist/Database/materializationParamVerifier.js

@@ -0,0 +1,302 @@
+import { SQLParser } from '@memberjunction/sql-parser';
+import { COMPARISON_OPS, isObject, nodeType, isLiteralNode, columnName, isAllLiteralBag, } from './materializationSqlAst.js';
+/** Flips a scalar comparison operator so a `value <op> column` predicate reads canonically as `column <flip> value`. */
+function flipOperator(op) {
+    switch (op) {
+        case '<': return '>';
+        case '>': return '<';
+        case '<=': return '>=';
+        case '>=': return '<=';
+        // =, !=, <> are symmetric so need no flip. IN/BETWEEN/IS never appear as `value <op> column`.
+        // NOTE: LIKE is NOT symmetric (`value LIKE column` ≠ `column LIKE value`), so this default would
+        // MIS-normalize a column-on-right LIKE — safe only because LIKE is excluded from
+        // SAFE_READ_FILTER_OPERATORS (refused → live-only) and never reaches read-time injection. If LIKE
+        // (or any non-symmetric op) is ever whitelisted, handle its column-on-right form explicitly here.
+        default: return op;
+    }
+}
+/** The column attributed to a varying site, given the context it was found in. */
+function siteColumn(ctx) {
+    return ctx.topWhere && ctx.conjClean ? ctx.predColumn : null;
+}
+/**
+ * Builds a varying site from the walk context. A site is *clean* (read-time-filterable) only inside the
+ * top-level conjunctive WHERE as the value operand of a `column <op> value` predicate; otherwise its
+ * column/operator are null (tainted → the parameter becomes Unbounded). `kind` records scalar vs list bag.
+ */
+function makeSite(ctx, kind) {
+    const clean = ctx.topWhere && ctx.conjClean;
+    return {
+        column: clean ? ctx.predColumn : null,
+        operator: clean ? ctx.predOperator : null,
+        kind,
+    };
+}
+/** Whether a bag's literal contents differ (length or any element value) between two variants. */
+function bagVaries(a, b) {
+    const av = a.value;
+    const bv = b.value;
+    if (av.length !== bv.length) {
+        return true;
+    }
+    for (let i = 0; i < av.length; i++) {
+        const ai = av[i];
+        const bi = bv[i];
+        if (isObject(ai) && isObject(bi) && ai.value !== bi.value) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Recursively diffs two AST nodes in lockstep, collecting varying-literal sites. Returns structural equality. */
+function walk(a, b, ctx, sites) {
+    // Both absent.
+    if (a == null && b == null) {
+        return true;
+    }
+    if (a == null || b == null) {
+        return false;
+    }
+    // Scalars (operator names, aliases, flags). A mismatch here is a structural difference.
+    if (!isObject(a) && !Array.isArray(a)) {
+        return a === b;
+    }
+    if (Array.isArray(a) || Array.isArray(b)) {
+        return walkArray(a, b, ctx, sites);
+    }
+    // Both objects from here on.
+    if (isLiteralNode(a) && isLiteralNode(b)) {
+        return walkLiteral(a, b, ctx, sites);
+    }
+    if (isAllLiteralBag(a) && isAllLiteralBag(b)) {
+        return walkBag(a, b, ctx, sites);
+    }
+    const ta = nodeType(a);
+    const tb = nodeType(b);
+    if (ta !== tb) {
+        return false; // shape change (e.g., column_ref → number, select → binary_expr)
+    }
+    if (ta === 'binary_expr') {
+        return walkBinaryExpr(a, b, ctx, sites);
+    }
+    if (ta === 'select') {
+        // A nested SELECT (subquery / derived table) — its insides are never the top-level WHERE.
+        return walkObjectKeys(a, b, plainSubtreeCtx(), sites);
+    }
+    return walkObjectKeys(a, b, plainSubtreeCtx(), sites);
+}
+/** A context for any subtree that cannot host a clean read-time filter (resets all flags). */
+function plainSubtreeCtx() {
+    return { topWhere: false, conjClean: false, predColumn: null, predOperator: null };
+}
+function walkArray(a, b, ctx, sites) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+        return false;
+    }
+    let ok = true;
+    for (let i = 0; i < a.length; i++) {
+        ok = walk(a[i], b[i], ctx, sites) && ok;
+    }
+    return ok;
+}
+function walkLiteral(a, b, ctx, sites) {
+    if (a.type !== b.type) {
+        return false; // literal category changed (string ↔ number) — treat as structural
+    }
+    if (a.value !== b.value) {
+        sites.push(makeSite(ctx, 'scalar'));
+    }
+    return true;
+}
+function walkBag(a, b, ctx, sites) {
+    // Collapse the bag: a differing length/content is allowed *literal* variation, not a shape change.
+    if (bagVaries(a, b)) {
+        sites.push(makeSite(ctx, 'list'));
+    }
+    return true;
+}
+/** Context for the value operand of a clean comparison: keep AND/where flags, attach the column + normalized operator. */
+function valueOperandCtx(ctx, column, operator) {
+    return { topWhere: ctx.topWhere, conjClean: ctx.conjClean, predColumn: column, predOperator: operator };
+}
+/** Context for the column operand (and any non-value child): keep flags, no predicate column/operator. */
+function plainOperandCtx(ctx) {
+    return { topWhere: ctx.topWhere, conjClean: ctx.conjClean, predColumn: null, predOperator: null };
+}
+/** Context below a non-AND combinator (`OR`, etc.): still in where, but no longer conjunctive-clean. */
+function disjunctiveCtx(ctx) {
+    return { topWhere: ctx.topWhere, conjClean: false, predColumn: null, predOperator: null };
+}
+function walkBinaryExpr(a, b, ctx, sites) {
+    const op = a.operator;
+    if (op !== b.operator || typeof op !== 'string') {
+        return false; // operator change is structural
+    }
+    if (op === 'AND') {
+        // Conjunction preserves clean context down both sides.
+        const left = walk(a.left, b.left, ctx, sites);
+        const right = walk(a.right, b.right, ctx, sites);
+        return left && right;
+    }
+    if (COMPARISON_OPS.has(op)) {
+        return walkComparison(a, b, ctx, sites);
+    }
+    // OR / XOR / any other combinator → descendants are not conjunctive-clean.
+    const c = disjunctiveCtx(ctx);
+    const left = walk(a.left, b.left, c, sites);
+    const right = walk(a.right, b.right, c, sites);
+    return left && right;
+}
+function walkComparison(a, b, ctx, sites) {
+    const op = typeof a.operator === 'string' ? a.operator : null;
+    const leftCol = columnName(a.left);
+    const rightCol = columnName(a.right);
+    let leftCtx = plainOperandCtx(ctx);
+    let rightCtx = plainOperandCtx(ctx);
+    // Attach the predicate column + operator to the *value* side only when exactly one side is a plain
+    // column_ref. Normalize the operator to the `column <op> value` reading: when the column is on the
+    // RIGHT (`value < column`), flip it so read-time injection emits `column > value` — an un-flipped
+    // operator here would invert the predicate and silently over/under-scope the materialized read.
+    if (leftCol && !rightCol) {
+        rightCtx = valueOperandCtx(ctx, leftCol, op); // column on left → operator as written
+    }
+    else if (rightCol && !leftCol) {
+        leftCtx = valueOperandCtx(ctx, rightCol, op == null ? null : flipOperator(op));
+    }
+    const left = walk(a.left, b.left, leftCtx, sites);
+    const right = walk(a.right, b.right, rightCtx, sites);
+    return left && right;
+}
+/** Generic structural recursion over an object's keys (ignoring source-location noise). */
+function walkObjectKeys(a, b, childCtx, sites) {
+    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+    keys.delete('loc');
+    let ok = true;
+    for (const k of keys) {
+        ok = walk(a[k], b[k], childCtx, sites) && ok;
+    }
+    return ok;
+}
+/** True for a single plain SELECT that can host a clean top-level WHERE (not a set-op / SELECT INTO). */
+function isSimpleSelect(node) {
+    if (nodeType(node) !== 'select' || !isObject(node)) {
+        return false;
+    }
+    if (node.set_op != null || node._next != null) {
+        return false;
+    }
+    // node-sql-parser always emits `into: { position: null }` on a plain SELECT; only a real
+    // SELECT ... INTO sets `into.position`. Treat only the latter as disqualifying.
+    const into = node.into;
+    if (isObject(into) && into.position != null) {
+        return false;
+    }
+    return true;
+}
+/** Diffs the two statement roots, applying top-WHERE context only to a simple SELECT's `where`. */
+function walkRoot(a, b, sites) {
+    if (nodeType(a) !== nodeType(b)) {
+        return false;
+    }
+    if (isSimpleSelect(a) && isSimpleSelect(b) && isObject(a) && isObject(b)) {
+        const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+        keys.delete('loc');
+        let ok = true;
+        for (const k of keys) {
+            const ctx = k === 'where'
+                ? { topWhere: true, conjClean: true, predColumn: null, predOperator: null }
+                : plainSubtreeCtx();
+            ok = walk(a[k], b[k], ctx, sites) && ok;
+        }
+        return ok;
+    }
+    // Non-simple root (set-op, mutation, etc.) — no position can be a clean read-time filter.
+    return walk(a, b, plainSubtreeCtx(), sites);
+}
+/**
+ * Returns the sole statement of an AST, or null if it is not exactly one statement.
+ * A multi-statement render (e.g. `SELECT …; SELECT …`) cannot be analyzed from one statement —
+ * the parameter might act anywhere in the rest — so we refuse rather than inspect only the first.
+ */
+function soleStatement(ast) {
+    if (Array.isArray(ast)) {
+        return ast.length === 1 ? ast[0] : null;
+    }
+    return ast;
+}
+/** Parses and diffs one pair of rendered variants. */
+function diffVariantPair(sqlA, sqlB, dialect) {
+    const ra = SQLParser.Astify(sqlA, dialect);
+    const rb = SQLParser.Astify(sqlB, dialect);
+    if (!ra.astParsed || !rb.astParsed || ra.ast == null || rb.ast == null) {
+        return { structurallyEqual: false, varyingSites: [], hardRefuse: 'a rendered variant failed to parse — cannot verify; refusing under uncertainty' };
+    }
+    const aStmt = soleStatement(ra.ast);
+    const bStmt = soleStatement(rb.ast);
+    if (aStmt == null || bStmt == null) {
+        return { structurallyEqual: false, varyingSites: [], hardRefuse: 'a rendered variant is multi-statement — cannot verify a single row-filter; refusing under uncertainty' };
+    }
+    const sites = [];
+    const structurallyEqual = walkRoot(aStmt, bStmt, sites);
+    return { structurallyEqual, varyingSites: sites };
+}
+/**
+ * Verifies a single parameter's {@link ParamRole} from ≥2 full-query SQL variants — the same query
+ * template rendered with the same values for every parameter *except* this one, which is varied
+ * across distinct values. Pure; the Phase 2c adapter supplies the rendered strings.
+ *
+ * Decision (refuse-under-uncertainty, §10):
+ *  - <2 variants, or any variant fails to parse → `Unbounded`.
+ *  - any pair differs structurally → `Structural` (shape depends on the value; possibly Bucket 2).
+ *  - all pairs structurally equal but no literal varied → `Unbounded` (no observable effect to prove).
+ *  - a varying literal is tainted (projection / `OR` / subquery / function / non-top-WHERE) → `Unbounded`.
+ *  - varying literals touch >1 column → `Unbounded` (multi-column not modeled in v1).
+ *  - else → `RowFilter` on the single bound column.
+ */
+export function verifyParamRole(variants, dialect) {
+    if (!variants || variants.length < 2) {
+        return { role: 'Unbounded', reason: 'need at least 2 distinct rendered variants to verify a parameter' };
+    }
+    const pairs = [];
+    for (let i = 1; i < variants.length; i++) {
+        pairs.push(diffVariantPair(variants[0], variants[i], dialect));
+    }
+    const refused = pairs.find((p) => p.hardRefuse);
+    if (refused) {
+        return { role: 'Unbounded', reason: refused.hardRefuse };
+    }
+    if (pairs.some((p) => !p.structurallyEqual)) {
+        return { role: 'Structural', reason: 'varying the value changes the SQL shape (different branch/columns/joins) — structural, not a row filter' };
+    }
+    const allSites = pairs.flatMap((p) => p.varyingSites);
+    if (allSites.length === 0) {
+        return { role: 'Unbounded', reason: 'varying the value produced no observable SQL change — cannot prove a pure row filter; refusing under uncertainty' };
+    }
+    if (allSites.some((s) => s.column == null)) {
+        return { role: 'Unbounded', reason: 'value varies outside a clean top-level conjunctive WHERE predicate (projection, OR/NOT, subquery, function, or JOIN ON) — not a safe read-time row filter' };
+    }
+    const distinct = new Map(); // lowercased → original casing
+    for (const s of allSites) {
+        const col = s.column;
+        const key = col.trim().toLowerCase();
+        if (!distinct.has(key)) {
+            distinct.set(key, col);
+        }
+    }
+    if (distinct.size > 1) {
+        return { role: 'Unbounded', reason: `value affects multiple columns (${[...distinct.values()].join(', ')}) — not modeled in v1; refusing under uncertainty` };
+    }
+    const filterColumn = [...distinct.values()][0];
+    // Derive the single operator + kind for read-time reconstruction (Phase 2). All clean sites for one
+    // parameter must agree — a single parameter can only occupy one predicate position, so >1 distinct
+    // operator/kind means our AST reading is ambiguous → refuse under uncertainty (§10) rather than guess.
+    const distinctOps = new Set(allSites.map((s) => s.operator).filter((o) => o != null));
+    const distinctKinds = new Set(allSites.map((s) => s.kind));
+    if (distinctOps.size !== 1 || distinctKinds.size !== 1) {
+        return { role: 'Unbounded', reason: `value varies on "${filterColumn}" but the predicate operator/shape is ambiguous (ops: [${[...distinctOps].join(', ')}], kinds: [${[...distinctKinds].join(', ')}]) — refusing under uncertainty` };
+    }
+    const filterOperator = [...distinctOps][0];
+    const filterKind = [...distinctKinds][0];
+    return { role: 'RowFilter', filterColumn, filterOperator, filterKind, reason: `value varies only a literal at a clean top-level WHERE predicate "${filterColumn} ${filterOperator} <value>" (${filterKind})` };
+}
+//# sourceMappingURL=materializationParamVerifier.js.map

package/dist/Database/materializationParamVerifier.js.map

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

package/dist/Database/materializationSqlAst.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Shared, dialect-tolerant primitives for walking node-sql-parser's loosely-typed JSON AST, used by the
+ * materialization CodeGen analyzers: the parameter verifier (materializationParamVerifier.ts), the broad-render
+ * predicate stripper (materializationBroadRender.ts), and the GROUP BY key detector (materializationAnalysis.ts).
+ *
+ * These MUST be a single source of truth. The verifier classifies a parameter as a clean RowFilter using
+ * LITERAL_NODE_TYPES / COMPARISON_OPS, and broad-render strips exactly those predicates; if divergent hand-kept
+ * copies drifted (e.g. a node-sql-parser upgrade adds a literal node type to one set but not the other), the
+ * verifier could accept a predicate broad-render then fails to isolate — a wrongly-filtered materialization.
+ * Centralizing them here removes that hazard.
+ *
+ * node-sql-parser emits a discriminated-ish union of dozens of node shapes; walking it generically is the
+ * correct use of `unknown` + type guards (every access is narrowed), not a lazy escape. A node is a scalar,
+ * an array, or a keyed object with an optional `type` discriminant.
+ */
+export type AstNode = unknown;
+export type AstObject = Record<string, unknown>;
+/** Literal-leaf node types whose `value` is the substituted literal (the value side of a filter predicate). */
+export declare const LITERAL_NODE_TYPES: Set<string>;
+/** Comparison operators whose `column <op> value` form is a re-applicable read-time row filter. */
+export declare const COMPARISON_OPS: Set<string>;
+export declare function isObject(v: AstNode): v is AstObject;
+export declare function nodeType(v: AstNode): string | undefined;
+export declare function isLiteralNode(v: AstNode): boolean;
+/**
+ * Resolves a `column_ref` node's bare column name across dialects. SQL Server emits `column` as a string;
+ * PostgreSQL emits `column: { expr: { type: 'default', value: 'X' } }`. Returns null for computed/expression
+ * columns (which are not clean filter/grouping columns).
+ *
+ * **This deliberately DISCARDS the table qualifier** — `o.Status` and `c.Status` both return `'Status'`.
+ * That is correct for callers that only need a name, but a caller that MATCHES a column reference against
+ * another column reference (a SELECT-list output, another predicate) MUST also compare
+ * {@link columnQualifier} — see {@link qualifiedColumn}. Matching on the bare name alone silently conflates
+ * same-named columns from different tables in a join.
+ */
+export declare function columnName(v: AstNode): string | null;
+/**
+ * Resolves a `column_ref` node's TABLE QUALIFIER — the `o` in `o.Status` (a table alias, or the table name
+ * when no alias is declared). Returns null when the reference is unqualified (`Status`) or when the node is
+ * not a `column_ref`. Dialect-tolerant in the same way as {@link columnName}.
+ */
+export declare function columnQualifier(v: AstNode): string | null;
+/** A `column_ref` split into its optional table qualifier and its bare column name. */
+export interface QualifiedColumn {
+    /** Table alias / table name qualifying the reference (`o` in `o.Status`); null when unqualified. */
+    qualifier: string | null;
+    /** Bare column name (`Status` in `o.Status`). */
+    column: string;
+}
+/**
+ * Resolves a `column_ref` into its qualifier + column pair, or null when the node is not a plain column
+ * reference. Prefer this over {@link columnName} whenever the resolved column is compared to ANOTHER
+ * column reference — the qualifier is what distinguishes `o.Status` from `c.Status`.
+ */
+export declare function qualifiedColumn(v: AstNode): QualifiedColumn | null;
+/** Case- and whitespace-insensitive SQL identifier equality. Null/undefined never matches anything. */
+export declare function identifiersEqual(a: string | null | undefined, b: string | null | undefined): boolean;
+/**
+ * True when a parsed statement root is a SET OPERATION (`UNION` / `UNION ALL` / `EXCEPT` / `INTERSECT`).
+ *
+ * **Why every analyzer needs this guard:** node-sql-parser does NOT emit a distinct `union` node type. It
+ * emits a SINGLE `type: 'select'` root for the FIRST branch, carrying `set_op: 'union all'` and `_next`
+ * (the remaining branch, itself a select node). So a naive `ast[0]` reader sees a plain SELECT whose
+ * `columns`, `where`, and `groupby` describe **only the first branch** — every other branch is invisible.
+ * Any analyzer that draws a conclusion about the whole result set (its key, its predicates, its shape)
+ * from that root is silently reasoning about a fraction of the query. All such analyzers MUST refuse a
+ * set-op root outright (§10 refuse-under-uncertainty).
+ */
+export declare function isSetOperationRoot(node: AstNode): boolean;
+/**
+ * Returns the sole statement of a parsed AST, or null when it is not exactly one statement.
+ * A multi-statement script cannot be analyzed from its first statement alone, so callers refuse
+ * rather than inspect only `ast[0]`.
+ */
+export declare function soleStatement(ast: AstNode): AstNode | null;
+/** True when every element of an `expr_list` value array is a literal leaf (an all-literal bag). */
+export declare function isAllLiteralBag(v: AstNode): boolean;
+//# sourceMappingURL=materializationSqlAst.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"materializationSqlAst.d.ts","sourceRoot":"","sources":["../../src/Database/materializationSqlAst.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,MAAM,OAAO,GAAG,OAAO,CAAC;AAC9B,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEhD,+GAA+G;AAC/G,eAAO,MAAM,kBAAkB,aAe7B,CAAC;AAEH,mGAAmG;AACnG,eAAO,MAAM,cAAc,aAGzB,CAAC;AAEH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAEvD;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAGjD;AAkBD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAKpD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAKzD;AAED,uFAAuF;AACvF,MAAM,WAAW,eAAe;IAC5B,oGAAoG;IACpG,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,GAAG,eAAe,GAAG,IAAI,CAMlE;AAED,uGAAuG;AACvG,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAKpG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAK1D;AAED,oGAAoG;AACpG,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAKnD"}

package/dist/Database/materializationSqlAst.js

@@ -0,0 +1,142 @@
+/**
+ * Shared, dialect-tolerant primitives for walking node-sql-parser's loosely-typed JSON AST, used by the
+ * materialization CodeGen analyzers: the parameter verifier (materializationParamVerifier.ts), the broad-render
+ * predicate stripper (materializationBroadRender.ts), and the GROUP BY key detector (materializationAnalysis.ts).
+ *
+ * These MUST be a single source of truth. The verifier classifies a parameter as a clean RowFilter using
+ * LITERAL_NODE_TYPES / COMPARISON_OPS, and broad-render strips exactly those predicates; if divergent hand-kept
+ * copies drifted (e.g. a node-sql-parser upgrade adds a literal node type to one set but not the other), the
+ * verifier could accept a predicate broad-render then fails to isolate — a wrongly-filtered materialization.
+ * Centralizing them here removes that hazard.
+ *
+ * node-sql-parser emits a discriminated-ish union of dozens of node shapes; walking it generically is the
+ * correct use of `unknown` + type guards (every access is narrowed), not a lazy escape. A node is a scalar,
+ * an array, or a keyed object with an optional `type` discriminant.
+ */
+/** Literal-leaf node types whose `value` is the substituted literal (the value side of a filter predicate). */
+export const LITERAL_NODE_TYPES = new Set([
+    'single_quote_string',
+    'double_quote_string',
+    'backticks_quote_string',
+    'string',
+    'number',
+    'bool',
+    'boolean',
+    'null',
+    'date',
+    'datetime',
+    'time',
+    'timestamp',
+    'hex_string',
+    'bit_string',
+]);
+/** Comparison operators whose `column <op> value` form is a re-applicable read-time row filter. */
+export const COMPARISON_OPS = new Set([
+    '=', '!=', '<>', '<', '>', '<=', '>=',
+    'IN', 'NOT IN', 'LIKE', 'NOT LIKE', 'IS', 'IS NOT', 'BETWEEN', 'NOT BETWEEN',
+]);
+export function isObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+export function nodeType(v) {
+    return isObject(v) && typeof v.type === 'string' ? v.type : undefined;
+}
+export function isLiteralNode(v) {
+    const t = nodeType(v);
+    return t !== undefined && LITERAL_NODE_TYPES.has(t);
+}
+/**
+ * Unwraps a node-sql-parser identifier slot (`column`, `table`) to plain text across dialects.
+ * SQL Server emits a bare string; PostgreSQL wraps a quoted identifier as
+ * `{ expr: { type: 'double_quote_string' | 'default', value: 'X' } }`. Returns null for anything else
+ * (an absent qualifier, or a computed/expression node that is not a plain identifier).
+ */
+function identifierText(v) {
+    if (typeof v === 'string') {
+        return v;
+    }
+    if (isObject(v) && isObject(v.expr) && typeof v.expr.value === 'string') {
+        return v.expr.value;
+    }
+    return null;
+}
+/**
+ * Resolves a `column_ref` node's bare column name across dialects. SQL Server emits `column` as a string;
+ * PostgreSQL emits `column: { expr: { type: 'default', value: 'X' } }`. Returns null for computed/expression
+ * columns (which are not clean filter/grouping columns).
+ *
+ * **This deliberately DISCARDS the table qualifier** — `o.Status` and `c.Status` both return `'Status'`.
+ * That is correct for callers that only need a name, but a caller that MATCHES a column reference against
+ * another column reference (a SELECT-list output, another predicate) MUST also compare
+ * {@link columnQualifier} — see {@link qualifiedColumn}. Matching on the bare name alone silently conflates
+ * same-named columns from different tables in a join.
+ */
+export function columnName(v) {
+    if (nodeType(v) !== 'column_ref' || !isObject(v)) {
+        return null;
+    }
+    return identifierText(v.column);
+}
+/**
+ * Resolves a `column_ref` node's TABLE QUALIFIER — the `o` in `o.Status` (a table alias, or the table name
+ * when no alias is declared). Returns null when the reference is unqualified (`Status`) or when the node is
+ * not a `column_ref`. Dialect-tolerant in the same way as {@link columnName}.
+ */
+export function columnQualifier(v) {
+    if (nodeType(v) !== 'column_ref' || !isObject(v)) {
+        return null;
+    }
+    return identifierText(v.table);
+}
+/**
+ * Resolves a `column_ref` into its qualifier + column pair, or null when the node is not a plain column
+ * reference. Prefer this over {@link columnName} whenever the resolved column is compared to ANOTHER
+ * column reference — the qualifier is what distinguishes `o.Status` from `c.Status`.
+ */
+export function qualifiedColumn(v) {
+    const column = columnName(v);
+    if (column == null) {
+        return null;
+    }
+    return { qualifier: columnQualifier(v), column };
+}
+/** Case- and whitespace-insensitive SQL identifier equality. Null/undefined never matches anything. */
+export function identifiersEqual(a, b) {
+    if (a == null || b == null) {
+        return false;
+    }
+    return a.trim().toLowerCase() === b.trim().toLowerCase();
+}
+/**
+ * True when a parsed statement root is a SET OPERATION (`UNION` / `UNION ALL` / `EXCEPT` / `INTERSECT`).
+ *
+ * **Why every analyzer needs this guard:** node-sql-parser does NOT emit a distinct `union` node type. It
+ * emits a SINGLE `type: 'select'` root for the FIRST branch, carrying `set_op: 'union all'` and `_next`
+ * (the remaining branch, itself a select node). So a naive `ast[0]` reader sees a plain SELECT whose
+ * `columns`, `where`, and `groupby` describe **only the first branch** — every other branch is invisible.
+ * Any analyzer that draws a conclusion about the whole result set (its key, its predicates, its shape)
+ * from that root is silently reasoning about a fraction of the query. All such analyzers MUST refuse a
+ * set-op root outright (§10 refuse-under-uncertainty).
+ */
+export function isSetOperationRoot(node) {
+    return isObject(node) && (node.set_op != null || node._next != null);
+}
+/**
+ * Returns the sole statement of a parsed AST, or null when it is not exactly one statement.
+ * A multi-statement script cannot be analyzed from its first statement alone, so callers refuse
+ * rather than inspect only `ast[0]`.
+ */
+export function soleStatement(ast) {
+    if (Array.isArray(ast)) {
+        return ast.length === 1 ? ast[0] : null;
+    }
+    return ast;
+}
+/** True when every element of an `expr_list` value array is a literal leaf (an all-literal bag). */
+export function isAllLiteralBag(v) {
+    if (nodeType(v) !== 'expr_list' || !isObject(v) || !Array.isArray(v.value)) {
+        return false;
+    }
+    return v.value.length > 0 && v.value.every(isLiteralNode);
+}
+//# sourceMappingURL=materializationSqlAst.js.map

package/dist/Database/materializationSqlAst.js.map

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