@slexisvn/query-engine 0.1.0

package/dist/binder/binder.d.ts

@@ -0,0 +1,130 @@
+import type * as AST from '../parser/ast.js';
+import { BinderScope, type ColumnInfo } from './scope.js';
+import * as BE from './expression-binder.js';
+export interface TableMeta {
+    name: string;
+    columns: ColumnInfo[];
+}
+export interface CatalogLike {
+    getTable(name: string): TableMeta | undefined;
+}
+export interface OutputColumn {
+    name: string;
+    expr: BE.BoundExpr;
+    dataType: string | null;
+}
+export interface BoundSelectItem {
+    expr: BE.BoundExpr;
+    alias: string | null;
+    inferredName: string | null;
+}
+export interface BoundOrderKey {
+    expr: BE.BoundExpr;
+    direction: string;
+    nullOrder: string | null;
+}
+export interface BoundTableRef {
+    type: 'TableRef';
+    tableName: string;
+    alias: string;
+    columns: ColumnInfo[];
+}
+export interface BoundCTERef {
+    type: 'CTERef';
+    cteName: string;
+    alias: string;
+    columns: ColumnInfo[];
+    query: BoundQuery;
+}
+export interface BoundJoinRef {
+    type: 'JoinRef';
+    joinType: string;
+    left: BoundFrom;
+    right: BoundFrom;
+    condition: BE.BoundExpr | null;
+}
+export interface BoundSubqueryRef {
+    type: 'SubqueryRef';
+    alias: string;
+    query: BoundQuery;
+    columns: OutputColumn[];
+}
+export type BoundFrom = BoundTableRef | BoundCTERef | BoundJoinRef | BoundSubqueryRef;
+export interface BoundSelect {
+    type: 'BoundSelect';
+    plan: BoundFrom | null;
+    selectItems: BoundSelectItem[];
+    where: BE.BoundExpr | null;
+    groupBy: BE.BoundExpr[] | null;
+    aggregates: BE.BoundExpr[];
+    having: BE.BoundExpr | null;
+    orderBy: BoundOrderKey[] | null;
+    limit: BE.BoundExpr | null;
+    offset: BE.BoundExpr | null;
+    distinct: boolean;
+    outputColumns: OutputColumn[];
+}
+export interface BoundSetOp {
+    type: 'SetOp';
+    op: string;
+    all: boolean;
+    left: BoundQuery;
+    right: BoundQuery;
+    outputColumns: OutputColumn[];
+}
+export type BoundQuery = BoundSelect | BoundSetOp;
+interface CteInfo {
+    name: string;
+    columns: ColumnInfo[];
+    bound: BoundQuery;
+}
+interface JoinSide {
+    type?: string;
+    columns?: ColumnInfo[];
+    alias?: string;
+    tableName?: string;
+    cteName?: string;
+}
+export declare class Binder {
+    catalog: CatalogLike;
+    functionRegistry: object;
+    cteScopes: Map<string, CteInfo>;
+    aggregatesFound: BE.BoundExpr[];
+    constructor(catalog: CatalogLike, functionRegistry: object);
+    bind(ast: AST.QueryStmt): BoundQuery;
+    bindQuery(node: AST.QueryStmt, scope: BinderScope): BoundQuery;
+    bindSetOp(node: AST.SetOpNode, scope: BinderScope): BoundSetOp;
+    bindSelect(node: AST.SelectStmtNode, scope: BinderScope): BoundSelect;
+    bindKeyWithAlias(expr: AST.Expr, scope: BinderScope, selectAliasMap: Map<string, BE.BoundExpr>): BE.BoundExpr;
+    bindWithClause(withClause: AST.WithClauseNode, scope: BinderScope): void;
+    bindFrom(node: AST.FromItem, scope: BinderScope): BoundFrom;
+    bindTableRef(node: AST.TableRefNode, scope: BinderScope): BoundTableRef | BoundCTERef;
+    bindJoinRef(node: AST.JoinRefNode, scope: BinderScope): BoundJoinRef;
+    buildNaturalJoinCondition(left: BoundFrom, right: BoundFrom, scope: BinderScope): BE.BoundExpr | null;
+    buildUsingCondition(columnNames: string[], left: BoundFrom, right: BoundFrom, scope: BinderScope): BE.BoundExpr | null;
+    getRefColumnNames(ref: JoinSide): string[];
+    getRefAlias(ref: JoinSide): string | null;
+    bindSubqueryRef(node: AST.SubqueryRefNode, scope: BinderScope): BoundSubqueryRef;
+    bindSelectItems(items: AST.SelectItemNode[], scope: BinderScope): BoundSelectItem[];
+    expandStar(node: AST.AllColumnsNode, scope: BinderScope): BoundSelectItem[];
+    bindExpression(node: AST.Expr | AST.QuantifiedSubqueryNode, scope: BinderScope): BE.BoundExpr;
+    bindWindowCall(node: AST.WindowCallNode, scope: BinderScope): BE.BoundWindowNode;
+    bindColumnRef(node: AST.ColumnRefNode, scope: BinderScope): BE.BoundColumnRefNode;
+    bindLiteral(node: AST.LiteralNode): BE.BoundLiteralNode;
+    bindBinaryExpr(node: AST.BinaryExprNode, scope: BinderScope): BE.BoundBinaryNode;
+    bindUnaryExpr(node: AST.UnaryExprNode, scope: BinderScope): BE.BoundUnaryNode;
+    bindAggregateCall(node: AST.AggregateCallNode, scope: BinderScope): BE.BoundAggregateNode;
+    bindFunctionCall(node: AST.FunctionCallNode, scope: BinderScope): BE.BoundFunctionNode;
+    bindCaseExpr(node: AST.CaseExprNode, scope: BinderScope): BE.BoundCaseNode;
+    bindCastExpr(node: AST.CastExprNode, scope: BinderScope): BE.BoundCastNode;
+    bindInExpr(node: AST.InExprNode, scope: BinderScope): BE.BoundInListNode;
+    bindExistsExpr(node: AST.ExistsExprNode, scope: BinderScope): BE.BoundExistsNode;
+    bindSubqueryExpr(node: AST.SubqueryExprNode, scope: BinderScope): BE.BoundSubqueryNode;
+    inferColumnName(node: AST.Expr): string | null;
+    inferArithmeticType(left: string | null, right: string | null): string;
+    inferAggregateType(name: string, args: BE.BoundExpr[]): string;
+    inferFunctionType(name: string, args: BE.BoundExpr[]): string | null;
+    inferWindowType(name: string, args: BE.BoundExpr[]): string | null;
+    resolveTypeName(typeName: AST.TypeNameNode): string;
+}
+export {};

