opfsql 0.0.2

package/dist/executor/evaluate/column-ref.d.ts

@@ -0,0 +1,5 @@
+import type { BoundExpression } from '../../binder/types.js';
+import type { Value, Tuple } from '../types.js';
+import type { Resolver } from '../resolve.js';
+import type { SyncEvalContext as EvalContext } from './context.js';
+export declare function evalColumnRef(expr: BoundExpression, tuple: Tuple, resolver: Resolver, ctx: EvalContext): Value;

package/dist/executor/evaluate/comparison.d.ts

@@ -0,0 +1,5 @@
+import type { BoundExpression } from "../../binder/types.js";
+import type { Resolver } from "../resolve.js";
+import type { Tuple, Value } from "../types.js";
+import type { SyncEvalContext } from "./context.js";
+export declare function evalComparison(expr: BoundExpression, tuple: Tuple, resolver: Resolver, ctx: SyncEvalContext): Value;

package/dist/executor/evaluate/compile.d.ts

@@ -0,0 +1,11 @@
+import type { BoundExpression, ComparisonType, TableFilter } from '../../binder/types.js';
+import type { Resolver } from '../resolve.js';
+import type { Tuple, Value } from '../types.js';
+import type { SyncEvalContext } from './context.js';
+export interface CompiledFilter {
+    getValue: (tuple: Tuple) => Value;
+    comparisonType: ComparisonType;
+    getConstant: (params?: readonly Value[]) => Value;
+}
+export declare function compileExpression(expr: BoundExpression, resolver: Resolver, ctx: SyncEvalContext): (tuple: Tuple) => Value;
+export declare function compileFilter(filter: TableFilter, resolver: Resolver, ctx: SyncEvalContext): CompiledFilter;

package/dist/executor/evaluate/conjunction.d.ts

@@ -0,0 +1,5 @@
+import type { BoundExpression } from '../../binder/types.js';
+import type { Value, Tuple } from '../types.js';
+import type { Resolver } from '../resolve.js';
+import type { SyncEvalContext } from './context.js';
+export declare function evalConjunction(expr: BoundExpression, tuple: Tuple, resolver: Resolver, ctx: SyncEvalContext): Value;

package/dist/executor/evaluate/context.d.ts

@@ -0,0 +1,9 @@
+import type { LogicalOperator } from '../../binder/types.js';
+import type { Tuple, Value } from '../types.js';
+import type { Resolver } from '../resolve.js';
+export interface SyncEvalContext {
+    executeSubplan(plan: LogicalOperator, outerTuple?: Tuple, outerResolver?: Resolver, limit?: number): Tuple[];
+    outerTuple?: Tuple;
+    outerResolver?: Resolver;
+    params?: readonly Value[];
+}

package/dist/executor/evaluate/function.d.ts

@@ -0,0 +1,5 @@
+import type { BoundExpression } from "../../binder/types.js";
+import type { Resolver } from "../resolve.js";
+import type { Tuple, Value } from "../types.js";
+import type { SyncEvalContext } from "./context.js";
+export declare function evalFunction(expr: BoundExpression, tuple: Tuple, resolver: Resolver, ctx: SyncEvalContext): Value;

package/dist/executor/evaluate/functions/md5.d.ts

@@ -0,0 +1 @@
+export declare function md5(input: string): string;

package/dist/executor/evaluate/functions/normalize-json.d.ts

@@ -0,0 +1,8 @@
+import type { JsonValue } from '../../../types.js';
+/**
+ * Recursively normalize a JSON value for canonical serialization:
+ * - Object keys are sorted lexicographically
+ * - Array order is preserved
+ * - Primitives pass through unchanged
+ */
+export declare function normalizeJson(value: JsonValue): JsonValue;

package/dist/executor/evaluate/helpers.d.ts

