qubu 0.6.1 → 0.6.2

package/dist/introspection/postgres.mjs

@@ -9,6 +9,8 @@ const postgresServerQuery = `
 /** Read one PostgreSQL schema into the normalized catalog contract. */
 async function readCatalog(connection, options) {
 	const diagnostics = [];
+	const deferredObjects = [];
+	const opaqueObjects = [];
 	if (connection.dialect !== "postgresql") {
 		diagnostics.push(createIntrospectionDiagnostic({
 			severity: "error",
@@ -54,24 +56,35 @@ async function readCatalog(connection, options) {
 	for (const row of indexRows) {
 		const indexOid = text(row.index_oid);
 		const physicalName = text(row.physical_name);
+		const ownerTable = tableByOid.get(text(row.table_oid));
 		if (indexOid && physicalName) indexReferences.set(`pg_class:${indexOid}`, {
 			kind: "index",
 			id: stableId(physicalName),
 			physicalName,
+			...ownerTable === void 0 ? {} : { owner: {
+				kind: "table",
+				id: ownerTable.id
+			} },
 			reference: reference("index", physicalName, options.namespace, "pg_class", "oid", row.index_oid)
 		});
 	}
-	const constraintsByTable = groupBy(await query(connection, postgresConstraintsQuery, [options.namespace], options, diagnostics, "constraints"), (row) => row.table_oid);
+	const constraintsByTable = groupBy(await query(connection, (server.parsedVersion?.major ?? 0) >= 15 ? postgresConstraintsQuery : postgresConstraintsQueryWithoutNullsNotDistinct, [options.namespace], options, diagnostics, "constraints"), (row) => row.table_oid);
 	for (const table of tables) {
 		const rows = constraintsByTable.get(table.reference?.catalog?.value) ?? [];
 		const columnsByNumber = new Map(table.columns.map((column) => [column.ordinalPosition, column.physicalName]));
-		table.constraints = rows.map((row) => constraint(row, table, columnsByNumber, tableByOid, options.namespace, diagnostics, indexReferences)).filter((value) => value !== void 0);
+		const constraints = [];
+		for (const value of rows.map((row) => constraint(row, table, columnsByNumber, tableByOid, options.namespace, diagnostics, indexReferences))) {
+			if (value === void 0) continue;
+			if (value.kind === "opaque-object") opaqueObjects.push(value);
+			else constraints.push(value);
+		}
+		table.constraints = constraints;
 	}
 	const indexesByTable = groupBy(indexRows, (row) => row.table_oid);
-	for (const table of tables) table.indexes = mapIndexes(indexesByTable.get(table.reference?.catalog?.value) ?? [], table, new Map(table.columns.map((column) => [column.ordinalPosition, column.physicalName])), options.namespace);
+	for (const table of tables) table.indexes = mapIndexes(indexesByTable.get(table.reference?.catalog?.value) ?? [], table, new Map(table.columns.map((column) => [column.ordinalPosition, column.physicalName])), options.namespace, diagnostics, opaqueObjects);
 	const sequences = (await query(connection, postgresSequencesQuery, [options.namespace], options, diagnostics, "sequences")).map((row) => sequenceObject(row, options.namespace, tableByOid, diagnostics));
 	const enums = mapEnums(await query(connection, postgresEnumsQuery, [options.namespace], options, diagnostics, "enums"), options.namespace);
-	const domains = mapDomains(await query(connection, postgresDomainsQuery, [options.namespace], options, diagnostics, "domains"), await query(connection, postgresDomainConstraintsQuery, [options.namespace], options, diagnostics, "domain-constraints"), options.namespace);
+	const domains = mapDomains(await query(connection, postgresDomainsQuery, [options.namespace], options, diagnostics, "domains"), await query(connection, postgresDomainConstraintsQuery, [options.namespace], options, diagnostics, "domain-constraints"), options.namespace, opaqueObjects, diagnostics);
 	const collations = (await query(connection, postgresCollationsQuery, [options.namespace], options, diagnostics, "collations")).map((row) => collationObject(row, options.namespace));
 	const triggerRows = await query(connection, postgresTriggersQuery, [options.namespace], options, diagnostics, "triggers");
 	const triggers = [];
@@ -82,19 +95,27 @@ async function readCatalog(connection, options) {
 		else triggers.push(value);
 	}
 	const routines = mapRoutines(await query(connection, postgresRoutinesQuery, [options.namespace], options, diagnostics, "routines"), await query(connection, postgresRoutineParametersQuery, [options.namespace], options, diagnostics, "routine-parameters"), options.namespace, diagnostics);
-	const partitions = (await query(connection, postgresPartitionsQuery, [options.namespace], options, diagnostics, "partitions")).map((row) => partitionObject(row, options.namespace, tableByOid, diagnostics)).filter((value) => value !== void 0);
+	const partitionRows = await query(connection, postgresPartitionsQuery, [options.namespace], options, diagnostics, "partitions");
+	const partitions = [];
+	for (const row of partitionRows) {
+		const value = partitionObject(row, options.namespace, tableByOid, diagnostics);
+		if (value === void 0) continue;
+		if (value.kind === "partition") partitions.push(value);
+		else if (value.kind === "deferred-object") deferredObjects.push(value);
+		else opaqueObjects.push(value);
+	}
 	const policies = (await query(connection, postgresPoliciesQuery, [options.namespace], options, diagnostics, "policies")).map((row) => policyObject(row, options.namespace, tableByOid, diagnostics)).filter((value) => value !== void 0);
 	const extensionObjects = (await query(connection, postgresExtensionsQuery, [options.namespace], options, diagnostics, "extensions")).map((row) => extensionObject(row, options.namespace));
 	const typedRelationOids = new Set([...views, ...sequences].map((object) => object.reference?.catalog?.value));
-	const deferredObjects = relationObjects.filter((row) => {
+	deferredObjects.push(...relationObjects.filter((row) => {
 		const relkind = text(row.relkind);
 		return relkind === "f" || (relkind === "v" || relkind === "m" || relkind === "S") && !typedRelationOids.has(row.oid === void 0 ? void 0 : text(row.oid));
-	}).map((row) => deferredObject(row, text(row.relkind) === "f" ? "foreign-table" : text(row.relkind) === "v" ? "view" : text(row.relkind) === "m" ? "materialized-view" : "sequence"));
+	}).map((row) => deferredObject(row, text(row.relkind) === "f" ? "foreign-table" : text(row.relkind) === "v" ? "view" : text(row.relkind) === "m" ? "materialized-view" : "sequence")));
 	deferredObjects.push(...triggerDeferredObjects);
-	const opaqueObjects = relationObjects.filter((row) => {
+	opaqueObjects.push(...relationObjects.filter((row) => {
 		const kind = text(row.relkind);
 		return kind !== "r" && kind !== "p" && kind !== "v" && kind !== "m" && kind !== "S" && kind !== "f";
-	}).map((row) => opaqueRelationObject(row, options.namespace, diagnostics));
+	}).map((row) => opaqueRelationObject(row, options.namespace, diagnostics)));
 	const metadata = mapMetadataRows(await query(connection, postgresMetadataQuery, [options.namespace], options, diagnostics, "comments-and-ownership"), options.namespace, tables, views, sequences, enums, domains, collations, routines, triggers, policies, extensionObjects, deferredObjects, opaqueObjects, indexReferences, relationReferences, diagnostics);
 	opaqueObjects.push(...metadata.opaqueObjects);
 	return Object.freeze({
@@ -161,6 +182,24 @@ const postgresColumnsQuery = `
     AND NOT a.attisdropped
   ORDER BY a.attrelid, a.attnum
 `;
+/** Constraint metadata for PostgreSQL versions before pg_index.indnullsnotdistinct. */
+const postgresConstraintsQueryWithoutNullsNotDistinct = `
+  SELECT con.oid::text AS oid, con.conrelid::text AS table_oid,
+         con.conname AS physical_name, con.contype,
+         con.conkey, con.confrelid::text AS target_table_oid, con.confkey,
+         con.confupdtype, con.confdeltype, con.confmatchtype,
+         con.condeferrable, con.condeferred, con.convalidated,
+         con.conindid::text AS backing_index_oid,
+         pg_get_constraintdef(con.oid, true) AS definition
+  FROM pg_constraint con
+  JOIN pg_class c ON c.oid = con.conrelid
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+  LEFT JOIN pg_index i ON i.indexrelid = con.conindid
+  WHERE n.nspname = $1
+    AND con.contype IN ('p', 'u', 'f', 'c', 'x')
+  ORDER BY con.conrelid, con.oid
+`;
+/** Constraint metadata for PostgreSQL versions that expose nulls-not-distinct indexes. */
 const postgresConstraintsQuery = `
   SELECT con.oid::text AS oid, con.conrelid::text AS table_oid,
          con.conname AS physical_name, con.contype,
