@prisma/orm-target-postgres 8.0.0-rc.17-dev.37 → 8.0.0-rc.17-dev.38

package/dist/{control-policy-C5VoaD11-lzAw5cjN.mjs → control-policy-DXaIsgUW-Btyo9Vs8.mjs}

@@ -1,23 +1,24 @@
 import { s as postgresError } from "./errors-DYyzTYzE-39CV_aMo.mjs";
-import { _ as pgInt8, f as pgFloat4, g as pgInt4, h as pgInt2, p as pgFloat8 } from "./data-types-DRkmmE9S-C5Q9oH4Q.mjs";
-import { d as isPostgresSchema } from "./postgres-schema-DIaAgaL6-Dmqzjbu5.mjs";
+import { A as pgTimestamptz, E as pgTime, I as pgVarbit, L as pgVarchar, M as pgTimetz, O as pgTimestamp, R as postgresDataTypes, _ as pgInt8, f as pgFloat4, g as pgInt4, h as pgInt2, p as pgFloat8, w as pgText, x as pgNumeric } from "./data-types-K6tDhu1D-BN--9o1o.mjs";
+import { d as isPostgresSchema } from "./postgres-schema-Ysxbqkzr-hFRwS-zT.mjs";
 import { n as PostgresSchemaNodeKind, o as postgresNodeEntityKind, r as PostgresTableSchemaNode, t as PostgresNativeEnumSchemaNode } from "./postgres-table-schema-node-BBkitBQh-DT1T5VWU.mjs";
-import { n as buildColumnTypeSql } from "./planner-ddl-builders-Y0_96xpe-BzugdEDO.mjs";
-import { t as buildExpectedFormatType } from "./planner-sql-checks-Bt_KuSiH-CdGZDp7M.mjs";
-import { C as DropNativeEnumTypeCall, D as EnableRowLevelSecurityCall, E as DropTableCall, F as SetNotNullCall, I as buildTargetDetails, L as columnNameOfCall, O as RawSqlCall, P as SetDefaultCall, S as DropIndexCall, V as postgresDefaultToDdlColumnDefault, _ as DisableRowLevelSecurityCall, a as AddNotNullColumnDirectCall, b as DropConstraintCall, c as AddUniqueCall, d as CreateIndexCall, f as CreateNativeEnumTypeCall, g as DataTransformCall, h as CreateTableCall, i as AddNativeEnumValueCall, l as AlterColumnTypeCall, m as CreateSchemaCall, n as AddColumnCall, o as AddNotNullColumnWithTempDefaultCall, r as AddForeignKeyCall, s as AddPrimaryKeyCall, t as AddCheckConstraintCall, v as DropCheckConstraintCall, w as DropNotNullCall, x as DropDefaultCall, y as DropColumnCall } from "./op-factory-call-DiwaNQVO-NSekrcmI.mjs";
-import { n as resolveIdentityValue } from "./planner-identity-values-CRS2cQ6v-DakZeIQj.mjs";
+import { i as stackDataTypes } from "./planner-sql-checks-CX37qDix-Gkq38UQQ.mjs";
+import { t as buildTargetDetails } from "./planner-target-details-CUEF0s90-COTks5yz.mjs";
+import { C as DropNativeEnumTypeCall, D as EnableRowLevelSecurityCall, E as DropTableCall, F as SetNotNullCall, L as columnNameOfCall, O as RawSqlCall, P as SetDefaultCall, S as DropIndexCall, V as postgresDefaultToDdlColumnDefault, _ as DisableRowLevelSecurityCall, a as AddNativeEnumValueCall, b as DropConstraintCall, c as AddUniqueCall, d as CreateIndexCall, f as CreateNativeEnumTypeCall, g as DataTransformCall, h as CreateTableCall, i as AddForeignKeyCall, l as AlterColumnTypeCall, m as CreateSchemaCall, n as AddColumnCall, o as AddPrimaryKeyCall, r as AddColumnWithTemporaryDefaultCall, s as AddRequiredColumnToEmptyTableCall, t as AddCheckConstraintCall, v as DropCheckConstraintCall, w as DropNotNullCall, x as DropDefaultCall, y as DropColumnCall } from "./op-factory-call-ltgiEZ8g-CX6WX57X.mjs";
+import { t as buildColumnTypeSql } from "./planner-ddl-builders-BcJ353Wj-Dfaixf4X.mjs";
+import { n as resolveIdentityValue } from "./planner-identity-values-BZdomjRU-G521DabU.mjs";
 import { n as defaultPrimaryKeyName, r as defaultUniqueName, t as defaultForeignKeyName } from "./default-constraint-names-CtcRXhV8-nz3ff6b8.mjs";