@@ -0,0 +1,14 @@
+import type { ComparisonType } from "../../binder/types.js";
+import type { Value } from "../types.js";
+/** SQL truthiness: only boolean true passes filters */
+export declare function isTruthy(v: Value): boolean;
+/** Compare two non-null values. Numbers compare numerically, else as strings. */
+export declare function compareValues(a: Value, b: Value): number;
+/** Apply comparison operator to two values with NULL propagation. */
+export declare function applyComparison(left: Value, right: Value, comparisonType: ComparisonType): Value;
+/** Convert SQL LIKE pattern to RegExp. */
+export declare function likeToRegex(pattern: string): RegExp;
+/** Serialize a value to a string for hashing (joins, distinct, group by). */
+export declare function serializeValue(v: Value): string;
+/** Cast a value to a target type. */
+export declare function castValue(v: Value, targetType: string): Value;

package/dist/executor/evaluate/index.d.ts

@@ -0,0 +1,6 @@
+import type { BoundExpression } from "../../binder/types.js";
+import type { Resolver } from "../resolve.js";
+import type { Tuple, Value } from "../types.js";
+import type { SyncEvalContext } from "./context.js";
+export { type SyncEvalContext } from "./context.js";
+export declare function evaluateExpression(expr: BoundExpression, tuple: Tuple, resolver: Resolver, ctx: SyncEvalContext): Value;

package/dist/executor/evaluate/json-access.d.ts

@@ -0,0 +1,7 @@
+import type { BoundExpression } from "../../binder/types.js";
+import type { JsonPathSegment } from "../../types.js";
+import type { Resolver } from "../resolve.js";
+import type { Tuple, Value } from "../types.js";
+import type { SyncEvalContext } from "./context.js";
+export declare function evalJsonAccess(expr: BoundExpression, tuple: Tuple, resolver: Resolver, ctx: SyncEvalContext): Value;
+export declare function traverseJsonPath(obj: Value, path: JsonPathSegment[]): Value;

package/dist/executor/evaluate/operator.d.ts

@@ -0,0 +1,5 @@
+import type { BoundExpression } from '../../binder/types.js';
+import type { Value, Tuple } from '../types.js';
+import type { Resolver } from '../resolve.js';
+import type { SyncEvalContext } from './context.js';
+export declare function evalOperator(expr: BoundExpression, tuple: Tuple, resolver: Resolver, ctx: SyncEvalContext): Value;

package/dist/executor/evaluate/parameter.d.ts

@@ -0,0 +1,4 @@
+import type { BoundParameterExpression } from "../../binder/types.js";
+import type { Value } from "../types.js";
+import type { SyncEvalContext } from "./context.js";
+export declare function evalParameter(expr: BoundParameterExpression, ctx: SyncEvalContext): Value;

package/dist/executor/evaluate/subquery.d.ts

@@ -0,0 +1,5 @@
+import type { BoundExpression } from "../../binder/types.js";
+import type { Resolver } from "../resolve.js";
+import type { Tuple, Value } from "../types.js";
+import type { SyncEvalContext } from "./context.js";
+export declare function evalSubquery(expr: BoundExpression, tuple: Tuple, resolver: Resolver, ctx: SyncEvalContext): Value;

package/dist/executor/evaluate/utils/cast.d.ts

@@ -0,0 +1,7 @@
+import type { Value } from "../../types.js";
+/** Cast a value to a target type. */
+export declare function castValue(v: Value, targetType: string): Value;
+export declare function castText(v: Value): string;
+export declare function castJson(v: Value): any;
+export declare function blobToHex(buf: Uint8Array): string;
+export declare function hexToBlob(hex: string): Uint8Array;

package/dist/executor/evaluate/utils/compare.d.ts

@@ -0,0 +1,8 @@
+import type { ComparisonType } from "../../../binder/types.js";
+import type { Value } from "../../types.js";
+/** SQL truthiness: only boolean true passes filters */
+export declare function isTruthy(v: Value): boolean;
+/** Compare two non-null values. Numbers compare numerically, else as strings. */
+export declare function compareValues(a: Value, b: Value): number;
+/** Apply comparison operator to two values with NULL propagation. */
+export declare function applyComparison(left: Value, right: Value, comparisonType: ComparisonType): Value;

package/dist/executor/evaluate/utils/like.d.ts

@@ -0,0 +1,2 @@
+/** Convert SQL LIKE pattern to RegExp. */
+export declare function likeToRegex(pattern: string): RegExp;

package/dist/executor/evaluate/utils/serialize.d.ts