@@ -326,6 +365,7 @@ const postgresPartitionsQuery = `
   SELECT child.oid::text AS partition_oid, parent.oid::text AS parent_oid,
          n.nspname AS namespace, child.relname AS physical_name,
          part.partstrat, part.partattrs::text AS key_attributes,
+         pg_get_partkeydef(parent.oid) AS key_definition,
          pg_get_expr(child.relpartbound, child.oid, true) AS bound,
          child.relispartition, child.relkind
   FROM pg_catalog.pg_inherits inh
@@ -544,10 +584,7 @@ function viewObject(row, namespace, diagnostics) {
 			physicalReference,
 			remediation: "Grant access to pg_get_viewdef before treating this object as migration input."
 		}));
-		return deferredCatalogObject(kind === "view" ? "view" : "materialized-view", physicalName, physicalReference, [{
-			name: "definition",
-			value: expression("/* view definition unavailable */", "decompiler", physicalReference)
-		}]);
+		return deferredCatalogObject(kind === "view" ? "view" : "materialized-view", physicalName, physicalReference);
 	}
 	const options = stringArray(row.reloptions);
 	const checkOption = (() => {
@@ -672,7 +709,7 @@ function mapEnums(rows, namespace) {
 		};
 	});
 }
-function mapDomains(rows, constraintRows, namespace) {
+function mapDomains(rows, constraintRows, namespace, opaqueObjects, diagnostics) {
 	const constraintsByDomain = groupBy(constraintRows, (row) => text(row.domain_oid) ?? "unknown");
 	return rows.map((row) => {
 		const physicalName = text(row.physical_name) ?? `domain_${text(row.oid) ?? "unknown"}`;
@@ -680,18 +717,37 @@ function mapDomains(rows, constraintRows, namespace) {
 		const domainConstraints = (constraintsByDomain.get(text(row.oid)) ?? []).map((constraintRow) => {
 			const constraintName = text(constraintRow.physical_name) ?? `domain_constraint_${text(constraintRow.oid) ?? "unknown"}`;
 			const constraintReference = reference("constraint", constraintName, text(row.namespace) ?? namespace, "pg_constraint", "oid", constraintRow.oid);
+			const definition = text(constraintRow.definition);
+			if (definition === void 0 || definition.trim() === "") {
+				diagnostics.push(createIntrospectionDiagnostic({
+					severity: "warning",
+					code: "unmodeled-object",
+					message: `PostgreSQL domain constraint ${constraintName} has no recoverable definition`,
+					path: [
+						"domains",
+						physicalName,
+						"constraints",
+						constraintName
+					],
+					physicalReference: constraintReference,
+					remediation: "Inspect the opaque domain constraint before using it as migration input."
+				}));
+				opaqueObjects.push(opaqueDomainConstraint(physicalName, constraintName, constraintReference, void 0));
+				return;
+			}
 			return {
 				kind: "check",
 				id: stableId(constraintName),
 				identitySource: "physical-name",
 				physicalName: constraintName,
-				expression: expression(text(constraintRow.definition) ?? "CHECK (true)", "decompiler", constraintReference),
+				expression: expression(definition, "decompiler", constraintReference),
 				deferrable: constraintRow.condeferrable === void 0 ? void 0 : boolean(constraintRow.condeferrable),
 				initially: constraintRow.condeferred === void 0 ? void 0 : boolean(constraintRow.condeferred) ? "deferred" : "immediate",
 				validated: constraintRow.convalidated === void 0 ? void 0 : boolean(constraintRow.convalidated),
 				reference: constraintReference
 			};
-		});
+		}).filter((value) => value !== void 0);
+		const defaultValue = domainDefault(row.default_expression, physicalReference);
 		return {
 			kind: "domain",
 			id: stableId(physicalName),
@@ -699,12 +755,73 @@ function mapDomains(rows, constraintRows, namespace) {
 			physicalName,
 			storage: storage(row.native_type),
 			...row.nullable === void 0 || row.nullable === null ? {} : { nullable: boolean(row.nullable) },
-			...factIfPresent(row.default_expression) === void 0 ? {} : { default: factIfPresent(row.default_expression) },
+			...defaultValue === void 0 ? {} : { default: defaultValue },
 			...domainConstraints.length === 0 ? {} : { constraints: domainConstraints },
 			reference: physicalReference
 		};
 	});
 }
+function opaqueDomainConstraint(domainName, constraintName, physicalReference, definition) {
+	return {
+		kind: "opaque-object",
+		id: stableId(`domain-constraint:${domainName}:${constraintName}`),
+		identitySource: "physical-name",
+		objectKind: "domain-constraint",
+		physicalName: constraintName,
+		data: {
+			domain: domainName,
+			definitionAvailable: definition !== void 0
+		},
+		...definition === void 0 ? {} : { sql: expression(definition, "decompiler", physicalReference) },
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "postgresql",
+			reference: physicalReference
+		}
+	};
+}
+function domainDefault(value, physicalReference) {
+	const textValue = text(value);
+	if (textValue === void 0 || textValue.trim() === "") return;
+	const trimmed = textValue.trim();
+	if (/^NULL$/i.test(trimmed)) return {
+		kind: "literal",
+		value: null
+	};
+	if (/^TRUE$/i.test(trimmed)) return {
+		kind: "literal",
+		value: true
+	};
+	if (/^FALSE$/i.test(trimmed)) return {
+		kind: "literal",
+		value: false
+	};
+	if (/^[+-]?\d+$/.test(trimmed)) {
+		const fact = literalFact(trimmed);
+		if (fact !== void 0) return fact;
+	}
+	if (/^[+-]?\d+\.\d+$/.test(trimmed)) {
+		const fact = literalFact(trimmed);
+		if (fact?.value !== void 0 && typeof fact.value === "number" && canonicalDecimal(trimmed) === canonicalDecimal(String(fact.value))) return fact;
+	}
+	if (trimmed.match(/^'(?:''|[^'])*'$/)) return {
+		kind: "literal",
+		value: trimmed.slice(1, -1).replace(/''/g, "'")
+	};
+	return {
+		kind: "expression",
+		expression: expression(textValue, "catalog", physicalReference)
+	};
+}
+function canonicalDecimal(value) {
+	const match = value.match(/^([+-]?)(\d+)(?:\.(\d+))?$/);
+	if (!match) return;
+	const sign = match[1] === "-" ? "-" : "";
+	const integer = match[2].replace(/^0+(?=\d)/, "");
+	const fraction = (match[3] ?? "").replace(/0+$/, "");
+	return `${sign}${integer}${fraction === "" ? "" : `.${fraction}`}`;
+}
 function collationObject(row, namespace) {
 	const physicalName = text(row.physical_name) ?? `collation_${text(row.oid) ?? "unknown"}`;
 	return {
@@ -836,41 +953,139 @@ function mapRoutines(rows, parameterRows, namespace, diagnostics) {
 function partitionObject(row, namespace, tableByOid, diagnostics) {
 	const physicalName = text(row.physical_name) ?? `partition_${text(row.partition_oid) ?? "unknown"}`;
 	const physicalReference = reference("partition", physicalName, text(row.namespace) ?? namespace, "pg_class", "oid", row.partition_oid);
+	if (!boolean(row.relispartition)) return inheritanceObject(row, namespace, diagnostics);
 	const parent = tableByOid.get(text(row.parent_oid));
-	if (parent === void 0) diagnostics.push(createIntrospectionDiagnostic({
-		severity: "error",
-		code: "unresolved-reference",
-		message: `PostgreSQL partition ${physicalName} has no parent table in the selected schema`,
+	const keyDefinition = text(row.key_definition);
+	const bound = text(row.bound);
+	if (parent === void 0) {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "unresolved-reference",
+			message: `PostgreSQL partition ${physicalName} has no parent table in the selected schema`,
+			path: [
+				"partitions",
+				physicalName,
+				"parent"
+			],
+			physicalReference,
+			remediation: "Select the parent table schema before mapping partitions."
+		}));
+		return deferredCatalogObject("partition", physicalName, physicalReference, [
+			...text(row.parent_oid) === void 0 ? [] : [{
+				name: "parentOid",
+				value: text(row.parent_oid)
+			}],
+			...text(row.key_attributes) === void 0 ? [] : [{
+				name: "keyAttributes",
+				value: text(row.key_attributes)
+			}],
+			...keyDefinition === void 0 ? [] : [{
+				name: "keyDefinition",
+				value: expression(keyDefinition, "decompiler", physicalReference)
+			}],
+			...bound === void 0 ? [] : [{
+				name: "bound",
+				value: expression(bound, "decompiler", physicalReference)
+			}]
+		]);
+	}
+	const keyInfo = partitionKeyInfo(row.key_attributes, parent.columns);
+	const unknownFields = [];
+	if (keyDefinition !== void 0 && (keyInfo.hasExpression || keyInfo.missingPositions.length > 0 || keyInfo.columns.length === 0)) unknownFields.push({
+		name: "keyDefinition",
+		value: expression(keyDefinition, "decompiler", physicalReference)
+	});
+	if (keyInfo.missingPositions.length > 0 || keyInfo.hasExpression && keyDefinition === void 0) {
+		const keyAttributes = text(row.key_attributes);
+		if (keyAttributes !== void 0) unknownFields.push({
+			name: "keyAttributes",
+			value: keyAttributes
+		});
+	}
+	if (keyInfo.hasExpression) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "warning",
+		code: "unsupported-feature",
+		message: `PostgreSQL partition ${physicalName} has an expression key retained as dialect evidence`,
 		path: [
 			"partitions",
 			physicalName,
-			"parent"
+			"keyDefinition"
 		],
 		physicalReference,
-		remediation: "Select the parent table schema before mapping partitions."
+		remediation: "Inspect the retained partition key definition before using it as migration input."
+	}));
+	if (keyInfo.missingPositions.length > 0) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "warning",
+		code: "unresolved-reference",
+		message: `PostgreSQL partition ${physicalName} has unknown key attributes`,
+		path: [
+			"partitions",
+			physicalName,
+			"keyAttributes"
+		],
+		physicalReference
 	}));
-	const parentReference = parent ? {
-		kind: "table",
-		id: parent.id
-	} : {
-		kind: "table",
-		id: stableId(`missing_parent_${text(row.parent_oid) ?? "unknown"}`)
-	};
-	const keyColumns = partitionKeyColumns(row.key_attributes, parent?.columns ?? []);
-	const bound = text(row.bound);
 	return {
 		kind: "partition",
 		id: stableId(physicalName),
 		identitySource: "physical-name",
 		physicalName,
-		parent: parentReference,
+		parent: {
+			kind: "table",
+			id: parent.id
+		},
 		strategy: partitionStrategy(row.partstrat),
-		...keyColumns.length === 0 ? {} : { keyColumns },
+		...keyInfo.hasExpression || keyInfo.missingPositions.length > 0 || keyInfo.columns.length === 0 ? {} : { keyColumns: keyInfo.columns },
 		...bound === void 0 ? {} : { bound: expression(bound, "decompiler", physicalReference) },
 		...bound !== void 0 && /^default$/i.test(bound.trim()) ? { default: true } : {},
+		...unknownFields.length === 0 ? {} : { unknownFields },
 		reference: physicalReference
 	};
 }
+function inheritanceObject(row, namespace, diagnostics) {
+	const physicalName = text(row.physical_name) ?? `inherited_${text(row.partition_oid) ?? "unknown"}`;
+	const physicalReference = reference("opaque-object", physicalName, text(row.namespace) ?? namespace, "pg_inherits", "inhrelid", row.partition_oid);
+	diagnostics.push(createIntrospectionDiagnostic({
+		severity: "warning",
+		code: "unmodeled-object",
+		message: `PostgreSQL ordinary inheritance ${physicalName} was retained as opaque evidence`,
+		path: ["opaqueObjects", physicalName],
+		physicalReference,
+		remediation: "Inspect the inheritance relationship before using it as migration input."
+	}));
+	return {
+		kind: "opaque-object",
+		id: stableId(`inheritance:${physicalName}`),
+		identitySource: "physical-name",
+		objectKind: "ordinary-inheritance",
+		physicalName,
+		data: {
+			...text(row.parent_oid) === void 0 ? {} : { parentOid: text(row.parent_oid) },
+			...text(row.relkind) === void 0 ? {} : { childRelkind: text(row.relkind) },
+			relispartition: false
+		},
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "postgresql",
+			reference: physicalReference
+		}
+	};
+}
+function partitionKeyInfo(value, columns) {
+	const attributes = integerArray(value);
+	const byOrdinal = new Map(columns.map((column) => [column.ordinalPosition, column.physicalName]));
+	const positions = attributes.filter((position) => position > 0);
+	const missingPositions = positions.filter((position) => !byOrdinal.has(position));
+	return {
+		columns: positions.flatMap((position) => {
+			const name = byOrdinal.get(position);
+			return name === void 0 ? [] : [name];
+		}),
+		hasExpression: attributes.some((position) => position === 0),
+		missingPositions
+	};
+}
 function policyObject(row, namespace, tableByOid, diagnostics) {
 	const physicalName = text(row.physical_name) ?? `policy_${text(row.oid) ?? "unknown"}`;
 	const physicalReference = reference("policy", physicalName, text(row.namespace) ?? namespace, "pg_policy", "oid", row.oid);
@@ -994,10 +1209,6 @@ function partitionStrategy(value) {
 		h: "hash"
 	}[text(value)] ?? "unknown";
 }
-function partitionKeyColumns(value, columns) {
-	const byOrdinal = new Map(columns.map((column) => [column.ordinalPosition, column.physicalName]));
-	return integerArray(value).filter((position) => position > 0).map((position) => byOrdinal.get(position) ?? `attnum_${position}`);
-}
 function policyCommand(value) {
 	return {
 		"*": "all",
@@ -1141,6 +1352,7 @@ function column(row, table, namespace, identityOptionValues) {
 function constraint(row, table, columnsByNumber, tableByOid, namespace, diagnostics, indexReferences) {
 	const kind = text(row.contype);
 	const physicalName = text(row.physical_name) ?? `constraint_${text(row.oid) ?? "unknown"}`;
+	const definition = text(row.definition);
 	const columns = integerArray(row.conkey).map((numberValue) => columnsByNumber.get(numberValue) ?? `attnum_${numberValue}`);
 	const common = {
 		id: stableId(physicalName),
@@ -1160,8 +1372,28 @@ function constraint(row, table, columnsByNumber, tableByOid, namespace, diagnost
 	const backing = backingOid ? indexReferences.get(`pg_class:${backingOid}`) : void 0;
 	const backingIndex = backing ? {
 		kind: "index",
-		id: backing.id
+		id: backing.id,
+		owner: {
+			kind: "table",
+			id: table.id
+		}
 	} : void 0;
+	if (kind === "x" || kind === "c" && (definition === void 0 || definition.trim() === "")) {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "warning",
+			code: "unmodeled-object",
+			message: kind === "x" ? `PostgreSQL exclusion constraint ${physicalName} was retained as opaque evidence` : `PostgreSQL check constraint ${physicalName} has no recoverable definition`,
+			path: [
+				"tables",
+				table.physicalName,
+				"constraints",
+				physicalName
+			],
+			physicalReference: reference("opaque-object", physicalName, namespace, "pg_constraint", "oid", row.oid),
+			remediation: "Inspect the opaque constraint before using it as migration input."
+		}));
+		return opaqueConstraint(row, table, namespace, definition);
+	}
 	if (kind === "p") return {
 		kind: "primary-key",
 		...common,
@@ -1178,9 +1410,23 @@ function constraint(row, table, columnsByNumber, tableByOid, namespace, diagnost
 	if (kind === "c") return {
 		kind: "check",
 		...common,
-		expression: sql(text(row.definition) ?? "CHECK (true)", namespace, table, physicalName)
+		expression: sql(definition, namespace, table, physicalName)
 	};
-	if (kind !== "f") return;
+	if (kind !== "f") {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "warning",
+			code: "unmodeled-object",
+			message: `PostgreSQL constraint ${physicalName} (${kind ?? "unknown"}) was retained as opaque evidence`,
+			path: [
+				"tables",
+				table.physicalName,
+				"constraints",
+				physicalName
+			],
+			remediation: "Inspect the opaque constraint before using it as migration input."
+		}));
+		return opaqueConstraint(row, table, namespace, definition);
+	}
 	const targetTable = tableByOid.get(text(row.target_table_oid));
 	if (!targetTable) {
 		diagnostics.push(createIntrospectionDiagnostic({
@@ -1212,7 +1458,32 @@ function constraint(row, table, columnsByNumber, tableByOid, namespace, diagnost
 		match: matchType(row.confmatchtype)
 	};
 }
-function mapIndexes(rows, table, columnsByNumber, namespace) {
+function opaqueConstraint(row, table, namespace, definition) {
+	const physicalName = text(row.physical_name) ?? `constraint_${text(row.oid) ?? "unknown"}`;
+	const physicalReference = reference("opaque-object", physicalName, namespace, "pg_constraint", "oid", row.oid);
+	const data = {
+		table: table.physicalName,
+		constraintType: text(row.contype) ?? "unknown",
+		...text(row.conkey) === void 0 ? {} : { keyAttributes: text(row.conkey) },
+		...text(row.backing_index_oid) === void 0 ? {} : { backingIndexOid: text(row.backing_index_oid) }
+	};
+	return {
+		kind: "opaque-object",
+		id: stableId(`constraint:${table.physicalName}:${physicalName}`),
+		identitySource: "physical-name",
+		objectKind: text(row.contype) === "x" ? "exclusion-constraint" : "constraint",
+		physicalName,
+		data,
+		...definition === void 0 ? {} : { sql: sql(definition, namespace, table, physicalName) },
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "postgresql",
+			reference: physicalReference
+		}
+	};
+}
+function mapIndexes(rows, table, columnsByNumber, namespace, diagnostics, opaqueObjects) {
 	const grouped = /* @__PURE__ */ new Map();
 	for (const row of rows) {
 		const key = text(row.index_oid) ?? text(row.physical_name) ?? "unknown";
@@ -1227,6 +1498,7 @@ function mapIndexes(rows, table, columnsByNumber, namespace) {
 		const keyCount = number(first.indnkeyatts) ?? indexRows.length;
 		const terms = [];
 		const includedColumns = [];
+		let unavailableTerm = false;
 		for (const row of orderedRows) {
 			const position = number(row.position) ?? 0;
 			const attnum = number(row.attnum) ?? 0;
@@ -1235,6 +1507,25 @@ function mapIndexes(rows, table, columnsByNumber, namespace) {
 				if (columnName) includedColumns.push(columnName);
 				continue;
 			}
+			const termDefinition = text(row.term_definition);
+			if (!columnName && (termDefinition === void 0 || termDefinition.trim() === "")) {
+				unavailableTerm = true;
+				diagnostics.push(createIntrospectionDiagnostic({
+					severity: "warning",
+					code: "unmodeled-object",
+					message: `PostgreSQL index ${physicalName} has an expression term with no recoverable definition`,
+					path: [
+						table.physicalName,
+						"indexes",
+						physicalName,
+						"terms",
+						position
+					],
+					physicalReference: reference("index", physicalName, namespace, "pg_class", "oid", first.index_oid),
+					remediation: "Inspect the opaque index record before using it as migration input."
+				}));
+				continue;
+			}
 			terms.push(columnName ? {
 				kind: "column",
 				column: columnName,
@@ -1243,12 +1534,16 @@ function mapIndexes(rows, table, columnsByNumber, namespace) {
 				...text(row.operator_class) === void 0 ? {} : { operatorClass: text(row.operator_class) }
 			} : {
 				kind: "expression",
-				expression: sql(text(row.term_definition) ?? "/* expression unavailable */", namespace, table, physicalName),
+				expression: sql(termDefinition, namespace, table, physicalName),
 				position,
 				...indexTermOptions(row, text(first.method)),
 				...text(row.operator_class) === void 0 ? {} : { operatorClass: text(row.operator_class) }
 			});
 		}
+		if (unavailableTerm) {
+			opaqueObjects.push(opaqueIndex(indexRows, table, namespace));
+			return;
+		}
 		return {
 			kind: "index",
 			id: stableId(physicalName),
@@ -1266,7 +1561,30 @@ function mapIndexes(rows, table, columnsByNumber, namespace) {
 			} : void 0,
 			reference: reference("index", physicalName, namespace, "pg_class", "oid", first.index_oid)
 		};
-	});
+	}).filter((value) => value !== void 0);
+}
+function opaqueIndex(rows, table, namespace) {
+	const first = rows[0];
+	const physicalName = text(first.physical_name) ?? `index_${text(first.index_oid) ?? "unknown"}`;
+	const physicalReference = reference("opaque-object", physicalName, namespace, "pg_class", "oid", first.index_oid);
+	return {
+		kind: "opaque-object",
+		id: stableId(`index:${table.physicalName}:${physicalName}`),
+		identitySource: "physical-name",
+		objectKind: "index",
+		physicalName,
+		data: {
+			table: table.physicalName,
+			reason: "term-definition-unavailable",
+			...text(first.index_oid) === void 0 ? {} : { indexOid: text(first.index_oid) }
+		},
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "postgresql",
+			reference: physicalReference
+		}
+	};
 }
 function mapMetadataRows(rows, namespace, tables, views, sequences, enums, domains, collations, routines, triggers, policies, extensions, deferredObjects, opaqueObjects, indexReferences, relationReferences, diagnostics) {
 	const targets = /* @__PURE__ */ new Map();
@@ -1300,7 +1618,8 @@ function mapMetadataRows(rows, namespace, tables, views, sequences, enums, domai
 	}, opaque.physicalName, opaque.reference);
 	for (const index of indexReferences.values()) if (index.reference?.catalog !== void 0) add("pg_class", index.reference.catalog.value, {
 		kind: "index",
-		id: index.id
+		id: index.id,
+		...index.owner === void 0 ? {} : { owner: index.owner }
 	}, index.physicalName, index.reference);
 	for (const enumObject of enums) if (enumObject.reference?.catalog !== void 0) add("pg_type", enumObject.reference.catalog.value, {
 		kind: "enum",
@@ -1335,7 +1654,11 @@ function mapMetadataRows(rows, namespace, tables, views, sequences, enums, domai
 	for (const table of tables) for (const constraint of table.constraints) if (constraint.reference?.catalog !== void 0) targets.set(metadataKey("pg_constraint", constraint.reference.catalog.value, 0), {
 		object: {
 			kind: "constraint",
-			id: constraint.id
+			id: constraint.id,
+			owner: {
+				kind: "table",
+				id: table.id
+			}
 		},
 		reference: constraint.reference,
 		physicalName: constraint.physicalName ?? constraint.id
@@ -1343,7 +1666,11 @@ function mapMetadataRows(rows, namespace, tables, views, sequences, enums, domai
 	for (const domain of domains) for (const constraint of domain.constraints ?? []) if (constraint.reference?.catalog !== void 0) targets.set(metadataKey("pg_constraint", constraint.reference.catalog.value, 0), {
 		object: {
 			kind: "constraint",
-			id: constraint.id
+			id: constraint.id,
+			owner: {
+				kind: "domain",
+				id: domain.id
+			}
 		},
 		reference: constraint.reference,
 		physicalName: constraint.physicalName ?? constraint.id
@@ -1386,7 +1713,7 @@ function mapMetadataRows(rows, namespace, tables, views, sequences, enums, domai
 		const description = text(row.description);
 		if (description !== void 0) comments.push({
 			kind: "comment",
-			id: stableId(`${target.object.kind}_${target.object.id}_comment`),
+			id: metadataId(target.object, "comment"),
 			object: target.object,
 			text: description,
 			reference: target.reference,
@@ -1399,7 +1726,7 @@ function mapMetadataRows(rows, namespace, tables, views, sequences, enums, domai
 		const owner = text(row.owner);
 		if (owner !== void 0) ownership.push({
 			kind: "ownership",
-			id: stableId(`${target.object.kind}_${target.object.id}_ownership`),
+			id: metadataId(target.object, "ownership"),
 			object: target.object,
 			owner,
 			reference: target.reference,
@@ -1422,7 +1749,11 @@ function addNestedColumns(targets, relation, owner, namespace) {
 	for (const column of owner.columns) targets.set(metadataKey(relation, tableOid, column.ordinalPosition), {
 		object: {
 			kind: "column",
-			id: column.id
+			id: column.id,
+			owner: {
+				kind: owner.kind,
+				id: owner.id
+			}
 		},
 		reference: column.reference ?? reference("column", column.physicalName, namespace, "pg_attribute", "attrelid", tableOid),
 		physicalName: column.physicalName
@@ -1431,6 +1762,10 @@ function addNestedColumns(targets, relation, owner, namespace) {
 function metadataKey(relation, oid, subid) {
 	return `${relation}:${text(oid) ?? "unknown"}:${number(subid) ?? 0}`;
 }
+function metadataId(object, suffix) {
+	const owner = object.owner;
+	return stableId(`${owner === void 0 ? "" : `${owner.kind}_${owner.id}_`}${object.kind}_${object.id}_${suffix}`);
+}
 function indexTermOptions(row, method) {
 	const option = number(row.indoption);
 	if (method !== "btree" || option === void 0) return {};
@@ -1530,9 +1865,9 @@ function booleanOption(options, name) {
 }
 function integerArray(value) {
 	if (Array.isArray(value)) return value.map((item) => number(item) ?? 0);
-	const parsed = text(value)?.replace(/[{}]/g, "").trim();
+	const parsed = text(value)?.replace(/^\[[^\]]+\]=/, "").replace(/[{}]/g, "").trim();
 	if (!parsed) return [];
-	return parsed.split(",").map((item) => number(item.trim()) ?? 0);
+	return parsed.split(/[\s,]+/).map((item) => number(item.trim())).filter((item) => item !== void 0);
 }
 function referentialAction(value) {
 	return {
@@ -1551,4 +1886,4 @@ function matchType(value) {
 	}[text(value)];
 }
 //#endregion
-export { postgresCollationsQuery, postgresColumnsQuery, postgresConstraintsQuery, postgresDomainConstraintsQuery, postgresDomainsQuery, postgresEnumsQuery, postgresExtensionsQuery, postgresIdentitiesQuery, postgresIndexesQuery, postgresMetadataQuery, postgresPartitionsQuery, postgresPoliciesQuery, postgresRelationsQuery, postgresRoutineParametersQuery, postgresRoutinesQuery, postgresSequencesQuery, postgresServerQuery, postgresTriggersQuery, postgresViewsQuery, readCatalog };
+export { postgresCollationsQuery, postgresColumnsQuery, postgresConstraintsQuery, postgresConstraintsQueryWithoutNullsNotDistinct, postgresDomainConstraintsQuery, postgresDomainsQuery, postgresEnumsQuery, postgresExtensionsQuery, postgresIdentitiesQuery, postgresIndexesQuery, postgresMetadataQuery, postgresPartitionsQuery, postgresPoliciesQuery, postgresRelationsQuery, postgresRoutineParametersQuery, postgresRoutinesQuery, postgresSequencesQuery, postgresServerQuery, postgresTriggersQuery, postgresViewsQuery, readCatalog };