@slexisvn/query-engine 0.1.0

package/dist/execution/builders/source-builders.d.ts

@@ -0,0 +1,23 @@
+import { ScanOperator } from '../operators/scan.js';
+import { IndexScanOperator } from '../operators/index-scan.js';
+import type { ColumnMapping, CompiledPipeline, ExecSchema } from '../execution-types.js';
+import type { LogicalPlanNode, LogicalScanNode, LogicalIndexScanNode, LogicalSingleRowNode, LogicalEmptyNode } from '../../planner/logical-plan.js';
+import type { ColumnInfo } from '../../binder/scope.js';
+type ScanStorage = ConstructorParameters<typeof ScanOperator>[0];
+type IndexStorage = ConstructorParameters<typeof IndexScanOperator>[1];
+type IndexBTree = ConstructorParameters<typeof IndexScanOperator>[0];
+interface CatalogLike {
+    getTableStorage(name: string): (ScanStorage & IndexStorage) | null;
+    getIndexForColumn(table: string, column: string): IndexBTree | null;
+}
+interface ExecutorLike {
+    catalog: CatalogLike;
+    buildPipeline(node: LogicalPlanNode): Promise<CompiledPipeline>;
+    resolveProjectedColumnIndexes(schema: ExecSchema, planColumns: ColumnInfo[] | null): number[] | null;
+    buildSchemaMapping(schema: ExecSchema, alias: string): ColumnMapping;
+}
+export declare function buildScan(executor: ExecutorLike, node: LogicalScanNode): Promise<CompiledPipeline>;
+export declare function buildIndexScan(executor: ExecutorLike, node: LogicalIndexScanNode): Promise<CompiledPipeline>;
+export declare function buildSingleRow(executor: ExecutorLike, node: LogicalSingleRowNode): Promise<CompiledPipeline>;
+export declare function buildEmpty(executor: ExecutorLike, node: LogicalEmptyNode): Promise<CompiledPipeline>;
+export {};

package/dist/execution/column-resolve.d.ts

@@ -0,0 +1,7 @@
+import type { BoundColumnRefNode } from '../binder/expression-binder.js';
+import type { ColumnMapping } from './execution-types.js';
+interface ResolveColumnIndexOpts {
+    clampNegative?: boolean;
+}
+export declare function resolveColumnIndex(expr: BoundColumnRefNode, columnMapping: ColumnMapping | null, opts?: ResolveColumnIndexOpts): number;
+export {};

package/dist/execution/execution-types.d.ts

@@ -0,0 +1,33 @@
+import type { DataChunk } from '../storage/chunk.js';
+import type { ColumnValue, DataType } from '../storage/data-type.js';
+import type { PipelineGraph, CancelToken } from './pipeline.js';
+export type ColumnMapping = Map<string, number>;
+export interface IntervalValue {
+    value: number;
+    unit: string;
+    _isInterval: true;
+}
+export type EvalValue = ColumnValue | IntervalValue | undefined;
+export type CompiledExpr = (chunk: DataChunk, rowIdx: number) => EvalValue;
+export interface ExecColumn {
+    name: string;
+    dataType: DataType;
+    tableAlias?: string;
+    tableName?: string;
+    alias?: string;
+    outputName?: string;
+}
+export type ExecSchema = ExecColumn[];
+export interface Sink {
+    consume(chunk: DataChunk): Promise<void>;
+    finalize?(): Promise<void>;
+    init?(): Promise<void>;
+    error?(err: Error): void;
+    cancelToken?: CancelToken;
+}
+export interface CompiledPipeline {
+    schema: ExecSchema;
+    columnMapping: ColumnMapping;
+    register(graph: PipelineGraph, currentPipelineId: number, currentSink: Sink): void;
+}
+export type SourceGenerator = () => AsyncGenerator<DataChunk>;

package/dist/execution/expression-eval.d.ts

