@slexisvn/query-engine 0.1.0

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

@@ -0,0 +1,336 @@
+import type { LogicalPlanNode, PlanNodeType } from '../planner/logical-plan.js';
+import type { DataChunk } from '../storage/chunk.js';
+import type { ColumnValue, DataType } from '../storage/data-type.js';
+import type { BoundExpr } from '../binder/expression-binder.js';
+import type { ExecSchema, ExecColumn } from '../execution/execution-types.js';
+import type { FragmentSpec, JoinSpec } from '../execution/fragment-spec.js';
+export type NodeId = string;
+export type ChannelId = string;
+export type FragmentId = number;
+export type PartitionId = number;
+export declare enum NodeRole {
+    COORDINATOR = "coordinator",
+    WORKER = "worker",
+    HYBRID = "hybrid"
+}
+export declare enum NodeStatus {
+    ALIVE = "alive",
+    SUSPECT = "suspect",
+    DEAD = "dead"
+}
+export declare enum StrategyType {
+    HASH = "hash",
+    RANGE = "range",
+    ROUND_ROBIN = "round_robin"
+}
+export declare enum DistributionStrategy {
+    COLOCATED = "colocated",
+    BROADCAST_LEFT = "broadcast_left",
+    BROADCAST_RIGHT = "broadcast_right",
+    SHUFFLE = "shuffle"
+}
+export declare enum ExchangeType {
+    HASH_SHUFFLE = "hash_shuffle",
+    BROADCAST = "broadcast",
+    GATHER = "gather",
+    PASSTHROUGH = "passthrough"
+}
+export declare enum FragmentState {
+    PENDING = "pending",
+    DISPATCHED = "dispatched",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    CANCELLED = "cancelled"
+}
+export interface NodeCapacity {
+    cores: number;
+    memoryMb: number;
+}
+export interface NodeDescriptorJSON {
+    nodeId: NodeId;
+    host: string;
+    port: number;
+    role: NodeRole;
+    capacity: NodeCapacity;
+    status: NodeStatus;
+    partitions: string[];
+}
+export interface NodeAddress {
+    host: string;
+    port: number;
+}
+export interface ClusterSnapshot {
+    localNodeId: NodeId;
+    nodes: NodeDescriptorJSON[];
+}
+export interface PartitionAssignment {
+    node: NodeDescriptorJSON;
+    partitionIds: PartitionId[];
+}
+export type NodeStatusChange = (nodeId: NodeId, status: NodeStatus) => void;
+export type NodeFailureCallback = (node: NodeDescriptorJSON) => void;
+export type NodeJoinCallback = (descriptor: NodeDescriptorJSON) => void;
+export interface NodeRegistration {
+    nodeId: NodeId;
+    host: string;
+    port: number;
+    role: NodeRole;
+    capacity: NodeCapacity;
+    partitions: string[];
+}
+export interface RegisterAck {
+    ok: boolean;
+}
+export interface HeartbeatMessage {
+    nodeId: NodeId;
+    timestamp: number;
+}
+export interface HeartbeatAck {
+    ts: number;
+}
+export interface StatusResponse {
+    status: 'alive';
+    nodeId: NodeId | null;
+}
+export declare const CHUNK_HEADER_MAGIC = 1363493704;
+export interface EncodedChunkColumnHeader {
+    typeId: number;
+    isDictionary: boolean;
+    payloadSize: number;
+}
+export interface EncodedChunkEnvelope {
+    magic: typeof CHUNK_HEADER_MAGIC;
+    columnCount: number;
+    rowCount: number;
+    columns: EncodedChunkColumnHeader[];
+}
+export interface DecodedColumnMeta {
+    dataType: DataType;
+    isDictionary: boolean;
+    payloadSize: number;
+}
+export interface ExchangeChunkMessage {
+    channelId: ChannelId;
+    sourceNodeId: NodeId;
+    encodedChunk: Buffer;
+}
+export type ChunkReceivedCallback = (sourceNodeId: NodeId, encodedChunk: Buffer) => void;
+export interface PendingChunk {
+    sourceNodeId: NodeId;
+    data: Buffer;
+}
+export declare enum ControlMessageType {
+    CANCEL_FRAGMENT = "cancel_fragment",
+    FRAGMENT_COMPLETED = "fragment_completed",
+    FRAGMENT_FAILED = "fragment_failed"
+}
+export interface CancelFragmentMessage {
+    type: ControlMessageType.CANCEL_FRAGMENT;
+    fragmentId: FragmentId;
+}
+export interface FragmentCompletedMessage {
+    type: ControlMessageType.FRAGMENT_COMPLETED;
+    fragmentId: FragmentId;
+    nodeId: NodeId;
+}
+export interface FragmentFailedMessage {
+    type: ControlMessageType.FRAGMENT_FAILED;
+    fragmentId: FragmentId;
+    error: string;
+}
+export type ControlMessage = CancelFragmentMessage | FragmentCompletedMessage | FragmentFailedMessage;
+export type ControlMessageCallback = (message: ControlMessage) => void;
+export type FragmentReceivedCallback = (fragment: FragmentDispatchJSON) => void;
+export interface ExchangeInput {
+    sourceFragmentId: FragmentId;
+    exchangeType: ExchangeType;
+    keys?: BoundExpr[];
+    ordered?: boolean;
+    orderKeys?: DistributedOrderKey[];
+}
+export interface GatherPartitioning {
+    exchangeType: ExchangeType.GATHER;
+    partitionCount: number;
+    targetNodes?: NodeId[];
+}
+export interface BroadcastPartitioning {
+    exchangeType: ExchangeType.BROADCAST;
+    targetNodes: NodeId[];
+    partitionCount?: number;
+}
+export interface HashShufflePartitioning {
+    exchangeType: ExchangeType.HASH_SHUFFLE;
+    partitionCount: number;
+    targetNodes: NodeId[];
+    keyColumns: number[];
+}
+export type OutputPartitioning = GatherPartitioning | BroadcastPartitioning | HashShufflePartitioning;
+export interface DistributedOrderKey {
+    expr?: BoundExpr;
+    columnIndex?: number;
+    direction?: string;
+}
+export interface FragmentDispatchJSON {
+    fragmentId: FragmentId;
+    planRoot: LogicalPlanNode;
+    targetNodes: NodeId[];
+    exchangeInputs: ExchangeInput[];
+    outputPartitioning: OutputPartitioning | null;
+    estimatedCardinality: number;
+    state: FragmentState;
+    coordinatorNodeId?: NodeId;
+}
+export interface FragmentExecutionResult {
+    fragmentId: FragmentId;
+    state: FragmentState.COMPLETED | FragmentState.FAILED;
+    rowCount: number;
+}
+export interface OutputConfig {
+    targetNodes: NodeId[];
+    exchangeType: ExchangeType;
+    partitionCount?: number;
+    keyColumns?: number[];
+    channelId: ChannelId;
+    keyExtractors?: KeyExtractor[];
+}
+export type KeyExtractor = (chunk: DataChunk, rowIdx: number) => ColumnValue;
+export interface ExchangeSenderOptions {
+    exchangeType: ExchangeType;
+    keyExtractors: KeyExtractor[];
+    partitionCount: number;
+    channelId: ChannelId;
+}
+export interface ExchangeReceiverOptions {
+    channelId: ChannelId;
+}
+export interface MergeExchangeOptions {
+    orderKeys: DistributedOrderKey[];
+    limit: number | null;
+    channelId: ChannelId;
+}
+export interface PartitionTableInfo {
+    strategyType: StrategyType;
+    partitionCount: number;
+    partitionKey: string | null;
+    placements: Map<PartitionId, NodeId[]>;
+}
+export interface PartitionTableSnapshot {
+    strategyType: StrategyType;
+    partitionCount: number;
+    placements: Record<string, NodeId[]>;
+}
+export type PartitionMapSnapshot = Record<string, PartitionTableSnapshot>;
+export type PartitionPlacements = Map<PartitionId, NodeId[]>;
+export interface PartitionMovement {
+    partitionId: PartitionId;
+    from: NodeId;
+    to: NodeId;
+}
+export type PrunedPartitionSet = Set<PartitionId>;
+export interface RangeBoundarySpec {
+    type: StrategyType.RANGE;
+    boundaries: ColumnValue[];
+}
+export interface HashStrategySpec {
+    type: StrategyType.HASH;
+    seed: number;
+}
+export interface RoundRobinStrategySpec {
+    type: StrategyType.ROUND_ROBIN;
+}
+export type PartitionStrategySpec = HashStrategySpec | RangeBoundarySpec | RoundRobinStrategySpec;
+export interface PartitionKeyRef {
+    col: BoundExpr;
+    side: 'left' | 'right';
+}
+export interface JoinShuffleKeys {
+    leftKeys: BoundExpr[];
+    rightKeys: BoundExpr[];
+}
+export interface JoinShuffleKeyIndices {
+    leftIdx: number[];
+    rightIdx: number[];
+}
+export interface PassthroughSideExchange {
+    type: ExchangeType.PASSTHROUGH;
+}
+export interface BroadcastSideExchange {
+    type: ExchangeType.BROADCAST;
+}
+export interface ShuffleSideExchange {
+    type: ExchangeType.HASH_SHUFFLE;
+    keys: BoundExpr[];
+    partitionCount: number;
+}
+export type SideExchange = PassthroughSideExchange | BroadcastSideExchange | ShuffleSideExchange;
+export interface JoinExchangePlacement {
+    left: SideExchange;
+    right: SideExchange;
+}
+export interface GatherAggregateExchange {
+    type: ExchangeType.GATHER;
+}
+export interface ShuffleAggregateExchange {
+    type: ExchangeType.HASH_SHUFFLE;
+    keys: BoundExpr[];
+    partitionCount: number;
+}
+export type AggregateExchange = GatherAggregateExchange | ShuffleAggregateExchange;
+export interface SortExchange {
+    type: ExchangeType.GATHER;
+    ordered: true;
+    orderKeys: DistributedOrderKey[];
+}
+export interface AggregateDecomposition {
+    partial: string;
+    final: string;
+}
+export interface DistributedScanSchemaColumn {
+    name: string;
+    dataType: DataType | string;
+    tableAlias: string;
+}
+export type DistributedScanSchema = DistributedScanSchemaColumn[];
+export interface FragmentProcessResult {
+    plan: LogicalPlanNode;
+    exchangeInputs: ExchangeInput[];
+    workerNodes: NodeId[];
+}
+export interface GatherPlacementResult {
+    plan: LogicalPlanNode;
+    exchangeInputs: ExchangeInput[];
+}
+export interface FragmentizeContext {
+    coordinatorId: NodeId;
+}
+export declare enum QueryStatus {
+    RUNNING = "running",
+    CANCELLED = "cancelled"
+}
+export interface FragmentStatusSummary {
+    fragmentId: FragmentId;
+    state: FragmentState;
+    assignedNode: NodeId | null;
+}
+export interface QueryStatusReport {
+    queryId: number;
+    status: QueryStatus;
+    elapsed: number;
+    fragments: FragmentStatusSummary[];
+}
+export interface DistributedQueryResult {
+    rows: ColumnValue[][];
+    columns: string[];
+}
+export type DistributedPlanNodeType = PlanNodeType.EXCHANGE | PlanNodeType.PARTIAL_AGGREGATE | PlanNodeType.FINAL_AGGREGATE | PlanNodeType.MERGE_EXCHANGE | PlanNodeType.EXCHANGE_RECEIVE;
+export interface WorkerFragmentSpec {
+    fragmentId: FragmentId;
+    spec: FragmentSpec;
+    joinSpec: JoinSpec | null;
+    schema: ExecSchema;
+}
+export interface ExchangeChannelSchema {
+    channelId: ChannelId;
+    schema: ExecColumn[];
+}