package/dist/binder/expression-binder.d.ts

@@ -0,0 +1,168 @@
+import type { BoundQuery } from './binder.js';
+export type LiteralValue = string | number | boolean | bigint | null;
+export declare enum BoundExprKind {
+    COLUMN_REF = "BoundColumnRef",
+    LITERAL = "BoundLiteral",
+    BINARY = "BoundBinary",
+    UNARY = "BoundUnary",
+    FUNCTION = "BoundFunction",
+    AGGREGATE = "BoundAggregate",
+    CASE = "BoundCase",
+    CAST = "BoundCast",
+    BETWEEN = "BoundBetween",
+    IN_LIST = "BoundInList",
+    LIKE = "BoundLike",
+    IS_NULL = "BoundIsNull",
+    SUBQUERY = "BoundSubquery",
+    EXISTS = "BoundExists",
+    EXTRACT = "BoundExtract",
+    INTERVAL = "BoundInterval",
+    COMPARISON = "BoundComparison",
+    WINDOW = "BoundWindow"
+}
+export type BoundExpr = BoundColumnRefNode | BoundLiteralNode | BoundBinaryNode | BoundUnaryNode | BoundFunctionNode | BoundAggregateNode | BoundCaseNode | BoundCastNode | BoundBetweenNode | BoundInListNode | BoundLikeNode | BoundIsNullNode | BoundSubqueryNode | BoundExistsNode | BoundExtractNode | BoundIntervalNode | BoundWindowNode;
+export interface BoundWhenClause {
+    condition: BoundExpr;
+    result: BoundExpr;
+}
+export interface BoundWindowOrderKey {
+    expr: BoundExpr;
+    direction?: string;
+    nullOrder?: string | null;
+}
+export interface BoundColumnRefNode {
+    kind: BoundExprKind.COLUMN_REF;
+    tableAlias: string;
+    columnName: string;
+    columnIndex: number;
+    dataType: string | null;
+    depth: number;
+    isCorrelated: boolean;
+}
+export interface BoundLiteralNode {
+    kind: BoundExprKind.LITERAL;
+    value: LiteralValue;
+    dataType: string | null;
+}
+export interface BoundBinaryNode {
+    kind: BoundExprKind.BINARY;
+    op: string;
+    left: BoundExpr;
+    right: BoundExpr;
+    resultType: string;
+}
+export interface BoundUnaryNode {
+    kind: BoundExprKind.UNARY;
+    op: string;
+    operand: BoundExpr;
+    resultType: string | null;
+}
+export interface BoundFunctionNode {
+    kind: BoundExprKind.FUNCTION;
+    name: string;
+    args: BoundExpr[];
+    resultType: string | null;
+}
+export interface BoundAggregateNode {
+    kind: BoundExprKind.AGGREGATE;
+    name: string;
+    args: BoundExpr[];
+    distinct: boolean;
+    resultType: string;
+}
+export interface BoundCaseNode {
+    kind: BoundExprKind.CASE;
+    operand: BoundExpr | null;
+    whenClauses: BoundWhenClause[];
+    elseExpr: BoundExpr | null;
+    resultType: string;
+}
+export interface BoundCastNode {
+    kind: BoundExprKind.CAST;
+    expr: BoundExpr;
+    targetType: string;
+    dataType: string;
+}
+export interface BoundBetweenNode {
+    kind: BoundExprKind.BETWEEN;
+    expr: BoundExpr;
+    low: BoundExpr;
+    high: BoundExpr;
+    negated: boolean;
+    resultType: string;
+}
+export interface BoundInListNode {
+    kind: BoundExprKind.IN_LIST;
+    expr: BoundExpr;
+    list: BoundExpr | BoundExpr[];
+    negated: boolean;
+    resultType: string;
+}
+export interface BoundLikeNode {
+    kind: BoundExprKind.LIKE;
+    expr: BoundExpr;
+    pattern: BoundExpr;
+    negated: boolean;
+    resultType: string;
+}
+export interface BoundIsNullNode {
+    kind: BoundExprKind.IS_NULL;
+    expr: BoundExpr;
+    negated: boolean;
+    resultType: string;
+}
+export interface BoundSubqueryNode {
+    kind: BoundExprKind.SUBQUERY;
+    plan: BoundQuery;
+    subqueryType: string;
+}
+export interface BoundExistsNode {
+    kind: BoundExprKind.EXISTS;
+    plan: BoundQuery;
+    negated: boolean;
+    resultType: string;
+}
+export interface BoundExtractNode {
+    kind: BoundExprKind.EXTRACT;
+    field: string;
+    source: BoundExpr;
+    resultType: string;
+}
+export interface BoundIntervalNode {
+    kind: BoundExprKind.INTERVAL;
+    value: number;
+    unit: string;
+    resultType: string;
+}
+export interface BoundWindowNode {
+    kind: BoundExprKind.WINDOW;
+    name: string;
+    args: BoundExpr[];
+    partitionBy: BoundExpr[];
+    orderBy: BoundWindowOrderKey[];
+    resultType: string | null;
+}
+export declare function BoundColumnRef(tableAlias: string, columnName: string, columnIndex: number, dataType: string | null, depth?: number): BoundColumnRefNode;
+export declare function BoundLiteral(value: LiteralValue, dataType: string | null): BoundLiteralNode;
+export declare function BoundBinary(op: string, left: BoundExpr, right: BoundExpr, resultType: string): BoundBinaryNode;
+export declare function BoundUnary(op: string, operand: BoundExpr, resultType: string | null): BoundUnaryNode;
+export declare function BoundFunction(name: string, args: BoundExpr[], resultType: string | null): BoundFunctionNode;
+export declare function BoundAggregate(name: string, args: BoundExpr[], distinct: boolean, resultType: string): BoundAggregateNode;
+export declare function BoundCase(operand: BoundExpr | null, whenClauses: BoundWhenClause[], elseExpr: BoundExpr | null, resultType: string): BoundCaseNode;
+export declare function BoundCast(expr: BoundExpr, targetType: string): BoundCastNode;
+export declare function BoundBetween(expr: BoundExpr, low: BoundExpr, high: BoundExpr, negated: boolean): BoundBetweenNode;
+export declare function BoundInList(expr: BoundExpr, list: BoundExpr | BoundExpr[], negated: boolean): BoundInListNode;
+export declare function BoundLike(expr: BoundExpr, pattern: BoundExpr, negated: boolean): BoundLikeNode;
+export declare function BoundIsNull(expr: BoundExpr, negated: boolean): BoundIsNullNode;
+export declare function BoundSubquery(plan: BoundQuery, subqueryType: string): BoundSubqueryNode;
+export declare function BoundExists(plan: BoundQuery, negated: boolean): BoundExistsNode;
+export declare function BoundExtract(field: string, source: BoundExpr): BoundExtractNode;
+export declare function BoundInterval(value: number, unit: string): BoundIntervalNode;
+export declare function BoundWindow(name: string, args: BoundExpr[], partitionBy: BoundExpr[], orderBy: BoundWindowOrderKey[], resultType: string | null): BoundWindowNode;
+export declare function getExprType(expr?: {
+    kind?: BoundExprKind;
+    resultType?: string | null;
+    dataType?: string | null;
+} | null): string | null;
+export declare function collectCorrelatedColumns(expr: BoundExpr): BoundColumnRefNode[];
+export declare function walkExpr(expr: BoundExpr | null | undefined, fn: (node: BoundExpr) => void): void;