@@ -0,0 +1,13 @@
+import type { BoundExpr, BoundAggregateNode, BoundWindowNode } from '../binder/expression-binder.js';
+import type { CompiledExpr, ColumnMapping, ExecColumn } from './execution-types.js';
+interface MappingSchema {
+    columns?: ExecColumn[];
+    alias?: string;
+    tableName?: string;
+}
+export declare function compileExpression(expr: BoundExpr | null, columnMapping: ColumnMapping | null): CompiledExpr;
+declare function aggExprKey(expr: BoundAggregateNode): string;
+export { aggExprKey };
+declare function windowExprKey(expr: BoundWindowNode): string;
+export { windowExprKey };
+export declare function buildColumnMapping(schemas: MappingSchema[] | ExecColumn[][]): ColumnMapping;

package/dist/execution/fragment-spec.d.ts

@@ -0,0 +1,125 @@
+import { type LogicalPlanNode } from '../planner/logical-plan.js';
+import type { ColumnInfo } from '../binder/scope.js';
+import type { BoundExpr, BoundColumnRefNode, BoundAggregateNode } from '../binder/expression-binder.js';
+import { DataType } from '../storage/data-type.js';
+import { FilterOperator } from './operators/filter.js';
+import { ProjectionOperator } from './operators/projection.js';
+import { HashAggregateOperator, getAccumulatorFactory } from './operators/hash-aggregate.js';
+import type { CompiledExpr, ColumnMapping, ExecSchema } from './execution-types.js';
+export declare enum StageKind {
+    FILTER = "filter",
+    PROJECT = "project"
+}
+interface FilterStage {
+    kind: StageKind.FILTER;
+    condition: BoundExpr | null;
+}
+interface ProjectStage {
+    kind: StageKind.PROJECT;
+    expressions: BoundExpr[];
+}
+export type Stage = FilterStage | ProjectStage;
+interface AggregateSpec {
+    name: string;
+    distinct: boolean;
+    args: BoundExpr[];
+}
+interface AggregateDef {
+    name: string;
+    valueKey: string | null;
+    resultType: DataType;
+    createAccumulator: ReturnType<typeof getAccumulatorFactory>;
+    extractValue: CompiledExpr;
+    _wasmColIndex?: number;
+    _sourceExpr: BoundExpr | null;
+    _columnMapping: ColumnMapping;
+}
+interface StageChain {
+    table: string;
+    alias: string;
+    scanColumns: ColumnInfo[];
+    stages: Stage[];
+}
+export interface FragmentSpec {
+    baseSchema: ExecSchema;
+    stages: Stage[];
+    groupBy: BoundExpr[];
+    aggregates: AggregateSpec[];
+}
+interface BuiltFragmentSpec {
+    spec: FragmentSpec;
+    columnIndexes: number[];
+    estimatedRowBytes: number;
+}
+interface InstantiatedStages {
+    operators: (FilterOperator | ProjectionOperator)[];
+    schema: ExecSchema;
+    mapping: ColumnMapping;
+}
+interface InstantiatedFragment {
+    operators: (FilterOperator | ProjectionOperator)[];
+    aggregate: HashAggregateOperator;
+}
+interface SideSpec {
+    baseSchema: ExecSchema;
+    stages: Stage[];
+    schema: ExecSchema;
+}
+interface JoinSpecInput {
+    build: SideSpec;
+    probe: SideSpec;
+    buildKeys: BoundExpr[];
+    probeKeys: BoundExpr[];
+    residualCondition: BoundExpr | null;
+    joinType: string;
+    buildPreserved: boolean;
+    uniqueKeys: boolean;
+    buildMapping: ColumnMapping;
+    probeMapping: ColumnMapping;
+    combinedMapping: ColumnMapping;
+}
+export interface JoinSpec {
+    build: SideSpec;
+    probe: SideSpec;
+    buildKeys: BoundExpr[];
+    probeKeys: BoundExpr[];
+    residualCondition: BoundExpr | null;
+    joinType: string;
+    buildPreserved: boolean;
+    uniqueKeys: boolean;
+    buildColCount: number;
+    probeColCount: number;
+}
+interface InstantiatedJoinSpec {
+    buildOperators: (FilterOperator | ProjectionOperator)[];
+    probeOperators: (FilterOperator | ProjectionOperator)[];
+    buildExtractors: CompiledExpr[];
+    probeExtractors: CompiledExpr[];
+    conditionEvaluator: CompiledExpr | null;
+}
+interface AggregateLike {
+    name?: string;
+}
+export declare function normalizeExecType(dt: DataType | string): DataType;
+export declare function normalizeAggResultType(agg: BoundAggregateNode | AggregateLike): DataType;
+export declare function expressionCacheKey(expr: BoundExpr | null): string;
+export declare function schemaMappingOf(schema: ExecSchema): ColumnMapping;
+export declare function projectionSchemaOf(expressions: BoundExpr[]): ExecSchema;
+export declare function collectColumnRefs(node: BoundExpr | BoundExpr[] | null, acc?: BoundColumnRefNode[]): BoundColumnRefNode[];
+export declare function resolveRef(ref: BoundColumnRefNode, mapping: ColumnMapping): number | undefined;
+export declare function buildAggregateDefs(aggregates: AggregateSpec[], columnMapping: ColumnMapping): AggregateDef[];
+export declare function extractStageChain(startNode: LogicalPlanNode | null): StageChain | null;
+export declare function extractAggregateFragment(node: LogicalPlanNode): StageChain | null;
+export declare function stagedSchemaOf(baseSchema: ExecSchema, stages: Stage[]): ExecSchema;
+export declare function instantiateStages(baseSchema: ExecSchema, stages: Stage[]): InstantiatedStages;
+export declare function buildFragmentSpec(fragment: StageChain, node: LogicalPlanNode & {
+    groupBy?: BoundExpr[];
+    aggregates: BoundExpr[];
+}, storageSchema: ExecSchema): BuiltFragmentSpec | null;
+export declare function instantiateFragment(spec: FragmentSpec): InstantiatedFragment;
+export declare function instantiateAggregate(spec: FragmentSpec): HashAggregateOperator;
+export declare function plainSchemaOf(schema: ExecSchema): ExecSchema;
+export declare function schemasEqual(a: ExecSchema, b: ExecSchema): boolean;
+export declare function buildJoinSpec({ build, probe, buildKeys, probeKeys, residualCondition, joinType, buildPreserved, uniqueKeys, buildMapping, probeMapping, combinedMapping, }: JoinSpecInput): JoinSpec | null;
+export declare function instantiateJoinSpec(spec: JoinSpec): InstantiatedJoinSpec;
+export {};