package/dist/distributed/execution/coordinator.d.ts

@@ -0,0 +1,53 @@
+import { DistributedPlanner } from '../planner/distributed-planner.js';
+import { FragmentExecutor } from './fragment-executor.js';
+import { ResultSink } from '../../execution/result-sink.js';
+import type { Fragment, FragmentPlan } from '../planner/fragment.js';
+import type { QueryEngine } from '../../engine/query-engine.js';
+import type { ClusterManager } from '../cluster/cluster-manager.js';
+import type { Transport } from '../transport/transport.js';
+import type { ExchangeReceiver } from './exchange-operator.js';
+import type { LogicalPlanNode } from '../../planner/logical-plan.js';
+import type { NodeId, FragmentId, OutputConfig, QueryStatus, QueryStatusReport, DistributedQueryResult } from '../distributed-types.js';
+type DistributedPlannerArgs = ConstructorParameters<typeof DistributedPlanner>;
+type PartitionMapLike = DistributedPlannerArgs[0];
+type FragmentReceivers = Map<FragmentId, ExchangeReceiver>;
+type FragmentExecuteResult = Awaited<ReturnType<FragmentExecutor['execute']>>;
+interface RootFragmentResult {
+    sink: ResultSink;
+}
+interface ActiveQuery {
+    fragmentPlan: FragmentPlan;
+    startTime: number;
+    status: QueryStatus | 'running' | 'cancelled';
+}
+type DDLResultLike = ReturnType<QueryEngine['executeDDL']>;
+export declare class QueryCoordinator {
+    _engine: QueryEngine;
+    _clusterManager: ClusterManager;
+    _partitionMap: PartitionMapLike;
+    _transport: Transport;
+    _activeQueries: Map<number, ActiveQuery>;
+    _fragmentExecutor: FragmentExecutor;
+    _nextQueryId: number;
+    constructor(queryEngine: QueryEngine, clusterManager: ClusterManager, partitionMap: PartitionMapLike, transport: Transport);
+    execute(sql: string): Promise<DistributedQueryResult | DDLResultLike>;
+    cancel(queryId: number): Promise<void>;
+    _executeFragmentPlan(fragmentPlan: FragmentPlan, queryId: number, timeout: number): Promise<void>;
+    _groupByDependencyLevel(fragments: Fragment[], fragmentPlan: FragmentPlan): Fragment[][];
+    _dispatchFragment(fragment: Fragment, fragmentPlan: FragmentPlan): Promise<void>;
+    _executeLocalFragment(fragment: Fragment, _fragmentPlan: FragmentPlan): Promise<void>;
+    _executeRemoteFragment(fragment: Fragment, targetNodeId: NodeId): Promise<void>;
+    _executeRootFragment(rootFragment: Fragment): Promise<FragmentExecuteResult>;
+    _executeRootFragmentWithReceivers(rootFragment: Fragment, receivers: FragmentReceivers): Promise<RootFragmentResult>;
+    _waitForFragmentCompletion(fragment: Fragment): Promise<void>;
+    _cancelFragment(fragment: Fragment): Promise<void>;
+    _selectTargetNode(fragment: Fragment): NodeId;
+    _buildOutputConfig(fragment: Fragment, targetNodeId?: NodeId): OutputConfig | null;
+    _reoptimize(plan: LogicalPlanNode): LogicalPlanNode;
+    _setupFragmentHandler(): void;
+    _handleFragmentCompleted(fragmentId: FragmentId): void;
+    _handleFragmentFailed(fragmentId: FragmentId, errorMessage: string): void;
+    getActiveQueryCount(): number;
+    getQueryStatus(queryId: number): QueryStatusReport | null;
+}
+export {};

