@dbsp/adapter-pgsql 1.7.0 → 1.8.1

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { ExpressionRef, IndexInfo, TruncateOptions, VacuumOptions, AlterColumnOptions, CreateIndexOptions, DropIndexOptions, ModelIR as ModelIR$1 } from '@dbsp/core';
 export { normalizeSQL } from '@dbsp/core';
 import * as _dbsp_types from '@dbsp/types';
-import { ColumnListInput, ParamIntent, JsonAggOrderByEntry, DialectCapabilities, ModelIR, DbCasing, ColumnIR, HierarchyIR, WhereIntent, Adapter, AdapterLogger, AdapterCapabilities, PlanReport, CompiledNqlQuery, CompileOptions, CompiledQuery, CompileResultWithIncludes, SubqueryIncludeInfo, ExpressionIntent, InsertIntent, InsertFromIntent, UpdateIntent, BatchUpdateIntent, DeleteIntent, UpsertIntent, UpsertFromIntent, RecursivePlanReport, CteQueryIntent, SetOperationIntent, DumpMeta, Dump, AdapterStreamOptions, CompileOnlyAdapter, QueryIntent } from '@dbsp/types';
+import { ColumnListInput, ParamIntent, JsonAggOrderByEntry, DialectCapabilities, ModelIR, DbCasing, ColumnIR, HierarchyIR, MutationReturningItem, WhereIntent, Adapter, AdapterLogger, AdapterCapabilities, PlanReport, CompiledNqlQuery, CompileOptions, CompiledQuery, CompileResultWithIncludes, SubqueryIncludeInfo, ExpressionIntent, InsertIntent, InsertFromIntent, UpdateIntent, BatchUpdateIntent, DeleteIntent, UpsertIntent, UpsertFromIntent, RecursivePlanReport, CteQueryIntent, SetOperationIntent, DumpMeta, Dump, AdapterStreamOptions, CompileOnlyAdapter, QueryIntent } from '@dbsp/types';
 import * as _pgsql_types from '@pgsql/types';
 import { Node, OnConflictClause, ParamRef } from '@pgsql/types';
 import { Pool, PoolClient } from 'pg';