package/dist/execution/join-utils.d.ts

@@ -0,0 +1,14 @@
+import type { BoundExpr, BoundColumnRefNode } from '../binder/expression-binder.js';
+import type { ColumnMapping } from './execution-types.js';
+export interface JoinKeyPair {
+    buildKey: BoundColumnRefNode;
+    probeKey: BoundColumnRefNode;
+}
+export interface ExtractedJoinKeys {
+    buildKeys: BoundExpr[];
+    probeKeys: BoundExpr[];
+    residualCondition: BoundExpr | null;
+}
+export declare function splitAnd(expr: BoundExpr | null): BoundExpr[];
+export declare function findCommonEquiJoinKeys(expr: BoundExpr | null, leftMapping: ColumnMapping, rightMapping: ColumnMapping): JoinKeyPair | null;
+export declare function extractJoinKeys(condition: BoundExpr | null, leftMapping: ColumnMapping, rightMapping: ColumnMapping): ExtractedJoinKeys;

package/dist/execution/operator-registry.d.ts

@@ -0,0 +1,9 @@
+export type OperatorArg = string | number | boolean | object | null;
+export type OperatorFactory = (...args: OperatorArg[]) => object;
+export declare class OperatorRegistry {
+    factories: Map<string, OperatorFactory>;
+    constructor();
+    register(logicalType: string, factory: OperatorFactory): this;
+    create(logicalType: string, ...args: OperatorArg[]): object;
+    has(logicalType: string): boolean;
+}