@@ -0,0 +1,3 @@
+import type { Value } from "../../types.js";
+/** Serialize a value to a string for hashing (joins, distinct, group by). */
+export declare function serializeValue(v: Value): string;

package/dist/executor/execute/index.d.ts

@@ -0,0 +1,4 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import type { ICatalog, SyncIIndexManager, SyncIRowManager } from "../../store/types.js";
+import type { ExecuteResult, Value } from "../types.js";
+export declare function execute(plan: LogicalOperator, rowManager: SyncIRowManager, catalog: ICatalog, indexManager?: SyncIIndexManager, params?: readonly Value[]): ExecuteResult;

package/dist/executor/execute/result.d.ts

@@ -0,0 +1,5 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import type { Row } from "../../store/types.js";
+import type { Tuple } from "../types.js";
+export declare function extractColumnNames(plan: LogicalOperator): string[];
+export declare function tuplesToRows(tuples: Tuple[], columnNames: string[]): Row[];

package/dist/executor/execute/select.d.ts

@@ -0,0 +1,8 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import type { ICatalog, SyncIIndexManager, SyncIRowManager } from "../../store/types.js";
+import type { SyncEvalContext } from "../evaluate/context.js";
+import type { Resolver } from "../resolve.js";
+import type { ExecuteResult, Tuple, Value } from "../types.js";
+export declare function createEvalContext(rowManager: SyncIRowManager, catalog: ICatalog, params?: readonly Value[], outerTuple?: Tuple, outerResolver?: Resolver): SyncEvalContext;
+export declare function executeSelect(plan: LogicalOperator, rowManager: SyncIRowManager, ctx: SyncEvalContext, indexManager?: SyncIIndexManager): ExecuteResult;
+export declare function executeSubplan(plan: LogicalOperator, rowManager: SyncIRowManager, catalog: ICatalog, outerTuple?: Tuple, outerResolver?: Resolver, limit?: number, params?: readonly Value[]): Tuple[];

package/dist/executor/executor.d.ts

@@ -0,0 +1,5 @@
+import type { LogicalOperator } from "../binder/types.js";
+import type { SyncIIndexManager, SyncIRowManager } from "../store/types.js";
+import type { ICatalog } from "../store/types.js";
+import type { ExecuteResult, Value } from "./types.js";
+export declare function execute(plan: LogicalOperator, rowManager: SyncIRowManager, catalog: ICatalog, indexManager?: SyncIIndexManager, params?: readonly Value[]): ExecuteResult;

package/dist/executor/index.d.ts

@@ -0,0 +1,3 @@
+export { execute } from './executor.js';
+export { ExecutorError } from './errors.js';
+export type { ExecuteResult, CatalogChange, Value, Tuple, PhysicalOperator, CTECacheEntry, } from './types.js';

package/dist/executor/operators/aggregate.d.ts

@@ -0,0 +1,22 @@
+import type { ColumnBinding, LogicalAggregate } from "../../binder/types.js";
+import type { SyncEvalContext } from "../evaluate/context.js";
+import type { SyncPhysicalOperator, Tuple } from "../types.js";
+export declare class PhysicalHashAggregate implements SyncPhysicalOperator {
+    private readonly child;
+    private readonly op;
+    private readonly ctx;
+    private readonly layout;
+    private readonly childResolver;
+    private emitted;
+    constructor(child: SyncPhysicalOperator, op: LogicalAggregate, ctx: SyncEvalContext);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+    private buildGroups;
+    private computeGroupKey;
+    private newAggStates;
+    private updateAgg;
+    private finalize;
+    private finalizeAgg;
+    private applyHaving;
+}

package/dist/executor/operators/cte.d.ts