package/dist/distributed/execution/exchange-operator.d.ts

@@ -0,0 +1,44 @@
+import { ChunkCodec } from '../transport/chunk-codec.js';
+import { DataChunk } from '../../storage/chunk.js';
+import type { Transport } from '../transport/transport.js';
+import type { NodeId, ChannelId, KeyExtractor, ExchangeType as ExchangeTypeEnum, ExchangeSenderOptions, ExchangeReceiverOptions, PartitionId } from '../distributed-types.js';
+export declare class ExchangeSender {
+    _transport: Transport;
+    _targetNodes: NodeId[];
+    _exchangeType: ExchangeTypeEnum;
+    _keyExtractors: KeyExtractor[];
+    _partitionCount: number;
+    _channelId: ChannelId;
+    _codec: ChunkCodec;
+    _batchSize: number;
+    _closed: boolean;
+    constructor(transport: Transport, targetNodes: NodeId[], options?: Partial<ExchangeSenderOptions>);
+    get channelId(): ChannelId;
+    init(): Promise<void>;
+    consume(chunk: DataChunk): Promise<void>;
+    finalize(): Promise<void>;
+    _sendGather(chunk: DataChunk): Promise<void>;
+    _sendBroadcast(chunk: DataChunk): Promise<void>;
+    _sendShuffle(chunk: DataChunk): Promise<void>;
+    _partitionByKey(chunk: DataChunk): Map<PartitionId, DataChunk>;
+}
+export declare class ExchangeReceiver {
+    _transport: Transport;
+    _sourceNodes: NodeId[];
+    _channelId: ChannelId;
+    _codec: ChunkCodec;
+    _bufferCapacity: number;
+    _buffer: DataChunk[];
+    _completedSources: Set<NodeId>;
+    _resolveWaiter: (() => void) | null;
+    _done: boolean;
+    _error: Error | null;
+    _listening: boolean;
+    constructor(transport: Transport, sourceNodes: NodeId[], options?: Partial<ExchangeReceiverOptions>);
+    get channelId(): ChannelId;
+    init(): Promise<void>;
+    generate(): AsyncGenerator<DataChunk, void, void>;
+    cleanup(): void;
+    _handleChunk(sourceNodeId: NodeId, encodedChunk: Buffer): void;
+    _wake(): void;
+}