@@ -1368,6 +1368,8 @@ interface InsertConfig {
     values: unknown[][];
     /** Columns to return (RETURNING clause) */
     returning?: string[];
+    /** Alias-aware RETURNING projection items */
+    returningItems?: readonly MutationReturningItem[];
     /** Subquery for INSERT ... SELECT */
     selectQuery?: Node;
     /** Column database types for type-cast emission (e.g. range types) */
@@ -1388,6 +1390,8 @@ interface UpdateConfig {
     where?: Decision[];
     /** Columns to return (RETURNING clause) */
     returning?: string[];
+    /** Alias-aware RETURNING projection items */
+    returningItems?: readonly MutationReturningItem[];
     /** Column database types for type-cast emission (e.g. range types) */
     columnTypes?: Record<string, string>;
 }
@@ -1401,6 +1405,8 @@ interface DeleteConfig {
     where?: Decision[];
     /** Columns to return (RETURNING clause) */
     returning?: string[];
+    /** Alias-aware RETURNING projection items */
+    returningItems?: readonly MutationReturningItem[];
 }
 /**
  * Compile an INSERT statement from configuration.
@@ -1469,6 +1475,8 @@ interface UpsertConfig {
     useExcluded?: boolean;
     /** Columns to return (RETURNING clause) */
     returning?: string[];
+    /** Alias-aware RETURNING projection items */
+    returningItems?: readonly MutationReturningItem[];
     /** Optional column type hints for unnest casting (schema-driven) */
     columnTypes?: Record<string, string>;
     /**

package/dist/index.js

@@ -4859,10 +4859,7 @@ var init_where = __esm({
       hasRelationHandler,
       hasNoRelationHandler
     ];
-    allWhereHandlers = [
-      ...simpleWhereHandlers,
-      ...complexWhereHandlers
-    ];
+    allWhereHandlers = [...simpleWhereHandlers, ...complexWhereHandlers];
   }
 });
 
@@ -5385,10 +5382,6 @@ __export(handlers_exports, {
   LOGICAL_OPERATORS: () => LOGICAL_OPERATORS,
   NULL_OPERATORS: () => NULL_OPERATORS,
   PATTERN_OPERATORS: () => PATTERN_OPERATORS,
-  aggregateExpressionHandlers: () => aggregateExpressionHandlers,
-  allExpressionHandlers: () => allExpressionHandlers,
-  allIncludeHandlers: () => allIncludeHandlers,
-  allWhereHandlers: () => allWhereHandlers,
   andHandler: () => andHandler,
   anyHandler: () => anyHandler,
   arithmeticHandler: () => arithmeticHandler,
@@ -5399,12 +5392,9 @@ __export(handlers_exports, {
   clearHandlers: () => clearHandlers,
   coalesceHandler: () => coalesceHandler,
   columnAliasHandler: () => columnAliasHandler,
-  columnExpressionHandlers: () => columnExpressionHandlers,
   columnHandler: () => columnHandler,
   comparisonHandler: () => comparisonHandler,
   compileExpressionIntent: () => compileExpressionIntent,
-  complexWhereHandlers: () => complexWhereHandlers,
-  conditionalExpressionHandlers: () => conditionalExpressionHandlers,
   countDistinctHandler: () => countDistinctHandler,
   countHandler: () => countHandler,
   createCompilerState: () => createCompilerState,
@@ -5441,7 +5431,6 @@ __export(handlers_exports, {
   jsonComparisonHandler: () => jsonComparisonHandler,
   jsonContainsHandler: () => jsonContainsHandler,
   jsonExistsHandler: () => jsonExistsHandler,
-  jsonExpressionHandlers: () => jsonExpressionHandlers,
   jsonExtractHandler: () => jsonExtractHandler,
   jsonPathExtractHandler: () => jsonPathExtractHandler,
   lagHandler: () => lagHandler,
@@ -5462,11 +5451,9 @@ __export(handlers_exports, {
   orHandler: () => orHandler,
   prefixedRelationColumnHandler: () => prefixedRelationColumnHandler,
   pseudoColumnHandler: () => pseudoColumnHandler,
-  pseudoExpressionHandlers: () => pseudoExpressionHandlers,
   rangeHandler: () => rangeHandler,
   rankHandler: () => rankHandler,
   rawExistsHandler: () => rawExistsHandler,
-  rawExpressionHandlers: () => rawExpressionHandlers,
   rawHandler: () => rawHandler,
   registerAllExpressionHandlers: () => registerAllExpressionHandlers,
   registerAllIncludeHandlers: () => registerAllIncludeHandlers,
@@ -5478,7 +5465,6 @@ __export(handlers_exports, {
   relationAliasHandler: () => relationAliasHandler,
   relationColumnHandler: () => relationColumnHandler,
   relationColumnsHandler: () => relationColumnsHandler,
-  relationExpressionHandlers: () => relationExpressionHandlers,
   relationFilterHandler: () => relationFilterHandler,
   relationStarHandler: () => relationStarHandler,
   rowNumberHandler: () => rowNumberHandler,
@@ -5488,8 +5474,7 @@ __export(handlers_exports, {
   singleHopPseudoHandler: () => singleHopPseudoHandler,
   sqlFunctionHandler: () => sqlFunctionHandler,
   starHandler: () => starHandler,
-  sumHandler: () => sumHandler,
-  windowExpressionHandlers: () => windowExpressionHandlers
+  sumHandler: () => sumHandler
 });
 function registerWhereHandler(handler) {
   for (const op3 of handler.operators) {
@@ -6929,6 +6914,14 @@ var init_raw = __esm({
 });
 
 // src/handlers/expression/relation.ts
+function resolveRelationAlias(relation, state, options = {}) {
+  if (options.resolveDottedLeaf && relation.includes(".")) {
+    const segments = relation.split(".");
+    const leaf = segments[segments.length - 1];
+    return state.aliases.get(relation) ?? state.aliases.get(leaf) ?? leaf;
+  }
+  return state.aliases.get(relation) ?? relation;
+}
 var relationStarHandler, relationColumnHandler, relationColumnsHandler, relationAliasHandler, prefixedRelationColumnHandler;
 var init_relation = __esm({
   "src/handlers/expression/relation.ts"() {
@@ -6961,14 +6954,9 @@ var init_relation = __esm({
         if (!column) {
           throw new Error("Relation column handler requires column name");
         }
-        let alias;
-        if (relation.includes(".")) {
-          const segments = relation.split(".");
-          const leaf = segments[segments.length - 1];
-          alias = state.aliases.get(relation) ?? state.aliases.get(leaf) ?? leaf;
-        } else {
-          alias = state.aliases.get(relation) ?? relation;
-        }
+        const alias = resolveRelationAlias(relation, state, {
+          resolveDottedLeaf: true
+        });
         if (column === "*") {
           return columnRefStar(alias, ctx.naming);
         }
@@ -6986,7 +6974,7 @@ var init_relation = __esm({
         if (!columns || columns.length === 0) {
           throw new Error("Relation columns handler requires columns array");
         }
-        const alias = state.aliases.get(relation) ?? relation;
+        const alias = resolveRelationAlias(relation, state);
         const column = columns[0];
         const colRef = columnRef(column, alias, void 0, ctx.naming);
         const outputAlias = decision.alias;
@@ -7012,7 +7000,7 @@ var init_relation = __esm({
         if (!column) {
           throw new Error("Relation alias handler requires column name");
         }
-        const tableAlias = state.aliases.get(relation) ?? relation;
+        const tableAlias = resolveRelationAlias(relation, state);
         const colRef = columnRef(column, tableAlias, void 0, ctx.naming);
         if (!outputAlias) {
           return colRef;
@@ -7283,15 +7271,8 @@ var init_expression = __esm({
       lastValueHandler,
       genericWindowHandler
     ];
-    rawExpressionHandlers = [
-      rawHandler,
-      sqlFunctionHandler,
-      literalHandler
-    ];
-    jsonExpressionHandlers = [
-      jsonExtractHandler,
-      jsonPathExtractHandler
-    ];
+    rawExpressionHandlers = [rawHandler, sqlFunctionHandler, literalHandler];
+    jsonExpressionHandlers = [jsonExtractHandler, jsonPathExtractHandler];
     pseudoExpressionHandlers = [
       pseudoColumnHandler,
       singleHopPseudoHandler,
@@ -14052,12 +14033,48 @@ init_handlers();
 init_param_intent();
 init_param_ref();
 import { isSqlRaw } from "@dbsp/core";
-import { isParamIntent as isParamIntent7 } from "@dbsp/types";
-function buildReturningList(columns, tableRef, ctx) {
-  if (!columns || columns.length === 0) return void 0;
+import {
+  isParamIntent as isParamIntent7
+} from "@dbsp/types";
+function buildReturningList(columns, tableRef, ctx, returningItems) {
   const { naming } = ctx;
+  if (returningItems !== void 0) {
+    const returning = columns ?? [];
+    if (returningItems.length !== returning.length) {
+      throw new Error(
+        `Invalid mutation RETURNING items: returningItems length (${returningItems.length}) must match returning length (${returning.length}).`
+      );
+    }
+    if (returning.includes("*") || returningItems.some((item) => item.output === "*" || item.source === "*")) {
+      throw new Error(
+        "Invalid mutation RETURNING items: star RETURNING cannot carry alias-aware returningItems."
+      );
+    }
+    if (returningItems.length === 0) return void 0;
+    const emittedOutputs = /* @__PURE__ */ new Map();
+    return returningItems.map((item, index) => {
+      if (item.output !== returning[index]) {
+        throw new Error(
+          `Invalid mutation RETURNING items: returningItems[${index}].output '${item.output}' must match returning[${index}] '${returning[index]}'.`
+        );
+      }
+      const emittedOutput = naming.toDatabase(item.output);
+      const previousOutput = emittedOutputs.get(emittedOutput);
+      if (previousOutput !== void 0) {
+        throw new Error(
+          `Duplicate mutation RETURNING output after database naming: '${emittedOutput}' from '${previousOutput}' and '${item.output}'.`
+        );
+      }
+      emittedOutputs.set(emittedOutput, item.output);
+      return resTarget(
+        columnRef(item.source, tableRef, ctx.schema, naming),
+        emittedOutput
+      );
+    });
+  }
+  if (!columns || columns.length === 0) return void 0;
   return columns.map(
-    (col) => resTarget(
+    (col) => col === "*" ? starTarget() : resTarget(
       columnRef(col, tableRef, ctx.schema, naming),
       naming.toDatabase(col)
     )
@@ -14076,7 +14093,12 @@ function compileInsert(config, ctx, state) {
       return valueToNode(val, state, dbType);
     })
   );