@@ -0,0 +1,37 @@
+import type { LogicalCTERef, ColumnBinding } from '../../binder/types.js';
+import type { SyncPhysicalOperator, Tuple, CTECacheEntry } from '../types.js';
+export declare class PhysicalMaterialize implements SyncPhysicalOperator {
+    private readonly cteDefinition;
+    private readonly mainPlan;
+    private readonly cteIndex;
+    private readonly cteCache;
+    private materialized;
+    constructor(cteDefinition: SyncPhysicalOperator, mainPlan: SyncPhysicalOperator, cteIndex: number, cteCache: Map<number, CTECacheEntry>);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+}
+export declare class PhysicalCTEScan implements SyncPhysicalOperator {
+    private readonly op;
+    private readonly cteCache;
+    private offset;
+    private readonly layout;
+    constructor(op: LogicalCTERef, cteCache: Map<number, CTECacheEntry>);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+}
+export declare class PhysicalRecursiveCTE implements SyncPhysicalOperator {
+    private readonly anchor;
+    private readonly recursive;
+    private readonly cteIndex;
+    private readonly cteCache;
+    private readonly isUnionAll;
+    private result;
+    private offset;
+    constructor(anchor: SyncPhysicalOperator, recursive: SyncPhysicalOperator, cteIndex: number, cteCache: Map<number, CTECacheEntry>, isUnionAll: boolean);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+    private execute;
+}

package/dist/executor/operators/filter.d.ts

@@ -0,0 +1,13 @@
+import type { BoundExpression, ColumnBinding } from "../../binder/types.js";
+import type { SyncEvalContext } from "../evaluate/context.js";
+import type { SyncPhysicalOperator, Tuple } from "../types.js";
+export declare class PhysicalFilter implements SyncPhysicalOperator {
+    private readonly child;
+    private readonly condition;
+    private readonly ctx;
+    private readonly resolver;
+    constructor(child: SyncPhysicalOperator, condition: BoundExpression, ctx: SyncEvalContext);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+}

package/dist/executor/operators/index-min-max.d.ts

@@ -0,0 +1,18 @@
+import type { ColumnBinding, LogicalAggregate } from "../../binder/types.js";
+import type { IndexDef, SyncIIndexManager } from "../../store/types.js";
+import type { SyncPhysicalOperator, Tuple } from "../types.js";
+export declare class PhysicalIndexMinMax implements SyncPhysicalOperator {
+    private readonly agg;
+    private readonly indexManager;
+    private readonly hint;
+    private emitted;
+    private readonly layout;
+    constructor(agg: LogicalAggregate, indexManager: SyncIIndexManager, hint: {
+        indexDef: IndexDef;
+        functionName: "MIN" | "MAX";
+        keyPosition: number;
+    });
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+}

package/dist/executor/operators/index-scan.d.ts

@@ -0,0 +1,22 @@
+import type { ColumnBinding, IndexSearchPredicate, LogicalGet, TableFilter } from "../../binder/types.js";
+import type { IndexDef, SyncIIndexManager, SyncIRowManager } from "../../store/types.js";
+import type { SyncEvalContext } from "../evaluate/context.js";
+import type { SyncPhysicalOperator, Tuple } from "../types.js";
+export declare class PhysicalIndexScan implements SyncPhysicalOperator {
+    private readonly op;
+    private readonly rowManager;
+    private readonly indexManager;
+    private readonly indexDef;
+    private readonly indexPredicates;
+    private readonly ctx;
+    private rowIds;
+    private cursor;
+    private done;
+    private readonly layout;
+    private readonly compiledResiduals;
+    constructor(op: LogicalGet, rowManager: SyncIRowManager, indexManager: SyncIIndexManager, indexDef: IndexDef, indexPredicates: IndexSearchPredicate[], residualFilters: TableFilter[], ctx: SyncEvalContext);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+    private fetchRowIds;
+}

package/dist/executor/operators/index-union-scan.d.ts

@@ -0,0 +1,22 @@
+import type { ColumnBinding, IndexUnionHint, LogicalGet } from "../../binder/types.js";
+import type { SyncIIndexManager, SyncIRowManager } from "../../store/types.js";
+import type { SyncEvalContext } from "../evaluate/context.js";
+import type { SyncPhysicalOperator, Tuple } from "../types.js";
+export declare class PhysicalIndexUnionScan implements SyncPhysicalOperator {
+    private readonly op;
+    private readonly rowManager;
+    private readonly indexManager;
+    private readonly hint;
+    private readonly ctx;
+    private rowIds;
+    private cursor;
+    private done;
+    private readonly layout;
+    private readonly resolver;
+    private readonly residualExpr;
+    constructor(op: LogicalGet, rowManager: SyncIRowManager, indexManager: SyncIIndexManager, hint: IndexUnionHint, ctx: SyncEvalContext);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+    private fetchUnionRowIds;
+}