package/dist/distributed/execution/fragment-executor.d.ts

@@ -0,0 +1,48 @@
+import type { LogicalPlanNode } from '../../planner/logical-plan.js';
+import { QueryExecutor } from '../../execution/query-executor.js';
+import { ResultSink } from '../../execution/result-sink.js';
+import { ExchangeSender } from './exchange-operator.js';
+import { ExchangeReceiver } from './exchange-operator.js';
+import type { Transport } from '../transport/transport.js';
+import type { FragmentId, OutputConfig, ExchangeInput } from '../distributed-types.js';
+type QueryExecutorArgs = ConstructorParameters<typeof QueryExecutor>;
+type CatalogLike = QueryExecutorArgs[0];
+type TempManagerLike = QueryExecutorArgs[1];
+type StorageBackendLike = NonNullable<QueryExecutorArgs[2]>;
+interface FragmentLike {
+    fragmentId: FragmentId;
+    planRoot: LogicalPlanNode;
+    exchangeInputs: ExchangeInput[];
+    markRunning(): void;
+    markCompleted(): void;
+    markFailed(error: Error): void;
+    markCancelled(): void;
+}
+interface CancelToken {
+    cancelled: boolean;
+}
+interface ActiveFragment {
+    fragment: FragmentLike;
+    cancelToken: CancelToken;
+}
+interface ExecuteResult {
+    sink: ResultSink;
+    sender: ExchangeSender | null;
+    receivers: Map<FragmentId, ExchangeReceiver>;
+}
+export declare class FragmentExecutor {
+    _catalog: CatalogLike;
+    _tempManager: TempManagerLike;
+    _transport: Transport;
+    _activeFragments: Map<FragmentId, ActiveFragment>;
+    _localExecutor: QueryExecutor;
+    constructor(catalog: CatalogLike, tempManager: TempManagerLike, transport: Transport, storageBackend: StorageBackendLike, options?: Record<string, never>);
+    execute(fragment: FragmentLike, outputConfig: OutputConfig | null): Promise<ExecuteResult>;
+    cancel(fragmentId: FragmentId): Promise<void>;
+    isRunning(fragmentId: FragmentId): boolean;
+    _executePlan(planRoot: LogicalPlanNode, sink: ResultSink, receivers: Map<FragmentId, ExchangeReceiver>, cancelToken: CancelToken): Promise<void>;
+    _setupReceivers(fragment: FragmentLike): Promise<Map<FragmentId, ExchangeReceiver>>;
+    _setupSender(outputConfig: OutputConfig): Promise<ExchangeSender>;
+    _cleanupReceivers(fragment: FragmentLike): void;
+}
+export {};

