@prisma-next/adapter-postgres 0.3.0-pr.99.6 → 0.4.0-dev.1

package/src/core/adapter.ts

@@ -1,27 +1,61 @@
-import type {
-  Adapter,
-  AdapterProfile,
-  BinaryExpr,
-  ColumnRef,
-  DeleteAst,
-  ExistsExpr,
-  IncludeRef,
-  InsertAst,
-  JoinAst,
+import {
+  type Adapter,
+  type AdapterProfile,
+  type AggregateExpr,
+  type AnyExpression,
+  type AnyFromSource,
+  type AnyQueryAst,
+  type BinaryExpr,
+  type CodecParamsDescriptor,
+  type ColumnRef,
+  createCodecRegistry,
+  type DeleteAst,
+  type InsertAst,
+  type InsertValue,
+  type JoinAst,
+  type JoinOnExpr,
+  type JsonArrayAggExpr,
+  type JsonObjectExpr,
+  type ListExpression,
   LiteralExpr,
-  LowererContext,
-  OperationExpr,
-  ParamRef,
-  QueryAst,
-  SelectAst,
-  UpdateAst,
+  type LowererContext,
+  type NullCheckExpr,
+  type OperationExpr,
+  type OrderByItem,
+  type ParamRef,
+  type ProjectionItem,
+  type SelectAst,
+  type SubqueryExpr,
+  type UpdateAst,
 } from '@prisma-next/sql-relational-core/ast';
-import { createCodecRegistry, isOperationExpr } from '@prisma-next/sql-relational-core/ast';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { PG_JSON_CODEC_ID, PG_JSONB_CODEC_ID } from './codec-ids';
 import { codecDefinitions } from './codecs';
+import { escapeLiteral, quoteIdentifier } from './sql-utils';
 import type { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } from './types';
 
 const VECTOR_CODEC_ID = 'pg/vector@1' as const;
 
+function getCodecParamCast(codecId: string | undefined): string | undefined {
+  if (codecId === VECTOR_CODEC_ID) {
+    return 'vector';
+  }
+  if (codecId === PG_JSON_CODEC_ID) {
+    return 'json';
+  }
+  if (codecId === PG_JSONB_CODEC_ID) {
+    return 'jsonb';
+  }
+  return undefined;
+}
+
+function renderTypedParam(index: number, codecId: string | undefined): string {
+  const cast = getCodecParamCast(codecId);
+  return cast ? `$${index}::${cast}` : `$${index}`;
+}
+
+type ParamIndexMap = Map<ParamRef, number>;
+
 const defaultCapabilities = Object.freeze({
   postgres: {
     orderBy: true,
@@ -30,9 +64,32 @@ const defaultCapabilities = Object.freeze({
     jsonAgg: true,
     returning: true,
   },
+  sql: {
+    enums: true,
+    returning: true,
+    defaultInInsert: true,
+  },
 });
 
-class PostgresAdapterImpl implements Adapter<QueryAst, PostgresContract, PostgresLoweredStatement> {
+type AdapterCodec = (typeof codecDefinitions)[keyof typeof codecDefinitions]['codec'];
+type ParameterizedCodec = AdapterCodec & {
+  readonly paramsSchema: NonNullable<AdapterCodec['paramsSchema']>;
+};
+
+const parameterizedCodecs: ReadonlyArray<CodecParamsDescriptor> = Object.values(codecDefinitions)
+  .map((definition) => definition.codec)
+  .filter((codec): codec is ParameterizedCodec => codec.paramsSchema !== undefined)
+  .map((codec) =>
+    Object.freeze({
+      codecId: codec.id,
+      paramsSchema: codec.paramsSchema,
+      ...ifDefined('init', codec.init),
+    }),
+  );
+
+class PostgresAdapterImpl
+  implements Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement>
+{
   // These fields make the adapter instance structurally compatible with
   // RuntimeAdapterInstance<'sql', 'postgres'> without introducing a runtime-plane dependency.
   readonly familyId = 'sql' as const;
@@ -53,23 +110,50 @@ class PostgresAdapterImpl implements Adapter<QueryAst, PostgresContract, Postgre
       target: 'postgres',
       capabilities: defaultCapabilities,
       codecs: () => this.codecRegistry,
+      readMarkerStatement: () => ({
+        sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1',
+        params: [1],
+      }),
     });
   }
 
-  lower(ast: QueryAst, context: LowererContext<PostgresContract>) {
+  parameterizedCodecs(): ReadonlyArray<CodecParamsDescriptor> {
+    return parameterizedCodecs;
+  }
+
+  lower(ast: AnyQueryAst, context: LowererContext<PostgresContract>) {
+    const collectedParamRefs = ast.collectParamRefs();
+    const paramIndexMap: ParamIndexMap = new Map();
+    const params: unknown[] = [];
+    for (const ref of collectedParamRefs) {
+      if (paramIndexMap.has(ref)) {
+        continue;
+      }
+      paramIndexMap.set(ref, params.length + 1);
+      params.push(ref.value);
+    }
+
     let sql: string;
-    const params = context.params ? [...context.params] : [];
-
-    if (ast.kind === 'select') {
-      sql = renderSelect(ast, context.contract);
-    } else if (ast.kind === 'insert') {
-      sql = renderInsert(ast, context.contract);
-    } else if (ast.kind === 'update') {
-      sql = renderUpdate(ast, context.contract);
-    } else if (ast.kind === 'delete') {
-      sql = renderDelete(ast, context.contract);
-    } else {
-      throw new Error(`Unsupported AST kind: ${(ast as { kind: string }).kind}`);
+
+    const node = ast;
+    switch (node.kind) {
+      case 'select':
+        sql = renderSelect(node, context.contract, paramIndexMap);
+        break;
+      case 'insert':
+        sql = renderInsert(node, context.contract, paramIndexMap);
+        break;
+      case 'update':
+        sql = renderUpdate(node, context.contract, paramIndexMap);
+        break;
+      case 'delete':
+        sql = renderDelete(node, context.contract, paramIndexMap);
+        break;
+      // v8 ignore next 4
+      default:
+        throw new Error(
+          `Unsupported AST node kind: ${(node satisfies never as { kind: string }).kind}`,
+        );
     }
 
     return Object.freeze({
@@ -79,84 +163,175 @@ class PostgresAdapterImpl implements Adapter<QueryAst, PostgresContract, Postgre
   }
 }
 
-function renderSelect(ast: SelectAst, contract?: PostgresContract): string {
-  const selectClause = `SELECT ${renderProjection(ast, contract)}`;
-  const fromClause = `FROM ${quoteIdentifier(ast.from.name)}`;
+function renderSelect(ast: SelectAst, contract?: PostgresContract, pim?: ParamIndexMap): string {
+  const selectClause = `SELECT ${renderDistinctPrefix(ast.distinct, ast.distinctOn, contract, pim)}${renderProjection(
+    ast.projection,
+    contract,
+    pim,
+  )}`;
+  const fromClause = `FROM ${renderSource(ast.from, contract, pim)}`;
 
   const joinsClause = ast.joins?.length
-    ? ast.joins.map((join) => renderJoin(join, contract)).join(' ')
-    : '';
-  const includesClause = ast.includes?.length
-    ? ast.includes.map((include) => renderInclude(include, contract)).join(' ')
+    ? ast.joins.map((join) => renderJoin(join, contract, pim)).join(' ')
     : '';
 
-  const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract)}` : '';
+  const whereClause = ast.where ? `WHERE ${renderWhere(ast.where, contract, pim)}` : '';
+  const groupByClause = ast.groupBy?.length
+    ? `GROUP BY ${ast.groupBy.map((expr) => renderExpr(expr, contract, pim)).join(', ')}`
+    : '';
+  const havingClause = ast.having ? `HAVING ${renderWhere(ast.having, contract, pim)}` : '';
   const orderClause = ast.orderBy?.length
-    ? ` ORDER BY ${ast.orderBy
+    ? `ORDER BY ${ast.orderBy
         .map((order) => {
-          const expr = renderExpr(order.expr as ColumnRef | OperationExpr, contract);
+          const expr = renderExpr(order.expr, contract, pim);
           return `${expr} ${order.dir.toUpperCase()}`;
         })
         .join(', ')}`
     : '';
-  const limitClause = typeof ast.limit === 'number' ? ` LIMIT ${ast.limit}` : '';
-
-  const clauses = [joinsClause, includesClause].filter(Boolean).join(' ');
-  return `${selectClause} ${fromClause}${clauses ? ` ${clauses}` : ''}${whereClause}${orderClause}${limitClause}`.trim();
+  const limitClause = typeof ast.limit === 'number' ? `LIMIT ${ast.limit}` : '';
+  const offsetClause = typeof ast.offset === 'number' ? `OFFSET ${ast.offset}` : '';
+
+  const clauses = [
+    selectClause,
+    fromClause,
+    joinsClause,
+    whereClause,
+    groupByClause,
+    havingClause,
+    orderClause,
+    limitClause,
+    offsetClause,
+  ]
+    .filter((part) => part.length > 0)
+    .join(' ');
+  return clauses.trim();
 }
 
-function renderProjection(ast: SelectAst, contract?: PostgresContract): string {
-  return ast.project
+function renderProjection(
+  projection: ReadonlyArray<ProjectionItem>,
+  contract?: PostgresContract,
+  pim?: ParamIndexMap,
+): string {
+  return projection
     .map((item) => {
-      const expr = item.expr as ColumnRef | IncludeRef | OperationExpr | LiteralExpr;
-      if (expr.kind === 'includeRef') {
-        // For include references, select the column from the LATERAL join alias
-        // The LATERAL subquery returns a single column (the JSON array) with the alias
-        // The table is aliased as {alias}_lateral, and the column inside is aliased as the include alias
-        // We select it using table_alias.column_alias
-        const tableAlias = `${expr.alias}_lateral`;
-        return `${quoteIdentifier(tableAlias)}.${quoteIdentifier(expr.alias)} AS ${quoteIdentifier(item.alias)}`;
-      }
-      if (expr.kind === 'operation') {
-        const operation = renderOperation(expr, contract);
-        const alias = quoteIdentifier(item.alias);
-        return `${operation} AS ${alias}`;
-      }
-      if (expr.kind === 'literal') {
-        const literal = renderLiteral(expr);
-        const alias = quoteIdentifier(item.alias);
-        return `${literal} AS ${alias}`;
-      }
-      const column = renderColumn(expr as ColumnRef);
       const alias = quoteIdentifier(item.alias);
-      return `${column} AS ${alias}`;
+      if (item.expr.kind === 'literal') {
+        return `${renderLiteral(item.expr)} AS ${alias}`;
+      }
+      return `${renderExpr(item.expr, contract, pim)} AS ${alias}`;
     })
     .join(', ');
 }
 
-function renderWhere(expr: BinaryExpr | ExistsExpr, contract?: PostgresContract): string {
-  if (expr.kind === 'exists') {
-    const notKeyword = expr.not ? 'NOT ' : '';
-    const subquery = renderSelect(expr.subquery, contract);
-    return `${notKeyword}EXISTS (${subquery})`;
+function renderDistinctPrefix(
+  distinct: true | undefined,
+  distinctOn: ReadonlyArray<AnyExpression> | undefined,
+  contract?: PostgresContract,
+  pim?: ParamIndexMap,
+): string {
+  if (distinctOn && distinctOn.length > 0) {
+    const rendered = distinctOn.map((expr) => renderExpr(expr, contract, pim)).join(', ');
+    return `DISTINCT ON (${rendered}) `;
   }
-  return renderBinary(expr, contract);
+  if (distinct) {
+    return 'DISTINCT ';
+  }
+  return '';
 }
 
-function renderBinary(expr: BinaryExpr, contract?: PostgresContract): string {
-  const leftExpr = expr.left as ColumnRef | OperationExpr;
-  const left = renderExpr(leftExpr, contract);
-  // Handle both ParamRef and ColumnRef on the right side
-  // (ColumnRef can appear in EXISTS subqueries for correlation)
-  const rightExpr = expr.right as ParamRef | ColumnRef;
-  const right =
-    rightExpr.kind === 'col'
-      ? renderColumn(rightExpr)
-      : renderParam(rightExpr as ParamRef, contract);
-  // Only wrap in parentheses if it's an operation expression
-  const leftRendered = isOperationExpr(leftExpr) ? `(${left})` : left;
-
-  // Map operators to SQL symbols
+function renderSource(
+  source: AnyFromSource,
+  contract?: PostgresContract,
+  pim?: ParamIndexMap,
+): string {
+  const node = source;
+  switch (node.kind) {
+    case 'table-source': {
+      const table = quoteIdentifier(node.name);
+      if (!node.alias) {
+        return table;
+      }
+      return `${table} AS ${quoteIdentifier(node.alias)}`;
+    }
+    case 'derived-table-source':
+      return `(${renderSelect(node.query, contract, pim)}) AS ${quoteIdentifier(node.alias)}`;
+    // v8 ignore next 4
+    default:
+      throw new Error(
+        `Unsupported source node kind: ${(node satisfies never as { kind: string }).kind}`,
+      );
+  }
+}
+
+function assertScalarSubquery(query: SelectAst): void {
+  if (query.projection.length !== 1) {
+    throw new Error('Subquery expressions must project exactly one column');
+  }
+}
+
+function renderSubqueryExpr(
+  expr: SubqueryExpr,
+  contract?: PostgresContract,
+  pim?: ParamIndexMap,
+): string {
+  assertScalarSubquery(expr.query);
+  return `(${renderSelect(expr.query, contract, pim)})`;
+}
+
+function renderWhere(
+  expr: AnyExpression,
+  contract?: PostgresContract,
+  pim?: ParamIndexMap,
+): string {
+  return renderExpr(expr, contract, pim);
+}
+
+function renderNullCheck(
+  expr: NullCheckExpr,
+  contract?: PostgresContract,
+  pim?: ParamIndexMap,
+): string {
+  const rendered = renderExpr(expr.expr, contract, pim);
+  const renderedExpr =
+    expr.expr.kind === 'operation' || expr.expr.kind === 'subquery' ? `(${rendered})` : rendered;
+  return expr.isNull ? `${renderedExpr} IS NULL` : `${renderedExpr} IS NOT NULL`;
+}
+
+function renderBinary(expr: BinaryExpr, contract?: PostgresContract, pim?: ParamIndexMap): string {
+  if (expr.right.kind === 'list' && expr.right.values.length === 0) {
+    if (expr.op === 'in') {
+      return 'FALSE';
+    }
+    if (expr.op === 'notIn') {
+      return 'TRUE';
+    }
+  }
+
+  const leftExpr = expr.left;
+  const left = renderExpr(leftExpr, contract, pim);
+  const leftRendered =
+    leftExpr.kind === 'operation' || leftExpr.kind === 'subquery' ? `(${left})` : left;
+
+  const rightNode = expr.right;
+  let right: string;
+  switch (rightNode.kind) {
+    case 'list':
+      right = renderListLiteral(rightNode, pim);
+      break;
+    case 'literal':
+      right = renderLiteral(rightNode);
+      break;
+    case 'column-ref':
+      right = renderColumn(rightNode);
+      break;
+    case 'param-ref':
+      right = renderParamRef(rightNode, pim);
+      break;
+    default:
+      right = renderExpr(rightNode, contract, pim);
+      break;
+  }
+
   const operatorMap: Record<BinaryExpr['op'], string> = {
     eq: '=',
     neq: '!=',
@@ -164,249 +339,353 @@ function renderBinary(expr: BinaryExpr, contract?: PostgresContract): string {
     lt: '<',
     gte: '>=',
     lte: '<=',
+    like: 'LIKE',
+    ilike: 'ILIKE',
+    in: 'IN',
+    notIn: 'NOT IN',
   };
 
   return `${leftRendered} ${operatorMap[expr.op]} ${right}`;
 }
 
+function renderListLiteral(expr: ListExpression, pim?: ParamIndexMap): string {
+  if (expr.values.length === 0) {
+    return '(NULL)';
+  }
+  const values = expr.values
+    .map((v) => {
+      if (v.kind === 'param-ref') return renderParamRef(v, pim);
+      if (v.kind === 'literal') return renderLiteral(v);
+      return renderExpr(v, undefined, pim);
+    })
+    .join(', ');
+  return `(${values})`;
+}
+
 function renderColumn(ref: ColumnRef): string {
+  if (ref.table === 'excluded') {
+    return `excluded.${quoteIdentifier(ref.column)}`;
+  }
   return `${quoteIdentifier(ref.table)}.${quoteIdentifier(ref.column)}`;
 }
 
-function renderExpr(expr: ColumnRef | OperationExpr, contract?: PostgresContract): string {
-  if (isOperationExpr(expr)) {
-    return renderOperation(expr, contract);
+function renderAggregateExpr(
+  expr: AggregateExpr,
+  contract?: PostgresContract,
+  pim?: ParamIndexMap,
+): string {
+  const fn = expr.fn.toUpperCase();
+  if (!expr.expr) {
+    return `${fn}(*)`;
   }
-  return renderColumn(expr);
+  return `${fn}(${renderExpr(expr.expr, contract, pim)})`;
+}
+
+function renderJsonObjectExpr(
+  expr: JsonObjectExpr,
+  contract?: PostgresContract,
+  pim?: ParamIndexMap,
+): string {
+  const args = expr.entries
+    .flatMap((entry): [string, string] => {
+      const key = `'${escapeLiteral(entry.key)}'`;
+      if (entry.value.kind === 'literal') {
+        return [key, renderLiteral(entry.value)];
+      }
+      return [key, renderExpr(entry.value, contract, pim)];
+    })
+    .join(', ');
+  return `json_build_object(${args})`;
 }
 
-function renderParam(
-  ref: ParamRef,
+function renderOrderByItems(
+  items: ReadonlyArray<OrderByItem>,
   contract?: PostgresContract,
-  tableName?: string,
-  columnName?: string,
+  pim?: ParamIndexMap,
 ): string {
-  // Cast vector parameters to vector type for PostgreSQL
-  if (contract && tableName && columnName) {
-    const tableMeta = contract.storage.tables[tableName];
-    const columnMeta = tableMeta?.columns[columnName];
-    if (columnMeta?.codecId === VECTOR_CODEC_ID) {
-      return `$${ref.index}::vector`;
+  return items
+    .map((item) => `${renderExpr(item.expr, contract, pim)} ${item.dir.toUpperCase()}`)
+    .join(', ');
+}
+
+function renderJsonArrayAggExpr(
+  expr: JsonArrayAggExpr,
+  contract?: PostgresContract,
+  pim?: ParamIndexMap,
+): string {
+  const aggregateOrderBy =
+    expr.orderBy && expr.orderBy.length > 0
+      ? ` ORDER BY ${renderOrderByItems(expr.orderBy, contract, pim)}`
+      : '';
+  const aggregated = `json_agg(${renderExpr(expr.expr, contract, pim)}${aggregateOrderBy})`;
+  if (expr.onEmpty === 'emptyArray') {
+    return `coalesce(${aggregated}, json_build_array())`;
+  }
+  return aggregated;
+}
+
+function renderExpr(expr: AnyExpression, contract?: PostgresContract, pim?: ParamIndexMap): string {
+  const node = expr;
+  switch (node.kind) {
+    case 'column-ref':
+      return renderColumn(node);
+    case 'identifier-ref':
+      return quoteIdentifier(node.name);
+    case 'operation':
+      return renderOperation(node, contract, pim);
+    case 'subquery':
+      return renderSubqueryExpr(node, contract, pim);
+    case 'aggregate':
+      return renderAggregateExpr(node, contract, pim);
+    case 'json-object':
+      return renderJsonObjectExpr(node, contract, pim);
+    case 'json-array-agg':
+      return renderJsonArrayAggExpr(node, contract, pim);
+    case 'binary':
+      return renderBinary(node, contract, pim);
+    case 'and':
+      if (node.exprs.length === 0) {
+        return 'TRUE';
+      }
+      return `(${node.exprs.map((part) => renderExpr(part, contract, pim)).join(' AND ')})`;
+    case 'or':
+      if (node.exprs.length === 0) {
+        return 'FALSE';
+      }
+      return `(${node.exprs.map((part) => renderExpr(part, contract, pim)).join(' OR ')})`;
+    case 'exists': {
+      const notKeyword = node.notExists ? 'NOT ' : '';
+      const subquery = renderSelect(node.subquery, contract, pim);
+      return `${notKeyword}EXISTS (${subquery})`;
     }
+    case 'null-check':
+      return renderNullCheck(node, contract, pim);
+    case 'not':
+      return `NOT (${renderExpr(node.expr, contract, pim)})`;
+    case 'param-ref':
+      return renderParamRef(node, pim);
+    case 'literal':
+      return renderLiteral(node);
+    case 'list':
+      return renderListLiteral(node, pim);
+    // v8 ignore next 4
+    default:
+      throw new Error(
+        `Unsupported expression node kind: ${(node satisfies never as { kind: string }).kind}`,
+      );
   }
-  return `$${ref.index}`;
+}
+
+function renderParamRef(ref: ParamRef, pim?: ParamIndexMap): string {
+  const index = pim?.get(ref);
+  if (index === undefined) {
+    throw new Error('ParamRef not found in index map');
+  }
+  return renderTypedParam(index, ref.codecId);
 }
 
 function renderLiteral(expr: LiteralExpr): string {
   if (typeof expr.value === 'string') {
-    return `'${expr.value.replace(/'/g, "''")}'`;
+    return `'${escapeLiteral(expr.value)}'`;
   }
   if (typeof expr.value === 'number' || typeof expr.value === 'boolean') {
     return String(expr.value);
   }
+  if (typeof expr.value === 'bigint') {
+    return String(expr.value);
+  }
   if (expr.value === null) {
     return 'NULL';
   }
+  if (expr.value === undefined) {
+    return 'NULL';
+  }
+  if (expr.value instanceof Date) {
+    return `'${escapeLiteral(expr.value.toISOString())}'`;
+  }
   if (Array.isArray(expr.value)) {
-    return `ARRAY[${expr.value.map((v: unknown) => renderLiteral({ kind: 'literal', value: v })).join(', ')}]`;
+    return `ARRAY[${expr.value.map((v: unknown) => renderLiteral(new LiteralExpr(v))).join(', ')}]`;
   }
-  return JSON.stringify(expr.value);
+  const json = JSON.stringify(expr.value);
+  if (json === undefined) {
+    return 'NULL';
+  }
+  return `'${escapeLiteral(json)}'`;
 }
 
-function renderOperation(expr: OperationExpr, contract?: PostgresContract): string {
-  const self = renderExpr(expr.self, contract);
-  // For vector operations, cast param arguments to vector type
-  const isVectorOperation = expr.forTypeId === VECTOR_CODEC_ID;
-  const args = expr.args.map((arg: ColumnRef | ParamRef | LiteralExpr | OperationExpr) => {
-    if (arg.kind === 'col') {
-      return renderColumn(arg);
-    }
-    if (arg.kind === 'param') {
-      // Cast vector operation parameters to vector type
-      return isVectorOperation ? `$${arg.index}::vector` : renderParam(arg, contract);
-    }
-    if (arg.kind === 'literal') {
-      return renderLiteral(arg);
-    }
-    if (arg.kind === 'operation') {
-      return renderOperation(arg, contract);
-    }
-    const _exhaustive: never = arg;
-    throw new Error(`Unsupported argument kind: ${(_exhaustive as { kind: string }).kind}`);
+function renderOperation(
+  expr: OperationExpr,
+  contract?: PostgresContract,
+  pim?: ParamIndexMap,
+): string {
+  const self = renderExpr(expr.self, contract, pim);
+  const args = expr.args.map((arg) => {
+    return renderExpr(arg, contract, pim);
   });
 
   let result = expr.lowering.template;
-  result = result.replace(/\$\{self\}/g, self);
+  result = result.replace(/\{\{self\}\}/g, self);
   for (let i = 0; i < args.length; i++) {
-    result = result.replace(new RegExp(`\\$\\{arg${i}\\}`, 'g'), args[i] ?? '');
-  }
-
-  if (expr.lowering.strategy === 'function') {
-    return result;
+    result = result.replace(new RegExp(`\\{\\{arg${i}\\}\\}`, 'g'), args[i] ?? '');
   }
 
   return result;
 }
 
-function renderJoin(join: JoinAst, _contract?: PostgresContract): string {
+function renderJoin(join: JoinAst, contract?: PostgresContract, pim?: ParamIndexMap): string {
   const joinType = join.joinType.toUpperCase();
-  const table = quoteIdentifier(join.table.name);
-  const onClause = renderJoinOn(join.on);
-  return `${joinType} JOIN ${table} ON ${onClause}`;
+  const lateral = join.lateral ? 'LATERAL ' : '';
+  const source = renderSource(join.source, contract, pim);
+  const onClause = renderJoinOn(join.on, contract, pim);
+  return `${joinType} JOIN ${lateral}${source} ON ${onClause}`;
 }
 
-function renderJoinOn(on: JoinAst['on']): string {
-  if (on.kind === 'eqCol') {
+function renderJoinOn(on: JoinOnExpr, contract?: PostgresContract, pim?: ParamIndexMap): string {
+  if (on.kind === 'eq-col-join-on') {
     const left = renderColumn(on.left);
     const right = renderColumn(on.right);
     return `${left} = ${right}`;
   }
-  throw new Error(`Unsupported join ON expression kind: ${on.kind}`);
+  return renderWhere(on, contract, pim);
 }
 
-function renderInclude(
-  include: NonNullable<SelectAst['includes']>[number],
-  contract?: PostgresContract,
-): string {
-  const alias = include.alias;
+function getInsertColumnOrder(
+  rows: ReadonlyArray<Record<string, InsertValue>>,
+  contract: PostgresContract,
+  tableName: string,
+): string[] {
+  const orderedColumns: string[] = [];
+  const seenColumns = new Set<string>();
+
+  for (const row of rows) {
+    for (const column of Object.keys(row)) {
+      if (seenColumns.has(column)) {
+        continue;
+      }
+      seenColumns.add(column);
+      orderedColumns.push(column);
+    }
+  }
 
-  // Build the lateral subquery
-  const childProjection = include.child.project
-    .map((item: { alias: string; expr: ColumnRef | OperationExpr }) => {
-      const expr = renderExpr(item.expr, contract);
-      return `'${item.alias}', ${expr}`;
-    })
-    .join(', ');
+  if (orderedColumns.length > 0) {
+    return orderedColumns;
+  }
 
-  const jsonBuildObject = `json_build_object(${childProjection})`;
+  return Object.keys(contract.storage.tables[tableName]?.columns ?? {});
+}
 
-  // Build the ON condition from the include's ON clause - this goes in the WHERE clause
-  const onCondition = renderJoinOn(include.child.on);
+function renderInsertValue(value: InsertValue | undefined, pim?: ParamIndexMap): string {
+  if (!value || value.kind === 'default-value') {
+    return 'DEFAULT';
+  }
 
-  // Build WHERE clause: combine ON condition with any additional WHERE clauses
-  let whereClause = ` WHERE ${onCondition}`;
-  if (include.child.where) {
-    whereClause += ` AND ${renderWhere(include.child.where, contract)}`;
+  switch (value.kind) {
+    case 'param-ref':
+      return renderParamRef(value, pim);
+    case 'column-ref':
+      return renderColumn(value);
+    // v8 ignore next 4
+    default:
+      throw new Error(
+        `Unsupported value node in INSERT: ${(value satisfies never as { kind: string }).kind}`,
+      );
   }
+}
 
-  // Add ORDER BY if present - it goes inside json_agg() call
-  const childOrderBy = include.child.orderBy?.length
-    ? ` ORDER BY ${include.child.orderBy
-        .map(
-          (order: { expr: ColumnRef | OperationExpr; dir: string }) =>
-            `${renderExpr(order.expr, contract)} ${order.dir.toUpperCase()}`,
-        )
-        .join(', ')}`
-    : '';
+function renderInsert(ast: InsertAst, contract: PostgresContract, pim?: ParamIndexMap): string {
+  const table = quoteIdentifier(ast.table.name);
+  const rows = ast.rows;
+  if (rows.length === 0) {
+    throw new Error('INSERT requires at least one row');
+  }
+  const hasExplicitValues = rows.some((row) => Object.keys(row).length > 0);
+  const insertClause = (() => {
+    if (!hasExplicitValues) {
+      if (rows.length === 1) {
+        return `INSERT INTO ${table} DEFAULT VALUES`;
+      }
 
-  // Add LIMIT if present
-  const childLimit = typeof include.child.limit === 'number' ? ` LIMIT ${include.child.limit}` : '';
-
-  // Build the lateral subquery
-  // When ORDER BY is present without LIMIT, it goes inside json_agg() call: json_agg(expr ORDER BY ...)
-  // When LIMIT is present (with or without ORDER BY), we need to wrap in a subquery
-  const childTable = quoteIdentifier(include.child.table.name);
-  let subquery: string;
-  if (typeof include.child.limit === 'number') {
-    // With LIMIT, we need to wrap in a subquery
-    // Select individual columns in inner query, then aggregate
-    // Create a map of column references to their aliases for ORDER BY
-    // Only ColumnRef can be mapped (OperationExpr doesn't have table/column properties)
-    const columnAliasMap = new Map<string, string>();
-    for (const item of include.child.project) {
-      if (item.expr.kind === 'col') {
-        const columnKey = `${item.expr.table}.${item.expr.column}`;
-        columnAliasMap.set(columnKey, item.alias);
+      const defaultColumns = getInsertColumnOrder(rows, contract, ast.table.name);
+      if (defaultColumns.length === 0) {
+        return `INSERT INTO ${table} VALUES ${rows.map(() => '()').join(', ')}`;
       }
+
+      const quotedColumns = defaultColumns.map((column) => quoteIdentifier(column));
+      const defaultRow = `(${defaultColumns.map(() => 'DEFAULT').join(', ')})`;
+      return `INSERT INTO ${table} (${quotedColumns.join(', ')}) VALUES ${rows
+        .map(() => defaultRow)
+        .join(', ')}`;
     }
 
-    const innerColumns = include.child.project
-      .map((item: { alias: string; expr: ColumnRef | OperationExpr }) => {
-        const expr = renderExpr(item.expr, contract);
-        return `${expr} AS ${quoteIdentifier(item.alias)}`;
+    const columnOrder = getInsertColumnOrder(rows, contract, ast.table.name);
+    const columns = columnOrder.map((column) => quoteIdentifier(column));
+    const values = rows
+      .map((row) => {
+        const renderedRow = columnOrder.map((column) => renderInsertValue(row[column], pim));
+        return `(${renderedRow.join(', ')})`;
       })
       .join(', ');
 
-    // For ORDER BY, use column aliases if the column is in the SELECT list
-    const childOrderByWithAliases = include.child.orderBy?.length
-      ? ` ORDER BY ${include.child.orderBy
-          .map((order: { expr: ColumnRef | OperationExpr; dir: string }) => {
-            if (order.expr.kind === 'col') {
-              const columnKey = `${order.expr.table}.${order.expr.column}`;
-              const alias = columnAliasMap.get(columnKey);
-              if (alias) {
-                return `${quoteIdentifier(alias)} ${order.dir.toUpperCase()}`;
+    return `INSERT INTO ${table} (${columns.join(', ')}) VALUES ${values}`;
+  })();
+  const onConflictClause = ast.onConflict
+    ? (() => {
+        const conflictColumns = ast.onConflict.columns.map((col) => quoteIdentifier(col.column));
+        if (conflictColumns.length === 0) {
+          throw new Error('INSERT onConflict requires at least one conflict column');
+        }
+
+        const action = ast.onConflict.action;
+        switch (action.kind) {
+          case 'do-nothing':
+            return ` ON CONFLICT (${conflictColumns.join(', ')}) DO NOTHING`;
+          case 'do-update-set': {
+            const updates = Object.entries(action.set).map(([colName, value]) => {
+              const target = quoteIdentifier(colName);
+              if (value.kind === 'param-ref') {
+                return `${target} = ${renderParamRef(value, pim)}`;
               }
-            }
-            return `${renderExpr(order.expr, contract)} ${order.dir.toUpperCase()}`;
-          })
-          .join(', ')}`
-      : '';
-
-    const innerSelect = `SELECT ${innerColumns} FROM ${childTable}${whereClause}${childOrderByWithAliases}${childLimit}`;
-    subquery = `(SELECT json_agg(row_to_json(sub.*)) AS ${quoteIdentifier(alias)} FROM (${innerSelect}) sub)`;
-  } else if (childOrderBy) {
-    // With ORDER BY but no LIMIT, ORDER BY goes inside json_agg()
-    subquery = `(SELECT json_agg(${jsonBuildObject}${childOrderBy}) AS ${quoteIdentifier(alias)} FROM ${childTable}${whereClause})`;
-  } else {
-    // No ORDER BY or LIMIT
-    subquery = `(SELECT json_agg(${jsonBuildObject}) AS ${quoteIdentifier(alias)} FROM ${childTable}${whereClause})`;
-  }
-
-  // Return the LATERAL join with ON true (the condition is in the WHERE clause)
-  // The subquery returns a single column (the JSON array) with the alias
-  // We use a different alias for the table to avoid ambiguity when selecting the column
-  const tableAlias = `${alias}_lateral`;
-  return `LEFT JOIN LATERAL ${subquery} AS ${quoteIdentifier(tableAlias)} ON true`;
-}
-
-function quoteIdentifier(identifier: string): string {
-  return `"${identifier.replace(/"/g, '""')}"`;
-}
-
-function renderInsert(ast: InsertAst, contract: PostgresContract): string {
-  const table = quoteIdentifier(ast.table.name);
-  const columns = Object.keys(ast.values).map((col) => quoteIdentifier(col));
-  const tableMeta = contract.storage.tables[ast.table.name];
-  const values = Object.entries(ast.values).map(([colName, val]) => {
-    if (val.kind === 'param') {
-      const columnMeta = tableMeta?.columns[colName];
-      const isVector = columnMeta?.codecId === VECTOR_CODEC_ID;
-      return isVector ? `$${val.index}::vector` : `$${val.index}`;
-    }
-    if (val.kind === 'col') {
-      return `${quoteIdentifier(val.table)}.${quoteIdentifier(val.column)}`;
-    }
-    throw new Error(`Unsupported value kind in INSERT: ${(val as { kind: string }).kind}`);
-  });
-
-  const insertClause = `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${values.join(', ')})`;
+              return `${target} = ${renderColumn(value)}`;
+            });
+            return ` ON CONFLICT (${conflictColumns.join(', ')}) DO UPDATE SET ${updates.join(', ')}`;
+          }
+          // v8 ignore next 4
+          default:
+            throw new Error(
+              `Unsupported onConflict action: ${(action satisfies never as { kind: string }).kind}`,
+            );
+        }
+      })()
+    : '';
   const returningClause = ast.returning?.length
     ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`
     : '';
 
-  return `${insertClause}${returningClause}`;
+  return `${insertClause}${onConflictClause}${returningClause}`;
 }
 
-function renderUpdate(ast: UpdateAst, contract: PostgresContract): string {
+function renderUpdate(ast: UpdateAst, contract: PostgresContract, pim?: ParamIndexMap): string {
   const table = quoteIdentifier(ast.table.name);
-  const tableMeta = contract.storage.tables[ast.table.name];
   const setClauses = Object.entries(ast.set).map(([col, val]) => {
     const column = quoteIdentifier(col);
     let value: string;
-    if (val.kind === 'param') {
-      const columnMeta = tableMeta?.columns[col];
-      const isVector = columnMeta?.codecId === VECTOR_CODEC_ID;
-      value = isVector ? `$${val.index}::vector` : `$${val.index}`;
-    } else if (val.kind === 'col') {
-      value = `${quoteIdentifier(val.table)}.${quoteIdentifier(val.column)}`;
-    } else {
-      throw new Error(`Unsupported value kind in UPDATE: ${(val as { kind: string }).kind}`);
+    switch (val.kind) {
+      case 'param-ref':
+        value = renderParamRef(val, pim);
+        break;
+      case 'column-ref':
+        value = renderColumn(val);
+        break;
+      // v8 ignore next 4
+      default:
+        throw new Error(
+          `Unsupported value node in UPDATE: ${(val satisfies never as { kind: string }).kind}`,
+        );
     }
     return `${column} = ${value}`;
   });
 
-  const whereClause = ` WHERE ${renderBinary(ast.where, contract)}`;
+  const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : '';
   const returningClause = ast.returning?.length
     ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`
     : '';
@@ -414,9 +693,9 @@ function renderUpdate(ast: UpdateAst, contract: PostgresContract): string {
   return `UPDATE ${table} SET ${setClauses.join(', ')}${whereClause}${returningClause}`;
 }
 
-function renderDelete(ast: DeleteAst, contract?: PostgresContract): string {
+function renderDelete(ast: DeleteAst, contract?: PostgresContract, pim?: ParamIndexMap): string {
   const table = quoteIdentifier(ast.table.name);
-  const whereClause = ` WHERE ${renderBinary(ast.where, contract)}`;
+  const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : '';
   const returningClause = ast.returning?.length
     ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`
     : '';