@slexisvn/query-engine 0.1.0

package/dist/optimizer/dphyp/cardinality.d.ts

@@ -0,0 +1,69 @@
+import { type BoundExpr, type BoundColumnRefNode, type BoundBinaryNode, type BoundBetweenNode, type BoundLikeNode, type BoundInListNode, type BoundIsNullNode, type LiteralValue } from '../../binder/expression-binder.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export interface Mcv {
+    values: (string | number)[];
+    frequencies: number[];
+}
+export interface Histogram {
+    numBuckets: number;
+    totalCount: number;
+    boundaries: (number | bigint)[];
+    bucketCounts: number[];
+    bucketDistincts: number[];
+    estimateLessThan(value: LiteralValue): number;
+    estimateRange(low: LiteralValue, high: LiteralValue): number;
+}
+export interface ColumnStats {
+    ndv?: number;
+    nullFraction?: number;
+    avgLength?: number;
+    min?: number | bigint | string | null;
+    max?: number | bigint | string | null;
+    mcv?: Mcv;
+    histogram?: Histogram;
+}
+export interface TableStats {
+    rowCount: number;
+    columnStats?: Map<string, ColumnStats>;
+    getCorrelation?(a: string, b: string): number | null;
+}
+export interface StatsProvider {
+    get(key: string): TableStats | undefined;
+    values(): IterableIterator<TableStats>;
+}
+export interface EquiPred {
+    left: BoundExpr;
+    right: BoundExpr;
+}
+export declare class DefaultCardinalityEstimator {
+    stats: StatsProvider;
+    constructor(statisticsProvider: StatsProvider);
+    estimateScan(tableName: string): number;
+    estimatePlan(node?: LogicalPlanNode | null): number;
+    estimateFilter(inputCard: number, predicate: BoundExpr | null): number;
+    estimateJoin(leftCard: number, rightCard: number, condition: BoundExpr | null): number;
+    estimateEquiJoinSelectivity(leftExpr: BoundExpr, rightExpr: BoundExpr, leftCard: number, rightCard: number): number;
+    _histogramJoinCollision(sA: ColumnStats | null, sB: ColumnStats | null): number | null;
+    estimateLeftJoin(leftCard: number, rightCard: number, condition: BoundExpr | null): number;
+    estimateSemiJoin(leftCard: number, rightCard: number, condition: BoundExpr | null): number;
+    estimateSemiJoinSelectivity(leftExpr: BoundExpr, rightExpr: BoundExpr): number;
+    estimateAntiJoin(leftCard: number, rightCard: number, condition: BoundExpr | null): number;
+    estimateAggregate(inputCard: number, groupByCount: number, groupByExprs?: BoundExpr[]): number;
+    estimateSelectivity(predicate: BoundExpr | null): number;
+    estimateEqualitySelectivity(predicate: BoundBinaryNode): number;
+    estimateRangeSelectivity(predicate: BoundBinaryNode): number;
+    estimateBetweenSelectivity(predicate: BoundBetweenNode): number;
+    estimateInListSelectivity(predicate: BoundInListNode): number;
+    estimateIsNullSelectivity(predicate: BoundIsNullNode): number;
+    estimateLikeSelectivity(predicate: BoundLikeNode): number;
+    isPrefixPattern(pattern: string): boolean;
+    isContainsPattern(pattern: string): boolean;
+    isSuffixPattern(pattern: string): boolean;
+    likeFallback(type: string): number;
+    lookupCorrelation(leftPred: BoundExpr, rightPred: BoundExpr): number;
+    extractSingleColumn(pred: BoundExpr): BoundColumnRefNode | null;
+    getColumnNdv(expr: BoundExpr): number;
+    getColumnStats(expr: BoundExpr | null): ColumnStats | null;
+    extractEquiPredicates(condition: BoundExpr | null): EquiPred[];
+    _collectEqui(expr: BoundExpr | null, result: EquiPred[]): void;
+}

package/dist/optimizer/dphyp/cost-model.d.ts