package/dist/distributed/execution/merge-exchange.d.ts

@@ -0,0 +1,55 @@
+import { DataChunk } from '../../storage/chunk.js';
+import { Column } from '../../storage/column.js';
+import { ChunkCodec } from '../transport/chunk-codec.js';
+import type { Transport } from '../transport/transport.js';
+import type { NodeId, ChannelId, DistributedOrderKey, MergeExchangeOptions } from '../distributed-types.js';
+interface ReadableChunk extends DataChunk {
+    _readIdx?: number;
+}
+interface HeapEntry {
+    nodeId: NodeId;
+    chunk: ReadableChunk;
+    rowIdx: number;
+}
+type EntryComparator = (a: HeapEntry, b: HeapEntry) => number;
+export declare class MergeExchangeOperator {
+    _transport: Transport;
+    _sourceNodes: NodeId[];
+    _orderKeys: DistributedOrderKey[];
+    _limit: number | null;
+    _channelId: ChannelId;
+    _codec: ChunkCodec;
+    _buffers: Map<NodeId, ReadableChunk[]>;
+    _exhausted: Set<NodeId>;
+    _resolveWaiter: (() => void) | null;
+    _error: Error | null;
+    _listening: boolean;
+    constructor(transport: Transport, sourceNodes: NodeId[], options?: Partial<MergeExchangeOptions>);
+    get channelId(): ChannelId;
+    init(): Promise<void>;
+    generate(): AsyncGenerator<DataChunk, void, void>;
+    _computeRunLength(top: HeapEntry, heap: MinHeap): number;
+    _compareRowAgainst(chunk: ReadableChunk, rowIdx: number, entry: HeapEntry): number;
+    _compareRows(chunkA: ReadableChunk, rowA: number, chunkB: ReadableChunk, rowB: number): number;
+    _bulkCopy(srcChunk: ReadableChunk, srcStart: number, destCols: Column[], destStart: number, count: number): void;
+    cleanup(): void;
+    _handleChunk(sourceNodeId: NodeId, encodedChunk: Buffer): void;
+    _nextEntry(nodeId: NodeId): HeapEntry | null;
+    _ensureAllStreamsHaveData(): Promise<void>;
+    _waitForData(nodeId: NodeId): Promise<void>;
+    _wake(): void;
+    _compareEntries(a: HeapEntry, b: HeapEntry): number;
+}
+declare class MinHeap {
+    _data: HeapEntry[];
+    _compare: EntryComparator;
+    constructor(comparator: EntryComparator);
+    get size(): number;
+    push(item: HeapEntry): void;
+    pop(): HeapEntry | null;
+    peek(): HeapEntry | null;
+    _bubbleUp(idx: number): void;
+    _sinkDown(idx: number): void;
+    _swap(i: number, j: number): void;
+}
+export { MinHeap };

