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

package/dist/sqlEngine/physical/PhysicalHashAggregate.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * PhysicalHashAggregate: groups all input rows in a Map keyed on JSON-serialised
+ * group-key values, then finalises accumulators and yields one output row per
+ * group.
+ *
+ * Memory is bounded by maxHashRows (total input rows consumed), after which an
+ * EngineUnsupportedError is thrown so the router falls back to legacy in 'auto'
+ * mode (runSelect fully materializes before returning, so nothing has been
+ * emitted when the cap trips).
+ *
+ * Special cases:
+ *  - No GROUP BY + no rows  → emit one row with default aggregate values
+ *    (e.g. COUNT(*) = 0).
+ *  - COUNT(*) arg is a star placeholder; we pass the sentinel value 1 to step()
+ *    so the accumulator counts every row unconditionally.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.physicalHashAggregate = physicalHashAggregate;
+const compile_ts_1 = require("../expressions/compile.js");
+const registry_ts_1 = require("../functions/registry.js");
+const errors_ts_1 = require("../errors.js");
+function physicalHashAggregate(input, groupKeys, aggs, maxHashRows, qualified = false) {
+    // In join (qualified) queries the group-key column lives under its
+    // `<alias>.<name>` key, and the aggregate output is keyed the same way so the
+    // projection above resolves it consistently.
+    const groupKeyNames = groupKeys.map((k) => {
+        if (k.kind !== 'column')
+            throw new errors_ts_1.EngineUnsupportedError('GROUP BY supports only column refs', k);
+        return qualified && k.table ? `${k.table}.${k.name}` : k.name;
+    });
+    const groupKeyEvals = groupKeyNames.map((key) => (row) => row[key]);
+    const compiledAggs = aggs.map((a) => {
+        const desc = registry_ts_1.functionRegistry.lookup(a.name);
+        if (!desc || desc.kind !== 'aggregate') {
+            throw new errors_ts_1.EngineUnsupportedError(`unknown aggregate function: ${a.name}`);
+        }
+        // DISTINCT-in-aggregate dedup is not implemented; the accumulator would
+        // otherwise step every row (silent wrong result, e.g. COUNT(DISTINCT x)
+        // counting all rows). Reject so 'auto' falls back to legacy, which dedups.
+        if (a.distinct) {
+            throw new errors_ts_1.EngineUnsupportedError(`DISTINCT aggregate not supported yet: ${a.name}`);
+        }
+        const isStarArg = a.arg.kind === 'star';
+        const argEval = isStarArg ? null : (0, compile_ts_1.compileExpr)(a.arg, qualified).eval;
+        return {
+            outputName: a.outputName,
+            factory: desc.impl.factory,
+            isStarArg,
+            argEval,
+        };
+    });
+    return {
+        schema: [],
+        execute(ctx) {
+            return runAggregate(input, ctx, groupKeyEvals, groupKeyNames, compiledAggs, maxHashRows);
+        },
+    };
+}
+async function* runAggregate(input, ctx, groupKeyEvals, groupKeyNames, compiledAggs, maxHashRows) {
+    const groups = new Map();
+    let rowCount = 0;
+    for await (const row of input.execute(ctx)) {
+        if (++rowCount > maxHashRows) {
+            throw new errors_ts_1.EngineUnsupportedError(`aggregate exceeded maxHashRows (${maxHashRows})`);
+        }
+        const keyVals = groupKeyEvals.map((fn) => fn(row));
+        const groupKey = JSON.stringify(keyVals);
+        let entry = groups.get(groupKey);
+        if (!entry) {
+            entry = { keys: keyVals, accs: compiledAggs.map((a) => a.factory()) };
+            groups.set(groupKey, entry);
+        }
+        for (let i = 0; i < compiledAggs.length; i++) {
+            const agg = compiledAggs[i];
+            const val = agg.isStarArg ? 1 : agg.argEval(row);
+            entry.accs[i].step(val);
+        }
+    }
+    // No GROUP BY + no rows → emit one row with zero/null aggregate values.
+    if (groups.size === 0 && groupKeyNames.length === 0) {
+        const outputRow = {};
+        for (const agg of compiledAggs) {
+            outputRow[agg.outputName] = agg.factory().finalize();
+        }
+        yield outputRow;
+        return;
+    }
+    for (const { keys, accs } of groups.values()) {
+        const outputRow = {};
+        for (let i = 0; i < groupKeyNames.length; i++) {
+            outputRow[groupKeyNames[i]] = keys[i];
+        }
+        for (let i = 0; i < compiledAggs.length; i++) {
+            outputRow[compiledAggs[i].outputName] = accs[i].finalize();
+        }
+        yield outputRow;
+    }
+}
+//# sourceMappingURL=PhysicalHashAggregate.js.map

