@prisma-next/sql-lane 0.3.0-dev.11 → 0.3.0-dev.113

package/src/sql/include-builder.ts

@@ -1,17 +1,18 @@
-import type { ParamDescriptor } from '@prisma-next/contract/types';
 import type { SqlContract, SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
-import type {
+import {
+  AndExpr,
+  type AnyExpression,
   BinaryExpr,
   ColumnRef,
-  IncludeAst,
-  OperationExpr,
-  TableRef,
-} from '@prisma-next/sql-relational-core/ast';
-import {
-  createColumnRef,
-  createJoinOnExpr,
-  createOrderByItem,
-  createTableRef,
+  DerivedTableSource,
+  JoinAst,
+  JsonArrayAggExpr,
+  JsonObjectExpr,
+  OrderByItem,
+  ProjectionItem,
+  SelectAst,
+  type TableRef,
+  TableSource,
 } from '@prisma-next/sql-relational-core/ast';
 import type {
   AnyBinaryBuilder,
@@ -22,10 +23,6 @@ import type {
   NestedProjection,
   OrderBuilder,
 } from '@prisma-next/sql-relational-core/types';
-import {
-  extractBaseColumnRef,
-  isOperationExpr,
-} from '@prisma-next/sql-relational-core/utils/guards';
 import {
   errorChildProjectionMustBeSpecified,
   errorLimitMustBeNonNegativeInteger,
@@ -55,16 +52,14 @@ export class IncludeChildBuilderImpl<
 > implements IncludeChildBuilder<TContract, CodecTypes, ChildRow>
 {
   private readonly contract: TContract;
-  private readonly codecTypes: CodecTypes;
   private readonly table: TableRef;
   private childProjection?: ProjectionState;
   private childWhere?: BinaryBuilder;
   private childOrderBy?: OrderBuilder;
   private childLimit?: number;
 
-  constructor(contract: TContract, codecTypes: CodecTypes, table: TableRef) {
+  constructor(contract: TContract, table: TableRef) {
     this.contract = contract;
-    this.codecTypes = codecTypes;
     this.table = table;
   }
 
@@ -76,7 +71,7 @@ export class IncludeChildBuilderImpl<
       TContract,
       CodecTypes,
       InferNestedProjectionRow<P, CodecTypes>
-    >(this.contract, this.codecTypes, this.table);
+    >(this.contract, this.table);
     builder.childProjection = projectionState;
     if (this.childWhere !== undefined) {
       builder.childWhere = this.childWhere;
@@ -93,7 +88,6 @@ export class IncludeChildBuilderImpl<
   where(expr: AnyBinaryBuilder): IncludeChildBuilderImpl<TContract, CodecTypes, ChildRow> {
     const builder = new IncludeChildBuilderImpl<TContract, CodecTypes, ChildRow>(
       this.contract,
-      this.codecTypes,
       this.table,
     );
     if (this.childProjection !== undefined) {
@@ -112,7 +106,6 @@ export class IncludeChildBuilderImpl<
   orderBy(order: AnyOrderBuilder): IncludeChildBuilderImpl<TContract, CodecTypes, ChildRow> {
     const builder = new IncludeChildBuilderImpl<TContract, CodecTypes, ChildRow>(
       this.contract,
-      this.codecTypes,
       this.table,
     );
     if (this.childProjection !== undefined) {
@@ -135,7 +128,6 @@ export class IncludeChildBuilderImpl<
 
     const builder = new IncludeChildBuilderImpl<TContract, CodecTypes, ChildRow>(
       this.contract,
-      this.codecTypes,
       this.table,
     );
     if (this.childProjection !== undefined) {
@@ -181,68 +173,115 @@ export class IncludeChildBuilderImpl<
   }
 }
 
-export function buildIncludeAst(
+function buildIncludeOrderArtifacts(
   include: IncludeState,
-  contract: SqlContract<SqlStorage>,
-  paramsMap: Record<string, unknown>,
-  paramDescriptors: ParamDescriptor[],
-  paramValues: unknown[],
-): IncludeAst {
+  rowsAlias: string,
+): {
+  readonly childOrderBy: ReadonlyArray<OrderByItem> | undefined;
+  readonly hiddenOrderProjection: ReadonlyArray<ProjectionItem>;
+  readonly aggregateOrderBy: ReadonlyArray<OrderByItem> | undefined;
+} {
   const childOrderBy = include.childOrderBy
     ? (() => {
         const orderBy = include.childOrderBy as OrderBuilder<string, StorageColumn, unknown>;
-        const orderExpr = orderBy.expr;
-        const expr: ColumnRef | OperationExpr = (() => {
-          if (isOperationExpr(orderExpr)) {
-            const baseCol = extractBaseColumnRef(orderExpr);
-            return createColumnRef(baseCol.table, baseCol.column);
-          }
-          // orderExpr is ColumnBuilder - TypeScript can't narrow properly
-          const colBuilder = orderExpr as { table: string; column: string };
-          return createColumnRef(colBuilder.table, colBuilder.column);
-        })();
-        return [createOrderByItem(expr, orderBy.dir)];
+        return [new OrderByItem(orderBy.expr, orderBy.dir)];
       })()
     : undefined;
 
-  let childWhere: BinaryExpr | undefined;
+  if (!childOrderBy || childOrderBy.length === 0) {
+    return {
+      childOrderBy: undefined,
+      hiddenOrderProjection: [],
+      aggregateOrderBy: undefined,
+    };
+  }
+
+  const hiddenOrderProjection = childOrderBy.map((orderItem, index) =>
+    ProjectionItem.of(`${include.alias}__order_${index}`, orderItem.expr),
+  );
+  const aggregateOrderBy = hiddenOrderProjection.map((projection, index) => {
+    const orderItem = childOrderBy[index];
+    if (!orderItem) {
+      throw new Error(`Missing include order metadata at index ${index}`);
+    }
+    return new OrderByItem(ColumnRef.of(rowsAlias, projection.alias), orderItem.dir);
+  });
+
+  return {
+    childOrderBy,
+    hiddenOrderProjection,
+    aggregateOrderBy,
+  };
+}
+
+function buildChildProjectionItems(include: IncludeState): ProjectionItem[] {
+  return include.childProjection.aliases.map((alias, idx) => {
+    const column = include.childProjection.columns[idx];
+    if (!column) {
+      errorMissingColumnForAlias(alias, idx);
+    }
+    return ProjectionItem.of(alias, column.toExpr());
+  });
+}
+
+export interface IncludeJoinArtifact {
+  readonly join: JoinAst;
+  readonly projection: ProjectionItem;
+}
+
+export function buildIncludeJoinArtifact(
+  include: IncludeState,
+  contract: SqlContract<SqlStorage>,
+  paramsMap: Record<string, unknown>,
+): IncludeJoinArtifact {
+  let childWhere: AnyExpression | undefined;
   if (include.childWhere) {
-    const whereResult = buildWhereExpr(
-      contract,
-      include.childWhere,
-      paramsMap,
-      paramDescriptors,
-      paramValues,
-    );
+    const whereResult = buildWhereExpr(contract, include.childWhere, paramsMap);
     childWhere = whereResult.expr;
   }
 
   const onLeft = include.on.left as { table: string; column: string };
   const onRight = include.on.right as { table: string; column: string };
-  const leftCol = createColumnRef(onLeft.table, onLeft.column);
-  const rightCol = createColumnRef(onRight.table, onRight.column);
-  const onExpr = createJoinOnExpr(leftCol, rightCol);
+  const onExpr = BinaryExpr.eq(
+    ColumnRef.of(onLeft.table, onLeft.column),
+    ColumnRef.of(onRight.table, onRight.column),
+  );
+  const rowsWhere = childWhere ? AndExpr.of([onExpr, childWhere]) : onExpr;
+
+  const childProjectItems = buildChildProjectionItems(include);
+  const rowsAlias = `${include.alias}__rows`;
+  const { childOrderBy, hiddenOrderProjection, aggregateOrderBy } = buildIncludeOrderArtifacts(
+    include,
+    rowsAlias,
+  );
+  let childRowsAst = SelectAst.from(TableSource.named(include.table.name, include.table.alias))
+    .withProjection([...childProjectItems, ...hiddenOrderProjection])
+    .withWhere(rowsWhere);
+  if (childOrderBy) {
+    childRowsAst = childRowsAst.withOrderBy(childOrderBy);
+  }
+  if (typeof include.childLimit === 'number') {
+    childRowsAst = childRowsAst.withLimit(include.childLimit);
+  }
+
+  const aggregatedAlias = `${include.alias}_lateral`;
+  const jsonObjectExpr = JsonObjectExpr.fromEntries(
+    childProjectItems.map((item) =>
+      JsonObjectExpr.entry(item.alias, ColumnRef.of(rowsAlias, item.alias)),
+    ),
+  );
+  const jsonAggExpr = JsonArrayAggExpr.of(jsonObjectExpr, 'emptyArray', aggregateOrderBy);
+
+  const aggregateSelect = SelectAst.from(
+    DerivedTableSource.as(rowsAlias, childRowsAst),
+  ).withProjection([ProjectionItem.of(include.alias, jsonAggExpr)]);
 
   return {
-    kind: 'includeMany' as const,
-    alias: include.alias,
-    child: {
-      table: createTableRef(include.table.name),
-      on: onExpr,
-      ...(childWhere ? { where: childWhere } : {}),
-      ...(childOrderBy ? { orderBy: childOrderBy } : {}),
-      ...(typeof include.childLimit === 'number' ? { limit: include.childLimit } : {}),
-      project: include.childProjection.aliases.map((alias, idx) => {
-        const column = include.childProjection.columns[idx];
-        if (!column || !alias) {
-          errorMissingColumnForAlias(alias ?? 'unknown', idx);
-        }
-
-        return {
-          alias,
-          expr: createColumnRef(column.table, column.column),
-        };
-      }),
-    },
+    join: JoinAst.left(
+      DerivedTableSource.as(aggregatedAlias, aggregateSelect),
+      AndExpr.true(),
+      true,
+    ),
+    projection: ProjectionItem.of(include.alias, ColumnRef.of(aggregatedAlias, include.alias)),
   };
 }

package/src/sql/join-builder.ts

@@ -1,18 +1,28 @@
-import type { JoinAst } from '@prisma-next/sql-relational-core/ast';
-import {
-  createColumnRef,
-  createJoin,
-  createJoinOnExpr,
-  createTableRef,
-} from '@prisma-next/sql-relational-core/ast';
+import { ColumnRef, EqColJoinOn, JoinAst, TableSource } from '@prisma-next/sql-relational-core/ast';
 import type { JoinState } from '../utils/state';
 
 export function buildJoinAst(join: JoinState): JoinAst {
   // TypeScript can't narrow ColumnBuilder properly, so we assert
   const onLeft = join.on.left as { table: string; column: string };
   const onRight = join.on.right as { table: string; column: string };
-  const leftCol = createColumnRef(onLeft.table, onLeft.column);
-  const rightCol = createColumnRef(onRight.table, onRight.column);
-  const onExpr = createJoinOnExpr(leftCol, rightCol);
-  return createJoin(join.joinType, createTableRef(join.table.name), onExpr);
+  const onExpr = EqColJoinOn.of(
+    ColumnRef.of(onLeft.table, onLeft.column),
+    ColumnRef.of(onRight.table, onRight.column),
+  );
+  const tableSource = TableSource.named(join.table.name, join.table.alias);
+
+  switch (join.joinType) {
+    case 'inner':
+      return JoinAst.inner(tableSource, onExpr);
+    case 'left':
+      return JoinAst.left(tableSource, onExpr);
+    case 'right':
+      return JoinAst.right(tableSource, onExpr);
+    case 'full':
+      return JoinAst.full(tableSource, onExpr);
+    default: {
+      const exhaustiveCheck: never = join.joinType;
+      throw new Error(`Unsupported join type: ${String(exhaustiveCheck)}`);
+    }
+  }
 }

package/src/sql/mutation-builder.ts

@@ -1,16 +1,15 @@
-import type { ParamDescriptor } from '@prisma-next/contract/types';
 import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
-import type { ColumnRef, ParamRef, TableRef } from '@prisma-next/sql-relational-core/ast';
 import {
-  createColumnRef,
-  createDeleteAst,
-  createInsertAst,
-  createParamRef,
-  createTableRef,
-  createUpdateAst,
+  ColumnRef,
+  DeleteAst,
+  InsertAst,
+  ParamRef,
+  type TableRef,
+  TableSource,
+  UpdateAst,
 } 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,7 +17,9 @@ import type {
   InferReturningRow,
   ParamPlaceholder,
   SqlBuilderOptions,
+  UnaryBuilder,
 } from '@prisma-next/sql-relational-core/types';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { checkReturningCapability } from '../utils/capabilities';
 import {
   errorFailedToBuildWhereClause,
@@ -32,6 +33,18 @@ import type { ProjectionState } from '../utils/state';
 import { buildMeta } from './plan';
 import { buildWhereExpr } from './predicate-builder';
 
+function deriveParamsFromAst(ast: { collectParamRefs(): ParamRef[] }) {
+  const collected = [...new Set(ast.collectParamRefs())];
+  return {
+    paramValues: collected.map((p) => p.value),
+    paramDescriptors: collected.map((p) => ({
+      ...ifDefined('name', p.name),
+      source: 'dsl' as const,
+      ...ifDefined('codecId', p.codecId),
+    })),
+  };
+}
+
 export interface InsertBuilder<
   TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,
   CodecTypes extends Record<string, { readonly output: unknown }> = Record<string, never>,
@@ -48,7 +61,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 +73,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 +87,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[] = [];
@@ -108,9 +121,6 @@ export class InsertBuilderImpl<
 
   build(options?: BuildOptions): SqlQueryPlan<Row> {
     const paramsMap = (options?.params ?? {}) as Record<string, unknown>;
-    const paramDescriptors: ParamDescriptor[] = [];
-    const paramValues: unknown[] = [];
-    const paramCodecs: Record<string, string> = {};
 
     const contractTable = this.contract.storage.tables[this.table.name];
     if (!contractTable) {
@@ -119,7 +129,8 @@ export class InsertBuilderImpl<
 
     const values: Record<string, ColumnRef | ParamRef> = {};
     for (const [columnName, placeholder] of Object.entries(this.values)) {
-      if (!contractTable.columns[columnName]) {
+      const columnMeta = contractTable.columns[columnName];
+      if (!columnMeta) {
         errorUnknownColumn(columnName, this.table.name);
       }
 
@@ -129,41 +140,44 @@ export class InsertBuilderImpl<
       }
 
       const value = paramsMap[paramName];
-      const index = paramValues.push(value);
+      values[columnName] = ParamRef.of(value, {
+        name: paramName,
+        codecId: columnMeta.codecId,
+      });
+    }
 
-      const columnMeta = contractTable.columns[columnName];
-      const codecId = columnMeta?.codecId;
-      if (paramName && codecId) {
-        paramCodecs[paramName] = codecId;
+    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);
       }
 
-      paramDescriptors.push({
-        name: paramName,
-        source: 'dsl',
-        refs: { table: this.table.name, column: columnName },
-        ...(codecId ? { codecId } : {}),
-        ...(columnMeta?.nativeType ? { nativeType: columnMeta.nativeType } : {}),
-        ...(columnMeta?.nullable !== undefined ? { nullable: columnMeta.nullable } : {}),
+      values[defaultValue.column] = ParamRef.of(defaultValue.value, {
+        name: defaultValue.column,
+        codecId: columnMeta.codecId,
       });
-
-      values[columnName] = createParamRef(index, paramName);
     }
 
     const returning: ColumnRef[] = this.returningColumns.map((col) => {
-      // TypeScript can't narrow ColumnBuilder properly
       const c = col as unknown as { table: string; column: string };
-      return createColumnRef(c.table, c.column);
+      return ColumnRef.of(c.table, c.column);
     });
 
-    const ast = createInsertAst({
-      table: createTableRef(this.table.name),
-      values,
-      returning,
-    });
+    let ast = InsertAst.into(TableSource.named(this.table.name)).withValues(values);
+    if (returning.length > 0) {
+      ast = ast.withReturning(returning);
+    }
+
+    const { paramValues, paramDescriptors } = deriveParamsFromAst(ast);
 
     const returningProjection: ProjectionState = {
       aliases: this.returningColumns.map((col) => {
-        // TypeScript can't narrow ColumnBuilder properly
         const c = col as unknown as { column: string };
         return c.column;
       }),
@@ -175,7 +189,6 @@ export class InsertBuilderImpl<
       table: this.table,
       projection: returning.length > 0 ? returningProjection : { aliases: [], columns: [] },
       paramDescriptors,
-      ...(Object.keys(paramCodecs).length > 0 ? { paramCodecs } : {}),
     });
 
     const queryPlan: SqlQueryPlan<Row> = Object.freeze({
@@ -203,10 +216,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 +233,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,
@@ -258,9 +271,6 @@ export class UpdateBuilderImpl<
     }
 
     const paramsMap = (options?.params ?? {}) as Record<string, unknown>;
-    const paramDescriptors: ParamDescriptor[] = [];
-    const paramValues: unknown[] = [];
-    const paramCodecs: Record<string, string> = {};
 
     const contractTable = this.contract.storage.tables[this.table.name];
     if (!contractTable) {
@@ -269,7 +279,8 @@ export class UpdateBuilderImpl<
 
     const set: Record<string, ColumnRef | ParamRef> = {};
     for (const [columnName, placeholder] of Object.entries(this.set)) {
-      if (!contractTable.columns[columnName]) {
+      const columnMeta = contractTable.columns[columnName];
+      if (!columnMeta) {
         errorUnknownColumn(columnName, this.table.name);
       }
 
@@ -279,58 +290,50 @@ export class UpdateBuilderImpl<
       }
 
       const value = paramsMap[paramName];
-      const index = paramValues.push(value);
+      set[columnName] = ParamRef.of(value, {
+        name: paramName,
+        codecId: columnMeta.codecId,
+      });
+    }
 
-      const columnMeta = contractTable.columns[columnName];
-      const codecId = columnMeta?.codecId;
-      if (paramName && codecId) {
-        paramCodecs[paramName] = codecId;
+    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);
       }
 
-      paramDescriptors.push({
-        name: paramName,
-        source: 'dsl',
-        refs: { table: this.table.name, column: columnName },
-        ...(codecId ? { codecId } : {}),
-        ...(columnMeta?.nativeType ? { nativeType: columnMeta.nativeType } : {}),
-        ...(columnMeta?.nullable !== undefined ? { nullable: columnMeta.nullable } : {}),
+      set[defaultValue.column] = ParamRef.of(defaultValue.value, {
+        name: defaultValue.column,
+        codecId: columnMeta.codecId,
       });
-
-      set[columnName] = createParamRef(index, paramName);
     }
 
-    const whereResult = buildWhereExpr(
-      this.contract,
-      this.wherePredicate,
-      paramsMap,
-      paramDescriptors,
-      paramValues,
-    );
+    const whereResult = buildWhereExpr(this.contract, this.wherePredicate, paramsMap);
     const whereExpr = whereResult.expr;
     if (!whereExpr) {
       errorFailedToBuildWhereClause();
     }
 
-    if (whereResult.codecId && whereResult.paramName) {
-      paramCodecs[whereResult.paramName] = whereResult.codecId;
-    }
-
     const returning: ColumnRef[] = this.returningColumns.map((col) => {
-      // TypeScript can't narrow ColumnBuilder properly
       const c = col as unknown as { table: string; column: string };
-      return createColumnRef(c.table, c.column);
+      return ColumnRef.of(c.table, c.column);
     });
 
-    const ast = createUpdateAst({
-      table: createTableRef(this.table.name),
-      set,
-      where: whereExpr,
-      returning,
-    });
+    let ast = UpdateAst.table(TableSource.named(this.table.name)).withSet(set).withWhere(whereExpr);
+    if (returning.length > 0) {
+      ast = ast.withReturning(returning);
+    }
+
+    const { paramValues, paramDescriptors } = deriveParamsFromAst(ast);
 
     const returningProjection: ProjectionState = {
       aliases: this.returningColumns.map((col) => {
-        // TypeScript can't narrow ColumnBuilder properly
         const c = col as unknown as { column: string };
         return c.column;
       }),
@@ -342,7 +345,6 @@ export class UpdateBuilderImpl<
       table: this.table,
       projection: returning.length > 0 ? returningProjection : { aliases: [], columns: [] },
       paramDescriptors,
-      ...(Object.keys(paramCodecs).length > 0 ? { paramCodecs } : {}),
       where: this.wherePredicate,
     });
 
@@ -372,9 +374,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 +385,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,
@@ -419,46 +421,32 @@ export class DeleteBuilderImpl<
     }
 
     const paramsMap = (options?.params ?? {}) as Record<string, unknown>;
-    const paramDescriptors: ParamDescriptor[] = [];
-    const paramValues: unknown[] = [];
-    const paramCodecs: Record<string, string> = {};
 
     const contractTable = this.contract.storage.tables[this.table.name];
     if (!contractTable) {
       errorUnknownTable(this.table.name);
     }
 
-    const whereResult = buildWhereExpr(
-      this.contract,
-      this.wherePredicate,
-      paramsMap,
-      paramDescriptors,
-      paramValues,
-    );
+    const whereResult = buildWhereExpr(this.contract, this.wherePredicate, paramsMap);
     const whereExpr = whereResult.expr;
     if (!whereExpr) {
       errorFailedToBuildWhereClause();
     }
 
-    if (whereResult.codecId && whereResult.paramName) {
-      paramCodecs[whereResult.paramName] = whereResult.codecId;
-    }
-
     const returning: ColumnRef[] = this.returningColumns.map((col) => {
-      // TypeScript can't narrow ColumnBuilder properly
       const c = col as unknown as { table: string; column: string };
-      return createColumnRef(c.table, c.column);
+      return ColumnRef.of(c.table, c.column);
     });
 
-    const ast = createDeleteAst({
-      table: createTableRef(this.table.name),
-      where: whereExpr,
-      returning,
-    });
+    let ast = DeleteAst.from(TableSource.named(this.table.name)).withWhere(whereExpr);
+    if (returning.length > 0) {
+      ast = ast.withReturning(returning);
+    }
+
+    const { paramValues, paramDescriptors } = deriveParamsFromAst(ast);
 
     const returningProjection: ProjectionState = {
       aliases: this.returningColumns.map((col) => {
-        // TypeScript can't narrow ColumnBuilder properly
         const c = col as unknown as { column: string };
         return c.column;
       }),
@@ -470,7 +458,6 @@ export class DeleteBuilderImpl<
       table: this.table,
       projection: returning.length > 0 ? returningProjection : { aliases: [], columns: [] },
       paramDescriptors,
-      ...(Object.keys(paramCodecs).length > 0 ? { paramCodecs } : {}),
       where: this.wherePredicate,
     });