package/dist/execution/operators/agg-wasm.d.ts

@@ -0,0 +1,16 @@
+import { globalDispatch } from '../../wasm/dispatch.js';
+import { DataType } from '../../storage/data-type.js';
+type GlobalDispatch = typeof globalDispatch;
+interface AggregateDef {
+    name: string;
+    resultType: DataType;
+}
+export interface ResolvedKernel {
+    kernelKey: string | null;
+    dataType: string | null;
+    kind: string;
+}
+export type ScalarReduceKernel = (data: Float64Array | Int32Array) => number | Promise<number>;
+export type BitmapCountKernel = (bitmap: Uint32Array, count: number) => number | Promise<number>;
+export declare function resolveWasmAggKernel(def: AggregateDef, globalDispatch: GlobalDispatch): ResolvedKernel | null;
+export {};

package/dist/execution/operators/dedup-core.d.ts

@@ -0,0 +1,10 @@
+import { DataChunk } from '../../storage/chunk.js';
+import type { DataType } from '../../storage/data-type.js';
+export interface DedupTarget {
+    seen: Set<string>;
+    schema: DataType[] | null;
+    _legacyChunks: DataChunk[];
+}
+export declare function dedupProcess(target: DedupTarget, chunk: DataChunk): DataChunk;
+export declare function dedupConsume(target: DedupTarget, result: DataChunk): Promise<void>;
+export declare function dedupFinalize(target: DedupTarget): DataChunk[];

package/dist/execution/operators/dependent-join.d.ts

@@ -0,0 +1,14 @@
+import { DataChunk } from '../../storage/chunk.js';
+import type { ColumnValue } from '../../storage/data-type.js';
+import type { ExecSchema } from '../execution-types.js';
+type JoinRow = ColumnValue[];
+export declare class DependentJoinOperator {
+    subqueryType: string;
+    outerSchema: ExecSchema;
+    resultRows: JoinRow[];
+    resultSchema: ExecSchema;
+    constructor(subqueryType: string, outerSchema: ExecSchema);
+    processOuterRow(outerRow: JoinRow, subResultChunks: DataChunk[]): Promise<void>;
+    finalize(): Promise<DataChunk[]>;
+}
+export {};

package/dist/execution/operators/distinct.d.ts

@@ -0,0 +1,12 @@
+import { DataChunk } from '../../storage/chunk.js';
+import type { DataType } from '../../storage/data-type.js';
+export declare class DistinctOperator {
+    seen: Set<string>;
+    schema: DataType[] | null;
+    _legacyChunks: DataChunk[];
+    constructor();
+    init(): Promise<void>;
+    process(chunk: DataChunk): Promise<DataChunk>;
+    consume(chunk: DataChunk): Promise<void>;
+    finalize(): Promise<DataChunk[]>;
+}

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