package/dist/sqlEngine/physical/PhysicalHashAggregate.js.map

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

package/dist/sqlEngine/physical/PhysicalHashJoin.d.ts

@@ -0,0 +1,29 @@
+/**
+ * PhysicalHashJoin: equi-join via an in-memory hash table on the right (inner)
+ * side.
+ *
+ * Build phase materializes the right input into a Map keyed on the JSON-encoded
+ * join-key tuple (bounded by maxHashRows). Probe phase streams the left
+ * (outer) input, looks up each left row's key tuple, and emits the merged row
+ * for every matching right row. An optional `residual` predicate (the
+ * non-equi remainder of the ON clause) is checked on the merged row.
+ *
+ * For a LEFT join, a left row with no surviving match emits once with the right
+ * side's declared columns null-filled (matching legacy `undefined → null`
+ * outer-join semantics in dataLayer/SQLSearch).
+ *
+ * Rows on both sides are already qualified (`<alias>.<attr>`), so the merge is
+ * a plain spread with no key collisions.
+ */
+import type { ExprNode } from '../parser/ast.ts';
+import type { PhysicalOp } from './op.ts';
+export interface HashJoinOptions {
+    leftKeys: ExprNode[];
+    rightKeys: ExprNode[];
+    residual?: ExprNode;
+    type: 'inner' | 'left';
+    /** Right-side qualified keys to null-fill on unmatched LEFT rows. */
+    rightNullKeys: string[];
+    maxHashRows: number;
+}
+export declare function physicalHashJoin(left: PhysicalOp, right: PhysicalOp, opts: HashJoinOptions): PhysicalOp;