package/dist/binder/scope.d.ts

@@ -0,0 +1,40 @@
+export interface ColumnInfo {
+    name: string;
+    dataType: string | null;
+}
+export interface TableInfo {
+    originalName: string;
+    columns: ColumnInfo[];
+    isCTE?: boolean;
+}
+export interface ResolvedTable {
+    table: TableInfo;
+    depth: number;
+}
+export interface ResolvedColumn {
+    tableAlias: string;
+    tableName: string;
+    column: ColumnInfo;
+    columnIndex: number;
+    depth: number;
+}
+export interface ColumnEntry {
+    tableAlias: string;
+    tableName: string;
+    column: ColumnInfo;
+    columnIndex: number;
+}
+export declare class BinderScope {
+    parent: BinderScope | null;
+    tables: Map<string, TableInfo>;
+    columns: Map<string, ColumnInfo[]>;
+    correlatedRefs: never[];
+    constructor(parent?: BinderScope | null);
+    addTable(alias: string, tableInfo: TableInfo): void;
+    addColumn(alias: string, columnInfo: ColumnInfo): void;
+    resolveTable(name: string): ResolvedTable | null;
+    resolveColumn(name: string, tableAlias?: string | null): ResolvedColumn | null;
+    getAllColumns(): ColumnEntry[];
+    getTableColumns(tableAlias: string): ColumnEntry[] | null;
+    child(): BinderScope;
+}