@@ -0,0 +1,87 @@
+import { DataChunk, AnyColumn, SelectionVector } from '../../storage/chunk.js';
+import { BoundExprKind } from '../../binder/expression-binder.js';
+import type { BoundExpr, BoundColumnRefNode } from '../../binder/expression-binder.js';
+import type { AnyTypedArray, ColumnValue, DataType } from '../../storage/data-type.js';
+import type { CompiledExpr, ColumnMapping } from '../execution-types.js';
+interface BoundComparisonNode {
+    kind: BoundExprKind.COMPARISON;
+    op: string;
+    left: BoundExpr;
+    right: BoundExpr;
+    dataType?: string | null;
+}
+type PredicateExpr = BoundExpr | BoundComparisonNode;
+interface ParallelFilterResult {
+    selectionVector: Uint32Array;
+    matchCount: number;
+}
+interface ParallelDispatch {
+    canParallelize(op: string, dt: DataType, n: number): boolean;
+    filterParallel(data: AnyTypedArray, len: number, op: string, dt: DataType, args: {
+        value?: ColumnValue;
+        low?: ColumnValue;
+        high?: ColumnValue;
+    }): Promise<ParallelFilterResult | null>;
+}
+interface SimpleFilterPlan {
+    type: 'simple';
+    operation: string;
+    dataType: DataType;
+    columnIndex: number;
+    value: ColumnValue;
+}
+interface BetweenFilterPlan {
+    type: 'between';
+    operation: string;
+    dataType: DataType;
+    columnIndex: number;
+    low: ColumnValue;
+    high: ColumnValue;
+}
+interface AndFilterPlan {
+    type: 'and';
+    left: FilterPlan;
+    right: FilterPlan;
+}
+interface OrFilterPlan {
+    type: 'or';
+    left: FilterPlan;
+    right: FilterPlan;
+}
+type FilterPlan = SimpleFilterPlan | BetweenFilterPlan | AndFilterPlan | OrFilterPlan;
+export declare class FilterOperator {
+    predicate: PredicateExpr | null;
+    evaluator: CompiledExpr;
+    columnMapping: ColumnMapping | null;
+    parallelDispatch: ParallelDispatch | null;
+    constructor(predicate: PredicateExpr | null, evaluator: CompiledExpr, columnMapping: ColumnMapping | null, parallelDispatch: ParallelDispatch | null);
+    init(): Promise<void>;
+    process(chunk: DataChunk): Promise<DataChunk>;
+    _analyze(expr: PredicateExpr | null): FilterPlan | null;
+    _analyzeComparison(expr: PredicateExpr): FilterPlan | null;
+    _analyzeBetween(expr: PredicateExpr): FilterPlan | null;
+    _analyzeLogical(expr: PredicateExpr): FilterPlan | null;
+    _extractColumnAndLiteral(expr: PredicateExpr): {
+        columnRef: BoundColumnRefNode | null;
+        literal: ColumnValue;
+    };
+    _extractLiteralValue(expr: BoundExpr | null): ColumnValue;
+    _executeParallel(chunk: DataChunk, plan: FilterPlan): Promise<DataChunk | null>;
+    _executeSimple(chunk: DataChunk, plan: SimpleFilterPlan): Promise<DataChunk | null>;
+    _dropNullRows(column: AnyColumn, sv: Uint32Array, count: number): number;
+    _executeBetween(chunk: DataChunk, plan: BetweenFilterPlan): Promise<DataChunk | null>;
+    _executeAnd(chunk: DataChunk, plan: AndFilterPlan): Promise<DataChunk | null>;
+    _executeOr(chunk: DataChunk, plan: OrFilterPlan): Promise<DataChunk | null>;
+    _getColumnData(chunk: DataChunk, column: AnyColumn): AnyTypedArray | null;
+    _applySelectionVector(chunk: DataChunk, sv: SelectionVector, count: number): DataChunk;
+    _executeFallback(chunk: DataChunk): DataChunk;
+}
+export declare function intersectSorted(a: SelectionVector, aLen: number, b: SelectionVector, bLen: number): {
+    data: Uint32Array;
+    count: number;
+};
+export declare function unionSorted(a: SelectionVector, aLen: number, b: SelectionVector, bLen: number): {
+    data: Uint32Array;
+    count: number;
+};
+export {};

package/dist/execution/operators/hash-aggregate.d.ts