-import { i as hasUniqueConstraint, n as hasForeignKey, t as buildSchemaLookupMap } from "./planner-schema-lookup-kMIVP2y--CdO4VlnF.mjs";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { sqlDataTypeOfCodec } from "@prisma/orm-family-sql/contract/data-type";
+import { dataTypeParams, resolveWrittenSqlTypes, sqlDataTypeOfCodec } from "@prisma/orm-family-sql/contract/data-type";
 import { UNBOUND_NAMESPACE_ID, entityAt } from "@prisma/orm-framework/components/ir";
 import { issueOutcome, orderIssuesByDependencies } from "@prisma/orm-framework/components/control";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import * as contractFree from "@prisma/orm-family-sql/relational-core/contract-free";
+import { columnTakesTemporaryValue } from "@prisma/orm-family-sql/family/control";
 import { RelationalSchemaNodeKind, SqlSchemaIR, contractDefaultRefusal, defaultInCanonicalForm } from "@prisma/orm-family-sql/schema-ir/types";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
-//#region ../../../3-targets/3-targets/postgres/dist/control-policy-C5VoaD11.mjs
+//#region ../../../3-targets/3-targets/postgres/dist/control-policy-DXaIsgUW.mjs
 /**
 * The storage-`entries` coordinate `(entityKind, entityName)` a Postgres diff
 * node addresses — a table by its name, a native enum by its physical type
@@ -44,7 +45,7 @@ function postgresNodeStorageCoordinate(node) {
 const AUTOINCREMENT = "autoincrement()";
 /**
 * Reconstructs the `StorageColumn`-shaped fields the DDL builder functions
-* (`buildColumnTypeSql`, `buildExpectedFormatType`, `resolveIdentityValue`)
+* (`buildColumnTypeSql`, `resolveIdentityValue`)
 * expect, from a column node's own stamped codec identity (`codecRef` /
 * `codecBaseNativeType`, Decision 5) — never the contract. The node's fields
 * are already resolved past any `typeRef` indirection, so the builders get
@@ -100,11 +101,7 @@ function renderColumnDdl(name, column, types) {
 * Builds the `ALTER COLUMN … TYPE` operands for an expected column node.
 */
 function renderColumnAlterType(column, types) {
-	const like = columnLike(column);
-	return {
-		qualifiedTargetType: buildColumnTypeSql(like, types, {}, false),
-		formatTypeExpected: buildExpectedFormatType(like, types)
-	};
+	return buildColumnTypeSql(columnLike(column), types, {}, false);
 }
 /**
 * Resolves the identity value (monoid neutral element) SQL literal used as
@@ -134,40 +131,93 @@ function buildSetDefaultColumn(columnName, defaultNode, types) {
 		...ifDefined("codecRef", defaultNode.codecRef)
 	});
 }
-/** The type changes that keep every value: each pair is `from→to` by data type id. */
+/** The changes between data types that keep every value: each pair is `from→to` by data type id. */
 const SAFE_WIDENINGS = /* @__PURE__ */ new Set([
 	`${pgInt2.id}→${pgInt4.id}`,
 	`${pgInt2.id}→${pgInt8.id}`,
 	`${pgInt4.id}→${pgInt8.id}`,
-	`${pgFloat4.id}→${pgFloat8.id}`
+	`${pgInt2.id}→${pgFloat4.id}`,
+	`${pgInt2.id}→${pgFloat8.id}`,
+	`${pgInt4.id}→${pgFloat8.id}`,
+	`${pgFloat4.id}→${pgFloat8.id}`,
+	`${pgVarchar.id}→${pgText.id}`,
+	`${pgInt2.id}→${pgText.id}`,
+	`${pgInt4.id}→${pgText.id}`,
+	`${pgInt8.id}→${pgText.id}`,
+	`${pgNumeric.id}→${pgText.id}`,
+	`${pgFloat4.id}→${pgText.id}`,
+	`${pgFloat8.id}→${pgText.id}`
 ]);