package/dist/sqlEngine/physical/PhysicalHashJoin.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * PhysicalHashJoin: equi-join via an in-memory hash table on the right (inner)
+ * side.
+ *
+ * Build phase materializes the right input into a Map keyed on the JSON-encoded
+ * join-key tuple (bounded by maxHashRows). Probe phase streams the left
+ * (outer) input, looks up each left row's key tuple, and emits the merged row
+ * for every matching right row. An optional `residual` predicate (the
+ * non-equi remainder of the ON clause) is checked on the merged row.
+ *
+ * For a LEFT join, a left row with no surviving match emits once with the right
+ * side's declared columns null-filled (matching legacy `undefined → null`
+ * outer-join semantics in dataLayer/SQLSearch).
+ *
+ * Rows on both sides are already qualified (`<alias>.<attr>`), so the merge is
+ * a plain spread with no key collisions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.physicalHashJoin = physicalHashJoin;
+const compile_ts_1 = require("../expressions/compile.js");
+const errors_ts_1 = require("../errors.js");
+function physicalHashJoin(left, right, opts) {
+    const leftKeyEvals = opts.leftKeys.map((e) => (0, compile_ts_1.compileExpr)(e, true).eval);
+    const rightKeyEvals = opts.rightKeys.map((e) => (0, compile_ts_1.compileExpr)(e, true).eval);
+    const residual = opts.residual ? (0, compile_ts_1.compileExpr)(opts.residual, true) : undefined;
+    return {
+        schema: [],
+        async *execute(ctx) {
+            // Build side: right input → Map<keyTuple, Row[]>.
+            const buckets = new Map();
+            let built = 0;
+            for await (const rrow of right.execute(ctx)) {
+                if (++built > opts.maxHashRows) {
+                    throw new errors_ts_1.EngineUnsupportedError(`hash join build side exceeded maxHashRows (${opts.maxHashRows})`);
+                }
+                const key = keyTuple(rightKeyEvals, rrow);
+                if (key === undefined)
+                    continue; // NULL join key never matches
+                const bucket = buckets.get(key);
+                if (bucket)
+                    bucket.push(rrow);
+                else
+                    buckets.set(key, [rrow]);
+            }
+            for await (const lrow of left.execute(ctx)) {
+                const key = keyTuple(leftKeyEvals, lrow);
+                let matched = false;
+                if (key !== undefined) {
+                    const bucket = buckets.get(key);
+                    if (bucket) {
+                        for (const rrow of bucket) {
+                            const merged = { ...lrow, ...rrow };
+                            if (residual) {
+                                const v = residual.eval(merged);
+                                if (v == null || v === false)
+                                    continue;
+                            }
+                            matched = true;
+                            yield merged;
+                        }
+                    }
+                }
+                if (!matched && opts.type === 'left') {
+                    yield nullFill(lrow, opts.rightNullKeys);
+                }
+            }
+        },
+    };
+}
+/**
+ * Serializes the join key. Returns undefined if any key component is null/
+ * undefined or NaN — SQL equi-joins never match on NULL, and NaN is never equal
+ * to itself (without this guard JSON.stringify coerces NaN → "null", letting two
+ * NaN keys collide and match).
+ */
+function keyTuple(evals, row) {
+    const vals = [];
+    for (const e of evals) {
+        const v = e(row);
+        if (v == null || (typeof v === 'number' && Number.isNaN(v)))
+            return undefined;
+        vals.push(v);
+    }
+    return JSON.stringify(vals);
+}
+function nullFill(lrow, rightNullKeys) {
+    const out = { ...lrow };
+    for (const k of rightNullKeys)
+        out[k] = null;
+    return out;
+}
+//# sourceMappingURL=PhysicalHashJoin.js.map

package/dist/sqlEngine/physical/PhysicalHashJoin.js.map

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

package/dist/sqlEngine/physical/PhysicalIndexNestedLoopJoin.d.ts

@@ -0,0 +1,36 @@
+/**
+ * PhysicalIndexNestedLoopJoin: streams the outer (left) input and, for each
+ * outer row, probes the inner table via Table.search on its indexed join key.
+ *
+ * This is the default join strategy when the inner join key is indexed: no full
+ * inner scan, bounded memory (one inner result set at a time), and it composes
+ * with the inner table's own pushed-down WHERE conditions.
+ *
+ * The probe equality is ANDed with the inner scan's base conditions. Inner
+ * records are filtered by the inner residual (bare names), then qualified with
+ * the inner alias and merged with the outer row; an optional join residual (the
+ * non-equi remainder of ON) is checked on the merged row. LEFT joins null-fill
+ * the inner columns when no inner row matches.
+ */
+import type { ExprNode } from '../parser/ast.ts';
+import type { PhysicalOp } from './op.ts';
+import type { ConditionNode } from '../optimizer/whereToConditions.ts';
+export interface IndexNLJoinOptions {
+    innerResource: unknown;
+    innerAlias: string;
+    /** Indexed inner attribute the probe equates against the outer key value. */
+    innerAttribute: string;
+    /** Outer-side join-key expression (compiled in qualified mode). */
+    outerKey: ExprNode;
+    /** Inner scan's own pushed-down conditions, ANDed with the probe equality. */
+    innerBaseConditions: ConditionNode[];
+    innerOperator: 'and' | 'or';
+    innerSelect?: string[];
+    /** Inner single-table residual (bare names), applied to probe records. */
+    innerResidual?: ExprNode;
+    /** Non-equi remainder of the ON clause (qualified), applied to merged rows. */
+    residualOn?: ExprNode;
+    type: 'inner' | 'left';
+    rightNullKeys: string[];
+}
+export declare function physicalIndexNestedLoopJoin(left: PhysicalOp, opts: IndexNLJoinOptions): PhysicalOp;