@@ -0,0 +1,121 @@
+import { DataChunk } from '../../storage/chunk.js';
+import { DataType, type ColumnValue } from '../../storage/data-type.js';
+import type { BoundExpr } from '../../binder/expression-binder.js';
+import type { CompiledExpr, ColumnMapping, EvalValue } from '../execution-types.js';
+type AvgState = {
+    sum: number;
+    count: number;
+};
+type AccumulatorState = ColumnValue | AvgState | ColumnValue[];
+interface Accumulator {
+    add(val: EvalValue): void;
+    result(): ColumnValue;
+    exportState(): AccumulatorState;
+    mergeState(state: AccumulatorState): void;
+}
+interface AggregateDef {
+    name: string;
+    valueKey: string | null;
+    resultType: DataType;
+    createAccumulator: () => Accumulator;
+    extractValue: CompiledExpr;
+    _wasmColIndex?: number;
+    _sourceExpr: BoundExpr | null;
+    _columnMapping: ColumnMapping;
+}
+type GroupKey = string | number | bigint | boolean | null;
+interface GroupState {
+    groupValues: ColumnValue[];
+    accumulators: Accumulator[];
+}
+interface PartialGroup {
+    key: GroupKey;
+    groupValues: ColumnValue[];
+    states: AccumulatorState[];
+}
+export declare class HashAggregateOperator {
+    groupByExtractors: CompiledExpr[];
+    groupByTypes: DataType[];
+    aggregateDefs: AggregateDef[];
+    hasCachedValues: boolean;
+    groups: Map<GroupKey, GroupState>;
+    groupKeys: GroupKey[];
+    constructor(groupByExtractors: CompiledExpr[], groupByTypes: DataType[], aggregateDefs: AggregateDef[]);
+    init(): Promise<void>;
+    consume(chunk: DataChunk): Promise<void>;
+    finalize(): Promise<DataChunk[]>;
+    exportPartials(partitionCount: number): PartialGroup[][];
+    absorbPartials(partials: PartialGroup[]): void;
+    _tryWasmUngrouped(chunk: DataChunk): Promise<boolean>;
+}
+export declare const GLOBAL_GROUP_KEY = "__ALL__";
+export declare function hashGroupKey(key: GroupKey): number;
+export declare class SumAccumulator implements Accumulator {
+    sum: number;
+    hasValue: boolean;
+    constructor();
+    add(val: EvalValue): void;
+    result(): ColumnValue;
+    exportState(): ColumnValue;
+    mergeState(state: number | null): void;
+}
+export declare class CountAccumulator implements Accumulator {
+    count: number;
+    constructor();
+    add(val: EvalValue): void;
+    result(): ColumnValue;
+    exportState(): ColumnValue;
+    mergeState(state: number): void;
+}
+export declare class CountStarAccumulator implements Accumulator {
+    count: number;
+    constructor();
+    add(): void;
+    result(): ColumnValue;
+    exportState(): ColumnValue;
+    mergeState(state: number): void;
+}
+export declare class AvgAccumulator implements Accumulator {
+    sum: number;
+    count: number;
+    constructor();
+    add(val: EvalValue): void;
+    result(): ColumnValue;
+    exportState(): AvgState;
+    mergeState(state: AvgState): void;
+}
+export declare class AvgFinalAccumulator implements Accumulator {
+    sum: number;
+    count: number;
+    constructor();
+    add(pair: EvalValue | ColumnValue[]): void;
+    result(): ColumnValue;
+    exportState(): AvgState;
+    mergeState(state: AvgState): void;
+}
+export declare class MinAccumulator implements Accumulator {
+    min: ColumnValue;
+    constructor();
+    add(val: EvalValue): void;
+    result(): ColumnValue;
+    exportState(): ColumnValue;
+    mergeState(state: ColumnValue): void;
+}
+export declare class MaxAccumulator implements Accumulator {
+    max: ColumnValue;
+    constructor();
+    add(val: EvalValue): void;
+    result(): ColumnValue;
+    exportState(): ColumnValue;
+    mergeState(state: ColumnValue): void;
+}
+export declare class CountDistinctAccumulator implements Accumulator {
+    values: Set<ColumnValue>;
+    constructor();
+    add(val: EvalValue): void;
+    result(): ColumnValue;
+    exportState(): ColumnValue[];
+    mergeState(state: ColumnValue[]): void;
+}
+export declare function getAccumulatorFactory(name: string, distinct?: boolean): () => Accumulator;
+export {};

