@slexisvn/query-engine 0.1.0

package/dist/parser/lexer.d.ts

@@ -0,0 +1,135 @@
+export declare enum TokenType {
+    IDENT = "IDENT",
+    NUMBER = "NUMBER",
+    STRING = "STRING",
+    COMMA = "COMMA",
+    DOT = "DOT",
+    STAR = "STAR",
+    LPAREN = "LPAREN",
+    RPAREN = "RPAREN",
+    EQ = "EQ",
+    NEQ = "NEQ",
+    LT = "LT",
+    GT = "GT",
+    LTE = "LTE",
+    GTE = "GTE",
+    PLUS = "PLUS",
+    MINUS = "MINUS",
+    SLASH = "SLASH",
+    PERCENT = "PERCENT",
+    SEMICOLON = "SEMICOLON",
+    CONCAT = "CONCAT",
+    COLON = "COLON",
+    EOF = "EOF",
+    EXPLAIN = "EXPLAIN",
+    SELECT = "SELECT",
+    FROM = "FROM",
+    WHERE = "WHERE",
+    AND = "AND",
+    OR = "OR",
+    NOT = "NOT",
+    AS = "AS",
+    ON = "ON",
+    JOIN = "JOIN",
+    INNER = "INNER",
+    LEFT = "LEFT",
+    RIGHT = "RIGHT",
+    FULL = "FULL",
+    OUTER = "OUTER",
+    CROSS = "CROSS",
+    IN = "IN",
+    EXISTS = "EXISTS",
+    BETWEEN = "BETWEEN",
+    LIKE = "LIKE",
+    IS = "IS",
+    NULL = "NULL",
+    TRUE = "TRUE",
+    FALSE = "FALSE",
+    CASE = "CASE",
+    WHEN = "WHEN",
+    THEN = "THEN",
+    ELSE = "ELSE",
+    END = "END",
+    DISTINCT = "DISTINCT",
+    ALL = "ALL",
+    GROUP = "GROUP",
+    BY = "BY",
+    HAVING = "HAVING",
+    ORDER = "ORDER",
+    ASC = "ASC",
+    DESC = "DESC",
+    LIMIT = "LIMIT",
+    OFFSET = "OFFSET",
+    UNION = "UNION",
+    EXCEPT = "EXCEPT",
+    INTERSECT = "INTERSECT",
+    WITH = "WITH",
+    CAST = "CAST",
+    INTERVAL = "INTERVAL",
+    EXTRACT = "EXTRACT",
+    SUBSTRING = "SUBSTRING",
+    TRIM = "TRIM",
+    YEAR = "YEAR",
+    MONTH = "MONTH",
+    DAY = "DAY",
+    DATE = "DATE",
+    SUM = "SUM",
+    AVG = "AVG",
+    COUNT = "COUNT",
+    MIN = "MIN",
+    MAX = "MAX",
+    CREATE = "CREATE",
+    VIEW = "VIEW",
+    NULLS = "NULLS",
+    FIRST = "FIRST",
+    LAST = "LAST",
+    FETCH = "FETCH",
+    NEXT = "NEXT",
+    ROWS = "ROWS",
+    ONLY = "ONLY",
+    SOME = "SOME",
+    ANY = "ANY",
+    LEADING = "LEADING",
+    TRAILING = "TRAILING",
+    BOTH = "BOTH",
+    FOR = "FOR",
+    TIMESTAMP = "TIMESTAMP",
+    HOUR = "HOUR",
+    MINUTE = "MINUTE",
+    SECOND = "SECOND",
+    OVER = "OVER",
+    PARTITION = "PARTITION",
+    RANGE = "RANGE",
+    UNBOUNDED = "UNBOUNDED",
+    PRECEDING = "PRECEDING",
+    FOLLOWING = "FOLLOWING",
+    CURRENT = "CURRENT",
+    ROW = "ROW",
+    NATURAL = "NATURAL",
+    USING = "USING",
+    TABLE = "TABLE",
+    DROP = "DROP",
+    IF = "IF",
+    ANALYZE = "ANALYZE"
+}
+export declare class Token {
+    type: TokenType;
+    value: string;
+    position: number;
+    constructor(type: TokenType, value: string, position: number);
+}
+export declare class Lexer {
+    input: string;
+    pos: number;
+    tokens: Token[];
+    constructor(input: string);
+    _tokenize(): void;
+    _skipWhitespaceAndComments(): void;
+    _readString(start: number): Token;
+    _readNumber(start: number): Token;
+    _readIdentOrKeyword(start: number): Token;
+    _readSymbol(start: number): Token;
+    _isDigit(ch: string): boolean;
+    _isIdentStart(ch: string): boolean;
+    _isIdentPart(ch: string): boolean;
+}