package/dist/browser.d.ts

@@ -0,0 +1,8 @@
+import { QueryEngine } from './engine/query-engine.js';
+import { setWasmBaseUrl } from './wasm/fetch-byte-source.js';
+import { Catalog } from './catalog/catalog.js';
+import { DataType } from './storage/data-type.js';
+import { InMemoryRelation, RelationBuilder } from './dataframe/in-memory-relation.js';
+export { QueryEngine, Catalog, DataType, InMemoryRelation, RelationBuilder, setWasmBaseUrl };
+export { DataFrame, GroupedData, Col, col, lit, expr, sum, avg, min, max, count, countStar, } from './dataframe/index.js';
+export { createEngine, registerTable, registerStreamingTable } from './engine-entry.js';

package/dist/catalog/catalog.d.ts

@@ -0,0 +1,53 @@
+import type { ColumnSchema } from '../storage/data-type.js';
+import type { Table } from '../storage/table.js';
+import type { BTreeIndex } from '../storage/btree.js';
+export interface ForeignKeySchema {
+    columns: string[];
+    refTable: string;
+    refColumns: string[];
+}
+export interface CatalogTableOptions {
+    primaryKey?: string[];
+    foreignKeys?: ForeignKeySchema[];
+}
+export interface CatalogTable {
+    name: string;
+    columns: ColumnSchema[];
+    primaryKey: string[];
+    foreignKeys: ForeignKeySchema[];
+}
+export interface IndexEntry {
+    tableName: string;
+    columnName: string;
+    btree: BTreeIndex;
+}
+export interface PartitionStrategyLike {
+    name?: string;
+}
+export type PartitionKeyLike = string | string[] | Map<string, number>;
+export interface PartitionInfo {
+    strategy: PartitionStrategyLike;
+    partitionCount: number;
+    partitionKey: PartitionKeyLike;
+}
+export declare class Catalog {
+    tables: Map<string, CatalogTable>;
+    tableStorage: Map<string, Table>;
+    indexes: Map<string, IndexEntry>;
+    partitionInfo: Map<string, PartitionInfo>;
+    constructor();
+    registerTable(name: string, schema: ColumnSchema[], options?: CatalogTableOptions): void;
+    registerTableStorage(name: string, storage: Table): void;
+    getTable(name: string): CatalogTable | null;
+    getTableStorage(name: string): Table | null;
+    getColumn(tableName: string, columnName: string): ColumnSchema | null;
+    getColumnIndex(tableName: string, columnName: string): number;
+    dropTable(name: string): void;
+    hasTable(name: string): boolean;
+    listTables(): string[];
+    registerIndex(tableName: string, columnName: string, btree: BTreeIndex): void;
+    getIndexForColumn(tableName: string, columnName: string): BTreeIndex | null;
+    getIndexesForTable(tableName: string): IndexEntry[];
+    registerPartitionInfo(tableName: string, strategy: PartitionStrategyLike, partitionCount: number, partitionKey: PartitionKeyLike): void;
+    getPartitionInfo(tableName: string): PartitionInfo | null;
+}

