oak-db 3.3.13 → 4.0.0

package/lib/PostgreSQL/migration.js

@@ -0,0 +1,984 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPostgreSqlSchema = readPostgreSqlSchema;
+exports.inspectPostgreSqlSchema = inspectPostgreSqlSchema;
+exports.buildPostgreSqlMigrationPlan = buildPostgreSqlMigrationPlan;
+const crypto_1 = require("crypto");
+const migration_1 = require("../migration");
+const inspection_1 = require("../utils/inspection");
+const indexInspection_1 = require("../utils/indexInspection");
+const prepare_1 = require("./prepare");
+function mapOnDeleteRule(deleteRule) {
+    switch ((deleteRule || '').toUpperCase()) {
+        case 'CASCADE':
+            return 'cascade';
+        case 'SET NULL':
+            return 'set null';
+        default:
+            return 'no action';
+    }
+}
+function makeWarning(code, message, table, column, sql) {
+    return {
+        code,
+        level: 'warning',
+        message,
+        table,
+        column,
+        sql,
+    };
+}
+function escapeStringValue(value) {
+    return value.replace(/'/g, "''");
+}
+function buildPostgreSqlTempEnumTypeName(enumTypeName) {
+    const suffix = `__old_${(0, crypto_1.createHash)('sha1')
+        .update(enumTypeName)
+        .digest('hex')
+        .slice(0, 8)}`;
+    const maxBaseLength = 63 - suffix.length;
+    return `${enumTypeName.slice(0, Math.max(1, maxBaseLength))}${suffix}`;
+}
+function extractTypeExpression(columnDefinition) {
+    const withoutName = columnDefinition.replace(/^"[^"]+"\s+/, '');
+    const markers = [' NOT NULL', ' UNIQUE', ' DEFAULT', ' PRIMARY KEY'];
+    let end = withoutName.length;
+    markers.forEach((marker) => {
+        const index = withoutName.indexOf(marker);
+        if (index >= 0 && index < end) {
+            end = index;
+        }
+    });
+    return withoutName.slice(0, end);
+}
+function translateDefaultValue(attr) {
+    const { default: defaultValue, type } = attr;
+    if (defaultValue === undefined) {
+        return undefined;
+    }
+    if (type === 'bool' || type === 'boolean') {
+        return defaultValue ? 'TRUE' : 'FALSE';
+    }
+    if (typeof defaultValue === 'number') {
+        return String(defaultValue);
+    }
+    if (type === 'object' || type === 'array') {
+        return `'${escapeStringValue(JSON.stringify(defaultValue))}'::jsonb`;
+    }
+    return `'${escapeStringValue(String(defaultValue))}'`;
+}
+function mapPostgreSqlIndexType(indexType) {
+    switch (indexType.toLowerCase()) {
+        case 'hash':
+            return 'hash';
+        case 'gist':
+            return 'spatial';
+        default:
+            return 'btree';
+    }
+}
+function createPgAdapter(translator) {
+    const quote = (name) => translator.quoteIdentifier(name);
+    const getTableName = (table, tableDef) => tableDef?.storageName || table;
+    const getForeignKeyName = (tableName, column) => `${tableName}_${column}_fk`;
+    const getOnDeleteSql = (onDelete) => {
+        switch (onDelete) {
+            case 'cascade':
+                return 'CASCADE';
+            case 'set null':
+                return 'SET NULL';
+            default:
+                return 'NO ACTION';
+        }
+    };
+    const createEnumSql = (tableName, column, attr) => {
+        const enumTypeName = translator.getEnumTypeName(tableName, column);
+        const values = attr.enumeration || [];
+        return `DO $$ BEGIN CREATE TYPE ${quote(enumTypeName)} AS ENUM (${values.map((value) => `'${escapeStringValue(value)}'`).join(', ')}); EXCEPTION WHEN duplicate_object THEN NULL; END $$;`;
+    };
+    const buildCreateEnumTypeSql = (enumTypeName, values) => `CREATE TYPE ${quote(enumTypeName)} AS ENUM (${values.map((value) => `'${escapeStringValue(value)}'`).join(', ')});`;
+    const buildColumnDefaultSql = (tableName, column, defaultValue) => defaultValue === undefined
+        ? `ALTER TABLE ${quote(tableName)} ALTER COLUMN ${quote(column)} DROP DEFAULT;`
+        : `ALTER TABLE ${quote(tableName)} ALTER COLUMN ${quote(column)} SET DEFAULT ${defaultValue};`;
+    const buildEnumManualAlterSql = (tableName, column, oldAttr, newAttr) => {
+        const oldDefault = translateDefaultValue(oldAttr);
+        const newDefault = translateDefaultValue(newAttr);
+        const oldNotNull = !!oldAttr.notNull || oldAttr.type === 'geometry';
+        const newNotNull = !!newAttr.notNull || newAttr.type === 'geometry';
+        const sqls = [];
+        if (oldAttr.type === 'enum' && newAttr.type === 'enum') {
+            const enumTypeName = translator.getEnumTypeName(tableName, column);
+            const tempEnumTypeName = buildPostgreSqlTempEnumTypeName(enumTypeName);
+            if (oldDefault !== undefined) {
+                sqls.push(buildColumnDefaultSql(tableName, column, undefined));
+            }
+            // 先把旧类型让位，再用目标枚举定义重建同名类型，最后把列按 text 中转回绑到新类型。
+            sqls.push(`ALTER TYPE ${quote(enumTypeName)} RENAME TO ${quote(tempEnumTypeName)};`);
+            sqls.push(buildCreateEnumTypeSql(enumTypeName, newAttr.enumeration || []));
+            sqls.push(`ALTER TABLE ${quote(tableName)} ALTER COLUMN ${quote(column)} TYPE ${quote(enumTypeName)} USING ${quote(column)}::text::${quote(enumTypeName)};`);
+            sqls.push(`DROP TYPE ${quote(tempEnumTypeName)};`);
+        }
+        else {
+            if (newAttr.type === 'enum') {
+                sqls.push(buildCreateEnumTypeSql(translator.getEnumTypeName(tableName, column), newAttr.enumeration || []));
+            }
+            const oldColumnDef = translator.translateColumnDefinition(tableName, column, oldAttr);
+            const newColumnDef = translator.translateColumnDefinition(tableName, column, newAttr);
+            const oldType = extractTypeExpression(oldColumnDef);
+            const newType = extractTypeExpression(newColumnDef);
+            if (oldType !== newType) {
+                const usingClause = oldAttr.type === 'enum' || newAttr.type === 'enum'
+                    ? `${quote(column)}::text::${newType}`
+                    : `${quote(column)}::${newType}`;
+                if (oldDefault !== undefined && oldAttr.type === 'enum') {
+                    sqls.push(buildColumnDefaultSql(tableName, column, undefined));
+                }
+                sqls.push(`ALTER TABLE ${quote(tableName)} ALTER COLUMN ${quote(column)} TYPE ${newType} USING ${usingClause};`);
+            }
+            if (oldAttr.type === 'enum') {
+                sqls.push(`DROP TYPE IF EXISTS ${quote(translator.getEnumTypeName(tableName, column))};`);
+            }
+        }
+        // enum 迁移中经常需要先临时移除默认值；这里统一按目标定义回放默认值与空值约束，
+        // 保证 migration.sql 执行完后列语义与最新 schema 一致。
+        if (oldDefault !== newDefault || (oldAttr.type === 'enum' && oldDefault !== undefined)) {
+            if (newDefault !== undefined) {
+                sqls.push(buildColumnDefaultSql(tableName, column, newDefault));
+            }
+        }
+        if (oldNotNull !== newNotNull) {
+            sqls.push(`ALTER TABLE ${quote(tableName)} ALTER COLUMN ${quote(column)} ${newNotNull ? 'SET' : 'DROP'} NOT NULL;`);
+        }
+        return sqls;
+    };
+    const buildIndexNames = (tableName, table, index) => {
+        if (index.config?.type === 'fulltext') {
+            const tsConfigs = Array.isArray(index.config?.tsConfig)
+                ? [...index.config.tsConfig]
+                : [index.config?.tsConfig || 'simple'];
+            return tsConfigs.map((tsConfig) => ({
+                physicalName: translator.getPhysicalIndexName(table, tableName, index.name, tsConfigs.length > 1 ? `_${tsConfig}` : ''),
+                tsConfig,
+            }));
+        }
+        return [{
+                physicalName: translator.getPhysicalIndexName(table, tableName, index.name),
+                tsConfig: undefined,
+            }];
+    };
+    const buildIndexSql = (tableName, table, index, options) => {
+        return buildIndexNames(tableName, table, index).map(({ physicalName, tsConfig }) => {
+            const indexName = options?.indexNameOverride || physicalName;
+            let sql = 'CREATE ';
+            if (options?.concurrently) {
+                sql += 'INDEX CONCURRENTLY ';
+                if (index.config?.unique) {
+                    sql = 'CREATE UNIQUE INDEX CONCURRENTLY ';
+                }
+            }
+            else if (index.config?.unique) {
+                sql += 'UNIQUE ';
+            }
+            if (!options?.concurrently) {
+                sql += 'INDEX ';
+            }
+            if (index.config?.unique) {
+                if (!options?.concurrently) {
+                    sql += '';
+                }
+            }
+            sql += `IF NOT EXISTS ${quote(indexName)} ON ${quote(tableName)} `;
+            if (index.config?.type === 'hash') {
+                sql += 'USING HASH ';
+            }
+            else if (index.config?.type === 'spatial') {
+                sql += 'USING GIST ';
+            }
+            else if (index.config?.type === 'fulltext') {
+                sql += 'USING GIN ';
+            }
+            sql += '(';
+            if (index.config?.type === 'fulltext') {
+                sql += index.attributes.map(({ name }) => `to_tsvector('${tsConfig}', COALESCE(${quote(String(name))}, ''))`).join(', ');
+            }
+            else {
+                sql += index.attributes.map(({ name, direction }) => {
+                    let fragment = quote(String(name));
+                    if (direction) {
+                        fragment += ` ${direction}`;
+                    }
+                    return fragment;
+                }).join(', ');
+            }
+            sql += ');';
+            return sql;
+        });
+    };
+    const buildDropIndexSql = (tableName, table, index, options) => {
+        const originNames = index.__originNames || [];
+        const physicalNames = options?.indexNameOverride
+            ? [options.indexNameOverride]
+            : (originNames.length
+                ? originNames
+                : (typeof index.__originName === 'string'
+                    ? [index.__originName]
+                    : buildIndexNames(tableName, table, index).map(({ physicalName }) => physicalName)));
+        return physicalNames.map((indexName) => `DROP INDEX ${options?.concurrently ? 'CONCURRENTLY ' : ''}IF EXISTS ${quote(indexName)};`);
+    };
+    const getExpectedPhysicalIndexNames = (tableName, table, index) => buildIndexNames(tableName, table, index).map(({ physicalName }) => physicalName);
+    const buildAlterColumnSql = (tableName, column, oldAttr, newAttr) => {
+        const sqls = [];
+        const oldColumnDef = translator.translateColumnDefinition(tableName, column, oldAttr);
+        const newColumnDef = translator.translateColumnDefinition(tableName, column, newAttr);
+        const oldType = extractTypeExpression(oldColumnDef);
+        const newType = extractTypeExpression(newColumnDef);
+        if (oldType !== newType) {
+            sqls.push(`ALTER TABLE ${quote(tableName)} ALTER COLUMN ${quote(column)} TYPE ${newType} USING ${quote(column)}::${newType};`);
+        }
+        const oldDefault = translateDefaultValue(oldAttr);
+        const newDefault = translateDefaultValue(newAttr);
+        if (oldDefault !== newDefault) {
+            if (newDefault === undefined) {
+                sqls.push(`ALTER TABLE ${quote(tableName)} ALTER COLUMN ${quote(column)} DROP DEFAULT;`);
+            }
+            else {
+                sqls.push(`ALTER TABLE ${quote(tableName)} ALTER COLUMN ${quote(column)} SET DEFAULT ${newDefault};`);
+            }
+        }
+        const oldNotNull = !!oldAttr.notNull || oldAttr.type === 'geometry';
+        const newNotNull = !!newAttr.notNull || newAttr.type === 'geometry';
+        if (oldNotNull !== newNotNull) {
+            sqls.push(`ALTER TABLE ${quote(tableName)} ALTER COLUMN ${quote(column)} ${newNotNull ? 'SET' : 'DROP'} NOT NULL;`);
+        }
+        return sqls;
+    };
+    return {
+        dialect: 'postgresql',
+        normalizeIdentifier(name) {
+            return name;
+        },
+        getTableName,
+        buildPrepareSql(currentSchema, targetSchema) {
+            return (0, prepare_1.buildPostgreSqlPrepareSql)(currentSchema, targetSchema);
+        },
+        buildNewTablePlan(table, tableDef) {
+            const tableName = getTableName(table, tableDef);
+            const prepareSql = Object.entries(tableDef.attributes || {}).flatMap(([column, attr]) => attr.type === 'enum'
+                ? [createEnumSql(tableName, column, attr)]
+                : []);
+            const sql = translator.translateCreateEntity(table, {
+                ifExists: 'omit',
+            }).filter((stmt) => !/^\s*(?:DO\s+\$\$\s+BEGIN\s+)?CREATE\s+TYPE\b/i.test(stmt));
+            const foreignKeys = this.getForeignKeys(table, tableDef, translator.schema);
+            return {
+                prepareSql,
+                forwardSql: sql,
+                deferredForwardSql: Object.values(foreignKeys).map((foreignKey) => `ALTER TABLE ${quote(tableName)} ADD CONSTRAINT ${quote(foreignKey.name)} FOREIGN KEY (${quote(foreignKey.column)}) REFERENCES ${quote(foreignKey.refTable)} (${quote(foreignKey.refColumn)}) ON DELETE ${getOnDeleteSql(foreignKey.onDelete)};`),
+                summary: {
+                    newTables: 1,
+                    addedIndexes: (tableDef.indexes || []).length,
+                    addedForeignKeys: Object.keys(foreignKeys).length,
+                },
+            };
+        },
+        buildDropTablePlan(tableName) {
+            return {
+                backwardSql: [
+                    `DROP TABLE IF EXISTS ${quote(tableName)} CASCADE;`,
+                ],
+                summary: {
+                    removedTables: 1,
+                },
+            };
+        },
+        buildRenamePlan(tableName, from, to) {
+            const sql = [
+                `ALTER TABLE ${quote(tableName)} RENAME COLUMN ${quote(from)} TO ${quote(to)};`,
+            ];
+            return {
+                manualSql: sql,
+                warnings: [
+                    makeWarning('rename-candidate', `字段「${from}」与「${to}」结构一致，推测为重命名，请先确认再执行`, tableName, to, sql),
+                ],
+                renameCandidates: [{
+                        table: tableName,
+                        from,
+                        to,
+                        reason: '旧字段与新字段结构完全一致',
+                        sql,
+                    }],
+                summary: {
+                    manualActions: 1,
+                    changedColumns: 1,
+                },
+            };
+        },
+        buildColumnPlan(tableName, column, oldAttr, newAttr, classification) {
+            if (!oldAttr && newAttr) {
+                const prepareSql = newAttr.type === 'enum'
+                    ? [createEnumSql(tableName, column, newAttr)]
+                    : [];
+                const sql = `ALTER TABLE ${quote(tableName)} ADD COLUMN ${translator.translateColumnDefinition(tableName, column, newAttr)};`;
+                if (classification.mode === 'manual') {
+                    return {
+                        prepareSql,
+                        manualSql: [sql],
+                        warnings: [
+                            makeWarning('manual-column-change', classification.reason || `新增字段「${column}」需要人工确认`, tableName, column, [sql]),
+                        ],
+                        summary: {
+                            addedColumns: 1,
+                            manualActions: 1,
+                        },
+                    };
+                }
+                return {
+                    prepareSql,
+                    forwardSql: [sql],
+                    summary: {
+                        addedColumns: 1,
+                    },
+                };
+            }
+            if (oldAttr && !newAttr) {
+                return {
+                    backwardSql: [
+                        `ALTER TABLE ${quote(tableName)} DROP COLUMN ${quote(column)};`,
+                    ],
+                    summary: {
+                        removedColumns: 1,
+                    },
+                };
+            }
+            if (classification.mode === 'none') {
+                return {};
+            }
+            if (classification.enumAppendOnly && oldAttr?.enumeration && newAttr?.enumeration) {
+                const enumTypeName = translator.getEnumTypeName(tableName, column);
+                const addedValues = newAttr.enumeration.slice(oldAttr.enumeration.length);
+                return {
+                    prepareSql: addedValues.map((value) => `ALTER TYPE ${quote(enumTypeName)} ADD VALUE IF NOT EXISTS '${escapeStringValue(value)}';`),
+                    summary: {
+                        changedColumns: addedValues.length ? 1 : 0,
+                    },
+                };
+            }
+            const sql = oldAttr && newAttr
+                && (oldAttr.type === 'enum' || newAttr.type === 'enum')
+                ? buildEnumManualAlterSql(tableName, column, oldAttr, newAttr)
+                : buildAlterColumnSql(tableName, column, oldAttr, newAttr);
+            if (classification.mode === 'manual') {
+                return {
+                    manualSql: sql,
+                    warnings: [
+                        makeWarning(newAttr?.type === 'enum' || oldAttr?.type === 'enum' ? 'manual-enum-change' : 'manual-column-change', classification.reason || `字段「${column}」变更需要人工确认`, tableName, column, sql),
+                    ],
+                    summary: {
+                        changedColumns: 1,
+                        manualActions: 1,
+                    },
+                };
+            }
+            return {
+                forwardSql: sql,
+                summary: {
+                    changedColumns: 1,
+                },
+            };
+        },
+        buildIndexPlan(tableName, table, oldIndex, newIndex, context) {
+            const estimatedRows = context.tableStats?.rowCount;
+            const isLargeTable = !context.isNewTable
+                && estimatedRows !== undefined
+                && estimatedRows >= context.largeTableRowThreshold;
+            const makeLargeTableIndexWarning = (message, sql) => makeWarning('large-table-index-change', `${message}${estimatedRows !== undefined ? `（当前估算行数: ${estimatedRows}）` : ''}`, tableName, undefined, sql);
+            if (!oldIndex && newIndex) {
+                const sql = buildIndexSql(tableName, table, newIndex);
+                if (newIndex.config?.unique && !context.isNewTable) {
+                    return {
+                        manualSql: sql,
+                        warnings: [
+                            makeWarning('manual-index-change', `索引「${newIndex.name}」是唯一索引，执行前需要确认历史数据无重复`, tableName, undefined, sql),
+                        ],
+                        summary: {
+                            addedIndexes: 1,
+                            manualActions: 1,
+                        },
+                    };
+                }
+                if (isLargeTable) {
+                    const onlineSql = buildIndexSql(tableName, table, newIndex, {
+                        concurrently: true,
+                    });
+                    return {
+                        onlineSql,
+                        warnings: [
+                            makeLargeTableIndexWarning(`大表新增索引「${newIndex.name}」已切换为在线创建`, onlineSql),
+                        ],
+                        summary: {
+                            addedIndexes: 1,
+                            onlineActions: 1,
+                            largeTableIndexes: 1,
+                        },
+                    };
+                }
+                return {
+                    forwardSql: sql,
+                    summary: {
+                        addedIndexes: 1,
+                    },
+                };
+            }
+            if (oldIndex && !newIndex) {
+                if (isLargeTable && !oldIndex.config?.unique) {
+                    const onlineSql = buildDropIndexSql(tableName, table, oldIndex, {
+                        concurrently: true,
+                    });
+                    return {
+                        onlineSql,
+                        warnings: [
+                            makeLargeTableIndexWarning(`大表删除索引「${oldIndex.name}」已切换为在线删除`, onlineSql),
+                        ],
+                        summary: {
+                            removedIndexes: 1,
+                            onlineActions: 1,
+                            largeTableIndexes: 1,
+                        },
+                    };
+                }
+                return {
+                    backwardSql: buildDropIndexSql(tableName, table, oldIndex),
+                    summary: {
+                        removedIndexes: 1,
+                    },
+                };
+            }
+            const dropSql = buildDropIndexSql(tableName, table, oldIndex);
+            const createSql = buildIndexSql(tableName, table, newIndex);
+            if (isLargeTable) {
+                const manualSql = [
+                    ...buildDropIndexSql(tableName, table, oldIndex, {
+                        concurrently: true,
+                    }),
+                    ...buildIndexSql(tableName, table, newIndex, {
+                        concurrently: true,
+                    }),
+                ];
+                return {
+                    manualSql,
+                    warnings: [
+                        makeLargeTableIndexWarning(`大表重建索引「${oldIndex.name}」可能导致长时间索引维护，已转为人工确认`, manualSql),
+                    ],
+                    summary: {
+                        changedIndexes: 1,
+                        manualActions: 1,
+                        largeTableIndexes: 1,
+                    },
+                };
+            }
+            if (oldIndex?.config?.unique || newIndex?.config?.unique) {
+                return {
+                    manualSql: [...dropSql, ...createSql],
+                    warnings: [
+                        makeWarning('manual-index-change', `索引「${oldIndex.name}」包含唯一性变化，需要确认历史数据后再重建`, tableName, undefined, [...dropSql, ...createSql]),
+                    ],
+                    summary: {
+                        changedIndexes: 1,
+                        manualActions: 1,
+                    },
+                };
+            }
+            return {
+                forwardSql: [...dropSql, ...createSql],
+                summary: {
+                    changedIndexes: 1,
+                },
+            };
+        },
+        buildRenameIndexPlan(tableName, table, oldIndex, newIndex) {
+            const oldPhysicalNames = (0, indexInspection_1.getIndexOriginNames)(oldIndex);
+            const newPhysicalNames = getExpectedPhysicalIndexNames(tableName, table, newIndex);
+            if (oldPhysicalNames.length !== 1 || newPhysicalNames.length !== 1) {
+                return {};
+            }
+            if (oldPhysicalNames[0] === newPhysicalNames[0]) {
+                return {};
+            }
+            return {
+                forwardSql: [
+                    `ALTER INDEX ${quote(oldPhysicalNames[0])} RENAME TO ${quote(newPhysicalNames[0])};`,
+                ],
+                backwardSql: [
+                    `ALTER INDEX ${quote(newPhysicalNames[0])} RENAME TO ${quote(oldPhysicalNames[0])};`,
+                ],
+                summary: {
+                    changedIndexes: 1,
+                },
+            };
+        },
+        buildForeignKeyPlan(tableName, oldForeignKey, newForeignKey, isNewTable) {
+            if (!oldForeignKey && newForeignKey) {
+                const sql = `ALTER TABLE ${quote(tableName)} ADD CONSTRAINT ${quote(newForeignKey.name)} FOREIGN KEY (${quote(newForeignKey.column)}) REFERENCES ${quote(newForeignKey.refTable)} (${quote(newForeignKey.refColumn)}) ON DELETE ${getOnDeleteSql(newForeignKey.onDelete)};`;
+                if (isNewTable) {
+                    return {
+                        forwardSql: [sql],
+                        summary: {
+                            addedForeignKeys: 1,
+                        },
+                    };
+                }
+                return {
+                    manualSql: [sql],
+                    warnings: [
+                        makeWarning('manual-foreign-key-change', `新增外键「${newForeignKey.name}」前需要确认历史数据引用完整`, tableName, newForeignKey.column, [sql]),
+                    ],
+                    summary: {
+                        addedForeignKeys: 1,
+                        manualActions: 1,
+                    },
+                };
+            }
+            if (oldForeignKey && !newForeignKey) {
+                return {
+                    backwardSql: [
+                        `ALTER TABLE ${quote(tableName)} DROP CONSTRAINT IF EXISTS ${quote(oldForeignKey.name)};`,
+                    ],
+                    summary: {
+                        removedForeignKeys: 1,
+                    },
+                };
+            }
+            const dropSql = `ALTER TABLE ${quote(tableName)} DROP CONSTRAINT IF EXISTS ${quote(oldForeignKey.name)};`;
+            const createSql = `ALTER TABLE ${quote(tableName)} ADD CONSTRAINT ${quote(newForeignKey.name)} FOREIGN KEY (${quote(newForeignKey.column)}) REFERENCES ${quote(newForeignKey.refTable)} (${quote(newForeignKey.refColumn)}) ON DELETE ${getOnDeleteSql(newForeignKey.onDelete)};`;
+            return {
+                manualSql: [dropSql, createSql],
+                warnings: [
+                    makeWarning('manual-foreign-key-change', `外键「${oldForeignKey.name}」发生变化，需要确认数据后再重建`, tableName, newForeignKey.column, [dropSql, createSql]),
+                ],
+                summary: {
+                    changedForeignKeys: 1,
+                    manualActions: 1,
+                },
+            };
+        },
+        getForeignKeys(table, tableDef, fullSchema) {
+            const tableName = getTableName(table, tableDef);
+            const foreignKeys = {};
+            Object.keys(tableDef.attributes || {}).forEach((column) => {
+                const attr = tableDef.attributes[column];
+                if (attr.type !== 'ref' || Array.isArray(attr.ref) || !attr.ref) {
+                    return;
+                }
+                const refTableDef = fullSchema[attr.ref];
+                const refTable = refTableDef ? getTableName(attr.ref, refTableDef) : attr.ref;
+                const foreignKey = {
+                    name: getForeignKeyName(tableName, column),
+                    column,
+                    refTable,
+                    refColumn: 'id',
+                    onDelete: attr.onRefDelete === 'delete'
+                        ? 'cascade'
+                        : (attr.onRefDelete === 'setNull' ? 'set null' : 'no action'),
+                };
+                foreignKeys[foreignKey.name] = foreignKey;
+            });
+            return foreignKeys;
+        },
+    };
+}
+function parseDefaultValue(value, attr) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        let trimmed = value.trim();
+        const stringLiteralMatch = trimmed.match(/^(?:E)?'((?:''|[^'])*)'(?:\s*::[\w\s".\[\]]+)?$/s);
+        if (stringLiteralMatch) {
+            trimmed = stringLiteralMatch[1];
+        }
+        else {
+            const castPattern = /\s*::[\w\s".\[\]]+$/;
+            while (castPattern.test(trimmed)) {
+                trimmed = trimmed.replace(castPattern, '').trim();
+            }
+            while (trimmed.startsWith('(') && trimmed.endsWith(')')) {
+                trimmed = trimmed.slice(1, -1).trim();
+            }
+            if (/^e'[\s\S]*'$/i.test(trimmed)) {
+                trimmed = trimmed.slice(2, -1);
+            }
+            else if (/^'(.*)'$/s.test(trimmed)) {
+                trimmed = trimmed.slice(1, -1);
+            }
+        }
+        trimmed = trimmed.replace(/''/g, "'");
+        if (trimmed === '') {
+            return '';
+        }
+        if (trimmed === 'true') {
+            return true;
+        }
+        if (trimmed === 'false') {
+            return false;
+        }
+        if ((attr.type === 'object' || attr.type === 'array')
+            && /^[\[{]/.test(trimmed)) {
+            try {
+                return JSON.parse(trimmed);
+            }
+            catch (err) {
+            }
+        }
+        if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+            return Number(trimmed);
+        }
+        return trimmed;
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return value;
+    }
+    return String(value);
+}
+function getFullTextSuffixes(index) {
+    if (index.config?.type !== 'fulltext') {
+        return [''];
+    }
+    const tsConfigs = Array.isArray(index.config?.tsConfig)
+        ? index.config.tsConfig
+        : [index.config?.tsConfig || 'simple'];
+    if (tsConfigs.length <= 1) {
+        return [''];
+    }
+    return tsConfigs.map((tsConfig) => `_${tsConfig}`);
+}
+function findMatchingPostgreSqlIndexHint(translator, entityName, tableName, actualIndexName, indexes) {
+    return (indexes || []).find((candidate) => getFullTextSuffixes(candidate).some((suffix) => translator.getLegacyPhysicalIndexNames(entityName, tableName, candidate.name, suffix).includes(actualIndexName)));
+}
+const postgreSqlAttributeHintRules = [
+    {
+        actualTypes: ['bigint'],
+        semanticTypes: ['date', 'time', 'datetime', 'money'],
+    },
+    {
+        actualTypes: ['object'],
+        semanticTypes: ['array'],
+    },
+    {
+        actualTypes: ['boolean'],
+        semanticTypes: ['bool'],
+    },
+    {
+        actualTypes: ['text'],
+        semanticTypes: ['image', 'function'],
+    },
+];
+function normalizePostgreSqlTextArray(value) {
+    if (!value) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (trimmed === '{}' || trimmed === '') {
+        return [];
+    }
+    const body = trimmed.startsWith('{') && trimmed.endsWith('}')
+        ? trimmed.slice(1, -1)
+        : trimmed;
+    if (!body) {
+        return [];
+    }
+    return body.split(',').map((item) => item.replace(/^"(.*)"$/, '$1').replace(/\\"/g, '"'));
+}
+function mapPostgreSqlIndexAttributes(index) {
+    const columnNames = normalizePostgreSqlTextArray(index.column_names);
+    const columnDirections = normalizePostgreSqlTextArray(index.column_directions);
+    return columnNames.map((name, indexPosition) => ({
+        name,
+        direction: columnDirections[indexPosition] || 'ASC',
+    }));
+}
+async function readPostgreSqlSchema(connector, translator) {
+    const inspection = await inspectPostgreSqlSchema(connector, translator);
+    return inspection.schema;
+}
+async function inspectPostgreSqlSchema(connector, translator) {
+    const result = {};
+    const tableStats = {};
+    const tableHints = (0, inspection_1.buildTargetTableHintMap)(translator.schema);
+    const [tables] = await connector.exec(`
+        SELECT
+            t.tablename,
+            c.reltuples::bigint AS estimated_rows
+        FROM pg_tables t
+        LEFT JOIN pg_class c
+            ON c.relname = t.tablename
+        WHERE t.schemaname = 'public'
+        ORDER BY tablename;
+    `);
+    for (const tableRow of tables) {
+        const tableName = tableRow.tablename;
+        const tableHintEntry = tableHints.get(tableName);
+        const tableHint = tableHintEntry?.tableDef;
+        const tableKey = tableHintEntry?.key || tableName;
+        const estimatedRows = tableRow.estimated_rows === null || tableRow.estimated_rows === undefined
+            ? undefined
+            : Number(tableRow.estimated_rows);
+        const [columns] = await connector.exec(`
+            SELECT
+                column_name,
+                data_type,
+                character_maximum_length,
+                numeric_precision,
+                numeric_scale,
+                is_nullable,
+                column_default,
+                udt_name,
+                is_identity
+            FROM information_schema.columns
+            WHERE table_schema = 'public'
+                AND table_name = '${tableName}'
+            ORDER BY ordinal_position;
+        `);
+        const attributes = {};
+        for (const column of columns) {
+            let attr;
+            const attributeHint = tableHint?.attributes?.[column.column_name];
+            if (column.data_type === 'USER-DEFINED') {
+                if (column.udt_name === 'geometry' || attributeHint?.type === 'geometry') {
+                    attr = {
+                        type: 'geometry',
+                    };
+                }
+                else if (column.udt_name === 'geography' || attributeHint?.type === 'geography') {
+                    attr = {
+                        type: 'geography',
+                    };
+                }
+                else {
+                    const [enumValues] = await connector.exec(`
+                        SELECT e.enumlabel
+                        FROM pg_type t
+                        JOIN pg_enum e ON e.enumtypid = t.oid
+                        WHERE t.typname = '${column.udt_name}'
+                        ORDER BY e.enumsortorder;
+                    `);
+                    attr = {
+                        type: 'enum',
+                        enumeration: enumValues.map((item) => item.enumlabel),
+                    };
+                }
+            }
+            else {
+                let fullType = column.data_type;
+                const integerTypes = ['bigint', 'integer', 'smallint'];
+                if (column.character_maximum_length && !integerTypes.includes(column.data_type)) {
+                    fullType = `${column.data_type}(${column.character_maximum_length})`;
+                }
+                else if (column.numeric_precision !== null && column.numeric_scale !== null && !integerTypes.includes(column.data_type)) {
+                    fullType = `${column.data_type}(${column.numeric_precision},${column.numeric_scale})`;
+                }
+                else if (column.numeric_precision !== null && !integerTypes.includes(column.data_type)) {
+                    fullType = `${column.data_type}(${column.numeric_precision})`;
+                }
+                attr = translator.reTranslateToAttribute(fullType);
+            }
+            attr = (0, inspection_1.applyInspectionAttributeHint)(attr, attributeHint, postgreSqlAttributeHintRules);
+            attr = (0, inspection_1.applyOakManagedAttributeFallback)(attr, column.column_name, attributeHint);
+            if (column.is_identity === 'YES' || column.column_name === '$$seq$$' || column.column_default?.includes('nextval')) {
+                attr.type = 'sequence';
+                attr.sequenceStart = 10000;
+            }
+            attr.notNull = attr.type === 'sequence' ? false : column.is_nullable === 'NO';
+            const defaultValue = parseDefaultValue(column.column_default, attr);
+            if (defaultValue !== undefined && attr.type !== 'sequence') {
+                attr.default = defaultValue;
+            }
+            attributes[column.column_name] = attr;
+        }
+        if (!(0, inspection_1.isOakManagedTable)(attributes, !!tableHint)) {
+            continue;
+        }
+        tableStats[tableName] = {
+            rowCount: Number.isFinite(estimatedRows) ? estimatedRows : undefined,
+            approximate: true,
+        };
+        const [foreignKeys] = await connector.exec(`
+            SELECT
+                tc.constraint_name,
+                kcu.column_name,
+                ccu.table_name AS referenced_table_name,
+                ccu.column_name AS referenced_column_name,
+                rc.delete_rule
+            FROM information_schema.table_constraints tc
+            JOIN information_schema.key_column_usage kcu
+                ON tc.constraint_name = kcu.constraint_name
+                AND tc.table_schema = kcu.table_schema
+            JOIN information_schema.constraint_column_usage ccu
+                ON tc.constraint_name = ccu.constraint_name
+                AND tc.table_schema = ccu.table_schema
+            JOIN information_schema.referential_constraints rc
+                ON tc.constraint_name = rc.constraint_name
+                AND tc.table_schema = rc.constraint_schema
+            WHERE tc.constraint_type = 'FOREIGN KEY'
+                AND tc.table_schema = 'public'
+                AND tc.table_name = '${tableName}';
+        `);
+        for (const foreignKey of foreignKeys) {
+            const attr = attributes[foreignKey.column_name];
+            if (!attr) {
+                continue;
+            }
+            attr.type = 'ref';
+            attr.ref = foreignKey.referenced_table_name;
+            switch (mapOnDeleteRule(foreignKey.delete_rule)) {
+                case 'cascade':
+                    attr.onRefDelete = 'delete';
+                    break;
+                case 'set null':
+                    attr.onRefDelete = 'setNull';
+                    break;
+                default:
+                    attr.onRefDelete = 'ignore';
+            }
+        }
+        const [indexes] = await connector.exec(`
+            SELECT
+                i.relname AS index_name,
+                ix.indisunique AS is_unique,
+                am.amname AS index_type,
+                pg_get_indexdef(ix.indexrelid) AS index_def,
+                COALESCE(
+                    array_agg(att.attname ORDER BY ord.ordinality)
+                    FILTER (WHERE att.attname IS NOT NULL),
+                    ARRAY[]::text[]
+                ) AS column_names,
+                COALESCE(
+                    array_agg(
+                        CASE
+                            WHEN pg_index_column_has_property(ix.indexrelid, ord.ordinality::int, 'desc')
+                                THEN 'DESC'
+                            ELSE 'ASC'
+                        END
+                        ORDER BY ord.ordinality
+                    ) FILTER (WHERE att.attname IS NOT NULL),
+                    ARRAY[]::text[]
+                ) AS column_directions
+            FROM pg_class t
+            JOIN pg_index ix ON t.oid = ix.indrelid
+            JOIN pg_class i ON i.oid = ix.indexrelid
+            JOIN pg_am am ON am.oid = i.relam
+            LEFT JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS ord(attnum, ordinality)
+                ON TRUE
+            LEFT JOIN pg_attribute att
+                ON att.attrelid = t.oid
+                AND att.attnum = ord.attnum
+            WHERE t.relname = '${tableName}'
+                AND t.relkind = 'r'
+                AND NOT ix.indisprimary
+            GROUP BY i.relname, ix.indexrelid, ix.indisunique, am.amname
+            ORDER BY i.relname;
+        `);
+        const indexDict = {};
+        for (const index of indexes) {
+            const targetIndexHint = findMatchingPostgreSqlIndexHint(translator, tableKey, tableName, index.index_name, tableHint?.indexes);
+            if (index.index_type === 'gin' && index.index_def.includes('to_tsvector')) {
+                const tsConfigMatch = index.index_def.match(/to_tsvector\('([^']+)'/);
+                const tsConfig = tsConfigMatch?.[1] || 'simple';
+                const columns = Array.from(index.index_def.matchAll(/COALESCE\(\s*(?:"([^"]+)"|([A-Za-z0-9_$]+))/g)).map((item) => item[1] || item[2]).filter(Boolean);
+                let logicalName = targetIndexHint?.name || index.index_name;
+                if (!targetIndexHint && logicalName.startsWith(`${tableName}_`)) {
+                    logicalName = logicalName.slice(tableName.length + 1);
+                }
+                if (!targetIndexHint && logicalName.endsWith(`_${tsConfig}`)) {
+                    logicalName = logicalName.slice(0, -(`_${tsConfig}`.length));
+                }
+                const existed = indexDict[logicalName];
+                if (existed) {
+                    const currentTsConfig = existed.config?.tsConfig;
+                    const tsConfigs = Array.isArray(currentTsConfig)
+                        ? currentTsConfig
+                        : (currentTsConfig ? [currentTsConfig] : []);
+                    if (!tsConfigs.includes(tsConfig)) {
+                        existed.config = {
+                            ...existed.config,
+                            tsConfig: [...tsConfigs, tsConfig].sort(),
+                        };
+                    }
+                    const originNames = existed.__originNames || [];
+                    if (!originNames.includes(index.index_name)) {
+                        existed.__originNames = [
+                            ...originNames,
+                            index.index_name,
+                        ];
+                    }
+                }
+                else {
+                    indexDict[logicalName] = {
+                        name: logicalName,
+                        attributes: (targetIndexHint?.config?.type === 'fulltext'
+                            ? targetIndexHint.attributes
+                            : columns.map((name) => ({
+                                name,
+                            }))).map((attribute) => ({
+                            ...attribute,
+                        })),
+                        config: targetIndexHint?.config?.type === 'fulltext'
+                            ? {
+                                ...targetIndexHint.config,
+                            }
+                            : {
+                                type: 'fulltext',
+                                tsConfig,
+                            },
+                    };
+                    indexDict[logicalName].__originNames = [index.index_name];
+                }
+                continue;
+            }
+            const logicalName = targetIndexHint?.name || (index.index_name.startsWith(`${tableName}_`)
+                ? index.index_name.slice(tableName.length + 1)
+                : index.index_name);
+            const attributes2 = mapPostgreSqlIndexAttributes(index);
+            if (index.is_unique && attributes2.length === 1) {
+                const attr = attributes[attributes2[0].name];
+                if (attr) {
+                    attr.unique = true;
+                    continue;
+                }
+            }
+            const inspectedIndex = {
+                name: logicalName,
+                attributes: attributes2,
+                config: {
+                    unique: index.is_unique,
+                    type: mapPostgreSqlIndexType(index.index_type),
+                },
+            };
+            inspectedIndex.__originName = index.index_name;
+            const existed = indexDict[logicalName];
+            if (existed && (0, indexInspection_1.areEquivalentInspectedIndexes)(existed, inspectedIndex)) {
+                (0, indexInspection_1.mergeIndexOriginName)(existed, index.index_name);
+                continue;
+            }
+            indexDict[logicalName] = inspectedIndex;
+        }
+        const inspectedTableDef = {
+            ...(tableHint || {
+                actions: [],
+                actionType: 'crud',
+            }),
+            attributes,
+            indexes: Object.keys(indexDict).length ? Object.values(indexDict) : undefined,
+        };
+        result[tableKey] = inspectedTableDef;
+    }
+    return {
+        schema: result,
+        tableStats,
+    };
+}
+function buildPostgreSqlMigrationPlan(currentSchema, targetSchema, translator, options) {
+    return (0, migration_1.buildMigrationPlan)(currentSchema, targetSchema, createPgAdapter(translator), options);
+}