lakeql 0.1.8 → 0.2.0

package/dist/{chunk-5K5JMJ2M.js → chunk-3WUY56UD.js}

@@ -1,5 +1,6 @@
-import { Lake, stableStringify, vectorValue, scalarVectorValue, batchFromColumns, withObjectStoreReadControls, throwIfAborted, readControlSignal, readParquetObjectBatches, readIcebergParquetDeletes } from './chunk-MXGEAVHL.js';
-import { LakeqlError, jsonSafeValue, matches } from './chunk-TFD5RFKB.js';
+import { Lake, vectorValue, scalarVectorValue, batchFromColumns, withObjectStoreReadControls, throwIfAborted, readControlSignal, readParquetObjectBatches, readIcebergParquetDeletes, createParquetLake, parseSql, writePartitionedParquet, broadcastJoin } from './chunk-32PE6IK4.js';
+import { stableStringify } from './chunk-LWF5FKHB.js';
+import { LakeqlError, jsonSafeValue, matches, evaluate } from './chunk-WGHR35QU.js';
 
 // ../core/dist/in-memory.js
 var InMemoryRowsScanner = class {
@@ -2017,4 +2018,682 @@ async function* projectIcebergParquetBatches(store, table, path, partition, snap
   }
 }
 
-export { IcebergRestCatalog, IcebergTable, IcebergUnsupportedCatalog, InMemoryRowsScanner, InMemoryRowsStore, ObjectStoreIcebergCommitCatalog, ObjectStoreJsonCache, PACKAGE, applyIcebergDeletes, createInMemoryLake, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, inMemoryRowsScanner, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, objectStoreJsonCache, planFiles2 as planFiles, scanBatches, scanPlannedIcebergRows, scanRows, vectorHashJoin };
+// src/sql.ts
+var textEncoder = new TextEncoder();
+var sqlTempOrdinal = 0;
+function createLake(config) {
+  const lake = createParquetLake(config);
+  lake.sql = (sql, options = {}) => querySql(lake, sql, options);
+  return lake;
+}
+function querySql(lake, sql, options = {}) {
+  return new SqlQueryResult(() => executeSql(lake, sql, options));
+}
+var SqlQueryResult = class {
+  execute;
+  rowsPromise;
+  constructor(execute) {
+    this.execute = execute;
+  }
+  async toArray() {
+    this.rowsPromise ??= this.execute();
+    return await this.rowsPromise;
+  }
+  async first() {
+    return (await this.toArray())[0];
+  }
+  async count() {
+    return (await this.toArray()).length;
+  }
+  async *rows() {
+    for (const row of await this.toArray()) yield row;
+  }
+  async *batches() {
+    const rows = await this.toArray();
+    if (rows.length > 0) yield rows;
+  }
+  streamJson() {
+    return streamText(async () => jsonStringify(await this.toArray()));
+  }
+  streamNdjson() {
+    return streamText(
+      async () => (await this.toArray()).map((row) => jsonStringify(row)).join("\n")
+    );
+  }
+  streamCsv(options = {}) {
+    return streamText(async () => rowsToCsv(await this.toArray(), options));
+  }
+};
+async function executeSql(lake, sql, options) {
+  const ast = sqlAst(sql, options);
+  const bound = bindSources(ast, options);
+  const materialized = await materializeCteIfNeeded(lake.store, lake, bound);
+  try {
+    const resolved = await resolveScalarSubqueries(lake, materialized.ast);
+    if (resolved.subqueryJoin !== void 0)
+      return subqueryJoinRowsFromAst(lake, resolved, options);
+    if (resolved.join !== void 0) return joinRowsFromAst(lake, resolved, options);
+    if (hasAggregation(resolved)) return aggregateRowsFromAst(lake.path(resolved.source), resolved);
+    return await builderFromAst(lake.path(resolved.source), resolved).toArray();
+  } finally {
+    await materialized.cleanup();
+  }
+}
+function sqlAst(sql, options) {
+  const trimmed = sql.trim();
+  const sourceSql = /\bfrom\b/iu.test(trimmed) ? trimmed : addDefaultFrom(trimmed);
+  return options.parameters === void 0 ? parseSql(sourceSql) : parseSql(sourceSql, { parameters: options.parameters });
+}
+function bindSources(ast, options) {
+  const tables = options.tables ?? {};
+  const bindSource = (source) => {
+    if (source === "input" && options.path !== void 0) return options.path;
+    return tables[source] ?? source;
+  };
+  return mapAstSources(ast, bindSource);
+}
+function mapAstSources(ast, bindSource, seen = /* @__PURE__ */ new WeakSet()) {
+  const out = { ...ast, source: bindSource(ast.source) };
+  if (seen.has(ast)) {
+    delete out.scalarSubqueries;
+    return out;
+  }
+  seen.add(ast);
+  if (ast.join !== void 0) out.join = { ...ast.join, source: bindSource(ast.join.source) };
+  if (ast.subqueryJoin !== void 0) {
+    out.subqueryJoin = {
+      ...ast.subqueryJoin,
+      source: bindSource(ast.subqueryJoin.source)
+    };
+  }
+  if (ast.cte !== void 0) {
+    out.cte = { ...ast.cte, query: mapAstSources(ast.cte.query, bindSource, seen) };
+  }
+  if (ast.scalarSubqueries !== void 0) {
+    out.scalarSubqueries = Object.fromEntries(
+      Object.entries(ast.scalarSubqueries).map(([id, subquery]) => [
+        id,
+        { ...subquery, query: mapAstSources(subquery.query, bindSource, seen) }
+      ])
+    );
+  }
+  return out;
+}
+function builderFromAst(builder, ast) {
+  let next = builder;
+  for (const [alias, expr] of Object.entries(ast.windows ?? {})) next = next.window(alias, expr);
+  if (ast.select) next = next.select(ast.select);
+  if (ast.projections) next = next.project(ast.projections);
+  if (ast.where) next = next.where(ast.where);
+  if (ast.qualify) next = next.qualify(ast.qualify);
+  if (ast.distinct === true) next = next.distinct();
+  if (ast.orderBy) next = next.orderBy(ast.orderBy);
+  if (ast.offset !== void 0) next = next.offset(ast.offset);
+  if (ast.limit !== void 0) next = next.limit(ast.limit);
+  return next;
+}
+function hasAggregation(ast) {
+  return ast.aggregates !== void 0 || ast.groupBy !== void 0 && ast.groupBy.length > 0 || ast.having !== void 0;
+}
+function hasWindowSemantics(ast) {
+  return ast.windows !== void 0 && Object.keys(ast.windows).length > 0 || ast.qualify !== void 0;
+}
+async function materializeCteIfNeeded(store, lake, ast) {
+  if (ast.cte === void 0) return { ast, cleanup: async () => {
+  } };
+  if (ast.source !== ast.cte.name) {
+    throw new LakeqlError(
+      "LAKEQL_SQL_UNSUPPORTED",
+      "CTEs are only supported as the outer FROM source"
+    );
+  }
+  if (ast.join !== void 0 || ast.subqueryJoin !== void 0) {
+    throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "CTEs inside JOINs are not supported yet");
+  }
+  const cteRows = hasAggregation(ast.cte.query) ? await aggregateRowsFromAst(lake.path(ast.cte.query.source), ast.cte.query) : await builderFromAst(lake.path(ast.cte.query.source), ast.cte.query).toArray();
+  if (cteRows.length === 0) {
+    throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "Empty CTE results are not supported yet");
+  }
+  const prefix = `__lakeql_sql_cte/${safeTempName(ast.cte.name)}/${nextSqlTempId()}`;
+  const written = await writePartitionedParquet(store, prefix, {
+    rows: cteRows,
+    maxRowsPerFile: cteRows.length
+  });
+  const { cte: _cte, ...rest } = ast;
+  return {
+    ast: { ...rest, source: `${prefix}/*.parquet` },
+    cleanup: async () => {
+      await Promise.all(written.files.map((file) => store.delete(file.path)));
+    }
+  };
+}
+function nextSqlTempId() {
+  const randomUuid = globalThis.crypto?.randomUUID?.();
+  if (randomUuid !== void 0) return randomUuid;
+  sqlTempOrdinal += 1;
+  return `${Date.now().toString(36)}-${sqlTempOrdinal.toString(36)}`;
+}
+function safeTempName(name) {
+  return name.replaceAll(/[^A-Za-z0-9_-]/gu, "_");
+}
+async function resolveScalarSubqueries(lake, ast) {
+  if (ast.scalarSubqueries === void 0) return ast;
+  const values = /* @__PURE__ */ new Map();
+  for (const [id, subquery] of Object.entries(ast.scalarSubqueries)) {
+    const rows = hasAggregation(subquery.query) ? await aggregateRowsFromAst(lake.path(subquery.query.source), subquery.query) : await builderFromAst(lake.path(subquery.query.source), subquery.query).toArray();
+    if (rows.length > 1) {
+      throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "Scalar subquery returned more than one row");
+    }
+    values.set(id, rows.length === 0 ? null : rows[0]?.[subquery.column] ?? null);
+  }
+  const out = { ...ast };
+  if (ast.where !== void 0) out.where = replaceScalarSubqueryExpr(ast.where, values);
+  if (ast.having !== void 0) out.having = replaceScalarSubqueryExpr(ast.having, values);
+  if (ast.projections !== void 0) {
+    out.projections = Object.fromEntries(
+      Object.entries(ast.projections).map(([alias, expr]) => [
+        alias,
+        replaceScalarSubqueryExpr(expr, values)
+      ])
+    );
+  }
+  delete out.scalarSubqueries;
+  return out;
+}
+function replaceScalarSubqueryExpr(expr, values) {
+  switch (expr.kind) {
+    case "call":
+      if (expr.fn === "__lakeql_scalar_subquery") {
+        const id = expr.args[0];
+        if (id?.kind !== "literal" || typeof id.value !== "string" || !values.has(id.value)) {
+          throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "Invalid scalar subquery placeholder");
+        }
+        return { kind: "literal", value: values.get(id.value) };
+      }
+      return { ...expr, args: expr.args.map((arg) => replaceScalarSubqueryExpr(arg, values)) };
+    case "compare":
+      return {
+        ...expr,
+        left: replaceScalarSubqueryExpr(expr.left, values),
+        right: replaceScalarSubqueryExpr(expr.right, values)
+      };
+    case "between":
+      return {
+        ...expr,
+        target: replaceScalarSubqueryExpr(expr.target, values),
+        low: replaceScalarSubqueryExpr(expr.low, values),
+        high: replaceScalarSubqueryExpr(expr.high, values)
+      };
+    case "in":
+      return {
+        ...expr,
+        target: replaceScalarSubqueryExpr(expr.target, values),
+        values: expr.values.map((value) => replaceScalarSubqueryExpr(value, values))
+      };
+    case "logical":
+      return {
+        ...expr,
+        operands: expr.operands.map((operand) => replaceScalarSubqueryExpr(operand, values))
+      };
+    case "not":
+      return { ...expr, operand: replaceScalarSubqueryExpr(expr.operand, values) };
+    case "null-check":
+      return { ...expr, target: replaceScalarSubqueryExpr(expr.target, values) };
+    case "like":
+      return { ...expr, target: replaceScalarSubqueryExpr(expr.target, values) };
+    case "arithmetic":
+      return {
+        ...expr,
+        left: replaceScalarSubqueryExpr(expr.left, values),
+        right: replaceScalarSubqueryExpr(expr.right, values)
+      };
+    case "case":
+      return {
+        ...expr,
+        whens: expr.whens.map((branch) => ({
+          when: replaceScalarSubqueryExpr(branch.when, values),
+          value: replaceScalarSubqueryExpr(branch.value, values)
+        })),
+        ...expr.else === void 0 ? {} : { else: replaceScalarSubqueryExpr(expr.else, values) }
+      };
+    case "column":
+    case "literal":
+      return expr;
+  }
+}
+async function joinRowsFromAst(lake, ast, options) {
+  if (ast.join === void 0) throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Missing SQL JOIN");
+  const join = ast.join;
+  if (hasWindowSemantics(ast)) {
+    throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "Window SQL over JOIN is not supported");
+  }
+  if (hasAggregation(ast)) {
+    throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "Aggregate SQL over JOIN is not supported yet");
+  }
+  const leftAlias = ast.join.leftAlias;
+  const plan = planJoinSides(ast, leftAlias, join.alias);
+  let leftBuilder = lake.path(ast.source);
+  let rightBuilder = lake.path(join.source);
+  if (plan.leftWhere !== void 0) leftBuilder = leftBuilder.where(plan.leftWhere);
+  if (plan.rightWhere !== void 0) rightBuilder = rightBuilder.where(plan.rightWhere);
+  if (plan.leftColumns !== void 0) leftBuilder = leftBuilder.select(plan.leftColumns);
+  if (plan.rightColumns !== void 0) rightBuilder = rightBuilder.select(plan.rightColumns);
+  const leftRows = (await leftBuilder.toArray()).map((row) => qualifyRow(row, leftAlias));
+  const rightRows = (await rightBuilder.toArray()).map((row) => qualifyOnlyRow(row, join.alias));
+  let rows = await broadcastJoin(leftRows, rightRows, {
+    leftKey: join.leftKey,
+    rightKey: join.rightKey,
+    type: join.type,
+    rightPrefix: `${join.alias}.`,
+    maxRightRows: options.joinMaxRightRows ?? 1e5
+  });
+  if (join.type === "left") {
+    rows = fillLeftJoinNulls(rows, join.alias, leftJoinRightColumns(ast, join.alias, rightRows));
+  }
+  if (plan.residualWhere !== void 0)
+    rows = rows.filter((row) => matches(plan.residualWhere, row));
+  if (ast.orderBy !== void 0) rows = sortRows(rows, ast.orderBy);
+  rows = projectRows(rows, ast);
+  if (ast.distinct === true) rows = distinctRows(rows);
+  return offsetLimitRows(rows, ast);
+}
+function planJoinSides(ast, leftAlias, rightAlias) {
+  if (ast.join === void 0) throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Missing SQL JOIN");
+  const leftPredicates = [];
+  const rightPredicates = [];
+  const residualPredicates = [];
+  for (const predicate of splitAndPredicate(ast.where)) {
+    const columns = exprColumns(predicate);
+    if (columns.length > 0 && columns.every((column) => isQualifiedBy(column, leftAlias))) {
+      leftPredicates.push(stripQualifiedExpr(predicate, leftAlias));
+    } else if (ast.join.type === "inner" && columns.length > 0 && columns.every((column) => isQualifiedBy(column, rightAlias))) {
+      rightPredicates.push(stripQualifiedExpr(predicate, rightAlias));
+    } else {
+      residualPredicates.push(predicate);
+    }
+  }
+  const plan = {};
+  const leftWhere = combineAndPredicate(leftPredicates);
+  const rightWhere = combineAndPredicate(rightPredicates);
+  const residualWhere = combineAndPredicate(residualPredicates);
+  if (leftWhere !== void 0) plan.leftWhere = leftWhere;
+  if (rightWhere !== void 0) plan.rightWhere = rightWhere;
+  if (residualWhere !== void 0) plan.residualWhere = residualWhere;
+  if (canProjectJoinSides(ast, leftAlias, rightAlias)) {
+    plan.leftColumns = joinSideColumns(ast, leftAlias, ast.join.leftKey);
+    plan.rightColumns = joinSideColumns(ast, rightAlias, ast.join.rightKey);
+  }
+  return plan;
+}
+function splitAndPredicate(expr) {
+  if (expr === void 0) return [];
+  if (expr.kind === "logical" && expr.op === "and") return expr.operands.flatMap(splitAndPredicate);
+  return [expr];
+}
+function combineAndPredicate(predicates) {
+  if (predicates.length === 0) return void 0;
+  if (predicates.length === 1) return predicates[0];
+  return { kind: "logical", op: "and", operands: predicates };
+}
+function isQualifiedBy(column, alias) {
+  return column.startsWith(`${alias}.`) && column.length > alias.length + 1;
+}
+function stripQualifiedColumn(column, alias) {
+  return isQualifiedBy(column, alias) ? column.slice(alias.length + 1) : column;
+}
+function stripQualifiedExpr(expr, alias) {
+  switch (expr.kind) {
+    case "column":
+      return { ...expr, name: stripQualifiedColumn(expr.name, alias) };
+    case "compare":
+      return {
+        ...expr,
+        left: stripQualifiedExpr(expr.left, alias),
+        right: stripQualifiedExpr(expr.right, alias)
+      };
+    case "between":
+      return {
+        ...expr,
+        target: stripQualifiedExpr(expr.target, alias),
+        low: stripQualifiedExpr(expr.low, alias),
+        high: stripQualifiedExpr(expr.high, alias)
+      };
+    case "in":
+      return {
+        ...expr,
+        target: stripQualifiedExpr(expr.target, alias),
+        values: expr.values.map((value) => stripQualifiedExpr(value, alias))
+      };
+    case "logical":
+      return {
+        ...expr,
+        operands: expr.operands.map((operand) => stripQualifiedExpr(operand, alias))
+      };
+    case "not":
+      return { ...expr, operand: stripQualifiedExpr(expr.operand, alias) };
+    case "null-check":
+      return { ...expr, target: stripQualifiedExpr(expr.target, alias) };
+    case "like":
+      return { ...expr, target: stripQualifiedExpr(expr.target, alias) };
+    case "call":
+      return { ...expr, args: expr.args.map((arg) => stripQualifiedExpr(arg, alias)) };
+    case "arithmetic":
+      return {
+        ...expr,
+        left: stripQualifiedExpr(expr.left, alias),
+        right: stripQualifiedExpr(expr.right, alias)
+      };
+    case "case":
+      return {
+        ...expr,
+        whens: expr.whens.map((branch) => ({
+          when: stripQualifiedExpr(branch.when, alias),
+          value: stripQualifiedExpr(branch.value, alias)
+        })),
+        ...expr.else === void 0 ? {} : { else: stripQualifiedExpr(expr.else, alias) }
+      };
+    case "literal":
+      return expr;
+  }
+}
+function exprColumns(expr) {
+  const columns = /* @__PURE__ */ new Set();
+  collectExprColumns(expr, columns);
+  return [...columns];
+}
+function collectExprColumns(expr, columns) {
+  switch (expr.kind) {
+    case "column":
+      columns.add(expr.name);
+      return;
+    case "compare":
+      collectExprColumns(expr.left, columns);
+      collectExprColumns(expr.right, columns);
+      return;
+    case "between":
+      collectExprColumns(expr.target, columns);
+      collectExprColumns(expr.low, columns);
+      collectExprColumns(expr.high, columns);
+      return;
+    case "in":
+      collectExprColumns(expr.target, columns);
+      for (const value of expr.values) collectExprColumns(value, columns);
+      return;
+    case "logical":
+      for (const operand of expr.operands) collectExprColumns(operand, columns);
+      return;
+    case "not":
+      collectExprColumns(expr.operand, columns);
+      return;
+    case "null-check":
+      collectExprColumns(expr.target, columns);
+      return;
+    case "like":
+      collectExprColumns(expr.target, columns);
+      return;
+    case "call":
+      for (const arg of expr.args) collectExprColumns(arg, columns);
+      return;
+    case "arithmetic":
+      collectExprColumns(expr.left, columns);
+      collectExprColumns(expr.right, columns);
+      return;
+    case "case":
+      for (const branch of expr.whens) {
+        collectExprColumns(branch.when, columns);
+        collectExprColumns(branch.value, columns);
+      }
+      if (expr.else !== void 0) collectExprColumns(expr.else, columns);
+      return;
+    case "literal":
+      return;
+  }
+}
+function canProjectJoinSides(ast, leftAlias, rightAlias) {
+  if (ast.select?.includes("*") ?? false) return false;
+  return referencedJoinColumns(ast).every(
+    (column) => isQualifiedBy(column, leftAlias) || isQualifiedBy(column, rightAlias)
+  );
+}
+function referencedJoinColumns(ast) {
+  const columns = /* @__PURE__ */ new Set();
+  for (const select of ast.select ?? []) {
+    const { column } = selectColumn(select);
+    columns.add(column);
+  }
+  for (const expr of Object.values(ast.projections ?? {})) collectExprColumns(expr, columns);
+  if (ast.where !== void 0) collectExprColumns(ast.where, columns);
+  for (const term of ast.orderBy ?? []) columns.add(term.column);
+  return [...columns].filter((column) => column !== "*");
+}
+function joinSideColumns(ast, alias, joinKey2) {
+  const columns = new Set(
+    (Array.isArray(joinKey2) ? joinKey2 : [joinKey2]).map(
+      (column) => stripQualifiedColumn(column, alias)
+    )
+  );
+  for (const column of referencedJoinColumns(ast)) {
+    if (isQualifiedBy(column, alias)) columns.add(stripQualifiedColumn(column, alias));
+  }
+  return [...columns];
+}
+function leftJoinRightColumns(ast, rightAlias, rightRows) {
+  const columns = /* @__PURE__ */ new Set();
+  if (ast.select?.includes("*") ?? false) {
+    for (const row of rightRows) {
+      for (const column of Object.keys(row)) {
+        if (isQualifiedBy(column, rightAlias))
+          columns.add(stripQualifiedColumn(column, rightAlias));
+      }
+    }
+  }
+  for (const column of referencedJoinColumns(ast)) {
+    if (isQualifiedBy(column, rightAlias)) columns.add(stripQualifiedColumn(column, rightAlias));
+  }
+  return [...columns];
+}
+function fillLeftJoinNulls(rows, rightAlias, rightColumns) {
+  if (rightColumns.length === 0) return rows;
+  return rows.map((row) => {
+    let out;
+    for (const column of rightColumns) {
+      const qualified = `${rightAlias}.${column}`;
+      if (qualified in row) continue;
+      out ??= { ...row };
+      out[qualified] = null;
+    }
+    return out ?? row;
+  });
+}
+async function subqueryJoinRowsFromAst(lake, ast, options) {
+  if (ast.subqueryJoin === void 0) {
+    throw new LakeqlError("LAKEQL_VALIDATION_ERROR", "Missing SQL IN subquery");
+  }
+  if (hasWindowSemantics(ast)) {
+    throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "Window SQL over IN subquery is not supported");
+  }
+  if (hasAggregation(ast)) {
+    throw new LakeqlError(
+      "LAKEQL_SQL_UNSUPPORTED",
+      "Aggregate SQL over IN subquery is not supported yet"
+    );
+  }
+  const join = ast.subqueryJoin;
+  let rightRows = await lake.path(join.source).toArray();
+  if (join.where !== void 0) rightRows = rightRows.filter((row) => matches(join.where, row));
+  let rows = await broadcastJoin(await lake.path(ast.source).toArray(), rightRows, {
+    leftKey: join.leftKey,
+    rightKey: join.rightKey,
+    type: join.type,
+    maxRightRows: options.joinMaxRightRows ?? 1e5
+  });
+  if (ast.where !== void 0) rows = rows.filter((row) => matches(ast.where, row));
+  if (ast.orderBy !== void 0) rows = sortRows(rows, ast.orderBy);
+  rows = projectRows(rows, ast);
+  if (ast.distinct === true) rows = distinctRows(rows);
+  return offsetLimitRows(rows, ast);
+}
+function qualifyRow(row, alias) {
+  const out = { ...row };
+  for (const [key, value] of Object.entries(row)) out[`${alias}.${key}`] = value;
+  return out;
+}
+function qualifyOnlyRow(row, alias) {
+  return Object.fromEntries(Object.entries(row).map(([key, value]) => [`${alias}.${key}`, value]));
+}
+function projectRows(rows, ast) {
+  const hasWildcardProjection = ast.select?.includes("*") ?? false;
+  return rows.map((row) => {
+    if (hasWildcardProjection && ast.projections === void 0) return row;
+    const out = {};
+    if (hasWildcardProjection) {
+      for (const [column, value] of Object.entries(row)) out[column] = value;
+    } else {
+      for (const select of ast.select ?? []) {
+        const { column, alias } = selectColumn(select);
+        out[alias] = row[column];
+      }
+    }
+    for (const [alias, expr] of Object.entries(ast.projections ?? {})) {
+      out[alias] = evaluate(expr, row);
+    }
+    return out;
+  });
+}
+async function aggregateRowsFromAst(builder, ast) {
+  if (hasWindowSemantics(ast)) {
+    throw new LakeqlError("LAKEQL_SQL_UNSUPPORTED", "Window SQL over aggregates is not supported");
+  }
+  validateAggregateProjection(ast);
+  let next = builder;
+  if (ast.where) next = next.where(ast.where);
+  const aggregates = ast.aggregates ?? {};
+  const hiddenCountAlias = hiddenAggregateAlias(ast);
+  const aggregateSpec = Object.keys(aggregates).length > 0 ? aggregates : { [hiddenCountAlias]: { op: "count" } };
+  let rows = await next.groupBy(ast.groupBy ?? []).aggregate(aggregateSpec, {
+    ...ast.having !== void 0 ? { having: ast.having } : {},
+    ...ast.orderBy !== void 0 ? { orderBy: ast.orderBy } : {},
+    ...ast.distinct === true ? {} : ast.limit !== void 0 ? { limit: ast.limit } : {},
+    ...ast.distinct === true ? {} : ast.offset !== void 0 ? { offset: ast.offset } : {}
+  });
+  rows = projectAggregateRows(rows, ast, hiddenCountAlias);
+  if (ast.distinct === true) rows = distinctRows(rows);
+  if (ast.distinct === true) return offsetLimitRows(rows, ast);
+  return rows;
+}
+function validateAggregateProjection(ast) {
+  const groupColumns = new Set(ast.groupBy ?? []);
+  for (const select of ast.select ?? []) {
+    const { column } = selectColumn(select);
+    if (column === "*") continue;
+    if (!groupColumns.has(column)) {
+      throw new LakeqlError(
+        "LAKEQL_SQL_UNSUPPORTED",
+        `Aggregate SQL can only select grouped columns or aggregate expressions, not ${column}`
+      );
+    }
+  }
+}
+function projectAggregateRows(rows, ast, hiddenCountAlias) {
+  const aggregates = Object.entries(ast.aggregates ?? {});
+  const hasWildcardProjection = ast.select?.includes("*") ?? false;
+  return rows.map((row) => {
+    const out = {};
+    if (hasWildcardProjection) {
+      for (const [column, value] of Object.entries(row)) {
+        if (column !== hiddenCountAlias) out[column] = value;
+      }
+    } else if (ast.select !== void 0) {
+      for (const select of ast.select ?? []) {
+        const { column, alias } = selectColumn(select);
+        out[alias] = row[column];
+      }
+    }
+    for (const [alias] of aggregates) out[alias] = row[alias];
+    for (const [alias, expr] of Object.entries(ast.projections ?? {})) {
+      out[alias] = evaluate(expr, row);
+    }
+    return out;
+  });
+}
+function hiddenAggregateAlias(ast) {
+  const reserved = /* @__PURE__ */ new Set([...ast.select ?? [], ...Object.keys(ast.aggregates ?? {})]);
+  let alias = "__lakeql_group_count";
+  while (reserved.has(alias)) alias = `_${alias}`;
+  return alias;
+}
+function selectColumn(select) {
+  const match = /^(.+?)\s+as\s+(.+)$/iu.exec(select);
+  if (match === null) return { column: select, alias: select };
+  const [, column, alias] = match;
+  return { column: column ?? select, alias: alias ?? select };
+}
+function distinctRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const row of rows) {
+    const key = jsonStringify(row);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(row);
+  }
+  return out;
+}
+function sortRows(rows, orderBy) {
+  return [...rows].sort((a, b) => {
+    for (const term of orderBy) {
+      const av = a[term.column] ?? null;
+      const bv = b[term.column] ?? null;
+      if (av === bv) continue;
+      if (av === null) return term.nulls === "first" ? -1 : 1;
+      if (bv === null) return term.nulls === "first" ? 1 : -1;
+      const direction = term.direction === "desc" ? -1 : 1;
+      return (av < bv ? -1 : 1) * direction;
+    }
+    return 0;
+  });
+}
+function offsetLimitRows(rows, ast) {
+  const offset = ast.offset ?? 0;
+  if (ast.limit !== void 0) return rows.slice(offset, offset + ast.limit);
+  return offset > 0 ? rows.slice(offset) : rows;
+}
+function rowsToCsv(rows, options) {
+  const columns = Object.keys(rows[0] ?? {});
+  const lines = [columns.join(",")];
+  for (const row of rows) {
+    lines.push(columns.map((column) => csvCell(row[column], options)).join(","));
+  }
+  return `${lines.join("\n")}
+`;
+}
+function csvCell(value, options) {
+  if (value === null || value === void 0) return "";
+  const raw = String(value);
+  const text = options.preventFormulae === true && /^[=+\-@]/u.test(raw) ? `'${raw}` : raw;
+  return /[",\n\r]/u.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+}
+function jsonStringify(value) {
+  return JSON.stringify(value, (_key, item) => typeof item === "bigint" ? item.toString() : item);
+}
+function streamText(read) {
+  let done = false;
+  return new ReadableStream({
+    async pull(controller) {
+      if (done) return;
+      done = true;
+      controller.enqueue(textEncoder.encode(await read()));
+      controller.close();
+    }
+  });
+}
+function addDefaultFrom(sql) {
+  if (!/^\s*select\b/iu.test(sql)) {
+    throw new LakeqlError("LAKEQL_PARSE_ERROR", "SQL must start with SELECT");
+  }
+  const clause = /\b(where|group\s+by|having|order\s+by|limit|offset)\b/iu.exec(sql);
+  if (clause === null || clause.index === void 0) return `${sql} from input`;
+  return `${sql.slice(0, clause.index)}from input ${sql.slice(clause.index)}`;
+}
+
+export { IcebergRestCatalog, IcebergTable, IcebergUnsupportedCatalog, InMemoryRowsScanner, InMemoryRowsStore, ObjectStoreIcebergCommitCatalog, ObjectStoreJsonCache, PACKAGE, SqlQueryResult, applyIcebergDeletes, createInMemoryLake, createLake, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, inMemoryRowsScanner, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, objectStoreJsonCache, planFiles2 as planFiles, querySql, scanBatches, scanPlannedIcebergRows, scanRows, vectorHashJoin };