@@ -0,0 +1,47 @@
+export interface CostModelOptions {
+    hashBuildCost?: number;
+    hashProbeCost?: number;
+    compareCost?: number;
+    scanCost?: number;
+    filterCost?: number;
+    outputCost?: number;
+    memoryCost?: number;
+    ioCost?: number;
+    spillThreshold?: number;
+    crossJoinPenalty?: number;
+}
+export declare class DefaultCostModel {
+    C_HASH_BUILD: number;
+    C_HASH_PROBE: number;
+    C_COMPARE: number;
+    C_SCAN: number;
+    C_FILTER: number;
+    C_OUTPUT: number;
+    C_MEMORY: number;
+    C_IO: number;
+    SPILL_THRESHOLD: number;
+    C_CROSS: number;
+    constructor(options?: CostModelOptions);
+    hashJoinCost(buildCard: number, probeCard: number, outputCard?: number | null): number;
+    mergeJoinCost(leftCard: number, rightCard: number, outputCard?: number | null): number;
+    sortMergeJoinCost(leftCard: number, rightCard: number, outputCard?: number | null): number;
+    nestedLoopJoinCost(outerCard: number, innerCard: number): number;
+    crossJoinCost(leftCard: number, rightCard: number): number;
+    sortCost(card: number): number;
+    topNSortCost(card: number, limit: number): number;
+    scanCost(card: number): number;
+    filterCost(card: number): number;
+    aggregateCost(card: number): number;
+    hashAggregateCost(card: number, numGroups?: number | null): number;
+    streamAggregateCost(card: number): number;
+    totalJoinCost(buildPlan: {
+        totalCost: number;
+    }, probePlan: {
+        totalCost: number;
+    }, buildCard: number, probeCard: number, outputCard: number): number;
+    cheaperJoinCost(leftCard: number, rightCard: number, leftSorted: boolean, rightSorted: boolean, outputCard: number, downstreamSortSaving?: number): {
+        hashCost: number;
+        mergeCost: number;
+        preferMerge: boolean;
+    };
+}

package/dist/optimizer/dphyp/dphyp.d.ts

@@ -0,0 +1,32 @@
+import { type HyperGraph } from './hypergraph.js';
+import { type BoundExpr } from '../../binder/expression-binder.js';
+import type { LogicalPlanNode } from '../../planner/logical-plan.js';
+import type { DefaultCostModel } from './cost-model.js';
+import type { DefaultCardinalityEstimator } from './cardinality.js';
+export interface DPhypPlan {
+    type: 'HashJoin';
+    buildSide: LogicalPlanNode | DPhypPlan;
+    probeSide: LogicalPlanNode | DPhypPlan;
+    condition: BoundExpr | null;
+    buildCard: number;
+    probeCard: number;
+}
+export interface DPEntry {
+    plan: LogicalPlanNode | DPhypPlan;
+    cardinality: number;
+    totalCost: number;
+    mask: number;
+}
+export declare class DPhypEnumerator {
+    graph: HyperGraph;
+    costModel: DefaultCostModel;
+    cardEstimator: DefaultCardinalityEstimator;
+    dp: Map<number, DPEntry>;
+    constructor(hyperGraph: HyperGraph, costModel: DefaultCostModel, cardinalityEstimator: DefaultCardinalityEstimator);
+    solve(): DPEntry | null;
+    enumerateSize(size: number): void;
+    enumerateCsgCmpPairs(combined: number): void;
+    emitPair(s1Mask: number, s2Mask: number, combinedMask: number, predicates: BoundExpr[]): void;
+    tryJoinOrder(build: DPEntry, probe: DPEntry, combinedMask: number, joinCondition: BoundExpr | null): void;
+}
+export declare function runDPhyp(hyperGraph: HyperGraph, costModel: DefaultCostModel, cardinalityEstimator: DefaultCardinalityEstimator): DPEntry | null;

package/dist/optimizer/dphyp/hypergraph.d.ts