package/dist/parser/parser.d.ts

@@ -0,0 +1,64 @@
+import { Token, TokenType } from './lexer.js';
+import * as AST from './ast.js';
+export declare class Parser {
+    tokens: Token[];
+    pos: number;
+    constructor(sql: string);
+    parse(): AST.Statement;
+    parseStatement(): AST.Statement;
+    parseCreateTable(): AST.CreateTableStmtNode;
+    parseDropTable(): AST.DropTableStmtNode;
+    parseQueryExpr(): AST.QueryStmt;
+    parseSelectStmt(): AST.QueryStmt;
+    parseWithClause(): AST.WithClauseNode;
+    parseCTE(): AST.CTENode;
+    parseSelectItems(): AST.SelectItemNode[];
+    parseOptionalAlias(guard?: () => boolean): string | null;
+    parseSelectItem(): AST.SelectItemNode;
+    parseFromClause(): AST.FromItem;
+    parseTableRef(): AST.FromItem;
+    parseSubqueryRef(): AST.SubqueryRefNode;
+    parseJoin(left: AST.FromItem): AST.JoinRefNode;
+    parseExpression(): AST.Expr;
+    parseOr(): AST.Expr;
+    parseAnd(): AST.Expr;
+    parseNot(): AST.Expr;
+    parseComparison(): AST.Expr;
+    parseBetween(left: AST.Expr, negated: boolean): AST.BetweenExprNode;
+    parseIn(left: AST.Expr, negated: boolean): AST.InExprNode;
+    parseLike(left: AST.Expr, negated: boolean): AST.LikeExprNode;
+    parseExists(): AST.ExistsExprNode;
+    parseAddition(): AST.Expr;
+    parseMultiplication(): AST.Expr;
+    parseUnary(): AST.Expr;
+    parsePrimary(): AST.Expr;
+    parseAggregateCall(): AST.AggregateCallNode | AST.WindowCallNode;
+    parseFunctionCallNamed(name: string): AST.FunctionCallNode | AST.WindowCallNode;
+    parseWindowCall(name: string, args: AST.Expr[]): AST.WindowCallNode;
+    parseCaseExpr(): AST.CaseExprNode;
+    parseCast(): AST.CastExprNode;
+    parseExtract(): AST.ExtractExprNode;
+    parseSubstringFn(): AST.SubstringExprNode;
+    parseTrim(): AST.FunctionCallNode;
+    parseInterval(): AST.IntervalExprNode;
+    parseTypeName(): AST.TypeNameNode;
+    parseExpressionList(): AST.Expr[];
+    parseOrderByList(): AST.OrderKeyNode[];
+    peek(): Token;
+    peekAhead(offset: number): Token | null;
+    advance(): Token;
+    isAt(type: TokenType): boolean;
+    tryConsume(type: TokenType): boolean;
+    expect(type: TokenType): Token;
+    expectIdent(): string;
+    isNonReservedKeyword(type: TokenType): boolean;
+    isAggregateKeyword(type: TokenType): boolean;
+    isJoinKeyword(): boolean;
+    isClauseKeyword(): boolean;
+    isSubqueryStart(): boolean;
+    isLookaheadSelect(): boolean;
+    isAtKeyword(keyword: string): boolean;
+    error(message: string): never;
+}
+export declare function parse(sql: string): AST.Statement;
+export declare function parseExpression(sql: string): AST.Expr;

package/dist/planner/logical-plan.d.ts

