@prisma/orm-target-postgres 8.0.0-rc.14-dev.5 → 8.0.0-rc.14-dev.7

package/dist/native-type-normalizer-CW6g9Fut-C5lMRRjS.mjs

@@ -0,0 +1,102 @@
+//#region ../../../3-targets/3-targets/postgres/dist/native-type-normalizer-CW6g9Fut.mjs
+/**
+* Postgres native-type normalization.
+*
+* Lives in `target-postgres` because both the migration planner/runner (control
+* plane) and the introspection adapter (control plane) need to normalize raw
+* native-type strings to the same canonical form for comparison.
+*/
+/** PostgreSQL's other names for a type, each with the name introspection reports it under. */
+const TYPE_NAME_ALIASES = /* @__PURE__ */ new Map([
+	["char", "character"],
+	["bpchar", "character"],
+	["varchar", "character varying"],
+	["varbit", "bit varying"],
+	["int", "int4"],
+	["integer", "int4"],
+	["smallint", "int2"],
+	["bigint", "int8"],
+	["real", "float4"],
+	["double precision", "float8"],
+	["float", "float8"],
+	["boolean", "bool"],
+	["decimal", "numeric"]
+]);
+/** The types that take ` with time zone`, each with the name it has with one. */
+const WITH_TIME_ZONE = /* @__PURE__ */ new Map([["timestamp", "timestamptz"], ["time", "timetz"]]);
+const NATIVE_TYPE_PARTS = /^([a-z][a-z ]*?)(\([^)]*\))?( with time zone| without time zone)?$/;
+/**
+* `nativeType` named as introspection reports it, on the contract side and the introspected side alike: an alias under PostgreSQL's canonical name (`char(3)` is `character(3)`, `int` is `int4`), `timestamp(3) with time zone` as `timestamptz(3)`, `time without time zone` as `time`, and a list type's element the same way. A `float` with a precision is `real` or `double precision` depending on it, so it is left as written, and so is a name this does not describe, such as a user-defined type.
+*/
+function normalizeSchemaNativeType(nativeType) {
+	const trimmed = nativeType.trim();
+	if (trimmed.endsWith("[]")) return `${normalizeSchemaNativeType(trimmed.slice(0, -2))}[]`;
+	const parts = NATIVE_TYPE_PARTS.exec(trimmed);
+	if (parts === null) return trimmed;
+	const [, base = "", modifier = "", zone = ""] = parts;
+	if (zone !== "") {
+		const zoned = WITH_TIME_ZONE.get(base);
+		if (zoned === void 0) return trimmed;
+		return `${zone === " with time zone" ? zoned : base}${modifier}`;
+	}
+	if (base === "float" && modifier !== "") return trimmed;
+	return `${TYPE_NAME_ALIASES.get(base) ?? base}${modifier}`;
+}
+/** The types PostgreSQL stores with a length of 1 when none is written, and reports that way. */
+const LENGTH_ONE_WHEN_BARE = /* @__PURE__ */ new Set(["character", "bit"]);
+/** A normalized type name with the length PostgreSQL gives `character` and `bit` when none is written. */
+function withLengthOneWhenBare(typeName) {
+	return LENGTH_ONE_WHEN_BARE.has(typeName) ? `${typeName}(1)` : typeName;
+}
+/** The native type introspection reports for a column, from its catalog type columns. */
+function introspectedNativeType(column) {
+	const reported = reportedNativeType(column);
+	const many = reported.endsWith("[]") ? true : void 0;
+	const nativeType = many ? normalizeSchemaNativeType(reported.slice(0, -2)) : reported;
+	return {
+		nativeType,
+		many,
+		resolvedNativeType: `${normalizeSchemaNativeType(nativeType)}${many ? "[]" : ""}`
+	};
+}
+function reportedNativeType(column) {
+	if (column.formattedType) return normalizeFormattedType(column.formattedType);
+	if (column.dataType === "character varying" || column.dataType === "character") return column.characterMaximumLength ? `${column.dataType}(${column.characterMaximumLength})` : column.dataType;
+	if (column.dataType === "numeric" || column.dataType === "decimal") {
+		if (column.numericPrecision && column.numericScale !== null) return `${column.dataType}(${column.numericPrecision},${column.numericScale})`;
+		return column.numericPrecision ? `${column.dataType}(${column.numericPrecision})` : column.dataType;
+	}
+	return column.udtName || column.dataType;
+}
+/**
+* `format_type`'s name for a column type, named as the contract names it: a built-in type through {@link normalizeSchemaNativeType}, and a user-defined type, which `format_type` quotes where it needs to (mixed case, a reserved word, a dot) and schema-qualifies outside the search path, with each identifier unquoted.
+*/
+function normalizeFormattedType(formattedType) {
+	if (formattedType.endsWith("[]")) return `${normalizeFormattedType(formattedType.slice(0, -2))}[]`;
+	const normalized = normalizeSchemaNativeType(formattedType);
+	if (normalized !== formattedType) return normalized;
+	return splitQualifiedName(formattedType).map(unquoteIdentifier).join(".");
+}
+function splitQualifiedName(name) {
+	const segments = [];
+	let current = "";
+	let quoted = false;
+	for (const char of name) {
+		if (char === "\"") quoted = !quoted;
+		if (char === "." && !quoted) {
+			segments.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	segments.push(current);
+	return segments;
+}
+function unquoteIdentifier(segment) {
+	return segment.length >= 2 && segment.startsWith("\"") && segment.endsWith("\"") ? segment.slice(1, -1).replaceAll("\"\"", "\"") : segment;
+}
+//#endregion
+export { normalizeSchemaNativeType as n, withLengthOneWhenBare as r, introspectedNativeType as t };
+
+//# sourceMappingURL=native-type-normalizer-CW6g9Fut-C5lMRRjS.mjs.map

package/dist/native-type-normalizer-CW6g9Fut-C5lMRRjS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-type-normalizer-CW6g9Fut-C5lMRRjS.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/native-type-normalizer-CW6g9Fut.mjs"],"sourcesContent":["//#region src/core/native-type-normalizer.ts\n/**\n* Postgres native-type normalization.\n*\n* Lives in `target-postgres` because both the migration planner/runner (control\n* plane) and the introspection adapter (control plane) need to normalize raw\n* native-type strings to the same canonical form for comparison.\n*/\n/** PostgreSQL's other names for a type, each with the name introspection reports it under. */\nconst TYPE_NAME_ALIASES = /* @__PURE__ */ new Map([\n\t[\"char\", \"character\"],\n\t[\"bpchar\", \"character\"],\n\t[\"varchar\", \"character varying\"],\n\t[\"varbit\", \"bit varying\"],\n\t[\"int\", \"int4\"],\n\t[\"integer\", \"int4\"],\n\t[\"smallint\", \"int2\"],\n\t[\"bigint\", \"int8\"],\n\t[\"real\", \"float4\"],\n\t[\"double precision\", \"float8\"],\n\t[\"float\", \"float8\"],\n\t[\"boolean\", \"bool\"],\n\t[\"decimal\", \"numeric\"]\n]);\n/** The types that take ` with time zone`, each with the name it has with one. */\nconst WITH_TIME_ZONE = /* @__PURE__ */ new Map([[\"timestamp\", \"timestamptz\"], [\"time\", \"timetz\"]]);\nconst NATIVE_TYPE_PARTS = /^([a-z][a-z ]*?)(\\([^)]*\\))?( with time zone| without time zone)?$/;\n/**\n* `nativeType` named as introspection reports it, on the contract side and the introspected side alike: an alias under PostgreSQL's canonical name (`char(3)` is `character(3)`, `int` is `int4`), `timestamp(3) with time zone` as `timestamptz(3)`, `time without time zone` as `time`, and a list type's element the same way. A `float` with a precision is `real` or `double precision` depending on it, so it is left as written, and so is a name this does not describe, such as a user-defined type.\n*/\nfunction normalizeSchemaNativeType(nativeType) {\n\tconst trimmed = nativeType.trim();\n\tif (trimmed.endsWith(\"[]\")) return `${normalizeSchemaNativeType(trimmed.slice(0, -2))}[]`;\n\tconst parts = NATIVE_TYPE_PARTS.exec(trimmed);\n\tif (parts === null) return trimmed;\n\tconst [, base = \"\", modifier = \"\", zone = \"\"] = parts;\n\tif (zone !== \"\") {\n\t\tconst zoned = WITH_TIME_ZONE.get(base);\n\t\tif (zoned === void 0) return trimmed;\n\t\treturn `${zone === \" with time zone\" ? zoned : base}${modifier}`;\n\t}\n\tif (base === \"float\" && modifier !== \"\") return trimmed;\n\treturn `${TYPE_NAME_ALIASES.get(base) ?? base}${modifier}`;\n}\n/** The types PostgreSQL stores with a length of 1 when none is written, and reports that way. */\nconst LENGTH_ONE_WHEN_BARE = /* @__PURE__ */ new Set([\"character\", \"bit\"]);\n/** A normalized type name with the length PostgreSQL gives `character` and `bit` when none is written. */\nfunction withLengthOneWhenBare(typeName) {\n\treturn LENGTH_ONE_WHEN_BARE.has(typeName) ? `${typeName}(1)` : typeName;\n}\n/** The native type introspection reports for a column, from its catalog type columns. */\nfunction introspectedNativeType(column) {\n\tconst reported = reportedNativeType(column);\n\tconst many = reported.endsWith(\"[]\") ? true : void 0;\n\tconst nativeType = many ? normalizeSchemaNativeType(reported.slice(0, -2)) : reported;\n\treturn {\n\t\tnativeType,\n\t\tmany,\n\t\tresolvedNativeType: `${normalizeSchemaNativeType(nativeType)}${many ? \"[]\" : \"\"}`\n\t};\n}\nfunction reportedNativeType(column) {\n\tif (column.formattedType) return normalizeFormattedType(column.formattedType);\n\tif (column.dataType === \"character varying\" || column.dataType === \"character\") return column.characterMaximumLength ? `${column.dataType}(${column.characterMaximumLength})` : column.dataType;\n\tif (column.dataType === \"numeric\" || column.dataType === \"decimal\") {\n\t\tif (column.numericPrecision && column.numericScale !== null) return `${column.dataType}(${column.numericPrecision},${column.numericScale})`;\n\t\treturn column.numericPrecision ? `${column.dataType}(${column.numericPrecision})` : column.dataType;\n\t}\n\treturn column.udtName || column.dataType;\n}\n/**\n* `format_type`'s name for a column type, named as the contract names it: a built-in type through {@link normalizeSchemaNativeType}, and a user-defined type, which `format_type` quotes where it needs to (mixed case, a reserved word, a dot) and schema-qualifies outside the search path, with each identifier unquoted.\n*/\nfunction normalizeFormattedType(formattedType) {\n\tif (formattedType.endsWith(\"[]\")) return `${normalizeFormattedType(formattedType.slice(0, -2))}[]`;\n\tconst normalized = normalizeSchemaNativeType(formattedType);\n\tif (normalized !== formattedType) return normalized;\n\treturn splitQualifiedName(formattedType).map(unquoteIdentifier).join(\".\");\n}\nfunction splitQualifiedName(name) {\n\tconst segments = [];\n\tlet current = \"\";\n\tlet quoted = false;\n\tfor (const char of name) {\n\t\tif (char === \"\\\"\") quoted = !quoted;\n\t\tif (char === \".\" && !quoted) {\n\t\t\tsegments.push(current);\n\t\t\tcurrent = \"\";\n\t\t\tcontinue;\n\t\t}\n\t\tcurrent += char;\n\t}\n\tsegments.push(current);\n\treturn segments;\n}\nfunction unquoteIdentifier(segment) {\n\treturn segment.length >= 2 && segment.startsWith(\"\\\"\") && segment.endsWith(\"\\\"\") ? segment.slice(1, -1).replaceAll(\"\\\"\\\"\", \"\\\"\") : segment;\n}\n//#endregion\nexport { normalizeSchemaNativeType as n, withLengthOneWhenBare as r, introspectedNativeType as t };\n\n//# sourceMappingURL=native-type-normalizer-CW6g9Fut.mjs.map"],"mappings":"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"}

package/dist/op-factory-call-Bi1XxJEv.d.mts

@@ -0,0 +1 @@
+import "./op-factory-call-VLJFI-b_-Du23HNYc.mjs";

package/dist/{op-factory-call-t4k8mlRJ-BgtGXlIC.d.mts → op-factory-call-VLJFI-b_-Du23HNYc.d.mts}

@@ -7,7 +7,7 @@ import { MigrationOperationClass, OpFactoryCall } from "@prisma/orm-framework/co
 import { CodecControlHooks, SqlMigrationPlanOperation } from "@prisma/orm-family-sql/family/control";
 import { ImportRequirement, TsExpression } from "@prisma/orm-framework/ts-render";
 import { ExecuteRequestLowerer, Lowerer } from "@prisma/orm-family-sql/family/control-adapter";
-//#region ../../../3-targets/3-targets/postgres/dist/op-factory-call-t4k8mlRJ.d.mts
+//#region ../../../3-targets/3-targets/postgres/dist/op-factory-call-VLJFI-b_.d.mts
 //#region src/core/migrations/operations/shared.d.ts
 type Op$1 = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
 /**
@@ -156,10 +156,10 @@ declare class SetDefaultCall extends PostgresOpFactoryCallNode {
   readonly operationClass: 'additive' | 'widening';
   readonly schemaName: string;
   readonly tableName: string;
-  readonly columnName: string;
-  readonly defaultSql: string;
+  /** The column with the default to set, its type and its codec; the adapter writes the clause. */
+  readonly column: DdlColumn;
   readonly label: string;
-  constructor(schemaName: string, tableName: string, columnName: string, defaultSql: string, operationClass?: 'additive' | 'widening');
+  constructor(schemaName: string, tableName: string, column: DdlColumn, operationClass?: 'additive' | 'widening');
   toOp(lowerer?: ExecuteRequestLowerer): Promise<Op>;
   renderTypeScript(): string;
   importRequirements(): readonly ImportRequirement[];
@@ -531,4 +531,4 @@ declare class RenamePostgresRlsPolicyCall extends PostgresOpFactoryCallNode {
 type PostgresOpFactoryCall = CreateTableCall | DropTableCall | AddColumnCall | DropColumnCall | AlterColumnTypeCall | SetNotNullCall | DropNotNullCall | SetDefaultCall | DropDefaultCall | AddNotNullColumnDirectCall | AddNotNullColumnWithTempDefaultCall | AddPrimaryKeyCall | AddForeignKeyCall | AddUniqueCall | AddCheckConstraintCall | RenameCheckConstraintCall | DropCheckConstraintCall | CreateIndexCall | RenameIndexCall | DropIndexCall | DropConstraintCall | RawSqlCall | CreateExtensionCall | CreateSchemaCall | CreateNativeEnumTypeCall | DropNativeEnumTypeCall | AddNativeEnumValueCall | CreatePostgresRlsPolicyCall | DropPostgresRlsPolicyCall | EnableRowLevelSecurityCall | DisableRowLevelSecurityCall | RenamePostgresRlsPolicyCall | DataTransformCall;
 //#endregion
 export { Op$1 as A, DropIndexCall as C, DropTableCall as D, DropPostgresRlsPolicyCall as E, RenamePostgresRlsPolicyCall as F, SetDefaultCall as I, SetNotNullCall as L, RawSqlCall as M, RenameCheckConstraintCall as N, EnableRowLevelSecurityCall as O, RenameIndexCall as P, DropDefaultCall as S, DropNotNullCall as T, DataTransformCall as _, AddNotNullColumnWithTempDefaultCall as a, DropColumnCall as b, AlterColumnTypeCall as c, CreateIndexCall as d, CreateIndexExtras as f, CreateTableCall as g, CreateSchemaCall as h, AddNativeEnumValueCall as i, PostgresOpFactoryCall as j, ForeignKeySpec as k, AlterColumnTypeOptions as l, CreatePostgresRlsPolicyCall as m, AddColumnCall as n, AddPrimaryKeyCall as o, CreateNativeEnumTypeCall as p, AddForeignKeyCall as r, AddUniqueCall as s, AddCheckConstraintCall as t, CreateExtensionCall as u, DisableRowLevelSecurityCall as v, DropNativeEnumTypeCall as w, DropConstraintCall as x, DropCheckConstraintCall as y };
-//# sourceMappingURL=op-factory-call-t4k8mlRJ-BgtGXlIC.d.mts.map
+//# sourceMappingURL=op-factory-call-VLJFI-b_-Du23HNYc.d.mts.map

package/dist/op-factory-call-VLJFI-b_-Du23HNYc.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"op-factory-call-VLJFI-b_-Du23HNYc.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/op-factory-call-VLJFI-b_.d.mts"],"mappings":"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"}

package/dist/{op-factory-call-BBkvFvKK-7MkUHWJq.mjs → op-factory-call-y5YADY2E-CnhkIujC.mjs}

@@ -2,9 +2,9 @@ import { s as postgresError } from "./errors-DYyzTYzE-39CV_aMo.mjs";
 import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86-Cpp8PTxD.mjs";
 import { a as validateEnumValueLength, i as quoteQualifiedName, r as quoteIdentifier, t as escapeLiteral } from "./sql-utils-Bh-mnsSY-D6hnFPrP.mjs";
 import { C as nativeEnumValueExistsAst, D as tableExistsAst, E as rlsPolicyExistsAst, O as tableIsEmptyAst, S as nativeEnumTypeExistsAst, T as rlsEnabledAst, _ as dropIndex$1, a as columnDefaultAst, b as extensionExistsAst, c as columnTypeAst, d as createPolicy, f as createSchema, g as dropDefaultAction, h as disableRowLevelSecurity$1, i as alterTable, l as constraintExistsAst, m as createType, n as alterIndexRename, o as columnExistsAst, p as createTable, r as alterPolicyRename, s as columnNullabilityAst, t as addColumnAction, u as createIndex$1, v as dropPolicy, w as noNullValuesAst, x as indexExistsAst, y as dropType } from "./ddl-BEslwyjE-CzNPjhh1.mjs";
-import { n as qualifyTableName } from "./planner-sql-checks-Bd8nN9P8-Cd98iEee.mjs";
-import { n as buildColumnTypeSql } from "./planner-ddl-builders-GTcVPpwb-ClvrXb26.mjs";
-import { FunctionColumnDefault, LiteralColumnDefault } from "@prisma/orm-family-sql/relational-core/ast";
+import { n as qualifyTableName } from "./planner-sql-checks-ZMXeCK6W-D1VMBywZ.mjs";
+import { t as buildColumnTypeSql } from "./planner-ddl-builders-iE35pyxA-g7b_clbn.mjs";
+import { DdlColumn, FunctionColumnDefault, LiteralColumnDefault } from "@prisma/orm-family-sql/relational-core/ast";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
@@ -14,7 +14,7 @@ import { InternalError, assertNever } from "@prisma/orm-framework/utils/internal
 import { errorUnfilledPlaceholder } from "@prisma/orm-framework/errors/migration";
 import { TsExpression, jsonToTsSource } from "@prisma/orm-framework/ts-render";
 import { REFERENTIAL_ACTION_SQL } from "@prisma/orm-family-sql/contract/referential-action-sql";
-//#region ../../../3-targets/3-targets/postgres/dist/op-factory-call-BBkvFvKK.mjs
+//#region ../../../3-targets/3-targets/postgres/dist/op-factory-call-y5YADY2E.mjs
 /**
 * Maps a planner schema name to the contract-free DDL builder's optional
 * `schema` field: the unbound sentinel becomes `undefined` (the builder omits
@@ -150,35 +150,39 @@ async function dropNotNull(schemaName, tableName, columnName, lowerer) {
 	};
 }
 /**
-* `defaultSql` is the full `DEFAULT …` clause as produced by
-* `buildColumnDefaultSql` — e.g. `"DEFAULT 42"`,
-* `"DEFAULT (CURRENT_TIMESTAMP)"`, or `"DEFAULT nextval('seq'::regclass)"`.
+* Sets `column`'s default. The adapter writes the `DEFAULT …` clause, reading a literal default with
+* the column's codec first, as every DDL statement that writes a default does.
 *
 * `operationClass` defaults to `'additive'` (setting a default on a column
 * that currently has none). The reconciliation planner passes `'widening'`
 * when the column already has a different default — policy enforcement
-* treats that as a widening change rather than an additive one.
+* treats that as a widening change rather than an additive one. A widening
+* change has no postcheck: the old default would pass a check for a default,
+* and the runner skips an operation whose postcheck already passes. Setting a
+* default again is harmless.
 */
-async function setDefault(schemaName, tableName, columnName, defaultSql, lowerer, operationClass = "additive") {
+async function setDefault(schemaName, tableName, column, lowerer, operationClass = "additive") {
+	const columnName = column.name;
 	const qualified = qualifyTableName(schemaName, tableName);
+	const clause = await lowerer.renderColumnDefault(column, tableName);
 	const { present } = await columnExistsSteps(lowerer, {
 		schema: schemaName,
 		table: tableName,
 		column: columnName
 	});
-	const hasDefault = await lowerer.lowerToExecuteRequest(columnDefaultAst({
+	const hasDefault = operationClass === "additive" ? await lowerer.lowerToExecuteRequest(columnDefaultAst({
 		schema: schemaName,
 		table: tableName,
 		column: columnName
-	}).defaultPresent());
+	}).defaultPresent()) : void 0;
 	return {
 		id: `setDefault.${tableName}.${columnName}`,
 		label: `Set default on "${tableName}"."${columnName}"`,
 		operationClass,
 		target: targetDetails("column", columnName, schemaName, tableName),
 		precheck: [step(`ensure column "${columnName}" exists`, present.sql, present.params)],
-		execute: [step(`set default on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} SET ${defaultSql}`)],
-		postcheck: [step(`verify column "${columnName}" has a default`, hasDefault.sql, hasDefault.params)]
+		execute: [step(`set default on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} SET ${clause}`)],
+		postcheck: hasDefault === void 0 ? [] : [step(`verify column "${columnName}" has a default`, hasDefault.sql, hasDefault.params)]
 	};
 }
 async function dropDefault(schemaName, tableName, columnName, lowerer) {
@@ -1181,34 +1185,38 @@ var SetDefaultCall = class extends PostgresOpFactoryCallNode {
 	operationClass;
 	schemaName;
 	tableName;
-	columnName;
-	defaultSql;
+	/** The column with the default to set, its type and its codec; the adapter writes the clause. */
+	column;
 	label;
-	constructor(schemaName, tableName, columnName, defaultSql, operationClass = "additive") {
+	constructor(schemaName, tableName, column, operationClass = "additive") {
 		super();
 		this.schemaName = schemaName;
 		this.tableName = tableName;
-		this.columnName = columnName;
-		this.defaultSql = defaultSql;
+		this.column = column;
 		this.operationClass = operationClass;
-		this.label = `Set default on "${tableName}"."${columnName}"`;
+		this.label = `Set default on "${tableName}"."${column.name}"`;
 		this.freeze();
 	}
 	async toOp(lowerer) {
-		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `SetDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "SetDefaultCall" } });
-		return setDefault(this.schemaName, this.tableName, this.columnName, this.defaultSql, lowerer, this.operationClass);
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `SetDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.column.name}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "SetDefaultCall" } });
+		return setDefault(this.schemaName, this.tableName, this.column, lowerer, this.operationClass);
 	}
 	renderTypeScript() {
 		const opts = [];
 		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
 		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
-		opts.push(`column: ${jsonToTsSource(this.columnName)}`);
-		opts.push(`defaultSql: ${jsonToTsSource(this.defaultSql)}`);
+		opts.push(`column: ${renderDdlColumnAsTsCall(this.column)}`);
 		if (this.operationClass !== "additive") opts.push(`operationClass: ${jsonToTsSource(this.operationClass)}`);
 		return `this.setDefault({ ${opts.join(", ")} })`;
 	}
 	importRequirements() {
-		return [];
+		return [{
+			moduleSpecifier: POSTGRES_MIGRATION_FACADE,
+			symbol: "col"
+		}, ...defaultImportSymbols([this.column]).map((symbol) => ({
+			moduleSpecifier: POSTGRES_MIGRATION_FACADE,
+			symbol
+		}))];
 	}
 };
 var DropDefaultCall = class extends PostgresOpFactoryCallNode {
@@ -2056,7 +2064,12 @@ var RenamePostgresRlsPolicyCall = class extends PostgresOpFactoryCallNode {
 		return [];
 	}
 };