package/dist/catalog/function-registry.d.ts

@@ -0,0 +1,26 @@
+import type { ColumnValue, DataType } from '../storage/data-type.js';
+export declare enum FunctionType {
+    SCALAR = "SCALAR",
+    AGGREGATE = "AGGREGATE"
+}
+export type FunctionImpl = (args: ColumnValue[]) => ColumnValue;
+export interface FunctionDef {
+    name: string;
+    type: FunctionType;
+    minArgs: number;
+    maxArgs: number;
+    argTypes?: DataType[];
+    returnType?: DataType;
+    impl?: FunctionImpl;
+}
+export declare class FunctionRegistry {
+    functions: Map<string, FunctionDef>;
+    constructor();
+    register(name: string, definition: FunctionDef): void;
+    lookup(name: string): FunctionDef | null;
+    has(name: string): boolean;
+    isAggregate(name: string): boolean;
+    isScalar(name: string): boolean;
+    _registerBuiltins(): void;
+}
+export declare const defaultFunctionRegistry: FunctionRegistry;

package/dist/catalog/statistics-cache.d.ts

@@ -0,0 +1,39 @@
+import type { TableStatistics } from './statistics.js';
+import type { ColumnSchema, ColumnValue } from '../storage/data-type.js';
+interface TableStorageLike {
+    rowCount(): number;
+    getSchema(): ColumnSchema[];
+    getColumnIndex(name: string): number;
+    scan(): AsyncIterable<{
+        size: number;
+        getValue(row: number, col: number): ColumnValue;
+    }>;
+}
+interface CatalogLike {
+    getTableStorage(name: string): TableStorageLike | null;
+    listTables(): string[];
+}
+interface CacheEntry {
+    stats: TableStatistics;
+    version: number;
+}
+export declare class StatisticsCache {
+    catalog: CatalogLike;
+    cache: Map<string, CacheEntry>;
+    versions: Map<string, number>;
+    constructor(catalog: CatalogLike);
+    get(tableName: string): TableStatistics | undefined;
+    has(tableName: string): boolean;
+    set(tableName: string, stats: TableStatistics): void;
+    ensure(tableName: string): Promise<TableStatistics | undefined>;
+    ensureAll(): Promise<void>;
+    invalidate(tableName: string): void;
+    invalidateAll(): void;
+    getVersion(key: string): number;
+    get size(): number;
+    values(): Generator<TableStatistics>;
+    entries(): Generator<[string, TableStatistics]>;
+    [Symbol.iterator](): Generator<[string, TableStatistics]>;
+    toMap(): Map<string, TableStatistics>;
+}
+export {};