@@ -0,0 +1,38 @@
+import { type BoundExpr } from '../../binder/expression-binder.js';
+import type { LogicalPlanNode } from '../../planner/logical-plan.js';
+import type { DefaultCardinalityEstimator } from './cardinality.js';
+export interface Relation {
+    name: string;
+    alias?: string;
+    plan: LogicalPlanNode;
+}
+export interface RelationEntry {
+    id: number;
+    name: string;
+    plan: LogicalPlanNode;
+    cardinality: number;
+    mask: number;
+}
+export declare class HyperEdge {
+    leftMask: number;
+    rightMask: number;
+    predicate: BoundExpr;
+    constructor(leftMask: number, rightMask: number, predicate: BoundExpr);
+}
+export declare class HyperGraph {
+    relations: RelationEntry[];
+    relationIndex: Map<string, number>;
+    edges: HyperEdge[];
+    adjacency: number[];
+    constructor();
+    addRelation(name: string, plan: LogicalPlanNode, cardinality: number): number;
+    addEdge(leftNames: string[], rightNames: string[], predicate: BoundExpr): void;
+    getNeighborhood(subset: number): number;
+    isConnected(subset: number): boolean;
+    findJoinPredicates(leftMask: number, rightMask: number): BoundExpr[];
+    get size(): number;
+    get fullMask(): number;
+}
+export declare function buildHyperGraph(relations: Relation[], joinPredicates: BoundExpr[], cardinalityEstimator: DefaultCardinalityEstimator): HyperGraph;
+export declare function popcount(mask: number): number;
+export declare function subsets(mask: number): number[];

package/dist/optimizer/optimizer.d.ts

@@ -0,0 +1,12 @@
+import type { LogicalPlanNode } from '../planner/logical-plan.js';
+import type { OptimizationPass } from './pass.js';
+export declare class Optimizer {
+    passes: OptimizationPass[];
+    constructor();
+    registerPass(pass: OptimizationPass): this;
+    removePass(name: string): this;
+    insertPassBefore(name: string, pass: OptimizationPass): this;
+    insertPassAfter(name: string, pass: OptimizationPass): this;
+    optimize(plan: LogicalPlanNode, context?: Record<string, never>): LogicalPlanNode;
+    listPasses(): string[];
+}

package/dist/optimizer/pass.d.ts

@@ -0,0 +1,5 @@
+import type { LogicalPlanNode } from '../planner/logical-plan.js';
+export declare class OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode, context?: Record<string, never>): LogicalPlanNode;
+}

package/dist/optimizer/passes/aggregate-pushdown.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class AggregatePushdown extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/cte-optimization.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class CTEOptimization extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/empty-propagation.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class EmptyPropagation extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/expr-walk.d.ts

@@ -0,0 +1,20 @@
+import { type BoundExpr } from '../../binder/expression-binder.js';
+export type ExprLike = BoundExpr & {
+    left?: BoundExpr;
+    right?: BoundExpr;
+    operand?: BoundExpr;
+    expr?: BoundExpr;
+    low?: BoundExpr;
+    high?: BoundExpr;
+    args?: BoundExpr[];
+    whenClauses?: Array<{
+        condition: BoundExpr;
+        result: BoundExpr;
+    }>;
+    elseExpr?: BoundExpr;
+    list?: BoundExpr | BoundExpr[];
+    pattern?: BoundExpr;
+    source?: BoundExpr;
+};
+export declare function walkExpr(expr: BoundExpr | null | undefined, fn: (e: BoundExpr) => void): void;
+export declare function containsAggregate(expr?: BoundExpr): boolean;

package/dist/optimizer/passes/expression-simplifier.d.ts

@@ -0,0 +1,8 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+import { type BoundExpr } from '../../binder/expression-binder.js';
+export declare class ExpressionSimplifier extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}
+export declare function simplifyExpression(expr: BoundExpr | null): BoundExpr | null;

package/dist/optimizer/passes/filter-ordering.d.ts

@@ -0,0 +1,13 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+import { DefaultCardinalityEstimator } from '../dphyp/cardinality.js';
+interface TableStatistics {
+    rowCount: number;
+}
+export declare class FilterOrdering extends OptimizationPass {
+    cardEstimator: DefaultCardinalityEstimator;
+    constructor(statisticsMap?: Map<string, TableStatistics>);
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}
+export {};

package/dist/optimizer/passes/having-pushdown.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class HavingPushdown extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/index-selection.d.ts

@@ -0,0 +1,24 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode, type IndexScanValue } from '../../planner/logical-plan.js';
+interface ColumnStatsLike {
+    ndv: number;
+    min: IndexScanValue;
+    max: IndexScanValue;
+}
+interface TableStatsLike {
+    getColumnStats(column: string): ColumnStatsLike | null;
+}
+interface StatisticsLike {
+    get(name: string): TableStatsLike | undefined;
+}
+interface CatalogLike {
+    getIndexForColumn(table: string, column: string): object | null;
+}
+export declare class IndexSelection extends OptimizationPass {
+    catalog: CatalogLike;
+    statistics: StatisticsLike | null;
+    constructor(catalog: CatalogLike, statistics: StatisticsLike | null);
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}
+export {};