-const WIDENABLE_TYPES = [
-	pgInt2,
-	pgInt4,
-	pgInt8,
-	pgFloat4,
-	pgFloat8
-];
-function isSafeTypeWidening(fromDataType, toDataType) {
-	return SAFE_WIDENINGS.has(`${fromDataType}→${toDataType}`);
+/** Types whose `length` caps their values; a larger cap, or none, keeps every value. */
+const LENGTH_CAPPED = /* @__PURE__ */ new Set([pgVarchar.id, pgVarbit.id]);
+/** Types whose `precision` rounds their fractional seconds; more, or none, keeps every value. */
+const PRECISION_ROUNDED = /* @__PURE__ */ new Set([
+	pgTime.id,
+	pgTimetz.id,
+	pgTimestamp.id,
+	pgTimestamptz.id
+]);
+function numberParam(params, key) {
+	const value = params[key];
+	return typeof value === "number" ? value : void 0;
+}
+/** Whether a cap, where `undefined` means none, is at least as large as before. */
+function capGrows(from, to) {
+	return to === void 0 || from !== void 0 && to >= from;
 }
-/** The id of the data type a column node's codec represents. */
-function columnDataType(column, types) {
+/**
+* A `numeric` keeps every value when it allows at least as many digits before the point and after
+* it; an unconstrained `numeric` holds any value.
+*/
+function numericGrows(from, to) {
+	const toPrecision = numberParam(to, "precision");
+	if (toPrecision === void 0) return true;
+	const fromPrecision = numberParam(from, "precision");
+	if (fromPrecision === void 0) return false;
+	const fromScale = numberParam(from, "scale") ?? 0;
+	const toScale = numberParam(to, "scale") ?? 0;
+	return toScale >= fromScale && toPrecision - toScale >= fromPrecision - fromScale;
+}
+/** Whether changing a column from one type to another keeps every value. */
+function isSafeTypeWidening(from, to) {
+	if (SAFE_WIDENINGS.has(`${from.dataType}→${to.dataType}`)) return true;
+	if (from.dataType !== to.dataType) return false;
+	if (LENGTH_CAPPED.has(from.dataType)) return capGrows(numberParam(from.params, "length"), numberParam(to.params, "length"));
+	if (PRECISION_ROUNDED.has(from.dataType)) return capGrows(numberParam(from.params, "precision"), numberParam(to.params, "precision"));
+	if (from.dataType === pgNumeric.id) return numericGrows(from.params, to.params);
+	return false;
+}
+function isParamRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** The data type a column node's codec represents, with its parameters. */
+function columnType(column, types) {
 	if (column.codecRef === void 0) throw new InternalError(`Column "${column.name}" carries no codec, so its data type is unknown; a type change is planned only between columns built from contracts.`);
-	return sqlDataTypeOfCodec(column.codecRef.codecId, types).id;
+	const type = sqlDataTypeOfCodec(column.codecRef.codecId, types);
+	const typeParams = column.codecRef.typeParams;
+	const params = isParamRecord(typeParams) ? dataTypeParams(type, typeParams) : {};
+	return {
+		dataType: type.id,
+		params: type.sql.normalize(params)
+	};
 }
-/** The widenable data type a migration writes as `text`, which introspection reports normalised. */
-function widenableDataTypeWritten(text) {
-	return WIDENABLE_TYPES.find((type) => type.sql.texts.some((candidate) => candidate.written === true && candidate.text === text))?.id;
+/** The type of an introspected column, read from the type name introspection reports. */
+function introspectedColumnType(column) {
+	if (column.resolvedNativeType === void 0) return void 0;
+	const [only, ...others] = resolveWrittenSqlTypes(column.resolvedNativeType, postgresDataTypes);
+	return only === void 0 || others.length > 0 ? void 0 : {
+		dataType: only.dataType,
+		params: only.typeParams
+	};
 }
 /**
-* Whether changing an introspected column to the contract's column keeps every value. The live
-* column carries no codec, so its type is read from the normalised name introspection reports.
+* Whether changing a live column to the contract's column keeps every value. A column introspected
+* from the database carries no codec, so its type is read from the name introspection reports.
 */
 function liveColumnWidensSafely(expected, actual, types) {
 	if (expected.many === true || actual.many === true) return false;
-	const from = actual.resolvedNativeType === void 0 ? void 0 : widenableDataTypeWritten(actual.resolvedNativeType);
-	return from !== void 0 && isSafeTypeWidening(from, columnDataType(expected, types));
+	const from = actual.codecRef === void 0 ? introspectedColumnType(actual) : columnType(actual, types);
+	return from !== void 0 && isSafeTypeWidening(from, columnType(expected, types));
 }
 /**
 * Look up a storage table by its explicit namespace coordinate. Returns
@@ -204,6 +254,16 @@ function columnNodePair(issue) {
 		actual: blindCast(issue.actual)
 	};
 }
+/** The `--backfill` statement's column an issue is about, if a statement names it. */
+function backfilled(ctx, ddlSchemaName, tableName, columnName) {
+	const namespaceId = namespaceIdForDdlSchema(ctx, ddlSchemaName);
+	return ctx.statementColumns.backfill.find((column) => column.namespaceId === namespaceId && column.table === tableName && column.column === columnName);
+}
+/**
+* Handles a required column with no default added to an existing table, for a field a
+* `--backfill` statement names: a nullable add, a data transform whose slots the user fills, then
+* `SET NOT NULL`. Every other such column is left to `notNullAddColumnCallStrategy`.
+*/
 const notNullBackfillCallStrategy = (issues, ctx) => {
 	if (!ctx.policy.allowedOperationClasses.includes("data")) return { kind: "no_match" };
 	const matched = [];
@@ -217,11 +277,18 @@ const notNullBackfillCallStrategy = (issues, ctx) => {
 		const ddlSchemaName = issueSchemaName(issue);
 		const tableName = issueTableName(issue);
 		if (ddlSchemaName === void 0 || tableName === void 0) continue;
+		const named = backfilled(ctx, ddlSchemaName, tableName, expected.name);
+		if (named === void 0) continue;
 		const schemaName = emissionSchemaName(ctx, ddlSchemaName);
+		const slot = named.text;
 		matched.push(issue);
 		const ddl = renderColumnDdl(expected.name, expected, ctx.types);
 		const nullableSpec = contractFree.col(ddl.name, ddl.type, { ...ddl.codecRef !== void 0 ? { codecRef: ddl.codecRef } : {} });
-		calls.push(new AddColumnCall(schemaName, tableName, nullableSpec), new DataTransformCall(`backfill-${tableName}-${expected.name}`, `backfill-${tableName}-${expected.name}:check`, `backfill-${tableName}-${expected.name}:run`), new SetNotNullCall(schemaName, tableName, expected.name));
+		calls.push(new AddColumnCall(schemaName, tableName, nullableSpec), new DataTransformCall(`backfill-${tableName}-${expected.name}`, `${slot}:check`, `${slot}:run`, "data", {
+			schema: schemaName,
+			table: tableName,
+			column: expected.name
+		}), new SetNotNullCall(schemaName, tableName, expected.name));
 	}
 	if (matched.length === 0) return { kind: "no_match" };
 	return {
@@ -232,22 +299,16 @@ const notNullBackfillCallStrategy = (issues, ctx) => {
 	};
 };
 /**
-* Handles `not-equal` column issues whose TYPE differs, for a plan that has an
-* origin contract and may include `data` operations: `migration plan`. Under
-* `db update` or `db init`, whose policies leave out `data`, it never fires,
-* whether or not an origin contract is known: it could only plan the in-place
-* ALTER that `mapNodeIssueToCall` plans, so leaving that to the mapper keeps
-* the plan, and its order, the same either way.
+* Handles a `not-equal` column issue whose type differs, for a field a `--convert` statement names,
+* in a plan that may include `data` operations: `migration plan`. The alter is classed `data` and
+* its USING clause is a slot the user fills with the conversion. A known-safe widening needs no
+* conversion and is left to `mapNodeIssueToCall`, as is every type change no statement names: a
+* direct alter, `widening` or `destructive`, which the plan asks about.
 *
-* A single node issue can carry BOTH type and nullability drift (Postgres
-* alters in place, so the differ emits one `not-equal` column issue where
-* the legacy coordinate walk emitted two: `type_mismatch` +
-* `nullability_mismatch`). When this strategy consumes the issue for its
-* type portion, it also emits whatever nullability delta the same node pair
-* carries — using the same construction `nullableTighteningCallStrategy` /
-* the mapper's direct dispatch would have used — so the issue is never
-* partially handled.
+* One node issue can carry both type and nullability drift, so the strategy also emits the
+* nullability change: `SET NOT NULL` after the alter, whose conversion can map NULL to a value.
 */
+/** A field as a statement names it: with its namespace only when the contract has several. */
 const typeChangeCallStrategy = (issues, ctx) => {
 	if (ctx.fromContract === null || !ctx.policy.allowedOperationClasses.includes("data")) return { kind: "no_match" };
 	const matched = [];
@@ -258,22 +319,27 @@ const typeChangeCallStrategy = (issues, ctx) => {
 		if (pair === void 0) continue;
 		const { expected, actual } = pair;
 		if (!columnTypeChangedNativeOnly(expected, actual)) continue;
-		const isSafeWidening = isSafeTypeWidening(columnDataType(actual, ctx.types), columnDataType(expected, ctx.types));
 		const ddlSchemaName = issueSchemaName(issue);
 		const tableName = issueTableName(issue);
 		if (ddlSchemaName === void 0 || tableName === void 0) continue;
+		const namespaceId = namespaceIdForDdlSchema(ctx, ddlSchemaName);
+		const converted = ctx.statementColumns.convert.find((column) => column.namespaceId === namespaceId && column.table === tableName && column.column === expected.name);
+		if (converted === void 0) continue;
+		if (isSafeTypeWidening(columnType(actual, ctx.types), columnType(expected, ctx.types))) continue;
 		const schemaName = emissionSchemaName(ctx, ddlSchemaName);
 		matched.push(issue);
-		const { qualifiedTargetType, formatTypeExpected } = renderColumnAlterType(expected, ctx.types);
-		const alterOpts = {
-			qualifiedTargetType,
-			formatTypeExpected,
-			rawTargetTypeForLabel: qualifiedTargetType
-		};
-		if (isSafeWidening) calls.push(new AlterColumnTypeCall(schemaName, tableName, expected.name, alterOpts, "widening"));
-		else calls.push(new DataTransformCall(`typechange-${tableName}-${expected.name}`, `typechange-${tableName}-${expected.name}:check`, `typechange-${tableName}-${expected.name}:run`), new AlterColumnTypeCall(schemaName, tableName, expected.name, alterOpts));
-		if (expected.nullable !== actual.nullable) if (expected.nullable) calls.push(new DropNotNullCall(schemaName, tableName, expected.name));
-		else calls.push(new DataTransformCall(`handle-nulls-${tableName}-${expected.name}`, `handle-nulls-${tableName}-${expected.name}:check`, `handle-nulls-${tableName}-${expected.name}:run`), new SetNotNullCall(schemaName, tableName, expected.name));
+		calls.push(new AlterColumnTypeCall({
+			schemaName,
+			tableName,
+			columnName: expected.name,
+			type: renderColumnAlterType(expected, ctx.types),
+			using: {
+				kind: "placeholder",
+				slot: `${converted.text}:convert`
+			},
+			dataTypes: ctx.dataTypes
+		}));
+		if (expected.nullable !== actual.nullable) calls.push(expected.nullable ? new DropNotNullCall(schemaName, tableName, expected.name) : new SetNotNullCall(schemaName, tableName, expected.name));
 	}
 	if (matched.length === 0) return { kind: "no_match" };
 	return {
@@ -294,11 +360,11 @@ function columnTypeChangedNativeOnly(expected, actual) {
 	return expected.nativeType !== actual.nativeType;
 }
 /**
-* Handles `not-equal` column issues whose type did NOT change but
-* nullability tightened (contract requires NOT NULL, live column is
-* nullable). A type-changed issue's nullability delta (if any) is already
-* handled by `typeChangeCallStrategy`, which runs first — this strategy
-* only ever sees issues that strategy left behind.
+* Handles a `not-equal` column issue whose type did not change but which becomes required, for a
+* field a `--backfill` statement names: a data transform whose slots the user fills with values for
+* the NULLs, then `SET NOT NULL`. Every other such column gets the direct `SET NOT NULL` of
+* `mapNodeIssueToCall`. A type-changed issue's nullability is handled by `typeChangeCallStrategy`
+* or the direct alter.
 */
 const nullableTighteningCallStrategy = (issues, ctx) => {
 	if (!ctx.policy.allowedOperationClasses.includes("data")) return { kind: "no_match" };
@@ -314,9 +380,16 @@ const nullableTighteningCallStrategy = (issues, ctx) => {
 		const ddlSchemaName = issueSchemaName(issue);
 		const tableName = issueTableName(issue);
 		if (ddlSchemaName === void 0 || tableName === void 0) continue;
+		const named = backfilled(ctx, ddlSchemaName, tableName, expected.name);
+		if (named === void 0) continue;
 		const schemaName = emissionSchemaName(ctx, ddlSchemaName);
+		const slot = named.text;
 		matched.push(issue);
-		calls.push(new DataTransformCall(`handle-nulls-${tableName}-${expected.name}`, `handle-nulls-${tableName}-${expected.name}:check`, `handle-nulls-${tableName}-${expected.name}:run`), new SetNotNullCall(schemaName, tableName, expected.name));
+		calls.push(new DataTransformCall(`handle-nulls-${tableName}-${expected.name}`, `${slot}:check`, `${slot}:run`, "data", {
+			schema: schemaName,
+			table: tableName,
+			column: expected.name
+		}), new SetNotNullCall(schemaName, tableName, expected.name));
 	}
 	if (matched.length === 0) return { kind: "no_match" };
 	return {
@@ -375,7 +448,8 @@ const storageTypePlanCallStrategy = (issues, ctx) => {
 *    nullable → backfill identity value → `SET NOT NULL` → `DROP DEFAULT`).
 *    The temp-default value is resolved from the column node's `codecRef`
 *    (`resolveColumnTemporaryDefault`, wrapping `resolveIdentityValue`).
-*  - Empty-table guarded: emit a hand-built op with a `tableIsEmptyCheck`
+*  - Empty-table guarded, for a column in a key, or whose values come from a value set, which
+*    no one value stands in for: emit a hand-built op with a `tableIsEmptyCheck`
 *    precheck so the failure message is "table is not empty" rather than the
 *    raw PG NOT NULL violation.
 *
@@ -385,8 +459,6 @@ const storageTypePlanCallStrategy = (issues, ctx) => {
 const notNullAddColumnCallStrategy = (issues, ctx) => {
 	const matched = [];
 	const calls = [];
-	const schemaLookups = buildSchemaLookupMap(ctx.schema);
-	const mutableStorageTypes = blindCast(ctx.storageTypes);
 	for (const issue of issues) {
 		if (issueOutcome(issue) !== "not-found") continue;
 		const node = issueNode(issue);
@@ -401,30 +473,12 @@ const notNullAddColumnCallStrategy = (issues, ctx) => {
 		const contractTable = tableAt(ctx.toContract.storage, namespaceId, tableName);
 		const column = contractTable?.columns[expected.name];
 		if (!contractTable || !column) continue;
-		const schemaTable = ctx.schema.tables[tableName];
-		if (!schemaTable) continue;
+		if (ctx.schema.tables[tableName] === void 0) continue;
 		const temporaryDefault = resolveColumnTemporaryDefault(expected, ctx.codecHooks, ctx.types);
-		const schemaLookup = schemaLookups.get(tableName);
-		const canUseSharedTempDefault = temporaryDefault !== null && canUseSharedTemporaryDefaultStrategy({
-			table: contractTable,
-			schemaTable,
-			schemaLookup,
-			columnName: expected.name
-		});
+		const canUseSharedTempDefault = temporaryDefault !== null && columnTakesTemporaryValue(contractTable, expected.name);
 		matched.push(issue);
-		if (canUseSharedTempDefault && temporaryDefault !== null) {
-			calls.push(new AddNotNullColumnWithTempDefaultCall({
-				schemaName,
-				tableName,
-				columnName: expected.name,
-				column,
-				types: ctx.types,
-				storageTypes: mutableStorageTypes,
-				temporaryDefault
-			}));
-			continue;
-		}
-		calls.push(new AddNotNullColumnDirectCall(schemaName, tableName, expected.name, renderColumnDdl(expected.name, expected, ctx.types)));
+		const ddl = renderColumnDdl(expected.name, expected, ctx.types);
+		calls.push(canUseSharedTempDefault && temporaryDefault !== null ? new AddColumnWithTemporaryDefaultCall(schemaName, tableName, ddl.name, ddl.type, temporaryDefault) : new AddRequiredColumnToEmptyTableCall(schemaName, tableName, ddl.name, ddl.type));
 	}
 	if (matched.length === 0) return { kind: "no_match" };
 	return {
@@ -433,36 +487,19 @@ const notNullAddColumnCallStrategy = (issues, ctx) => {
 		calls
 	};
 };
-function canUseSharedTemporaryDefaultStrategy(options) {
-	const { table, schemaTable, schemaLookup, columnName } = options;
-	if (table.primaryKey?.columns.includes(columnName) && !schemaTable.primaryKey) return false;
-	for (const unique of table.uniques) {
-		if (!unique.columns.includes(columnName)) continue;
-		if (!schemaLookup || !hasUniqueConstraint(schemaLookup, unique.columns)) return false;
-	}
-	for (const foreignKey of table.foreignKeys) {
-		if (!foreignKey.source.columns.includes(columnName)) continue;
-		if (!schemaLookup || !hasForeignKey(schemaLookup, foreignKey)) return false;
-	}
-	return true;
-}
 /**
 * Ordered list of Postgres planner strategies, shared by `migration plan`
 * and `db update` / `db init`. The issue planner runs each strategy in
 * order, letting it consume any issues it handles, and routes whatever's
-* left through `mapNodeIssueToCall`. Behavior diverges purely on
-* `policy.allowedOperationClasses`:
+* left through `mapNodeIssueToCall`.
 *
-* - When `'data'` is allowed (`migration plan`), the data-safe strategies
-*   (`notNullBackfillCallStrategy`, `typeChangeCallStrategy`,
-*   `nullableTighteningCallStrategy`) consume their matching issues and emit
-*   `DataTransformCall` placeholders or recipe ops.
-*
-* - When `'data'` is not allowed (`db update` / `db init`), the
-*   placeholder-emitting strategies short-circuit to `no_match`, leaving
-*   the issue for the downstream strategies (`storageTypePlanCallStrategy`,
-*   `notNullAddColumnCallStrategy`) or the `mapNodeIssueToCall` default to
-*   handle with direct DDL.
+* The strategies that write a placeholder (`notNullBackfillCallStrategy`,
+* `typeChangeCallStrategy`, `nullableTighteningCallStrategy`) act only on a
+* field a `--backfill` or `--convert` statement names, and only when the
+* policy allows `data` (`migration plan`). Every other required field added to
+* an existing table gets the temporary default of
+* `notNullAddColumnCallStrategy`, and every other change the direct DDL of
+* `mapNodeIssueToCall`, under either command.
 *
 * Codec-typed storage type entries are dispatched through
 * `storageTypePlanCallStrategy`.
@@ -744,7 +781,7 @@ function mapTableNodeIssue(issue, schemaName, ddlSchemaName, types) {
 	if (!expected.rlsEnabled && actual.rlsEnabled) return ok([new DisableRowLevelSecurityCall(ddlSchemaName, expected.name)]);
 	return notOk(nodeConflict("unsupportedOperation", `unhandled table-attribute drift on "${expected.name}": table not-equal with no rlsEnabled delta (a second table attribute drifted)`));
 }
-function mapColumnNodeIssue(issue, schemaName, tableName, types) {
+function mapColumnNodeIssue(issue, schemaName, tableName, types, dataTypes) {
 	if (issueOutcome(issue) === "not-found") {
 		const column = blindCast(issue.expected);
 		return ok([new AddColumnCall(schemaName, tableName, renderColumnDdl(column.name, column, types))]);
@@ -753,14 +790,14 @@ function mapColumnNodeIssue(issue, schemaName, tableName, types) {
 	const expected = blindCast(issue.expected);
 	const actual = blindCast(issue.actual);
 	const calls = [];
-	if (columnTypeChanged(expected, actual)) {
-		const { qualifiedTargetType, formatTypeExpected } = renderColumnAlterType(expected, types);
-		calls.push(new AlterColumnTypeCall(schemaName, tableName, expected.name, {
-			qualifiedTargetType,
-			formatTypeExpected,
-			rawTargetTypeForLabel: qualifiedTargetType
-		}, liveColumnWidensSafely(expected, actual, types) ? "widening" : "destructive"));
-	}
+	if (columnTypeChanged(expected, actual)) calls.push(new AlterColumnTypeCall({
+		schemaName,
+		tableName,
+		columnName: expected.name,
+		type: renderColumnAlterType(expected, types),
+		dataTypes,
+		operationClass: liveColumnWidensSafely(expected, actual, types) ? "widening" : "destructive"
+	}));
 	if (expected.nullable !== actual.nullable) calls.push(expected.nullable ? new DropNotNullCall(schemaName, tableName, expected.name) : new SetNotNullCall(schemaName, tableName, expected.name));
 	return ok(calls);
 }
@@ -850,7 +887,7 @@ function mapNodeIssueToCall(issue, ctx) {
 	const schemaName = emissionSchemaName(ctx, ddlSchemaName);
 	switch (node.nodeKind) {
 		case PostgresSchemaNodeKind.table: return mapTableNodeIssue(issue, schemaName, ddlSchemaName, ctx.types);
-		case RelationalSchemaNodeKind.column: return mapColumnNodeIssue(issue, schemaName, tableName, ctx.types);
+		case RelationalSchemaNodeKind.column: return mapColumnNodeIssue(issue, schemaName, tableName, ctx.types, ctx.dataTypes);
 		case RelationalSchemaNodeKind.columnDefault: {
 			const columnName = issueColumnName(issue);
 			if (columnName === void 0) return notOk(nodeConflict("unsupportedOperation", `Default issue has no column in its path: ${issue.path.join("/")}`));
@@ -885,7 +922,12 @@ function planIssues(options) {
 		storageTypes: options.storageTypes,
 		schema,
 		policy,
-		frameworkComponents
+		frameworkComponents,
+		statementColumns: options.statementColumns ?? {
+			convert: [],
+			backfill: []
+		},
+		dataTypes: stackDataTypes(frameworkComponents)
 	};
 	const strategies = options.strategies ?? postgresPlannerStrategies;
 	let remaining = options.issues;
@@ -1190,4 +1232,4 @@ function resolvePostgresNodeIssueControlPolicySubject(issue, contract) {
 //#endregion
 export { planIssues as a, renderPostgresSuppression as c, resolvePostgresNodeIssueControlPolicySubject as d, resolvePostgresNodeIssueCreationFactoryName as f, issueSchemaName as i, resolveNamespaceIdForDdlSchema as l, conflictForDisallowedCall as n, postgresNodeStorageCoordinate as o, issueNode as r, postgresPlannerStrategies as s, coalesceSubtreeIssues as t, resolvePostgresCallControlPolicySubject as u };
 
-//# sourceMappingURL=control-policy-C5VoaD11-lzAw5cjN.mjs.map
+//# sourceMappingURL=control-policy-DXaIsgUW-Btyo9Vs8.mjs.map