@pgsql/transform 18.15.2 → 18.16.0

package/esm/index.js

@@ -10,4 +10,4 @@ export { createRoleResult, createRoleVisitor, transformRoles, } from './role-tra
 export { captureAstsFromSql, captureTransformAsts, firstDifference, normalizeParseTree, validateRoundTrip, } from './round-trip';
 export { CLEAN_TREE_VOLATILE_KEYS, cleanTree, normalizeTree, trimDefElemBody, } from './round-trip-core';
 export { SchemaRouter } from './router';
-export { createPlpgsqlVisitor, createSqlVisitor, escapeRegexp, extractPgpmHeader, shouldTransformSchema, transformComments, transformJsonStringValues, transformNameList, transformPlpgsqlTypeAst, transformPlpgsqlTypeString, transformRelation, transformSchemaName, transformSql, transformSqlStatement, transformVerifyCalls, validateNoUntransformedSchemas, walkPlpgsqlForSchemas, } from './transform';
+export { createPlpgsqlVisitor, createSqlVisitor, escapeRegexp, extractPgpmHeader, identityCastNamespace, shouldTransformSchema, transformComments, transformIdentityCastLiteral, transformJsonStringValues, transformNameList, transformPlpgsqlTypeAst, transformPlpgsqlTypeString, transformRelation, transformSchemaName, transformSql, transformSqlStatement, transformVerifyCalls, validateNoUntransformedSchemas, walkPlpgsqlForSchemas, } from './transform';

package/esm/transform.js

