@harperfast/harper 5.2.0-alpha.6 → 5.2.0-beta.1

package/dist/sqlEngine/optimizer/whereToConditions.js

@@ -0,0 +1,484 @@
+"use strict";
+/**
+ * Converts a (normalized) WHERE predicate into a Resource API condition tree
+ * plus an optional residual expression that the engine must apply as a
+ * post-scan Filter.
+ *
+ * The Resource API condition shape (see core/resources/search.ts:581):
+ *   { attribute, value, comparator? }
+ *   { conditions: Condition[], operator: 'and'|'or' }
+ *
+ * Comparator names use the canonical forms in
+ * core/resources/search.ts:204 (equals, ne, lt, le, gt, ge, between, gele,
+ * gelt, gtlt, gtle, starts_with, ends_with, contains).
+ *
+ * Anything that can't be represented as a condition (e.g., comparing two
+ * columns, function calls in WHERE, OR mixed with non-attribute predicates)
+ * is left in the residual.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whereToConditions = whereToConditions;
+exports.conditionIsPushable = conditionIsPushable;
+exports.conditionUsesIndex = conditionUsesIndex;
+exports.sortDrivesIndex = sortDrivesIndex;
+const BINARY_TO_COMPARATOR = {
+    '=': 'equals',
+    '!=': 'ne',
+    '<>': 'ne',
+    '<': 'lt',
+    '<=': 'le',
+    '>': 'gt',
+    '>=': 'ge',
+};
+// Single-sided range comparators, split by which bound they set, and the fused
+// comparator name that combines a lower + upper bound (matching the set
+// core/resources/search.ts issues a single bounded getRange for).
+const LOWER_COMPARATORS = { ge: 'ge', gt: 'gt' };
+const UPPER_COMPARATORS = { le: 'le', lt: 'lt' };
+function whereToConditions(predicate, attributes) {
+    if (!predicate) {
+        return { conditions: [], operator: 'and' };
+    }
+    const conjuncts = flattenAnd(predicate);
+    const conditions = [];
+    const residuals = [];
+    for (const e of conjuncts) {
+        const cond = leafToCondition(e);
+        // Only push a conjunct into the Resource API condition tree when every
+        // attribute it references is indexed: Table.search runs searchByIndex on
+        // each condition and throws "…is not indexed" for an unindexed attribute.
+        // A full-scan comparator (e.g. LIKE→contains) on an *indexed* attribute is
+        // still pushable — search applies it as a filter once another condition
+        // drives the index (validateScannable enforces that a driver exists). When
+        // `attributes` is unknown, keep the legacy behavior of pushing any
+        // representable condition.
+        if (cond && (attributes === undefined || conditionIsPushable(cond, attributes))) {
+            conditions.push(cond);
+            continue;
+        }
+        // A `!=`/NOT IN conjunct whose only unpushable leg is its not-null guard
+        // (search rejects null-valued conditions on an index without indexNulls,
+        // F-145): keep the value legs pushed — they carry the quoted-boolean/
+        // numeric coercion branches the expression evaluator doesn't replicate —
+        // and re-express just the guard as a residual IS NOT NULL filter.
+        const split = cond && splitUnpushableNullGuards(cond, attributes);
+        if (split) {
+            if (split.pushable)
+                conditions.push(split.pushable);
+            residuals.push(...split.guards);
+            continue;
+        }
+        residuals.push(e);
+    }
+    const result = { conditions: fuseRangeBounds(conditions, attributes), operator: 'and' };
+    if (residuals.length > 0) {
+        result.residual = residuals.length === 1 ? residuals[0] : { kind: 'logical', op: 'and', args: residuals };
+    }
+    return result;
+}
+/**
+ * If a condition is unpushable ONLY because it contains null-valued legs on
+ * attributes whose index can't serve nulls (the `!=`/NOT IN not-null guard, or
+ * an IS [NOT] NULL leg), split it: return the remaining pushable legs plus the
+ * null legs re-expressed as residual isNull ExprNodes (evaluated post-scan with
+ * correct three-valued logic). Returns undefined when the condition is
+ * unpushable for any other reason (caller residualizes the whole conjunct) or
+ * when nothing needed splitting.
+ */
+function splitUnpushableNullGuards(cond, attributes) {
+    if ('attribute' in cond && cond.attribute) {
+        if (cond.value !== null)
+            return undefined; // unpushable for a non-null-guard reason
+        const a = attributes?.find((x) => x.name === cond.attribute);
+        if (a?.indexed !== true || a.indexNulls)
+            return undefined; // not the indexNulls case
+        if (cond.comparator !== 'ne' && cond.comparator !== 'equals')
+            return undefined;
+        const guard = {
+            kind: 'isNull',
+            negated: cond.comparator === 'ne',
+            expr: { kind: 'column', name: cond.attribute },
+        };
+        return { guards: [guard] };
+    }
+    if ('conditions' in cond && cond.operator === 'and') {
+        // Salvage AND legs only: an OR containing an unservable null leg can't be
+        // split into pushed-conditions + residual (the residual would over-filter).
+        const pushable = [];
+        const guards = [];
+        for (const c of cond.conditions) {
+            if (conditionIsPushable(c, attributes)) {
+                pushable.push(c);
+                continue;
+            }
+            const sub = splitUnpushableNullGuards(c, attributes);
+            if (!sub)
+                return undefined;
+            if (sub.pushable)
+                pushable.push(sub.pushable);
+            guards.push(...sub.guards);
+        }
+        if (guards.length === 0)
+            return undefined;
+        if (pushable.length === 0)
+            return { guards };
+        return {
+            pushable: pushable.length === 1 ? pushable[0] : { conditions: pushable, operator: 'and' },
+            guards,
+        };
+    }
+    return undefined;
+}
+/**
+ * Comparators that force a full scan even on an indexed attribute, because they
+ * can't seek/range a B-tree index (suffix/substring match). These mirror
+ * `core/resources/search.ts`'s `needFullScan` set. `ne` against a non-null value
+ * is the same (an inequality can't seek); `ne null` (IS NOT NULL) is a range and
+ * stays index-servable.
+ */
+const FULL_SCAN_COMPARATORS = new Set(['ends_with', 'contains']);
+/**
+ * Whether a condition can be pushed into Table.search at all: every attribute it
+ * references must be indexed, because search runs searchByIndex per condition and
+ * throws on an unindexed attribute. Comparator-agnostic — a full-scan comparator
+ * on an indexed attribute is still pushable (it becomes a filter once another
+ * condition drives the index). Null-valued conditions (IS [NOT] NULL and the
+ * `!=`/NOT IN not-null guards) are pushable only when the index actually indexes
+ * nulls — search throws "not indexed for nulls" otherwise (F-145), even when a
+ * different condition drives the scan. Unpushable conditions become a residual
+ * Filter (the expression evaluator's three-valued logic keeps NULL exclusion
+ * correct on the residual path).
+ */
+function conditionIsPushable(cond, attributes) {
+    if ('attribute' in cond && cond.attribute) {
+        const a = attributes?.find((x) => x.name === cond.attribute);
+        if (a?.indexed !== true)
+            return false;
+        if (cond.value === null && !a.indexNulls)
+            return false;
+        return true;
+    }
+    if ('conditions' in cond) {
+        // Every leaf attribute must be indexed; a single unindexed leaf (in either
+        // an AND or an OR) would make search throw when it evaluates that condition.
+        return cond.conditions.every((c) => conditionIsPushable(c, attributes));
+    }
+    return false;
+}
+/**
+ * Whether a condition can *drive* an index scan (seek/range), and therefore make
+ * the scan valid without a full-table traversal. Stricter than pushability:
+ * excludes full-scan comparators and unseekable inequalities. Shared with the R8
+ * validateScannable rule so scannability and pushdown decisions can't drift.
+ */
+function conditionUsesIndex(cond, attributes) {
+    if ('attribute' in cond && cond.attribute) {
+        const a = attributes?.find((x) => x.name === cond.attribute);
+        if (!a?.indexed)
+            return false;
+        if (FULL_SCAN_COMPARATORS.has(cond.comparator ?? ''))
+            return false;
+        if (cond.comparator === 'ne' && cond.value !== null)
+            return false;
+        // A null-valued condition can only seek an index that indexes nulls.
+        if (cond.value === null && !a.indexNulls)
+            return false;
+        return true;
+    }
+    if ('conditions' in cond) {
+        // AND: at least one indexable child suffices.
+        // OR: every child must be indexable; otherwise the union requires a full scan.
+        if (cond.operator === 'and')
+            return cond.conditions.some((c) => conditionUsesIndex(c, attributes));
+        if (cond.operator === 'or')
+            return cond.conditions.every((c) => conditionUsesIndex(c, attributes));
+    }
+    return false;
+}
+/**
+ * Whether a pushed sort can itself drive an index-ordered scan: its primary key
+ * is a single column on the table's PRIMARY KEY. Table.search aligns such a sort
+ * to the index's natural order (resources/Table.ts — it adds a `comparator:
+ * 'sort'` condition), so the rows stream from the index already ordered and a
+ * pushed LIMIT early-terminates (O(window)) — no separate in-memory sort. Shared
+ * by the R8 validateScannable rule and the physical scan builder so scannability
+ * and the `allowFullScan` flag can't drift. NOTE: because Table.search flags the
+ * sort scan as `needFullScan`, the physical scan must pass `allowFullScan: true`
+ * for it — see physicalIndexScan.
+ *
+ * Restricted to the PRIMARY KEY, because only there does index order provably
+ * equal legacy's full-scan-then-stable-sort order. A non-PK secondary index
+ * diverges from legacy in two ways (D-219): (1) a DESC sort reverses the whole
+ * composite `[value, primaryKey]` entry, so rows tying on `value` come back in
+ * primary-key-DESC order, whereas legacy's stable sort preserves primary-key-ASC
+ * order for ties; and (2) the secondary index omits rows whose sort attribute is
+ * null (they were never indexed), whereas a legacy full scan includes them. The
+ * PK is unique (no ties) and always present (no null keys), so its ordered scan
+ * matches legacy in both directions. Secondary-index sort streaming can be a
+ * follow-up once those two divergences are handled.
+ */
+function sortDrivesIndex(pushedSort, attributes) {
+    const key = pushedSort?.[0];
+    if (!key || key.expr.kind !== 'column')
+        return false;
+    const attr = attributes?.find((x) => x.name === key.expr.name);
+    return attr?.indexed === true && attr.isPrimaryKey === true;
+}
+function flattenAnd(expr) {
+    if (expr.kind === 'logical' && expr.op === 'and') {
+        const out = [];
+        for (const a of expr.args)
+            out.push(...flattenAnd(a));
+        return out;
+    }
+    return [expr];
+}
+/** True for a single-sided range leaf (`col >= a`, `col < b`, …) on the given attribute. */
+function isRangeLeafOn(cond, attribute) {
+    if ('conditions' in cond)
+        return false;
+    const comparator = cond.comparator;
+    return (cond.attribute === attribute &&
+        comparator != null &&
+        (LOWER_COMPARATORS[comparator] != null || UPPER_COMPARATORS[comparator] != null));
+}
+/**
+ * Fuse a two-sided PRIMARY-KEY range written as separate conjuncts
+ * (`id >= a AND id < b`) into a single bounded comparator (gele/gelt/gtlt/gtle)
+ * so the storage layer issues one range-seek instead of an unbounded scan from
+ * one bound filtered by the other (#1822). Without this, a leading `ge` streams
+ * from `a` to the end of the table and filters `< b` in memory — O(table), not
+ * O(window). (A SQL `BETWEEN` already maps directly to a single `between`
+ * condition upstream, so it never needed fusing.)
+ *
+ * Deliberately limited to the primary key. The PK is always typed, so
+ * Table.search's prepareConditions coerces the fused bounds to the key type and
+ * the single seek's start/end always match stored-key ordering. A non-PK indexed
+ * attribute may be UNTYPED (e.g. system `hdb_job.start_datetime`): coercion is
+ * skipped, so a string literal against numeric storage would make the fused seek
+ * return nothing. The two-condition path tolerates that mismatch via its
+ * in-memory filter (JS type-juggling), so we leave non-PK ranges unfused.
+ *
+ * Only the unambiguous case is fused: exactly one lower bound (ge/gt) and one
+ * upper bound (le/lt) on the PK within this AND group. Extra bounds (rare, e.g.
+ * `id > 1 AND id > 5`) are left untouched — still correct, just not fused.
+ */
+function fuseRangeBounds(conditions, attributes) {
+    const pk = attributes?.find((a) => a.isPrimaryKey)?.name;
+    if (pk == null)
+        return conditions;
+    let lower;
+    let upper;
+    let lowerCount = 0;
+    let upperCount = 0;
+    for (const cond of conditions) {
+        if (!isRangeLeafOn(cond, pk))
+            continue;
+        if (LOWER_COMPARATORS[cond.comparator]) {
+            lower = cond;
+            lowerCount++;
+        }
+        else {
+            upper = cond;
+            upperCount++;
+        }
+    }
+    if (lowerCount !== 1 || upperCount !== 1)
+        return conditions;
+    const fusedComparator = LOWER_COMPARATORS[lower.comparator] + UPPER_COMPARATORS[upper.comparator];
+    const fused = [];
+    for (const cond of conditions) {
+        if (cond === upper)
+            continue; // merged into the lower bound's slot
+        if (cond === lower) {
+            fused.push({ attribute: pk, comparator: fusedComparator, value: [lower.value, upper.value] });
+            continue;
+        }
+        fused.push(cond);
+    }
+    return fused;
+}
+function leafToCondition(expr) {
+    switch (expr.kind) {
+        case 'binop': {
+            const comparator = BINARY_TO_COMPARATOR[expr.op];
+            if (!comparator)
+                return undefined;
+            const colLit = pickColumnAndLiteral(expr.left, expr.right);
+            if (!colLit)
+                return undefined;
+            const attribute = colLit.column;
+            // `=` matches either form (OR); `!=` must NOT match either form, and (SQL
+            // three-valued logic / legacy AlaSQL) must also exclude NULLs, so it's an
+            // AND that includes an explicit not-null guard.
+            if (comparator === 'ne' && colLit.value !== null) {
+                const conditions = equalityBranches(attribute, colLit.value, 'ne');
+                // `col != X` is UNKNOWN (not true) for a NULL col, so NULL rows are
+                // excluded — match legacy by AND-ing an `IS NOT NULL` guard.
+                conditions.push({ attribute, comparator: 'ne', value: null });
+                return { conditions, operator: 'and' };
+            }
+            if (comparator === 'equals') {
+                const branches = equalityBranches(attribute, colLit.value, 'equals');
+                if (branches.length > 1)
+                    return { conditions: branches, operator: 'or' };
+            }
+            return { attribute, comparator, value: colLit.value };
+        }
+        case 'in': {
+            if (expr.expr.kind !== 'column')
+                return undefined;
+            if (!Array.isArray(expr.list))
+                return undefined;
+            const attribute = expr.expr.name;
+            const variants = [];
+            const seen = new Set();
+            for (const item of expr.list) {
+                if (item.kind !== 'literal')
+                    return undefined;
+                // Legacy AlaSQL evaluates IN with loose (`==`) membership, so a quoted
+                // numeric (`id IN ('5')`) matches a numeric value (and vice versa).
+                // Single `=` is NOT loose in legacy, so this coercion is IN-only.
+                // Expanding to both forms keeps each branch an indexed equality lookup.
+                for (const variant of looseEqualVariants(item.value)) {
+                    if (!seen.has(variant)) {
+                        seen.add(variant);
+                        variants.push(variant);
+                    }
+                }
+            }
+            const conditions = variants.map((v) => ({
+                attribute,
+                comparator: expr.negated ? 'ne' : 'equals',
+                value: v,
+            }));
+            if (expr.negated) {
+                // `col NOT IN (a, b)` is `col != a AND col != b AND col IS NOT NULL`:
+                // a NULL col yields UNKNOWN (excluded), matching legacy AlaSQL 3VL.
+                // Mirror the `!=` path's explicit not-null guard (without it, a NULL
+                // row is returned by the new engine but dropped by legacy — a silent
+                // divergence when the NOT IN is ANDed with another indexed conjunct).
+                conditions.push({ attribute, comparator: 'ne', value: null });
+            }
+            return { conditions, operator: expr.negated ? 'and' : 'or' };
+        }
+        case 'between': {
+            if (expr.expr.kind !== 'column')
+                return undefined;
+            if (expr.low.kind !== 'literal' || expr.high.kind !== 'literal')
+                return undefined;
+            if (expr.negated)
+                return undefined;
+            return {
+                attribute: expr.expr.name,
+                comparator: 'between',
+                value: [expr.low.value, expr.high.value],
+            };
+        }
+        case 'like': {
+            if (expr.expr.kind !== 'column')
+                return undefined;
+            if (expr.pattern.kind !== 'literal' || typeof expr.pattern.value !== 'string')
+                return undefined;
+            if (expr.negated)
+                return undefined;
+            const pattern = expr.pattern.value;
+            const startsPct = pattern.startsWith('%');
+            const endsPct = pattern.endsWith('%');
+            const middle = pattern.slice(startsPct ? 1 : 0, endsPct ? pattern.length - 1 : undefined);
+            if (middle.includes('%') || middle.includes('_'))
+                return undefined;
+            if (startsPct && endsPct) {
+                return { attribute: expr.expr.name, comparator: 'contains', value: middle };
+            }
+            if (startsPct) {
+                return { attribute: expr.expr.name, comparator: 'ends_with', value: middle };
+            }
+            if (endsPct) {
+                return { attribute: expr.expr.name, comparator: 'starts_with', value: middle };
+            }
+            return { attribute: expr.expr.name, comparator: 'equals', value: middle };
+        }
+        case 'isNull': {
+            if (expr.expr.kind !== 'column')
+                return undefined;
+            return {
+                attribute: expr.expr.name,
+                comparator: expr.negated ? 'ne' : 'equals',
+                value: null,
+            };
+        }
+        case 'logical': {
+            if (expr.op !== 'or')
+                return undefined;
+            const sub = [];
+            for (const a of expr.args) {
+                const c = leafToCondition(a);
+                if (!c)
+                    return undefined;
+                sub.push(c);
+            }
+            return { conditions: sub, operator: 'or' };
+        }
+        default:
+            return undefined;
+    }
+}
+function pickColumnAndLiteral(a, b) {
+    if (a.kind === 'column' && b.kind === 'literal')
+        return { column: a.name, value: b.value };
+    if (b.kind === 'column' && a.kind === 'literal')
+        return { column: b.name, value: a.value };
+    return undefined;
+}
+/**
+ * Values an IN literal should match under legacy AlaSQL's loose (`==`) IN
+ * semantics: a numeric string also matches the equivalent number and vice versa
+ * (so `id IN ('5')` finds a numeric 5). Returns the original value plus any
+ * cross-type form; each becomes its own indexed equality branch. The exact
+ * round-trip guard (`String(Number(v)) === v`) avoids spurious variants for
+ * non-canonical strings like '05' or '5px'.
+ */
+function looseEqualVariants(value) {
+    if (typeof value === 'string') {
+        if (value.trim() !== '' && String(Number(value)) === value)
+            return [value, Number(value)];
+        return [value];
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return [value, String(value)];
+    }
+    return [value];
+}
+/**
+ * The boolean a quoted boolean literal should also match under legacy coercion:
+ * `'true'`/`'false'` (case-insensitive, trimmed) → the corresponding boolean.
+ * Returns `undefined` for anything else (including actual booleans, which need no
+ * expansion). Used for single `=`/`!=` only.
+ */
+function booleanVariant(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const v = value.trim().toLowerCase();
+    if (v === 'true')
+        return true;
+    if (v === 'false')
+        return false;
+    return undefined;
+}
+/**
+ * Equality/inequality branches for `col = X` / `col != X`, expanding a quoted
+ * boolean literal to also cover the real boolean (legacy AlaSQL coercion). Each
+ * branch stays an indexed equality lookup. The string branch is kept so a genuine
+ * string column still matches; the boolean branch is added only when the literal
+ * is `'true'`/`'false'`. (Numeric strings are NOT expanded for single `=`/`!=` —
+ * legacy keeps those strict — so this is boolean-only, unlike the IN path.)
+ */
+function equalityBranches(attribute, value, comparator) {
+    const branches = [{ attribute, comparator, value }];
+    const boolValue = booleanVariant(value);
+    if (boolValue !== undefined)
+        branches.push({ attribute, comparator, value: boolValue });
+    return branches;
+}
+//# sourceMappingURL=whereToConditions.js.map

