@slexisvn/query-engine 0.1.0

package/dist/distributed/partition/partition-strategy.d.ts

@@ -0,0 +1,43 @@
+import { DataChunk } from '../../storage/chunk.js';
+import type { ColumnValue } from '../../storage/data-type.js';
+export declare const StrategyType: {
+    HASH: string;
+    RANGE: string;
+    ROUND_ROBIN: string;
+};
+export type StrategyTypeValue = (typeof StrategyType)[keyof typeof StrategyType];
+export interface HashPartitionOptions {
+    seed?: number;
+}
+export type PartitionChunkResult = Map<number, DataChunk>;
+export declare class PartitionStrategy {
+    get type(): StrategyTypeValue;
+    partitionFor(_key: ColumnValue, _partitionCount: number): number;
+    partitionChunk(_chunk: DataChunk, _keyColumnIndex: number, _partitionCount: number): PartitionChunkResult;
+    protected _scatterByAssignments(chunk: DataChunk, assignments: Uint32Array, partCount: number): PartitionChunkResult;
+}
+export declare class HashPartitionStrategy extends PartitionStrategy {
+    _seed: number;
+    constructor(options?: HashPartitionOptions);
+    get type(): StrategyTypeValue;
+    partitionFor(key: ColumnValue, partitionCount: number): number;
+    partitionChunk(chunk: DataChunk, keyColumnIndex: number, partitionCount: number): PartitionChunkResult;
+    _normalizeKey(key: ColumnValue): string;
+}
+export declare class RangePartitionStrategy extends PartitionStrategy {
+    _boundaries: ColumnValue[];
+    constructor(boundaries: ColumnValue[]);
+    get type(): StrategyTypeValue;
+    get boundaries(): ColumnValue[];
+    partitionFor(key: ColumnValue): number;
+    partitionChunk(chunk: DataChunk, keyColumnIndex: number, _partitionCount: number): PartitionChunkResult;
+    _binarySearch(key: ColumnValue): number;
+    _compare(a: ColumnValue, b: ColumnValue): number;
+}
+export declare class RoundRobinPartitionStrategy extends PartitionStrategy {
+    get type(): StrategyTypeValue;
+    partitionFor(rowIndex: ColumnValue, partitionCount: number): number;
+    partitionChunk(chunk: DataChunk, _keyColumnIndex: number, partitionCount: number): PartitionChunkResult;
+}
+declare function murmur3(key: ColumnValue, seed: number): number;
+export { murmur3 };

package/dist/distributed/planner/distributed-planner.d.ts