-  const returningList = buildReturningList(config.returning, dbTable, ctx);
+  const returningList = buildReturningList(
+    config.returning,
+    dbTable,
+    ctx,
+    config.returningItems
+  );
   const options = {
     table: config.table,
     columns: dbColumns,
@@ -14115,7 +14137,12 @@ function compileUnnestInsert(config, ctx, state) {
       targetList
     }
   };
-  const returningList = buildReturningList(config.returning, dbTable, ctx);
+  const returningList = buildReturningList(
+    config.returning,
+    dbTable,
+    ctx,
+    config.returningItems
+  );
   const options = {
     table: config.table,
     columns: columns.map((c) => naming.toDatabase(c)),
@@ -14154,7 +14181,12 @@ function compileUpdate(config, ctx, state) {
       };
     }
   }
-  const returningList = buildReturningList(config.returning, tableAlias, ctx);
+  const returningList = buildReturningList(
+    config.returning,
+    tableAlias,
+    ctx,
+    config.returningItems
+  );
   const options = {
     table: config.table,
     set: setClause,
@@ -14224,7 +14256,12 @@ function compileUnnestUpdate(config, ctx, state) {
       args: [matchWhere, config.whereGuard]
     }
   } : matchWhere;
-  const returningList = buildReturningList(config.returning, dbTable, ctx);
+  const returningList = buildReturningList(
+    config.returning,
+    dbTable,
+    ctx,
+    config.returningItems
+  );
   const options = {
     table,
     set: setClause,
@@ -14257,7 +14294,12 @@ function compileDelete(config, ctx, state) {
       };
     }
   }