package/dist/catalog/statistics.d.ts

@@ -0,0 +1,72 @@
+import { type ColumnValue, type ColumnSchema } from '../storage/data-type.js';
+export interface Mcv {
+    values: (string | number)[];
+    frequencies: number[];
+}
+export interface ColumnStatisticsInit {
+    ndv?: number;
+    min?: ColumnValue;
+    max?: ColumnValue;
+    nullFraction?: number;
+    histogram?: EquiDepthHistogram | null;
+    mcv?: Mcv | null;
+    avgWidth?: number;
+    avgLength?: number | null;
+}
+export interface HistogramBucketInfo {
+    boundaries: ColumnValue[];
+    bucketCounts: number[] | null;
+    bucketDistincts: number[] | null;
+}
+export declare class ColumnStatistics {
+    ndv: number;
+    min: ColumnValue;
+    max: ColumnValue;
+    nullFraction: number;
+    histogram: EquiDepthHistogram | null;
+    mcv: Mcv | null;
+    avgWidth: number;
+    avgLength: number | null;
+    constructor({ ndv, min, max, nullFraction, histogram, mcv, avgWidth, avgLength }?: ColumnStatisticsInit);
+}
+export declare class TableStatistics {
+    rowCount: number;
+    columnStats: Map<string, ColumnStatistics>;
+    correlations: Map<string, number>;
+    constructor(rowCount: number, columnStats?: Map<string, ColumnStatistics>, correlations?: Map<string, number>);
+    getColumnStats(columnName: string): ColumnStatistics | null;
+    setColumnStats(columnName: string, stats: ColumnStatistics): void;
+    _correlationKey(colA: string, colB: string): string;
+    getCorrelation(colA: string, colB: string): number | null;
+    setCorrelation(colA: string, colB: string, value: number): void;
+    get avgRowWidth(): number;
+}
+export declare class EquiDepthHistogram {
+    boundaries: ColumnValue[];
+    numBuckets: number;
+    numRows: number;
+    rowsPerBucket: number;
+    bucketCounts: number[] | null;
+    bucketDistincts: number[] | null;
+    totalCount: number | null;
+    constructor(boundaries: ColumnValue[], numRows: number, bucketCounts?: number[] | null, bucketDistincts?: number[] | null);
+    bucketInfo(): HistogramBucketInfo;
+    estimateLessThan(value: ColumnValue): number;
+    estimateRange(low: ColumnValue, high: ColumnValue): number;
+}
+export interface TableStatsSource {
+    rowCount(): number;
+    getSchema(): ColumnSchema[];
+    getColumnIndex(name: string): number;
+    scan(): AsyncIterable<{
+        size: number;
+        getValue(row: number, col: number): ColumnValue;
+    }>;
+}
+export declare class StatisticsCollector {
+    static collect(table: TableStatsSource): Promise<TableStatistics>;
+    static _collectColumn(table: TableStatsSource, colDef: ColumnSchema, totalRows: number): Promise<ColumnStatistics>;
+    static _buildHistogram(values: ColumnValue[], totalRows: number): EquiDepthHistogram;
+    static _buildMCV(valueCounts: Map<string, number>, nonNullCount: number): Mcv | null;
+    static _computeCorrelations: (table: TableStatsSource, columnStats: Map<string, ColumnStatistics>) => Promise<Map<string, number>>;
+}

