@dbsp/nql 1.2.0 → 1.3.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { NQL_INTERNAL_COMPILER_OPTIONS } from '@dbsp/types/internal';
+import { NQL_INTERNAL_COMPILER_OPTIONS, isNqlBindingRef, getNqlBindingRefName, createNqlBindingRef } from '@dbsp/types/internal';
 import { NQL_SELECT_AGGREGATE_FUNCTIONS, NQL_SELECT_JSON_FUNCTIONS, NQL_SELECT_SCALAR_FUNCTIONS, isParamIntent, isNqlSelectWindowFunctionAllowed, isRankingWindowFunction } from '@dbsp/types';
 import { createToken, Lexer, CstParser } from 'chevrotain';
 
@@ -216,7 +216,7 @@ function expressionToValue(expr, ctx) {
     case "null":
       return null;
     case "path":
-      return { $ref: expr.segments.join(".") };
+      return createNqlBindingRef(expr.segments.join("."));
     case "function": {
       return {
         $fn: expr.name,
@@ -442,6 +442,285 @@ function coerceToStringKey(expr, contextLabel, ctx) {
   );
 }
 
+// src/compiler/compile-mutation.ts
+function assignMutationValue(target, column, value, ctx) {
+  target[column] = expressionToValue(value, ctx);
+}
+function compileMutationPipeline(pipeline, ctx, fns, bindings) {
+  ctx.currentFromTable = pipeline.mutation.table;
+  const mutation = compileMutation(pipeline.mutation, ctx, fns, bindings);
+  let returning;
+  for (const clause of pipeline.clauses) {
+    if (clause.type === "select") {
+      returning = extractReturningColumns(clause, ctx);
+    }
+  }
+  if (returning) {
+    return {
+      mutation: { ...mutation, returning }
+    };
+  }
+  return { mutation };
+}
+function compileMutation(mutation, ctx, fns, bindings) {
+  switch (mutation.type) {
+    case "insert":
+      return compileInsert(mutation, ctx);
+    case "insert_from":
+      return compileInsertFrom(mutation, ctx, fns, bindings);
+    case "update":
+      return compileUpdate(mutation, ctx, fns, bindings);
+    case "delete":
+      return compileDelete(mutation, ctx, fns, bindings);
+    case "upsert":
+      return compileUpsert(mutation, ctx, fns, bindings);
+    case "upsert_from":
+      return compileUpsertFrom(mutation, ctx, fns, bindings);
+  }
+}
+function compileInsert(insert, ctx) {
+  ctx.validator?.validateTable(insert.table);
+  const allColumns = /* @__PURE__ */ new Set();
+  for (const row of insert.rows) {
+    for (const assignment of row) {
+      ctx.validator?.validateColumn(insert.table, assignment.column);
+      allColumns.add(assignment.column);
+    }
+  }
+  const values = [];
+  for (const row of insert.rows) {
+    const rowValues = {};
+    const rowColumns = /* @__PURE__ */ new Set();
+    for (const assignment of row) {
+      rowColumns.add(assignment.column);
+      assignMutationValue(rowValues, assignment.column, assignment.value, ctx);
+    }
+    for (const col of allColumns) {
+      if (!rowColumns.has(col)) {
+        rowValues[col] = void 0;
+      }
+    }
+    values.push(rowValues);
+  }
+  return {
+    type: "insert",
+    table: insert.table,
+    values
+  };
+}
+function compileInsertFrom(insertFrom, ctx, fns, bindings) {
+  ctx.validator?.validateTable(insertFrom.table);
+  const sourceQuery = bindings?.get(insertFrom.source);
+  if (!sourceQuery) {
+    ctx.validator?.validateTable(insertFrom.source);
+  }
+  ctx.currentFromTable = insertFrom.source;
+  return {
+    type: "insert_from",
+    table: insertFrom.table,
+    source: insertFrom.source,
+    ...sourceQuery !== void 0 && { sourceQuery },
+    /* v8 ignore next — NQL grammar does not produce explicit column lists for INSERT FROM -- @preserve */
+    ...insertFrom.columns !== void 0 && { columns: insertFrom.columns },
+    ...insertFrom.where !== void 0 && {
+      where: fns.compileExpression(insertFrom.where, ctx, fns)
+    },
+    ...insertFrom.limit !== void 0 && {
+      limit: resolveIntegerCount(insertFrom.limit, ctx, "insert-from limit")
+    }
+  };
+}
+function compileUpdate(update, ctx, fns, bindings) {
+  ctx.currentFromTable = update.table;
+  ctx.validator?.validateTable(update.table);
+  const set = {};
+  for (const assignment of update.assignments) {
+    ctx.validator?.validateColumn(update.table, assignment.column);
+    assignMutationValue(set, assignment.column, assignment.value, ctx);
+  }
+  if (update.where) {
+    return {
+      type: "update",
+      table: update.table,
+      set,
+      where: resolveBindingsInWhere(
+        fns.compileExpression(update.where, ctx, fns),
+        bindings
+      )
+    };
+  }
+  if (!ctx.allowUnfilteredMutations) {
+    throw new Error(
+      "update without a where clause would affect all rows; pass { allowUnfilteredMutations: true } to the compiler to allow an unfiltered update"
+    );
+  }
+  return {
+    type: "update",
+    table: update.table,
+    set,
+    allowAll: true
+  };
+}
+function compileDelete(del, ctx, fns, bindings) {
+  ctx.currentFromTable = del.table;
+  ctx.validator?.validateTable(del.table);
+  if (del.where) {
+    return {
+      type: "delete",
+      table: del.table,
+      where: resolveBindingsInWhere(
+        fns.compileExpression(del.where, ctx, fns),
+        bindings
+      )
+    };
+  }
+  if (!ctx.allowUnfilteredMutations) {
+    throw new Error(
+      "delete without a where clause would affect all rows; pass { allowUnfilteredMutations: true } to the compiler to allow an unfiltered delete"
+    );
+  }
+  return {
+    type: "delete",
+    table: del.table,
+    allowAll: true
+  };
+}
+function compileUpsert(upsert, ctx, fns, bindings) {
+  ctx.currentFromTable = upsert.table;
+  ctx.validator?.validateTable(upsert.table);
+  const values = {};
+  for (const assignment of upsert.assignments) {
+    ctx.validator?.validateColumn(upsert.table, assignment.column);
+    assignMutationValue(values, assignment.column, assignment.value, ctx);
+  }
+  for (const col of upsert.conflictColumns) {
+    ctx.validator?.validateColumn(upsert.table, col);
+  }
+  return {
+    type: "upsert",
+    table: upsert.table,
+    values: [values],
+    onConflict: { columns: upsert.conflictColumns },
+    action: {
+      type: "doUpdate",
+      set: values,
+      ...upsert.where !== void 0 && {
+        where: resolveBindingsInWhere(
+          fns.compileExpression(upsert.where, ctx, fns),
+          bindings
+        )
+      }
+    }
+  };
+}
+function compileUpsertFrom(upsertFrom, ctx, fns, bindings) {
+  ctx.validator?.validateTable(upsertFrom.table);
+  const sourceQuery = bindings?.get(upsertFrom.source);
+  if (!sourceQuery) {
+    ctx.validator?.validateTable(upsertFrom.source);
+  }
+  for (const col of upsertFrom.conflictColumns) {
+    ctx.validator?.validateColumn(upsertFrom.table, col);
+  }
+  ctx.currentFromTable = upsertFrom.source;
+  return {
+    type: "upsert_from",
+    table: upsertFrom.table,
+    source: upsertFrom.source,
+    conflictColumns: upsertFrom.conflictColumns,
+    ...sourceQuery !== void 0 && { sourceQuery },
+    /* v8 ignore start — NQL grammar does not produce explicit column lists for UPSERT FROM -- @preserve */
+    ...upsertFrom.columns !== void 0 && {
+      columns: upsertFrom.columns
+    },
+    /* v8 ignore stop -- @preserve */
+    ...upsertFrom.where !== void 0 && {
+      where: fns.compileExpression(upsertFrom.where, ctx, fns)
+    },
+    ...upsertFrom.limit !== void 0 && {
+      limit: resolveIntegerCount(upsertFrom.limit, ctx, "upsert-from limit")
+    }
+  };
+}
+function extractReturningColumns(clause, ctx) {
+  const columns = [];
+  for (const item of clause.items) {
+    if (item.type === "star") {
+      return ["*"];
+    }
+    if (item.type === "expression") {
+      const field = expressionToField(item.expression);
+      if (field) {
+        if (ctx.currentFromTable && !field.includes(".")) {
+          ctx.validator?.validateColumn(ctx.currentFromTable, field);
+        }
+        columns.push(item.alias ?? field);
+      }
+    }
+  }
+  return columns;
+}
+function resolveBindingsInWhere(where, bindings) {
+  if (!bindings || bindings.size === 0) return where;
+  if (where.kind === "in") {
+    const inWhere = where;
+    const inValues = inWhere.subquery ? void 0 : inWhere.values;
+    if (inValues && inValues.length === 1) {
+      const val = inValues[0];
+      if (!isParamIntent(val) && isNqlBindingRef(val)) {
+        const ref = getNqlBindingRefName(val);
+        if (bindings.has(ref)) {
+          const boundQuery = bindings.get(ref);
+          const boundSelect = boundQuery.select;
+          const selectFields = boundSelect && "fields" in boundSelect ? boundSelect.fields : void 0;
+          const cteRef = {
+            type: "select",
+            from: ref,
+            ...selectFields && {
+              select: {
+                type: "fields",
+                fields: selectFields
+              }
+            }
+          };
+          return {
+            kind: "in",
+            field: inWhere.field,
+            subquery: cteRef
+          };
+        }
+      }
+    }
+    return where;
+  }
+  if (where.kind === "not") {
+    const notWhere = where;
+    const resolved = resolveBindingsInWhere(notWhere.condition, bindings);
+    return resolved === notWhere.condition ? where : { kind: "not", condition: resolved };
+  }
+  if (where.kind === "and" || where.kind === "or") {
+    const compound = where;
+    const resolved = compound.conditions.map(
+      (c) => resolveBindingsInWhere(c, bindings)
+    );
+    const changed = resolved.some((r, i) => r !== compound.conditions[i]);
+    return changed ? { kind: compound.kind, conditions: resolved } : where;
+  }
+  return where;
+}
+function extractBindName(stmt) {
+  if (stmt.type === "query") {
+    for (const clause of stmt.clauses) {
+      if (clause.type === "bind") return clause.name;
+    }
+  } else if (stmt.type === "mutationPipeline") {
+    for (const clause of stmt.clauses) {
+      if (clause.type === "bind") return clause.name;
+    }
+  }
+  return void 0;
+}
+
 // src/compiler/include-builder.ts
 function buildNestedIncludes(paths, flatMode) {
   const root = { children: /* @__PURE__ */ new Map() };
@@ -537,10 +816,9 @@ function compileQuery(query, ctx, fns, bindings) {
     const clause = query.clauses[i];
     switch (clause.type) {
       case "where": {
-        const condition = fns.compileExpression(
-          clause.condition,
-          ctx,
-          fns
+        const condition = resolveBindingsInWhere(
+          fns.compileExpression(clause.condition, ctx, fns),
+          bindings
         );
         if (groupByIndex >= 0 && i > groupByIndex) {
           havingConditions.push(condition);
@@ -1298,406 +1576,134 @@ function compileJson(expr, ctx, _fns, aliasContext, outerAliases) {
         kind: "jsonExists",
         field: jsonField2,
         key
-      };
-    }
-    throw new NqlSemanticException(
-      NqlErrorCodes.SEM_INVALID_SYNTAX,
-      `Unsupported function in WHERE context: ${fn}()`
-    );
-  }
-  const jsonComp = expr;
-  const jsonField = expressionToField(jsonComp.left, aliasContext);
-  if (!jsonField) {
-    throw new NqlSemanticException(
-      NqlErrorCodes.SEM_INVALID_SYNTAX,
-      "Left side of JSON comparison must be a field reference"
-    );
-  }
-  if (jsonComp.operator === "?") {
-    const key = coerceToStringKey(jsonComp.right, "? operator key", ctx);
-    return {
-      kind: "jsonExists",
-      field: jsonField,
-      key
-    };
-  }
-  const jsonValue = resolveFilterValue(
-    jsonComp.right,
-    ctx,
-    aliasContext,
-    outerAliases
-  );
-  const intent = {
-    kind: "jsonContains",
-    field: jsonField,
-    value: jsonValue,
-    reversed: jsonComp.operator === "<@"
-  };
-  return intent;
-}
-function compileRelationFilter(expr, ctx, fns, aliasContext, outerAliases) {
-  const relFilter = expr;
-  const nestedOuterAliases = aliasContext ? [...outerAliases ?? [], aliasContext] : outerAliases ?? [];
-  const prevRelationTarget = ctx.currentRelationTarget;
-  if (ctx.currentFromTable && ctx.validator && relFilter.relation[0]) {
-    ctx.currentRelationTarget = ctx.validator.resolveRelationTarget(
-      ctx.currentFromTable,
-      relFilter.relation[0]
-    );
-  }
-  const where = compileExpression(
-    relFilter.condition,
-    ctx,
-    fns,
-    relFilter.alias,
-    nestedOuterAliases
-  );
-  ctx.currentRelationTarget = prevRelationTarget;
-  return {
-    kind: "relationFilter",
-    relation: relFilter.relation,
-    where,
-    mode: relFilter.mode,
-    ...relFilter.alias !== void 0 && { alias: relFilter.alias }
-  };
-}
-function expandDateRangeList(field, patterns, negated) {
-  const conditions = patterns.map((pattern) => {
-    const { start, end } = expandDateRange(pattern);
-    return {
-      kind: "and",
-      conditions: [
-        {
-          kind: "comparison",
-          field,
-          operator: "gte",
-          value: start
-        },
-        {
-          kind: "comparison",
-          field,
-          operator: "lt",
-          value: end
-        }
-      ]
-    };
-  });
-  const result = conditions.length === 1 ? conditions[0] : { kind: "or", conditions };
-  if (negated) {
-    return { kind: "not", condition: result };
-  }
-  return result;
-}
-function compileExpression(expr, ctx, fns, aliasContext, outerAliases) {
-  switch (expr.type) {
-    case "binary":
-    case "unary":
-      return compileLogical(expr, ctx, fns, aliasContext, outerAliases);
-    case "comparison":
-      return compileComparison(expr, ctx, fns, aliasContext, outerAliases);
-    case "rangeOp":
-      return compileRange(expr, ctx, fns, aliasContext, outerAliases);
-    case "in":
-    case "any":
-      return compileMembership(expr, ctx, fns, aliasContext, outerAliases);
-    case "between":
-      return compileBetween(expr, ctx, fns, aliasContext, outerAliases);
-    case "isNull":
-      return compileNull(expr, ctx, aliasContext);
-    case "jsonComparison":
-    case "function":
-      return compileJson(expr, ctx, fns, aliasContext, outerAliases);
-    case "relationFilter":
-      return compileRelationFilter(expr, ctx, fns, aliasContext, outerAliases);
-    case "case":
-      throw new NqlSemanticException(
-        NqlErrorCodes.SEM_INVALID_SYNTAX,
-        "CASE in WHERE not supported. Use a computed column in SELECT or a relation filter instead."
-      );
-    case "exists":
-      throw new NqlSemanticException(
-        NqlErrorCodes.SEM_INVALID_SYNTAX,
-        "EXISTS (subquery) is not supported in NQL. Use relation filters instead:\n  orders | with customer | where customer.active = true\n  orders | where exists(customer, active = true)\nThese compile to efficient EXISTS subqueries automatically."
-      );
-    /* v8 ignore next — defensive: all parser-produced expression types are handled above -- @preserve */
-    default:
-      throw new NqlSemanticException(
-        NqlErrorCodes.SEM_INVALID_SYNTAX,
-        `Unsupported expression type in WHERE: ${expr.type}`
-      );
-  }
-}
-function assignMutationValue(target, column, value, ctx) {
-  target[column] = expressionToValue(value, ctx);
-}
-function compileMutationPipeline(pipeline, ctx, fns, bindings) {
-  ctx.currentFromTable = pipeline.mutation.table;
-  const mutation = compileMutation(pipeline.mutation, ctx, fns, bindings);
-  let returning;
-  for (const clause of pipeline.clauses) {
-    if (clause.type === "select") {
-      returning = extractReturningColumns(clause, ctx);
-    }
-  }
-  if (returning) {
-    return {
-      mutation: { ...mutation, returning }
-    };
-  }
-  return { mutation };
-}
-function compileMutation(mutation, ctx, fns, bindings) {
-  switch (mutation.type) {
-    case "insert":
-      return compileInsert(mutation, ctx);
-    case "insert_from":
-      return compileInsertFrom(mutation, ctx, fns, bindings);
-    case "update":
-      return compileUpdate(mutation, ctx, fns, bindings);
-    case "delete":
-      return compileDelete(mutation, ctx, fns, bindings);
-    case "upsert":
-      return compileUpsert(mutation, ctx);
-    case "upsert_from":
-      return compileUpsertFrom(mutation, ctx, fns, bindings);
-  }
-}
-function compileInsert(insert, ctx) {
-  ctx.validator?.validateTable(insert.table);
-  const allColumns = /* @__PURE__ */ new Set();
-  for (const row of insert.rows) {
-    for (const assignment of row) {
-      ctx.validator?.validateColumn(insert.table, assignment.column);
-      allColumns.add(assignment.column);
-    }
-  }
-  const values = [];
-  for (const row of insert.rows) {
-    const rowValues = {};
-    const rowColumns = /* @__PURE__ */ new Set();
-    for (const assignment of row) {
-      rowColumns.add(assignment.column);
-      assignMutationValue(rowValues, assignment.column, assignment.value, ctx);
-    }
-    for (const col of allColumns) {
-      if (!rowColumns.has(col)) {
-        rowValues[col] = void 0;
-      }
-    }
-    values.push(rowValues);
-  }
-  return {
-    type: "insert",
-    table: insert.table,
-    values
-  };
-}
-function compileInsertFrom(insertFrom, ctx, fns, bindings) {
-  ctx.validator?.validateTable(insertFrom.table);
-  const sourceQuery = bindings?.get(insertFrom.source);
-  if (!sourceQuery) {
-    ctx.validator?.validateTable(insertFrom.source);
-  }
-  ctx.currentFromTable = insertFrom.source;
-  return {
-    type: "insert_from",
-    table: insertFrom.table,
-    source: insertFrom.source,
-    ...sourceQuery !== void 0 && { sourceQuery },
-    /* v8 ignore next — NQL grammar does not produce explicit column lists for INSERT FROM -- @preserve */
-    ...insertFrom.columns !== void 0 && { columns: insertFrom.columns },
-    ...insertFrom.where !== void 0 && {
-      where: fns.compileExpression(insertFrom.where, ctx, fns)
-    },
-    ...insertFrom.limit !== void 0 && {
-      limit: resolveIntegerCount(insertFrom.limit, ctx, "insert-from limit")
-    }
-  };
-}
-function compileUpdate(update, ctx, fns, bindings) {
-  ctx.currentFromTable = update.table;
-  ctx.validator?.validateTable(update.table);
-  const set = {};
-  for (const assignment of update.assignments) {
-    ctx.validator?.validateColumn(update.table, assignment.column);
-    assignMutationValue(set, assignment.column, assignment.value, ctx);
-  }
-  if (update.where) {
-    return {
-      type: "update",
-      table: update.table,
-      set,
-      where: resolveBindingsInWhere(
-        fns.compileExpression(update.where, ctx, fns),
-        bindings
-      )
-    };
+      };
+    }
+    throw new NqlSemanticException(
+      NqlErrorCodes.SEM_INVALID_SYNTAX,
+      `Unsupported function in WHERE context: ${fn}()`
+    );
   }
-  if (!ctx.allowUnfilteredMutations) {
-    throw new Error(
-      "update without a where clause would affect all rows; pass { allowUnfilteredMutations: true } to the compiler to allow an unfiltered update"
+  const jsonComp = expr;
+  const jsonField = expressionToField(jsonComp.left, aliasContext);
+  if (!jsonField) {
+    throw new NqlSemanticException(
+      NqlErrorCodes.SEM_INVALID_SYNTAX,
+      "Left side of JSON comparison must be a field reference"
     );
   }
-  return {
-    type: "update",
-    table: update.table,
-    set,
-    allowAll: true
-  };
-}
-function compileDelete(del, ctx, fns, bindings) {
-  ctx.currentFromTable = del.table;
-  ctx.validator?.validateTable(del.table);
-  if (del.where) {
+  if (jsonComp.operator === "?") {
+    const key = coerceToStringKey(jsonComp.right, "? operator key", ctx);
     return {
-      type: "delete",
-      table: del.table,
-      where: resolveBindingsInWhere(
-        fns.compileExpression(del.where, ctx, fns),
-        bindings
-      )
+      kind: "jsonExists",
+      field: jsonField,
+      key
     };
   }
-  if (!ctx.allowUnfilteredMutations) {
-    throw new Error(
-      "delete without a where clause would affect all rows; pass { allowUnfilteredMutations: true } to the compiler to allow an unfiltered delete"
-    );
-  }
-  return {
-    type: "delete",
-    table: del.table,
-    allowAll: true
+  const jsonValue = resolveFilterValue(
+    jsonComp.right,
+    ctx,
+    aliasContext,
+    outerAliases
+  );
+  const intent = {
+    kind: "jsonContains",
+    field: jsonField,
+    value: jsonValue,
+    reversed: jsonComp.operator === "<@"
   };
+  return intent;
 }
-function compileUpsert(upsert, ctx) {
-  ctx.validator?.validateTable(upsert.table);
-  const values = {};
-  for (const assignment of upsert.assignments) {
-    ctx.validator?.validateColumn(upsert.table, assignment.column);
-    assignMutationValue(values, assignment.column, assignment.value, ctx);
-  }
-  for (const col of upsert.conflictColumns) {
-    ctx.validator?.validateColumn(upsert.table, col);
-  }
-  if (upsert.where) {
-    throw new Error(
-      "conditional upsert is not yet supported: a WHERE clause on `upsert` (ON CONFLICT DO UPDATE ... WHERE) is parsed but cannot be honored by the SQL generator yet. Remove the WHERE, or use a plain conditional update. Tracked for a future release."
+function compileRelationFilter(expr, ctx, fns, aliasContext, outerAliases) {
+  const relFilter = expr;
+  const nestedOuterAliases = aliasContext ? [...outerAliases ?? [], aliasContext] : outerAliases ?? [];
+  const prevRelationTarget = ctx.currentRelationTarget;
+  if (ctx.currentFromTable && ctx.validator && relFilter.relation[0]) {
+    ctx.currentRelationTarget = ctx.validator.resolveRelationTarget(
+      ctx.currentFromTable,
+      relFilter.relation[0]
     );
   }
+  const where = compileExpression(
+    relFilter.condition,
+    ctx,
+    fns,
+    relFilter.alias,
+    nestedOuterAliases
+  );
+  ctx.currentRelationTarget = prevRelationTarget;
   return {
-    type: "upsert",
-    table: upsert.table,
-    values: [values],
-    onConflict: { columns: upsert.conflictColumns },
-    action: { type: "doUpdate", set: values }
-  };
-}
-function compileUpsertFrom(upsertFrom, ctx, fns, bindings) {
-  ctx.validator?.validateTable(upsertFrom.table);
-  const sourceQuery = bindings?.get(upsertFrom.source);
-  if (!sourceQuery) {
-    ctx.validator?.validateTable(upsertFrom.source);
-  }
-  for (const col of upsertFrom.conflictColumns) {
-    ctx.validator?.validateColumn(upsertFrom.table, col);
-  }
-  ctx.currentFromTable = upsertFrom.source;
-  return {
-    type: "upsert_from",
-    table: upsertFrom.table,
-    source: upsertFrom.source,
-    conflictColumns: upsertFrom.conflictColumns,
-    ...sourceQuery !== void 0 && { sourceQuery },
-    /* v8 ignore start — NQL grammar does not produce explicit column lists for UPSERT FROM -- @preserve */
-    ...upsertFrom.columns !== void 0 && {
-      columns: upsertFrom.columns
-    },
-    /* v8 ignore stop -- @preserve */
-    ...upsertFrom.where !== void 0 && {
-      where: fns.compileExpression(upsertFrom.where, ctx, fns)
-    },
-    ...upsertFrom.limit !== void 0 && {
-      limit: resolveIntegerCount(upsertFrom.limit, ctx, "upsert-from limit")
-    }
+    kind: "relationFilter",
+    relation: relFilter.relation,
+    where,
+    mode: relFilter.mode,
+    ...relFilter.alias !== void 0 && { alias: relFilter.alias }
   };
 }
-function extractReturningColumns(clause, ctx) {
-  const columns = [];
-  for (const item of clause.items) {
-    if (item.type === "star") {
-      return ["*"];
-    }
-    if (item.type === "expression") {
-      const field = expressionToField(item.expression);
-      if (field) {
-        if (ctx.currentFromTable && !field.includes(".")) {
-          ctx.validator?.validateColumn(ctx.currentFromTable, field);
-        }
-        columns.push(item.alias ?? field);
-      }
-    }
-  }
-  return columns;
-}
-function resolveBindingsInWhere(where, bindings) {
-  if (!bindings || bindings.size === 0) return where;
-  if (where.kind === "in") {
-    const inWhere = where;
-    const inValues = inWhere.subquery ? void 0 : inWhere.values;
-    if (inValues && inValues.length === 1) {
-      const val = inValues[0];
-      if (!isParamIntent(val) && val && typeof val === "object" && "$ref" in val) {
-        const ref = val.$ref;
-        if (bindings.has(ref)) {
-          const boundQuery = bindings.get(ref);
-          const boundSelect = boundQuery.select;
-          const selectFields = boundSelect && "fields" in boundSelect ? boundSelect.fields : void 0;
-          const cteRef = {
-            type: "select",
-            from: ref,
-            ...selectFields && {
-              select: {
-                type: "fields",
-                fields: selectFields
-              }
-            }
-          };
-          return {
-            kind: "in",
-            field: inWhere.field,
-            subquery: cteRef
-          };
+function expandDateRangeList(field, patterns, negated) {
+  const conditions = patterns.map((pattern) => {
+    const { start, end } = expandDateRange(pattern);
+    return {
+      kind: "and",
+      conditions: [
+        {
+          kind: "comparison",
+          field,
+          operator: "gte",
+          value: start
+        },
+        {
+          kind: "comparison",
+          field,
+          operator: "lt",
+          value: end
         }
-      }
-    }
-    return where;
-  }
-  if (where.kind === "not") {
-    const notWhere = where;
-    const resolved = resolveBindingsInWhere(notWhere.condition, bindings);
-    return resolved === notWhere.condition ? where : { kind: "not", condition: resolved };
-  }
-  if (where.kind === "and" || where.kind === "or") {
-    const compound = where;
-    const resolved = compound.conditions.map(
-      (c) => resolveBindingsInWhere(c, bindings)
-    );
-    const changed = resolved.some((r, i) => r !== compound.conditions[i]);
-    return changed ? { kind: compound.kind, conditions: resolved } : where;
+      ]
+    };
+  });
+  const result = conditions.length === 1 ? conditions[0] : { kind: "or", conditions };
+  if (negated) {
+    return { kind: "not", condition: result };
   }
-  return where;
+  return result;
 }
-function extractBindName(stmt) {
-  if (stmt.type === "query") {
-    for (const clause of stmt.clauses) {
-      if (clause.type === "bind") return clause.name;
-    }
-  } else if (stmt.type === "mutationPipeline") {
-    for (const clause of stmt.clauses) {
-      if (clause.type === "bind") return clause.name;
-    }
+function compileExpression(expr, ctx, fns, aliasContext, outerAliases) {
+  switch (expr.type) {
+    case "binary":
+    case "unary":
+      return compileLogical(expr, ctx, fns, aliasContext, outerAliases);
+    case "comparison":
+      return compileComparison(expr, ctx, fns, aliasContext, outerAliases);
+    case "rangeOp":
+      return compileRange(expr, ctx, fns, aliasContext, outerAliases);
+    case "in":
+    case "any":
+      return compileMembership(expr, ctx, fns, aliasContext, outerAliases);
+    case "between":
+      return compileBetween(expr, ctx, fns, aliasContext, outerAliases);
+    case "isNull":
+      return compileNull(expr, ctx, aliasContext);
+    case "jsonComparison":
+    case "function":
+      return compileJson(expr, ctx, fns, aliasContext, outerAliases);
+    case "relationFilter":
+      return compileRelationFilter(expr, ctx, fns, aliasContext, outerAliases);
+    case "case":
+      throw new NqlSemanticException(
+        NqlErrorCodes.SEM_INVALID_SYNTAX,
+        "CASE in WHERE not supported. Use a computed column in SELECT or a relation filter instead."
+      );
+    case "exists":
+      throw new NqlSemanticException(
+        NqlErrorCodes.SEM_INVALID_SYNTAX,
+        "EXISTS (subquery) is not supported in NQL. Use relation filters instead:\n  orders | with customer | where customer.active = true\n  orders | where exists(customer, active = true)\nThese compile to efficient EXISTS subqueries automatically."
+      );
+    /* v8 ignore next — defensive: all parser-produced expression types are handled above -- @preserve */
+    default:
+      throw new NqlSemanticException(
+        NqlErrorCodes.SEM_INVALID_SYNTAX,
+        `Unsupported expression type in WHERE: ${expr.type}`
+      );
   }
-  return void 0;
 }
 function paramExpressionIntent(param, alias) {
   const intent = { ...param };
@@ -5463,6 +5469,7 @@ function hasColumnValidatorShape(obj) {
 }
 /* v8 ignore next — '*' columns are validated at call-site before reaching here -- @preserve */
 /* v8 ignore next — graceful degradation: unknown tables skip validation -- @preserve */
+/* v8 ignore next — defensive: bound queries from NQL always have select.fields -- @preserve */
 /* v8 ignore next — defensive: callers always pass valid relation paths -- @preserve */
 /* v8 ignore next — not yet reachable: flat + pre-existing includes requires WITH clause -- @preserve */
 /* v8 ignore stop -- @preserve */
@@ -5478,7 +5485,6 @@ function hasColumnValidatorShape(obj) {
 /* v8 ignore start — defensive: parser guarantees IS NULL LHS is a path -- @preserve */
 /* v8 ignore start — defensive: parser guarantees at least 2 args -- @preserve */
 /* v8 ignore next — defensive: only json_* functions reach WHERE context -- @preserve */
-/* v8 ignore next — defensive: bound queries from NQL always have select.fields -- @preserve */
 /* v8 ignore start — defensive: star items are handled in compileSelectClause before reaching here -- @preserve */
 /* v8 ignore next — defensive: relationStar items are handled in compileSelectClause -- @preserve */
 /* v8 ignore start — defensive: all parser-produced SELECT expression types are handled above -- @preserve */