package/dist/sqlEngine/physical/PhysicalIndexNestedLoopJoin.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * PhysicalIndexNestedLoopJoin: streams the outer (left) input and, for each
+ * outer row, probes the inner table via Table.search on its indexed join key.
+ *
+ * This is the default join strategy when the inner join key is indexed: no full
+ * inner scan, bounded memory (one inner result set at a time), and it composes
+ * with the inner table's own pushed-down WHERE conditions.
+ *
+ * The probe equality is ANDed with the inner scan's base conditions. Inner
+ * records are filtered by the inner residual (bare names), then qualified with
+ * the inner alias and merged with the outer row; an optional join residual (the
+ * non-equi remainder of ON) is checked on the merged row. LEFT joins null-fill
+ * the inner columns when no inner row matches.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.physicalIndexNestedLoopJoin = physicalIndexNestedLoopJoin;
+const compile_ts_1 = require("../expressions/compile.js");
+function physicalIndexNestedLoopJoin(left, opts) {
+    const resource = opts.innerResource;
+    const outerKeyEval = (0, compile_ts_1.compileExpr)(opts.outerKey, true).eval;
+    const innerResidual = opts.innerResidual ? (0, compile_ts_1.compileExpr)(opts.innerResidual, false) : undefined;
+    const residualOn = opts.residualOn ? (0, compile_ts_1.compileExpr)(opts.residualOn, true) : undefined;
+    const prefix = `${opts.innerAlias}.`;
+    return {
+        schema: [],
+        async *execute(ctx) {
+            for await (const outerRow of left.execute(ctx)) {
+                const value = outerKeyEval(outerRow);
+                let matched = false;
+                if (value != null) {
+                    const target = buildProbeTarget(opts, value);
+                    for await (const innerRow of resource.search(target)) {
+                        if (innerResidual) {
+                            const v = innerResidual.eval(innerRow);
+                            if (v == null || v === false)
+                                continue;
+                        }
+                        const merged = { ...outerRow };
+                        for (const k of Object.keys(innerRow))
+                            merged[prefix + k] = innerRow[k];
+                        if (residualOn) {
+                            const v = residualOn.eval(merged);
+                            if (v == null || v === false)
+                                continue;
+                        }
+                        matched = true;
+                        yield merged;
+                    }
+                }
+                if (!matched && opts.type === 'left') {
+                    const out = { ...outerRow };
+                    for (const k of opts.rightNullKeys)
+                        out[k] = null;
+                    yield out;
+                }
+            }
+        },
+    };
+}
+function buildProbeTarget(opts, value) {
+    const probe = { attribute: opts.innerAttribute, value, comparator: 'equals' };
+    let conditions;
+    if (opts.innerBaseConditions.length === 0) {
+        conditions = [probe];
+    }
+    else if (opts.innerOperator === 'and') {
+        conditions = [...opts.innerBaseConditions, probe];
+    }
+    else {
+        conditions = [{ conditions: opts.innerBaseConditions, operator: 'or' }, probe];
+    }
+    const target = { conditions, operator: 'and', allowFullScan: false };
+    if (opts.innerSelect)
+        target.select = opts.innerSelect;
+    return target;
+}
+//# sourceMappingURL=PhysicalIndexNestedLoopJoin.js.map

package/dist/sqlEngine/physical/PhysicalIndexNestedLoopJoin.js.map

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

package/dist/sqlEngine/physical/PhysicalIndexScan.d.ts

@@ -0,0 +1,22 @@
+/**
+ * PhysicalIndexScan: wraps Table.search.
+ *
+ * Builds the RequestTarget from the LogicalScan's pushed filters/sort/limit
+ * and projection, then yields rows from the returned AsyncIterable.
+ */
+import type { LogicalScan } from '../logical/op.ts';
+import type { PhysicalOp } from './op.ts';
+import type { ConditionNode } from '../optimizer/whereToConditions.ts';
+export interface PhysicalIndexScanOptions {
+    conditions: ConditionNode[];
+    operator: 'and' | 'or';
+    /**
+     * Set for a sort-driven scan (no index-driving predicate; the pushed sort
+     * provides index order — D-219). Table.search flags a sort-aligned scan as
+     * needFullScan and would reject it under allowFullScan:false, so it must be
+     * allowed here. Validated as scannable by validateScannable, so this is not a
+     * blanket full-scan escape hatch.
+     */
+    allowFullScan?: boolean;
+}
+export declare function physicalIndexScan(scan: LogicalScan, opts: PhysicalIndexScanOptions): PhysicalOp;