package/dist/catalog/tpch-schema.d.ts

@@ -0,0 +1,15 @@
+import type { ColumnSchema } from '../storage/data-type.js';
+import { Catalog } from './catalog.js';
+interface ForeignKeySchema {
+    columns: string[];
+    refTable: string;
+    refColumns: string[];
+}
+interface TableSchema {
+    columns: ColumnSchema[];
+    primaryKey: string[];
+    foreignKeys?: ForeignKeySchema[];
+}
+export declare const TPCH_TABLES: Record<string, TableSchema>;
+export declare function createTPCHCatalog(): Catalog;
+export {};

package/dist/cli/cli-common.d.ts

@@ -0,0 +1,11 @@
+import type { Catalog, QueryEngine } from '../index.js';
+interface LoadDataFilesOptions {
+    loadOptions?: object;
+    formatLoadLine?: (context: {
+        tableName: string;
+        rowCount: number;
+        dataPath: string;
+    }) => string;
+}
+export declare function loadDataFiles(engine: QueryEngine, catalog: Catalog, dataPaths: string[], options?: LoadDataFilesOptions): Promise<void>;
+export {};

package/dist/cli/coordinator.d.ts

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

package/dist/cli/format.d.ts

@@ -0,0 +1,8 @@
+import type { ColumnValue } from '../index.js';
+interface ResultLike {
+    rows: Record<string, ColumnValue>[];
+    columns?: string[];
+    message?: string;
+}
+export declare function formatResult(result?: ResultLike): void;
+export {};

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export declare function start(): Promise<void>;

package/dist/cli/loaders/csv-loader.d.ts

@@ -0,0 +1,17 @@
+import type { ColumnSchema, ColumnValue, QueryEngine } from '../../index.js';
+import { DataLoader } from './data-loader.js';
+interface CSVLoadOptions {
+    partitionIndex?: number | null;
+    partitionCount?: number | null;
+    maxRows?: number | null;
+}
+type CSVRow = Record<string, string>;
+export declare class CSVLoader extends DataLoader {
+    allowedDir: string | null;
+    constructor(allowedDir?: string | null);
+    validatePath(filePath: string): string;
+    load(engine: QueryEngine, filePath: string, options?: CSVLoadOptions): Promise<string>;
+    inferSchema(firstRow: CSVRow): ColumnSchema[];
+    convertRow(rowObj: CSVRow, schema: ColumnSchema[]): ColumnValue[];
+}
+export {};

package/dist/cli/loaders/data-loader.d.ts

@@ -0,0 +1,7 @@
+import { DataType } from '../../index.js';
+import type { ColumnSchema, QueryEngine, Table } from '../../index.js';
+export declare class DataLoader {
+    load(engine: QueryEngine, filePath: string): Promise<string>;
+    registerToCatalog(engine: QueryEngine, tableName: string, schema: ColumnSchema[], table: Table): void;
+    buildSchema<T>(firstRow: Record<string, T>, classify: (value: T) => DataType): ColumnSchema[];
+}

package/dist/cli/loaders/json-loader.d.ts

@@ -0,0 +1,13 @@
+import type { ColumnSchema, QueryEngine } from '../../index.js';
+import { DataLoader } from './data-loader.js';
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+export declare class JSONLoader extends DataLoader {
+    load(engine: QueryEngine, filePath: string): Promise<string>;
+    inferSchema(firstRow: JsonObject): ColumnSchema[];
+}
+export {};

package/dist/cli/loaders/loader-factory.d.ts

@@ -0,0 +1,4 @@
+import type { DataLoader } from './data-loader.js';
+export declare class LoaderFactory {
+    static getLoader(filePath: string): DataLoader;
+}

package/dist/cli/repl.d.ts

@@ -0,0 +1,6 @@
+import type { QueryCoordinator, QueryEngine } from '../index.js';
+interface ReplOptions {
+    coordinator?: QueryCoordinator | null;
+}
+export declare function startREPL(engine: QueryEngine, options?: ReplOptions): void;
+export {};

package/dist/cli/worker.d.ts

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