+/** The name of the column a call acts on: its `columnName`, or the name of the column it carries. */
+function columnNameOfCall(call) {
+	if ("columnName" in call) return call.columnName;
+	if ("column" in call && call.column instanceof DdlColumn) return call.column.name;
+}
 //#endregion
-export { RenameIndexCall as A, DropNativeEnumTypeCall as C, EnableRowLevelSecurityCall as D, DropTableCall as E, createExtension as F, installExtension as I, postgresDefaultToDdlColumnDefault as L, SetDefaultCall as M, SetNotNullCall as N, RawSqlCall as O, buildTargetDetails as P, DropIndexCall as S, DropPostgresRlsPolicyCall as T, DisableRowLevelSecurityCall as _, AddNotNullColumnDirectCall as a, DropConstraintCall as b, AddUniqueCall as c, CreateIndexCall as d, CreateNativeEnumTypeCall as f, DataTransformCall as g, CreateTableCall as h, AddNativeEnumValueCall as i, RenamePostgresRlsPolicyCall as j, RenameCheckConstraintCall as k, AlterColumnTypeCall as l, CreateSchemaCall as m, AddColumnCall as n, AddNotNullColumnWithTempDefaultCall as o, CreatePostgresRlsPolicyCall as p, AddForeignKeyCall as r, AddPrimaryKeyCall as s, AddCheckConstraintCall as t, CreateExtensionCall as u, DropCheckConstraintCall as v, DropNotNullCall as w, DropDefaultCall as x, DropColumnCall as y };
+export { RenameIndexCall as A, DropNativeEnumTypeCall as C, EnableRowLevelSecurityCall as D, DropTableCall as E, columnNameOfCall as F, createExtension as I, installExtension as L, SetDefaultCall as M, SetNotNullCall as N, RawSqlCall as O, buildTargetDetails as P, postgresDefaultToDdlColumnDefault as R, DropIndexCall as S, DropPostgresRlsPolicyCall as T, DisableRowLevelSecurityCall as _, AddNotNullColumnDirectCall as a, DropConstraintCall as b, AddUniqueCall as c, CreateIndexCall as d, CreateNativeEnumTypeCall as f, DataTransformCall as g, CreateTableCall as h, AddNativeEnumValueCall as i, RenamePostgresRlsPolicyCall as j, RenameCheckConstraintCall as k, AlterColumnTypeCall as l, CreateSchemaCall as m, AddColumnCall as n, AddNotNullColumnWithTempDefaultCall as o, CreatePostgresRlsPolicyCall as p, AddForeignKeyCall as r, AddPrimaryKeyCall as s, AddCheckConstraintCall as t, CreateExtensionCall as u, DropCheckConstraintCall as v, DropNotNullCall as w, DropDefaultCall as x, DropColumnCall as y };
 
-//# sourceMappingURL=op-factory-call-BBkvFvKK-7MkUHWJq.mjs.map
+//# sourceMappingURL=op-factory-call-y5YADY2E-CnhkIujC.mjs.map