package/dist/execution/operators/hash-join.d.ts

@@ -0,0 +1,74 @@
+import { DataChunk } from '../../storage/chunk.js';
+import { JoinType } from '../../planner/logical-plan.js';
+import type { DataType, ColumnValue } from '../../storage/data-type.js';
+import type { CompiledExpr } from '../execution-types.js';
+type JoinKey = ColumnValue;
+interface BuildItem {
+    row: ColumnValue[];
+    pIdx?: number;
+    rIdx?: number;
+}
+interface PartitionRow {
+    row: ColumnValue[];
+    key: JoinKey;
+}
+interface BuildPartition {
+    rows: PartitionRow[];
+    spilled: boolean;
+}
+interface ProbeItem {
+    row: ColumnValue[];
+    key: JoinKey;
+}
+interface SpillManagerLike {
+    appendChunk(id: string, chunk: DataChunk | null): Promise<void>;
+    readChunks(id: string): AsyncGenerator<DataChunk>;
+    clearAll(): Promise<void>;
+}
+interface JoinSink {
+    consume(chunk: DataChunk): Promise<void>;
+}
+export declare class HashJoinBuild {
+    keyExtractors: CompiledExpr[];
+    joinType: JoinType;
+    uniqueKeys: boolean;
+    buildPreserved: boolean;
+    hashTable: Map<JoinKey, BuildItem[]>;
+    buildSchema: DataType[] | null;
+    hasNullKey: boolean;
+    nullKeyRows: ColumnValue[][];
+    spillManager: SpillManagerLike;
+    partitions: BuildPartition[];
+    totalRowsInRAM: number;
+    matchedSet: Set<string>;
+    constructor(keyExtractors: CompiledExpr[], joinType: JoinType, uniqueKeys: boolean, spillManager: SpillManagerLike, buildPreserved?: boolean);
+    init(): Promise<void>;
+    consume(chunk: DataChunk): Promise<void>;
+    flushPartition(pIdx: number): Promise<void>;
+    rowsToChunk(rows: ColumnValue[][]): DataChunk;
+    finalize(): Promise<void>;
+    markMatched(packed: BuildItem): void;
+    emitUnmatched(probeColCount: number): ColumnValue[][];
+    probe(key: JoinKey): BuildItem[] | null;
+    buildKey(chunk: DataChunk, rowIdx: number): JoinKey | null;
+}
+export declare class HashJoinProbe {
+    buildSide: HashJoinBuild;
+    probeKeyExtractors: CompiledExpr[];
+    buildColCount: number;
+    probeColCount: number;
+    joinType: JoinType;
+    conditionEvaluator: CompiledExpr | null;
+    spillBuffers: ProbeItem[][];
+    probeSchema: DataType[] | null;
+    constructor(buildSide: HashJoinBuild, probeKeyExtractors: CompiledExpr[], buildColCount: number, probeColCount: number, joinType?: JoinType, conditionEvaluator?: CompiledExpr | null);
+    init(): Promise<void>;
+    process(probeChunk: DataChunk): Promise<DataChunk | null>;
+    flushProbePartition(pIdx: number): Promise<void>;
+    rowsToProbeChunk(rows: ColumnValue[][]): DataChunk;
+    executeInMemoryJoin(probeItems: ProbeItem[]): DataChunk;
+    finalize(sink: JoinSink): Promise<void>;
+    extractProbeKey(chunk: DataChunk, rowIdx: number): JoinKey | null;
+    buildOutputChunk(rows: ColumnValue[][]): DataChunk;
+}
+export {};

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

