@prisma-next/target-postgres 0.9.0 → 0.10.0-dev.10

package/src/core/migrations/issue-planner.ts

@@ -22,6 +22,7 @@ import type {
   PostgresEnumStorageEntry,
   SqlStorage,
   StorageColumn,
+  StorageTable,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
@@ -36,6 +37,7 @@ import {
   AlterColumnTypeCall,
   CreateEnumTypeCall,
   CreateIndexCall,
+  CreateSchemaCall,
   CreateTableCall,
   DropColumnCall,
   DropConstraintCall,
@@ -53,17 +55,33 @@ import { buildExpectedFormatType } from './planner-sql-checks';
 import {
   type CallMigrationStrategy,
   postgresPlannerStrategies,
+  resolveDdlSchemaForNamespace,
+  resolveNamespaceIdForIssue,
   type StrategyContext,
+  tableAt,
 } from './planner-strategies';
 
 export type { CallMigrationStrategy, StrategyContext };
 
+function locateNamespaceTypeInStorage(storage: SqlStorage, typeName: string): unknown {
+  for (const ns of Object.values(storage.namespaces)) {
+    if (!('types' in ns) || ns.types == null) continue;
+    const entry = (ns.types as Record<string, unknown>)[typeName];
+    if (entry !== undefined) return entry;
+  }
+  return undefined;
+}
+
 // ============================================================================
 // Issue kind ordering (dependency order)
 // ============================================================================
 
 const ISSUE_KIND_ORDER: Record<string, number> = {
-  // Types first
+  // Schemas first — the database container must exist before any DDL
+  // that targets it can run.
+  missing_schema: 1,
+
+  // Types next
   type_missing: 2,
   type_values_mismatch: 3,
   enum_values_changed: 3,
@@ -183,22 +201,45 @@ function mapIssueToCall(
   ctx: StrategyContext,
 ): Result<readonly PostgresOpFactoryCall[], SqlPlannerConflict> {
   const { schemaName, codecHooks, storageTypes } = ctx;
+  // Per-table effective schema. `extra_table` issues intentionally
+  // omit `namespaceId` — the live DB carries a table that
+  // is not claimed by any contract namespace, so there is no contract
+  // coordinate to project from. Those issues fall back to the planner's
+  // global `ctx.schemaName`; every other issue dispatches through the
+  // resolved namespace's polymorphic `ddlSchemaName`.
+  const tableSchema = (issue: SchemaIssue): string => {
+    if (issue.kind === 'extra_table') return schemaName;
+    if (!('table' in issue) || !issue.table) return schemaName;
+    return resolveDdlSchemaForNamespace(ctx, resolveNamespaceIdForIssue(issue));
+  };
 
   switch (issue.kind) {
+    case 'missing_schema': {
+      const namespaceId = issue.namespaceId;
+      if (!namespaceId)
+        return notOk(
+          issueConflict('unsupportedOperation', 'Missing schema issue has no namespaceId'),
+        );
+      const ddlSchemaName = resolveDdlSchemaForNamespace(ctx, namespaceId);
+      return ok([new CreateSchemaCall(ddlSchemaName)]);
+    }
+
     case 'missing_table': {
       if (!issue.table)
         return notOk(
           issueConflict('unsupportedOperation', 'Missing table issue has no table name'),
         );
-      const contractTable = ctx.toContract.storage.tables[issue.table];
+      const namespaceId = resolveNamespaceIdForIssue(issue);
+      const contractTable = tableAt(ctx.toContract.storage, namespaceId, issue.table);
       if (!contractTable) {
         return notOk(
           issueConflict(
             'unsupportedOperation',
-            `Table "${issue.table}" reported missing but not found in destination contract`,
+            `Table "${issue.table}" in namespace "${namespaceId}" reported missing but not found in destination contract`,
           ),
         );
       }
+      const schemaForTable = tableSchema(issue);
       const columns: ColumnSpec[] = Object.entries(contractTable.columns).map(([name, column]) =>
         toColumnSpec(name, column, codecHooks, storageTypes),
       );
@@ -206,7 +247,7 @@ function mapIssueToCall(
         ? { columns: contractTable.primaryKey.columns }
         : undefined;
       const calls: PostgresOpFactoryCall[] = [
-        new CreateTableCall(schemaName, issue.table, columns, primaryKey),
+        new CreateTableCall(schemaForTable, issue.table, columns, primaryKey),
       ];
       for (const index of contractTable.indexes) {
         const indexName = index.name ?? `${issue.table}_${index.columns.join('_')}_idx`;
@@ -214,7 +255,7 @@ function mapIssueToCall(
         if (index.type !== undefined) extras.type = index.type;
         if (index.options !== undefined) extras.options = index.options;
         calls.push(
-          new CreateIndexCall(schemaName, issue.table, indexName, [...index.columns], extras),
+          new CreateIndexCall(schemaForTable, issue.table, indexName, [...index.columns], extras),
         );
       }
       const explicitIndexColumnSets = new Set(
@@ -222,24 +263,32 @@ function mapIssueToCall(
       );
       for (const fk of contractTable.foreignKeys) {
         if (fk.constraint) {
-          const fkName = fk.name ?? `${issue.table}_${fk.columns.join('_')}_fkey`;
+          const fkName = fk.name ?? `${issue.table}_${fk.source.columns.join('_')}_fkey`;
           const fkSpec: ForeignKeySpec = {
             name: fkName,
-            columns: fk.columns,
-            references: { table: fk.references.table, columns: fk.references.columns },
+            columns: fk.source.columns,
+            references: {
+              schema: fk.target.namespaceId,
+              table: fk.target.tableName,
+              columns: fk.target.columns,
+            },
             ...(fk.onDelete !== undefined && { onDelete: fk.onDelete }),
             ...(fk.onUpdate !== undefined && { onUpdate: fk.onUpdate }),
           };
-          calls.push(new AddForeignKeyCall(schemaName, issue.table, fkSpec));
+          calls.push(new AddForeignKeyCall(schemaForTable, issue.table, fkSpec));
         }
-        if (fk.index && !explicitIndexColumnSets.has(fk.columns.join(','))) {
-          const indexName = `${issue.table}_${fk.columns.join('_')}_idx`;
-          calls.push(new CreateIndexCall(schemaName, issue.table, indexName, [...fk.columns]));
+        if (fk.index && !explicitIndexColumnSets.has(fk.source.columns.join(','))) {
+          const indexName = `${issue.table}_${fk.source.columns.join('_')}_idx`;
+          calls.push(
+            new CreateIndexCall(schemaForTable, issue.table, indexName, [...fk.source.columns]),
+          );
         }
       }
       for (const unique of contractTable.uniques) {
         const constraintName = unique.name ?? `${issue.table}_${unique.columns.join('_')}_key`;
-        calls.push(new AddUniqueCall(schemaName, issue.table, constraintName, [...unique.columns]));
+        calls.push(
+          new AddUniqueCall(schemaForTable, issue.table, constraintName, [...unique.columns]),
+        );
       }
       return ok(calls);
     }
@@ -250,7 +299,10 @@ function mapIssueToCall(
           issueConflict('unsupportedOperation', 'Missing column issue has no table/column name'),
         );
       {
-        const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+        const namespaceId = resolveNamespaceIdForIssue(issue);
+        const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[
+          issue.column
+        ];
         if (!column)
           return notOk(
             issueConflict(
@@ -260,7 +312,7 @@ function mapIssueToCall(
           );
         return ok([
           new AddColumnCall(
-            schemaName,
+            tableSchema(issue),
             issue.table,
             toColumnSpec(issue.column, column, codecHooks, storageTypes),
           ),
@@ -273,7 +325,10 @@ function mapIssueToCall(
           issueConflict('unsupportedOperation', 'Default missing issue has no table/column name'),
         );
       {
-        const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+        const namespaceId = resolveNamespaceIdForIssue(issue);
+        const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[
+          issue.column
+        ];
         if (!column?.default) {
           return notOk(
             issueConflict(
@@ -284,27 +339,27 @@ function mapIssueToCall(
         }
         const defaultSql = buildColumnDefaultSql(column.default, column);
         if (!defaultSql) return ok([]);
-        return ok([new SetDefaultCall(schemaName, issue.table, issue.column, defaultSql)]);
+        return ok([new SetDefaultCall(tableSchema(issue), issue.table, issue.column, defaultSql)]);
       }
 
     case 'extra_table':
       if (!issue.table)
         return notOk(issueConflict('unsupportedOperation', 'Extra table issue has no table name'));
-      return ok([new DropTableCall(schemaName, issue.table)]);
+      return ok([new DropTableCall(tableSchema(issue), issue.table)]);
 
     case 'extra_column':
       if (!issue.table || !issue.column)
         return notOk(
           issueConflict('unsupportedOperation', 'Extra column issue has no table/column name'),
         );
-      return ok([new DropColumnCall(schemaName, issue.table, issue.column)]);
+      return ok([new DropColumnCall(tableSchema(issue), issue.table, issue.column)]);
 
     case 'extra_index':
       if (!issue.table || !issue.indexOrConstraint)
         return notOk(
           issueConflict('unsupportedOperation', 'Extra index issue has no table/index name'),
         );
-      return ok([new DropIndexCall(schemaName, issue.table, issue.indexOrConstraint)]);
+      return ok([new DropIndexCall(tableSchema(issue), issue.table, issue.indexOrConstraint)]);
 
     case 'extra_unique_constraint':
     case 'extra_foreign_key':
@@ -336,7 +391,12 @@ function mapIssueToCall(
         extra_primary_key: 'primaryKey' as const,
       };
       return ok([
-        new DropConstraintCall(schemaName, issue.table, constraintName, kindMap[issue.kind]),
+        new DropConstraintCall(
+          tableSchema(issue),
+          issue.table,
+          constraintName,
+          kindMap[issue.kind],
+        ),
       ]);
     }
 
@@ -345,14 +405,17 @@ function mapIssueToCall(
         return notOk(
           issueConflict('unsupportedOperation', 'Extra default issue has no table/column name'),
         );
-      return ok([new DropDefaultCall(schemaName, issue.table, issue.column)]);
+      return ok([new DropDefaultCall(tableSchema(issue), issue.table, issue.column)]);
 
     case 'nullability_mismatch': {
       if (!issue.table || !issue.column)
         return notOk(
           issueConflict('nullabilityConflict', 'Nullability mismatch has no table/column name'),
         );
-      const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+      const namespaceId = resolveNamespaceIdForIssue(issue);
+      const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[
+        issue.column
+      ];
       if (!column)
         return notOk(
           issueConflict(
@@ -360,10 +423,11 @@ function mapIssueToCall(
             `Column "${issue.table}"."${issue.column}" not found in destination contract`,
           ),
         );
+      const schemaForTable = tableSchema(issue);
       return ok(
         column.nullable
-          ? [new DropNotNullCall(schemaName, issue.table, issue.column)]
-          : [new SetNotNullCall(schemaName, issue.table, issue.column)],
+          ? [new DropNotNullCall(schemaForTable, issue.table, issue.column)]
+          : [new SetNotNullCall(schemaForTable, issue.table, issue.column)],
       );
     }
 
@@ -371,7 +435,10 @@ function mapIssueToCall(
       if (!issue.table || !issue.column)
         return notOk(issueConflict('typeMismatch', 'Type mismatch has no table/column name'));
       {
-        const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+        const namespaceId = resolveNamespaceIdForIssue(issue);
+        const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[
+          issue.column
+        ];
         if (!column)
           return notOk(
             issueConflict(
@@ -387,7 +454,7 @@ function mapIssueToCall(
         const qualifiedTargetType = buildColumnTypeSql(column, hooksMap, typesMap, false);
         const formatTypeExpected = buildExpectedFormatType(column, hooksMap, typesMap);
         return ok([
-          new AlterColumnTypeCall(schemaName, issue.table, issue.column, {
+          new AlterColumnTypeCall(tableSchema(issue), issue.table, issue.column, {
             qualifiedTargetType,
             formatTypeExpected,
             rawTargetTypeForLabel: qualifiedTargetType,
@@ -401,12 +468,15 @@ function mapIssueToCall(
           issueConflict('unsupportedOperation', 'Default mismatch has no table/column name'),
         );
       {
-        const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+        const namespaceId = resolveNamespaceIdForIssue(issue);
+        const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[
+          issue.column
+        ];
         if (!column?.default) return ok([]);
         const defaultSql = buildColumnDefaultSql(column.default, column);
         if (!defaultSql) return ok([]);
         return ok([
-          new SetDefaultCall(schemaName, issue.table, issue.column, defaultSql, 'widening'),
+          new SetDefaultCall(tableSchema(issue), issue.table, issue.column, defaultSql, 'widening'),
         ]);
       }
 
@@ -414,13 +484,16 @@ function mapIssueToCall(
       if (!issue.table)
         return notOk(issueConflict('indexIncompatible', 'Primary key issue has no table name'));
       if (isMissing(issue)) {
-        const pk = ctx.toContract.storage.tables[issue.table]?.primaryKey;
+        const namespaceId = resolveNamespaceIdForIssue(issue);
+        const pk = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.primaryKey;
         if (!pk)
           return notOk(
             issueConflict('indexIncompatible', `No primary key in contract for "${issue.table}"`),
           );
         const constraintName = pk.name ?? `${issue.table}_pkey`;
-        return ok([new AddPrimaryKeyCall(schemaName, issue.table, constraintName, pk.columns)]);
+        return ok([
+          new AddPrimaryKeyCall(tableSchema(issue), issue.table, constraintName, pk.columns),
+        ]);
       }
       return notOk(
         issueConflict(
@@ -438,7 +511,7 @@ function mapIssueToCall(
       if (isMissing(issue) && issue.expected) {
         const columns = issue.expected.split(', ');
         const constraintName = `${issue.table}_${columns.join('_')}_key`;
-        return ok([new AddUniqueCall(schemaName, issue.table, constraintName, columns)]);
+        return ok([new AddUniqueCall(tableSchema(issue), issue.table, constraintName, columns)]);
       }
       return notOk(
         issueConflict(
@@ -452,15 +525,22 @@ function mapIssueToCall(
       if (!issue.table)
         return notOk(issueConflict('indexIncompatible', 'Index issue has no table name'));
       if (isMissing(issue) && issue.expected) {
+        const namespaceId = resolveNamespaceIdForIssue(issue);
         const columns = issue.expected.split(', ');
-        const contractIndex = ctx.toContract.storage.tables[issue.table]?.indexes.find((idx) =>
+        const contractIndex = tableAt(
+          ctx.toContract.storage,
+          namespaceId,
+          issue.table,
+        )?.indexes.find((idx: StorageTable['indexes'][number]) =>
           arraysEqual(idx.columns, columns),
         );
         const indexName = contractIndex?.name ?? `${issue.table}_${columns.join('_')}_idx`;
         const extras: { type?: string; options?: Record<string, unknown> } = {};
         if (contractIndex?.type !== undefined) extras.type = contractIndex.type;
         if (contractIndex?.options !== undefined) extras.options = contractIndex.options;
-        return ok([new CreateIndexCall(schemaName, issue.table, indexName, columns, extras)]);
+        return ok([
+          new CreateIndexCall(tableSchema(issue), issue.table, indexName, columns, extras),
+        ]);
       }
       return notOk(
         issueConflict(
@@ -476,20 +556,25 @@ function mapIssueToCall(
       if (isMissing(issue) && issue.expected) {
         const arrowIdx = issue.expected.indexOf(' -> ');
         if (arrowIdx >= 0) {
+          const namespaceId = resolveNamespaceIdForIssue(issue);
           const columns = issue.expected.slice(0, arrowIdx).split(', ');
           const fkName = `${issue.table}_${columns.join('_')}_fkey`;
-          const fk = ctx.toContract.storage.tables[issue.table]?.foreignKeys.find(
-            (k) => k.columns.join(', ') === columns.join(', '),
+          const fk = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.foreignKeys.find(
+            (k) => k.source.columns.join(', ') === columns.join(', '),
           );
           if (fk) {
             const fkSpec: ForeignKeySpec = {
               name: fkName,
-              columns: fk.columns,
-              references: { table: fk.references.table, columns: fk.references.columns },
+              columns: fk.source.columns,
+              references: {
+                schema: fk.target.namespaceId,
+                table: fk.target.tableName,
+                columns: fk.target.columns,
+              },
               ...(fk.onDelete !== undefined && { onDelete: fk.onDelete }),
               ...(fk.onUpdate !== undefined && { onUpdate: fk.onUpdate }),
             };
-            return ok([new AddForeignKeyCall(schemaName, issue.table, fkSpec)]);
+            return ok([new AddForeignKeyCall(tableSchema(issue), issue.table, fkSpec)]);
           }
           return notOk(
             issueConflict(
@@ -511,7 +596,11 @@ function mapIssueToCall(
     case 'type_missing': {
       if (!issue.typeName)
         return notOk(issueConflict('unsupportedOperation', 'Type missing issue has no typeName'));
-      const typeInstance = ctx.toContract.storage.types?.[issue.typeName];
+      // Enum types live in namespace.types; codec aliases live in storage.types.
+      // Check both so the planner handles whichever slot the type is in.
+      const typeInstance: unknown =
+        ctx.toContract.storage.types?.[issue.typeName] ??
+        locateNamespaceTypeInStorage(ctx.toContract.storage, issue.typeName);
       if (!typeInstance) {
         return notOk(
           issueConflict(
@@ -530,10 +619,11 @@ function mapIssueToCall(
           ),
         ]);
       }
+      const codecInstance = typeInstance as StorageTypeInstance;
       return notOk(
         issueConflict(
           'unsupportedOperation',
-          `Type "${issue.typeName}" uses codec "${typeInstance.codecId}" — only enum types are supported`,
+          `Type "${issue.typeName}" uses codec "${codecInstance.codecId}" — only enum types are supported`,
         ),
       );
     }

package/src/core/migrations/operations/constraints.ts

@@ -15,7 +15,7 @@ function renderForeignKeySql(schemaName: string, tableName: string, fk: ForeignK
   let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
 ADD CONSTRAINT ${quoteIdentifier(fk.name)}
 FOREIGN KEY (${fk.columns.map(quoteIdentifier).join(', ')})
-REFERENCES ${qualifyTableName(schemaName, fk.references.table)} (${fk.references.columns
+REFERENCES ${qualifyTableName(fk.references.schema, fk.references.table)} (${fk.references.columns
     .map(quoteIdentifier)
     .join(', ')})`;
 

package/src/core/migrations/operations/shared.ts

@@ -26,13 +26,15 @@ export interface ColumnSpec {
 }
 
 /**
- * Literal-args shape for a foreign key definition. The referenced table is
- * assumed to live in the same schema as the constrained table.
+ * Literal-args shape for a foreign key definition. `references.schema`
+ * carries the target table's namespace (schema) coordinate so the rendered
+ * DDL qualifies the REFERENCES clause correctly for cross-schema FKs.
  */
 export interface ForeignKeySpec {
   readonly name: string;
   readonly columns: readonly string[];
   readonly references: {
+    readonly schema: string;
     readonly table: string;
     readonly columns: readonly string[];
   };

package/src/core/migrations/planner-ddl-builders.ts

@@ -233,8 +233,8 @@ export function buildForeignKeySql(
 ): string {
   let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
 ADD CONSTRAINT ${quoteIdentifier(fkName)}
-FOREIGN KEY (${foreignKey.columns.map(quoteIdentifier).join(', ')})
-REFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${foreignKey.references.columns
+FOREIGN KEY (${foreignKey.source.columns.map(quoteIdentifier).join(', ')})
+REFERENCES ${qualifyTableName(schemaName, foreignKey.target.tableName)} (${foreignKey.target.columns
     .map(quoteIdentifier)
     .join(', ')})`;
 

package/src/core/migrations/planner-schema-lookup.ts

@@ -1,3 +1,4 @@
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { ForeignKey } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 
@@ -26,11 +27,21 @@ function buildSchemaTableLookup(table: SqlSchemaIR['tables'][string]): SchemaTab
   const uniqueIndexKeys = new Set(
     table.indexes.filter((i) => i.unique).map((i) => i.columns.join(',')),
   );
-  const fkKeys = new Set(
-    table.foreignKeys.map(
-      (fk) => `${fk.columns.join(',')}|${fk.referencedTable}|${fk.referencedColumns.join(',')}`,
-    ),
-  );
+  const fkKeys = new Set<string>();
+  for (const fk of table.foreignKeys) {
+    // Keys are JSON-encoded tuples so identifiers containing any character
+    // (including the column-list comma or pipe characters) cannot collide
+    // across structurally-distinct FKs. Unqualified keys are 3-tuples
+    // (cols, table, refCols); qualified keys are 4-tuples
+    // (cols, schema, table, refCols) — the arity difference makes the two
+    // key shapes fundamentally non-collidable.
+    fkKeys.add(JSON.stringify([fk.columns, fk.referencedTable, fk.referencedColumns]));
+    if (fk.referencedSchema !== undefined) {
+      fkKeys.add(
+        JSON.stringify([fk.columns, fk.referencedSchema, fk.referencedTable, fk.referencedColumns]),
+      );
+    }
+  }
   return { uniqueKeys, indexKeys, uniqueIndexKeys, fkKeys };
 }
 
@@ -48,7 +59,20 @@ export function hasIndex(lookup: SchemaTableLookup, columns: readonly string[]):
 }
 
 export function hasForeignKey(lookup: SchemaTableLookup, fk: ForeignKey): boolean {
+  // Mirror the encoding produced by buildSchemaTableLookup exactly:
+  // unqualified 3-tuple for unbound-namespace FKs, qualified 4-tuple for
+  // bound-namespace FKs.
+  if (fk.target.namespaceId === UNBOUND_NAMESPACE_ID) {
+    return lookup.fkKeys.has(
+      JSON.stringify([fk.source.columns, fk.target.tableName, fk.target.columns]),
+    );
+  }
   return lookup.fkKeys.has(
-    `${fk.columns.join(',')}|${fk.references.table}|${fk.references.columns.join(',')}`,
+    JSON.stringify([
+      fk.source.columns,
+      fk.target.namespaceId,
+      fk.target.tableName,
+      fk.target.columns,
+    ]),
   );
 }

package/src/core/migrations/planner-sql-checks.ts

@@ -4,16 +4,27 @@ import type {
   StorageColumn,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
+import { postgresCreateNamespace } from '../postgres-schema';
 import { escapeLiteral, quoteIdentifier } from '../sql-utils';
 import { resolveColumnTypeMetadata } from './planner-type-resolution';
 
+/**
+ * String-keyed entry points the migration ops use to render
+ * schema-qualified DDL and catalog checks. The `schema` argument is
+ * interpreted as a namespace coordinate: the framework `__unbound__`
+ * sentinel resolves to the late-bound `PostgresUnboundSchema` singleton
+ * (which elides the qualifier so `search_path` decides at runtime); any
+ * other id materialises a `PostgresSchema(id)` whose qualifier is the
+ * named schema. Helpers route through these `Namespace` concretions so
+ * the unbound branch lives in the polymorphic override, not the call
+ * site.
+ */
 export function qualifyTableName(schema: string, table: string): string {
-  return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
+  return postgresCreateNamespace({ id: schema }).qualifyTable(table);
 }
 
 export function toRegclassLiteral(schema: string, name: string): string {
-  const regclass = `${quoteIdentifier(schema)}.${quoteIdentifier(name)}`;
-  return `'${escapeLiteral(regclass)}'`;
+  return postgresCreateNamespace({ id: schema }).regclassLiteral(name);
 }
 
 /**
@@ -32,15 +43,16 @@ export function constraintExistsCheck({
   table?: string;
   exists?: boolean;
 }): string {
+  const namespace = postgresCreateNamespace({ id: schema });
   const existsClause = exists ? 'EXISTS' : 'NOT EXISTS';
   const tableFilter = table
-    ? `AND c.conrelid = to_regclass(${toRegclassLiteral(schema, table)})`
+    ? `AND c.conrelid = to_regclass(${namespace.regclassLiteral(table)})`
     : '';
   return `SELECT ${existsClause} (
   SELECT 1 FROM pg_constraint c
   JOIN pg_namespace n ON c.connamespace = n.oid
   WHERE c.conname = '${escapeLiteral(constraintName)}'
-  AND n.nspname = '${escapeLiteral(schema)}'
+  AND n.nspname = ${namespace.schemaSqlExpression()}
   ${tableFilter}
 )`;
 }
@@ -56,11 +68,12 @@ export function columnExistsCheck({
   column: string;
   exists?: boolean;
 }): string {
+  const namespace = postgresCreateNamespace({ id: schema });
   const existsClause = exists ? '' : 'NOT ';
   return `SELECT ${existsClause}EXISTS (
   SELECT 1
   FROM information_schema.columns
-  WHERE table_schema = '${escapeLiteral(schema)}'
+  WHERE table_schema = ${namespace.schemaSqlExpression()}
     AND table_name = '${escapeLiteral(table)}'
     AND column_name = '${escapeLiteral(column)}'
 )`;
@@ -77,11 +90,12 @@ export function columnNullabilityCheck({
   column: string;
   nullable: boolean;
 }): string {
+  const namespace = postgresCreateNamespace({ id: schema });
   const expected = nullable ? 'YES' : 'NO';
   return `SELECT EXISTS (
   SELECT 1
   FROM information_schema.columns
-  WHERE table_schema = '${escapeLiteral(schema)}'
+  WHERE table_schema = ${namespace.schemaSqlExpression()}
     AND table_name = '${escapeLiteral(table)}'
     AND column_name = '${escapeLiteral(column)}'
     AND is_nullable = '${expected}'
@@ -97,10 +111,11 @@ export function columnHasNoDefaultCheck(opts: {
   table: string;
   column: string;
 }): string {
+  const namespace = postgresCreateNamespace({ id: opts.schema });
   return `SELECT NOT EXISTS (
   SELECT 1
   FROM information_schema.columns
-  WHERE table_schema = '${escapeLiteral(opts.schema)}'
+  WHERE table_schema = ${namespace.schemaSqlExpression()}
     AND table_name = '${escapeLiteral(opts.table)}'
     AND column_name = '${escapeLiteral(opts.column)}'
     AND column_default IS NOT NULL
@@ -267,12 +282,13 @@ export function columnTypeCheck({
   column: string;
   expectedType: string;
 }): string {
+  const namespace = postgresCreateNamespace({ id: schema });
   return `SELECT EXISTS (
   SELECT 1
   FROM pg_attribute a
   JOIN pg_class c ON c.oid = a.attrelid
   JOIN pg_namespace n ON n.oid = c.relnamespace
-  WHERE n.nspname = '${escapeLiteral(schema)}'
+  WHERE n.nspname = ${namespace.schemaSqlExpression()}
     AND c.relname = '${escapeLiteral(table)}'
     AND a.attname = '${escapeLiteral(column)}'
     AND format_type(a.atttypid, a.atttypmod) = '${escapeLiteral(expectedType)}'
@@ -291,11 +307,12 @@ export function columnDefaultExistsCheck({
   column: string;
   exists?: boolean;
 }): string {
+  const namespace = postgresCreateNamespace({ id: schema });
   const nullCheck = exists ? 'IS NOT NULL' : 'IS NULL';
   return `SELECT EXISTS (
   SELECT 1
   FROM information_schema.columns
-  WHERE table_schema = '${escapeLiteral(schema)}'
+  WHERE table_schema = ${namespace.schemaSqlExpression()}
     AND table_name = '${escapeLiteral(table)}'
     AND column_name = '${escapeLiteral(column)}'
     AND column_default ${nullCheck}
@@ -308,6 +325,7 @@ export function tableHasPrimaryKeyCheck(
   exists: boolean,
   constraintName?: string,
 ): string {
+  const namespace = postgresCreateNamespace({ id: schema });
   const comparison = exists ? '' : 'NOT ';
   const constraintFilter = constraintName
     ? `AND c2.relname = '${escapeLiteral(constraintName)}'`
@@ -318,7 +336,7 @@ export function tableHasPrimaryKeyCheck(
   JOIN pg_class c ON c.oid = i.indrelid
   JOIN pg_namespace n ON n.oid = c.relnamespace
   LEFT JOIN pg_class c2 ON c2.oid = i.indexrelid
-  WHERE n.nspname = '${escapeLiteral(schema)}'
+  WHERE n.nspname = ${namespace.schemaSqlExpression()}
     AND c.relname = '${escapeLiteral(table)}'
     AND i.indisprimary
     ${constraintFilter}