package/dist/executor/operators/join.d.ts

@@ -0,0 +1,36 @@
+import type { ColumnBinding, LogicalComparisonJoin } from "../../binder/types.js";
+import type { SyncEvalContext } from "../evaluate/context.js";
+import type { SyncPhysicalOperator, Tuple } from "../types.js";
+export declare class PhysicalHashJoin implements SyncPhysicalOperator {
+    private readonly probe;
+    private readonly build;
+    private readonly op;
+    private readonly ctx;
+    private readonly layout;
+    private readonly probeResolver;
+    private readonly buildResolver;
+    private readonly buildNullTuple;
+    private hashTable;
+    private emitter;
+    constructor(probe: SyncPhysicalOperator, build: SyncPhysicalOperator, op: LogicalComparisonJoin, ctx: SyncEvalContext);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+    private buildHashTable;
+    private emitMatches;
+    private emitSemiAnti;
+    private probeTuples;
+    private evalKey;
+}
+export declare class PhysicalNestedLoopJoin implements SyncPhysicalOperator {
+    private readonly left;
+    private readonly right;
+    private readonly layout;
+    private rightTuples;
+    private emitter;
+    constructor(left: SyncPhysicalOperator, right: SyncPhysicalOperator);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+    private emitCrossProduct;
+}

package/dist/executor/operators/limit.d.ts

@@ -0,0 +1,13 @@
+import type { LogicalLimit, ColumnBinding } from '../../binder/types.js';
+import type { SyncPhysicalOperator, Tuple } from '../types.js';
+export declare class PhysicalLimit implements SyncPhysicalOperator {
+    private readonly child;
+    private readonly op;
+    private skipped;
+    private emitted;
+    private readonly maxRows;
+    constructor(child: SyncPhysicalOperator, op: LogicalLimit);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+}

package/dist/executor/operators/projection.d.ts

@@ -0,0 +1,14 @@
+import type { LogicalProjection, ColumnBinding } from '../../binder/types.js';
+import type { SyncPhysicalOperator, Tuple } from '../types.js';
+import type { SyncEvalContext } from '../evaluate/context.js';
+export declare class PhysicalProjection implements SyncPhysicalOperator {
+    private readonly child;
+    private readonly op;
+    private readonly ctx;
+    private readonly resolver;
+    private readonly layout;
+    constructor(child: SyncPhysicalOperator, op: LogicalProjection, ctx: SyncEvalContext);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+}

package/dist/executor/operators/scan.d.ts

@@ -0,0 +1,29 @@
+import type { ColumnBinding, LogicalGet } from "../../binder/types.js";
+import type { SyncIRowManager } from "../../store/types.js";
+import type { SyncEvalContext } from "../evaluate/context.js";
+import type { SyncPhysicalOperator, Tuple } from "../types.js";
+export declare class PhysicalScan implements SyncPhysicalOperator {
+    private readonly op;
+    private readonly rowManager;
+    private readonly ctx;
+    private iterator;
+    private done;
+    private readonly layout;
+    private readonly compiledFilters;
+    constructor(op: LogicalGet, rowManager: SyncIRowManager, ctx: SyncEvalContext);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+}
+export declare class PhysicalChildScan implements SyncPhysicalOperator {
+    private readonly op;
+    private readonly childOp;
+    private readonly ctx;
+    private done;
+    private readonly layout;
+    private readonly compiledFilters;
+    constructor(op: LogicalGet, childOp: SyncPhysicalOperator, ctx: SyncEvalContext);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+}

package/dist/executor/operators/set.d.ts