@@ -0,0 +1,71 @@
+import type { LogicalPlanNode, LogicalScanNode, LogicalIndexScanNode, LogicalJoinNode, LogicalExchangeNode, LogicalMergeExchangeNode, LogicalPartialAggregateNode, LogicalFinalAggregateNode } from '../../planner/logical-plan.js';
+import { Fragment, FragmentPlan } from './fragment.js';
+import { ExchangePlacement } from './exchange-placement.js';
+import { PartitionPruner } from '../partition/partition-pruner.js';
+import type { NodeId, PartitionId, FragmentizeContext, DistributedScanSchemaColumn, JoinShuffleKeyIndices, FragmentProcessResult, GatherPlacementResult } from '../distributed-types.js';
+import type { BoundExpr } from '../../binder/expression-binder.js';
+interface ColumnRefLike {
+    kind?: string;
+    tableAlias?: string;
+    columnName?: string;
+    name?: string;
+}
+interface NodeLike {
+    nodeId: NodeId;
+}
+interface PartitionTableInfoLike {
+    partitionCount: number;
+    partitionKey: string | null;
+}
+interface PartitionMapLike {
+    getTableInfo(tableName: string): PartitionTableInfoLike | null;
+    getNodesForPartition(tableName: string, partitionId: PartitionId): NodeId[];
+}
+interface ClusterManagerLike {
+    localNode: NodeLike;
+    getWorkerNodes(): NodeLike[];
+}
+interface TableStorageLike {
+    getSchema(): DistributedScanSchemaColumn[];
+}
+interface CatalogLike {
+    getTableStorage(tableName: string): TableStorageLike | null | undefined;
+}
+interface StatisticsEntryLike {
+    rowCount?: number;
+    avgRowWidth?: number;
+}
+export declare class DistributedPlanner {
+    _partitionMap: PartitionMapLike;
+    _clusterManager: ClusterManagerLike;
+    _exchangePlacement: ExchangePlacement;
+    _pruner: PartitionPruner;
+    _catalog: CatalogLike | null;
+    _fragments: Fragment[];
+    constructor(partitionMap: PartitionMapLike, clusterManager: ClusterManagerLike, statisticsMap: Map<string, StatisticsEntryLike>, catalog?: CatalogLike | null);
+    fragmentize(logicalPlan: LogicalPlanNode): FragmentPlan;
+    _placeGathers(node: LogicalPlanNode): GatherPlacementResult;
+    _isPushableSubtree(node: LogicalPlanNode): boolean;
+    _findPartitionedScan(node: LogicalPlanNode): LogicalPlanNode | null;
+    _buildBroadcastJoin(node: LogicalJoinNode): GatherPlacementResult | null;
+    _isShufflePushableJoin(node: LogicalJoinNode): boolean;
+    _buildShuffleJoin(node: LogicalJoinNode): GatherPlacementResult | null;
+    _extractShuffleKeyIndices(condition: BoundExpr | null, leftSchema: DistributedScanSchemaColumn[], rightSchema: DistributedScanSchemaColumn[]): JoinShuffleKeyIndices | null;
+    _colIndexInSchema(ref: ColumnRefLike, schema: DistributedScanSchemaColumn[]): number;
+    _isColocatedPushableJoin(node: LogicalJoinNode): boolean;
+    _isScanFilterSubtree(node: LogicalPlanNode): boolean;
+    _joinOutputSchema(node: LogicalJoinNode): DistributedScanSchemaColumn[];
+    _deriveSubtreeSchema(node: LogicalPlanNode): DistributedScanSchemaColumn[];
+    _scanOutputSchema(node: LogicalScanNode): DistributedScanSchemaColumn[];
+    _processNode(node: LogicalPlanNode, context: FragmentizeContext): FragmentProcessResult;
+    _processScan(node: LogicalScanNode | LogicalIndexScanNode, context: FragmentizeContext): FragmentProcessResult;
+    _processJoin(node: LogicalJoinNode, context: FragmentizeContext): FragmentProcessResult;
+    _processPartialAggregate(node: LogicalPartialAggregateNode, context: FragmentizeContext): FragmentProcessResult;
+    _processFinalAggregate(node: LogicalFinalAggregateNode, context: FragmentizeContext): FragmentProcessResult;
+    _processExchange(node: LogicalExchangeNode, context: FragmentizeContext): FragmentProcessResult;
+    _processMergeExchange(node: LogicalMergeExchangeNode, context: FragmentizeContext): FragmentProcessResult;
+    _processGeneric(node: LogicalPlanNode, context: FragmentizeContext): FragmentProcessResult;
+    _findFilterAbove(_node: LogicalPlanNode): BoundExpr | null;
+    _selectNodesForPartitions(tableName: string, partitionIds: Set<PartitionId>, workerNodes: NodeLike[]): NodeId[];
+}
+export {};

package/dist/distributed/planner/exchange-placement.d.ts

@@ -0,0 +1,19 @@
+import type { LogicalJoinNode, LogicalAggregateNode, LogicalSortNode } from '../../planner/logical-plan.js';
+import type { JoinExchangePlacement, AggregateExchange, SortExchange, JoinShuffleKeys, PartitionTableInfo } from '../distributed-types.js';
+interface PartitionMapLike {
+    getTableInfo(table: string): PartitionTableInfo | null;
+}
+interface TableStatisticsLike {
+    rowCount: number;
+}
+type StatisticsMapLike = Map<string, TableStatisticsLike>;
+export declare class ExchangePlacement {
+    _partitionMap: PartitionMapLike;
+    _statisticsMap: StatisticsMapLike;
+    constructor(partitionMap: PartitionMapLike, statisticsMap?: StatisticsMapLike);
+    determineJoinExchange(joinNode: LogicalJoinNode): JoinExchangePlacement;
+    determineAggregateExchange(aggNode: LogicalAggregateNode): AggregateExchange;
+    determineSortExchange(sortNode: LogicalSortNode): SortExchange;
+    _extractShuffleKeys(joinNode: LogicalJoinNode): JoinShuffleKeys;
+}
+export {};

package/dist/distributed/planner/expr-utils.d.ts

@@ -0,0 +1,2 @@
+import type { BoundExpr } from '../../binder/expression-binder.js';
+export declare function splitAnd(expr: BoundExpr | null): BoundExpr[];

package/dist/distributed/planner/fragment.d.ts