package/dist/distributed/optimizer/distributed-sort.d.ts

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

package/dist/distributed/optimizer/distribution-aware-join.d.ts

@@ -0,0 +1,28 @@
+import { OptimizationPass } from '../../optimizer/pass.js';
+import type { LogicalPlanNode } from '../../planner/logical-plan.js';
+interface TableStatisticsLike {
+    rowCount: number;
+    avgRowWidth: number;
+}
+interface PartitionTableInfoLike {
+    partitionKey: string | null;
+}
+interface PartitionMapLike {
+    getTableInfo(tableName: string): PartitionTableInfoLike | null;
+    isColocated(tableA: string, tableB: string): boolean;
+}
+export declare const DistributionStrategy: {
+    COLOCATED: string;
+    BROADCAST_LEFT: string;
+    BROADCAST_RIGHT: string;
+    SHUFFLE: string;
+};
+export declare class DistributionAwareJoin extends OptimizationPass {
+    _partitionMap: PartitionMapLike | null;
+    _statisticsMap: Map<string, TableStatisticsLike>;
+    _costPerByte: number;
+    constructor(partitionMap: PartitionMapLike | null, statisticsMap?: Map<string, TableStatisticsLike>);
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}
+export {};

package/dist/distributed/optimizer/partial-aggregate.d.ts