@@ -0,0 +1,22 @@
+import type { ColumnBinding } from '../../binder/types.js';
+import type { SyncPhysicalOperator, Tuple } from '../types.js';
+export declare class PhysicalDistinct implements SyncPhysicalOperator {
+    private readonly child;
+    private readonly seen;
+    constructor(child: SyncPhysicalOperator);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+}
+export declare class PhysicalUnion implements SyncPhysicalOperator {
+    private readonly left;
+    private readonly right;
+    private readonly all;
+    private leftDone;
+    private readonly seen;
+    constructor(left: SyncPhysicalOperator, right: SyncPhysicalOperator, all: boolean);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+    private dedup;
+}

package/dist/executor/operators/sort.d.ts

@@ -0,0 +1,18 @@
+import type { LogicalOrderBy, ColumnBinding } from '../../binder/types.js';
+import type { SyncPhysicalOperator, Tuple } from '../types.js';
+import type { SyncEvalContext } from '../evaluate/context.js';
+export declare class PhysicalSort implements SyncPhysicalOperator {
+    private readonly child;
+    private readonly op;
+    private readonly ctx;
+    private sorted;
+    private offset;
+    constructor(child: SyncPhysicalOperator, op: LogicalOrderBy, ctx: SyncEvalContext);
+    getLayout(): ColumnBinding[];
+    next(): Tuple[] | null;
+    reset(): void;
+    private compare;
+    private computeKeys;
+    private sortAll;
+    private topKSort;
+}

package/dist/executor/operators/utils.d.ts

@@ -0,0 +1,10 @@
+import type { TableSchema, BoundConstantExpression, BoundParameterExpression } from '../../binder/types.js';
+import type { CompiledFilter } from '../evaluate/compile.js';
+import type { SyncPhysicalOperator, Tuple, Value } from '../types.js';
+export declare const SCAN_BATCH = 500;
+export declare const JOIN_BATCH = 2000;
+export declare function resolveFilterValue(constant: BoundConstantExpression | BoundParameterExpression, params?: readonly Value[]): Value;
+export declare function serializeKey(values: Value[]): string;
+export declare function rowToTuple(row: Record<string, Value>, columnIds: number[], schema: TableSchema): Tuple;
+export declare function passesCompiledFilters(tuple: Tuple, filters: CompiledFilter[], params?: readonly Value[]): boolean;
+export declare function drainOperator(op: SyncPhysicalOperator): Tuple[];

package/dist/executor/planner/index.d.ts

@@ -0,0 +1,5 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import type { SyncIIndexManager, SyncIRowManager } from "../../store/types.js";
+import type { SyncEvalContext } from "../evaluate/context.js";
+import type { CTECacheEntry, SyncPhysicalOperator } from "../types.js";
+export declare function createPhysicalPlan(node: LogicalOperator, rowManager: SyncIRowManager, cteCache: Map<number, CTECacheEntry>, ctx: SyncEvalContext, indexManager?: SyncIIndexManager): SyncPhysicalOperator;

package/dist/executor/planner/plan-aggregate.d.ts

@@ -0,0 +1,5 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import { PhysicalHashAggregate } from "../operators/aggregate.js";
+import { PhysicalIndexMinMax } from "../operators/index-min-max.js";
+import type { PlannerContext } from "./types.js";
+export declare function planAggregate(node: LogicalOperator, pc: PlannerContext): PhysicalHashAggregate | PhysicalIndexMinMax;

package/dist/executor/planner/plan-cte.d.ts

@@ -0,0 +1,6 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import { PhysicalCTEScan, PhysicalMaterialize, PhysicalRecursiveCTE } from "../operators/cte.js";
+import type { PlannerContext } from "./types.js";
+export declare function planMaterializedCTE(node: LogicalOperator, pc: PlannerContext): PhysicalMaterialize;
+export declare function planRecursiveCTE(node: LogicalOperator, pc: PlannerContext): PhysicalRecursiveCTE;
+export declare function planCTERef(node: LogicalOperator, pc: PlannerContext): PhysicalCTEScan;

package/dist/executor/planner/plan-filter.d.ts

@@ -0,0 +1,4 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import { PhysicalFilter } from "../operators/filter.js";
+import type { PlannerContext } from "./types.js";
+export declare function planFilter(node: LogicalOperator, pc: PlannerContext): PhysicalFilter;

package/dist/executor/planner/plan-get.d.ts