@@ -0,0 +1,47 @@
+import type { LogicalPlanNode } from '../../planner/logical-plan.js';
+import type { NodeId, FragmentId, ExchangeInput, OutputPartitioning, FragmentDispatchJSON, ExchangeType as ExchangeTypeEnum, FragmentState as FragmentStateEnum } from '../distributed-types.js';
+export declare const ExchangeType: Record<string, ExchangeTypeEnum>;
+export declare const FragmentState: Record<string, FragmentStateEnum>;
+export declare function resetFragmentIdCounter(): void;
+export interface FragmentInit {
+    planRoot: LogicalPlanNode;
+    targetNodes?: NodeId[];
+    exchangeInputs?: ExchangeInput[];
+    outputPartitioning?: OutputPartitioning | null;
+    estimatedCardinality?: number;
+}
+export declare class Fragment {
+    fragmentId: FragmentId;
+    planRoot: LogicalPlanNode;
+    targetNodes: NodeId[];
+    exchangeInputs: ExchangeInput[];
+    outputPartitioning: OutputPartitioning | null;
+    estimatedCardinality: number;
+    state: FragmentStateEnum;
+    retryCount: number;
+    error: string | null;
+    assignedNode: NodeId | null;
+    constructor({ planRoot, targetNodes, exchangeInputs, outputPartitioning, estimatedCardinality }: FragmentInit);
+    isLeaf(): boolean;
+    isRoot(): boolean;
+    markDispatched(nodeId: NodeId): void;
+    markRunning(): void;
+    markCompleted(): void;
+    markFailed(error: string | null): void;
+    markCancelled(): void;
+    canRetry(maxRetries: number): boolean;
+    toJSON(): FragmentDispatchJSON;
+}
+export declare class FragmentPlan {
+    fragments: Fragment[];
+    rootFragmentId: FragmentId;
+    _fragmentMap: Map<FragmentId, Fragment>;
+    constructor(fragments: Fragment[], rootFragmentId: FragmentId);
+    getFragment(fragmentId: FragmentId): Fragment | null;
+    getRootFragment(): Fragment | null;
+    getLeafFragments(): Fragment[];
+    topologicalOrder(): Fragment[];
+    getReadyFragments(): Fragment[];
+    allCompleted(): boolean;
+    hasFailed(): boolean;
+}

package/dist/distributed/transport/chunk-codec.d.ts

@@ -0,0 +1,18 @@
+import { DataType } from '../../storage/data-type.js';
+import { Column } from '../../storage/column.js';
+import { DictionaryColumn } from '../../storage/dictionary-column.js';
+import { DataChunk, type AnyColumn } from '../../storage/chunk.js';
+export declare class ChunkCodec {
+    encode(chunk: DataChunk): Buffer;
+    decode(buffer: Buffer): DataChunk;
+    _writeBitmap(buf: Buffer, offset: number, col: AnyColumn, bitmapWords: number): number;
+    _readBitmapInto(col: AnyColumn, buf: Buffer, rowCount: number): number;
+    _encodeColumn(col: AnyColumn, rowCount: number): Buffer;
+    _encodeRegularColumn(col: Column, rowCount: number): Buffer;
+    _encodeVarcharColumn(col: Column, rowCount: number): Buffer;
+    _encodeDictionaryColumn(col: DictionaryColumn, rowCount: number): Buffer;
+    _decodeColumn(buf: Buffer, dataType: DataType, isDictionary: boolean, rowCount: number): AnyColumn;
+    _decodeFixedColumn(buf: Buffer, dataType: DataType, rowCount: number): Column;
+    _decodeVarcharColumn(buf: Buffer, rowCount: number): Column;
+    _decodeDictionaryColumn(buf: Buffer, rowCount: number): DictionaryColumn;
+}

package/dist/distributed/transport/http-transport.d.ts

