@prisma-next/sql-lane 0.3.0-dev.7 → 0.3.0-dev.71

package/src/sql/mutation-builder.ts

@@ -10,7 +10,7 @@ import {
   createUpdateAst,
 } from '@prisma-next/sql-relational-core/ast';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
-import type { QueryLaneContext } from '@prisma-next/sql-relational-core/query-lane-context';
+import type { ExecutionContext } from '@prisma-next/sql-relational-core/query-lane-context';
 import type {
   AnyColumnBuilder,
   BinaryBuilder,
@@ -18,6 +18,7 @@ import type {
   InferReturningRow,
   ParamPlaceholder,
   SqlBuilderOptions,
+  UnaryBuilder,
 } from '@prisma-next/sql-relational-core/types';
 import { checkReturningCapability } from '../utils/capabilities';
 import {
@@ -48,7 +49,7 @@ export interface UpdateBuilder<
   CodecTypes extends Record<string, { readonly output: unknown }> = Record<string, never>,
   Row = unknown,
 > {
-  where(predicate: BinaryBuilder): UpdateBuilder<TContract, CodecTypes, Row>;
+  where(predicate: BinaryBuilder | UnaryBuilder): UpdateBuilder<TContract, CodecTypes, Row>;
   returning<const Columns extends readonly AnyColumnBuilder[]>(
     ...columns: Columns
   ): UpdateBuilder<TContract, CodecTypes, InferReturningRow<Columns>>;
@@ -60,7 +61,7 @@ export interface DeleteBuilder<
   CodecTypes extends Record<string, { readonly output: unknown }> = Record<string, never>,
   Row = unknown,
 > {
-  where(predicate: BinaryBuilder): DeleteBuilder<TContract, CodecTypes, Row>;
+  where(predicate: BinaryBuilder | UnaryBuilder): DeleteBuilder<TContract, CodecTypes, Row>;
   returning<const Columns extends readonly AnyColumnBuilder[]>(
     ...columns: Columns
   ): DeleteBuilder<TContract, CodecTypes, InferReturningRow<Columns>>;
@@ -74,7 +75,7 @@ export class InsertBuilderImpl<
 > implements InsertBuilder<TContract, CodecTypes, Row>
 {
   private readonly contract: TContract;
-  private readonly context: QueryLaneContext<TContract>;
+  private readonly context: ExecutionContext<TContract>;
   private readonly table: TableRef;
   private readonly values: Record<string, ParamPlaceholder>;
   private returningColumns: AnyColumnBuilder[] = [];
@@ -149,6 +150,31 @@ export class InsertBuilderImpl<
       values[columnName] = createParamRef(index, paramName);
     }
 
+    const appliedDefaults = this.context.applyMutationDefaults({
+      op: 'create',
+      table: this.table.name,
+      values,
+    });
+
+    for (const defaultValue of appliedDefaults) {
+      const columnMeta = contractTable.columns[defaultValue.column];
+      if (!columnMeta) {
+        errorUnknownColumn(defaultValue.column, this.table.name);
+      }
+
+      const index = paramValues.push(defaultValue.value);
+      paramCodecs[defaultValue.column] = columnMeta.codecId;
+      paramDescriptors.push({
+        name: defaultValue.column,
+        source: 'dsl',
+        refs: { table: this.table.name, column: defaultValue.column },
+        codecId: columnMeta.codecId,
+        nativeType: columnMeta.nativeType,
+        nullable: columnMeta.nullable,
+      });
+      values[defaultValue.column] = createParamRef(index, defaultValue.column);
+    }
+
     const returning: ColumnRef[] = this.returningColumns.map((col) => {
       // TypeScript can't narrow ColumnBuilder properly
       const c = col as unknown as { table: string; column: string };
@@ -203,10 +229,10 @@ export class UpdateBuilderImpl<
 > implements UpdateBuilder<TContract, CodecTypes, Row>
 {
   private readonly contract: TContract;
-  private readonly context: QueryLaneContext<TContract>;
+  private readonly context: ExecutionContext<TContract>;
   private readonly table: TableRef;
   private readonly set: Record<string, ParamPlaceholder>;
-  private wherePredicate?: BinaryBuilder;
+  private wherePredicate?: BinaryBuilder | UnaryBuilder;
   private returningColumns: AnyColumnBuilder[] = [];
 
   constructor(
@@ -220,7 +246,7 @@ export class UpdateBuilderImpl<
     this.set = set;
   }
 
-  where(predicate: BinaryBuilder): UpdateBuilder<TContract, CodecTypes, Row> {
+  where(predicate: BinaryBuilder | UnaryBuilder): UpdateBuilder<TContract, CodecTypes, Row> {
     const builder = new UpdateBuilderImpl<TContract, CodecTypes, Row>(
       {
         context: this.context,
@@ -299,6 +325,31 @@ export class UpdateBuilderImpl<
       set[columnName] = createParamRef(index, paramName);
     }
 
+    const appliedDefaults = this.context.applyMutationDefaults({
+      op: 'update',
+      table: this.table.name,
+      values: set,
+    });
+
+    for (const defaultValue of appliedDefaults) {
+      const columnMeta = contractTable.columns[defaultValue.column];
+      if (!columnMeta) {
+        errorUnknownColumn(defaultValue.column, this.table.name);
+      }
+
+      const index = paramValues.push(defaultValue.value);
+      paramCodecs[defaultValue.column] = columnMeta.codecId;
+      paramDescriptors.push({
+        name: defaultValue.column,
+        source: 'dsl',
+        refs: { table: this.table.name, column: defaultValue.column },
+        codecId: columnMeta.codecId,
+        nativeType: columnMeta.nativeType,
+        nullable: columnMeta.nullable,
+      });
+      set[defaultValue.column] = createParamRef(index, defaultValue.column);
+    }
+
     const whereResult = buildWhereExpr(
       this.contract,
       this.wherePredicate,
@@ -372,9 +423,9 @@ export class DeleteBuilderImpl<
 > implements DeleteBuilder<TContract, CodecTypes, Row>
 {
   private readonly contract: TContract;
-  private readonly context: QueryLaneContext<TContract>;
+  private readonly context: ExecutionContext<TContract>;
   private readonly table: TableRef;
-  private wherePredicate?: BinaryBuilder;
+  private wherePredicate?: BinaryBuilder | UnaryBuilder;
   private returningColumns: AnyColumnBuilder[] = [];
 
   constructor(options: SqlBuilderOptions<TContract>, table: TableRef) {
@@ -383,7 +434,7 @@ export class DeleteBuilderImpl<
     this.table = table;
   }
 
-  where(predicate: BinaryBuilder): DeleteBuilder<TContract, CodecTypes, Row> {
+  where(predicate: BinaryBuilder | UnaryBuilder): DeleteBuilder<TContract, CodecTypes, Row> {
     const builder = new DeleteBuilderImpl<TContract, CodecTypes, Row>(
       {
         context: this.context,

package/src/sql/plan.ts

@@ -1,42 +1,72 @@
 import type { PlanMeta } from '@prisma-next/contract/types';
-import type { OperationExpr } from '@prisma-next/sql-relational-core/ast';
+import type { Expression } from '@prisma-next/sql-relational-core/ast';
 import { compact } from '@prisma-next/sql-relational-core/ast';
-import type { AnyColumnBuilder } from '@prisma-next/sql-relational-core/types';
+import type { AnyExpressionSource } from '@prisma-next/sql-relational-core/types';
 import {
   collectColumnRefs,
-  getColumnInfo,
-  getOperationExpr,
   isColumnBuilder,
+  isExpressionBuilder,
   isOperationExpr,
 } from '@prisma-next/sql-relational-core/utils/guards';
 import type { MetaBuildArgs } from '../types/internal';
 import { assertColumnBuilder } from '../utils/assertions';
 import { errorMissingColumnForAlias } from '../utils/errors';
 
+/**
+ * Extracts column references from an ExpressionSource (ColumnBuilder or ExpressionBuilder).
+ */
+function collectRefsFromExpressionSource(
+  source: AnyExpressionSource,
+  refsColumns: Map<string, { table: string; column: string }>,
+): void {
+  if (isExpressionBuilder(source)) {
+    // ExpressionBuilder has an OperationExpr - collect all column refs
+    const allRefs = collectColumnRefs(source.expr);
+    for (const ref of allRefs) {
+      refsColumns.set(`${ref.table}.${ref.column}`, {
+        table: ref.table,
+        column: ref.column,
+      });
+    }
+  } else if (isColumnBuilder(source)) {
+    // ColumnBuilder - use table and column directly
+    const col = source as unknown as { table: string; column: string };
+    refsColumns.set(`${col.table}.${col.column}`, {
+      table: col.table,
+      column: col.column,
+    });
+  }
+}
+
+/**
+ * Extracts column references from an Expression (AST node).
+ */
+function collectRefsFromExpression(
+  expr: Expression,
+  refsColumns: Map<string, { table: string; column: string }>,
+): void {
+  if (isOperationExpr(expr)) {
+    const allRefs = collectColumnRefs(expr);
+    for (const ref of allRefs) {
+      refsColumns.set(`${ref.table}.${ref.column}`, {
+        table: ref.table,
+        column: ref.column,
+      });
+    }
+  } else if (expr.kind === 'col') {
+    refsColumns.set(`${expr.table}.${expr.column}`, {
+      table: expr.table,
+      column: expr.column,
+    });
+  }
+}
+
 export function buildMeta(args: MetaBuildArgs): PlanMeta {
   const refsColumns = new Map<string, { table: string; column: string }>();
   const refsTables = new Set<string>([args.table.name]);
 
   for (const column of args.projection.columns) {
-    // Skip null columns (include placeholders)
-    if (!column) {
-      continue;
-    }
-    const operationExpr = getOperationExpr(column);
-    if (operationExpr) {
-      const allRefs = collectColumnRefs(operationExpr);
-      for (const ref of allRefs) {
-        refsColumns.set(`${ref.table}.${ref.column}`, {
-          table: ref.table,
-          column: ref.column,
-        });
-      }
-    } else {
-      refsColumns.set(`${column.table}.${column.column}`, {
-        table: column.table,
-        column: column.column,
-      });
-    }
+    collectRefsFromExpressionSource(column, refsColumns);
   }
 
   if (args.joins) {
@@ -81,53 +111,40 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
       }
       // Add child WHERE columns if present
       if (include.childWhere) {
-        const colInfo = getColumnInfo(include.childWhere.left);
-        refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
-          table: colInfo.table,
-          column: colInfo.column,
-        });
-        // Handle right side of child WHERE clause
-        const childWhereRight = include.childWhere.right;
-        if (isColumnBuilder(childWhereRight)) {
-          const rightColInfo = getColumnInfo(childWhereRight);
-          refsColumns.set(`${rightColInfo.table}.${rightColInfo.column}`, {
-            table: rightColInfo.table,
-            column: rightColInfo.column,
-          });
+        // Handle UnaryBuilder (e.g., NullCheckBuilder) - it only has 'expr' property
+        if (include.childWhere.kind === 'nullCheck') {
+          const expr: Expression = include.childWhere.expr;
+          collectRefsFromExpression(expr, refsColumns);
+        } else {
+          // BinaryBuilder - has 'left' and 'right' properties
+          // childWhere.left is Expression (already converted at builder creation time)
+          collectRefsFromExpression(include.childWhere.left, refsColumns);
+          // Handle right side of child WHERE clause - can be ParamPlaceholder or ExpressionSource
+          const childWhereRight = include.childWhere.right;
+          if (isColumnBuilder(childWhereRight) || isExpressionBuilder(childWhereRight)) {
+            collectRefsFromExpressionSource(childWhereRight, refsColumns);
+          }
         }
       }
       // Add child ORDER BY columns if present
       if (include.childOrderBy) {
-        const orderBy = include.childOrderBy as unknown as {
-          expr?: AnyColumnBuilder | OperationExpr;
-        };
-        if (orderBy.expr) {
-          const colInfo = getColumnInfo(orderBy.expr);
-          refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
-            table: colInfo.table,
-            column: colInfo.column,
-          });
-        }
+        // childOrderBy.expr is Expression (already converted at builder creation time)
+        collectRefsFromExpression(include.childOrderBy.expr, refsColumns);
       }
     }
   }
 
   if (args.where) {
-    const whereLeft = args.where.left;
-    // Check if whereLeft is an OperationExpr directly (not wrapped in ColumnBuilder)
-    if (isOperationExpr(whereLeft)) {
-      const allRefs = collectColumnRefs(whereLeft);
-      for (const ref of allRefs) {
-        refsColumns.set(`${ref.table}.${ref.column}`, {
-          table: ref.table,
-          column: ref.column,
-        });
-      }
+    // Handle UnaryBuilder (e.g., NullCheckBuilder) - it only has 'expr' property
+    if (args.where.kind === 'nullCheck') {
+      const expr: Expression = args.where.expr;
+      collectRefsFromExpression(expr, refsColumns);
     } else {
-      // Check if whereLeft is a ColumnBuilder with an _operationExpr property
-      const operationExpr = (whereLeft as { _operationExpr?: OperationExpr })._operationExpr;
-      if (operationExpr) {
-        const allRefs = collectColumnRefs(operationExpr);
+      // BinaryBuilder - has 'left' and 'right' properties
+      // args.where.left is Expression (already converted at builder creation time)
+      const leftExpr: Expression = args.where.left;
+      if (isOperationExpr(leftExpr)) {
+        const allRefs = collectColumnRefs(leftExpr);
         for (const ref of allRefs) {
           refsColumns.set(`${ref.table}.${ref.column}`, {
             table: ref.table,
@@ -135,45 +152,38 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
           });
         }
       } else {
-        const colBuilder = assertColumnBuilder(whereLeft, 'where clause must be a ColumnBuilder');
-        refsColumns.set(`${colBuilder.table}.${colBuilder.column}`, {
-          table: colBuilder.table,
-          column: colBuilder.column,
+        // leftExpr is ColumnRef
+        refsColumns.set(`${leftExpr.table}.${leftExpr.column}`, {
+          table: leftExpr.table,
+          column: leftExpr.column,
         });
       }
-    }
 
-    // Handle right side of WHERE clause - can be ParamPlaceholder or AnyColumnBuilder
-    const whereRight = args.where.right;
-    if (isColumnBuilder(whereRight)) {
-      const colInfo = getColumnInfo(whereRight);
-      refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
-        table: colInfo.table,
-        column: colInfo.column,
-      });
+      // Handle right side of WHERE clause - can be ParamPlaceholder or AnyExpressionSource
+      const whereRight = args.where.right;
+      if (isColumnBuilder(whereRight) || isExpressionBuilder(whereRight)) {
+        collectRefsFromExpressionSource(whereRight, refsColumns);
+      }
     }
   }
 
   if (args.orderBy) {
-    const orderBy = args.orderBy as unknown as {
-      expr?: AnyColumnBuilder | OperationExpr;
-    };
-    const orderByExpr = orderBy.expr;
-    if (orderByExpr) {
-      if (isOperationExpr(orderByExpr)) {
-        const allRefs = collectColumnRefs(orderByExpr);
-        for (const ref of allRefs) {
-          refsColumns.set(`${ref.table}.${ref.column}`, {
-            table: ref.table,
-            column: ref.column,
-          });
-        }
-      } else {
-        refsColumns.set(`${orderByExpr.table}.${orderByExpr.column}`, {
-          table: orderByExpr.table,
-          column: orderByExpr.column,
+    // args.orderBy.expr is Expression (already converted at builder creation time)
+    const orderByExpr: Expression = args.orderBy.expr;
+    if (isOperationExpr(orderByExpr)) {
+      const allRefs = collectColumnRefs(orderByExpr);
+      for (const ref of allRefs) {
+        refsColumns.set(`${ref.table}.${ref.column}`, {
+          table: ref.table,
+          column: ref.column,
         });
       }
+    } else {
+      // orderByExpr is ColumnRef
+      refsColumns.set(`${orderByExpr.table}.${orderByExpr.column}`, {
+        table: orderByExpr.table,
+        column: orderByExpr.column,
+      });
     }
   }
 
@@ -191,13 +201,18 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
         // This shouldn't happen if projection building is correct, but handle gracefully
         errorMissingColumnForAlias(alias, index);
       }
-
-      const operationExpr = getOperationExpr(column);
-      if (operationExpr) {
-        return [alias, `operation:${operationExpr.method}`];
+      // Check if column is an ExpressionBuilder (operation result)
+      if (isExpressionBuilder(column)) {
+        return [alias, `operation:${column.expr.method}`];
+      }
+      // column is ColumnBuilder
+      const col = column as unknown as { table?: string; column?: string };
+      if (!col.table || !col.column) {
+        // This is a placeholder column for an include - skip it
+        return [alias, `include:${alias}`];
       }
 
-      return [alias, `${column.table}.${column.column}`];
+      return [alias, `${col.table}.${col.column}`];
     }),
   );
 
@@ -213,15 +228,15 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
     if (!column) {
       continue;
     }
-    const operationExpr = (column as { _operationExpr?: OperationExpr })._operationExpr;
-    if (operationExpr) {
+    if (isExpressionBuilder(column)) {
+      const operationExpr = column.expr;
       if (operationExpr.returns.kind === 'typeId') {
         projectionTypes[alias] = operationExpr.returns.type;
       } else if (operationExpr.returns.kind === 'builtin') {
         projectionTypes[alias] = operationExpr.returns.type;
       }
     } else {
-      // TypeScript can't narrow ColumnBuilder properly
+      // column is ColumnBuilder
       const col = column as unknown as { columnMeta?: { codecId: string } };
       const columnMeta = col.columnMeta;
       const codecId = columnMeta?.codecId;
@@ -243,14 +258,14 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
     if (!column) {
       continue;
     }
-    const operationExpr = (column as { _operationExpr?: OperationExpr })._operationExpr;
-    if (operationExpr) {
+    if (isExpressionBuilder(column)) {
+      const operationExpr = column.expr;
       if (operationExpr.returns.kind === 'typeId') {
         projectionCodecs[alias] = operationExpr.returns.type;
       }
     } else {
       // Use columnMeta.codecId directly as typeId (already canonicalized)
-      // TypeScript can't narrow ColumnBuilder properly
+      // column is ColumnBuilder
       const col = column as unknown as { columnMeta?: { codecId: string } };
       const columnMeta = col.columnMeta;
       const codecId = columnMeta?.codecId;
@@ -270,7 +285,7 @@ export function buildMeta(args: MetaBuildArgs): PlanMeta {
     compact({
       target: args.contract.target,
       targetFamily: args.contract.targetFamily,
-      coreHash: args.contract.coreHash,
+      storageHash: args.contract.storageHash,
       lane: 'dsl',
       refs: {
         tables: Array.from(refsTables),

package/src/sql/predicate-builder.ts

@@ -1,21 +1,25 @@
 import type { ParamDescriptor } from '@prisma-next/contract/types';
 import type { SqlContract, SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
 import type {
-  BinaryExpr,
-  ColumnRef,
-  OperationExpr,
+  Expression,
+  NullCheckExpr,
   ParamRef,
+  WhereExpr,
 } from '@prisma-next/sql-relational-core/ast';
 import {
   createBinaryExpr,
-  createColumnRef,
+  createNullCheckExpr,
   createParamRef,
 } from '@prisma-next/sql-relational-core/ast';
-import type { BinaryBuilder, ParamPlaceholder } from '@prisma-next/sql-relational-core/types';
+import type {
+  BinaryBuilder,
+  NullCheckBuilder,
+  ParamPlaceholder,
+  UnaryBuilder,
+} from '@prisma-next/sql-relational-core/types';
 import {
-  getColumnInfo,
-  getOperationExpr,
   isColumnBuilder,
+  isExpressionBuilder,
   isParamPlaceholder,
 } from '@prisma-next/sql-relational-core/utils/guards';
 import {
@@ -26,32 +30,83 @@ import {
 } from '../utils/errors';
 
 export interface BuildWhereExprResult {
-  expr: BinaryExpr;
+  expr: WhereExpr;
   codecId: string | undefined;
   paramName: string;
 }
 
+/**
+ * Type guard to check if a builder is a NullCheckBuilder (unary).
+ */
+function isNullCheckBuilder(builder: BinaryBuilder | UnaryBuilder): builder is NullCheckBuilder {
+  return builder.kind === 'nullCheck';
+}
+
+/**
+ * Builds a NullCheckExpr from a NullCheckBuilder.
+ */
+function buildNullCheckExpr(
+  contract: SqlContract<SqlStorage>,
+  where: NullCheckBuilder,
+): NullCheckExpr {
+  const expr = where.expr;
+
+  // Validate column exists in contract if it's a ColumnRef
+  if (expr.kind === 'col') {
+    const { table, column } = expr;
+    const contractTable = contract.storage.tables[table];
+    if (!contractTable) {
+      errorUnknownTable(table);
+    }
+
+    const columnMeta: StorageColumn | undefined = contractTable.columns[column];
+    if (!columnMeta) {
+      errorUnknownColumn(column, table);
+    }
+  }
+
+  return createNullCheckExpr(expr, where.isNull);
+}
+
 export function buildWhereExpr(
   contract: SqlContract<SqlStorage>,
-  where: BinaryBuilder,
+  where: BinaryBuilder | UnaryBuilder,
   paramsMap: Record<string, unknown>,
   descriptors: ParamDescriptor[],
   values: unknown[],
 ): BuildWhereExprResult {
-  let leftExpr: ColumnRef | OperationExpr;
+  // Handle NullCheckBuilder (unary expression)
+  if (isNullCheckBuilder(where)) {
+    return {
+      expr: buildNullCheckExpr(contract, where),
+      codecId: undefined,
+      paramName: '',
+    };
+  }
+
+  // Handle BinaryBuilder (binary expression)
+  let leftExpr: Expression;
   let codecId: string | undefined;
-  let rightExpr: ColumnRef | ParamRef;
+  let rightExpr: Expression | ParamRef;
   let paramName: string;
 
-  // Check if where.left is an OperationExpr directly (from operation.eq())
-  // or a ColumnBuilder with _operationExpr property
-  const operationExpr = getOperationExpr(where.left);
-  if (operationExpr) {
-    leftExpr = operationExpr;
-  } else if (isColumnBuilder(where.left)) {
-    // where.left is a ColumnBuilder - use proper type narrowing
-    const { table, column } = getColumnInfo(where.left);
+  // Validate where.left is a valid Expression (col or operation)
+  const validExpressionKinds = ['col', 'operation'];
+  if (
+    !where.left ||
+    typeof where.left !== 'object' ||
+    !validExpressionKinds.includes((where.left as { kind?: string }).kind ?? '')
+  ) {
+    errorFailedToBuildWhereClause();
+  }
+
+  // where.left is an Expression (already converted at builder creation time)
+  // It could be a ColumnRef or OperationExpr
+  leftExpr = where.left;
 
+  // If the left expression is a column reference, extract codecId for param descriptors
+  if (leftExpr.kind === 'col') {
+    const { table, column } = leftExpr;
     const contractTable = contract.storage.tables[table];
     if (!contractTable) {
       errorUnknownTable(table);
@@ -63,13 +118,9 @@ export function buildWhereExpr(
     }
 
     codecId = columnMeta.codecId;
-    leftExpr = createColumnRef(table, column);
-  } else {
-    // where.left is neither OperationExpr nor ColumnBuilder - invalid state
-    errorFailedToBuildWhereClause();
   }
 
-  // Handle where.right - can be ParamPlaceholder or AnyColumnBuilder
+  // Handle where.right - can be ParamPlaceholder or ExpressionSource
   if (isParamPlaceholder(where.right)) {
     // Handle param placeholder (existing logic)
     const placeholder: ParamPlaceholder = where.right;
@@ -82,9 +133,9 @@ export function buildWhereExpr(
     const value = paramsMap[paramName];
     const index = values.push(value);
 
-    // Construct descriptor directly from validated StorageColumn
-    if (isColumnBuilder(where.left)) {
-      const { table, column } = getColumnInfo(where.left);
+    // Construct descriptor directly from validated StorageColumn if left is a column
+    if (leftExpr.kind === 'col') {
+      const { table, column } = leftExpr;
       const contractTable = contract.storage.tables[table];
       const columnMeta = contractTable?.columns[column];
       if (columnMeta) {
@@ -100,25 +151,28 @@ export function buildWhereExpr(
     }
 
     rightExpr = createParamRef(index, paramName);
-  } else if (isColumnBuilder(where.right)) {
-    // Handle column builder on the right
-    const { table, column } = getColumnInfo(where.right);
+  } else if (isColumnBuilder(where.right) || isExpressionBuilder(where.right)) {
+    // Handle ExpressionSource (ColumnBuilder or ExpressionBuilder) on the right
+    rightExpr = where.right.toExpr();
 
-    const contractTable = contract.storage.tables[table];
-    if (!contractTable) {
-      errorUnknownTable(table);
-    }
+    // Validate column exists in contract if it's a ColumnRef
+    if (rightExpr.kind === 'col') {
+      const { table, column } = rightExpr;
+      const contractTable = contract.storage.tables[table];
+      if (!contractTable) {
+        errorUnknownTable(table);
+      }
 
-    const columnMeta: StorageColumn | undefined = contractTable.columns[column];
-    if (!columnMeta) {
-      errorUnknownColumn(column, table);
+      const columnMeta: StorageColumn | undefined = contractTable.columns[column];
+      if (!columnMeta) {
+        errorUnknownColumn(column, table);
+      }
     }
 
-    rightExpr = createColumnRef(table, column);
-    // Use a placeholder paramName for column references (not used for params)
+    // Use a placeholder paramName for expression references (not used for params)
     paramName = '';
   } else {
-    // where.right is neither ParamPlaceholder nor ColumnBuilder - invalid state
+    // where.right is neither ParamPlaceholder nor ExpressionSource - invalid state
     errorFailedToBuildWhereClause();
   }