package/dist/sqlEngine/physical/PhysicalIndexScan.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * PhysicalIndexScan: wraps Table.search.
+ *
+ * Builds the RequestTarget from the LogicalScan's pushed filters/sort/limit
+ * and projection, then yields rows from the returned AsyncIterable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.physicalIndexScan = physicalIndexScan;
+const errors_ts_1 = require("../errors.js");
+const hdbError_ts_1 = require("../../utility/errors/hdbError.js");
+function physicalIndexScan(scan, opts) {
+    const schema = (scan.boundTable?.attributes ?? []).map((a) => ({
+        name: a.name,
+        type: 'unknown',
+        nullable: true,
+    }));
+    return {
+        schema,
+        execute(ctx) {
+            return executeScan(scan, opts, ctx);
+        },
+    };
+}
+async function* executeScan(scan, opts, ctx) {
+    const resource = scan.boundTable?.resource;
+    if (!resource)
+        throw new Error('PhysicalIndexScan: scan has no boundTable.resource');
+    const target = { allowFullScan: opts.allowFullScan === true };
+    if (ctx.includeExpiredRows)
+        target.includeExpired = true;
+    // Only attach conditions/operator when there is at least one — Table.search
+    // rejects an empty `and`/`or` group ("requires at least one condition"). A
+    // scan with no conditions is driven by its pushed sort/limit alone.
+    if (opts.conditions.length > 0) {
+        target.conditions = opts.conditions;
+        target.operator = opts.operator;
+    }
+    if (scan.projection)
+        target.select = scan.projection;
+    if (scan.pushedSort && scan.pushedSort.length > 0) {
+        const k = scan.pushedSort[0];
+        if (k.expr.kind === 'column') {
+            target.sort = { attribute: k.expr.name, descending: k.descending };
+        }
+    }
+    if (scan.pushedLimit) {
+        if (scan.pushedLimit.limit != null)
+            target.limit = scan.pushedLimit.limit;
+        if (scan.pushedLimit.offset != null)
+            target.offset = scan.pushedLimit.offset;
+    }
+    // Safety net for the fallback contract: validateScannable predicts what
+    // Table.search will accept, but if the prediction is ever wrong (F-145: a
+    // pushed `ne null` guard on an index without indexNulls), search throws a
+    // capability-shaped ClientError (400/403/404) or IndexRebuildingError at
+    // runtime, past the router's EngineUnsupportedError catch — leaking an error
+    // where 'auto' should fall back. Convert those here; results are materialized
+    // before delivery, so no partial rows have been sent when this fires.
+    try {
+        for await (const row of resource.search(target)) {
+            yield row;
+        }
+    }
+    catch (err) {
+        if (err instanceof errors_ts_1.EngineUnsupportedError)
+            throw err;
+        if (err instanceof hdbError_ts_1.IndexRebuildingError) {
+            throw new errors_ts_1.EngineUnsupportedError(`index rebuilding: ${err.message}`);
+        }
+        if (err instanceof hdbError_ts_1.ClientError) {
+            throw new errors_ts_1.EngineUnsupportedError(`search rejected scan: ${err.message}`);
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=PhysicalIndexScan.js.map

package/dist/sqlEngine/physical/PhysicalIndexScan.js.map

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

package/dist/sqlEngine/physical/PhysicalLimit.d.ts

@@ -0,0 +1,5 @@
+/**
+ * PhysicalLimit: drops `offset` rows then yields up to `limit` rows.
+ */
+import type { PhysicalOp } from './op.ts';
+export declare function physicalLimit(child: PhysicalOp, limit: number | undefined, offset: number | undefined): PhysicalOp;

package/dist/sqlEngine/physical/PhysicalLimit.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * PhysicalLimit: drops `offset` rows then yields up to `limit` rows.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.physicalLimit = physicalLimit;
+function physicalLimit(child, limit, offset) {
+    return {
+        schema: child.schema,
+        async *execute(ctx) {
+            let skipped = 0;
+            let yielded = 0;
+            const skip = offset ?? 0;
+            const cap = limit ?? Number.POSITIVE_INFINITY;
+            for await (const row of child.execute(ctx)) {
+                if (skipped < skip) {
+                    skipped++;
+                    continue;
+                }
+                if (yielded >= cap)
+                    return;
+                yield row;
+                yielded++;
+            }
+        },
+    };
+}
+//# sourceMappingURL=PhysicalLimit.js.map

package/dist/sqlEngine/physical/PhysicalLimit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicalLimit.js","sourceRoot":"","sources":["../../../sqlEngine/physical/PhysicalLimit.ts"],"names":[],"mappings":";AAAA;;GAEG;;AAKH,sCAmBC;AAnBD,SAAgB,aAAa,CAAC,KAAiB,EAAE,KAAyB,EAAE,MAA0B;IACrG,OAAO;QACN,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,KAAK,CAAC,CAAC,OAAO,CAAC,GAAqB;YACnC,IAAI,OAAO,GAAG,CAAC,CAAC;YAChB,IAAI,OAAO,GAAG,CAAC,CAAC;YAChB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,CAAC;YACzB,MAAM,GAAG,GAAG,KAAK,IAAI,MAAM,CAAC,iBAAiB,CAAC;YAC9C,IAAI,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC5C,IAAI,OAAO,GAAG,IAAI,EAAE,CAAC;oBACpB,OAAO,EAAE,CAAC;oBACV,SAAS;gBACV,CAAC;gBACD,IAAI,OAAO,IAAI,GAAG;oBAAE,OAAO;gBAC3B,MAAM,GAAG,CAAC;gBACV,OAAO,EAAE,CAAC;YACX,CAAC;QACF,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/sqlEngine/physical/PhysicalNestedLoopJoin.d.ts

@@ -0,0 +1,20 @@
+/**
+ * PhysicalNestedLoopJoin: the general join fallback for CROSS joins and
+ * non-equi ON predicates that no hash/index strategy can serve.
+ *
+ * The right (inner) input is materialized once (bounded by maxHashRows); the
+ * left (outer) input streams. For each left row every buffered right row is
+ * tested against the compiled ON predicate (absent for CROSS) on the merged
+ * row. LEFT joins null-fill the right columns when a left row matches nothing.
+ *
+ * Both inputs are already qualified (`<alias>.<attr>`); merge is a plain spread.
+ */
+import type { ExprNode } from '../parser/ast.ts';
+import type { PhysicalOp } from './op.ts';
+export interface NestedLoopJoinOptions {
+    on?: ExprNode;
+    type: 'inner' | 'left' | 'cross';
+    rightNullKeys: string[];
+    maxHashRows: number;
+}
+export declare function physicalNestedLoopJoin(left: PhysicalOp, right: PhysicalOp, opts: NestedLoopJoinOptions): PhysicalOp;

package/dist/sqlEngine/physical/PhysicalNestedLoopJoin.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * PhysicalNestedLoopJoin: the general join fallback for CROSS joins and
+ * non-equi ON predicates that no hash/index strategy can serve.
+ *
+ * The right (inner) input is materialized once (bounded by maxHashRows); the
+ * left (outer) input streams. For each left row every buffered right row is
+ * tested against the compiled ON predicate (absent for CROSS) on the merged
+ * row. LEFT joins null-fill the right columns when a left row matches nothing.
+ *
+ * Both inputs are already qualified (`<alias>.<attr>`); merge is a plain spread.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.physicalNestedLoopJoin = physicalNestedLoopJoin;
+const compile_ts_1 = require("../expressions/compile.js");
+const errors_ts_1 = require("../errors.js");
+function physicalNestedLoopJoin(left, right, opts) {
+    const on = opts.on ? (0, compile_ts_1.compileExpr)(opts.on, true) : undefined;
+    return {
+        schema: [],
+        async *execute(ctx) {
+            const inner = [];
+            for await (const rrow of right.execute(ctx)) {
+                if (inner.length >= opts.maxHashRows) {
+                    throw new errors_ts_1.EngineUnsupportedError(`nested-loop join inner side exceeded maxHashRows (${opts.maxHashRows})`);
+                }
+                inner.push(rrow);
+            }
+            for await (const lrow of left.execute(ctx)) {
+                let matched = false;
+                for (const rrow of inner) {
+                    const merged = { ...lrow, ...rrow };
+                    if (on) {
+                        const v = on.eval(merged);
+                        if (v == null || v === false)
+                            continue;
+                    }
+                    matched = true;
+                    yield merged;
+                }
+                if (!matched && opts.type === 'left') {
+                    const out = { ...lrow };
+                    for (const k of opts.rightNullKeys)
+                        out[k] = null;
+                    yield out;
+                }
+            }
+        },
+    };
+}
+//# sourceMappingURL=PhysicalNestedLoopJoin.js.map

package/dist/sqlEngine/physical/PhysicalNestedLoopJoin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicalNestedLoopJoin.js","sourceRoot":"","sources":["../../../sqlEngine/physical/PhysicalNestedLoopJoin.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;AAeH,wDAiCC;AA3CD,0DAAwD;AACxD,4CAAsD;AAStD,SAAgB,sBAAsB,CAAC,IAAgB,EAAE,KAAiB,EAAE,IAA2B;IACtG,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,IAAA,wBAAW,EAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAE5D,OAAO;QACN,MAAM,EAAE,EAAE;QACV,KAAK,CAAC,CAAC,OAAO,CAAC,GAAqB;YACnC,MAAM,KAAK,GAAU,EAAE,CAAC;YACxB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC7C,IAAI,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;oBACtC,MAAM,IAAI,kCAAsB,CAAC,qDAAqD,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;gBAC5G,CAAC;gBACD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAClB,CAAC;YAED,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC5C,IAAI,OAAO,GAAG,KAAK,CAAC;gBACpB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;oBAC1B,MAAM,MAAM,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,EAAE,CAAC;oBACpC,IAAI,EAAE,EAAE,CAAC;wBACR,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;wBAC1B,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK;4BAAE,SAAS;oBACxC,CAAC;oBACD,OAAO,GAAG,IAAI,CAAC;oBACf,MAAM,MAAM,CAAC;gBACd,CAAC;gBACD,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;oBACtC,MAAM,GAAG,GAAQ,EAAE,GAAG,IAAI,EAAE,CAAC;oBAC7B,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,aAAa;wBAAE,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;oBAClD,MAAM,GAAG,CAAC;gBACX,CAAC;YACF,CAAC;QACF,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/sqlEngine/physical/PhysicalProject.d.ts

@@ -0,0 +1,18 @@
+/**
+ * PhysicalProject: per-row evaluation of the SELECT clause.
+ *
+ * Single-table (`qualified = false`): star expansion forwards the row's keys
+ * intact and layers projected columns on top, matching the Resource API's
+ * natural record shape.
+ *
+ * Join queries (`qualified = true`): rows arrive keyed by `<alias>.<name>`.
+ * Output columns are renamed to clean, unqualified names (or the SELECT `AS`
+ * alias). When two output columns collide on the same name the later one is
+ * suffixed `_2`, `_3`, … in SELECT order (legacy AlaSQL instead emitted
+ * `[name]`/`[name1]`; the differential harness normalizes between the two).
+ * `SELECT *` expands every column across all joined tables; `SELECT t.*`
+ * expands only table `t`'s columns.
+ */
+import type { ProjectionNode } from '../parser/ast.ts';
+import type { PhysicalOp } from './op.ts';
+export declare function physicalProject(child: PhysicalOp, projections: ProjectionNode[], qualified?: boolean): PhysicalOp;