package/dist/optimizer/passes/join-elimination.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class JoinElimination extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/join-reorder.d.ts

@@ -0,0 +1,12 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+import { DefaultCostModel } from '../dphyp/cost-model.js';
+import { DefaultCardinalityEstimator, type TableStats } from '../dphyp/cardinality.js';
+export declare class JoinReorder extends OptimizationPass {
+    statisticsMap: Map<string, TableStats>;
+    costModel: DefaultCostModel;
+    cardEstimator: DefaultCardinalityEstimator;
+    constructor(statisticsMap?: Map<string, TableStats>, costModel?: DefaultCostModel | null, cardEstimator?: DefaultCardinalityEstimator | null);
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/join-residual-split.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class JoinResidualSplit extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/limit-pushdown.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class LimitPushdown extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/node-merge.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class NodeMerge extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/outer-to-inner.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class OuterToInnerJoin extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/physical-design.d.ts

@@ -0,0 +1,12 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+import { DefaultCostModel } from '../dphyp/cost-model.js';
+import { DefaultCardinalityEstimator, type TableStats } from '../dphyp/cardinality.js';
+export declare class PhysicalDesign extends OptimizationPass {
+    statisticsMap: Map<string, TableStats>;
+    costModel: DefaultCostModel;
+    cardEstimator: DefaultCardinalityEstimator;
+    constructor(statisticsMap?: Map<string, TableStats>, costModel?: DefaultCostModel | null, cardEstimator?: DefaultCardinalityEstimator | null);
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/plan-refs.d.ts

@@ -0,0 +1,22 @@
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export interface PlanRefs {
+    aliases: Set<string>;
+    columns: Set<string>;
+}
+export interface ExprRef {
+    tableAlias: string;
+    columnName: string;
+}
+export interface NamedExpr {
+    outputName?: string;
+    alias?: string;
+    name?: string;
+    columnName?: string;
+}
+export interface CollectPlanRefsOptions {
+    recurseProject?: boolean;
+    dottedAlias?: boolean;
+}
+export declare function addOutputRefs(node: LogicalPlanNode, refs: PlanRefs, options?: CollectPlanRefsOptions): void;
+export declare function collectPlanRefs(node: LogicalPlanNode, options?: CollectPlanRefsOptions): PlanRefs;
+export declare function refBelongsToPlan(ref: ExprRef, planRefs: PlanRefs, options?: CollectPlanRefsOptions): boolean;

package/dist/optimizer/passes/predicate-dedup.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class PredicateDedup extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/predicate-inference.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class PredicateInference extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/predicate-pushdown.d.ts

@@ -0,0 +1,9 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+import { type BoundExpr } from '../../binder/expression-binder.js';
+export declare class PredicatePushdown extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}
+export declare function splitConjuncts(expr: BoundExpr | null): BoundExpr[];
+export declare function combineConjuncts(preds: BoundExpr[]): BoundExpr | null;

package/dist/optimizer/passes/projection-pushdown.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class ProjectionPushdown extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/sort-elimination.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class SortElimination extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/subquery-unnesting.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class SubqueryUnnesting extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/optimizer/passes/topn-fusion.d.ts

@@ -0,0 +1,6 @@
+import { OptimizationPass } from '../pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+export declare class TopNFusion extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}

package/dist/parallel/chunk-transport.d.ts

@@ -0,0 +1,24 @@
+import { DataChunk } from '../storage/chunk.js';
+import { type Allocator } from '../storage/sab-arena.js';
+import type { EncodedChunkSet } from './worker-messages.js';
+export declare function shareChunk(chunk: DataChunk, columnIndexes: number[], arena: Allocator, forceCopy?: boolean): DataChunk;
+interface DictBlob {
+    lengths: Uint32Array;
+    count: number;
+    blob: Uint8Array;
+    totalBytes: number;
+}
+export declare function encodeChunkSet(chunks: DataChunk[], columnIndexes: number[], arena: Allocator, dictCache?: Map<string[], DictBlob>): EncodedChunkSet;
+export declare function transportBytes(chunkSet: EncodedChunkSet): number;
+export declare class ChunkSetReader {
+    buffers: ArrayBufferLike[];
+    meta: Uint32Array;
+    sizes: Uint32Array;
+    colCount: number;
+    cache: Map<number, DataChunk>;
+    constructor({ buffers, meta, sizes, colCount }: EncodedChunkSet);
+    get count(): number;
+    chunk(index: number): DataChunk;
+    _decode(index: number): DataChunk;
+}
+export {};

package/dist/parallel/fragment-pool.d.ts

@@ -0,0 +1,49 @@
+import { Worker } from 'worker_threads';
+import type { DataChunk } from '../storage/chunk.js';
+import type { FragmentSpec, JoinSpec } from '../execution/fragment-spec.js';
+import type { PartialGroupRecord, JoinOutputTypes, FragmentAggregateRequest, FragmentCombineRequest, FragmentJoinPartitionRequest, FragmentJoinProbeRequest, FragmentReplyMessage, FragmentSuccessMessage } from './worker-messages.js';
+interface WorkerEntry {
+    worker: Worker;
+    slot: number;
+}
+interface PendingRequest {
+    expected: number;
+    replies: FragmentSuccessMessage[];
+    resolve: (replies: FragmentSuccessMessage[]) => void;
+    reject: (error: Error) => void;
+}
+interface RunAggregateOptions {
+    byteLimit?: number;
+    spillDir?: string | null;
+}
+interface JoinStreamSide {
+    chunks: DataChunk[];
+    columnIndexes: number[] | null;
+}
+interface PoolStats {
+    spillFiles: number;
+}
+export declare class FragmentPool {
+    workerCount: number;
+    morselRows: number;
+    workers: WorkerEntry[];
+    pending: Map<number, PendingRequest>;
+    nextReqId: number;
+    closed: boolean;
+    spillSeq?: number;
+    stats?: PoolStats;
+    constructor(workerCount?: number, morselRows?: number);
+    _ensure(): void;
+    _spawn(slot: number): WorkerEntry;
+    _updateRefs(): void;
+    _settle(reqId: number, settle: () => void): void;
+    _onMessage(msg: FragmentReplyMessage): void;
+    _failAll(err: Error): void;
+    _request(entry: WorkerEntry, payload: FragmentCombineRequest | FragmentJoinProbeRequest): Promise<FragmentSuccessMessage>;
+    _broadcast(payload: FragmentAggregateRequest | FragmentJoinPartitionRequest): Promise<FragmentSuccessMessage[]>;
+    runAggregate(spec: FragmentSpec, columnIndexes: number[], chunks: DataChunk[], options?: RunAggregateOptions): Promise<DataChunk[]>;
+    _combineAndFinalize(spec: FragmentSpec, perWorkerPartitions: PartialGroupRecord[][][], spillFiles: string[], partitionCount: number): Promise<DataChunk[]>;
+    runJoinStream(spec: JoinSpec, buildSide: JoinStreamSide, probeSide: JoinStreamSide, outputTypes: JoinOutputTypes): AsyncGenerator<DataChunk>;
+    close(): Promise<void>;
+}
+export {};

package/dist/parallel/fragment-worker.d.ts

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

package/dist/parallel/morsel-scheduler.d.ts

@@ -0,0 +1,11 @@
+import type { MorselSchedulerDescriptor, MorselRange } from './worker-messages.js';
+export declare class MorselScheduler {
+    totalUnits: number;
+    unitsPerMorsel: number;
+    counter: Int32Array;
+    constructor(totalUnits: number, unitsPerMorsel: number);
+    static attach({ counterBuffer, totalUnits, unitsPerMorsel }: MorselSchedulerDescriptor): MorselScheduler;
+    descriptor(): MorselSchedulerDescriptor;
+    next(): MorselRange | null;
+    drain(): Generator<MorselRange>;
+}

package/dist/parallel/parallel-dispatch.d.ts

@@ -0,0 +1,69 @@
+import type { AnyTypedArray, ColumnValue, DataType } from '../storage/data-type.js';
+import type { WasmVecData } from '../wasm/wasm-types.js';
+import type { CompoundCombineOp, FilterDescriptor, PipelineStage, WorkerTask, SelectionVectorResult, ScalarAggregateResult, ProjectResult, ScalarAggregatePartial } from './worker-messages.js';
+type WasmKernel = (data: WasmVecData | number, arg1?: WasmVecData | number, arg2?: WasmVecData | number) => Promise<Uint32Array | number> | WasmVecData | Promise<WasmVecData>;
+interface RegionAllocatorLike {
+    memory: WebAssembly.Memory;
+    resetStaging(): void;
+    allocStaging(bytes: number): number;
+}
+interface GlobalDispatchLike {
+    lookup(operation: string, dataType: string): WasmKernel | null;
+}
+interface WorkerPoolLike {
+    activeWorkerCount(): number;
+    execute<R>(tasks: WorkerTask[]): Promise<R[]>;
+}
+interface FilterParams {
+    value?: ColumnValue;
+    low?: ColumnValue;
+    high?: ColumnValue;
+}
+interface ProjectParams {
+    scalar?: number;
+    dataB?: AnyTypedArray;
+}
+interface Morsel {
+    start: number;
+    length: number;
+}
+interface PipelineAggregatesPartialResult {
+    aggregates?: ScalarAggregatePartial[];
+}
+interface MergedPipelineAggregates {
+    aggregates: Record<string, ScalarAggregateResult | null>;
+}
+interface FilterFallbackParams {
+    value?: ColumnValue;
+    low?: ColumnValue;
+    high?: ColumnValue;
+}
+export declare class ParallelDispatch {
+    workerPool: WorkerPoolLike | null;
+    regionAllocator: RegionAllocatorLike;
+    globalDispatch: GlobalDispatchLike;
+    constructor(workerPool: WorkerPoolLike | null, regionAllocator: RegionAllocatorLike, globalDispatch: GlobalDispatchLike);
+    canParallelize(operation: string, dataType: string, count: number): boolean;
+    filterParallel(data: AnyTypedArray, count: number, operation: string, dataType: DataType, params: FilterParams): Promise<SelectionVectorResult | null>;
+    aggregateParallel(data: AnyTypedArray, count: number, aggType: string, dataType: DataType): Promise<ScalarAggregateResult | null>;
+    compoundFilterParallel(data: AnyTypedArray, count: number, filters: FilterDescriptor[], combineOp: CompoundCombineOp, dataType: DataType): Promise<SelectionVectorResult | null>;
+    pipelineParallel(data: AnyTypedArray, count: number, dataType: DataType, stages: PipelineStage[]): Promise<SelectionVectorResult | MergedPipelineAggregates>;
+    projectParallel(data: AnyTypedArray, count: number, op: string, params?: ProjectParams): Promise<Float64Array | null>;
+    _gatherProjectResults(results: ProjectResult[], totalCount: number): Float64Array;
+    _resolveDataPtr(data: AnyTypedArray, count: number, bw: number): number;
+    _splitRange(totalCount: number, workerCount: number): Morsel[];
+    _gatherSelectionVectors(results: SelectionVectorResult[], totalCount: number): SelectionVectorResult;
+    _mergeAggregates(results: ScalarAggregateResult[], aggType: string): ScalarAggregateResult | null;
+    _mergePipelineAggregates(results: PipelineAggregatesPartialResult[]): MergedPipelineAggregates;
+    _compoundFilterFallback(data: AnyTypedArray, count: number, filters: FilterDescriptor[], combineOp: CompoundCombineOp, dataType: DataType): Promise<SelectionVectorResult>;
+    _pipelineFallback(data: AnyTypedArray, count: number, dataType: DataType, stages: PipelineStage[]): Promise<SelectionVectorResult | MergedPipelineAggregates>;
+    _gatherByIndices(data: AnyTypedArray, indices: Uint32Array, dataType: DataType): Float64Array | Int32Array;
+    _intersectSorted(a: Uint32Array, b: Uint32Array): Uint32Array;
+    _unionSorted(a: Uint32Array, b: Uint32Array): Uint32Array;
+    _filterFallback(operation: string, dataType: DataType, data: AnyTypedArray, params: FilterFallbackParams): Promise<{
+        selectionVector: Uint32Array;
+        matchCount: number;
+    } | null>;
+    _aggregateFallback(aggType: string, dataType: DataType, data: AnyTypedArray): Promise<ScalarAggregateResult | null>;
+}
+export {};

package/dist/parallel/partial-spill.d.ts

@@ -0,0 +1,3 @@
+import type { PartialGroupRecord } from './worker-messages.js';
+export declare function writePartialSpill(file: string, partitions: PartialGroupRecord[][]): void;
+export declare function readPartialSpill(file: string, partition: number): PartialGroupRecord[];