-  const returningList = buildReturningList(config.returning, tableAlias, ctx);
+  const returningList = buildReturningList(
+    config.returning,
+    tableAlias,
+    ctx,
+    config.returningItems
+  );
   const options = {
     table: config.table,
     naming
@@ -14337,7 +14379,8 @@ function compileInsertFrom(config, ctx, state) {
   const returningList = buildReturningList(
     config.returning,
     config.targetTable,
-    ctx
+    ctx,
+    config.returningItems
   );
   const options = {
     table: config.targetTable,
@@ -14418,7 +14461,8 @@ function compileUpsertFrom(config, ctx, state) {
   const returningList = buildReturningList(
     config.returning,
     config.targetTable,
-    ctx
+    ctx,
+    config.returningItems
   );
   const conflictInfer = {
     indexElems: config.conflictColumns.map((col) => ({
@@ -14655,7 +14699,12 @@ function compileUpsert(config, ctx, state) {
     }
   }));
   const onConflict = buildOnConflictClause(config, ctx, state);
-  const returningList = buildReturningList(config.returning, dbTable, ctx);
+  const returningList = buildReturningList(
+    config.returning,
+    dbTable,
+    ctx,
+    config.returningItems
+  );
   return {
     InsertStmt: {
       relation: {
@@ -14705,7 +14754,12 @@ function compileUnnestUpsert(config, ctx, state) {
     }
   };
   const onConflict = buildOnConflictClause(config, ctx, state);
-  const returningList = buildReturningList(config.returning, dbTable, ctx);
+  const returningList = buildReturningList(
+    config.returning,
+    dbTable,
+    ctx,
+    config.returningItems
+  );
   return {
     InsertStmt: {
       relation: {
@@ -15960,9 +16014,6 @@ function assertSafeTypeName(typeName, colIndex) {
     }
   }
 }
-function bridgeLegacyDecisions(decisions) {
-  return decisions;
-}
 function buildBatchValuesRangeFn(bv, startParamIndex, aliasOverride) {
   const params = [];
   let paramIdx = startParamIndex - 1;
@@ -16369,7 +16420,7 @@ function compileSelect(plan, options, deps) {
   } else {
     simplifiedPlan = {
       rootTable: plan.rootTable,
-      decisions: bridgeLegacyDecisions(plan.decisions),
+      decisions: plan.decisions,
       ...schemaName ? { schema: schemaName } : {}
     };
   }
@@ -16585,6 +16636,7 @@ function compileInsert2(intent, options, deps) {
     columns,
     values,
     ...intent.returning && { returning: [...intent.returning] },
+    ...intent.returningItems && { returningItems: intent.returningItems },
     ...columnTypes && { columnTypes }
   };
   const maxBatchSize = options?.maxBatchSize;
@@ -16631,7 +16683,8 @@ function compileInsertFrom2(intent, options, deps) {
     ...intent.columns && { columns: [...intent.columns] },
     ...resolvedWhere && { where: [whereIntentAsDecision(resolvedWhere)] },
     ...intent.limit !== void 0 && { limit: intent.limit },
-    ...intent.returning && { returning: [...intent.returning] }
+    ...intent.returning && { returning: [...intent.returning] },
+    ...intent.returningItems && { returningItems: intent.returningItems }
   };
   const ast = compileInsertFrom(config, ctx, state);
   const sql = deparseQuoted(ast);
@@ -16669,6 +16722,7 @@ function compileUpdate2(intent, options, deps) {
     })),
     ...resolvedWhere && { where: [whereIntentAsDecision(resolvedWhere)] },
     ...intent.returning && { returning: [...intent.returning] },
+    ...intent.returningItems && { returningItems: intent.returningItems },
     ...columnTypes && { columnTypes }
   };
   const ast = compileUpdate(config, ctx, state);
@@ -16750,6 +16804,7 @@ function compileBatchUpdate(intent, _options, deps) {
     columnArrays,
     ...scalarSet && { scalarSet },
     ...intent.returning && { returning: [...intent.returning] },
+    ...intent.returningItems && { returningItems: intent.returningItems },
     ...columnTypes && { columnTypes },
     ...whereGuard !== void 0 && { whereGuard }
   };
@@ -16779,7 +16834,8 @@ function compileDelete2(intent, options, deps) {
   const config = {
     table: intent.table,
     ...resolvedWhere && { where: [whereIntentAsDecision(resolvedWhere)] },
-    ...intent.returning && { returning: [...intent.returning] }
+    ...intent.returning && { returning: [...intent.returning] },
+    ...intent.returningItems && { returningItems: intent.returningItems }
   };
   const ast = compileDelete(config, ctx, state);
   const sql = deparseQuoted(ast);
@@ -16849,6 +16905,7 @@ function compileUpsert2(intent, options, deps) {
     conflictAction,
     ...updateColumns && { updateColumns },
     ...intent.returning && { returning: [...intent.returning] },
+    ...intent.returningItems && { returningItems: intent.returningItems },
     ...columnTypes && { columnTypes },
     ...hasRawExprs && { updateExpressions: rawExprs },
     ...resolvedActionWhere && {
@@ -16916,7 +16973,8 @@ function compileUpsertFrom2(intent, options, deps) {
     ...columns && { columns },
     ...resolvedWhere && { where: [whereIntentAsDecision(resolvedWhere)] },
     ...intent.limit !== void 0 && { limit: intent.limit },
-    ...intent.returning && { returning: [...intent.returning] }
+    ...intent.returning && { returning: [...intent.returning] },
+    ...intent.returningItems && { returningItems: intent.returningItems }
   };
   const ast = compileUpsertFrom(config, ctx, state);
   const sql = deparseQuoted(ast);
@@ -18505,20 +18563,115 @@ function assertRuntimeBindingValuesParameterCount(name, binding, parameterOffset
     `NQL runtime binding '${name}' would materialize ${valueParameterCount} VALUES parameters; limit is ${MAX_NQL_RUNTIME_BINDING_VALUES_PARAMETERS}. Current parameter offset is ${parameterOffset}, which would make ${totalParameterCount} total parameters before compiling the final statement.`
   );
 }
-function compileNqlRuntimeBindingCte(name, binding, naming, parameterOffset, sourceTable, schemaName, model) {
+function resolvePgTypeForColumnTypeInfo(bindingName, column, info) {
+  if (info.kind === "aggregate" && info.fn !== "count") {
+    throw new Error(
+      `NQL runtime binding '${bindingName}' cannot resolve a PostgreSQL type for projected column '${column}': unsupported aggregate kind '${String(info.fn)}'.`
+    );
+  }
+  const rawType = info.kind === "aggregate" ? "bigint" : info.originalDbType?.trim() || mapRuntimeBindingColumnType(info.type);
+  if (rawType === void 0 || rawType.trim() === "") {
+    throw new Error(
+      `NQL runtime binding '${bindingName}' cannot resolve a PostgreSQL type for projected column '${column}'.`
+    );
+  }
+  const typeName = rawType.trim();
+  try {
+    validateTypeName4(typeName);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `NQL runtime binding '${bindingName}' cannot use PostgreSQL cast type for projected column '${column}': ${reason}`
+    );
+  }
+  return typeName;
+}
+function resolveRuntimeBindingCteColumnTypes(name, binding) {
+  const columnTypes = binding.columnTypes;
+  if (columnTypes === void 0) {
+    throw new Error(
+      `NQL runtime binding '${name}' cannot resolve typed columns without a columnTypes map.`
+    );
+  }
+  return binding.columns.map((column) => {
+    const info = columnTypes[column];
+    if (info === void 0) {
+      throw new Error(
+        `NQL runtime binding '${name}' is missing type info for projected column '${column}'.`
+      );
+    }
+    return resolvePgTypeForColumnTypeInfo(name, column, info);
+  });
+}
+function compileTypedNqlRuntimeBindingCte(name, binding, naming, parameterOffset, cteName, columnSql) {
+  const pgTypes = resolveRuntimeBindingCteColumnTypes(name, binding);
+  const anchorColumns = binding.columns.map(
+    (column, columnIndex) => `CAST(NULL AS ${pgTypes[columnIndex]}) AS ${quoteIdent2(naming.toDatabase(column), "column")}`
+  ).join(", ");
+  const sourceAnchorSql = `SELECT ${anchorColumns} WHERE false`;
+  if (binding.rows.length === 0) {
+    return {
+      cte: `${cteName} (${columnSql}) as (${sourceAnchorSql})`,
+      parameters: []
+    };
+  }
+  assertRuntimeBindingValuesParameterCount(name, binding, parameterOffset);
+  const parameters = [];
+  let nextParam = parameterOffset + 1;
+  const valuesSql = binding.rows.map((row) => {
+    const placeholders = binding.columns.map((column, columnIndex) => {
+      parameters.push(row[column]);
+      return `$${nextParam++}::${pgTypes[columnIndex]}`;
+    });
+    return `(${placeholders.join(", ")})`;
+  }).join(", ");
+  return {
+    cte: `${cteName} (${columnSql}) as (${sourceAnchorSql} UNION ALL VALUES ${valuesSql})`,
+    parameters
+  };
+}
+function compileNqlRuntimeBindingCte(name, binding, naming, parameterOffset, sourceTable, schemaName, model, returningItems) {
+  if (returningItems !== void 0) {
+    if (returningItems.length !== binding.columns.length || returningItems.some((item, i) => item.output !== binding.columns[i])) {
+      throw new Error(
+        `NQL runtime binding '${name}' has returningItems desynced from its projected columns.`
+      );
+    }
+  }
+  const sourceColumnFor = (output) => returningItems?.find((item) => item.output === output)?.source ?? output;
   if (binding.columns.length === 0) {
     throw new Error(
       `NQL runtime binding '${name}' cannot be materialized without projected columns.`
     );
   }
   const cteName = quoteIdent2(emittedBindName(name, naming), "alias");
+  const emittedColumnNames = binding.columns.map(
+    (column) => naming.toDatabase(column)
+  );
+  if (new Set(emittedColumnNames).size !== emittedColumnNames.length) {
+    throw new Error(
+      `NQL runtime binding '${name}' emits duplicate column names after database naming.`
+    );
+  }
   const columnSql = binding.columns.map((column) => quoteIdent2(naming.toDatabase(column), "column")).join(", ");
+  if (binding.columnTypes !== void 0) {
+    return compileTypedNqlRuntimeBindingCte(
+      name,
+      binding,
+      naming,
+      parameterOffset,
+      cteName,
+      columnSql
+    );
+  }
   if (sourceTable === void 0) {
     throw new Error(
       `NQL runtime binding '${name}' cannot materialize a typed relation because its source table is unavailable.`
     );
   }
-  const projectedColumns = binding.columns.map((column) => quoteIdent2(naming.toDatabase(column), "column")).join(", ");
+  const projectedColumns = binding.columns.map(
+    (column) => quoteIdent2(naming.toDatabase(sourceColumnFor(column)), "column")
+  ).join(", ");
   const sourceAnchorSql = `SELECT ${projectedColumns} FROM ${qualifyTableIdent(sourceTable, schemaName, naming)} WHERE false`;
   if (binding.rows.length === 0) {
     return {
@@ -18529,7 +18682,7 @@ function compileNqlRuntimeBindingCte(name, binding, naming, parameterOffset, sou
   assertRuntimeBindingValuesParameterCount(name, binding, parameterOffset);
   const columnTypes = resolveRuntimeBindingColumnTypes(
     name,
-    binding,
+    { ...binding, columns: binding.columns.map(sourceColumnFor) },
     model,
     sourceTable
   );
@@ -18792,7 +18945,8 @@ var PgsqlAdapter = class _PgsqlAdapter {
           parameters.length,
           runtimeBindingSourceTable(bundle, name),
           deps.schemaName,
-          deps.model
+          deps.model,
+          bundle.mutationBindings?.get(name)?.returningItems
         );
         ctes.push(compiledRuntimeBinding.cte);
         parameters.push(...compiledRuntimeBinding.parameters);