@@ -0,0 +1,49 @@
+import { Agent } from 'http';
+import type { IncomingMessage, ServerResponse, Server, OutgoingHttpHeaders } from 'http';
+import { Transport } from './transport.js';
+import type { NodeId, ChannelId, NodeAddress, ChunkReceivedCallback, PendingChunk, ControlMessage, ControlMessageCallback, FragmentDispatchJSON, FragmentReceivedCallback, NodeRegistration, HeartbeatMessage } from '../distributed-types.js';
+export interface HttpTransportOptions {
+    port?: number;
+    nodeId?: NodeId | null;
+}
+export type RegisterCallback = (registration: NodeRegistration) => void;
+export type HeartbeatCallback = (message: HeartbeatMessage) => void;
+type BodyCallback = (body: Buffer) => void;
+export declare class HttpTransport extends Transport {
+    _port: number;
+    _nodeId: NodeId | null;
+    _server: Server | null;
+    _nodes: Map<NodeId, NodeAddress>;
+    _chunkListeners: Map<ChannelId, ChunkReceivedCallback>;
+    _pendingChunks: Map<ChannelId, PendingChunk[]>;
+    _controlCallbacks: ControlMessageCallback[];
+    _fragmentCallbacks: FragmentReceivedCallback[];
+    _registerCallbacks: RegisterCallback[];
+    _heartbeatCallbacks: HeartbeatCallback[];
+    _agents: Map<string, Agent>;
+    constructor(options?: HttpTransportOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    registerNode(nodeId: NodeId, host: string, port: number): void;
+    sendChunk(targetNodeId: NodeId, channelId: ChannelId, encodedChunk: Buffer): Promise<void>;
+    onChunkReceived(channelId: ChannelId, callback: ChunkReceivedCallback): void;
+    removeChunkListener(channelId: ChannelId): void;
+    sendFragment(targetNodeId: NodeId, fragment: FragmentDispatchJSON): Promise<void>;
+    sendControl(targetNodeId: NodeId, message: ControlMessage): Promise<void>;
+    sendRegister(targetNodeId: NodeId, registration: NodeRegistration): Promise<void>;
+    onControlMessage(callback: ControlMessageCallback): void;
+    onFragmentReceived(callback: FragmentReceivedCallback): void;
+    onRegister(callback: RegisterCallback): void;
+    onHeartbeat(callback: HeartbeatCallback): void;
+    sendHeartbeat(targetNodeId: NodeId, message: HeartbeatMessage): Promise<void>;
+    _handleRequest(req: IncomingMessage, res: ServerResponse): void;
+    _handleExchangeData(channelId: ChannelId, body: Buffer, req: IncomingMessage, res: ServerResponse): void;
+    _handleFragmentExecute(body: Buffer, res: ServerResponse): void;
+    _handleControl(body: Buffer, res: ServerResponse): void;
+    _handleHeartbeat(body: Buffer, res: ServerResponse): void;
+    _handleRegister(body: Buffer, res: ServerResponse): void;
+    _collectBody(req: IncomingMessage, callback: BodyCallback): void;
+    _post(target: NodeAddress, path: string, body: Buffer, headers?: OutgoingHttpHeaders): Promise<Buffer>;
+    _getAgent(target: NodeAddress): Agent;
+}
+export {};

package/dist/distributed/transport/transport.d.ts

@@ -0,0 +1,13 @@
+import type { NodeId, ChannelId, ChunkReceivedCallback, FragmentDispatchJSON, ControlMessage, ControlMessageCallback, FragmentReceivedCallback } from '../distributed-types.js';
+export declare class Transport {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendChunk(targetNodeId: NodeId, channelId: ChannelId, encodedChunk: Buffer): Promise<void>;
+    onChunkReceived(channelId: ChannelId, callback: ChunkReceivedCallback): void;
+    removeChunkListener(channelId: ChannelId): void;
+    sendFragment(targetNodeId: NodeId, fragment: FragmentDispatchJSON): Promise<void>;
+    sendControl(targetNodeId: NodeId, message: ControlMessage): Promise<void>;
+    onControlMessage(callback: ControlMessageCallback): void;
+    onFragmentReceived(callback: FragmentReceivedCallback): void;
+    registerNode(nodeId: NodeId, host: string, port: number): void;
+}

package/dist/engine/query-engine.d.ts

@@ -0,0 +1,142 @@
+import { defaultFunctionRegistry } from '../catalog/function-registry.js';
+import { Table } from '../storage/table.js';
+import { Optimizer } from '../optimizer/optimizer.js';
+import { QueryExecutor } from '../execution/query-executor.js';
+import { QueryResult } from '../execution/query-result.js';
+import { StatisticsCache } from '../catalog/statistics-cache.js';
+import type { LogicalPlanNode } from '../planner/logical-plan.js';
+import { DataFrame } from '../dataframe/dataframe.js';
+import type { Statement, QueryStmt, CreateTableStmtNode, DropTableStmtNode } from '../parser/ast.js';
+import type { BoundQuery, OutputColumn } from '../binder/binder.js';
+import type { Catalog } from '../catalog/catalog.js';
+import type { ColumnSchema, ColumnValue } from '../storage/data-type.js';
+import type { TableStatistics } from '../catalog/statistics.js';
+import type { OptimizationPass } from '../optimizer/pass.js';
+import type { Transport } from '../distributed/transport/transport.js';
+type StatisticsMap = Map<string, TableStatistics>;
+type DDLStmt = CreateTableStmtNode | DropTableStmtNode;
+interface StorageBackendLike {
+    createTempSpace(): TempManagerLike;
+    createPageStore(handle: string): PageStoreLike;
+}
+interface TempManagerLike {
+    allocate(category: string, label: string): string;
+    cleanup(): void;
+}
+type PageStoreLike = ConstructorParameters<typeof Table>[2];
+type StorageBackendFactory = (options: QueryEngineOptions) => StorageBackendLike | null | undefined;
+interface QueryEngineOptions {
+    storageBackend?: StorageBackendLike;
+    statistics?: StatisticsMap | null;
+}
+interface SqlFrame {
+    name: string;
+    columns: ColumnSchema[];
+    plan: LogicalPlanNode;
+    cteMap?: Map<string, LogicalPlanNode> | null;
+}
+interface SqlOptions {
+    frames?: SqlFrame[];
+}
+interface DistributedClusterConfig {
+    nodeId?: string;
+    host?: string;
+    port?: number;
+    role?: string;
+    capacity?: number;
+    transport?: Transport;
+}
+interface DistributedContext {
+    clusterManager: object;
+    partitionMap: object;
+    transport: Transport;
+    coordinator: object;
+    localNode: {
+        port: number;
+    };
+}
+interface DistributedPassEntry {
+    method: 'insertPassAfter' | 'registerPass';
+    args: [string, OptimizationPass] | [OptimizationPass];
+}
+interface WorkerPoolLike {
+    init(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+interface FragmentPoolLike {
+    close(): Promise<void>;
+}
+interface CompiledDDL {
+    ddl: DDLStmt;
+    plan?: undefined;
+}
+interface CompiledQuery {
+    ddl?: undefined;
+    plan: LogicalPlanNode;
+    outputColumns: OutputColumn[];
+    cteMap: Map<string, LogicalPlanNode>;
+    isExplain: boolean;
+    isAnalyze: boolean;
+}
+type CompileResult = CompiledDDL | CompiledQuery;
+interface DDLResult {
+    rows: Record<string, ColumnValue>[];
+    columns: string[];
+    message?: string;
+}
+interface RunRowsResult {
+    rows: Record<string, ColumnValue>[];
+    columns: string[];
+}
+export declare function setDefaultStorageBackend(factory: StorageBackendFactory): void;
+export declare class QueryEngine {
+    catalog: Catalog;
+    functionRegistry: typeof defaultFunctionRegistry;
+    storageBackend: StorageBackendLike;
+    tempManager: TempManagerLike;
+    executor: QueryExecutor;
+    wasmEnabled: boolean;
+    _dfIdCounter: number;
+    precomputedStats: StatisticsMap | null;
+    statsCache: StatisticsCache;
+    optimizer: Optimizer;
+    _statsCollected?: boolean;
+    _distributedPasses?: DistributedPassEntry[];
+    _activeCancel?: AbortController | null;
+    workerPool?: WorkerPoolLike | null;
+    fragmentPool?: FragmentPoolLike | null;
+    parallelEnabled?: boolean;
+    distributed?: DistributedContext;
+    constructor(catalog: Catalog, options?: QueryEngineOptions);
+    _nextDfId(): number;
+    close(): void;
+    collectStatistics(): Promise<StatisticsMap | null>;
+    createOptimizer(statistics: StatisticsMap | null): Optimizer;
+    parseSQL(sql: string): Statement;
+    bind(ast: QueryStmt): BoundQuery;
+    plan(boundQuery: BoundQuery): LogicalPlanNode;
+    optimize(logicalPlan: LogicalPlanNode): LogicalPlanNode;
+    compile(sql: string): Promise<CompileResult>;
+    optimizeCTEMap(cteMap: Map<string, LogicalPlanNode>): Map<string, LogicalPlanNode>;
+    _applyDistributedPasses(optimizer: Optimizer, passes: DistributedPassEntry[]): void;
+    _ensureStatistics(): Promise<void>;
+    table(name: string): DataFrame;
+    createDataFrame(rows: Record<string, ColumnValue>[] | ColumnValue[][], declaredSchema?: ColumnSchema[] | null): DataFrame;
+    sql(sqlString: string, options?: SqlOptions): DataFrame;
+    _formatPlan(plan: LogicalPlanNode): Promise<string>;
+    _explainPlanResult(plan: LogicalPlanNode): Promise<RunRowsResult>;
+    _runPlan(plan: LogicalPlanNode, outputColumns: OutputColumn[], streaming?: boolean, cteMap?: Map<string, LogicalPlanNode> | null): Promise<QueryResult>;
+    run(sql: string): Promise<DDLResult | RunRowsResult>;
+    cancel(): void;
+    executeDDL(ddl: DDLStmt): Promise<DDLResult>;
+    executeCreateTable(stmt: CreateTableStmtNode): Promise<DDLResult>;
+    createTableAsSelect(tableName: string, query: QueryStmt): Promise<DDLResult>;
+    executeDropTable(stmt: DropTableStmtNode): DDLResult;
+    stream(sql: string): Promise<DDLResult | RunRowsResult | QueryResult>;
+    buildIndexes(): Promise<void>;
+    enableWasm(): Promise<void>;
+    enableParallel(): Promise<boolean>;
+    enableDistributed(clusterConfig?: DistributedClusterConfig): Promise<object>;
+    shutdown(): Promise<void>;
+}
+export {};

package/dist/engine-entry.d.ts

@@ -0,0 +1,12 @@
+import { QueryEngine } from './engine/query-engine.js';
+import { Catalog } from './catalog/catalog.js';
+import type { ColumnSchema, ColumnValue } from './storage/data-type.js';
+export type RowInput = Record<string, ColumnValue> | ColumnValue[];
+type QueryEngineOptions = ConstructorParameters<typeof QueryEngine>[1];
+export type CreateEngineOptions = QueryEngineOptions & {
+    catalog?: Catalog;
+};
+export declare function createEngine(options?: CreateEngineOptions): QueryEngine;
+export declare function registerTable(engine: QueryEngine, name: string, rows: RowInput[], declaredSchema?: ColumnSchema[] | null): ColumnSchema[];
+export declare function registerStreamingTable(engine: QueryEngine, name: string, schemaOrBatches: ColumnSchema[] | null | AsyncIterable<RowInput[]>, maybeBatches?: AsyncIterable<RowInput[]>): Promise<ColumnSchema[]>;
+export {};

package/dist/execution/builders/aggregate-builder.d.ts

@@ -0,0 +1,46 @@
+import type { LogicalPlanNode, LogicalAggregateNode, LogicalPartialAggregateNode, LogicalFinalAggregateNode } from '../../planner/logical-plan.js';
+import { buildFragmentSpec } from '../fragment-spec.js';
+import { DataType } from '../../storage/data-type.js';
+import type { DataChunk } from '../../storage/chunk.js';
+import { BoundExprKind } from '../../binder/expression-binder.js';
+import type { BoundExpr } from '../../binder/expression-binder.js';
+import type { CompiledPipeline, ExecSchema } from '../execution-types.js';
+type BuiltFragmentSpec = NonNullable<ReturnType<typeof buildFragmentSpec>>;
+type FragmentSpec = BuiltFragmentSpec['spec'];
+interface AggDescriptor {
+    kind?: BoundExprKind;
+    name?: string;
+    func?: string;
+    distinct?: boolean;
+    args?: BoundExpr[];
+    outputName?: string;
+}
+interface TableStorageLike {
+    scan(): AsyncGenerator<DataChunk>;
+    getSchema(): ExecSchema;
+    rowCount(): number;
+}
+interface CatalogLike {
+    getTableStorage(table: string): TableStorageLike | null;
+}
+export interface FragmentPoolLike {
+    runAggregate(spec: FragmentSpec, columnIndexes: number[], chunks: DataChunk[], options: {
+        spillDir?: string;
+    }): Promise<DataChunk[]>;
+}
+interface TempManagerLike {
+    allocate(kind: string, label: string): string;
+}
+interface ExecutorLike {
+    buildPipeline(node: LogicalPlanNode): Promise<CompiledPipeline>;
+    catalog: CatalogLike;
+    tempManager: TempManagerLike;
+    fragmentPool: FragmentPoolLike | null;
+    normalizeExecType(dt: string): DataType;
+    normalizeAggResultType(agg: AggDescriptor): DataType;
+    _executeSubPipeline(compiled: CompiledPipeline): Promise<DataChunk[]>;
+}
+export declare function buildAggregate(executor: ExecutorLike, node: LogicalAggregateNode): Promise<CompiledPipeline>;
+export declare function buildPartialAggregate(executor: ExecutorLike, node: LogicalPartialAggregateNode): Promise<CompiledPipeline>;
+export declare function buildFinalAggregate(executor: ExecutorLike, node: LogicalFinalAggregateNode): Promise<CompiledPipeline>;
+export {};

package/dist/execution/builders/builder-utils.d.ts

@@ -0,0 +1,5 @@
+import type { DataChunk } from '../../storage/chunk.js';
+import type { PipelineGraph } from '../pipeline.js';
+import type { ColumnMapping, CompiledPipeline, ExecSchema } from '../execution-types.js';
+export declare function combinedMappingOf(...schemas: ExecSchema[]): ColumnMapping;
+export declare function registerBufferedChild(graph: PipelineGraph, currentPipelineId: number, compiled: CompiledPipeline): DataChunk[];

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

@@ -0,0 +1,20 @@
+import { DataChunk } from '../../storage/chunk.js';
+import type { ColumnMapping, CompiledPipeline, ExecSchema } from '../execution-types.js';
+import type { LogicalPlanNode, LogicalCTEAnchorNode, LogicalCTEScanNode, LogicalMaterializeNode, LogicalDependentJoinNode } from '../../planner/logical-plan.js';
+interface CTEResult {
+    chunks: DataChunk[];
+    schema: ExecSchema;
+    columnMapping: ColumnMapping;
+}
+interface ExecutorLike {
+    buildPipeline(node: LogicalPlanNode): Promise<CompiledPipeline>;
+    buildSchemaMapping(schema: ExecSchema, alias: string): ColumnMapping;
+    findCTEPlan(name: string): LogicalPlanNode | null;
+    cteResults: Map<string, CTEResult>;
+    cteDefinitions: Map<string, LogicalPlanNode>;
+}
+export declare function buildCTEAnchor(executor: ExecutorLike, node: LogicalCTEAnchorNode): Promise<CompiledPipeline>;
+export declare function buildCTEScan(executor: ExecutorLike, node: LogicalCTEScanNode): Promise<CompiledPipeline>;
+export declare function buildMaterialize(executor: ExecutorLike, node: LogicalMaterializeNode): Promise<CompiledPipeline>;
+export declare function buildDependentJoin(executor: ExecutorLike, node: LogicalDependentJoinNode): Promise<CompiledPipeline>;
+export {};

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

@@ -0,0 +1,33 @@
+import type { DataChunk } from '../../storage/chunk.js';
+import type { LogicalPlanNode, LogicalExchangeNode, LogicalMergeExchangeNode, LogicalExchangeReceiveNode } from '../../planner/logical-plan.js';
+import type { CompiledPipeline } from '../execution-types.js';
+import type { Transport } from '../../distributed/transport/transport.js';
+interface ExchangeConfig {
+    transport: Transport;
+    sourceNodes: string[];
+    channelId: string;
+    exchangeType?: string;
+}
+interface MergeExchangeConfig {
+    transport: Transport;
+    sourceNodes: string[];
+    channelId: string;
+}
+interface DistributedContextLike {
+    role: string;
+    getExchangeConfig(node: LogicalExchangeNode): ExchangeConfig;
+    getMergeExchangeConfig(node: LogicalMergeExchangeNode): MergeExchangeConfig;
+}
+interface ChunkReceiverLike {
+    generate(): AsyncGenerator<DataChunk>;
+    cleanup(): void;
+}
+interface ExecutorLike {
+    buildPipeline(node: LogicalPlanNode): Promise<CompiledPipeline>;
+    _distributedContext: DistributedContextLike | null;
+    _exchangeReceivers: Map<number, ChunkReceiverLike> | null;
+}
+export declare function buildExchange(executor: ExecutorLike, node: LogicalExchangeNode): Promise<CompiledPipeline>;
+export declare function buildMergeExchange(executor: ExecutorLike, node: LogicalMergeExchangeNode): Promise<CompiledPipeline>;
+export declare function buildExchangeReceive(executor: ExecutorLike, node: LogicalExchangeReceiveNode): Promise<CompiledPipeline>;
+export {};

package/dist/execution/builders/join-builder.d.ts

@@ -0,0 +1,67 @@
+import type { LogicalJoinNode, LogicalPlanNode } from '../../planner/logical-plan.js';
+import { HashJoinBuild, HashJoinProbe } from '../operators/hash-join.js';
+import type { Stage, JoinSpec } from '../fragment-spec.js';
+import { DataType } from '../../storage/data-type.js';
+import type { BoundExpr } from '../../binder/expression-binder.js';
+import type { ColumnInfo } from '../../binder/scope.js';
+import type { DataChunk } from '../../storage/chunk.js';
+import type { ColumnMapping, CompiledPipeline, ExecSchema } from '../execution-types.js';
+type SpillManagerLike = ConstructorParameters<typeof HashJoinBuild>[3];
+export type MakeBuildSide = () => HashJoinBuild;
+export type MakeProbeOp = (buildSide: HashJoinBuild) => HashJoinProbe;
+interface JoinSideSpec {
+    schema: ExecSchema;
+    baseSchema: ExecSchema;
+    stages: Stage[];
+}
+export interface JoinSide {
+    spec: JoinSideSpec;
+    storage: TableStorageLike | null;
+    columnIndexes: number[] | null;
+}
+export interface ParallelJoinPrep {
+    spec: JoinSpec;
+    buildSide: JoinSide;
+    probeSide: JoinSide;
+}
+interface JoinOutputTypes {
+    build: DataType[];
+    probe: DataType[];
+}
+interface JoinStreamSide {
+    chunks: DataChunk[];
+    columnIndexes: number[] | null;
+}
+export interface FragmentPoolLike {
+    runJoinStream(spec: JoinSpec, buildSide: JoinStreamSide, probeSide: JoinStreamSide, outputTypes: JoinOutputTypes): AsyncGenerator<DataChunk>;
+}
+interface TempManagerLike {
+    allocate(category: string, label: string): string;
+}
+interface StorageBackendLike {
+    createSpillManager(handle: string): SpillManagerLike;
+}
+interface TableStorageLike {
+    scan(): AsyncGenerator<DataChunk>;
+    getSchema(): ExecSchema;
+}
+interface CatalogLike {
+    getTableStorage(table: string): TableStorageLike | null;
+}
+interface ExecutorLike {
+    buildPipeline(node: LogicalPlanNode): Promise<CompiledPipeline>;
+    buildSchemaMapping(schema: ExecSchema, alias: string): ColumnMapping;
+    resolveProjectedColumnIndexes(storageSchema: ExecSchema, planColumns: ColumnInfo[] | null): number[] | null;
+    catalog: CatalogLike;
+    tempManager: TempManagerLike;
+    storageBackend: StorageBackendLike;
+    fragmentPool: FragmentPoolLike | null;
+    _estimatePlanRows(node: LogicalPlanNode): number;
+    _prepareParallelJoin(node: LogicalJoinNode, buildInput: CompiledPipeline, probeInput: CompiledPipeline, buildNode: LogicalPlanNode, probeNode: LogicalPlanNode, buildKeys: BoundExpr[], probeKeys: BoundExpr[], residualCondition: BoundExpr | null, combinedMapping: ColumnMapping): ParallelJoinPrep | null;
+    _runBufferedSerialJoin(makeBuildSide: MakeBuildSide, makeProbeOp: MakeProbeOp, buildChunks: DataChunk[], probeChunks: DataChunk[], node: LogicalJoinNode, probeColCount: number): Promise<DataChunk[]>;
+    _executeSubPipeline(compiled: CompiledPipeline): Promise<DataChunk[]>;
+}
+export declare function buildJoin(executor: ExecutorLike, node: LogicalJoinNode): Promise<CompiledPipeline>;
+export declare function prepareParallelJoin(executor: ExecutorLike, node: LogicalJoinNode, buildInput: CompiledPipeline, probeInput: CompiledPipeline, buildNode: LogicalPlanNode, probeNode: LogicalPlanNode, buildKeys: BoundExpr[], probeKeys: BoundExpr[], residualCondition: BoundExpr | null, combinedMapping: ColumnMapping): ParallelJoinPrep | null;
+export declare function runBufferedSerialJoin(makeBuildSide: MakeBuildSide, makeProbeOp: MakeProbeOp, buildChunks: DataChunk[], probeChunks: DataChunk[], node: LogicalJoinNode, probeColCount: number): Promise<DataChunk[]>;
+export {};

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

@@ -0,0 +1,30 @@
+import { FilterOperator } from '../operators/filter.js';
+import { SortOperator } from '../operators/sort.js';
+import type { DataType } from '../../storage/data-type.js';
+import type { ColumnMapping, CompiledPipeline, ExecSchema } from '../execution-types.js';
+import type { LogicalPlanNode, LogicalFilterNode, LogicalProjectNode, LogicalSortNode, LogicalTopNNode, LogicalLimitNode, LogicalDistinctNode, LogicalUnionNode, LogicalWindowNode } from '../../planner/logical-plan.js';
+type ParallelDispatchLike = ConstructorParameters<typeof FilterOperator>[3];
+type SpillManagerLike = ConstructorParameters<typeof SortOperator>[3];
+interface TempManagerLike {
+    allocate(category: string, label: string): string;
+}
+interface StorageBackendLike {
+    createSpillManager(handle: string): SpillManagerLike;
+}
+interface ExecutorLike {
+    buildPipeline(node: LogicalPlanNode): Promise<CompiledPipeline>;
+    buildSchemaMapping(schema: ExecSchema, alias: string): ColumnMapping;
+    normalizeExecType(dt: DataType | string): DataType;
+    parallelDispatch: ParallelDispatchLike;
+    tempManager: TempManagerLike;
+    storageBackend: StorageBackendLike;
+}
+export declare function buildFilter(executor: ExecutorLike, node: LogicalFilterNode): Promise<CompiledPipeline>;
+export declare function buildProject(executor: ExecutorLike, node: LogicalProjectNode): Promise<CompiledPipeline>;
+export declare function buildSort(executor: ExecutorLike, node: LogicalSortNode): Promise<CompiledPipeline>;
+export declare function buildTopN(executor: ExecutorLike, node: LogicalTopNNode): Promise<CompiledPipeline>;
+export declare function buildLimit(executor: ExecutorLike, node: LogicalLimitNode): Promise<CompiledPipeline>;
+export declare function buildDistinct(executor: ExecutorLike, node: LogicalDistinctNode): Promise<CompiledPipeline>;
+export declare function buildUnion(executor: ExecutorLike, node: LogicalUnionNode): Promise<CompiledPipeline>;
+export declare function buildWindow(executor: ExecutorLike, node: LogicalWindowNode): Promise<CompiledPipeline>;
+export {};