@@ -0,0 +1,250 @@
+import type { BoundExpr, BoundColumnRefNode } from '../binder/expression-binder.js';
+import type { ColumnInfo } from '../binder/scope.js';
+export type IndexScanValue = string | number | bigint | null;
+export type ProjectedExpr = BoundExpr & {
+    outputName?: string;
+};
+export declare enum PlanNodeType {
+    SCAN = "Scan",
+    FILTER = "Filter",
+    PROJECT = "Project",
+    JOIN = "Join",
+    AGGREGATE = "Aggregate",
+    SORT = "Sort",
+    LIMIT = "Limit",
+    DISTINCT = "Distinct",
+    UNION = "Union",
+    CTE_SCAN = "CTEScan",
+    CTE_ANCHOR = "CTEAnchor",
+    DEPENDENT_JOIN = "DependentJoin",
+    MATERIALIZE = "Materialize",
+    EMPTY = "Empty",
+    TOP_N = "TopN",
+    INDEX_SCAN = "IndexScan",
+    WINDOW = "Window",
+    EXCHANGE = "Exchange",
+    PARTIAL_AGGREGATE = "PartialAggregate",
+    FINAL_AGGREGATE = "FinalAggregate",
+    MERGE_EXCHANGE = "MergeExchange",
+    EXCHANGE_RECEIVE = "ExchangeReceive",
+    SINGLE_ROW = "SingleRow"
+}
+export declare enum JoinType {
+    INNER = "INNER",
+    LEFT = "LEFT",
+    RIGHT = "RIGHT",
+    FULL = "FULL",
+    SEMI = "SEMI",
+    ANTI = "ANTI",
+    MARK = "MARK",
+    SINGLE = "SINGLE",
+    CROSS = "CROSS"
+}
+export declare enum PhysicalStrategy {
+    HASH = "HASH",
+    MERGE = "MERGE",
+    NESTED_LOOP = "NESTED_LOOP",
+    STREAM = "STREAM",
+    UNGROUPED = "UNGROUPED",
+    PERFECT_HASH = "PERFECT_HASH"
+}
+export declare enum SortDirection {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+export declare enum NullOrder {
+    FIRST = "FIRST",
+    LAST = "LAST"
+}
+export interface LogicalOrderKey {
+    expr: BoundExpr;
+    direction?: string;
+    nullOrder?: string | null;
+}
+export type SortedByEntry = string | {
+    key: string;
+    direction?: string;
+};
+interface PlanNodeBase {
+    children?: LogicalPlanNode[];
+    _cardinality?: number;
+    _sortedBy?: SortedByEntry[];
+    _cteMap?: Map<string, LogicalPlanNode>;
+    _requiresSort?: {
+        left: boolean;
+        right: boolean;
+    };
+    _buildSide?: 'left' | 'right';
+    _dedupeBuild?: boolean;
+    _cost?: number;
+}
+export interface LogicalScanNode extends PlanNodeBase {
+    type: PlanNodeType.SCAN;
+    table: string;
+    columns: ColumnInfo[];
+    alias: string;
+}
+export interface LogicalFilterNode extends PlanNodeBase {
+    type: PlanNodeType.FILTER;
+    condition: BoundExpr | null;
+    children: LogicalPlanNode[];
+}
+export interface LogicalProjectNode extends PlanNodeBase {
+    type: PlanNodeType.PROJECT;
+    expressions: ProjectedExpr[];
+    children: LogicalPlanNode[];
+}
+export interface LogicalJoinNode extends PlanNodeBase {
+    type: PlanNodeType.JOIN;
+    joinType: JoinType;
+    condition: BoundExpr | null;
+    physicalStrategy: PhysicalStrategy;
+    children: LogicalPlanNode[];
+}
+export interface LogicalAggregateNode extends PlanNodeBase {
+    type: PlanNodeType.AGGREGATE;
+    groupBy: BoundExpr[];
+    aggregates: BoundExpr[];
+    physicalStrategy: PhysicalStrategy;
+    children: LogicalPlanNode[];
+}
+export interface LogicalSortNode extends PlanNodeBase {
+    type: PlanNodeType.SORT;
+    orderKeys: LogicalOrderKey[];
+    limit?: number;
+    offset?: number;
+    children: LogicalPlanNode[];
+}
+export interface LogicalLimitNode extends PlanNodeBase {
+    type: PlanNodeType.LIMIT;
+    count: number;
+    offset: number;
+    children: LogicalPlanNode[];
+}
+export interface LogicalDistinctNode extends PlanNodeBase {
+    type: PlanNodeType.DISTINCT;
+    children: LogicalPlanNode[];
+}
+export interface LogicalUnionNode extends PlanNodeBase {
+    type: PlanNodeType.UNION;
+    all: boolean;
+    children: LogicalPlanNode[];
+}
+export interface LogicalCTEScanNode extends PlanNodeBase {
+    type: PlanNodeType.CTE_SCAN;
+    cteName: string;
+    cteId: number;
+    children: LogicalPlanNode[];
+}
+export interface LogicalCTEAnchorNode extends PlanNodeBase {
+    type: PlanNodeType.CTE_ANCHOR;
+    cteName: string;
+    cteId: number;
+    children: LogicalPlanNode[];
+}
+export interface LogicalDependentJoinNode extends PlanNodeBase {
+    type: PlanNodeType.DEPENDENT_JOIN;
+    correlatedColumns: BoundColumnRefNode[];
+    subqueryType: string;
+    condition: BoundExpr | null;
+    children: LogicalPlanNode[];
+}
+export interface LogicalTopNNode extends PlanNodeBase {
+    type: PlanNodeType.TOP_N;
+    orderKeys: LogicalOrderKey[];
+    count: number;
+    offset: number;
+    children: LogicalPlanNode[];
+}
+export interface LogicalIndexScanNode extends PlanNodeBase {
+    type: PlanNodeType.INDEX_SCAN;
+    table: string;
+    alias: string;
+    indexName: string;
+    columnName: string;
+    scanType: string;
+    scanKey: IndexScanValue;
+    scanLow: IndexScanValue;
+    scanHigh: IndexScanValue;
+    lowInc: boolean;
+    highInc: boolean;
+    columns: ColumnInfo[];
+}
+export interface LogicalWindowNode extends PlanNodeBase {
+    type: PlanNodeType.WINDOW;
+    windowExprs: BoundExpr[];
+    children: LogicalPlanNode[];
+}
+export interface LogicalMaterializeNode extends PlanNodeBase {
+    type: PlanNodeType.MATERIALIZE;
+    children: LogicalPlanNode[];
+}
+export interface LogicalExchangeNode extends PlanNodeBase {
+    type: PlanNodeType.EXCHANGE;
+    exchangeType: string;
+    partitionKeys: BoundExpr[];
+    partitionCount: number;
+    children: LogicalPlanNode[];
+}
+export interface LogicalPartialAggregateNode extends PlanNodeBase {
+    type: PlanNodeType.PARTIAL_AGGREGATE;
+    groupBy: BoundExpr[];
+    aggregates: BoundExpr[];
+    physicalStrategy: PhysicalStrategy;
+    children: LogicalPlanNode[];
+}
+export interface LogicalFinalAggregateNode extends PlanNodeBase {
+    type: PlanNodeType.FINAL_AGGREGATE;
+    groupBy: BoundExpr[];
+    aggregates: BoundExpr[];
+    partialAggregates: BoundExpr[];
+    physicalStrategy: PhysicalStrategy;
+    children: LogicalPlanNode[];
+}
+export interface LogicalMergeExchangeNode extends PlanNodeBase {
+    type: PlanNodeType.MERGE_EXCHANGE;
+    orderKeys: LogicalOrderKey[];
+    limit: number | null;
+    children: LogicalPlanNode[];
+}
+export interface LogicalExchangeReceiveNode extends PlanNodeBase {
+    type: PlanNodeType.EXCHANGE_RECEIVE;
+    sourceFragmentIds: number[];
+    schema: ColumnInfo[];
+    children: LogicalPlanNode[];
+}
+export interface LogicalSingleRowNode extends PlanNodeBase {
+    type: PlanNodeType.SINGLE_ROW;
+    children: LogicalPlanNode[];
+}
+export interface LogicalEmptyNode extends PlanNodeBase {
+    type: PlanNodeType.EMPTY;
+    children?: LogicalPlanNode[];
+}
+export type LogicalPlanNode = LogicalScanNode | LogicalFilterNode | LogicalProjectNode | LogicalJoinNode | LogicalAggregateNode | LogicalSortNode | LogicalLimitNode | LogicalDistinctNode | LogicalUnionNode | LogicalCTEScanNode | LogicalCTEAnchorNode | LogicalDependentJoinNode | LogicalTopNNode | LogicalIndexScanNode | LogicalWindowNode | LogicalMaterializeNode | LogicalExchangeNode | LogicalPartialAggregateNode | LogicalFinalAggregateNode | LogicalMergeExchangeNode | LogicalExchangeReceiveNode | LogicalSingleRowNode | LogicalEmptyNode;
+export declare function LogicalScan(table: string, columns: ColumnInfo[], alias?: string): LogicalScanNode;
+export declare function LogicalFilter(condition: BoundExpr | null, child: LogicalPlanNode): LogicalFilterNode;
+export declare function LogicalProject(expressions: ProjectedExpr[], child: LogicalPlanNode): LogicalProjectNode;
+export declare function LogicalJoin(joinType: JoinType, condition: BoundExpr | null, left: LogicalPlanNode, right: LogicalPlanNode, physicalStrategy?: PhysicalStrategy): LogicalJoinNode;
+export declare function LogicalAggregate(groupBy: BoundExpr[], aggregates: BoundExpr[], child: LogicalPlanNode, physicalStrategy?: PhysicalStrategy): LogicalAggregateNode;
+export declare function LogicalSort(orderKeys: LogicalOrderKey[], child: LogicalPlanNode): LogicalSortNode;
+export declare function LogicalLimit(count: number, offset: number | null | undefined, child: LogicalPlanNode): LogicalLimitNode;
+export declare function LogicalDistinct(child: LogicalPlanNode): LogicalDistinctNode;
+export declare function LogicalUnion(left: LogicalPlanNode, right: LogicalPlanNode, all: boolean): LogicalUnionNode;
+export declare function LogicalCTEScan(cteName: string, cteId: number): LogicalCTEScanNode;
+export declare function LogicalCTEAnchor(cteName: string, cteId: number, producer: LogicalPlanNode, consumer: LogicalPlanNode): LogicalCTEAnchorNode;
+export declare function LogicalDependentJoin(child: LogicalPlanNode, subquery: LogicalPlanNode, correlatedColumns: BoundColumnRefNode[], subqueryType: string, condition: BoundExpr | null): LogicalDependentJoinNode;
+export declare function LogicalTopN(orderKeys: LogicalOrderKey[], count: number, offset: number | null | undefined, child: LogicalPlanNode): LogicalTopNNode;
+export declare function LogicalIndexScan(table: string, alias: string | undefined, indexName: string, columnName: string, scanType: string, scanKey: IndexScanValue, scanLow: IndexScanValue, scanHigh: IndexScanValue, lowInc: boolean, highInc: boolean, columns: ColumnInfo[]): LogicalIndexScanNode;
+export declare function LogicalWindow(windowExprs: BoundExpr[], child: LogicalPlanNode): LogicalWindowNode;
+export declare function LogicalMaterialize(child: LogicalPlanNode): LogicalMaterializeNode;
+export declare function LogicalExchange(exchangeType: string, partitionKeys: BoundExpr[] | null | undefined, partitionCount: number | null | undefined, child: LogicalPlanNode): LogicalExchangeNode;
+export declare function LogicalPartialAggregate(groupBy: BoundExpr[], aggregates: BoundExpr[], child: LogicalPlanNode): LogicalPartialAggregateNode;
+export declare function LogicalFinalAggregate(groupBy: BoundExpr[], aggregates: BoundExpr[], partialAggregates: BoundExpr[], child: LogicalPlanNode): LogicalFinalAggregateNode;
+export declare function LogicalMergeExchange(orderKeys: LogicalOrderKey[], limit: number | null | undefined, child: LogicalPlanNode): LogicalMergeExchangeNode;
+export declare function LogicalExchangeReceive(sourceFragmentIds: number[], schema?: ColumnInfo[]): LogicalExchangeReceiveNode;
+export declare function LogicalSingleRow(): LogicalSingleRowNode;
+export declare function getChildren(node: LogicalPlanNode): LogicalPlanNode[];
+export declare function setChildren<T extends LogicalPlanNode>(node: T, children: LogicalPlanNode[]): T;
+export declare function planToString(node: LogicalPlanNode, indent?: number): string;
+export {};

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

@@ -0,0 +1,23 @@
+import * as LP from './logical-plan.js';
+import { type BoundExpr, type BoundColumnRefNode } from '../binder/expression-binder.js';
+import type { BoundQuery, BoundSelect, BoundSetOp, BoundFrom } from '../binder/binder.js';
+export declare class LogicalPlanner {
+    cteMap: Map<string, LP.LogicalPlanNode>;
+    constructor();
+    plan(boundQuery: BoundQuery): LP.LogicalPlanNode;
+    planQuery(bound: BoundQuery): LP.LogicalPlanNode;
+    planSetOp(bound: BoundSetOp): LP.LogicalPlanNode;
+    planSelect(bound: BoundSelect): LP.LogicalPlanNode;
+    planFrom(bound: BoundFrom): LP.LogicalPlanNode;
+    extractSubqueries(expr: BoundExpr | null, currentPlan: LP.LogicalPlanNode): {
+        expr: BoundExpr | null;
+        subqueryJoins: Array<(child: LP.LogicalPlanNode) => LP.LogicalPlanNode>;
+    };
+    walkAndReplace(expr: BoundExpr | null, fn: (node: BoundExpr) => BoundExpr | null): BoundExpr | null;
+    _collectWindows(expr: BoundExpr | null, out: BoundExpr[]): void;
+    findCorrelatedRefs(boundQuery: BoundQuery): BoundColumnRefNode[];
+    _scanQuery(q: BoundQuery, refs: BoundColumnRefNode[]): void;
+    _scanFrom(f: BoundFrom, refs: BoundColumnRefNode[]): void;
+    _scanExpr(e: BoundExpr | null, refs: BoundColumnRefNode[]): void;
+}
+export declare function createLogicalPlan(boundQuery: BoundQuery): LP.LogicalPlanNode;

package/dist/planner/plan-formatter.d.ts

@@ -0,0 +1,4 @@
+import { type LogicalPlanNode } from './logical-plan.js';
+import { type BoundExpr } from '../binder/expression-binder.js';
+export declare function formatExpression(expr?: BoundExpr | null): string;
+export declare function formatPlan(plan: LogicalPlanNode, depth?: number): string;

package/dist/planner/plan-visitor.d.ts

@@ -0,0 +1,58 @@
+import * as LP from './logical-plan.js';
+import { type LogicalPlanNode } from './logical-plan.js';
+export declare class PlanVisitor {
+    visitScan?(node: LP.LogicalScanNode): void;
+    visitFilter?(node: LP.LogicalFilterNode): void;
+    visitProject?(node: LP.LogicalProjectNode): void;
+    visitJoin?(node: LP.LogicalJoinNode): void;
+    visitAggregate?(node: LP.LogicalAggregateNode): void;
+    visitSort?(node: LP.LogicalSortNode): void;
+    visitLimit?(node: LP.LogicalLimitNode): void;
+    visitDistinct?(node: LP.LogicalDistinctNode): void;
+    visitUnion?(node: LP.LogicalUnionNode): void;
+    visitCTEScan?(node: LP.LogicalCTEScanNode): void;
+    visitCTEAnchor?(node: LP.LogicalCTEAnchorNode): void;
+    visitDependentJoin?(node: LP.LogicalDependentJoinNode): void;
+    visitMaterialize?(node: LP.LogicalMaterializeNode): void;
+    visitEmpty?(node: LP.LogicalEmptyNode): void;
+    visitTopN?(node: LP.LogicalTopNNode): void;
+    visitIndexScan?(node: LP.LogicalIndexScanNode): void;
+    visitWindow?(node: LP.LogicalWindowNode): void;
+    visitExchange?(node: LP.LogicalExchangeNode): void;
+    visitPartialAggregate?(node: LP.LogicalPartialAggregateNode): void;
+    visitFinalAggregate?(node: LP.LogicalFinalAggregateNode): void;
+    visitMergeExchange?(node: LP.LogicalMergeExchangeNode): void;
+    visitExchangeReceive?(node: LP.LogicalExchangeReceiveNode): void;
+    visitSingleRow?(node: LP.LogicalSingleRowNode): void;
+    visit(node: LogicalPlanNode): void;
+    visitDefault(node: LogicalPlanNode): void;
+    visitChildren(node: LogicalPlanNode): void;
+}
+export declare class PlanRewriter {
+    rewriteScan?(node: LP.LogicalScanNode): LogicalPlanNode;
+    rewriteFilter?(node: LP.LogicalFilterNode): LogicalPlanNode;
+    rewriteProject?(node: LP.LogicalProjectNode): LogicalPlanNode;
+    rewriteJoin?(node: LP.LogicalJoinNode): LogicalPlanNode;
+    rewriteAggregate?(node: LP.LogicalAggregateNode): LogicalPlanNode;
+    rewriteSort?(node: LP.LogicalSortNode): LogicalPlanNode;
+    rewriteLimit?(node: LP.LogicalLimitNode): LogicalPlanNode;
+    rewriteDistinct?(node: LP.LogicalDistinctNode): LogicalPlanNode;
+    rewriteUnion?(node: LP.LogicalUnionNode): LogicalPlanNode;
+    rewriteCTEScan?(node: LP.LogicalCTEScanNode): LogicalPlanNode;
+    rewriteCTEAnchor?(node: LP.LogicalCTEAnchorNode): LogicalPlanNode;
+    rewriteDependentJoin?(node: LP.LogicalDependentJoinNode): LogicalPlanNode;
+    rewriteMaterialize?(node: LP.LogicalMaterializeNode): LogicalPlanNode;
+    rewriteEmpty?(node: LP.LogicalEmptyNode): LogicalPlanNode;
+    rewriteTopN?(node: LP.LogicalTopNNode): LogicalPlanNode;
+    rewriteIndexScan?(node: LP.LogicalIndexScanNode): LogicalPlanNode;
+    rewriteWindow?(node: LP.LogicalWindowNode): LogicalPlanNode;
+    rewriteExchange?(node: LP.LogicalExchangeNode): LogicalPlanNode;
+    rewritePartialAggregate?(node: LP.LogicalPartialAggregateNode): LogicalPlanNode;
+    rewriteFinalAggregate?(node: LP.LogicalFinalAggregateNode): LogicalPlanNode;
+    rewriteMergeExchange?(node: LP.LogicalMergeExchangeNode): LogicalPlanNode;
+    rewriteExchangeReceive?(node: LP.LogicalExchangeReceiveNode): LogicalPlanNode;
+    rewriteSingleRow?(node: LP.LogicalSingleRowNode): LogicalPlanNode;
+    rewrite(node: LogicalPlanNode): LogicalPlanNode;
+    rewriteDefault(node: LogicalPlanNode): LogicalPlanNode;
+    rewriteChildren<T extends LogicalPlanNode>(node: T): T;
+}

package/dist/runtime/platform.d.ts

@@ -0,0 +1,4 @@
+export declare function getEnvInt(key: string, fallback: number): number;
+export declare function getEnvFloat(key: string, fallback: number): number;
+export declare function getEnvFlag(key: string, fallback: boolean): boolean;
+export declare function getCpuCount(): number;

package/dist/storage/backend/memory-storage-backend.d.ts

@@ -0,0 +1,14 @@
+import { MemoryTempSpace } from '../temp-space/memory-temp-space.js';
+import { MemoryPageStore } from '../page-store/memory-page-store.js';
+import { SpillManager } from '../spill-manager/spill-manager.js';
+export interface StorageBackendOptions {
+    baseDir?: string;
+    tempDir?: string;
+}
+export declare class MemoryStorageBackend {
+    options: StorageBackendOptions;
+    constructor(options?: StorageBackendOptions);
+    createTempSpace(): MemoryTempSpace;
+    createPageStore(): MemoryPageStore;
+    createSpillManager(): SpillManager;
+}

package/dist/storage/backend/node-storage-backend.d.ts

@@ -0,0 +1,11 @@
+import { TempDirectoryManager } from '../temp-space/temp-directory-manager.js';
+import { FilePageStore } from '../page-store/file-page-store.js';
+import { SpillManager } from '../spill-manager/spill-manager.js';
+import type { StorageBackendOptions } from './memory-storage-backend.js';
+export declare class NodeStorageBackend {
+    options: StorageBackendOptions;
+    constructor(options?: StorageBackendOptions);
+    createTempSpace(): TempDirectoryManager;
+    createPageStore(handle: string): FilePageStore;
+    createSpillManager(handle: string): SpillManager;
+}

package/dist/storage/btree.d.ts

@@ -0,0 +1,34 @@
+import type { DataType } from './data-type.js';
+export type BTreeKey = string | number | bigint | boolean | null | undefined;
+export interface RowLocation {
+    pageId: string;
+    rowIndex: number;
+}
+interface SplitResult {
+    key: BTreeKey;
+    right: BTreeNode;
+}
+declare class BTreeNode {
+    isLeaf: boolean;
+    keys: BTreeKey[];
+    children: BTreeNode[];
+    values: RowLocation[][];
+    next: BTreeNode | null;
+    constructor(isLeaf: boolean);
+}
+export declare class BTreeIndex {
+    dataType: DataType;
+    root: BTreeNode;
+    order: number;
+    constructor(dataType: DataType);
+    _compare(a: BTreeKey, b: BTreeKey): number;
+    _findIndex(keys: BTreeKey[], key: BTreeKey): number;
+    insert(key: BTreeKey, rowLocation: RowLocation): void;
+    _insertInternal(node: BTreeNode, key: BTreeKey, rowLocation: RowLocation): SplitResult | null;
+    _findChildIndex(node: BTreeNode, key: BTreeKey): number;
+    _splitLeaf(leaf: BTreeNode): SplitResult;
+    _splitInternal(node: BTreeNode): SplitResult;
+    search(key: BTreeKey): RowLocation[];
+    range(low: BTreeKey, high: BTreeKey, lowInclusive: boolean, highInclusive: boolean): Generator<RowLocation>;
+}
+export {};

package/dist/storage/buffer-pool.d.ts

@@ -0,0 +1,17 @@
+import { LRUCache } from '../utils/lru-cache.js';
+import type { DataChunk } from './chunk.js';
+export interface PageStore {
+    write(pageId: string, chunk: DataChunk): Promise<void>;
+    read(pageId: string): Promise<DataChunk | null>;
+    clear(): void;
+}
+export declare class BufferPoolManager {
+    maxPages: number;
+    cache: LRUCache<string, DataChunk | null>;
+    pageStore: PageStore;
+    constructor(maxPages: number, pageStore: PageStore);
+    clear(): void;
+    writePage(pageId: string, chunk: DataChunk): Promise<void>;
+    readPage(pageId: string): Promise<DataChunk | null>;
+    fetchPage(pageId: string, bypassCache?: boolean): Promise<DataChunk | null>;
+}

package/dist/storage/chunk.d.ts

@@ -0,0 +1,26 @@
+import { Column } from './column.js';
+import { DictionaryColumn } from './dictionary-column.js';
+import { DataType, type ColumnValue } from './data-type.js';
+export type AnyColumn = Column | DictionaryColumn;
+export type SelectionVector = Uint32Array | Int32Array | number[];
+export declare class DataChunk {
+    columns: AnyColumn[];
+    size: number;
+    selectionVector: SelectionVector | null;
+    _cachedColumnCount: number;
+    constructor(columns: AnyColumn[], size?: number);
+    static fromSchema(schema: ReadonlyArray<{
+        dataType: DataType;
+    }>, capacity?: number): DataChunk;
+    getColumn(index: number): AnyColumn;
+    columnCount(): number;
+    getValue(rowIndex: number, colIndex: number): ColumnValue;
+    activeRowIndex(i: number): number;
+    setSelectionVector(sv: SelectionVector | null, count: number): void;
+    clearSelectionVector(): void;
+    appendRow(values: ColumnValue[]): void;
+    project(indices: number[]): DataChunk;
+    flatten(): DataChunk;
+    reset(): void;
+    toRows(): ColumnValue[][];
+}