oak-db 3.3.13 → 4.0.0

package/lib/MySQL/migration.js

@@ -0,0 +1,649 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readMySqlSchema = readMySqlSchema;
+exports.inspectMySqlSchema = inspectMySqlSchema;
+exports.buildMySqlMigrationPlan = buildMySqlMigrationPlan;
+const migration_1 = require("../migration");
+const inspection_1 = require("../utils/inspection");
+const indexInspection_1 = require("../utils/indexInspection");
+function parseDefaultValue(value, attr) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    if (attr.type === 'bool' || attr.type === 'boolean') {
+        if (value === '1' || value === 1) {
+            return true;
+        }
+        if (value === '0' || value === 0) {
+            return false;
+        }
+    }
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return '';
+        }
+        if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+            return Number(trimmed);
+        }
+        return trimmed;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    return String(value);
+}
+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 normalizeMySqlRow(row) {
+    const normalized = {};
+    Object.keys(row).forEach((key) => {
+        normalized[key.toLowerCase()] = row[key];
+    });
+    return normalized;
+}
+function mapMySqlIndexType(indexType) {
+    switch (indexType.toLowerCase()) {
+        case 'hash':
+            return 'hash';
+        case 'fulltext':
+            return 'fulltext';
+        case 'spatial':
+        case 'rtree':
+            return 'spatial';
+        default:
+            return 'btree';
+    }
+}
+function findMatchingMySqlIndexHint(translator, entityName, tableName, actualIndexName, indexes) {
+    return (indexes || []).find((candidate) => translator.getLegacyPhysicalIndexNames(entityName, tableName, candidate.name).includes(actualIndexName));
+}
+const mySqlAttributeHintRules = [
+    {
+        actualTypes: ['bigint'],
+        semanticTypes: ['date', 'time', 'datetime', 'money'],
+    },
+    {
+        actualTypes: ['json'],
+        semanticTypes: ['object', 'array'],
+    },
+    {
+        actualTypes: ['tinyint(1)'],
+        semanticTypes: ['bool', 'boolean'],
+    },
+    {
+        actualTypes: ['text'],
+        semanticTypes: ['image', 'function'],
+    },
+];
+function createMySqlAdapter(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 buildIndexSql = (tableName, table, index) => {
+        const physicalName = translator.getPhysicalIndexName(table, tableName, index.name);
+        const sqlParts = [`ALTER TABLE ${quote(tableName)} ADD `];
+        if (index.config?.unique) {
+            sqlParts.push('UNIQUE ');
+        }
+        else if (index.config?.type === 'fulltext') {
+            sqlParts.push('FULLTEXT ');
+        }
+        else if (index.config?.type === 'spatial') {
+            sqlParts.push('SPATIAL ');
+        }
+        sqlParts.push(`INDEX ${quote(physicalName)} `);
+        if (index.config?.type === 'hash') {
+            sqlParts.push('USING HASH ');
+        }
+        sqlParts.push('(');
+        sqlParts.push(index.attributes.map(({ name, size, direction }) => {
+            let fragment = quote(String(name));
+            if (size) {
+                fragment += ` (${size})`;
+            }
+            if (direction) {
+                fragment += ` ${direction}`;
+            }
+            return fragment;
+        }).join(', '));
+        sqlParts.push(')');
+        if (index.config?.parser) {
+            sqlParts.push(` WITH PARSER ${index.config.parser}`);
+        }
+        sqlParts.push(';');
+        return sqlParts.join('');
+    };
+    const getExpectedPhysicalIndexName = (tableName, table, index) => translator.getPhysicalIndexName(table, tableName, index.name);
+    return {
+        dialect: 'mysql',
+        normalizeIdentifier(name) {
+            return name.toLowerCase();
+        },
+        getTableName,
+        buildPrepareSql() {
+            return [];
+        },
+        buildNewTablePlan(table, tableDef) {
+            const tableName = getTableName(table, tableDef);
+            const sql = translator.translateCreateEntity(table, {
+                ifExists: 'omit',
+            });
+            const foreignKeys = this.getForeignKeys(table, tableDef, translator.schema);
+            return {
+                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)};`,
+                ],
+                summary: {
+                    removedTables: 1,
+                },
+            };
+        },
+        buildRenamePlan(tableName, from, to, oldAttr, newAttr) {
+            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 sql = `ALTER TABLE ${quote(tableName)} ADD COLUMN ${translator.translateColumnDefinition(tableName, column, newAttr)};`;
+                if (classification.mode === 'manual') {
+                    return {
+                        manualSql: [sql],
+                        warnings: [
+                            makeWarning('manual-column-change', classification.reason || `新增字段「${column}」需要人工确认`, tableName, column, [sql]),
+                        ],
+                        summary: {
+                            addedColumns: 1,
+                            manualActions: 1,
+                        },
+                    };
+                }
+                return {
+                    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 {};
+            }
+            const sql = `ALTER TABLE ${quote(tableName)} MODIFY COLUMN ${translator.translateColumnDefinition(tableName, column, 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 oldPhysicalNames = oldIndex
+                ? (0, indexInspection_1.getIndexOriginNames)(oldIndex)
+                : [];
+            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) {
+                    return {
+                        manualSql: [sql],
+                        warnings: [
+                            makeLargeTableIndexWarning(`MySQL 大表新增索引「${newIndex.name}」已转为人工确认，避免自动 DDL 造成长时间锁表或性能抖动`, [sql]),
+                        ],
+                        summary: {
+                            addedIndexes: 1,
+                            manualActions: 1,
+                            largeTableIndexes: 1,
+                        },
+                    };
+                }
+                return {
+                    forwardSql: [sql],
+                    summary: {
+                        addedIndexes: 1,
+                    },
+                };
+            }
+            if (oldIndex && !newIndex) {
+                const dropSql = oldPhysicalNames.map((physicalName) => `ALTER TABLE ${quote(tableName)} DROP INDEX ${quote(physicalName)};`);
+                if (isLargeTable) {
+                    return {
+                        manualSql: dropSql,
+                        warnings: [
+                            makeLargeTableIndexWarning(`MySQL 大表删除索引「${oldIndex.name}」已转为人工确认`, dropSql),
+                        ],
+                        summary: {
+                            removedIndexes: 1,
+                            manualActions: 1,
+                            largeTableIndexes: 1,
+                        },
+                    };
+                }
+                return {
+                    backwardSql: dropSql,
+                    summary: {
+                        removedIndexes: 1,
+                    },
+                };
+            }
+            const dropSql = oldPhysicalNames.map((physicalName) => `ALTER TABLE ${quote(tableName)} DROP INDEX ${quote(physicalName)};`);
+            const createSql = buildIndexSql(tableName, table, newIndex);
+            if (isLargeTable) {
+                return {
+                    manualSql: [...dropSql, createSql],
+                    warnings: [
+                        makeLargeTableIndexWarning(`MySQL 大表重建索引「${oldIndex.name}」已转为人工确认`, [...dropSql, createSql]),
+                    ],
+                    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 acceptedPhysicalNames = translator.getLegacyPhysicalIndexNames(table, tableName, newIndex.name);
+            const newPhysicalName = getExpectedPhysicalIndexName(tableName, table, newIndex);
+            if (oldPhysicalNames.some((physicalName) => physicalName === newPhysicalName
+                || acceptedPhysicalNames.includes(physicalName))) {
+                return {};
+            }
+            if (oldPhysicalNames.length !== 1) {
+                return {};
+            }
+            const [oldPhysicalName] = oldPhysicalNames;
+            if (oldPhysicalName === newPhysicalName
+                || acceptedPhysicalNames.includes(oldPhysicalName)) {
+                return {};
+            }
+            return {
+                forwardSql: [
+                    `ALTER TABLE ${quote(tableName)} RENAME INDEX ${quote(oldPhysicalName)} TO ${quote(newPhysicalName)};`,
+                ],
+                backwardSql: [
+                    `ALTER TABLE ${quote(tableName)} RENAME INDEX ${quote(newPhysicalName)} TO ${quote(oldPhysicalName)};`,
+                ],
+                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 FOREIGN KEY ${quote(oldForeignKey.name)};`,
+                    ],
+                    summary: {
+                        removedForeignKeys: 1,
+                    },
+                };
+            }
+            const dropSql = `ALTER TABLE ${quote(tableName)} DROP FOREIGN KEY ${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;
+        },
+    };
+}
+async function readMySqlSchema(connector, translator) {
+    const inspection = await inspectMySqlSchema(connector, translator);
+    return inspection.schema;
+}
+async function inspectMySqlSchema(connector, translator) {
+    const database = connector.configuration.database;
+    const result = {};
+    const tableStats = {};
+    const tableHints = (0, inspection_1.buildTargetTableHintMap)(translator.schema);
+    const [tables] = await connector.exec(`
+        SELECT table_name, table_rows
+        FROM information_schema.tables
+        WHERE table_schema = '${database}'
+            AND table_type = 'BASE TABLE'
+        ORDER BY table_name;
+    `);
+    for (const rawTableRow of tables) {
+        const tableRow = normalizeMySqlRow(rawTableRow);
+        const tableName = tableRow.table_name;
+        const tableHintEntry = tableHints.get(tableName);
+        const tableHint = tableHintEntry?.tableDef;
+        const tableKey = tableHintEntry?.key || tableName;
+        const [columns] = await connector.exec(`
+            SELECT
+                column_name,
+                column_type,
+                is_nullable,
+                column_default,
+                extra
+            FROM information_schema.columns
+            WHERE table_schema = '${database}'
+                AND table_name = '${tableName}'
+            ORDER BY ordinal_position;
+        `);
+        const attributes = {};
+        for (const rawColumn of columns) {
+            const column = normalizeMySqlRow(rawColumn);
+            const attributeHint = tableHint?.attributes?.[column.column_name];
+            let attr = (0, inspection_1.applyInspectionAttributeHint)(translator.reTranslateToAttribute(column.column_type), attributeHint, mySqlAttributeHintRules);
+            attr = (0, inspection_1.applyOakManagedAttributeFallback)(attr, column.column_name, attributeHint);
+            if (column.column_name === '$$seq$$' || column.extra.toLowerCase().includes('auto_increment')) {
+                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;
+        }
+        // inspection 会先尽量恢复字段/索引语义，但只有 Oak 托管表才进入 planner。
+        // 这样可以把业务库里的外部表隔离在迁移系统之外，避免误报“待删除表”。
+        if (!(0, inspection_1.isOakManagedTable)(attributes, !!tableHint)) {
+            continue;
+        }
+        tableStats[tableName] = {
+            rowCount: tableRow.table_rows === null || tableRow.table_rows === undefined
+                ? undefined
+                : Number(tableRow.table_rows),
+            approximate: true,
+        };
+        const [indexes] = await connector.exec(`
+            SELECT
+                index_name,
+                non_unique,
+                seq_in_index,
+                column_name,
+                index_type,
+                collation,
+                sub_part
+            FROM information_schema.statistics
+            WHERE table_schema = '${database}'
+                AND table_name = '${tableName}'
+            ORDER BY index_name, seq_in_index;
+        `);
+        const indexDict = {};
+        for (const rawIndexRow of indexes) {
+            const indexRow = normalizeMySqlRow(rawIndexRow);
+            if (indexRow.index_name === 'PRIMARY') {
+                continue;
+            }
+            if (!indexDict[indexRow.index_name]) {
+                indexDict[indexRow.index_name] = [];
+            }
+            indexDict[indexRow.index_name].push(indexRow);
+        }
+        const indexList = [];
+        Object.keys(indexDict).forEach((indexName) => {
+            const group = indexDict[indexName];
+            if (group.length === 1 && group[0].non_unique === 0) {
+                const columnName = group[0].column_name;
+                if (attributes[columnName]) {
+                    attributes[columnName].unique = true;
+                    return;
+                }
+            }
+            const index = {
+                name: indexName,
+                attributes: group.map((item) => ({
+                    name: item.column_name,
+                    direction: item.collation === 'D' ? 'DESC' : (item.collation === 'A' ? 'ASC' : undefined),
+                    size: item.sub_part || undefined,
+                })),
+            };
+            const indexType = group[0].index_type.toLowerCase();
+            const targetIndexHint = findMatchingMySqlIndexHint(translator, tableKey, tableName, indexName, tableHint?.indexes);
+            if (targetIndexHint) {
+                // 真实库里可能同时残留 long name / compact name / 服务端截断名。
+                // 这里借助目标 schema 的 hint，把它们折叠回同一个逻辑索引来源。
+                index.name = targetIndexHint.name;
+            }
+            if (targetIndexHint && ['fulltext', 'spatial'].includes(indexType)) {
+                index.attributes = targetIndexHint.attributes.map((attribute) => ({
+                    ...attribute,
+                }));
+            }
+            if (group[0].non_unique === 0 || indexType !== 'btree') {
+                index.config = targetIndexHint && ['fulltext', 'spatial'].includes(indexType)
+                    ? {
+                        ...targetIndexHint.config,
+                    }
+                    : {
+                        unique: group[0].non_unique === 0,
+                        type: mapMySqlIndexType(indexType),
+                    };
+            }
+            index.__originName = indexName;
+            const existed = indexList.find((candidate) => candidate.name === index.name
+                && (0, indexInspection_1.areEquivalentInspectedIndexes)(candidate, index));
+            if (existed) {
+                // 如果同一个逻辑索引在库里留下了多个历史物理名，
+                // 合并 origin name，后续 diff 就不会把它误判成重复 drop/create 或 rename。
+                (0, indexInspection_1.mergeIndexOriginName)(existed, indexName);
+                return;
+            }
+            indexList.push(index);
+        });
+        // FK 单独读取并回填到 attribute 上，而不是只信 column_type。
+        // 对老 MySQL 库来说，char(36) 是否应当当成 ref，要看物理 FK 是否真的存在。
+        const [foreignKeys] = await connector.exec(`
+            SELECT
+                kcu.constraint_name,
+                kcu.column_name,
+                kcu.referenced_table_name,
+                kcu.referenced_column_name,
+                rc.delete_rule
+            FROM information_schema.key_column_usage kcu
+            JOIN information_schema.referential_constraints rc
+                ON rc.constraint_schema = kcu.constraint_schema
+                AND rc.constraint_name = kcu.constraint_name
+            WHERE kcu.table_schema = '${database}'
+                AND kcu.table_name = '${tableName}'
+                AND kcu.referenced_table_name IS NOT NULL;
+        `);
+        for (const rawForeignKey of foreignKeys) {
+            const foreignKey = normalizeMySqlRow(rawForeignKey);
+            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 inspectedTableDef = {
+            ...(tableHint || {
+                actions: [],
+                actionType: 'crud',
+            }),
+            attributes,
+            indexes: indexList.length ? indexList : undefined,
+        };
+        result[tableKey] = inspectedTableDef;
+    }
+    return {
+        schema: result,
+        tableStats,
+    };
+}
+function buildMySqlMigrationPlan(currentSchema, targetSchema, translator, options) {
+    return (0, migration_1.buildMigrationPlan)(currentSchema, targetSchema, createMySqlAdapter(translator), options);
+}