@slexisvn/query-engine 0.1.0

package/dist/index.cli.js

@@ -0,0 +1,1002 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/planner/logical-plan.ts
+var logical_plan_exports = {};
+__export(logical_plan_exports, {
+  JoinType: () => JoinType,
+  LogicalAggregate: () => LogicalAggregate,
+  LogicalCTEAnchor: () => LogicalCTEAnchor,
+  LogicalCTEScan: () => LogicalCTEScan,
+  LogicalDependentJoin: () => LogicalDependentJoin,
+  LogicalDistinct: () => LogicalDistinct,
+  LogicalExchange: () => LogicalExchange,
+  LogicalExchangeReceive: () => LogicalExchangeReceive,
+  LogicalFilter: () => LogicalFilter,
+  LogicalFinalAggregate: () => LogicalFinalAggregate,
+  LogicalIndexScan: () => LogicalIndexScan,
+  LogicalJoin: () => LogicalJoin,
+  LogicalLimit: () => LogicalLimit,
+  LogicalMaterialize: () => LogicalMaterialize,
+  LogicalMergeExchange: () => LogicalMergeExchange,
+  LogicalPartialAggregate: () => LogicalPartialAggregate,
+  LogicalProject: () => LogicalProject,
+  LogicalScan: () => LogicalScan,
+  LogicalSingleRow: () => LogicalSingleRow,
+  LogicalSort: () => LogicalSort,
+  LogicalTopN: () => LogicalTopN,
+  LogicalUnion: () => LogicalUnion,
+  LogicalWindow: () => LogicalWindow,
+  NullOrder: () => NullOrder,
+  PhysicalStrategy: () => PhysicalStrategy,
+  PlanNodeType: () => PlanNodeType,
+  SortDirection: () => SortDirection,
+  getChildren: () => getChildren,
+  planToString: () => planToString,
+  setChildren: () => setChildren
+});
+function LogicalScan(table, columns, alias) {
+  return { type: "Scan" /* SCAN */, table, columns, alias: alias || table };
+}
+function LogicalFilter(condition, child) {
+  return { type: "Filter" /* FILTER */, condition, children: [child] };
+}
+function LogicalProject(expressions, child) {
+  return { type: "Project" /* PROJECT */, expressions, children: [child] };
+}
+function LogicalJoin(joinType, condition, left, right, physicalStrategy = "HASH" /* HASH */) {
+  return {
+    type: "Join" /* JOIN */,
+    joinType,
+    condition,
+    children: [left, right],
+    physicalStrategy
+  };
+}
+function LogicalAggregate(groupBy, aggregates, child, physicalStrategy = "HASH" /* HASH */) {
+  return {
+    type: "Aggregate" /* AGGREGATE */,
+    groupBy,
+    aggregates,
+    children: [child],
+    physicalStrategy
+  };
+}
+function LogicalSort(orderKeys, child) {
+  return { type: "Sort" /* SORT */, orderKeys, children: [child] };
+}
+function LogicalLimit(count, offset, child) {
+  return { type: "Limit" /* LIMIT */, count, offset: offset || 0, children: [child] };
+}
+function LogicalDistinct(child) {
+  return { type: "Distinct" /* DISTINCT */, children: [child] };
+}
+function LogicalUnion(left, right, all) {
+  return { type: "Union" /* UNION */, all: !!all, children: [left, right] };
+}
+function LogicalCTEScan(cteName, cteId) {
+  return { type: "CTEScan" /* CTE_SCAN */, cteName, cteId, children: [] };
+}
+function LogicalCTEAnchor(cteName, cteId, producer, consumer) {
+  return { type: "CTEAnchor" /* CTE_ANCHOR */, cteName, cteId, children: [producer, consumer] };
+}
+function LogicalDependentJoin(child, subquery, correlatedColumns, subqueryType, condition) {
+  return {
+    type: "DependentJoin" /* DEPENDENT_JOIN */,
+    correlatedColumns,
+    subqueryType,
+    condition,
+    children: [child, subquery]
+  };
+}
+function LogicalTopN(orderKeys, count, offset, child) {
+  return { type: "TopN" /* TOP_N */, orderKeys, count, offset: offset || 0, children: [child] };
+}
+function LogicalIndexScan(table, alias, indexName, columnName, scanType, scanKey, scanLow, scanHigh, lowInc, highInc, columns) {
+  return {
+    type: "IndexScan" /* INDEX_SCAN */,
+    table,
+    alias: alias || table,
+    indexName,
+    columnName,
+    scanType,
+    scanKey,
+    scanLow,
+    scanHigh,
+    lowInc,
+    highInc,
+    columns
+  };
+}
+function LogicalWindow(windowExprs, child) {
+  return { type: "Window" /* WINDOW */, windowExprs, children: [child] };
+}
+function LogicalMaterialize(child) {
+  return { type: "Materialize" /* MATERIALIZE */, children: [child] };
+}
+function LogicalExchange(exchangeType, partitionKeys, partitionCount, child) {
+  return {
+    type: "Exchange" /* EXCHANGE */,
+    exchangeType,
+    partitionKeys: partitionKeys || [],
+    partitionCount: partitionCount || 0,
+    children: [child]
+  };
+}
+function LogicalPartialAggregate(groupBy, aggregates, child) {
+  return {
+    type: "PartialAggregate" /* PARTIAL_AGGREGATE */,
+    groupBy,
+    aggregates,
+    children: [child],
+    physicalStrategy: "HASH" /* HASH */
+  };
+}
+function LogicalFinalAggregate(groupBy, aggregates, partialAggregates, child) {
+  return {
+    type: "FinalAggregate" /* FINAL_AGGREGATE */,
+    groupBy,
+    aggregates,
+    partialAggregates,
+    children: [child],
+    physicalStrategy: "HASH" /* HASH */
+  };
+}
+function LogicalMergeExchange(orderKeys, limit, child) {
+  return {
+    type: "MergeExchange" /* MERGE_EXCHANGE */,
+    orderKeys,
+    limit: limit || null,
+    children: [child]
+  };
+}
+function LogicalExchangeReceive(sourceFragmentIds, schema) {
+  return {
+    type: "ExchangeReceive" /* EXCHANGE_RECEIVE */,
+    sourceFragmentIds,
+    schema: schema || [],
+    children: []
+  };
+}
+function LogicalSingleRow() {
+  return { type: "SingleRow" /* SINGLE_ROW */, children: [] };
+}
+function getChildren(node) {
+  return node.children || [];
+}
+function setChildren(node, children) {
+  return { ...node, children };
+}
+function planToString(node, indent = 0) {
+  const prefix = "  ".repeat(indent);
+  let str = `${prefix}${node.type}`;
+  switch (node.type) {
+    case "Scan" /* SCAN */:
+      str += `(${node.table}${node.alias !== node.table ? ` AS ${node.alias}` : ""})`;
+      break;
+    case "Join" /* JOIN */:
+      str += `(${node.joinType})`;
+      break;
+    case "Limit" /* LIMIT */:
+      str += `(${node.count}${node.offset ? `, offset=${node.offset}` : ""})`;
+      break;
+    case "CTEScan" /* CTE_SCAN */:
+      str += `(${node.cteName})`;
+      break;
+    case "CTEAnchor" /* CTE_ANCHOR */:
+      str += `(${node.cteName})`;
+      break;
+    case "DependentJoin" /* DEPENDENT_JOIN */:
+      str += `(${node.subqueryType})`;
+      break;
+    case "Window" /* WINDOW */:
+      str += `(${node.windowExprs.map((w) => w.name).join(", ")})`;
+      break;
+    case "TopN" /* TOP_N */:
+      str += `(${node.count}${node.offset ? `, offset=${node.offset}` : ""})`;
+      break;
+    case "IndexScan" /* INDEX_SCAN */:
+      str += `(${node.table} using ${node.indexName})`;
+      break;
+    case "Exchange" /* EXCHANGE */:
+      str += `(${node.exchangeType})`;
+      break;
+    case "PartialAggregate" /* PARTIAL_AGGREGATE */:
+      str += `(partial)`;
+      break;
+    case "FinalAggregate" /* FINAL_AGGREGATE */:
+      str += `(final)`;
+      break;
+    case "MergeExchange" /* MERGE_EXCHANGE */:
+      str += `(${node.limit ? `limit=${node.limit}` : "all"})`;
+      break;
+    case "ExchangeReceive" /* EXCHANGE_RECEIVE */:
+      str += `(fragments=[${node.sourceFragmentIds.join(",")}])`;
+      break;
+  }
+  str += "\n";
+  for (const child of getChildren(node)) {
+    str += planToString(child, indent + 1);
+  }
+  return str;
+}
+var PlanNodeType, JoinType, PhysicalStrategy, SortDirection, NullOrder;
+var init_logical_plan = __esm({
+  "src/planner/logical-plan.ts"() {
+    "use strict";
+    PlanNodeType = /* @__PURE__ */ ((PlanNodeType2) => {
+      PlanNodeType2["SCAN"] = "Scan";
+      PlanNodeType2["FILTER"] = "Filter";
+      PlanNodeType2["PROJECT"] = "Project";
+      PlanNodeType2["JOIN"] = "Join";
+      PlanNodeType2["AGGREGATE"] = "Aggregate";
+      PlanNodeType2["SORT"] = "Sort";
+      PlanNodeType2["LIMIT"] = "Limit";
+      PlanNodeType2["DISTINCT"] = "Distinct";
+      PlanNodeType2["UNION"] = "Union";
+      PlanNodeType2["CTE_SCAN"] = "CTEScan";
+      PlanNodeType2["CTE_ANCHOR"] = "CTEAnchor";
+      PlanNodeType2["DEPENDENT_JOIN"] = "DependentJoin";
+      PlanNodeType2["MATERIALIZE"] = "Materialize";
+      PlanNodeType2["EMPTY"] = "Empty";
+      PlanNodeType2["TOP_N"] = "TopN";
+      PlanNodeType2["INDEX_SCAN"] = "IndexScan";
+      PlanNodeType2["WINDOW"] = "Window";
+      PlanNodeType2["EXCHANGE"] = "Exchange";
+      PlanNodeType2["PARTIAL_AGGREGATE"] = "PartialAggregate";
+      PlanNodeType2["FINAL_AGGREGATE"] = "FinalAggregate";
+      PlanNodeType2["MERGE_EXCHANGE"] = "MergeExchange";
+      PlanNodeType2["EXCHANGE_RECEIVE"] = "ExchangeReceive";
+      PlanNodeType2["SINGLE_ROW"] = "SingleRow";
+      return PlanNodeType2;
+    })(PlanNodeType || {});
+    JoinType = /* @__PURE__ */ ((JoinType2) => {
+      JoinType2["INNER"] = "INNER";
+      JoinType2["LEFT"] = "LEFT";
+      JoinType2["RIGHT"] = "RIGHT";
+      JoinType2["FULL"] = "FULL";
+      JoinType2["SEMI"] = "SEMI";
+      JoinType2["ANTI"] = "ANTI";
+      JoinType2["MARK"] = "MARK";
+      JoinType2["SINGLE"] = "SINGLE";
+      JoinType2["CROSS"] = "CROSS";
+      return JoinType2;
+    })(JoinType || {});
+    PhysicalStrategy = /* @__PURE__ */ ((PhysicalStrategy2) => {
+      PhysicalStrategy2["HASH"] = "HASH";
+      PhysicalStrategy2["MERGE"] = "MERGE";
+      PhysicalStrategy2["NESTED_LOOP"] = "NESTED_LOOP";
+      PhysicalStrategy2["STREAM"] = "STREAM";
+      PhysicalStrategy2["UNGROUPED"] = "UNGROUPED";
+      PhysicalStrategy2["PERFECT_HASH"] = "PERFECT_HASH";
+      return PhysicalStrategy2;
+    })(PhysicalStrategy || {});
+    SortDirection = /* @__PURE__ */ ((SortDirection2) => {
+      SortDirection2["ASC"] = "ASC";
+      SortDirection2["DESC"] = "DESC";
+      return SortDirection2;
+    })(SortDirection || {});
+    NullOrder = /* @__PURE__ */ ((NullOrder2) => {
+      NullOrder2["FIRST"] = "FIRST";
+      NullOrder2["LAST"] = "LAST";
+      return NullOrder2;
+    })(NullOrder || {});
+  }
+});
+
+// src/cli/index.ts
+import path5 from "path";
+import { fork } from "child_process";
+import { availableParallelism } from "os";
+import { fileURLToPath } from "url";
+import { Catalog, QueryEngine } from "./index.node.js";
+
+// src/cli/cli-common.ts
+import fs2 from "fs";
+import path4 from "path";
+
+// src/cli/loaders/loader-factory.ts
+import path3 from "path";
+
+// src/cli/loaders/csv-loader.ts
+import fs from "fs";
+import csv from "csv-parser";
+import path from "path";
+import { DataType, DEFAULT_CHUNK_SIZE, Table } from "./index.node.js";
+
+// src/cli/loaders/data-loader.ts
+var DataLoader = class {
+  async load(engine, filePath) {
+    throw new Error("Method not implemented.");
+  }
+  registerToCatalog(engine, tableName, schema, table) {
+    engine.catalog.registerTable(tableName, schema);
+    engine.catalog.registerTableStorage(tableName, table);
+  }
+  buildSchema(firstRow, classify) {
+    const schema = [];
+    for (const [key, value] of Object.entries(firstRow)) {
+      schema.push({ name: key, dataType: classify(value) });
+    }
+    return schema;
+  }
+};
+
+// src/cli/loaders/csv-loader.ts
+var CSVLoader = class extends DataLoader {
+  allowedDir;
+  constructor(allowedDir = null) {
+    super();
+    this.allowedDir = allowedDir;
+  }
+  validatePath(filePath) {
+    const resolved = path.resolve(filePath);
+    if (this.allowedDir) {
+      const allowedResolved = path.resolve(this.allowedDir);
+      if (!resolved.startsWith(allowedResolved + path.sep) && resolved !== allowedResolved) {
+        throw new Error(`Path traversal denied: ${filePath} is outside allowed directory`);
+      }
+    }
+    if (/\.\.[/\\]/.test(filePath)) {
+      const cwd = process.cwd();
+      if (!resolved.startsWith(cwd + path.sep) && resolved !== cwd) {
+        throw new Error(`Path traversal denied: ${filePath} resolves outside working directory`);
+      }
+    }
+    return resolved;
+  }
+  async load(engine, filePath, options = {}) {
+    const resolvedPath = this.validatePath(filePath);
+    const partitionIndex = options.partitionIndex ?? null;
+    const partitionCount = options.partitionCount ?? null;
+    const usePartitionFilter = partitionIndex !== null && partitionCount !== null;
+    const maxRows = options.maxRows ?? null;
+    return new Promise((resolve, reject) => {
+      const tableName = path.basename(resolvedPath, path.extname(resolvedPath)).toUpperCase();
+      let schema = null;
+      let table = null;
+      let batch = [];
+      let rowIndex = 0;
+      let done = false;
+      const flushBatch = async () => {
+        if (batch.length === 0) return;
+        await table.insertRows(batch);
+        batch = [];
+      };
+      const fileStream = fs.createReadStream(resolvedPath);
+      const stream = fileStream.pipe(csv());
+      const finish = () => {
+        if (done) return;
+        done = true;
+        fileStream.destroy();
+        flushBatch().then(() => resolve(tableName)).catch(reject);
+      };
+      stream.on("data", (data) => {
+        if (done) return;
+        if (!schema) {
+          schema = this.inferSchema(data);
+          const pageStore = engine.storageBackend.createPageStore(engine.tempManager.allocate("buffer", tableName));
+          table = new Table(tableName, schema, pageStore);
+          this.registerToCatalog(engine, tableName, schema, table);
+        }
+        const currentRow = rowIndex++;
+        if (maxRows !== null && currentRow >= maxRows) {
+          finish();
+          return;
+        }
+        if (usePartitionFilter && currentRow % partitionCount !== partitionIndex) {
+          return;
+        }
+        batch.push(this.convertRow(data, schema));
+        if (batch.length >= DEFAULT_CHUNK_SIZE) {
+          stream.pause();
+          flushBatch().then(() => stream.resume()).catch(reject);
+        }
+      });
+      stream.on("end", async () => {
+        if (done) return;
+        done = true;
+        try {
+          await flushBatch();
+          resolve(tableName);
+        } catch (err) {
+          reject(err);
+        }
+      });
+      stream.on("error", (err) => {
+        if (!done) reject(err);
+      });
+    });
+  }
+  inferSchema(firstRow) {
+    return this.buildSchema(firstRow, (value) => {
+      let type = DataType.VARCHAR;
+      if (value && value.trim() !== "") {
+        const trimmed = value.trim();
+        if (/^(true|false)$/i.test(trimmed)) {
+          type = DataType.BOOLEAN;
+        } else if (!isNaN(Number(trimmed))) {
+          type = Number.isInteger(Number(trimmed)) ? DataType.INT32 : DataType.FLOAT64;
+        }
+      }
+      return type;
+    });
+  }
+  convertRow(rowObj, schema) {
+    const row = new Array(schema.length);
+    for (let i = 0; i < schema.length; i++) {
+      const val = rowObj[schema[i].name];
+      if (val === void 0 || val === null || val === "") {
+        row[i] = null;
+        continue;
+      }
+      const trimmed = typeof val === "string" ? val.trim() : val;
+      if (trimmed === "") {
+        row[i] = null;
+        continue;
+      }
+      switch (schema[i].dataType) {
+        case DataType.BOOLEAN:
+          row[i] = trimmed.toLowerCase() === "true";
+          break;
+        case DataType.INT32:
+          row[i] = parseInt(trimmed, 10);
+          break;
+        case DataType.FLOAT64:
+          row[i] = parseFloat(trimmed);
+          break;
+        default:
+          row[i] = val;
+          break;
+      }
+    }
+    return row;
+  }
+};
+
+// src/cli/loaders/json-loader.ts
+import { createReadStream } from "fs";
+import path2 from "path";
+import { DataType as DataType2, DEFAULT_CHUNK_SIZE as DEFAULT_CHUNK_SIZE2, Table as Table2 } from "./index.node.js";
+var JSONLoader = class extends DataLoader {
+  async load(engine, filePath) {
+    const tableName = path2.basename(filePath, path2.extname(filePath)).toUpperCase();
+    let schema = null;
+    let table = null;
+    let batch = [];
+    for await (const obj of streamJsonArray(filePath)) {
+      if (!schema) {
+        schema = this.inferSchema(obj);
+        const pageStore = engine.storageBackend.createPageStore(engine.tempManager.allocate("buffer", tableName));
+        table = new Table2(tableName, schema, pageStore);
+        this.registerToCatalog(engine, tableName, schema, table);
+      }
+      const row = new Array(schema.length);
+      for (let c = 0; c < schema.length; c++) {
+        const val = obj[schema[c].name];
+        row[c] = val === void 0 ? null : val;
+      }
+      batch.push(row);
+      if (batch.length >= DEFAULT_CHUNK_SIZE2) {
+        await table.insertRows(batch);
+        batch = [];
+      }
+    }
+    if (!table) {
+      throw new Error("JSON array is empty.");
+    }
+    if (batch.length > 0) {
+      await table.insertRows(batch);
+    }
+    return tableName;
+  }
+  inferSchema(firstRow) {
+    return this.buildSchema(firstRow, (value) => {
+      let type = DataType2.VARCHAR;
+      if (typeof value === "boolean") {
+        type = DataType2.BOOLEAN;
+      } else if (typeof value === "number") {
+        type = Number.isInteger(value) ? DataType2.INT32 : DataType2.FLOAT64;
+      }
+      return type;
+    });
+  }
+};
+async function* streamJsonArray(filePath) {
+  const stream = createReadStream(filePath, { encoding: "utf8", highWaterMark: 64 * 1024 });
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+  let objectStart = -1;
+  let buffer = "";
+  let scanFrom = 0;
+  let seenArrayOpen = false;
+  for await (const chunk of stream) {
+    scanFrom = buffer.length;
+    buffer += chunk;
+    let i = scanFrom;
+    while (i < buffer.length) {
+      const ch = buffer[i];
+      if (escape) {
+        escape = false;
+        i++;
+        continue;
+      }
+      if (ch === "\\" && inString) {
+        escape = true;
+        i++;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        i++;
+        continue;
+      }
+      if (inString) {
+        i++;
+        continue;
+      }
+      if (!seenArrayOpen) {
+        if (ch === "[") seenArrayOpen = true;
+        i++;
+        continue;
+      }
+      if (ch === "{") {
+        if (depth === 0) objectStart = i;
+        depth++;
+      } else if (ch === "}") {
+        depth--;
+        if (depth === 0 && objectStart !== -1) {
+          yield JSON.parse(buffer.substring(objectStart, i + 1));
+          objectStart = -1;
+        }
+      }
+      i++;
+    }
+    if (objectStart !== -1) {
+      buffer = buffer.substring(objectStart);
+      objectStart = 0;
+    } else {
+      buffer = "";
+    }
+  }
+}
+
+// src/cli/loaders/loader-factory.ts
+var LoaderFactory = class {
+  static getLoader(filePath) {
+    const ext = path3.extname(filePath).toLowerCase();
+    switch (ext) {
+      case ".csv":
+        return new CSVLoader();
+      case ".json":
+        return new JSONLoader();
+      default:
+        throw new Error(`Unsupported file extension: ${ext}`);
+    }
+  }
+};
+
+// src/cli/cli-common.ts
+async function loadDataFiles(engine, catalog, dataPaths, options = {}) {
+  const loadOptions = options.loadOptions ?? {};
+  const formatLoadLine = options.formatLoadLine ?? (({ tableName, rowCount, dataPath }) => `[load] ${tableName} (${rowCount} rows) from ${dataPath}`);
+  for (const dp of dataPaths) {
+    const resolvedPath = path4.resolve(process.cwd(), dp);
+    if (!fs2.existsSync(resolvedPath)) {
+      console.error(`File not found: ${resolvedPath}`);
+      process.exit(1);
+    }
+    const loader = LoaderFactory.getLoader(resolvedPath);
+    const tableName = await loader.load(engine, resolvedPath, loadOptions);
+    const storage = catalog.getTableStorage(tableName);
+    const rowCount = storage ? storage.rowCount() : 0;
+    console.log(formatLoadLine({ tableName, rowCount, dataPath: dp }));
+  }
+}
+
+// src/cli/repl.ts
+import readline from "readline";
+import { highlight } from "cli-highlight";
+
+// src/cli/format.ts
+function formatResult(result) {
+  if (!result || !result.rows || result.rows.length === 0) {
+    console.log("Empty result set.");
+    return;
+  }
+  const columnNames = result.columns || Object.keys(result.rows[0]);
+  if (columnNames.length === 1 && (columnNames[0] === "EXPLAIN_PLAN" || columnNames[0] === "EXPLAIN_ANALYZE")) {
+    console.log(`
+${result.rows[0][columnNames[0]]}
+`);
+    return;
+  }
+  const colWidths = columnNames.map((name) => name.length);
+  for (const row of result.rows) {
+    for (let i = 0; i < columnNames.length; i++) {
+      const val = row[columnNames[i]];
+      const str = String(val ?? "NULL");
+      if (str.length > colWidths[i]) {
+        colWidths[i] = str.length;
+      }
+    }
+  }
+  const separator = "+" + colWidths.map((w) => "-".repeat(w + 2)).join("+") + "+";
+  console.log(separator);
+  console.log("|" + columnNames.map((name, i) => " " + name.padEnd(colWidths[i]) + " ").join("|") + "|");
+  console.log(separator);
+  for (const row of result.rows) {
+    console.log("|" + columnNames.map((name, i) => {
+      const val = row[name];
+      const str = String(val ?? "NULL");
+      return " " + str.padEnd(colWidths[i]) + " ";
+    }).join("|") + "|");
+  }
+  console.log(separator);
+  console.log(`${result.rows.length} row(s) returned.
+`);
+}
+
+// src/cli/repl.ts
+function startREPL(engine, options = {}) {
+  const coordinator = options.coordinator || null;
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: coordinator ? "dist> " : "sql> "
+  });
+  const originalWriteToOutput = rl._writeToOutput.bind(rl);
+  rl._writeToOutput = function(stringToWrite) {
+    const promptPatterns = ["sql> ", "...> ", "dist> "];
+    let promptIdx = -1;
+    let promptLen = 0;
+    for (const p of promptPatterns) {
+      const idx = stringToWrite.indexOf(p);
+      if (idx > -1) {
+        promptIdx = idx + p.length;
+        promptLen = p.length;
+        break;
+      }
+    }
+    if (promptIdx > -1) {
+      const prefix = stringToWrite.substring(0, promptIdx);
+      const code = stringToWrite.substring(promptIdx);
+      const highlightedCode = highlight(code, { language: "sql", ignoreIllegals: true });
+      originalWriteToOutput(prefix + highlightedCode);
+    } else {
+      originalWriteToOutput(stringToWrite);
+    }
+  };
+  rl._insertString = function(c) {
+    if (this.cursor < this.line.length) {
+      const beg = this.line.slice(0, this.cursor);
+      const end = this.line.slice(this.cursor, this.line.length);
+      this.line = beg + c + end;
+      this.cursor += c.length;
+      this._refreshLine();
+    } else {
+      this.line += c;
+      this.cursor += c.length;
+      this._refreshLine();
+    }
+  };
+  const defaultPrompt = coordinator ? "dist> " : "sql> ";
+  rl.prompt();
+  let queryBuffer = "";
+  rl.on("line", async (line) => {
+    const trimmed = line.trim();
+    if (trimmed.toLowerCase() === "exit" || trimmed.toLowerCase() === "quit") {
+      await engine.shutdown();
+      rl.close();
+      return;
+    }
+    if (trimmed === "") {
+      rl.prompt();
+      return;
+    }
+    if (trimmed.startsWith(".")) {
+      await handleMetaCommand(trimmed, engine, coordinator);
+      rl.prompt();
+      return;
+    }
+    queryBuffer += (queryBuffer ? " " : "") + trimmed;
+    if (queryBuffer.endsWith(";")) {
+      try {
+        console.log();
+        const sql = queryBuffer;
+        const startTime = performance.now();
+        let result;
+        if (coordinator) {
+          result = await coordinator.execute(sql);
+        } else {
+          result = await engine.run(sql);
+        }
+        const endTime = performance.now();
+        formatResult(result);
+        const mode = coordinator ? " [distributed]" : "";
+        console.log(`Executed in ${(endTime - startTime).toFixed(2)} ms${mode}
+`);
+      } catch (err) {
+        console.error(err.message);
+      }
+      queryBuffer = "";
+      rl.setPrompt(defaultPrompt);
+    } else {
+      rl.setPrompt("...> ");
+    }
+    rl.prompt();
+  }).on("close", () => {
+    process.exit(0);
+  });
+}
+async function handleMetaCommand(cmd, engine, coordinator) {
+  const parts = cmd.split(/\s+/);
+  const command = parts[0].toLowerCase();
+  switch (command) {
+    case ".status": {
+      console.log("");
+      console.log(`  wasm:        ${engine.wasmEnabled ? "enabled" : "disabled"}`);
+      console.log(`  parallel:    ${engine.parallelEnabled ? `enabled (${engine.workerPool?.maxWorkers} workers)` : "disabled"}`);
+      const distInfo = engine.distributed ? (() => {
+        const workers = engine.distributed.clusterManager.getWorkerNodes?.() || [];
+        return `enabled (node: ${engine.distributed.localNode.nodeId}, ${workers.length} worker(s))`;
+      })() : "disabled";
+      console.log(`  distributed: ${distInfo}`);
+      console.log(`  mode:        ${coordinator ? "distributed (queries go through coordinator)" : "local"}`);
+      console.log("");
+      break;
+    }
+    case ".tables": {
+      const tables = engine.catalog.listTables();
+      if (tables.length === 0) {
+        console.log("\n  No tables loaded.\n");
+      } else {
+        console.log("");
+        for (const name of tables) {
+          const storage = engine.catalog.getTableStorage(name);
+          const rows = storage ? storage.rowCount() : "?";
+          const tableDef = engine.catalog.getTable(name);
+          const cols = tableDef ? tableDef.columns.map((c) => c.name).join(", ") : "";
+          console.log(`  ${name} (${rows} rows) - [${cols}]`);
+        }
+        console.log("");
+      }
+      break;
+    }
+    case ".explain": {
+      const sql = parts.slice(1).join(" ");
+      if (!sql) {
+        console.log("\n  Usage: .explain <sql query>\n");
+        break;
+      }
+      try {
+        const compiled = await engine.compile(sql.endsWith(";") ? sql : sql + ";");
+        if (compiled.ddl) {
+          console.log("\n  DDL statement, no plan.\n");
+          break;
+        }
+        let plan = compiled.plan;
+        if (coordinator) {
+          plan._distributed = true;
+          plan = engine.optimize(plan);
+        }
+        const { planToString: planToString2 } = await Promise.resolve().then(() => (init_logical_plan(), logical_plan_exports));
+        console.log("");
+        console.log(planToString2(plan));
+      } catch (err) {
+        console.error(err.message);
+      }
+      break;
+    }
+    case ".help": {
+      console.log("");
+      console.log("  .status         Show engine status");
+      console.log("  .tables         List loaded tables");
+      console.log("  .explain <sql>  Show query plan");
+      console.log("  exit / quit     Exit");
+      console.log("");
+      break;
+    }
+    default:
+      console.log(`
+  Unknown command: ${command}. Type .help for available commands.
+`);
+  }
+}
+
+// src/cli/index.ts
+import { Config } from "./index.node.js";
+var __dirname = path5.dirname(fileURLToPath(import.meta.url));
+async function start() {
+  const args = process.argv.slice(2);
+  const dataPaths = [];
+  let useWasm = true;
+  let useParallel = false;
+  let useDistributed = false;
+  let workerCount = Config.distributedWorkers;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--no-wasm") {
+      useWasm = false;
+    } else if (arg === "--parallel") {
+      useParallel = true;
+    } else if (arg === "--distributed") {
+      useDistributed = true;
+    } else if (arg === "--workers" && args[i + 1]) {
+      workerCount = parseInt(args[++i], 10);
+    } else if (arg === "--help" || arg === "-h") {
+      console.log("Usage: npm start -- [options] <file1> [file2...]");
+      console.log("");
+      console.log("Options:");
+      console.log("  --no-wasm       Disable WebAssembly acceleration");
+      console.log("  --parallel      Enable parallel execution (requires WASM)");
+      console.log("  --distributed   Enable distributed query layer (auto-spawns workers)");
+      console.log("  --workers N     Number of worker processes (default: CPU cores - 2)");
+      console.log("");
+      console.log("REPL commands:");
+      console.log("  .status         Show engine status (wasm/parallel/distributed)");
+      console.log("  .tables         List loaded tables");
+      console.log("  .explain <sql>  Show query plan");
+      console.log("  exit / quit     Exit the REPL");
+      process.exit(0);
+    } else if (!arg.startsWith("-")) {
+      dataPaths.push(arg);
+    }
+  }
+  if (dataPaths.length === 0) {
+    console.error("Usage: npm start -- [--no-wasm] [--parallel] [--distributed] [--workers N] <file1> [file2...]");
+    process.exit(1);
+  }
+  if (workerCount <= 0) {
+    workerCount = Math.max(1, availableParallelism() - 2);
+  }
+  try {
+    const catalog = new Catalog();
+    const engine = new QueryEngine(catalog);
+    if (useWasm) {
+      await engine.enableWasm();
+    }
+    if (engine.wasmEnabled) {
+      console.log("[wasm] WebAssembly acceleration enabled");
+    }
+    if (useParallel) {
+      const ok = await engine.enableParallel();
+      if (ok) {
+        console.log(`[parallel] Parallel execution enabled (${engine.workerPool.maxWorkers} workers)`);
+      } else {
+        console.log("[parallel] Could not enable parallel execution (WASM required)");
+      }
+    }
+    const coordLoadOptions = useDistributed ? { partitionIndex: -1, partitionCount: 1 } : {};
+    await loadDataFiles(engine, catalog, dataPaths, { loadOptions: coordLoadOptions });
+    let coordinator = null;
+    const childProcesses = [];
+    if (useDistributed) {
+      const coordPort = Config.clusterPort;
+      coordinator = await engine.enableDistributed({
+        nodeId: `coordinator-${process.pid}`,
+        host: "127.0.0.1",
+        port: coordPort
+      });
+      await engine.distributed.transport.start();
+      console.log(`[distributed] Coordinator listening on port ${coordPort}`);
+      console.log(`[distributed] Spawning ${workerCount} worker(s)...`);
+      const workers = await spawnWorkers(engine, coordPort, workerCount, dataPaths);
+      childProcesses.push(...workers);
+      console.log(`[distributed] ${workers.length} worker(s) ready`);
+    }
+    const cleanup = () => {
+      for (const w of childProcesses) {
+        try {
+          w.kill();
+        } catch (_) {
+        }
+      }
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", () => {
+      cleanup();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      cleanup();
+      process.exit(0);
+    });
+    startREPL(engine, { coordinator });
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+}
+async function spawnWorkers(engine, coordPort, count, dataPaths) {
+  const { NodeDescriptor, NodeRole, RoundRobinPartitionStrategy } = await import("./index.node.js");
+  const workerScript = path5.join(__dirname, "worker.js");
+  const children = [];
+  const basePort = coordPort + 1;
+  const transport = engine.distributed.transport;
+  const partitionMap = engine.distributed.partitionMap;
+  return new Promise((resolve, reject) => {
+    let registered = 0;
+    const workerNodeIds = [];
+    const timeout = setTimeout(() => {
+      for (const c of children) {
+        try {
+          c.kill();
+        } catch (_) {
+        }
+      }
+      reject(new Error(`Timed out waiting for ${count} workers (${registered} registered)`));
+    }, 3e4);
+    transport.onRegister((reg) => {
+      const workerDesc = new NodeDescriptor({
+        nodeId: reg.nodeId,
+        host: reg.host,
+        port: reg.port,
+        role: NodeRole.WORKER
+      });
+      engine.distributed.clusterManager.addNode(workerDesc);
+      transport.registerNode(reg.nodeId, reg.host, reg.port);
+      workerNodeIds.push(reg.nodeId);
+      registered++;
+      console.log(`[distributed]   worker-${reg.port} joined (${registered}/${count})`);
+      if (registered >= count) {
+        clearTimeout(timeout);
+        const strategy = new RoundRobinPartitionStrategy();
+        const tables = engine.catalog.listTables();
+        for (const tableName of tables) {
+          const placements = /* @__PURE__ */ new Map();
+          for (let pid = 0; pid < count; pid++) {
+            placements.set(pid, [workerNodeIds[pid]]);
+          }
+          partitionMap.registerTable(tableName, strategy, count, placements);
+        }
+        resolve(children);
+      }
+    });
+    for (let i = 0; i < count; i++) {
+      const port = basePort + i;
+      const workerArgs = [
+        "--coordinator",
+        `127.0.0.1:${coordPort}`,
+        "--port",
+        String(port),
+        "--partition-index",
+        String(i),
+        "--partition-count",
+        String(count),
+        ...dataPaths.map((dp) => path5.resolve(process.cwd(), dp))
+      ];
+      const child = fork(workerScript, workerArgs, {
+        stdio: ["pipe", "pipe", "pipe", "ipc"]
+      });
+      child.stdout.on("data", (data) => {
+        for (const line of data.toString().trim().split("\n")) {
+          if (line) console.log(`  [worker-${port}] ${line}`);
+        }
+      });
+      child.stderr.on("data", (data) => {
+        for (const line of data.toString().trim().split("\n")) {
+          if (line) console.error(`  [worker-${port}] ${line}`);
+        }
+      });
+      child.on("exit", (code) => {
+        if (code !== 0 && code !== null) {
+          console.error(`  [worker-${port}] exited with code ${code}`);
+        }
+      });
+      children.push(child);
+    }
+  });
+}
+
+// dist/cli-entry.js
+start();