knight-server 1.0.0

package/utility/DatabaseUtility.js

@@ -0,0 +1,903 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseUtility = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** 数据库工具 */
+var DatabaseUtility;
+(function (DatabaseUtility) {
+    /** 智能表格 — 从 SQL 文件自动同步数据库表结构 */
+    class SmartTable {
+        constructor(pool) {
+            this.pool = pool;
+        }
+        // ==================== 核心方法 ====================
+        /**
+         * 自动同步目录下的所有 SQL 文件
+         * @param relativePath SQL文件所在目录相对项目根目录的路径
+         * @param options 同步选项
+         * @param fileFilter 文件过滤函数（可选），返回 true 表示需要处理
+         */
+        async syncAllFromDir(relativePath, options = {}, fileFilter) {
+            const projectRoot = path.resolve(__dirname, "../../");
+            const sqlDir = path.join(projectRoot, relativePath);
+            const results = new Map();
+            const failed = [];
+            try {
+                if (!fs.existsSync(sqlDir)) {
+                    return {
+                        success: false,
+                        results,
+                        failed,
+                        message: `SQL目录不存在: ${sqlDir}`
+                    };
+                }
+                const files = fs.readdirSync(sqlDir).filter(file => file.toLowerCase().endsWith('.sql'));
+                if (files.length === 0) {
+                    return {
+                        success: true,
+                        results,
+                        failed,
+                        message: `目录中没有找到 SQL 文件: ${sqlDir}`
+                    };
+                }
+                const sortedFiles = await this.sortFilesByDependency(sqlDir, files);
+                console.log(`🔍 找到 ${sortedFiles.length} 个 SQL 文件，按依赖顺序同步...`);
+                for (const file of sortedFiles) {
+                    if (fileFilter && !fileFilter(file)) {
+                        console.log(`⏭️ 跳过文件: ${file}`);
+                        continue;
+                    }
+                    const filePath = path.join(sqlDir, file);
+                    console.log(`📄 正在处理: ${file}`);
+                    try {
+                        const result = await this.syncTableFromSql(filePath, options);
+                        results.set(file, result);
+                        if (result.success) {
+                            const actionEmoji = result.action === 'CREATE' ? '🆕' :
+                                result.action === 'ALTER' ? '📝' :
+                                    result.action === 'NONE' ? '✅' : '➖';
+                            console.log(`  ${actionEmoji} ${result.message}`);
+                            if (!options.execute && result.statements) {
+                                console.log(`  需要执行 ${result.statements.length} 条语句`);
+                            }
+                        }
+                        else {
+                            failed.push(file);
+                            console.error(`  ❌ 处理失败: ${result.error}`);
+                        }
+                    }
+                    catch (error) {
+                        failed.push(file);
+                        const errorMsg = error instanceof Error ? error.message : String(error);
+                        console.error(`  💥 处理异常: ${errorMsg}`);
+                        results.set(file, {
+                            success: false,
+                            error: errorMsg
+                        });
+                    }
+                }
+                const successCount = results.size - failed.length;
+                const message = failed.length === 0
+                    ? `✅ 所有 SQL 文件处理完成，成功 ${successCount} 个`
+                    : `⚠️ 处理完成，成功 ${successCount} 个，失败 ${failed.length} 个`;
+                console.log(`${message}`);
+                if (failed.length > 0) {
+                    console.log('❌ 失败的文件:', failed.join(', '));
+                }
+                return {
+                    success: failed.length === 0,
+                    results,
+                    failed,
+                    message
+                };
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                return {
+                    success: false,
+                    results,
+                    failed,
+                    message: `处理过程中发生错误: ${errorMsg}`
+                };
+            }
+        }
+        /**
+         * 根据依赖关系排序文件（拓扑排序，被引用的表先处理）
+         */
+        async sortFilesByDependency(sqlDir, files) {
+            const dependencies = new Map();
+            for (const file of files) {
+                const filePath = path.join(sqlDir, file);
+                const sql = fs.readFileSync(filePath, 'utf8');
+                const foreignKeys = this.extractForeignKeys(sql);
+                dependencies.set(file, foreignKeys.map(fk => fk.tableName + '.sql'));
+            }
+            const sorted = [];
+            const visited = new Set();
+            const visiting = new Set();
+            const visit = (file) => {
+                if (visited.has(file))
+                    return;
+                if (visiting.has(file)) {
+                    console.warn(`⚠️ 检测到循环依赖: ${file}`);
+                    return;
+                }
+                visiting.add(file);
+                const deps = dependencies.get(file) || [];
+                for (const dep of deps) {
+                    if (files.includes(dep)) {
+                        visit(dep);
+                    }
+                }
+                visiting.delete(file);
+                visited.add(file);
+                sorted.push(file);
+            };
+            for (const file of files) {
+                visit(file);
+            }
+            return sorted;
+        }
+        /**
+         * 从 SQL 文件同步数据库结构
+         */
+        async syncTableFromSql(sqlFilePath, options = {}) {
+            let foreignKeysDisabled = false;
+            try {
+                const targetSchema = await this.parseSqlTableSchema(sqlFilePath);
+                if (!targetSchema) {
+                    return {
+                        success: false,
+                        error: `无法从 SQL 文件解析表结构: ${sqlFilePath}`
+                    };
+                }
+                const exists = await this.tableExists(targetSchema.name);
+                if (!exists) {
+                    if (options.execute !== false) {
+                        await this.executeSqlFile(sqlFilePath);
+                        return {
+                            success: true,
+                            message: `表 ${targetSchema.name} 创建成功`,
+                            action: 'CREATE'
+                        };
+                    }
+                    else {
+                        return {
+                            success: true,
+                            message: `需要创建表 ${targetSchema.name}`,
+                            action: 'CREATE',
+                            targetSchema
+                        };
+                    }
+                }
+                const currentSchema = await this.getTableSchema(targetSchema.name);
+                const referencingForeignKeys = await this.getReferencingForeignKeys(targetSchema.name);
+                const diff = this.compareTableSchemas(currentSchema, targetSchema, options);
+                if (diff.isEmpty) {
+                    return {
+                        success: true,
+                        message: `表 ${targetSchema.name} 已是最新，无需更新`,
+                        action: 'NONE'
+                    };
+                }
+                if (referencingForeignKeys.length > 0 && this.hasPrimaryKeyChanges(diff)) {
+                    if (options.execute !== false) {
+                        await this.disableForeignKeys();
+                        foreignKeysDisabled = true;
+                        console.log(`  🔓 临时禁用外键检查，因为表 ${targetSchema.name} 有 ${referencingForeignKeys.length} 个外键引用`);
+                    }
+                }
+                const alterStatements = this.generateAlterStatements(targetSchema.name, diff, options.dropExtraColumns);
+                if (alterStatements.length === 0) {
+                    return {
+                        success: true,
+                        message: `表 ${targetSchema.name} 无需修改`,
+                        action: 'NONE'
+                    };
+                }
+                if (options.backupData && options.execute !== false) {
+                    await this.backupTableData(targetSchema.name);
+                }
+                if (options.execute !== false) {
+                    console.log(`  🔧 即将执行 ${alterStatements.length} 条修改:`);
+                    alterStatements.forEach(s => console.log(`     ${s}`));
+                    await this.executeRawQuery('START TRANSACTION');
+                    let failedStmt = '';
+                    try {
+                        for (const statement of alterStatements) {
+                            failedStmt = statement;
+                            await this.executeRawQuery(statement);
+                        }
+                        await this.executeRawQuery('COMMIT');
+                    }
+                    catch (alterError) {
+                        await this.executeRawQuery('ROLLBACK');
+                        const msg = alterError instanceof Error ? alterError.message : String(alterError);
+                        throw new Error(`${msg}\n  → 失败语句: ${failedStmt}`);
+                    }
+                    return {
+                        success: true,
+                        message: `表 ${targetSchema.name} 更新成功，执行了 ${alterStatements.length} 条修改`,
+                        action: 'ALTER',
+                        details: alterStatements
+                    };
+                }
+                else {
+                    return {
+                        success: true,
+                        message: `表 ${targetSchema.name} 需要更新`,
+                        action: 'ALTER',
+                        diff,
+                        statements: alterStatements
+                    };
+                }
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error)
+                };
+            }
+            finally {
+                if (foreignKeysDisabled) {
+                    await this.enableForeignKeys();
+                    console.log(`  🔒 恢复外键检查`);
+                }
+            }
+        }
+        // ==================== SQL 执行方法 ====================
+        /**
+         * 执行原生SQL查询（用于DDL语句，比prepared statement更兼容）
+         */
+        async executeRawQuery(sql) {
+            const pool = this.pool;
+            if (null == pool) {
+                throw new Error('数据库连接池未初始化');
+            }
+            await pool.query(sql);
+        }
+        /**
+         * 执行SQL查询（用于参数化查询）
+         */
+        async executeQuery(sql, params = []) {
+            const pool = this.pool;
+            if (null == pool) {
+                throw new Error('数据库连接池未初始化');
+            }
+            const [rows, fields] = await pool.execute(sql, params);
+            return [rows, fields];
+        }
+        /**
+         * 执行 SQL 脚本（支持多条语句，逐条执行）
+         */
+        async executeSqlScript(sql) {
+            const cleanSql = sql
+                .replace(/--.*$/gm, '')
+                .replace(/\/\*[\s\S]*?\*\//g, '')
+                .trim();
+            if (!cleanSql)
+                return;
+            const statements = this.splitSqlStatements(cleanSql);
+            for (const statement of statements) {
+                if (statement.length > 0) {
+                    await this.executeRawQuery(statement);
+                }
+            }
+        }
+        /**
+         * 智能分割 SQL 语句（处理字符串和反引号中的分号）
+         */
+        splitSqlStatements(sql) {
+            const statements = [];
+            let current = '';
+            let inSingleQuote = false;
+            let inDoubleQuote = false;
+            let inBacktick = false;
+            for (let i = 0; i < sql.length; i++) {
+                const char = sql[i];
+                const prevChar = i > 0 ? sql[i - 1] : '';
+                if (char === "'" && !inDoubleQuote && !inBacktick && prevChar !== '\\') {
+                    inSingleQuote = !inSingleQuote;
+                }
+                else if (char === '"' && !inSingleQuote && !inBacktick && prevChar !== '\\') {
+                    inDoubleQuote = !inDoubleQuote;
+                }
+                else if (char === '`' && !inSingleQuote && !inDoubleQuote && prevChar !== '\\') {
+                    inBacktick = !inBacktick;
+                }
+                if (char === ';' && !inSingleQuote && !inDoubleQuote && !inBacktick) {
+                    const trimmed = current.trim();
+                    if (trimmed) {
+                        statements.push(trimmed);
+                    }
+                    current = '';
+                }
+                else {
+                    current += char;
+                }
+            }
+            const trimmed = current.trim();
+            if (trimmed) {
+                statements.push(trimmed);
+            }
+            return statements;
+        }
+        // ==================== 表结构解析与对比 ====================
+        /**
+         * 解析 SQL 文件中的表结构（使用括号计数处理嵌套括号）
+         */
+        async parseSqlTableSchema(sqlFilePath) {
+            const sql = fs.readFileSync(sqlFilePath, 'utf8');
+            const createMatch = sql.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?`?(\w+)`?\s*\(/i);
+            if (!createMatch)
+                return null;
+            const tableName = createMatch[1];
+            const startIdx = (createMatch.index || 0) + createMatch[0].length;
+            // 括号计数找到匹配的 )
+            let depth = 1;
+            let endIdx = startIdx;
+            let inStr = false;
+            let strChar = '';
+            for (let i = startIdx; i < sql.length && depth > 0; i++) {
+                const ch = sql[i];
+                const prev = i > 0 ? sql[i - 1] : '';
+                if ((ch === "'" || ch === '"') && prev !== '\\') {
+                    if (!inStr) {
+                        inStr = true;
+                        strChar = ch;
+                    }
+                    else if (strChar === ch) {
+                        inStr = false;
+                    }
+                }
+                if (!inStr) {
+                    if (ch === '(')
+                        depth++;
+                    else if (ch === ')')
+                        depth--;
+                }
+                if (depth === 0)
+                    endIdx = i;
+            }
+            const columnsDef = sql.substring(startIdx, endIdx);
+            const suffix = sql.substring(endIdx + 1);
+            const engineMatch = suffix.match(/ENGINE=(\w+)/i);
+            const charsetMatch = suffix.match(/DEFAULT\s+CHARSET=(\w+)/i);
+            const commentMatch = suffix.match(/COMMENT\s*=\s*'([^']*)'/i);
+            const engine = engineMatch?.[1] || 'InnoDB';
+            const charset = charsetMatch?.[1] || 'utf8mb4';
+            const comment = commentMatch?.[1] || '';
+            const columns = [];
+            const indexes = [];
+            let primaryKey = null;
+            const lines = columnsDef.split('\n')
+                .map(line => line.trim())
+                .filter(line => line.length > 0 && !line.startsWith('--'));
+            for (const line of lines) {
+                // 处理主键
+                if (line.match(/PRIMARY\s+KEY/i)) {
+                    const pkMatch = line.match(/PRIMARY\s+KEY\s*\(`?(\w+)`?\)/i);
+                    if (pkMatch)
+                        primaryKey = pkMatch[1];
+                    continue;
+                }
+                // 处理索引
+                const indexMatch = line.match(/(?:UNIQUE\s+)?(?:KEY|INDEX)\s+`?(\w+)`?\s*\(([^)]+)\)/i);
+                if (indexMatch) {
+                    const indexName = indexMatch[1];
+                    const indexColumns = indexMatch[2].split(',').map(c => c.replace(/`/g, '').trim());
+                    const isUnique = line.toUpperCase().includes('UNIQUE');
+                    indexes.push({
+                        name: indexName,
+                        columns: indexColumns,
+                        unique: isUnique,
+                        type: 'BTREE'
+                    });
+                    continue;
+                }
+                // 处理普通列
+                const colMatch = line.match(/`?(\w+)`?\s+(\w+)(\([\d,\s]+\))?\s*([^\n]*)/);
+                if (colMatch) {
+                    const colName = colMatch[1];
+                    const colBaseType = colMatch[2];
+                    const colLengthPart = colMatch[3] || '';
+                    const colAttrsRaw = colMatch[4] || '';
+                    // 从属性中提取类型修饰符（UNSIGNED, ZEROFILL, SIGNED）
+                    const upperAttrs = colAttrsRaw.toUpperCase();
+                    let typeModifiers = '';
+                    if (upperAttrs.includes('UNSIGNED')) {
+                        typeModifiers += ' UNSIGNED';
+                    }
+                    if (upperAttrs.includes('ZEROFILL')) {
+                        typeModifiers += ' ZEROFILL';
+                    }
+                    if (!upperAttrs.includes('UNSIGNED') && upperAttrs.includes('SIGNED')) {
+                        typeModifiers += ' SIGNED';
+                    }
+                    const typeStr = colBaseType + colLengthPart + typeModifiers;
+                    // 检测内联 PRIMARY KEY / UNIQUE KEY
+                    let key = '';
+                    if (upperAttrs.includes('PRIMARY KEY') || upperAttrs.includes('PRIMARY')) {
+                        key = 'PRI';
+                    }
+                    else if (upperAttrs.includes('UNIQUE KEY') || upperAttrs.includes('UNIQUE')) {
+                        key = 'UNI';
+                    }
+                    // 提取 extra（AUTO_INCREMENT, ON UPDATE CURRENT_TIMESTAMP 等）
+                    let extra = '';
+                    if (/auto_increment/i.test(colAttrsRaw)) {
+                        extra = 'auto_increment';
+                    }
+                    if (/ON\s+UPDATE\s+CURRENT_TIMESTAMP/i.test(colAttrsRaw)) {
+                        extra = extra ? extra + ' ON UPDATE CURRENT_TIMESTAMP' : 'ON UPDATE CURRENT_TIMESTAMP';
+                    }
+                    columns.push({
+                        name: colName,
+                        type: typeStr,
+                        nullable: !/NOT\s+NULL/i.test(colAttrsRaw),
+                        key,
+                        default: this.extractDefaultValue(colAttrsRaw),
+                        extra,
+                        comment: this.extractComment(colAttrsRaw)
+                    });
+                }
+            }
+            // 回填主键列的 key 标记（PRIMARY KEY 声明在单独一行时的情况）
+            if (primaryKey) {
+                const pkCol = columns.find(c => c.name === primaryKey);
+                if (pkCol && !pkCol.key) {
+                    pkCol.key = 'PRI';
+                }
+            }
+            return {
+                name: tableName,
+                columns,
+                indexes,
+                primaryKey,
+                engine,
+                charset,
+                comment
+            };
+        }
+        /**
+         * 提取默认值（处理字符串、数字、CURRENT_TIMESTAMP 等）
+         */
+        extractDefaultValue(attrs) {
+            const match = attrs.match(/DEFAULT\s+('(?:[^'\\]|\\.)*'|CURRENT_TIMESTAMP(?:\(\d*\))?|\w+)/i);
+            if (!match)
+                return undefined;
+            let value = match[1];
+            // SQL NULL 关键字 → JavaScript null
+            if (/^NULL$/i.test(value)) {
+                return null;
+            }
+            if (/^CURRENT_TIMESTAMP(?:\(\d*\))?$/i.test(value)) {
+                return value;
+            }
+            if (value.startsWith("'") && value.endsWith("'")) {
+                value = value.substring(1, value.length - 1);
+                value = value.replace(/\\'/g, "'");
+            }
+            if (/^-?\d+(\.\d+)?$/.test(value)) {
+                return Number(value);
+            }
+            return value;
+        }
+        /**
+         * 提取注释
+         */
+        extractComment(attrs) {
+            const match = attrs.match(/COMMENT\s+'([^']*)'/i);
+            return match ? match[1] : '';
+        }
+        /**
+         * 检查表是否存在
+         */
+        async tableExists(tableName) {
+            try {
+                const sql = `
+                SELECT COUNT(*) as count
+                FROM information_schema.tables
+                WHERE table_schema = DATABASE()
+                AND table_name = ?
+            `;
+                const [rows] = await this.executeQuery(sql, [tableName]);
+                return rows[0]?.count > 0;
+            }
+            catch (error) {
+                console.error('检查表是否存在失败:', error);
+                return false;
+            }
+        }
+        /**
+         * 获取当前表结构
+         */
+        async getTableSchema(tableName) {
+            const [columns] = await this.executeQuery(`SHOW FULL COLUMNS FROM \`${tableName}\``);
+            const [indexes] = await this.executeQuery(`SHOW INDEX FROM \`${tableName}\``);
+            const [tableStatus] = await this.executeQuery(`SHOW TABLE STATUS WHERE Name = ?`, [tableName]);
+            const columnSchemas = columns.map((col) => ({
+                name: col.Field,
+                type: col.Type,
+                nullable: col.Null === 'YES',
+                key: col.Key,
+                default: col.Default,
+                extra: col.Extra,
+                comment: col.Comment
+            }));
+            const indexMap = new Map();
+            for (const idx of indexes) {
+                const indexName = idx.Key_name;
+                if (indexName === 'PRIMARY')
+                    continue;
+                if (!indexMap.has(indexName)) {
+                    indexMap.set(indexName, {
+                        name: indexName,
+                        columns: [],
+                        unique: !idx.Non_unique,
+                        type: idx.Index_type
+                    });
+                }
+                indexMap.get(indexName).columns.push(idx.Column_name);
+            }
+            const primaryKey = columns.find((c) => c.Key === 'PRI')?.name || null;
+            return {
+                name: tableName,
+                columns: columnSchemas,
+                indexes: Array.from(indexMap.values()),
+                primaryKey,
+                engine: tableStatus[0]?.Engine || 'InnoDB',
+                charset: tableStatus[0]?.Collation?.split('_')[0] || 'utf8mb4',
+                comment: tableStatus[0]?.Comment || ''
+            };
+        }
+        /**
+         * 比较两个表结构的差异
+         */
+        compareTableSchemas(current, target, options = {}) {
+            const diff = {
+                addedColumns: [],
+                removedColumns: [],
+                modifiedColumns: [],
+                addedIndexes: [],
+                removedIndexes: [],
+                modifiedIndexes: [],
+                isEmpty: true
+            };
+            const currentColMap = new Map(current.columns.map(c => [c.name, c]));
+            const targetColMap = new Map(target.columns.map(c => [c.name, c]));
+            for (const targetCol of target.columns) {
+                const currentCol = currentColMap.get(targetCol.name);
+                if (!currentCol) {
+                    diff.addedColumns.push(targetCol);
+                }
+                else if (!this.isColumnEqual(currentCol, targetCol)) {
+                    diff.modifiedColumns.push({
+                        name: targetCol.name,
+                        current: currentCol,
+                        target: targetCol
+                    });
+                }
+            }
+            if (options.dropExtraColumns) {
+                for (const currentCol of current.columns) {
+                    if (!targetColMap.has(currentCol.name)) {
+                        diff.removedColumns.push(currentCol);
+                    }
+                }
+            }
+            const currentIdxMap = new Map(current.indexes.map(i => [i.name, i]));
+            const targetIdxMap = new Map(target.indexes.map(i => [i.name, i]));
+            for (const targetIdx of target.indexes) {
+                const currentIdx = currentIdxMap.get(targetIdx.name);
+                if (!currentIdx) {
+                    diff.addedIndexes.push(targetIdx);
+                }
+                else if (!this.isIndexEqual(currentIdx, targetIdx)) {
+                    diff.modifiedIndexes.push({
+                        name: targetIdx.name,
+                        current: currentIdx,
+                        target: targetIdx
+                    });
+                }
+            }
+            if (options.dropExtraColumns) {
+                for (const currentIdx of current.indexes) {
+                    if (!targetIdxMap.has(currentIdx.name)) {
+                        diff.removedIndexes.push(currentIdx);
+                    }
+                }
+            }
+            diff.isEmpty = diff.addedColumns.length === 0 &&
+                diff.removedColumns.length === 0 &&
+                diff.modifiedColumns.length === 0 &&
+                diff.addedIndexes.length === 0 &&
+                diff.removedIndexes.length === 0 &&
+                diff.modifiedIndexes.length === 0;
+            return diff;
+        }
+        /**
+         * 生成 ALTER 语句（去重、合并）
+         */
+        generateAlterStatements(tableName, diff, dropExtra = false) {
+            const statements = [];
+            const seen = new Set();
+            const addStmt = (stmt) => {
+                const key = stmt.replace(/\s+/g, ' ').trim().toLowerCase();
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    statements.push(stmt);
+                }
+            };
+            for (const col of diff.addedColumns) {
+                // NOT NULL 列必须有 DEFAULT，否则已有数据的表会报 "Invalid use of NULL value"
+                let colDef = this.generateColumnDefinition(col);
+                if (!col.nullable && col.default === undefined) {
+                    const safeDefault = this.determineSafeDefault(col);
+                    // 在 NOT NULL 后插入 DEFAULT
+                    colDef = colDef.replace(' NOT NULL', ` NOT NULL DEFAULT ${safeDefault}`);
+                    console.log(`  ⚠️ 新增 NOT NULL 列 ${col.name} 无默认值，自动补充 DEFAULT ${safeDefault}`);
+                }
+                addStmt(`ALTER TABLE \`${tableName}\` ADD COLUMN ${colDef}`);
+            }
+            for (const mod of diff.modifiedColumns) {
+                const colDef = this.generateColumnDefinition(mod.target);
+                // 如果列从 nullable → NOT NULL，先回填空值，避免 "Invalid use of NULL value"
+                if (mod.current.nullable && !mod.target.nullable) {
+                    const safeDefault = this.determineSafeDefault(mod.target);
+                    addStmt(`UPDATE \`${tableName}\` SET \`${mod.target.name}\` = ${safeDefault} WHERE \`${mod.target.name}\` IS NULL`);
+                    console.log(`  ⚠️ 列 ${mod.target.name} 改为 NOT NULL，先将 NULL 值替换为 ${safeDefault}`);
+                }
+                // 如果目标是 AUTO_INCREMENT 列，确保它是索引列（MySQL 要求）
+                if (mod.target.extra?.includes('auto_increment') && mod.target.key !== 'PRI' && mod.target.key !== 'UNI') {
+                    addStmt(`ALTER TABLE \`${tableName}\` ADD UNIQUE INDEX \`uniq_${mod.target.name}\` (\`${mod.target.name}\`)`);
+                }
+                addStmt(`ALTER TABLE \`${tableName}\` MODIFY COLUMN ${colDef}`);
+            }
+            if (dropExtra) {
+                for (const col of diff.removedColumns) {
+                    addStmt(`ALTER TABLE \`${tableName}\` DROP COLUMN \`${col.name}\``);
+                }
+            }
+            for (const idx of diff.addedIndexes) {
+                const unique = idx.unique ? 'UNIQUE ' : '';
+                const cols = idx.columns.map(c => `\`${c}\``).join(', ');
+                addStmt(`ALTER TABLE \`${tableName}\` ADD ${unique}INDEX \`${idx.name}\` (${cols})`);
+            }
+            if (dropExtra) {
+                for (const idx of diff.removedIndexes) {
+                    addStmt(`ALTER TABLE \`${tableName}\` DROP INDEX \`${idx.name}\``);
+                }
+            }
+            for (const mod of diff.modifiedIndexes) {
+                addStmt(`ALTER TABLE \`${tableName}\` DROP INDEX \`${mod.name}\``);
+                const unique = mod.target.unique ? 'UNIQUE ' : '';
+                const cols = mod.target.columns.map(c => `\`${c}\``).join(', ');
+                addStmt(`ALTER TABLE \`${tableName}\` ADD ${unique}INDEX \`${mod.name}\` (${cols})`);
+            }
+            return statements;
+        }
+        // ==================== 比较与规范化工具 ====================
+        normalizeType(type) {
+            return type
+                .trim()
+                .replace(/\s+/g, ' ')
+                .toLowerCase();
+        }
+        isColumnEqual(col1, col2) {
+            if (this.normalizeType(col1.type) !== this.normalizeType(col2.type))
+                return false;
+            if (col1.nullable !== col2.nullable)
+                return false;
+            const default1 = this.normalizeDefaultValue(col1.default);
+            const default2 = this.normalizeDefaultValue(col2.default);
+            if (default1 !== default2)
+                return false;
+            const hasAI1 = col1.extra?.includes('auto_increment') || false;
+            const hasAI2 = col2.extra?.includes('auto_increment') || false;
+            if (hasAI1 !== hasAI2)
+                return false;
+            const hasOnUpdate1 = /ON\s+UPDATE\s+CURRENT_TIMESTAMP/i.test(col1.extra || '');
+            const hasOnUpdate2 = /ON\s+UPDATE\s+CURRENT_TIMESTAMP/i.test(col2.extra || '');
+            if (hasOnUpdate1 !== hasOnUpdate2)
+                return false;
+            return true;
+        }
+        normalizeDefaultValue(value) {
+            if (value === null || value === undefined)
+                return '__NULL__';
+            let str = String(value).trim();
+            if (/^CURRENT_TIMESTAMP(\(\d*\))?$/i.test(str)) {
+                return 'CURRENT_TIMESTAMP';
+            }
+            if ((str.startsWith("'") && str.endsWith("'")) ||
+                (str.startsWith('"') && str.endsWith('"'))) {
+                str = str.slice(1, -1);
+            }
+            return str;
+        }
+        isIndexEqual(idx1, idx2) {
+            if (idx1.unique !== idx2.unique)
+                return false;
+            if (idx1.columns.length !== idx2.columns.length)
+                return false;
+            const cols1 = [...idx1.columns].sort();
+            const cols2 = [...idx2.columns].sort();
+            return JSON.stringify(cols1) === JSON.stringify(cols2);
+        }
+        generateColumnDefinition(col) {
+            let def = `\`${col.name}\` ${col.type}`;
+            if (!col.nullable) {
+                def += ' NOT NULL';
+            }
+            if (col.extra?.includes('auto_increment')) {
+                def += ' AUTO_INCREMENT';
+            }
+            if (!col.extra?.includes('auto_increment') && col.default !== undefined) {
+                if (col.default === null) {
+                    // SQL NULL 关键字，不加引号
+                    def += ' DEFAULT NULL';
+                }
+                else if (/^CURRENT_TIMESTAMP(\(\d*\))?$/i.test(String(col.default))) {
+                    def += ` DEFAULT ${col.default}`;
+                }
+                else if (typeof col.default === 'string') {
+                    def += ` DEFAULT '${col.default}'`;
+                }
+                else {
+                    def += ` DEFAULT ${col.default}`;
+                }
+            }
+            if (/ON\s+UPDATE\s+CURRENT_TIMESTAMP/i.test(col.extra || '')) {
+                def += ' ON UPDATE CURRENT_TIMESTAMP';
+            }
+            if (col.comment) {
+                def += ` COMMENT '${col.comment}'`;
+            }
+            return def;
+        }
+        /**
+         * 根据列类型确定安全的非 NULL 默认值（用于 nullable→NOT NULL 转换前回填空值）
+         */
+        determineSafeDefault(col) {
+            // 优先使用列自身定义的默认值
+            if (col.default !== null && col.default !== undefined) {
+                if (/^CURRENT_TIMESTAMP/i.test(String(col.default))) {
+                    return 'CURRENT_TIMESTAMP';
+                }
+                if (typeof col.default === 'string') {
+                    return `'${col.default}'`;
+                }
+                return String(col.default);
+            }
+            // 无显式默认值时，根据类型推断
+            const type = col.type.toLowerCase();
+            if (/\b(tinyint|smallint|mediumint|int|bigint|float|double|decimal|bit)\b/.test(type)) {
+                return '0';
+            }
+            if (/\b(datetime|timestamp)\b/.test(type)) {
+                return 'CURRENT_TIMESTAMP';
+            }
+            if (/\b(date|time|year)\b/.test(type)) {
+                return "'0000-00-00'";
+            }
+            // VARCHAR, CHAR, TEXT, BLOB, ENUM, JSON 等
+            return "''";
+        }
+        // ==================== 外键与备份 ====================
+        async disableForeignKeys() {
+            await this.executeRawQuery('SET FOREIGN_KEY_CHECKS = 0');
+        }
+        async enableForeignKeys() {
+            await this.executeRawQuery('SET FOREIGN_KEY_CHECKS = 1');
+        }
+        async getForeignKeys(tableName) {
+            const sql = `
+        SELECT
+            CONSTRAINT_NAME,
+            COLUMN_NAME,
+            REFERENCED_TABLE_NAME,
+            REFERENCED_COLUMN_NAME
+        FROM information_schema.KEY_COLUMN_USAGE
+        WHERE TABLE_SCHEMA = DATABASE()
+        AND TABLE_NAME = ?
+        AND REFERENCED_TABLE_NAME IS NOT NULL
+    `;
+            const [rows] = await this.executeQuery(sql, [tableName]);
+            return rows;
+        }
+        async getReferencingForeignKeys(tableName) {
+            const sql = `
+        SELECT
+            kcu.CONSTRAINT_NAME,
+            kcu.TABLE_NAME,
+            kcu.COLUMN_NAME,
+            kcu.REFERENCED_TABLE_NAME,
+            kcu.REFERENCED_COLUMN_NAME,
+            rc.UPDATE_RULE,
+            rc.DELETE_RULE
+        FROM information_schema.KEY_COLUMN_USAGE kcu
+        JOIN information_schema.REFERENTIAL_CONSTRAINTS rc
+            ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+            AND kcu.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
+        WHERE kcu.REFERENCED_TABLE_SCHEMA = DATABASE()
+        AND kcu.REFERENCED_TABLE_NAME = ?
+        AND kcu.REFERENCED_COLUMN_NAME IS NOT NULL
+    `;
+            const [rows] = await this.executeQuery(sql, [tableName]);
+            return rows;
+        }
+        hasPrimaryKeyChanges(diff) {
+            for (const mod of diff.modifiedColumns) {
+                if (mod.current.key === 'PRI' || mod.target.key === 'PRI') {
+                    return true;
+                }
+            }
+            for (const col of diff.removedColumns) {
+                if (col.key === 'PRI') {
+                    return true;
+                }
+            }
+            return false;
+        }
+        extractForeignKeys(sql) {
+            const foreignKeys = [];
+            const fkRegex = /CONSTRAINT\s+`?(\w+)`?\s+FOREIGN\s+KEY\s*\(`?(\w+)`?\)\s+REFERENCES\s+`?(\w+)`?\s*\(`?(\w+)`?\)(?:\s+ON\s+DELETE\s+(\w+))?(?:\s+ON\s+UPDATE\s+(\w+))?/gi;
+            let match;
+            while ((match = fkRegex.exec(sql)) !== null) {
+                foreignKeys.push({
+                    tableName: match[3],
+                    constraint: match[0]
+                });
+            }
+            return foreignKeys;
+        }
+        async backupTableData(tableName) {
+            const timestamp = Date.now();
+            const backupTable = `${tableName}_backup_${timestamp}`;
+            await this.executeRawQuery(`CREATE TABLE \`${backupTable}\` LIKE \`${tableName}\``);
+            await this.executeRawQuery(`INSERT INTO \`${backupTable}\` SELECT * FROM \`${tableName}\``);
+            console.log(`✅ 数据已备份到 ${backupTable}`);
+        }
+        async executeSqlFile(sqlFilePath) {
+            const sql = fs.readFileSync(sqlFilePath, 'utf8');
+            await this.executeSqlScript(sql);
+        }
+    }
+    DatabaseUtility.SmartTable = SmartTable;
+})(DatabaseUtility || (exports.DatabaseUtility = DatabaseUtility = {}));
+//# sourceMappingURL=DatabaseUtility.js.map