@@ -197,7 +197,9 @@ export function transformSchemaRefsInString(str, schemaMapping, result) {
     // References embedded in opaque strings carry no object identity, so only
     // whole-schema (schema-level default) routes can be applied here.
     for (const [oldSchema, newSchema] of schemaLevelMap(schemaMapping)) {
-        const pattern = new RegExp(`(?<![\\w-])("?)${escapeRegexp(oldSchema)}\\1(?=\\.)`, 'g');
+        if (!out.includes(oldSchema))
+            continue;
+        const pattern = cachedRegExp(`(?<![\\w-])("?)${cachedEscapeRegexp(oldSchema)}\\1(?=\\.)`, 'g');
         const before = out;
         out = out.replace(pattern, `$1${newSchema}$1`);
         if (out !== before) {
@@ -207,6 +209,98 @@ export function transformSchemaRefsInString(str, schemaMapping, result) {
     }
     return out;
 }
+/**
+ * Cast types whose string operand is an object reference rather than opaque
+ * text. `'sch.tbl'::regclass` is a relation the parser resolves, and the cast
+ * names the namespace it resolves in — so the reference can be routed from the
+ * cast, semantically, instead of pattern-matched. This reaches what the string
+ * passes cannot: a bare `'sch'::regnamespace` has no dot to match on.
+ */
+const IDENTITY_CAST_NAMESPACES = {
+    regclass: 'relation',
+    regcollation: 'unknown',
+    regconfig: 'unknown',
+    regdictionary: 'unknown',
+    regnamespace: 'schema',
+    regoper: 'unknown',
+    regoperator: 'unknown',
+    regproc: 'function',
+    regprocedure: 'function',
+    regtype: 'type'
+};
+/**
+ * The namespace a cast resolves its operand in, or `undefined` when the target
+ * type is not an object-identity type.
+ */
+export function identityCastNamespace(typeName) {
+    const names = typeName?.names;
+    if (!Array.isArray(names) || names.length === 0)
+        return undefined;
+    // Only `pg_catalog`-qualified (or unqualified) reg* types are the built-ins.
+    if (names.length > 1 && names[0]?.String?.sval !== 'pg_catalog')
+        return undefined;
+    const typeIdent = names[names.length - 1]?.String?.sval;
+    if (typeof typeIdent !== 'string')
+        return undefined;
+    return IDENTITY_CAST_NAMESPACES[typeIdent.toLowerCase()];
+}
+const IDENTITY_TOKEN = String.raw `(?:"(?:[^"]|"")*"|[^\s".,()[\]]+)`;
+const BARE_IDENTITY_RE = new RegExp(`^\\s*(${IDENTITY_TOKEN})\\s*$`);
+const QUALIFIED_IDENTITY_RE = new RegExp(`^\\s*(${IDENTITY_TOKEN})\\.([\\s\\S]+)$`);
+function unquoteIdentifier(token) {
+    if (token.length > 1 && token.startsWith('"') && token.endsWith('"')) {
+        return token.slice(1, -1).replace(/""/g, '"');
+    }
+    return token;
+}
+/**
+ * Route the object reference carried in the string operand of an identity
+ * cast. `ns` comes from the cast's target type.
+ *
+ * Unqualified operands (`'tbl'::regclass`) name no schema — they resolve
+ * through `search_path` — so they are returned unchanged.
+ */
+export function transformIdentityCastLiteral(sval, ns, schemaMapping, result) {
+    const router = asRouter(schemaMapping);
+    if (ns === 'schema') {
+        const bare = BARE_IDENTITY_RE.exec(sval);
+        if (!bare)
+            return sval;
+        const schemaName = unquoteIdentifier(bare[1]);
+        const newName = router.resolve(schemaName, undefined, 'schema');
+        if (!newName || newName === schemaName)
+            return sval;
+        result.schemasFound.add(schemaName);
+        result.schemasTransformed.set(schemaName, newName);
+        return QuoteUtils.quoteIdentifier(newName);
+    }
+    // `regprocedure` and `regoperator` carry an argument list after the name, and
+    // an argument type can itself be schema-qualified
+    // (`fn("my-schema".row_type)`), so the list is routed as ordinary schema refs.
+    const argsAt = sval.indexOf('(');
+    const head = argsAt === -1 ? sval : sval.slice(0, argsAt);
+    const args = argsAt === -1 ? '' : transformSchemaRefsInString(sval.slice(argsAt), router, result);
+    const qualified = QUALIFIED_IDENTITY_RE.exec(head);
+    if (!qualified)
+        return `${head}${args}`;
+    const schemaName = unquoteIdentifier(qualified[1]);
+    const objName = unquoteIdentifier(qualified[2].trim());
+    const target = router.resolveObject(schemaName, objName, ns);
+    if (!target)
+        return `${head}${args}`;
+    const rebound = target.name !== undefined && target.name !== objName;
+    const requalified = target.schema === null || (!!target.schema && target.schema !== schemaName);
+    if (!rebound && !requalified)
+        return `${head}${args}`;
+    result.schemasFound.add(schemaName);
+    const nameToken = QuoteUtils.quoteIdentifier(rebound ? target.name : objName);
+    if (target.schema === null)
+        return `${nameToken}${args}`;
+    if (target.schema && target.schema !== schemaName) {
+        result.schemasTransformed.set(schemaName, target.schema);
+    }
+    return `${QuoteUtils.quoteIdentifier(target.schema ?? schemaName)}.${nameToken}${args}`;
+}
 /**
  * Create a SQL AST visitor that transforms schema names.
  *
@@ -459,9 +553,28 @@ export function createSqlVisitor(schemaMapping, result, visitorOptions) {
         A_Const: (path) => {
             const node = path.node;
             if (typeof node.sval?.sval === 'string' && node.sval.sval.includes('.')) {
+                if (!claimSite(result, node.sval, 'sval'))
+                    return;
                 node.sval.sval = transformSchemaRefsInString(node.sval.sval, schemaMapping, result);
             }
         },
+        // Object identities carried as the operand of an identity cast
+        // ('sch.tbl'::regclass, 'sch.fn(uuid)'::regprocedure, 'sch'::regnamespace).
+        // The cast names the namespace, so these route through the same object
+        // routes as a RangeVar rather than through a string pattern — and the bare
+        // schema form, invisible to every string pass, routes here.
+        TypeCast: (path) => {
+            const node = path.node;
+            const sval = node?.arg?.A_Const?.sval;
+            if (typeof sval?.sval !== 'string')
+                return;
+            const ns = identityCastNamespace(node.typeName);
+            if (!ns)
+                return;
+            if (!claimSite(result, sval, 'sval'))
+                return;
+            sval.sval = transformIdentityCastLiteral(sval.sval, ns, router, result);
+        },
         // Transform DefineStmt (CREATE TYPE schema.name, CREATE AGGREGATE schema.agg)
         DefineStmt: (path) => {
             const node = path.node;
@@ -618,14 +731,19 @@ export function validateNoUntransformedSchemas(content, schemaMapping) {
     if (moved.size === 0) {
         return;
     }
+    // Every pattern below requires a literal occurrence of the schema name, so a
+    // single case-insensitive substring scan rules out most schemas up front.
+    const lowerContent = content.toLowerCase();
     for (const [oldSchema, newSchema] of moved) {
-        const escapedSchema = escapeRegexp(oldSchema);
+        if (!lowerContent.includes(oldSchema.toLowerCase()))
+            continue;
+        const escapedSchema = cachedEscapeRegexp(oldSchema);
         // Pattern 1: quoted or unquoted schema name followed by dot (schema-qualified)
-        const dotPattern = new RegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)`, 'g');
+        const dotPattern = cachedRegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)`, 'g');
         // Pattern 2: standalone schema name in known SQL contexts
         // Note: We don't use trailing \b because it fails after closing quotes
         // (both '"' and whitespace are non-word characters, so no boundary exists).
-        const standalonePattern = new RegExp(`(?:ON\\s+SCHEMA\\s+|IN\\s+SCHEMA\\s+|CREATE\\s+SCHEMA\\s+|DROP\\s+SCHEMA\\s+(?:IF\\s+EXISTS\\s+)?|SET\\s+SCHEMA\\s+)` +
+        const standalonePattern = cachedRegExp(`(?:ON\\s+SCHEMA\\s+|IN\\s+SCHEMA\\s+|CREATE\\s+SCHEMA\\s+|DROP\\s+SCHEMA\\s+(?:IF\\s+EXISTS\\s+)?|SET\\s+SCHEMA\\s+)` +
             `(?:"${escapedSchema}"|\\b${escapedSchema}\\b)`, 'gi');
         const dotMatches = content.match(dotPattern);
         const standaloneMatches = content.match(standalonePattern);
@@ -633,7 +751,7 @@ export function validateNoUntransformedSchemas(content, schemaMapping) {
         if (totalMatches > 0) {
             const lines = content.split('\n');
             const locations = [];
-            const combinedPattern = new RegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)|` +
+            const combinedPattern = cachedRegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)|` +
                 `(?:ON\\s+SCHEMA\\s+|IN\\s+SCHEMA\\s+|CREATE\\s+SCHEMA\\s+|DROP\\s+SCHEMA\\s+(?:IF\\s+EXISTS\\s+)?|SET\\s+SCHEMA\\s+)` +
                 `(?:"${escapedSchema}"|\\b${escapedSchema}\\b)`, 'gi');
             for (let i = 0; i < lines.length; i++) {
@@ -878,6 +996,34 @@ function transformSchemasInContext(ctx, schemaMapping, result, visitorOptions) {
 export function escapeRegexp(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/**
+ * Compiling a pattern costs far more than running it, and the string-level
+ * passes below rebuild the same handful of per-schema patterns for every file
+ * they touch — on a large corpus that is hundreds of thousands of identical
+ * compiles. Patterns are keyed by source + flags and reused; each returned
+ * RegExp is stateful (`g`/`y` carry `lastIndex`), so callers must only use it
+ * with `String#replace`/`String#match`, which reset it, or reset it
+ * themselves, exactly as the throwaway instances required.
+ */
+const regExpCache = new Map();
+function cachedRegExp(source, flags) {
+    const key = `${flags}\u0000${source}`;
+    let re = regExpCache.get(key);
+    if (!re) {
+        re = new RegExp(source, flags);
+        regExpCache.set(key, re);
+    }
+    return re;
+}
+const escapeRegexpCache = new Map();
+function cachedEscapeRegexp(str) {
+    let escaped = escapeRegexpCache.get(str);
+    if (escaped === undefined) {
+        escaped = escapeRegexp(str);
+        escapeRegexpCache.set(str, escaped);
+    }
+    return escaped;
+}
 /**
  * Extract pgpm header comments from the beginning of SQL content.
  */
@@ -936,7 +1082,7 @@ export function transformComments(content, schemaMapping, result) {
             if (!newName)
                 continue;
             result.schemasFound.add(schema);
-            const pathPattern = new RegExp(`(schemas/)${escapeRegexp(schema)}(/|$)`, 'g');
+            const pathPattern = cachedRegExp(`(schemas/)${cachedEscapeRegexp(schema)}(/|$)`, 'g');
             const before = newPath;
             newPath = newPath.replace(pathPattern, `$1${newName}$2`);
             if (newPath !== before) {
@@ -953,15 +1099,20 @@ export function transformComments(content, schemaMapping, result) {
 export function transformVerifyCalls(content, schemaMapping, result) {
     const schemas = Array.from(schemaMapping.keys()).sort((a, b) => b.length - a.length);
     let newContent = content;
+    // The pattern needs the schema name spelled out, case-insensitively.
+    let lowerContent = content.toLowerCase();
     for (const schema of schemas) {
         const newName = schemaMapping.get(schema);
         if (!newName)
             continue;
-        const escapedSchema = escapeRegexp(schema);
-        const verifyPattern = new RegExp(`(verify_(?:function|table|trigger|type|domain|view|index|constraint|schema|policy|table_grant|function_grant|sequence_grant|type_grant)\\s*\\(\\s*')${escapedSchema}(\\.|'\\s*\\))`, 'gi');
+        if (!lowerContent.includes(schema.toLowerCase()))
+            continue;
+        const escapedSchema = cachedEscapeRegexp(schema);
+        const verifyPattern = cachedRegExp(`(verify_(?:function|table|trigger|type|domain|view|index|constraint|schema|policy|table_grant|function_grant|sequence_grant|type_grant)\\s*\\(\\s*')${escapedSchema}(\\.|'\\s*\\))`, 'gi');
         const before = newContent;
         newContent = newContent.replace(verifyPattern, `$1${newName}$2`);
         if (newContent !== before) {
+            lowerContent = newContent.toLowerCase();
             result.schemasFound.add(schema);
             result.schemasTransformed.set(schema, newName);
         }
@@ -978,8 +1129,10 @@ export function transformJsonStringValues(content, schemaMapping, result) {
         const newName = schemaMapping.get(schema);
         if (!newName)
             continue;
-        const escapedSchema = escapeRegexp(schema);
-        const jsonValuePattern = new RegExp(`(:")${escapedSchema}(")`, 'g');
+        if (!newContent.includes(schema))
+            continue;
+        const escapedSchema = cachedEscapeRegexp(schema);
+        const jsonValuePattern = cachedRegExp(`(:")${escapedSchema}(")`, 'g');
         const before = newContent;
         newContent = newContent.replace(jsonValuePattern, `$1${newName}$2`);
         if (newContent !== before) {

package/index.d.ts

@@ -23,4 +23,4 @@ export { CLEAN_TREE_VOLATILE_KEYS, cleanTree, normalizeTree, trimDefElemBody, }
 export type { ObjectNamespace, ObjectRoute, ObjectRouteTarget, RouteNamespace, RouteSpec, SchemaRoute, } from './router';
 export { SchemaRouter } from './router';
 export type { SchemaMappingInput, SchemaTransformPass, SchemaTransformResult, TransformSqlOptions, } from './transform';
-export { createPlpgsqlVisitor, createSqlVisitor, escapeRegexp, extractPgpmHeader, shouldTransformSchema, transformComments, transformJsonStringValues, transformNameList, transformPlpgsqlTypeAst, transformPlpgsqlTypeString, transformRelation, transformSchemaName, transformSql, transformSqlStatement, transformVerifyCalls, validateNoUntransformedSchemas, walkPlpgsqlForSchemas, } from './transform';
+export { createPlpgsqlVisitor, createSqlVisitor, escapeRegexp, extractPgpmHeader, identityCastNamespace, shouldTransformSchema, transformComments, transformIdentityCastLiteral, transformJsonStringValues, transformNameList, transformPlpgsqlTypeAst, transformPlpgsqlTypeString, transformRelation, transformSchemaName, transformSql, transformSqlStatement, transformVerifyCalls, validateNoUntransformedSchemas, walkPlpgsqlForSchemas, } from './transform';

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.walkPlpgsqlForSchemas = exports.validateNoUntransformedSchemas = exports.transformVerifyCalls = exports.transformSqlStatement = exports.transformSql = exports.transformSchemaName = exports.transformRelation = exports.transformPlpgsqlTypeString = exports.transformPlpgsqlTypeAst = exports.transformNameList = exports.transformJsonStringValues = exports.transformComments = exports.shouldTransformSchema = exports.extractPgpmHeader = exports.escapeRegexp = exports.createSqlVisitor = exports.createPlpgsqlVisitor = exports.SchemaRouter = exports.trimDefElemBody = exports.normalizeTree = exports.cleanTree = exports.CLEAN_TREE_VOLATILE_KEYS = exports.validateRoundTrip = exports.normalizeParseTree = exports.firstDifference = exports.captureTransformAsts = exports.captureAstsFromSql = exports.transformRoles = exports.createRoleVisitor = exports.createRoleResult = exports.RoleRouter = exports.restructureSql = exports.orderStatements = exports.qualifyUnqualified = exports.mergeInventories = exports.createQualifyVisitor = exports.collectCreatedObjects = exports.identityOf = exports.buildStatementGraph = exports.classifyStatements = exports.transformExtensions = exports.createExtensionVisitor = exports.createExtensionResult = exports.ExtensionRouter = exports.COMMON_EXTENSIONS = void 0;
+exports.walkPlpgsqlForSchemas = exports.validateNoUntransformedSchemas = exports.transformVerifyCalls = exports.transformSqlStatement = exports.transformSql = exports.transformSchemaName = exports.transformRelation = exports.transformPlpgsqlTypeString = exports.transformPlpgsqlTypeAst = exports.transformNameList = exports.transformJsonStringValues = exports.transformIdentityCastLiteral = exports.transformComments = exports.shouldTransformSchema = exports.identityCastNamespace = exports.extractPgpmHeader = exports.escapeRegexp = exports.createSqlVisitor = exports.createPlpgsqlVisitor = exports.SchemaRouter = exports.trimDefElemBody = exports.normalizeTree = exports.cleanTree = exports.CLEAN_TREE_VOLATILE_KEYS = exports.validateRoundTrip = exports.normalizeParseTree = exports.firstDifference = exports.captureTransformAsts = exports.captureAstsFromSql = exports.transformRoles = exports.createRoleVisitor = exports.createRoleResult = exports.RoleRouter = exports.restructureSql = exports.orderStatements = exports.qualifyUnqualified = exports.mergeInventories = exports.createQualifyVisitor = exports.collectCreatedObjects = exports.identityOf = exports.buildStatementGraph = exports.classifyStatements = exports.transformExtensions = exports.createExtensionVisitor = exports.createExtensionResult = exports.ExtensionRouter = exports.COMMON_EXTENSIONS = void 0;
 var extension_router_1 = require("./extension-router");
 Object.defineProperty(exports, "COMMON_EXTENSIONS", { enumerable: true, get: function () { return extension_router_1.COMMON_EXTENSIONS; } });
 Object.defineProperty(exports, "ExtensionRouter", { enumerable: true, get: function () { return extension_router_1.ExtensionRouter; } });
@@ -46,8 +46,10 @@ Object.defineProperty(exports, "createPlpgsqlVisitor", { enumerable: true, get:
 Object.defineProperty(exports, "createSqlVisitor", { enumerable: true, get: function () { return transform_1.createSqlVisitor; } });
 Object.defineProperty(exports, "escapeRegexp", { enumerable: true, get: function () { return transform_1.escapeRegexp; } });
 Object.defineProperty(exports, "extractPgpmHeader", { enumerable: true, get: function () { return transform_1.extractPgpmHeader; } });
+Object.defineProperty(exports, "identityCastNamespace", { enumerable: true, get: function () { return transform_1.identityCastNamespace; } });
 Object.defineProperty(exports, "shouldTransformSchema", { enumerable: true, get: function () { return transform_1.shouldTransformSchema; } });
 Object.defineProperty(exports, "transformComments", { enumerable: true, get: function () { return transform_1.transformComments; } });
+Object.defineProperty(exports, "transformIdentityCastLiteral", { enumerable: true, get: function () { return transform_1.transformIdentityCastLiteral; } });
 Object.defineProperty(exports, "transformJsonStringValues", { enumerable: true, get: function () { return transform_1.transformJsonStringValues; } });
 Object.defineProperty(exports, "transformNameList", { enumerable: true, get: function () { return transform_1.transformNameList; } });
 Object.defineProperty(exports, "transformPlpgsqlTypeAst", { enumerable: true, get: function () { return transform_1.transformPlpgsqlTypeAst; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgsql/transform",
-  "version": "18.15.2",
+  "version": "18.16.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "AST-based SQL transformation, qualification, classification and closure analysis for PostgreSQL",
   "main": "index.js",
@@ -50,5 +50,5 @@
     "classify",
     "plpgsql"
   ],
-  "gitHead": "b6105874628cc7b8517c1ebbd99e9ad6fe786976"
+  "gitHead": "9ecd247f9f0ef696a95e1f582d7353eb6bb693d4"
 }

package/transform.d.ts

@@ -123,6 +123,19 @@ export declare function transformRelation(relation: any, schemaMapping: SchemaMa
  * followed by a dot are rewritten.
  */
 export declare function transformSchemaRefsInString(str: string, schemaMapping: SchemaMappingInput, result: SchemaTransformResult): string;
+/**
+ * The namespace a cast resolves its operand in, or `undefined` when the target
+ * type is not an object-identity type.
+ */
+export declare function identityCastNamespace(typeName: any): RouteNamespace | undefined;
+/**
+ * Route the object reference carried in the string operand of an identity
+ * cast. `ns` comes from the cast's target type.
+ *
+ * Unqualified operands (`'tbl'::regclass`) name no schema — they resolve
+ * through `search_path` — so they are returned unchanged.
+ */
+export declare function transformIdentityCastLiteral(sval: string, ns: RouteNamespace, schemaMapping: SchemaMappingInput, result: SchemaTransformResult): string;
 /**
  * Create a SQL AST visitor that transforms schema names.
  *
@@ -148,6 +161,7 @@ export declare function createSqlVisitor(schemaMapping: SchemaMappingInput, resu
     CreateTrigStmt: (path: any) => void;
     CommentStmt: (path: any) => void;
     A_Const: (path: any) => void;
+    TypeCast: (path: any) => void;
     DefineStmt: (path: any) => void;
     CreateDomainStmt: (path: any) => void;
     CreateEnumStmt: (path: any) => void;

package/transform.js

@@ -31,6 +31,8 @@ exports.transformNameList = transformNameList;
 exports.transformSchemaNameField = transformSchemaNameField;
 exports.transformRelation = transformRelation;
 exports.transformSchemaRefsInString = transformSchemaRefsInString;
+exports.identityCastNamespace = identityCastNamespace;
+exports.transformIdentityCastLiteral = transformIdentityCastLiteral;
 exports.createSqlVisitor = createSqlVisitor;
 exports.validateNoUntransformedSchemas = validateNoUntransformedSchemas;
 exports.createPlpgsqlVisitor = createPlpgsqlVisitor;
@@ -218,7 +220,9 @@ function transformSchemaRefsInString(str, schemaMapping, result) {
     // References embedded in opaque strings carry no object identity, so only
     // whole-schema (schema-level default) routes can be applied here.
     for (const [oldSchema, newSchema] of schemaLevelMap(schemaMapping)) {
-        const pattern = new RegExp(`(?<![\\w-])("?)${escapeRegexp(oldSchema)}\\1(?=\\.)`, 'g');
+        if (!out.includes(oldSchema))
+            continue;
+        const pattern = cachedRegExp(`(?<![\\w-])("?)${cachedEscapeRegexp(oldSchema)}\\1(?=\\.)`, 'g');
         const before = out;
         out = out.replace(pattern, `$1${newSchema}$1`);
         if (out !== before) {
@@ -228,6 +232,98 @@ function transformSchemaRefsInString(str, schemaMapping, result) {
     }
     return out;
 }
+/**
+ * Cast types whose string operand is an object reference rather than opaque
+ * text. `'sch.tbl'::regclass` is a relation the parser resolves, and the cast
+ * names the namespace it resolves in — so the reference can be routed from the
+ * cast, semantically, instead of pattern-matched. This reaches what the string
+ * passes cannot: a bare `'sch'::regnamespace` has no dot to match on.
+ */
+const IDENTITY_CAST_NAMESPACES = {
+    regclass: 'relation',
+    regcollation: 'unknown',
+    regconfig: 'unknown',
+    regdictionary: 'unknown',
+    regnamespace: 'schema',
+    regoper: 'unknown',
+    regoperator: 'unknown',
+    regproc: 'function',
+    regprocedure: 'function',
+    regtype: 'type'
+};
+/**
+ * The namespace a cast resolves its operand in, or `undefined` when the target
+ * type is not an object-identity type.
+ */
+function identityCastNamespace(typeName) {
+    const names = typeName?.names;
+    if (!Array.isArray(names) || names.length === 0)
+        return undefined;
+    // Only `pg_catalog`-qualified (or unqualified) reg* types are the built-ins.
+    if (names.length > 1 && names[0]?.String?.sval !== 'pg_catalog')
+        return undefined;
+    const typeIdent = names[names.length - 1]?.String?.sval;
+    if (typeof typeIdent !== 'string')
+        return undefined;
+    return IDENTITY_CAST_NAMESPACES[typeIdent.toLowerCase()];
+}
+const IDENTITY_TOKEN = String.raw `(?:"(?:[^"]|"")*"|[^\s".,()[\]]+)`;
+const BARE_IDENTITY_RE = new RegExp(`^\\s*(${IDENTITY_TOKEN})\\s*$`);
+const QUALIFIED_IDENTITY_RE = new RegExp(`^\\s*(${IDENTITY_TOKEN})\\.([\\s\\S]+)$`);
+function unquoteIdentifier(token) {
+    if (token.length > 1 && token.startsWith('"') && token.endsWith('"')) {
+        return token.slice(1, -1).replace(/""/g, '"');
+    }
+    return token;
+}
+/**
+ * Route the object reference carried in the string operand of an identity
+ * cast. `ns` comes from the cast's target type.
+ *
+ * Unqualified operands (`'tbl'::regclass`) name no schema — they resolve
+ * through `search_path` — so they are returned unchanged.
+ */
+function transformIdentityCastLiteral(sval, ns, schemaMapping, result) {
+    const router = asRouter(schemaMapping);
+    if (ns === 'schema') {
+        const bare = BARE_IDENTITY_RE.exec(sval);
+        if (!bare)
+            return sval;
+        const schemaName = unquoteIdentifier(bare[1]);
+        const newName = router.resolve(schemaName, undefined, 'schema');
+        if (!newName || newName === schemaName)
+            return sval;
+        result.schemasFound.add(schemaName);
+        result.schemasTransformed.set(schemaName, newName);
+        return quotes_1.QuoteUtils.quoteIdentifier(newName);
+    }
+    // `regprocedure` and `regoperator` carry an argument list after the name, and
+    // an argument type can itself be schema-qualified
+    // (`fn("my-schema".row_type)`), so the list is routed as ordinary schema refs.
+    const argsAt = sval.indexOf('(');
+    const head = argsAt === -1 ? sval : sval.slice(0, argsAt);
+    const args = argsAt === -1 ? '' : transformSchemaRefsInString(sval.slice(argsAt), router, result);
+    const qualified = QUALIFIED_IDENTITY_RE.exec(head);
+    if (!qualified)
+        return `${head}${args}`;
+    const schemaName = unquoteIdentifier(qualified[1]);
+    const objName = unquoteIdentifier(qualified[2].trim());
+    const target = router.resolveObject(schemaName, objName, ns);
+    if (!target)
+        return `${head}${args}`;
+    const rebound = target.name !== undefined && target.name !== objName;
+    const requalified = target.schema === null || (!!target.schema && target.schema !== schemaName);
+    if (!rebound && !requalified)
+        return `${head}${args}`;
+    result.schemasFound.add(schemaName);
+    const nameToken = quotes_1.QuoteUtils.quoteIdentifier(rebound ? target.name : objName);
+    if (target.schema === null)
+        return `${nameToken}${args}`;
+    if (target.schema && target.schema !== schemaName) {
+        result.schemasTransformed.set(schemaName, target.schema);
+    }
+    return `${quotes_1.QuoteUtils.quoteIdentifier(target.schema ?? schemaName)}.${nameToken}${args}`;
+}
 /**
  * Create a SQL AST visitor that transforms schema names.
  *
@@ -480,9 +576,28 @@ function createSqlVisitor(schemaMapping, result, visitorOptions) {
         A_Const: (path) => {
             const node = path.node;
             if (typeof node.sval?.sval === 'string' && node.sval.sval.includes('.')) {
+                if (!claimSite(result, node.sval, 'sval'))
+                    return;
                 node.sval.sval = transformSchemaRefsInString(node.sval.sval, schemaMapping, result);
             }
         },
+        // Object identities carried as the operand of an identity cast
+        // ('sch.tbl'::regclass, 'sch.fn(uuid)'::regprocedure, 'sch'::regnamespace).
+        // The cast names the namespace, so these route through the same object
+        // routes as a RangeVar rather than through a string pattern — and the bare
+        // schema form, invisible to every string pass, routes here.
+        TypeCast: (path) => {
+            const node = path.node;
+            const sval = node?.arg?.A_Const?.sval;
+            if (typeof sval?.sval !== 'string')
+                return;
+            const ns = identityCastNamespace(node.typeName);
+            if (!ns)
+                return;
+            if (!claimSite(result, sval, 'sval'))
+                return;
+            sval.sval = transformIdentityCastLiteral(sval.sval, ns, router, result);
+        },
         // Transform DefineStmt (CREATE TYPE schema.name, CREATE AGGREGATE schema.agg)
         DefineStmt: (path) => {
             const node = path.node;
@@ -639,14 +754,19 @@ function validateNoUntransformedSchemas(content, schemaMapping) {
     if (moved.size === 0) {
         return;
     }
+    // Every pattern below requires a literal occurrence of the schema name, so a
+    // single case-insensitive substring scan rules out most schemas up front.
+    const lowerContent = content.toLowerCase();
     for (const [oldSchema, newSchema] of moved) {
-        const escapedSchema = escapeRegexp(oldSchema);
+        if (!lowerContent.includes(oldSchema.toLowerCase()))
+            continue;
+        const escapedSchema = cachedEscapeRegexp(oldSchema);
         // Pattern 1: quoted or unquoted schema name followed by dot (schema-qualified)
-        const dotPattern = new RegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)`, 'g');
+        const dotPattern = cachedRegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)`, 'g');
         // Pattern 2: standalone schema name in known SQL contexts
         // Note: We don't use trailing \b because it fails after closing quotes
         // (both '"' and whitespace are non-word characters, so no boundary exists).
-        const standalonePattern = new RegExp(`(?:ON\\s+SCHEMA\\s+|IN\\s+SCHEMA\\s+|CREATE\\s+SCHEMA\\s+|DROP\\s+SCHEMA\\s+(?:IF\\s+EXISTS\\s+)?|SET\\s+SCHEMA\\s+)` +
+        const standalonePattern = cachedRegExp(`(?:ON\\s+SCHEMA\\s+|IN\\s+SCHEMA\\s+|CREATE\\s+SCHEMA\\s+|DROP\\s+SCHEMA\\s+(?:IF\\s+EXISTS\\s+)?|SET\\s+SCHEMA\\s+)` +
             `(?:"${escapedSchema}"|\\b${escapedSchema}\\b)`, 'gi');
         const dotMatches = content.match(dotPattern);
         const standaloneMatches = content.match(standalonePattern);
@@ -654,7 +774,7 @@ function validateNoUntransformedSchemas(content, schemaMapping) {
         if (totalMatches > 0) {
             const lines = content.split('\n');
             const locations = [];
-            const combinedPattern = new RegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)|` +
+            const combinedPattern = cachedRegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)|` +
                 `(?:ON\\s+SCHEMA\\s+|IN\\s+SCHEMA\\s+|CREATE\\s+SCHEMA\\s+|DROP\\s+SCHEMA\\s+(?:IF\\s+EXISTS\\s+)?|SET\\s+SCHEMA\\s+)` +
                 `(?:"${escapedSchema}"|\\b${escapedSchema}\\b)`, 'gi');
             for (let i = 0; i < lines.length; i++) {
@@ -899,6 +1019,34 @@ function transformSchemasInContext(ctx, schemaMapping, result, visitorOptions) {
 function escapeRegexp(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/**
+ * Compiling a pattern costs far more than running it, and the string-level
+ * passes below rebuild the same handful of per-schema patterns for every file
+ * they touch — on a large corpus that is hundreds of thousands of identical
+ * compiles. Patterns are keyed by source + flags and reused; each returned
+ * RegExp is stateful (`g`/`y` carry `lastIndex`), so callers must only use it
+ * with `String#replace`/`String#match`, which reset it, or reset it
+ * themselves, exactly as the throwaway instances required.
+ */
+const regExpCache = new Map();
+function cachedRegExp(source, flags) {
+    const key = `${flags}\u0000${source}`;
+    let re = regExpCache.get(key);
+    if (!re) {
+        re = new RegExp(source, flags);
+        regExpCache.set(key, re);
+    }
+    return re;
+}
+const escapeRegexpCache = new Map();
+function cachedEscapeRegexp(str) {
+    let escaped = escapeRegexpCache.get(str);
+    if (escaped === undefined) {
+        escaped = escapeRegexp(str);
+        escapeRegexpCache.set(str, escaped);
+    }
+    return escaped;
+}
 /**
  * Extract pgpm header comments from the beginning of SQL content.
  */
@@ -957,7 +1105,7 @@ function transformComments(content, schemaMapping, result) {
             if (!newName)
                 continue;
             result.schemasFound.add(schema);
-            const pathPattern = new RegExp(`(schemas/)${escapeRegexp(schema)}(/|$)`, 'g');
+            const pathPattern = cachedRegExp(`(schemas/)${cachedEscapeRegexp(schema)}(/|$)`, 'g');
             const before = newPath;
             newPath = newPath.replace(pathPattern, `$1${newName}$2`);
             if (newPath !== before) {
@@ -974,15 +1122,20 @@ function transformComments(content, schemaMapping, result) {
 function transformVerifyCalls(content, schemaMapping, result) {
     const schemas = Array.from(schemaMapping.keys()).sort((a, b) => b.length - a.length);
     let newContent = content;
+    // The pattern needs the schema name spelled out, case-insensitively.
+    let lowerContent = content.toLowerCase();
     for (const schema of schemas) {
         const newName = schemaMapping.get(schema);
         if (!newName)
             continue;
-        const escapedSchema = escapeRegexp(schema);
-        const verifyPattern = new RegExp(`(verify_(?:function|table|trigger|type|domain|view|index|constraint|schema|policy|table_grant|function_grant|sequence_grant|type_grant)\\s*\\(\\s*')${escapedSchema}(\\.|'\\s*\\))`, 'gi');
+        if (!lowerContent.includes(schema.toLowerCase()))
+            continue;
+        const escapedSchema = cachedEscapeRegexp(schema);
+        const verifyPattern = cachedRegExp(`(verify_(?:function|table|trigger|type|domain|view|index|constraint|schema|policy|table_grant|function_grant|sequence_grant|type_grant)\\s*\\(\\s*')${escapedSchema}(\\.|'\\s*\\))`, 'gi');
         const before = newContent;
         newContent = newContent.replace(verifyPattern, `$1${newName}$2`);
         if (newContent !== before) {
+            lowerContent = newContent.toLowerCase();
             result.schemasFound.add(schema);
             result.schemasTransformed.set(schema, newName);
         }
@@ -999,8 +1152,10 @@ function transformJsonStringValues(content, schemaMapping, result) {
         const newName = schemaMapping.get(schema);
         if (!newName)
             continue;
-        const escapedSchema = escapeRegexp(schema);
-        const jsonValuePattern = new RegExp(`(:")${escapedSchema}(")`, 'g');
+        if (!newContent.includes(schema))
+            continue;
+        const escapedSchema = cachedEscapeRegexp(schema);
+        const jsonValuePattern = cachedRegExp(`(:")${escapedSchema}(")`, 'g');
         const before = newContent;
         newContent = newContent.replace(jsonValuePattern, `$1${newName}$2`);
         if (newContent !== before) {