@@ -0,0 +1,34 @@
+import { DataChunk } from '../../storage/chunk.js';
+import type { ColumnValue } from '../../storage/data-type.js';
+import type { ExecSchema } from '../execution-types.js';
+type IndexScanKey = string | number | bigint | boolean | null | undefined;
+interface RowLocationLike {
+    pageId: string;
+    rowIndex: number;
+}
+interface BTreeLike {
+    search(key: IndexScanKey): RowLocationLike[];
+    range(low: IndexScanKey, high: IndexScanKey, lowInclusive: boolean, highInclusive: boolean): Generator<RowLocationLike>;
+}
+interface BufferPoolLike {
+    fetchPage(pageId: string, bypassCache: boolean): Promise<DataChunk | null>;
+}
+interface IndexTableLike {
+    bufferPool: BufferPoolLike;
+    getSchema(): ExecSchema;
+}
+export declare class IndexScanOperator {
+    btreeIndex: BTreeLike;
+    table: IndexTableLike;
+    scanType: string;
+    scanKey: IndexScanKey;
+    scanLow: IndexScanKey;
+    scanHigh: IndexScanKey;
+    lowInc: boolean;
+    highInc: boolean;
+    projectedColumns: number[] | null;
+    constructor(btreeIndex: BTreeLike, table: IndexTableLike, scanType: string, scanKey: IndexScanKey, scanLow: IndexScanKey, scanHigh: IndexScanKey, lowInc: boolean, highInc: boolean, projectedColumns: number[] | null);
+    scan(): AsyncGenerator<DataChunk>;
+    _buildChunk(rows: ColumnValue[][], schema: ExecSchema): DataChunk;
+}
+export {};

package/dist/execution/operators/join-core.d.ts

@@ -0,0 +1,47 @@
+import type { DataType, ColumnValue } from '../../storage/data-type.js';
+import { DataChunk } from '../../storage/chunk.js';
+import { JoinType } from '../../planner/logical-plan.js';
+import type { Allocator } from '../../storage/sab-arena.js';
+import type { CompiledExpr, EvalValue } from '../execution-types.js';
+type JoinKey = ColumnValue;
+type JoinRow = ColumnValue[];
+interface RowAdapterColumn {
+    get(): ColumnValue;
+}
+interface RowAdapter {
+    row: JoinRow | null;
+    columns: RowAdapterColumn[];
+    setRow(r: JoinRow): void;
+}
+type ConditionEvaluator = (adapter: RowAdapter, rowIdx: number) => EvalValue;
+interface BuildItem {
+    row: JoinRow;
+}
+interface ProbeItem {
+    row: JoinRow;
+    key: JoinKey;
+}
+interface ProbeOpts {
+    joinType: JoinType;
+    buildColCount: number;
+    probeColCount: number;
+    conditionEvaluator: ConditionEvaluator | null;
+    hasNullKey: boolean;
+    onMatched: ((item: BuildItem) => void) | null;
+}
+interface BuildChunkOpts {
+    joinType: JoinType;
+    buildColCount: number;
+    buildSchema?: (DataType | string)[];
+    probeSchema?: (DataType | string)[];
+}
+export declare function joinKeyOf(extractors: CompiledExpr[], chunk: DataChunk, rowIdx: number): JoinKey;
+export declare function joinKeyHash(key: JoinKey): number;
+export declare function createCombinedRowAdapter(totalCols: number): RowAdapter;
+export declare function probeJoinRows(items: Iterable<ProbeItem>, lookup: (key: JoinKey) => BuildItem[] | null, opts: ProbeOpts): JoinRow[];
+export declare function emitsOnUnmatchedProbe(joinType: JoinType): boolean;
+export declare function emitsUnmatchedBuild(joinType: JoinType): boolean;
+export declare function buildJoinOutputChunk(rows: JoinRow[], { joinType, buildColCount, buildSchema, probeSchema }: BuildChunkOpts, allocator?: Allocator): DataChunk;
+export declare function materializeRow(chunk: DataChunk, rowIdx: number): JoinRow;
+export declare function materializeActiveRow(chunk: DataChunk, i: number): JoinRow;
+export {};