package/dist/sqlEngine/optimizer/whereToConditions.js.map

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

package/dist/sqlEngine/parser/ast.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Internal SQL AST (IR).
+ *
+ * This is the boundary at which AlaSQL types die. The parser/normalizer.ts
+ * walks an `alasql.yy.*` tree and produces these plain objects. Nothing
+ * downstream imports from `alasql`.
+ */
+import type { SqlType } from '../types.ts';
+export type StatementNode = SelectNode | InsertNode | UpdateNode | DeleteNode;
+export interface SelectNode {
+    kind: 'select';
+    distinct: boolean;
+    projections: ProjectionNode[];
+    from: TableRefNode;
+    joins: JoinNode[];
+    where?: ExprNode;
+    groupBy?: ExprNode[];
+    having?: ExprNode;
+    orderBy?: SortNode[];
+    limit?: number;
+    offset?: number;
+}
+export interface InsertNode {
+    kind: 'insert';
+    table: TableRefNode;
+    columns: string[];
+    values: ExprNode[][] | SelectNode;
+}
+export interface UpdateNode {
+    kind: 'update';
+    table: TableRefNode;
+    assignments: {
+        column: string;
+        expr: ExprNode;
+    }[];
+    where?: ExprNode;
+}
+export interface DeleteNode {
+    kind: 'delete';
+    table: TableRefNode;
+    where?: ExprNode;
+}
+export interface TableRefNode {
+    database: string;
+    table: string;
+    alias?: string;
+}
+export interface JoinNode {
+    type: 'inner' | 'left' | 'right' | 'full' | 'cross';
+    table: TableRefNode;
+    on?: ExprNode;
+    using?: string[];
+}
+export interface ProjectionNode {
+    expr: ExprNode;
+    alias?: string;
+    /**
+     * Default output-column label when no `alias` is given, computed from the
+     * original (pre-aggregate-rewrite) expression to match the legacy AlaSQL
+     * column name (e.g. `COUNT(*)`, `SUM(price)`). Without it, an unaliased
+     * aggregate would surface under the engine's internal `__agg_N__` name.
+     */
+    label?: string;
+}
+export interface SortNode {
+    expr: ExprNode;
+    descending: boolean;
+    nullsFirst?: boolean;
+}
+export type BinaryOp = '=' | '!=' | '<>' | '<' | '<=' | '>' | '>=' | '+' | '-' | '*' | '/' | '%' | '||';
+export type ExprNode = {
+    kind: 'column';
+    table?: string;
+    name: string;
+} | {
+    kind: 'literal';
+    value: unknown;
+    sqlType: SqlType;
+} | {
+    kind: 'binop';
+    op: BinaryOp;
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    kind: 'logical';
+    op: 'and' | 'or' | 'not';
+    args: ExprNode[];
+} | {
+    kind: 'in';
+    expr: ExprNode;
+    list: ExprNode[] | SelectNode;
+    negated: boolean;
+} | {
+    kind: 'between';
+    expr: ExprNode;
+    low: ExprNode;
+    high: ExprNode;
+    negated: boolean;
+} | {
+    kind: 'like';
+    expr: ExprNode;
+    pattern: ExprNode;
+    escape?: ExprNode;
+    negated: boolean;
+} | {
+    kind: 'isNull';
+    expr: ExprNode;
+    negated: boolean;
+} | {
+    kind: 'case';
+    cases: {
+        when: ExprNode;
+        then: ExprNode;
+    }[];
+    else?: ExprNode;
+} | {
+    kind: 'funcCall';
+    name: string;
+    args: ExprNode[];
+    distinct?: boolean;
+} | {
+    kind: 'aggCall';
+    name: string;
+    arg: ExprNode | {
+        kind: 'star';
+    };
+    distinct?: boolean;
+} | {
+    kind: 'cast';
+    expr: ExprNode;
+    targetType: SqlType;
+} | {
+    kind: 'star';
+    table?: string;
+} | {
+    kind: 'subquery';
+    query: SelectNode;
+    correlated: boolean;
+};

package/dist/sqlEngine/parser/ast.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Internal SQL AST (IR).
+ *
+ * This is the boundary at which AlaSQL types die. The parser/normalizer.ts
+ * walks an `alasql.yy.*` tree and produces these plain objects. Nothing
+ * downstream imports from `alasql`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ast.js.map

package/dist/sqlEngine/parser/ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.js","sourceRoot":"","sources":["../../../sqlEngine/parser/ast.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG"}