@@ -0,0 +1,9 @@
+import { OptimizationPass } from '../../optimizer/pass.js';
+import { type LogicalPlanNode } from '../../planner/logical-plan.js';
+import type { AggregateDecomposition } from '../distributed-types.js';
+declare const DECOMPOSABLE_FUNCTIONS: Map<string, AggregateDecomposition>;
+export declare class PartialAggregatePass extends OptimizationPass {
+    get name(): string;
+    apply(plan: LogicalPlanNode): LogicalPlanNode;
+}
+export { DECOMPOSABLE_FUNCTIONS };

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

@@ -0,0 +1,27 @@
+import type { NodeId, PartitionId, PartitionPlacements, PartitionMovement, PartitionMapSnapshot, StrategyType as StrategyTypeEnum } from '../distributed-types.js';
+interface PartitionStrategyLike {
+    readonly type: StrategyTypeEnum;
+    readonly _partitionKey?: string | null;
+}
+interface StoredTableInfo {
+    strategy: PartitionStrategyLike;
+    partitionCount: number;
+    partitionKey: string | null;
+    placements: PartitionPlacements;
+}
+export declare class PartitionMap {
+    private _tables;
+    constructor();
+    registerTable(tableName: string, strategy: PartitionStrategyLike, partitionCount: number, placements?: Iterable<[PartitionId, NodeId | NodeId[]]> | null): void;
+    getTableInfo(tableName: string): StoredTableInfo | null;
+    getPartitionCount(tableName: string): number;
+    getPartitionsForNode(tableName: string, nodeId: NodeId): PartitionId[];
+    getNodesForPartition(tableName: string, partitionId: PartitionId): NodeId[];
+    getAllPartitionIds(tableName: string): PartitionId[];
+    isColocated(tableA: string, tableB: string): boolean;
+    rebalance(tableName: string, newNodeIds: NodeId[]): PartitionPlacements;
+    _buildHashRing(nodeIds: NodeId[], partitionCount: number): Map<PartitionId, NodeId>;
+    computeMovements(tableName: string, oldPlacements: PartitionPlacements, newPlacements: PartitionPlacements): PartitionMovement[];
+    snapshot(): PartitionMapSnapshot;
+}
+export {};

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

@@ -0,0 +1,33 @@
+import type { BoundExpr, LiteralValue } from '../../binder/expression-binder.js';
+import type { ColumnValue } from '../../storage/data-type.js';
+import type { PartitionId, PartitionKeyRef, PrunedPartitionSet } from '../distributed-types.js';
+interface PartitionStrategyLike {
+    type: string;
+    partitionFor(key: LiteralValue, partitionCount?: number): PartitionId;
+    boundaries: ColumnValue[];
+}
+interface PartitionTableInfoLike {
+    strategy: PartitionStrategyLike;
+    partitionCount: number;
+    partitionKey: string | null;
+}
+interface PartitionMapLike {
+    getTableInfo(tableName: string): PartitionTableInfoLike | null;
+}
+export declare class PartitionPruner {
+    prune(tableName: string, predicate: BoundExpr | null | undefined, partitionMap: PartitionMapLike): PrunedPartitionSet;
+    _prunePredicate(expr: BoundExpr | null | undefined, info: PartitionTableInfoLike): PrunedPartitionSet | null;
+    _pruneEquality(expr: BoundExpr, info: PartitionTableInfoLike): PrunedPartitionSet | null;
+    _pruneRange(expr: BoundExpr, info: PartitionTableInfoLike): PrunedPartitionSet | null;
+    _pruneBetween(expr: BoundExpr, info: PartitionTableInfoLike): PrunedPartitionSet | null;
+    _pruneInList(expr: BoundExpr, info: PartitionTableInfoLike): PrunedPartitionSet | null;
+    _extractPartitionColumn(expr: BoundExpr, info: PartitionTableInfoLike): PartitionKeyRef | null;
+    _isPartitionKey(colRef: {
+        columnName: string;
+    }, info: PartitionTableInfoLike): boolean;
+    _flipOp(op: string): string;
+    _intersect(setA: PrunedPartitionSet, setB: PrunedPartitionSet): PrunedPartitionSet;
+    _union(setA: PrunedPartitionSet, setB: PrunedPartitionSet): PrunedPartitionSet;
+    _allPartitions(count: number): PrunedPartitionSet;
+}
+export {};