lakeql 0.2.0 → 0.5.1

package/dist/{chunk-32PE6IK4.js → chunk-AUL4DYT4.js}

@@ -9207,6 +9207,48 @@ function compareSortValues(left, right, term) {
 }
 
 // ../core/dist/query-json.js
+var COMPARE_OPS = ["eq", "ne", "lt", "lte", "gt", "gte"];
+var ARITHMETIC_OPS = ["add", "sub", "mul", "div", "mod"];
+var AGGREGATE_OPS = [
+  "count",
+  "sum",
+  "avg",
+  "var_samp",
+  "var_pop",
+  "stddev_samp",
+  "stddev_pop",
+  "median",
+  "quantile",
+  "min",
+  "max",
+  "count_distinct",
+  "approx_count_distinct",
+  "mode",
+  "first",
+  "last"
+];
+var WINDOW_FN_NAMES = [
+  "row_number",
+  "rank",
+  "dense_rank",
+  "percent_rank",
+  "cume_dist",
+  "ntile",
+  "lag",
+  "lead",
+  "first_value",
+  "last_value",
+  "nth_value"
+];
+var WINDOW_FRAME_MODES = ["rows", "range", "groups"];
+var WINDOW_FRAME_EXCLUDES = ["no-others", "current-row", "group", "ties"];
+var WINDOW_FRAME_BOUND_KINDS = [
+  "unbounded-preceding",
+  "preceding",
+  "current-row",
+  "following",
+  "unbounded-following"
+];
 function parseJsonQuery(input) {
   if (!isRecord(input))
     throwParse("JSON query must be an object");
@@ -9223,6 +9265,10 @@ function parseJsonQuery(input) {
   }
   if (input.where !== void 0)
     init.where = parseJsonExpr(input.where);
+  if (input.windows !== void 0)
+    init.windows = parseJsonWindows(input.windows);
+  if (input.qualify !== void 0)
+    init.qualify = parseJsonExpr(input.qualify);
   if (input.distinct !== void 0) {
     if (typeof input.distinct !== "boolean")
       throwParse("JSON query distinct must be a boolean");
@@ -9262,6 +9308,8 @@ function parseJsonOrderByTerm(input) {
 function parseJsonExpr(input) {
   if (!isRecord(input))
     throwParse("JSON expression must be an object");
+  if (typeof input.kind === "string")
+    return parseJsonExprAst(input);
   const entries = Object.entries(input);
   if (entries.length !== 1)
     throwParse("JSON expression must have exactly one operator");
@@ -9314,6 +9362,213 @@ function parseJsonExpr(input) {
       throwParse(`Unsupported JSON expression operator ${op}`);
   }
 }
+function parseJsonExprAst(input) {
+  switch (input.kind) {
+    case "literal":
+      return { kind: "literal", value: requireScalar(input.value, "literal") };
+    case "column":
+      if (typeof input.name !== "string")
+        throwParse("column expression name must be a string");
+      return { kind: "column", name: input.name };
+    case "compare": {
+      if (!isCompareOp(input.op))
+        throwParse("compare expression op must be eq, ne, lt, lte, gt, or gte");
+      return {
+        kind: "compare",
+        op: input.op,
+        left: parseJsonExpr(input.left),
+        right: parseJsonExpr(input.right)
+      };
+    }
+    case "in": {
+      if (typeof input.negated !== "boolean")
+        throwParse("in expression negated must be a boolean");
+      if (!Array.isArray(input.values))
+        throwParse("in expression values must be an array");
+      return {
+        kind: "in",
+        negated: input.negated,
+        target: parseJsonExpr(input.target),
+        values: input.values.map(parseJsonExpr)
+      };
+    }
+    case "between":
+      return {
+        kind: "between",
+        target: parseJsonExpr(input.target),
+        low: parseJsonExpr(input.low),
+        high: parseJsonExpr(input.high)
+      };
+    case "null-check":
+      if (typeof input.negated !== "boolean") {
+        throwParse("null-check expression negated must be a boolean");
+      }
+      return { kind: "null-check", negated: input.negated, target: parseJsonExpr(input.target) };
+    case "logical": {
+      if (input.op !== "and" && input.op !== "or") {
+        throwParse("logical expression op must be and or or");
+      }
+      if (!Array.isArray(input.operands))
+        throwParse("logical expression operands must be an array");
+      if (input.operands.length < 2) {
+        throwParse("logical expression operands must include at least two expressions");
+      }
+      return { kind: "logical", op: input.op, operands: input.operands.map(parseJsonExpr) };
+    }
+    case "not":
+      return { kind: "not", operand: parseJsonExpr(input.operand) };
+    case "like":
+      if (typeof input.caseInsensitive !== "boolean") {
+        throwParse("like expression caseInsensitive must be a boolean");
+      }
+      if (typeof input.pattern !== "string")
+        throwParse("like expression pattern must be a string");
+      return {
+        kind: "like",
+        caseInsensitive: input.caseInsensitive,
+        target: parseJsonExpr(input.target),
+        pattern: input.pattern
+      };
+    case "call":
+      if (typeof input.fn !== "string")
+        throwParse("call expression fn must be a string");
+      if (!Array.isArray(input.args))
+        throwParse("call expression args must be an array");
+      return { kind: "call", fn: input.fn, args: input.args.map(parseJsonExpr) };
+    case "arithmetic":
+      if (!isArithmeticOp(input.op))
+        throwParse("arithmetic expression op is invalid");
+      return {
+        kind: "arithmetic",
+        op: input.op,
+        left: parseJsonExpr(input.left),
+        right: parseJsonExpr(input.right)
+      };
+    case "case": {
+      if (!Array.isArray(input.whens))
+        throwParse("case expression whens must be an array");
+      return {
+        kind: "case",
+        whens: input.whens.map((when) => {
+          if (!isRecord(when))
+            throwParse("case expression whens must be objects");
+          return { when: parseJsonExpr(when.when), value: parseJsonExpr(when.value) };
+        }),
+        ...input.else === void 0 ? {} : { else: parseJsonExpr(input.else) }
+      };
+    }
+    default:
+      throwParse(`Unsupported JSON expression kind ${String(input.kind)}`);
+  }
+}
+function parseJsonWindows(input) {
+  if (!isRecord(input))
+    throwParse("JSON query windows must be an object");
+  const windows = {};
+  for (const [alias, value2] of Object.entries(input)) {
+    if (alias.length === 0 || isPrototypeMutationKey2(alias)) {
+      throwParse("JSON query window aliases must be valid object keys");
+    }
+    windows[alias] = parseJsonWindowExpr(value2);
+  }
+  return windows;
+}
+function parseJsonWindowExpr(input) {
+  if (!isRecord(input))
+    throwParse("JSON window expression must be an object");
+  const over = input.over;
+  if (!isRecord(over))
+    throwParse("JSON window expression over must be an object");
+  if (!Array.isArray(input.args))
+    throwParse("JSON window expression args must be an array");
+  const expr = {
+    fn: parseJsonWindowFn(input.fn),
+    args: input.args.map(parseJsonExpr),
+    over: {
+      partitionBy: parseExprArray(over.partitionBy, "JSON window partitionBy"),
+      orderBy: parseJsonWindowOrderBy(over.orderBy),
+      ...over.frame === void 0 ? {} : { frame: parseJsonWindowFrame(over.frame) }
+    }
+  };
+  if (input.filter !== void 0)
+    expr.filter = parseJsonExpr(input.filter);
+  if (input.ignoreNulls !== void 0) {
+    if (typeof input.ignoreNulls !== "boolean") {
+      throwParse("JSON window expression ignoreNulls must be a boolean");
+    }
+    expr.ignoreNulls = input.ignoreNulls;
+  }
+  if (input.distinct !== void 0) {
+    if (typeof input.distinct !== "boolean") {
+      throwParse("JSON window expression distinct must be a boolean");
+    }
+    expr.distinct = input.distinct;
+  }
+  return expr;
+}
+function parseJsonWindowFn(input) {
+  if (isWindowFnName(input))
+    return input;
+  if (isRecord(input) && isAggregateOp(input.aggregate))
+    return { aggregate: input.aggregate };
+  throwParse("JSON window function is invalid");
+}
+function parseJsonWindowOrderBy(input) {
+  if (input === void 0)
+    return [];
+  if (!Array.isArray(input))
+    throwParse("JSON window orderBy must be an array");
+  return input.map((term) => {
+    if (!isRecord(term))
+      throwParse("JSON window orderBy terms must be objects");
+    const out = { expr: parseJsonExpr(term.expr) };
+    if (term.direction !== void 0) {
+      if (term.direction !== "asc" && term.direction !== "desc") {
+        throwParse("JSON window orderBy direction must be asc or desc");
+      }
+      out.direction = term.direction;
+    }
+    if (term.nulls !== void 0) {
+      if (term.nulls !== "first" && term.nulls !== "last") {
+        throwParse("JSON window orderBy nulls must be first or last");
+      }
+      out.nulls = term.nulls;
+    }
+    return out;
+  });
+}
+function parseJsonWindowFrame(input) {
+  if (!isRecord(input))
+    throwParse("JSON window frame must be an object");
+  if (!isOneOf(WINDOW_FRAME_MODES, input.mode)) {
+    throwParse("JSON window frame mode must be rows, range, or groups");
+  }
+  if (!isOneOf(WINDOW_FRAME_EXCLUDES, input.exclude))
+    throwParse("JSON window frame exclude is invalid");
+  return {
+    mode: input.mode,
+    start: parseJsonWindowFrameBound(input.start),
+    end: parseJsonWindowFrameBound(input.end),
+    exclude: input.exclude
+  };
+}
+function parseJsonWindowFrameBound(input) {
+  if (!isRecord(input))
+    throwParse("JSON window frame bound must be an object");
+  if (!isOneOf(WINDOW_FRAME_BOUND_KINDS, input.kind))
+    throwParse("JSON window frame bound kind is invalid");
+  return {
+    kind: input.kind,
+    ...input.offset === void 0 ? {} : { offset: parseJsonExpr(input.offset) }
+  };
+}
+function parseExprArray(input, field) {
+  if (input === void 0)
+    return [];
+  if (!Array.isArray(input))
+    throwParse(`${field} must be an array`);
+  return input.map(parseJsonExpr);
+}
 function tuple2(value2, op, cb) {
   const tuple = requireTuple(value2, op, 2);
   return cb(requireColumn(tuple[0], op), requireScalar(tuple[1], op));
@@ -9351,6 +9606,24 @@ function requireScalar(value2, op) {
   }
   throwParse(`${op} value must be a scalar`);
 }
+function isCompareOp(value2) {
+  return isOneOf(COMPARE_OPS, value2);
+}
+function isArithmeticOp(value2) {
+  return isOneOf(ARITHMETIC_OPS, value2);
+}
+function isAggregateOp(value2) {
+  return isOneOf(AGGREGATE_OPS, value2);
+}
+function isWindowFnName(value2) {
+  return isOneOf(WINDOW_FN_NAMES, value2);
+}
+function isPrototypeMutationKey2(value2) {
+  return value2 === "__proto__" || value2 === "prototype" || value2 === "constructor";
+}
+function isOneOf(values, value2) {
+  return typeof value2 === "string" && values.includes(value2);
+}
 function parseNonNegativeInt(value2, field) {
   if (typeof value2 !== "number" || !Number.isInteger(value2) || value2 < 0) {
     throwParse(`${field} must be a non-negative integer`);
@@ -12744,7 +13017,7 @@ var QueryResult = class {
     if (config.scanner.scanColumns === void 0)
       return void 0;
     const state = createVectorGroupByState(groupColumns, spec);
-    for await (const batch of this.columnBatches(aggregateReadColumns(groupColumns, spec, config.where), startedAt, columnarBatchSize(config.batchSize))) {
+    for await (const batch of this.columnBatches(aggregateReadColumns(groupColumns, spec, config.where, config.projections), startedAt, columnarBatchSize(config.batchSize))) {
       const selection = predicateSelection(batch, config.where);
       this.stats.rowsMatched += updateVectorGroupByState(state, batch, selection, {
         budget: config.budget,
@@ -12892,9 +13165,10 @@ var QueryResult = class {
     ]);
     const groups = await aggregateGroupsFromState(groupColumns, spec, options);
     const startedAt = this.config.now();
-    const readColumns = aggregateReadColumns(groupColumns, spec, this.config.where);
+    const readColumns = aggregateReadColumns(groupColumns, spec, this.config.where, this.config.projections);
     for await (const row of this.matchedRows(startedAt, readColumns)) {
-      const keyValues = groupColumns.map((column) => valueForColumn(row, column));
+      const aggregateRow = this.config.projections === void 0 ? row : project(row, ["*"], this.config.projections);
+      const keyValues = groupColumns.map((column) => valueForColumn(aggregateRow, column));
       const key = stableStringify(keyValues);
       let group = groups.get(key);
       if (!group) {
@@ -12904,7 +13178,7 @@ var QueryResult = class {
         group = createAggregateGroup(groupColumns, keyValues, spec);
         groups.set(key, group);
       }
-      group.add(row);
+      group.add(aggregateRow);
       enforceBufferedRowsBudget(this.config.budget, estimateAggregateBufferedRows(groups));
       enforceOperatorMemoryBudget(this.config.budget, estimateAggregateOperatorMemoryBytes(groupColumns, spec, groups));
     }
@@ -14480,10 +14754,15 @@ async function* rowsAsBatches(rows, batchSize) {
     yield rows.slice(index, index + batchSize);
   }
 }
-function aggregateReadColumns(groupColumns, spec, where) {
+function aggregateReadColumns(groupColumns, spec, where, projections) {
   const columns = /* @__PURE__ */ new Set();
-  for (const column of groupColumns)
-    columns.add(column);
+  for (const column of groupColumns) {
+    const projection = projections?.[column];
+    if (projection === void 0)
+      columns.add(column);
+    else
+      collectExprColumns(projection, columns);
+  }
   for (const aggregate of Object.values(spec)) {
     if (aggregate.column !== void 0)
       columns.add(aggregate.column);
@@ -14955,6 +15234,20 @@ async function lookupJoin(left, lookup, options) {
   }
   return out;
 }
+async function crossJoin(left, right, options) {
+  validateCrossJoinOptions(options);
+  const rightRows = await collectRightRows(right, options.maxRightRows);
+  const out = [];
+  for await (const leftRow of left) {
+    for (const rightRow of rightRows) {
+      if (out.length >= options.maxOutputRows) {
+        enforceMaxOutputRows(out.length + 1, options.maxOutputRows);
+      }
+      out.push(mergeCrossRows(leftRow, rightRow, options.rightPrefix));
+    }
+  }
+  return out;
+}
 async function collectRightRows(rows, maxRightRows) {
   const out = [];
   for await (const row of rows) {
@@ -14965,6 +15258,14 @@ async function collectRightRows(rows, maxRightRows) {
   }
   return out;
 }
+function validateCrossJoinOptions(options) {
+  if (!Number.isInteger(options.maxRightRows) || options.maxRightRows < 1) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Cross join maxRightRows must be a positive integer");
+  }
+  if (!Number.isInteger(options.maxOutputRows) || options.maxOutputRows < 1) {
+    throw new LakeqlError("LAKEQL_TYPE_ERROR", "Cross join maxOutputRows must be a positive integer");
+  }
+}
 function validateJoinOptions(options, strategy) {
   const leftKeys = normalizeJoinKeys(options.leftKey, "leftKey", strategy);
   const rightKeys = normalizeJoinKeys(options.rightKey, "rightKey", strategy);
@@ -15028,11 +15329,24 @@ function mergeRows(left, right, options) {
   }
   return out;
 }
+function mergeCrossRows(left, right, rightPrefix = "right.") {
+  const out = { ...left };
+  for (const [key, value2] of Object.entries(right)) {
+    const outKey = key in out ? `${rightPrefix}${key}` : key;
+    out[outKey] = value2;
+  }
+  return out;
+}
 function enforceMaxRightRows(strategy, actual, limit) {
   if (actual <= limit)
     return;
   throw new LakeqlError("LAKEQL_BUDGET_EXCEEDED", `${strategy} join exceeded maxRightRows (${actual} > ${limit})`, { metric: "maxRightRows", limit, actual });
 }
+function enforceMaxOutputRows(actual, limit) {
+  if (actual <= limit)
+    return;
+  throw new LakeqlError("LAKEQL_BUDGET_EXCEEDED", `Cross join exceeded maxOutputRows (${actual} > ${limit})`, { metric: "maxOutputRows", limit, actual });
+}
 
 // ../core/dist/memory-store.js
 async function collect(body) {
@@ -19757,6 +20071,7 @@ function parseSql(sql, options = {}) {
   if (sql.length > MAX_SQL_LENGTH) {
     throwParse2(`SQL input length exceeds ${MAX_SQL_LENGTH}`);
   }
+  rejectRecursiveCte(sql);
   const windowPrepass = extractWindowFrames(sql);
   const prepass = extractTopLevelQualify(windowPrepass.sql);
   let statements;
@@ -19781,6 +20096,18 @@ function parseSql(sql, options = {}) {
     throwUnsupported("Only SELECT statements are supported");
   return selectStatementToAst(statement, context, context.qualifySql);
 }
+function rejectRecursiveCte(sql) {
+  const withIndex = findTopLevelKeyword(sql, "with", 0);
+  if (withIndex === -1)
+    return;
+  const recursiveIndex = findTopLevelKeyword(sql, "recursive", withIndex + "with".length);
+  if (recursiveIndex === -1)
+    return;
+  const between2 = sql.slice(withIndex + "with".length, recursiveIndex);
+  if (between2.trim().length > 0)
+    return;
+  throwUnsupported("Recursive CTEs are not supported");
+}
 function parseSqlStatement(sql, options = {}) {
   const describe = parseDescribeStatement(sql);
   if (describe !== void 0)
@@ -19811,28 +20138,27 @@ function withStatementToAst(statement, context) {
   const binding = asNode(bindings[0], "CTE binding");
   const name = nameNodeToString(binding.alias);
   const inner = asNode(binding.statement, "CTE statement");
-  if (inner.type !== "select")
+  if (inner.type !== "select" && inner.type !== "with") {
     throwUnsupported("Only SELECT CTEs are supported");
-  const cteQuery = selectStatementToAst(inner, context);
-  validateCteQuery(cteQuery);
+  }
+  const cteQuery = inner.type === "with" ? withStatementToAst(inner, context) : selectStatementToAst(inner, context);
   const outer = asNode(statement.in, "CTE outer query");
   if (outer.type !== "select")
     throwUnsupported("Only SELECT after WITH is supported");
   const ast = selectStatementToAst(outer, context, context.qualifySql);
+  if (ast.cte !== void 0)
+    throwUnsupported("WITH queries cannot also use derived tables");
   ast.cte = { name, query: cteQuery };
   return ast;
 }
-function validateCteQuery(ast) {
-  if (ast.join !== void 0 || ast.subqueryJoin !== void 0 || ast.scalarSubqueries !== void 0 || ast.cte !== void 0) {
-    throwUnsupported("Nested CTE joins and subqueries are not supported");
-  }
-}
 function selectStatementToAst(statement, context = newSqlParseContext(), qualifySql) {
   const previousWindows = context.windows;
   const previousNextWindowId = context.nextWindowId;
+  const previousNextHavingAggregateId = context.nextHavingAggregateId;
   const previousQualifySql = context.qualifySql;
   context.windows = {};
   context.nextWindowId = 0;
+  context.nextHavingAggregateId = 0;
   if (qualifySql === void 0)
     delete context.qualifySql;
   else
@@ -19840,6 +20166,7 @@ function selectStatementToAst(statement, context = newSqlParseContext(), qualify
   const ast = selectStatementToAstInScope(statement, context);
   context.windows = previousWindows;
   context.nextWindowId = previousNextWindowId;
+  context.nextHavingAggregateId = previousNextHavingAggregateId;
   if (previousQualifySql === void 0)
     delete context.qualifySql;
   else
@@ -19850,16 +20177,28 @@ function selectStatementToAstInScope(statement, context) {
   rejectPresent(statement, "with", "CTEs are not supported");
   rejectPresent(statement, "windows", "Window functions are not supported");
   const from = optionalArray(statement.from);
-  if (from.length !== 1 && from.length !== 2) {
-    throwUnsupported("SELECT must have exactly one FROM table or one bounded JOIN");
+  if (from.length < 1) {
+    throwUnsupported("SELECT must have a FROM table");
   }
-  const leftSource = sourceTable(from[0]);
+  const leftSource = sourceTable(from[0], context);
   const ast = { source: leftSource.source };
+  if (leftSource.cte !== void 0)
+    ast.cte = leftSource.cte;
   const scope = new SqlScope(leftSource);
-  if (from.length === 2) {
-    const join = joinToAst(from[1], leftSource);
-    ast.join = join;
-    scope.add({ source: join.source, alias: join.alias });
+  const joinedSources = [leftSource];
+  const joins = [];
+  for (const source of from.slice(1)) {
+    const { join, right } = joinToAst(source, joinedSources);
+    joins.push(join);
+    joinedSources.push(right);
+    scope.add(right);
+  }
+  if (joins.length > 0) {
+    const firstJoin = joins[0];
+    if (firstJoin === void 0)
+      throwUnsupported("JOIN chain must contain at least one join");
+    ast.join = firstJoin;
+    ast.joins = joins;
   }
   if (statement.distinct !== void 0) {
     if (statement.distinct !== "distinct") {
@@ -19874,6 +20213,7 @@ function selectStatementToAstInScope(statement, context) {
   const projections = {};
   const aggregates = {};
   const outputAliases = /* @__PURE__ */ new Set();
+  const hiddenAggregates = /* @__PURE__ */ new Set();
   for (const column of columns) {
     const item = asNode(column, "select item");
     const expr = asNode(item.expr, "select expression");
@@ -19924,17 +20264,25 @@ function selectStatementToAstInScope(statement, context) {
     const where = whereToAst(asNode(statement.where, "WHERE"), scope, context);
     if (where.where !== void 0)
       ast.where = where.where;
-    if (where.subqueryJoin !== void 0)
-      ast.subqueryJoin = where.subqueryJoin;
+    if (where.subqueryJoins !== void 0) {
+      ast.subqueryJoins = where.subqueryJoins;
+      const firstSubqueryJoin = where.subqueryJoins[0];
+      if (firstSubqueryJoin !== void 0)
+        ast.subqueryJoin = firstSubqueryJoin;
+    }
   }
   if (statement.groupBy !== void 0) {
     ast.groupBy = optionalArray(statement.groupBy).map((expr) => scope.refName(asNode(expr, "GROUP BY expression")));
   }
   if (statement.having !== void 0) {
-    ast.having = exprToLakeql(asNode(statement.having, "HAVING"), scope, context);
+    ast.having = havingToExpr(asNode(statement.having, "HAVING"), scope, context, aggregates, hiddenAggregates, outputAliases);
+    if (Object.keys(aggregates).length > 0)
+      ast.aggregates = aggregates;
+    if (hiddenAggregates.size > 0)
+      ast.hiddenAggregates = [...hiddenAggregates];
   }
   if (context.qualifySql !== void 0) {
-    ast.qualify = qualifyToExpr(context.qualifySql, scope, context);
+    ast.qualify = expandProjectionAliasesInExpr(qualifyToExpr(context.qualifySql, scope, context), projections, context.windows);
   }
   if (Object.keys(context.windows).length > 0)
     ast.windows = context.windows;
@@ -19952,6 +20300,9 @@ function selectStatementToAstInScope(statement, context) {
   if (Object.keys(context.scalarSubqueries).length > 0) {
     ast.scalarSubqueries = context.scalarSubqueries;
   }
+  if (Object.keys(context.correlatedScalarSubqueries).length > 0) {
+    ast.correlatedScalarSubqueries = context.correlatedScalarSubqueries;
+  }
   return ast;
 }
 function qualifyToExpr(sql, scope, context) {
@@ -19967,12 +20318,106 @@ function qualifyToExpr(sql, scope, context) {
   const where = asNode(statement.where, "QUALIFY predicate");
   return exprToLakeql(where, scope, context);
 }
+function expandProjectionAliasesInExpr(expr, projections, windows) {
+  switch (expr.kind) {
+    case "column":
+      return expr.name in windows ? expr : projections[expr.name] ?? expr;
+    case "compare":
+      return {
+        ...expr,
+        left: expandProjectionAliasesInExpr(expr.left, projections, windows),
+        right: expandProjectionAliasesInExpr(expr.right, projections, windows)
+      };
+    case "between":
+      return {
+        ...expr,
+        target: expandProjectionAliasesInExpr(expr.target, projections, windows),
+        low: expandProjectionAliasesInExpr(expr.low, projections, windows),
+        high: expandProjectionAliasesInExpr(expr.high, projections, windows)
+      };
+    case "in":
+      return {
+        ...expr,
+        target: expandProjectionAliasesInExpr(expr.target, projections, windows),
+        values: expr.values.map((value2) => expandProjectionAliasesInExpr(value2, projections, windows))
+      };
+    case "null-check":
+      return { ...expr, target: expandProjectionAliasesInExpr(expr.target, projections, windows) };
+    case "logical":
+      return {
+        ...expr,
+        operands: expr.operands.map((operand) => expandProjectionAliasesInExpr(operand, projections, windows))
+      };
+    case "not":
+      return {
+        ...expr,
+        operand: expandProjectionAliasesInExpr(expr.operand, projections, windows)
+      };
+    case "like":
+      return { ...expr, target: expandProjectionAliasesInExpr(expr.target, projections, windows) };
+    case "call":
+      return {
+        ...expr,
+        args: expr.args.map((arg) => expandProjectionAliasesInExpr(arg, projections, windows))
+      };
+    case "arithmetic":
+      return {
+        ...expr,
+        left: expandProjectionAliasesInExpr(expr.left, projections, windows),
+        right: expandProjectionAliasesInExpr(expr.right, projections, windows)
+      };
+    case "case":
+      return {
+        ...expr,
+        whens: expr.whens.map((branch) => ({
+          when: expandProjectionAliasesInExpr(branch.when, projections, windows),
+          value: expandProjectionAliasesInExpr(branch.value, projections, windows)
+        })),
+        ...expr.else === void 0 ? {} : { else: expandProjectionAliasesInExpr(expr.else, projections, windows) }
+      };
+    case "literal":
+      return expr;
+  }
+}
+function havingToExpr(expr, scope, context, aggregates, hiddenAggregates, outputAliases) {
+  const previous = context.havingAggregates;
+  context.havingAggregates = { aggregates, hiddenAggregates, outputAliases };
+  try {
+    return exprToLakeql(expr, scope, context);
+  } finally {
+    if (previous === void 0)
+      delete context.havingAggregates;
+    else
+      context.havingAggregates = previous;
+  }
+}
+function registerHavingAggregate(expr, scope, context) {
+  const havingAggregates = context.havingAggregates;
+  if (havingAggregates === void 0)
+    throwUnsupported("HAVING aggregate context is missing");
+  const spec = aggregateCallToSpec(expr, scope, context);
+  for (const [alias2, aggregate] of Object.entries(havingAggregates.aggregates)) {
+    if (JSON.stringify(aggregate) === JSON.stringify(spec))
+      return alias2;
+  }
+  let alias = `__lakeql_having_${context.nextHavingAggregateId}`;
+  context.nextHavingAggregateId += 1;
+  while (havingAggregates.outputAliases.has(alias) || havingAggregates.aggregates[alias] !== void 0) {
+    alias = `__lakeql_having_${context.nextHavingAggregateId}`;
+    context.nextHavingAggregateId += 1;
+  }
+  havingAggregates.aggregates[alias] = spec;
+  havingAggregates.hiddenAggregates.add(alias);
+  return alias;
+}
 function newSqlParseContext(options = {}) {
   return {
     scalarSubqueries: {},
+    correlatedScalarSubqueries: {},
     nextScalarSubqueryId: 0,
     windows: {},
     nextWindowId: 0,
+    nextHavingAggregateId: 0,
     windowFrames: [],
     nextWindowFrameId: 0,
     ...options.parameters === void 0 ? {} : { parameters: options.parameters }
@@ -20000,13 +20445,19 @@ function exprToLakeql(expr, scope = SqlScope.empty(), context = newSqlParseConte
     case "case":
       return caseToExpr(expr, scope, context);
     case "select":
-      return scalarSubqueryToExpr(expr, context);
+      return scalarSubqueryToExpr(expr, scope, context);
     case "cast":
       return castToExpr(expr, scope, context);
     case "call":
+      if (context.havingAggregates !== void 0 && isAggregateCall(expr)) {
+        return { kind: "column", name: registerHavingAggregate(expr, scope, context) };
+      }
       if ("over" in expr && expr.over !== void 0) {
         return { kind: "column", name: registerSyntheticWindow(expr, scope, context) };
       }
+      if (functionName(expr.function) === "exists") {
+        return existsSubqueryToExpr(expr, context);
+      }
       return {
         kind: "call",
         fn: functionName(expr.function),
@@ -20070,17 +20521,15 @@ function binaryToExpr(expr, scope = SqlScope.empty(), context = newSqlParseConte
 }
 function whereToAst(expr, scope, context) {
   const predicates = flattenWhereConjuncts(expr);
-  let subqueryJoin;
+  const subqueryJoins = [];
   const residual = [];
   for (const predicate of predicates) {
-    const extracted = maybeSubqueryJoin(predicate, scope);
+    const extracted = maybeSubqueryJoin(predicate, scope, context);
     if (extracted === void 0) {
       residual.push(predicate);
       continue;
     }
-    if (subqueryJoin !== void 0)
-      throwUnsupported("Only one IN subquery is supported");
-    subqueryJoin = extracted;
+    subqueryJoins.push(extracted);
   }
   const out = {};
   if (residual.length === 1)
@@ -20092,35 +20541,159 @@ function whereToAst(expr, scope, context) {
       operands: residual.map((predicate) => exprToLakeql(predicate, scope, context))
     };
   }
-  if (subqueryJoin !== void 0)
-    out.subqueryJoin = subqueryJoin;
+  if (subqueryJoins.length > 0)
+    out.subqueryJoins = subqueryJoins;
   return out;
 }
-function maybeSubqueryJoin(expr, scope) {
-  if (expr.type !== "binary")
+function maybeSubqueryJoin(expr, scope, context) {
+  if (expr.type === "binary") {
+    const scalarAggregateJoin = scalarAggregatePredicateSubqueryJoinToAst(expr, scope, context);
+    if (scalarAggregateJoin !== void 0)
+      return scalarAggregateJoin;
+    const op = String(expr.op).toUpperCase();
+    if (op !== "IN" && op !== "NOT IN")
+      return void 0;
+    const right = asNode(expr.right, "IN right side");
+    if (right.type !== "select")
+      return void 0;
+    return subqueryJoinToAst(asNode(expr.left, "IN left side"), right, scope, op === "NOT IN", context);
+  }
+  const exists = existsCallFromPredicate(expr);
+  if (exists === void 0)
     return void 0;
+  return existsSubqueryJoinToAst(exists.call, scope, exists.negated, context);
+}
+function scalarAggregatePredicateSubqueryJoinToAst(expr, outerScope, context) {
   const op = String(expr.op).toUpperCase();
-  if (op !== "IN" && op !== "NOT IN")
+  if (!["=", "!=", "<>", "<", "<=", ">", ">="].includes(op))
+    return void 0;
+  const left = asNode(expr.left, "scalar aggregate predicate left side");
+  const right = asNode(expr.right, "scalar aggregate predicate right side");
+  const scalarSide = left.type === "select" && right.type !== "select" ? { subquery: left, other: right, subqueryOnLeft: true } : right.type === "select" && left.type !== "select" ? { subquery: right, other: left, subqueryOnLeft: false } : void 0;
+  if (scalarSide === void 0)
+    return void 0;
+  const scalar = scalarAggregateSubqueryToAst(scalarSide.subquery, outerScope, context);
+  if (scalar === void 0)
+    return void 0;
+  const subqueryScope = new SqlScope({
+    source: scalar.source,
+    alias: scalar.alias ?? scalar.source
+  });
+  const aggregate = scalar.aggregates[scalar.column];
+  if (aggregate === void 0)
+    throwUnsupported("Correlated scalar aggregate is missing output");
+  const alias = scalar.alias;
+  const out = {
+    source: scalar.source,
+    type: "semi",
+    leftKey: scalar.leftKey,
+    rightKey: scalar.rightKey,
+    groupBy: scalar.groupBy,
+    aggregates: scalar.aggregates,
+    ...scalar.hiddenAggregates === void 0 ? {} : { hiddenAggregates: scalar.hiddenAggregates },
+    ...scalar.having === void 0 ? {} : { having: scalar.having },
+    ...scalar.leftAlias === void 0 ? {} : { leftAlias: scalar.leftAlias },
+    ...alias === void 0 ? {} : { alias },
+    ...scalar.where === void 0 ? {} : { where: scalar.where }
+  };
+  const aggregateExpr = {
+    kind: "column",
+    name: alias === void 0 ? scalar.column : `${alias}.${scalar.column}`
+  };
+  const other = exprToLakeql(scalarSide.other, combinedScope(outerScope, subqueryScope), context);
+  out.predicate = {
+    kind: "compare",
+    op: compareOp(op),
+    left: scalarSide.subqueryOnLeft ? aggregateExpr : other,
+    right: scalarSide.subqueryOnLeft ? other : aggregateExpr
+  };
+  return out;
+}
+function scalarAggregateSubqueryToAst(subquery, outerScope, context) {
+  const from = optionalArray(subquery.from);
+  if (from.length !== 1)
+    return void 0;
+  const source = sourceTable(from[0]);
+  const subqueryScope = new SqlScope(source);
+  const aggregate = scalarAggregateSelectItem(subquery, subqueryScope, context);
+  if (aggregate === void 0)
+    return void 0;
+  rejectPresent(subquery, "orderBy", "ORDER BY in correlated scalar aggregate subqueries is not supported");
+  rejectPresent(subquery, "limit", "LIMIT in correlated scalar aggregate subqueries is not supported");
+  const out = {
+    source: source.source,
+    leftKey: [],
+    rightKey: [],
+    groupBy: [],
+    aggregates: { [aggregate.alias]: aggregate.spec },
+    column: aggregate.alias
+  };
+  applyCorrelatedSubqueryWhere(out, subquery, outerScope, subqueryScope, context);
+  if (out.leftKey.length === 0) {
+    if (predicateReferencesOuterScope(subquery, outerScope)) {
+      throwUnsupported("Correlated scalar aggregate subqueries require equality correlation keys");
+    }
     return void 0;
-  const right = asNode(expr.right, "IN right side");
-  if (right.type !== "select")
+  }
+  if (out.predicate !== void 0) {
+    throwUnsupported("Correlated scalar aggregate subqueries with non-equality predicates are not supported");
+  }
+  if (subquery.groupBy !== void 0) {
+    out.groupBy = optionalArray(subquery.groupBy).map((expr) => subqueryScope.refName(asNode(expr, "scalar aggregate subquery GROUP BY expression")));
+    const rightKeys = new Set(out.rightKey);
+    if (out.groupBy.some((column) => !rightKeys.has(column))) {
+      throwUnsupported("Correlated scalar aggregate subqueries can only group by equality correlation keys");
+    }
+  }
+  out.groupBy = appendUnique(out.groupBy ?? [], out.rightKey);
+  if (subquery.having !== void 0) {
+    const aggregates = out.aggregates ?? {};
+    const hiddenAggregates = /* @__PURE__ */ new Set();
+    const outputAliases = /* @__PURE__ */ new Set([...out.groupBy, aggregate.alias]);
+    out.having = havingToExpr(asNode(subquery.having, "scalar aggregate subquery HAVING"), subqueryScope, context, aggregates, hiddenAggregates, outputAliases);
+    if (Object.keys(aggregates).length > 0)
+      out.aggregates = aggregates;
+    if (hiddenAggregates.size > 0)
+      out.hiddenAggregates = [...hiddenAggregates];
+  }
+  const leftAlias = outerScope.primaryAlias();
+  if (leftAlias !== void 0)
+    out.leftAlias = leftAlias;
+  const alias = subqueryScope.primaryAlias();
+  if (alias !== void 0)
+    out.alias = alias;
+  return out;
+}
+function scalarAggregateSelectItem(subquery, scope, context) {
+  const columns = optionalArray(subquery.columns);
+  if (columns.length !== 1) {
+    throwUnsupported("Scalar aggregate subqueries must return exactly one column");
+  }
+  const item = asNode(columns[0], "scalar aggregate subquery select item");
+  const expr = asNode(item.expr, "scalar aggregate subquery select expression");
+  if (expr.type !== "call" || !isAggregateCall(expr))
     return void 0;
-  return subqueryJoinToAst(asNode(expr.left, "IN left side"), right, scope, op === "NOT IN");
+  return {
+    alias: aliasName(item.alias) ?? functionName(expr.function),
+    spec: aggregateCallToSpec(expr, scope, context)
+  };
 }
-function subqueryJoinToAst(left, subquery, outerScope, negated) {
-  rejectPresent(subquery, "groupBy", "Grouped IN subqueries are not supported");
-  rejectPresent(subquery, "having", "HAVING in IN subqueries is not supported");
-  rejectPresent(subquery, "orderBy", "ORDER BY in IN subqueries is not supported");
-  rejectPresent(subquery, "limit", "LIMIT in IN subqueries is not supported");
+function subqueryJoinToAst(left, subquery, outerScope, negated, context) {
   const from = optionalArray(subquery.from);
   if (from.length !== 1)
     throwUnsupported("IN subqueries must select from one table");
   const source = sourceTable(from[0]);
   const subqueryScope = new SqlScope(source);
+  const aggregates = {};
+  const hiddenAggregates = /* @__PURE__ */ new Set();
+  const outputAliases = /* @__PURE__ */ new Set();
   const leftKey = subqueryLeftKeys(left, outerScope);
+  const directLeftKeyCount = leftKey.length;
   const rightKey = optionalArray(subquery.columns).map((column) => {
     const item = asNode(column, "IN subquery select item");
-    return subqueryScope.refName(asNode(item.expr, "IN subquery key"));
+    const key = subqueryScope.refName(asNode(item.expr, "IN subquery key"));
+    ensureUniqueOutputAlias(aliasName(item.alias) ?? key, outputAliases);
+    return key;
   });
   if (leftKey.length !== rightKey.length || leftKey.length === 0) {
     throwUnsupported("IN subquery key counts must match");
@@ -20131,11 +20704,206 @@ function subqueryJoinToAst(left, subquery, outerScope, negated) {
     leftKey,
     rightKey
   };
-  if (subquery.where !== void 0) {
-    out.where = exprToLakeql(asNode(subquery.where, "IN subquery WHERE"), subqueryScope);
+  applyCorrelatedSubqueryWhere(out, subquery, outerScope, subqueryScope, context);
+  if ((subquery.groupBy !== void 0 || subquery.having !== void 0) && out.predicate !== void 0) {
+    throwUnsupported("Correlated grouped IN subqueries with non-equality predicates are not supported");
+  }
+  if (subquery.groupBy !== void 0) {
+    out.groupBy = optionalArray(subquery.groupBy).map((expr) => subqueryScope.refName(asNode(expr, "IN subquery GROUP BY expression")));
+  }
+  if (subquery.groupBy !== void 0 || subquery.having !== void 0) {
+    out.groupBy = appendUnique(out.groupBy ?? [], out.rightKey.slice(directLeftKeyCount));
+  }
+  if (subquery.having !== void 0) {
+    out.having = havingToExpr(asNode(subquery.having, "IN subquery HAVING"), subqueryScope, context, aggregates, hiddenAggregates, outputAliases);
+  }
+  if (Object.keys(aggregates).length > 0)
+    out.aggregates = aggregates;
+  if (hiddenAggregates.size > 0)
+    out.hiddenAggregates = [...hiddenAggregates];
+  if (subquery.orderBy !== void 0) {
+    out.orderBy = optionalArray(subquery.orderBy).map((term) => orderByToTerm(term, subqueryScope));
+  }
+  const limit = subquery.limit;
+  if (limit !== void 0) {
+    const node = asNode(limit, "IN subquery LIMIT");
+    if (node.limit !== void 0)
+      out.limit = nonNegativeInteger(node.limit, "LIMIT", context);
+    if (node.offset !== void 0)
+      out.offset = nonNegativeInteger(node.offset, "OFFSET", context);
+  }
+  return out;
+}
+function existsCallFromPredicate(expr) {
+  if (expr.type === "call" && functionName(expr.function) === "exists") {
+    return { call: expr, negated: false };
+  }
+  if (expr.type !== "unary" || String(expr.op).toUpperCase() !== "NOT")
+    return void 0;
+  const operand = asNode(expr.operand, "NOT operand");
+  if (operand.type !== "call" || functionName(operand.function) !== "exists")
+    return void 0;
+  return { call: operand, negated: true };
+}
+function existsSubqueryJoinToAst(expr, outerScope, negated, context) {
+  const subquery = existsSubquery(expr);
+  rejectPresent(subquery, "orderBy", "ORDER BY in EXISTS subqueries is not supported");
+  rejectPresent(subquery, "limit", "LIMIT in EXISTS subqueries is not supported");
+  const from = optionalArray(subquery.from);
+  if (from.length !== 1)
+    throwUnsupported("EXISTS subqueries must select from one table");
+  const source = sourceTable(from[0]);
+  const subqueryScope = new SqlScope(source);
+  const aggregates = {};
+  const hiddenAggregates = /* @__PURE__ */ new Set();
+  const outputAliases = /* @__PURE__ */ new Set();
+  const out = {
+    source: source.source,
+    type: negated ? "anti" : "semi",
+    leftKey: [],
+    rightKey: []
+  };
+  applyCorrelatedSubqueryWhere(out, subquery, outerScope, subqueryScope, context);
+  if (subquery.groupBy !== void 0 || subquery.having !== void 0) {
+    if (out.predicate !== void 0) {
+      throwUnsupported("Correlated grouped EXISTS subqueries with non-equality predicates are not supported");
+    }
+    if (out.leftKey.length === 0)
+      return void 0;
+    if (subquery.groupBy !== void 0) {
+      out.groupBy = optionalArray(subquery.groupBy).map((expr2) => subqueryScope.refName(asNode(expr2, "EXISTS subquery GROUP BY expression")));
+    }
+    out.groupBy = appendUnique(out.groupBy ?? [], out.rightKey);
+    if (subquery.having !== void 0) {
+      out.having = havingToExpr(asNode(subquery.having, "EXISTS subquery HAVING"), subqueryScope, context, aggregates, hiddenAggregates, outputAliases);
+    }
+    if (Object.keys(aggregates).length > 0)
+      out.aggregates = aggregates;
+    if (hiddenAggregates.size > 0)
+      out.hiddenAggregates = [...hiddenAggregates];
+    return out;
+  }
+  return out.leftKey.length === 0 && out.predicate === void 0 ? void 0 : out;
+}
+function appendUnique(values, additions) {
+  const out = [...values];
+  const seen = new Set(out);
+  for (const value2 of additions) {
+    if (seen.has(value2))
+      continue;
+    seen.add(value2);
+    out.push(value2);
   }
   return out;
 }
+function existsSubquery(expr) {
+  const args = optionalArray(expr.args);
+  if (args.length !== 1)
+    throwUnsupported("EXISTS requires exactly one subquery");
+  const subquery = asNode(args[0], "EXISTS subquery");
+  if (subquery.type !== "select")
+    throwUnsupported("EXISTS requires a SELECT subquery");
+  return subquery;
+}
+function applyCorrelatedSubqueryWhere(out, subquery, outerScope, subqueryScope, context) {
+  if (subquery.where === void 0)
+    return;
+  const residual = [];
+  const correlated = [];
+  for (const predicate of flattenWhereConjuncts(asNode(subquery.where, "subquery WHERE"))) {
+    const pair = correlatedJoinKeyPair(predicate, outerScope, subqueryScope);
+    if (pair === void 0) {
+      if (predicateReferencesOuterScope(predicate, outerScope)) {
+        correlated.push(predicate);
+        continue;
+      }
+      residual.push(predicate);
+      continue;
+    }
+    out.leftKey.push(pair.leftKey);
+    out.rightKey.push(pair.rightKey);
+  }
+  if (correlated.length === 1) {
+    const leftAlias = outerScope.primaryAlias();
+    if (leftAlias !== void 0)
+      out.leftAlias = leftAlias;
+    const alias = subqueryScope.primaryAlias();
+    if (alias !== void 0)
+      out.alias = alias;
+    out.predicate = exprToLakeql(correlated[0], combinedScope(outerScope, subqueryScope), context);
+  } else if (correlated.length > 1) {
+    const leftAlias = outerScope.primaryAlias();
+    if (leftAlias !== void 0)
+      out.leftAlias = leftAlias;
+    const alias = subqueryScope.primaryAlias();
+    if (alias !== void 0)
+      out.alias = alias;
+    out.predicate = {
+      kind: "logical",
+      op: "and",
+      operands: correlated.map((predicate) => exprToLakeql(predicate, combinedScope(outerScope, subqueryScope), context))
+    };
+  }
+  if (residual.length === 1) {
+    out.where = exprToLakeql(residual[0], subqueryScope, context);
+  } else if (residual.length > 1) {
+    out.where = {
+      kind: "logical",
+      op: "and",
+      operands: residual.map((predicate) => exprToLakeql(predicate, subqueryScope, context))
+    };
+  }
+}
+function combinedScope(left, right) {
+  const scope = SqlScope.empty();
+  for (const source of left.sources())
+    scope.add(source);
+  for (const source of right.sources())
+    scope.add(source);
+  return scope;
+}
+function predicateReferencesOuterScope(predicate, outerScope) {
+  let found = false;
+  visitPgRefs(predicate, (ref) => {
+    if (outerScope.qualifiedRefName(ref) !== void 0)
+      found = true;
+  });
+  return found;
+}
+function visitPgRefs(value2, visit) {
+  if (!isRecord4(value2))
+    return;
+  if (value2.type === "ref")
+    visit(value2);
+  for (const child of Object.values(value2)) {
+    if (Array.isArray(child)) {
+      for (const item of child)
+        visitPgRefs(item, visit);
+    } else {
+      visitPgRefs(child, visit);
+    }
+  }
+}
+function isRecord4(value2) {
+  return typeof value2 === "object" && value2 !== null;
+}
+function correlatedJoinKeyPair(predicate, outerScope, subqueryScope) {
+  if (predicate.type !== "binary" || String(predicate.op) !== "=")
+    return void 0;
+  const left = asNode(predicate.left, "correlated left key");
+  const right = asNode(predicate.right, "correlated right key");
+  const leftOuter = outerScope.qualifiedRefName(left);
+  const leftSubquery = subqueryScope.qualifiedRefName(left);
+  const rightOuter = outerScope.qualifiedRefName(right);
+  const rightSubquery = subqueryScope.qualifiedRefName(right);
+  if (leftOuter !== void 0 && rightSubquery !== void 0) {
+    return { leftKey: leftOuter, rightKey: rightSubquery };
+  }
+  if (rightOuter !== void 0 && leftSubquery !== void 0) {
+    return { leftKey: rightOuter, rightKey: leftSubquery };
+  }
+  return void 0;
+}
 function subqueryLeftKeys(expr, scope) {
   if (expr.type === "list") {
     return optionalArray(expr.expressions).map((value2) => scope.refName(asNode(value2, "IN left key")));
@@ -20151,7 +20919,10 @@ function flattenWhereConjuncts(expr) {
   }
   return [expr];
 }
-function scalarSubqueryToExpr(subquery, context) {
+function scalarSubqueryToExpr(subquery, outerScope, context) {
+  const correlated = scalarAggregateSubqueryToAst(subquery, outerScope, context);
+  if (correlated !== void 0)
+    return registerCorrelatedScalarSubquery(correlated, context);
   const query = selectStatementToAst(subquery, context);
   const outputColumns = scalarSubqueryOutputColumns(query);
   if (outputColumns.length !== 1) {
@@ -20160,9 +20931,72 @@ function scalarSubqueryToExpr(subquery, context) {
   if (query.aggregates === void 0 && query.limit !== 1) {
     throwUnsupported("Scalar subqueries must be aggregate queries or use LIMIT 1");
   }
+  return registerScalarSubquery(query, outputColumns[0], context);
+}
+function existsSubqueryToExpr(expr, context) {
+  const subquery = existsSubquery(expr);
+  rejectPresent(subquery, "orderBy", "ORDER BY in EXISTS subqueries is not supported");
+  rejectPresent(subquery, "limit", "LIMIT in EXISTS subqueries is not supported");
+  rejectPresent(subquery, "windows", "Window functions in EXISTS subqueries are not supported");
+  const from = optionalArray(subquery.from);
+  if (from.length !== 1)
+    throwUnsupported("EXISTS subqueries must select from one table");
+  const source = sourceTable(from[0]);
+  if (subquery.groupBy !== void 0 || subquery.having !== void 0) {
+    return registerExistsSubquery(groupedExistsSubqueryToAst(subquery, source, context), context);
+  }
+  const query = {
+    source: source.source,
+    aggregates: { __lakeql_exists_count: { op: "count" } }
+  };
+  if (subquery.where !== void 0) {
+    query.where = exprToLakeql(asNode(subquery.where, "EXISTS subquery WHERE"), new SqlScope(source), context);
+  }
+  const count = registerScalarSubquery(query, "__lakeql_exists_count", context);
+  return { kind: "compare", op: "gt", left: count, right: literal2(0) };
+}
+function groupedExistsSubqueryToAst(subquery, source, context) {
+  const scope = new SqlScope(source);
+  const query = { source: source.source };
+  if (subquery.where !== void 0) {
+    query.where = exprToLakeql(asNode(subquery.where, "EXISTS subquery WHERE"), scope, context);
+  }
+  if (subquery.groupBy !== void 0) {
+    query.groupBy = optionalArray(subquery.groupBy).map((expr) => scope.refName(asNode(expr, "EXISTS subquery GROUP BY expression")));
+    query.select = query.groupBy;
+  }
+  const aggregates = {};
+  const hiddenAggregates = /* @__PURE__ */ new Set();
+  const outputAliases = new Set(query.select ?? []);
+  if (subquery.having !== void 0) {
+    query.having = havingToExpr(asNode(subquery.having, "EXISTS subquery HAVING"), scope, context, aggregates, hiddenAggregates, outputAliases);
+  }
+  if (Object.keys(aggregates).length > 0)
+    query.aggregates = aggregates;
+  if (hiddenAggregates.size > 0)
+    query.hiddenAggregates = [...hiddenAggregates];
+  return query;
+}
+function registerScalarSubquery(query, column, context) {
   const id = `scalar_${context.nextScalarSubqueryId}`;
   context.nextScalarSubqueryId += 1;
-  context.scalarSubqueries[id] = { query, column: outputColumns[0] };
+  context.scalarSubqueries[id] = { query, column };
+  return { kind: "call", fn: "__lakeql_scalar_subquery", args: [{ kind: "literal", value: id }] };
+}
+function registerCorrelatedScalarSubquery(query, context) {
+  const id = `correlated_scalar_${context.nextScalarSubqueryId}`;
+  context.nextScalarSubqueryId += 1;
+  context.correlatedScalarSubqueries[id] = query;
+  return {
+    kind: "call",
+    fn: "__lakeql_correlated_scalar_subquery",
+    args: [{ kind: "literal", value: id }]
+  };
+}
+function registerExistsSubquery(query, context) {
+  const id = `scalar_${context.nextScalarSubqueryId}`;
+  context.nextScalarSubqueryId += 1;
+  context.scalarSubqueries[id] = { query, column: "__lakeql_exists", mode: "exists" };
   return { kind: "call", fn: "__lakeql_scalar_subquery", args: [{ kind: "literal", value: id }] };
 }
 function scalarSubqueryOutputColumns(query) {
@@ -20187,13 +21021,12 @@ function unaryToExpr(expr, scope = SqlScope.empty(), context = newSqlParseContex
   throwUnsupported(`Unsupported unary operator ${op}`);
 }
 function caseToExpr(expr, scope = SqlScope.empty(), context = newSqlParseContext()) {
-  if (expr.value !== null && expr.value !== void 0) {
-    throwUnsupported("Simple CASE expressions are not supported yet");
-  }
+  const caseValue = expr.value === null || expr.value === void 0 ? void 0 : exprToLakeql(asNode(expr.value, "CASE expression"), scope, context);
   const whens = optionalArray(expr.whens).map((branch) => {
     const node = asNode(branch, "CASE branch");
+    const when = exprToLakeql(asNode(node.when, "CASE WHEN expression"), scope, context);
     return {
-      when: exprToLakeql(asNode(node.when, "CASE WHEN expression"), scope, context),
+      when: caseValue === void 0 ? when : { kind: "compare", op: "eq", left: caseValue, right: when },
       value: exprToLakeql(asNode(node.value, "CASE THEN expression"), scope, context)
     };
   });
@@ -20201,8 +21034,71 @@ function caseToExpr(expr, scope = SqlScope.empty(), context = newSqlParseContext
   if (expr.else !== void 0) {
     out.else = exprToLakeql(asNode(expr.else, "CASE ELSE expression"), scope, context);
   }
+  validateCaseResultTypes(out);
   return out;
 }
+function validateCaseResultTypes(expr) {
+  const resultTypes = caseResultTypes(expr);
+  if (resultTypes.size <= 1)
+    return;
+  throwType("CASE result branches must have compatible literal types", {
+    types: [...resultTypes].sort()
+  });
+}
+function caseResultTypes(expr) {
+  const types = /* @__PURE__ */ new Set();
+  for (const branch of expr.whens) {
+    const type = staticExprResultType(branch.value);
+    if (type !== void 0)
+      types.add(type);
+  }
+  if (expr.else !== void 0) {
+    const type = staticExprResultType(expr.else);
+    if (type !== void 0)
+      types.add(type);
+  }
+  return types;
+}
+function staticExprResultType(expr) {
+  switch (expr.kind) {
+    case "literal":
+      return staticScalarType(expr.value);
+    case "compare":
+    case "between":
+    case "in":
+    case "like":
+    case "logical":
+    case "not":
+    case "null-check":
+      return "boolean";
+    case "arithmetic":
+      return "number";
+    case "case": {
+      const resultTypes = caseResultTypes(expr);
+      return resultTypes.size === 1 ? [...resultTypes][0] : void 0;
+    }
+    case "call":
+    case "column":
+      return void 0;
+  }
+}
+function staticScalarType(value2) {
+  if (value2 === null)
+    return void 0;
+  if (value2 instanceof Uint8Array)
+    return "binary";
+  if (isTimestampValue(value2))
+    return "timestamp";
+  if (isIntervalValue(value2))
+    return "interval";
+  if (typeof value2 === "boolean")
+    return "boolean";
+  if (typeof value2 === "bigint")
+    return "bigint";
+  if (typeof value2 === "number")
+    return "number";
+  return "string";
+}
 function ternaryToExpr(expr, scope = SqlScope.empty(), context = newSqlParseContext()) {
   const op = String(expr.op).toUpperCase();
   if (op !== "BETWEEN" && op !== "NOT BETWEEN") {
@@ -20478,7 +21374,7 @@ function isAggregateCall(expr) {
     return false;
   return aggregateOpOrUndefined(functionName(expr.function)) !== void 0;
 }
-function isAggregateOp(op) {
+function isAggregateOp2(op) {
   return [
     "count",
     "sum",
@@ -20529,31 +21425,66 @@ var SqlScope = class _SqlScope {
     this.aliases.set(source.source, source);
     this.aliases.set(source.alias, source);
   }
+  sources() {
+    return [...new Set(this.aliases.values())];
+  }
+  primaryAlias() {
+    return this.sources()[0]?.alias;
+  }
   refName(expr) {
+    const name = this.resolveQualifiedRefName(expr, true);
+    if (name !== void 0)
+      return name;
+    if (expr.type !== "ref" || typeof expr.name !== "string") {
+      throwUnsupported("Only column references are supported here");
+    }
+    const qualifier = expr.table === void 0 ? "" : nameNodeToString(expr.table);
+    throwUnsupported(`Unknown SQL table qualifier ${qualifier}`);
+  }
+  qualifiedRefName(expr) {
+    if (expr.type !== "ref" || typeof expr.name !== "string")
+      return void 0;
+    return this.resolveQualifiedRefName(expr, false);
+  }
+  resolveQualifiedRefName(expr, allowUnqualified) {
     if (expr.type !== "ref" || typeof expr.name !== "string") {
       throwUnsupported("Only column references are supported here");
     }
     if (expr.table === void 0)
-      return expr.name;
+      return allowUnqualified ? expr.name : void 0;
     const qualifier = nameNodeToString(expr.table);
     const source = this.aliases.get(qualifier);
     if (source === void 0)
-      throwUnsupported(`Unknown SQL table qualifier ${qualifier}`);
+      return void 0;
     if (this.aliases.size <= 2)
       return expr.name;
     return `${source.alias}.${expr.name}`;
   }
 };
-function sourceTable(value2) {
+function sourceTable(value2, context) {
   const node = asNode(value2, "FROM item");
   if (node.type === "call")
     return readParquetSourceTable(node);
+  if (node.type === "statement")
+    return derivedSourceTable(node, context);
   if (node.type !== "table")
     throwUnsupported("Only table FROM sources are supported");
   if (node.join !== void 0)
     throwUnsupported("Unexpected JOIN position");
   const source = nameNodeToString(node.name);
-  return { source, alias: aliasName(node.name) ?? source };
+  return { source, alias: aliasName(node.alias) ?? aliasName(node.name) ?? source };
+}
+function derivedSourceTable(node, context) {
+  if (context === void 0)
+    throwUnsupported("Derived tables are not supported here");
+  const alias = aliasName(node.alias);
+  if (alias === void 0)
+    throwUnsupported("Derived tables require an alias");
+  const statement = asNode(node.statement, "derived table SELECT");
+  if (statement.type !== "select")
+    throwUnsupported("Derived tables must be SELECT statements");
+  const query = selectStatementToAst(statement, context);
+  return { source: alias, alias, cte: { name: alias, query } };
 }
 function readParquetSourceTable(node) {
   const functionName2 = nameNodeToString(node.function).toLowerCase();
@@ -20569,74 +21500,120 @@ function readParquetSourceTable(node) {
   }
   return { source: arg.value, alias: aliasName(node.alias) ?? arg.value };
 }
-function joinToAst(value2, left) {
+function joinToAst(value2, joinedSources) {
   const node = asNode(value2, "JOIN source");
   if (node.type !== "table" && node.type !== "call") {
     throwUnsupported("Only table JOIN sources are supported");
   }
-  const join = asNode(node.join, "JOIN");
-  const joinType = String(join.type).toUpperCase();
-  if (joinType !== "INNER JOIN" && joinType !== "LEFT JOIN") {
+  const join = node.join === void 0 ? void 0 : asNode(node.join, "JOIN");
+  const joinType = join === void 0 ? "" : String(join.type).toUpperCase();
+  if (join === void 0 || joinType === "CROSS JOIN") {
+    const right2 = sourceTable({ ...node, join: void 0 });
+    const left2 = joinedSources[0];
+    if (left2 === void 0)
+      throwUnsupported("JOIN requires a left source");
+    return {
+      right: right2,
+      join: {
+        source: right2.source,
+        leftAlias: left2.alias,
+        alias: right2.alias,
+        type: "cross",
+        leftKey: [],
+        rightKey: []
+      }
+    };
+  }
+  if (joinType !== "INNER JOIN" && joinType !== "LEFT JOIN" && joinType !== "RIGHT JOIN" && joinType !== "FULL JOIN") {
     throwUnsupported(`Unsupported JOIN type ${joinType}`);
   }
   const right = sourceTable({ ...node, join: void 0 });
+  const left = joinedSources[0];
+  if (left === void 0)
+    throwUnsupported("JOIN requires a left source");
   if (join.using !== void 0) {
     const using = optionalArray(join.using);
     if (using.length === 0)
       throwUnsupported("JOIN USING requires at least one column");
-    const keys = using.map(nameNodeToString);
+    const keys2 = using.map(nameNodeToString);
     return {
-      source: right.source,
-      leftAlias: left.alias,
-      alias: right.alias,
-      type: joinType === "LEFT JOIN" ? "left" : "inner",
-      leftKey: keys.map((key) => `${left.alias}.${key}`),
-      rightKey: keys.map((key) => `${right.alias}.${key}`)
+      right,
+      join: {
+        source: right.source,
+        leftAlias: left.alias,
+        alias: right.alias,
+        type: sqlJoinType(joinType),
+        leftKey: keys2.map((key) => `${left.alias}.${key}`),
+        rightKey: keys2.map((key) => `${right.alias}.${key}`)
+      }
     };
   }
   const on = asNode(join.on, "JOIN ON");
-  const { leftKey, rightKey } = joinKeysFromPredicate(on, left, right);
+  const keys = joinKeysFromPredicate(on, joinedSources, right);
   return {
-    source: right.source,
-    leftAlias: left.alias,
-    alias: right.alias,
-    type: joinType === "LEFT JOIN" ? "left" : "inner",
-    leftKey,
-    rightKey
+    right,
+    join: {
+      source: right.source,
+      leftAlias: left.alias,
+      alias: right.alias,
+      type: sqlJoinType(joinType),
+      leftKey: keys?.leftKey ?? [],
+      rightKey: keys?.rightKey ?? [],
+      ...keys === void 0 ? { predicate: exprToLakeql(on, joinScope(joinedSources, right)) } : {}
+    }
   };
 }
-function qualifiedJoinKey(expr, left, right) {
-  if (expr.type !== "ref" || typeof expr.name !== "string" || expr.table === void 0) {
-    throwUnsupported("JOIN keys must be qualified column references");
-  }
+function sqlJoinType(joinType) {
+  if (joinType === "LEFT JOIN")
+    return "left";
+  if (joinType === "RIGHT JOIN")
+    return "right";
+  if (joinType === "FULL JOIN")
+    return "full";
+  return "inner";
+}
+function maybeQualifiedJoinKey(expr, joinedSources, right) {
+  if (expr.type !== "ref" || typeof expr.name !== "string" || expr.table === void 0)
+    return void 0;
   const qualifier = nameNodeToString(expr.table);
-  if (qualifier === left.alias || qualifier === left.source)
-    return `${left.alias}.${expr.name}`;
-  if (qualifier === right.alias || qualifier === right.source)
-    return `${right.alias}.${expr.name}`;
-  throwUnsupported(`Unknown JOIN qualifier ${qualifier}`);
+  if (qualifier === right.alias || qualifier === right.source) {
+    return { side: "right", key: `${right.alias}.${expr.name}` };
+  }
+  const left = joinedSources.find((source) => qualifier === source.alias || qualifier === source.source);
+  if (left !== void 0)
+    return { side: "left", key: `${left.alias}.${expr.name}` };
+  return void 0;
 }
-function joinKeysFromPredicate(expr, left, right) {
+function joinKeysFromPredicate(expr, joinedSources, right) {
   const conjuncts2 = flattenJoinConjuncts(expr);
   const leftKey = [];
   const rightKey = [];
   for (const conjunct of conjuncts2) {
-    if (String(conjunct.op) !== "=")
-      throwUnsupported("Only equi-joins are supported");
-    const first = qualifiedJoinKey(asNode(conjunct.left, "JOIN left key"), left, right);
-    const second = qualifiedJoinKey(asNode(conjunct.right, "JOIN right key"), left, right);
-    if (first.startsWith(`${left.alias}.`) && second.startsWith(`${right.alias}.`)) {
-      leftKey.push(first);
-      rightKey.push(second);
-    } else if (second.startsWith(`${left.alias}.`) && first.startsWith(`${right.alias}.`)) {
-      leftKey.push(second);
-      rightKey.push(first);
+    if (conjunct.type !== "binary" || String(conjunct.op) !== "=")
+      return void 0;
+    const first = maybeQualifiedJoinKey(asNode(conjunct.left, "JOIN left key"), joinedSources, right);
+    const second = maybeQualifiedJoinKey(asNode(conjunct.right, "JOIN right key"), joinedSources, right);
+    if (first === void 0 || second === void 0)
+      return void 0;
+    if (first.side === "left" && second.side === "right") {
+      leftKey.push(first.key);
+      rightKey.push(second.key);
+    } else if (second.side === "left" && first.side === "right") {
+      leftKey.push(second.key);
+      rightKey.push(first.key);
     } else {
       throwUnsupported("JOIN ON must compare left table key to right table key");
     }
   }
   return { leftKey, rightKey };
 }
+function joinScope(joinedSources, right) {
+  const scope = SqlScope.empty();
+  for (const source of joinedSources)
+    scope.add(source);
+  scope.add(right);
+  return scope;
+}
 function flattenJoinConjuncts(expr) {
   if (expr.type === "binary" && String(expr.op).toUpperCase() === "AND") {
     return [
@@ -20734,7 +21711,7 @@ function aggregateOp(op) {
   throwUnsupported(`Unsupported aggregate ${op}`);
 }
 function aggregateOpOrUndefined(op) {
-  if (isAggregateOp(op))
+  if (isAggregateOp2(op))
     return op;
   if (op === "var" || op === "variance")
     return "var_samp";
@@ -20800,4 +21777,4 @@ function throwType(message, details) {
   throw new LakeqlError("LAKEQL_TYPE_ERROR", message, details);
 }
 
-export { AggregationBuilder, CacheApiCache, Lake, MemoryCache, MemoryObjectStore, MemorySpillAdapter, ParquetScanAdapter, QueryBuilder, QueryResult, ResumedQuery, SharedMemoryCache, add, aggregateParquetGroupTask, aggregateParquetGroupTasks, aggregateParquetGroupTasksBatch, aggregateParquetTask, aggregateParquetTasks, and, asyncBufferFromStore, batchExprValues, batchFromColumns, batchFromVectors, bboxMayIntersect, between, broadcastJoin, buildBBoxIndex, buildMinMaxIndex, cacheApiCache, cachedObjectStore, classifyPredicate, col, concatBatches, createParquetLake, createParquetTableAs, createVectorAggregateStates, createVectorGroupByState, deserializeAggregateOperatorState, deserializeSortOperatorState, deserializeTopKOperatorState, deserializeWindowOperatorState, div, enforceVectorGroupByBudget, eq, evaluateWindowWorkUnitPartials, fanInWorkUnits, finalizeVectorAggregateStates, finalizeVectorGroupByBatch, finalizeVectorGroupByRows, fn, gatherBatch, getOrCreateVectorGroup, gt, gte, ilike, isIn, isNotNull, isNull, jsonWorkUnitBoundary, like, lit, lookupJoin, lt, lte, materializeBatchRow, materializeBatchRows, materializeSelectedBatchRows, memoryCache, memorySpillAdapter, memoryStore, mergeVectorAggregateStateSnapshots, mergeVectorAggregateStates, mergeVectorGroupByStates, mod, mul, ne, not, notIn, or, parquetScanner, parseHivePartitions, parseJsonQuery, parseSql, parseSqlStatement, partitionWindowWorkUnitRows, partitionedParquetOutputEntries, planParquetTaskWorkUnits, planRowGroups, planRowGroupsFromMetadata, predicateSelection, pruneFilesWithIndex, readControlSignal, readIcebergParquetDeletes, readParquetColumnBatches, readParquetMetadata, readParquetObjectBatches, readParquetObjects, rejectUnsupportedParquetSchema, restoreVectorAggregateStates, restoreVectorGroupByState, rowGroupMayMatch, rowGroupMustMatch, scalarVectorValue, scanParquetTaskBatches, scanParquetTaskColumnBatches, selectedRowCount, selectedRowIndices, serializeAggregateOperatorState, serializeSortOperatorState, serializeTopKOperatorState, serializeWindowOperatorState, snapshotVectorAggregateStates, snapshotVectorGroupByState, sub, throwIfAborted, tryPredicateSelection, updateVectorAggregateStateValue, updateVectorAggregateStates, updateVectorGroupAggregateValue, updateVectorGroupByState, uriObjectStore, vectorAggregateBatch, vectorFromValues, vectorGroupByBatch, vectorLength, vectorOrderByBatch, vectorProjectBatch, vectorSortIndices, vectorTopKBatch, vectorTopKIndices, vectorValue, windowOperatorState, windowOperatorStateFromRuns, windowParquetTask, windowParquetTasks, windowPartitionBucket, windowRowsFromState, withObjectStoreReadControls, writeParquet, writePartitionedParquet, writePartitionedParquetTask };
+export { AggregationBuilder, CacheApiCache, Lake, MemoryCache, MemoryObjectStore, MemorySpillAdapter, ParquetScanAdapter, QueryBuilder, QueryResult, ResumedQuery, SharedMemoryCache, add, aggregateParquetGroupTask, aggregateParquetGroupTasks, aggregateParquetGroupTasksBatch, aggregateParquetTask, aggregateParquetTasks, and, asyncBufferFromStore, batchExprValues, batchFromColumns, batchFromVectors, bboxMayIntersect, between, broadcastJoin, buildBBoxIndex, buildMinMaxIndex, cacheApiCache, cachedObjectStore, classifyPredicate, col, concatBatches, createParquetLake, createParquetTableAs, createVectorAggregateStates, createVectorGroupByState, crossJoin, deserializeAggregateOperatorState, deserializeSortOperatorState, deserializeTopKOperatorState, deserializeWindowOperatorState, div, enforceVectorGroupByBudget, eq, evaluateWindowWorkUnitPartials, fanInWorkUnits, finalizeVectorAggregateStates, finalizeVectorGroupByBatch, finalizeVectorGroupByRows, fn, gatherBatch, getOrCreateVectorGroup, gt, gte, ilike, isIn, isNotNull, isNull, jsonWorkUnitBoundary, like, lit, lookupJoin, lt, lte, materializeBatchRow, materializeBatchRows, materializeSelectedBatchRows, memoryCache, memorySpillAdapter, memoryStore, mergeVectorAggregateStateSnapshots, mergeVectorAggregateStates, mergeVectorGroupByStates, mod, mul, ne, not, notIn, or, parquetScanner, parseHivePartitions, parseJsonQuery, parseSql, parseSqlStatement, partitionWindowWorkUnitRows, partitionedParquetOutputEntries, planParquetTaskWorkUnits, planRowGroups, planRowGroupsFromMetadata, predicateSelection, pruneFilesWithIndex, readControlSignal, readIcebergParquetDeletes, readParquetColumnBatches, readParquetMetadata, readParquetObjectBatches, readParquetObjects, rejectUnsupportedParquetSchema, restoreVectorAggregateStates, restoreVectorGroupByState, rowGroupMayMatch, rowGroupMustMatch, scalarVectorValue, scanParquetTaskBatches, scanParquetTaskColumnBatches, selectedRowCount, selectedRowIndices, serializeAggregateOperatorState, serializeSortOperatorState, serializeTopKOperatorState, serializeWindowOperatorState, snapshotVectorAggregateStates, snapshotVectorGroupByState, sub, throwIfAborted, tryPredicateSelection, updateVectorAggregateStateValue, updateVectorAggregateStates, updateVectorGroupAggregateValue, updateVectorGroupByState, uriObjectStore, vectorAggregateBatch, vectorFromValues, vectorGroupByBatch, vectorLength, vectorOrderByBatch, vectorProjectBatch, vectorSortIndices, vectorTopKBatch, vectorTopKIndices, vectorValue, windowOperatorState, windowOperatorStateFromRuns, windowParquetTask, windowParquetTasks, windowPartitionBucket, windowRowsFromState, withObjectStoreReadControls, writeParquet, writePartitionedParquet, writePartitionedParquetTask };