@@ -0,0 +1,6 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import { PhysicalIndexScan } from "../operators/index-scan.js";
+import { PhysicalIndexUnionScan } from "../operators/index-union-scan.js";
+import { PhysicalChildScan, PhysicalScan } from "../operators/scan.js";
+import type { PlannerContext } from "./types.js";
+export declare function planGet(node: LogicalOperator, pc: PlannerContext): PhysicalIndexScan | PhysicalIndexUnionScan | PhysicalScan | PhysicalChildScan;

package/dist/executor/planner/plan-join.d.ts

@@ -0,0 +1,5 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import { PhysicalHashJoin, PhysicalNestedLoopJoin } from "../operators/join.js";
+import type { PlannerContext } from "./types.js";
+export declare function planComparisonJoin(node: LogicalOperator, pc: PlannerContext): PhysicalHashJoin;
+export declare function planCrossProduct(node: LogicalOperator, pc: PlannerContext): PhysicalNestedLoopJoin;

package/dist/executor/planner/plan-limit.d.ts

@@ -0,0 +1,4 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import { PhysicalLimit } from "../operators/limit.js";
+import type { PlannerContext } from "./types.js";
+export declare function planLimit(node: LogicalOperator, pc: PlannerContext): PhysicalLimit;

package/dist/executor/planner/plan-order-by.d.ts

@@ -0,0 +1,4 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import { PhysicalSort } from "../operators/sort.js";
+import type { PlannerContext } from "./types.js";
+export declare function planOrderBy(node: LogicalOperator, pc: PlannerContext): PhysicalSort;

package/dist/executor/planner/plan-projection.d.ts

@@ -0,0 +1,4 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import { PhysicalProjection } from "../operators/projection.js";
+import type { PlannerContext } from "./types.js";
+export declare function planProjection(node: LogicalOperator, pc: PlannerContext): PhysicalProjection;

package/dist/executor/planner/plan-set.d.ts

@@ -0,0 +1,5 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import { PhysicalDistinct, PhysicalUnion } from "../operators/set.js";
+import type { PlannerContext } from "./types.js";
+export declare function planDistinct(node: LogicalOperator, pc: PlannerContext): PhysicalDistinct;
+export declare function planUnion(node: LogicalOperator, pc: PlannerContext): PhysicalUnion;

package/dist/executor/planner/types.d.ts

@@ -0,0 +1,12 @@
+import type { LogicalOperator } from "../../binder/types.js";
+import type { SyncIIndexManager, SyncIRowManager } from "../../store/types.js";
+import type { SyncEvalContext } from "../evaluate/context.js";
+import type { CTECacheEntry, SyncPhysicalOperator } from "../types.js";
+export interface PlannerContext {
+    rowManager: SyncIRowManager;
+    cteCache: Map<number, CTECacheEntry>;
+    ctx: SyncEvalContext;
+    indexManager?: SyncIIndexManager;
+    plan: (child: LogicalOperator) => SyncPhysicalOperator;
+}
+export type PlanHandler = (node: LogicalOperator, pc: PlannerContext) => SyncPhysicalOperator;

package/dist/executor/planner.d.ts

@@ -0,0 +1,5 @@
+import type { LogicalOperator } from "../binder/types.js";
+import type { SyncIIndexManager, SyncIRowManager } from "../store/types.js";
+import type { SyncEvalContext } from "./evaluate/context.js";
+import type { CTECacheEntry, SyncPhysicalOperator } from "./types.js";
+export declare function createPhysicalPlan(node: LogicalOperator, rowManager: SyncIRowManager, cteCache: Map<number, CTECacheEntry>, ctx: SyncEvalContext, indexManager?: SyncIIndexManager): SyncPhysicalOperator;

package/dist/executor/resolve.d.ts

@@ -0,0 +1,3 @@
+import type { ColumnBinding } from '../binder/types.js';
+export type Resolver = (binding: ColumnBinding) => number | undefined;
+export declare function buildResolver(layout: ColumnBinding[]): Resolver;

package/dist/executor/tests/compile.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/executor/tests/ddl-dml.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/executor/tests/evaluate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/executor/tests/executor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/executor/tests/functions.test.d.ts

@@ -0,0 +1 @@
+export {};