midway-fatcms 0.0.5 → 0.0.7

package/dist/libs/crud-sharding/ShardingTableCreator.js

@@ -0,0 +1,805 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardingTableCreator = void 0;
+const keys_1 = require("../../libs/crud-pro/models/keys");
+/**
+ * 分表自动创建器
+ *
+ * 根据基表结构自动创建分表，支持 MySQL、PostgreSQL、SQL Server。
+ *
+ * @example
+ * const creator = new ShardingTableCreator(crudPro, config);
+ * await creator.createTableIfNeeded('t_order_202403', {
+ *   sqlDatabase: 'mydb',
+ *   sqlDbType: SqlDbType.mysql,
+ * });
+ */
+class ShardingTableCreator {
+    constructor(crudPro, config) {
+        this.crudPro = crudPro;
+        this.config = config;
+        this.validateIdentifier(this.config.baseTable, 'baseTable');
+    }
+    /**
+     * 校验表名格式，防止 SQL 注入
+     * 只允许合法的数据库标识符：以字母或下划线开头，后续只能包含字母数字下划线
+     */
+    validateIdentifier(tableName, fieldName) {
+        const validIdentifierPattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+        if (!tableName) {
+            throw new Error(`[ShardingTableCreator] ${fieldName} 不能为空`);
+        }
+        if (!validIdentifierPattern.test(tableName)) {
+            throw new Error(`[ShardingTableCreator] ${fieldName} 格式不合法: "${tableName}"。` +
+                `只允许以字母或下划线开头，后续包含字母、数字、下划线的标识符`);
+        }
+    }
+    /**
+     * 创建分表（如果不存在）
+     *
+     * @param tableName 目标分表名
+     * @param baseCfg 基础配置（sqlDatabase, sqlDbType）
+     * @param options 创建选项
+     * @returns 创建结果
+     */
+    async createTableIfNeeded(tableName, baseCfg, options = {}) {
+        // 校验分表名格式，防止 SQL 注入
+        this.validateIdentifier(tableName, 'tableName');
+        const { copyIndexes = false } = options;
+        try {
+            // 1. 获取基表元信息
+            const tableMeta = await this.getBaseTableMeta(baseCfg);
+            if (!tableMeta || !tableMeta.columnDetails || tableMeta.columnDetails.length === 0) {
+                throw new Error(`[ShardingTableCreator] 无法获取基表 ${this.config.baseTable} 的结构信息`);
+            }
+            // 2. 生成建表 SQL
+            const createSql = this.generateCreateTableSql(tableName, tableMeta.columnDetails, baseCfg.sqlDbType, options);
+            // 3. 执行建表
+            await this.executeCreateSql(baseCfg, createSql);
+            // 4. 可选：复制索引
+            if (copyIndexes) {
+                await this.copyIndexes(tableName, baseCfg);
+            }
+            return { success: true, tableName, createSql };
+        }
+        catch (error) {
+            return {
+                success: false,
+                tableName,
+                error: error instanceof Error ? error : new Error(String(error)),
+            };
+        }
+    }
+    /**
+     * 获取基表列信息
+     */
+    async getBaseTableMeta(baseCfg) {
+        try {
+            const columns = await this.loadTableColumns(baseCfg);
+            if (!columns || columns.length === 0) {
+                return null;
+            }
+            return { columnDetails: columns };
+        }
+        catch (error) {
+            console.error('[ShardingTableCreator] 获取基表元信息失败:', error);
+            return null;
+        }
+    }
+    /**
+     * 根据数据库类型加载表列信息
+     */
+    async loadTableColumns(baseCfg) {
+        const { sqlDbType } = baseCfg;
+        if (sqlDbType === keys_1.SqlDbType.mysql) {
+            return this.loadMySQLColumns(baseCfg);
+        }
+        else if (sqlDbType === keys_1.SqlDbType.postgres) {
+            return this.loadPostgreSQLColumns(baseCfg);
+        }
+        else if (sqlDbType === keys_1.SqlDbType.sqlserver) {
+            return this.loadSQLServerColumns(baseCfg);
+        }
+        throw new Error(`[ShardingTableCreator] 不支持的数据库类型: ${sqlDbType}`);
+    }
+    /**
+     * 加载 MySQL 表列信息
+     */
+    async loadMySQLColumns(baseCfg) {
+        const sql = `
+      SELECT 
+        COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_KEY, 
+        COLUMN_DEFAULT, COLUMN_COMMENT, EXTRA
+      FROM information_schema.COLUMNS
+      WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = '${this.config.baseTable}'
+      ORDER BY ORDINAL_POSITION
+    `.trim();
+        const result = await this.crudPro.executeSQL({
+            isNativeSQL: true,
+            sqlDatabase: baseCfg.sqlDatabase,
+            sqlDbType: baseCfg.sqlDbType,
+            executeSql: sql,
+        });
+        const rows = (result === null || result === void 0 ? void 0 : result.rows) || [];
+        return rows.map((row) => {
+            var _a;
+            return ({
+                name: row.COLUMN_NAME,
+                type: row.COLUMN_TYPE,
+                isNullable: row.IS_NULLABLE === 'YES',
+                isPrimaryKey: row.COLUMN_KEY === 'PRI',
+                defaultValue: row.COLUMN_DEFAULT,
+                comment: row.COLUMN_COMMENT || undefined,
+                isAutoIncrement: ((_a = row.EXTRA) === null || _a === void 0 ? void 0 : _a.includes('auto_increment')) || false,
+            });
+        });
+    }
+    /**
+     * 加载 PostgreSQL 表列信息
+     */
+    async loadPostgreSQLColumns(baseCfg) {
+        const schema = 'public';
+        const sql = `
+      SELECT
+        column_name,
+        data_type,
+        is_nullable,
+        column_default,
+        character_maximum_length
+      FROM information_schema.columns
+      WHERE table_schema = '${schema}' AND table_name = '${this.config.baseTable}'
+      ORDER BY ordinal_position
+    `.trim();
+        const result = await this.crudPro.executeSQL({
+            isNativeSQL: true,
+            sqlDatabase: baseCfg.sqlDatabase,
+            sqlDbType: baseCfg.sqlDbType,
+            executeSql: sql,
+        });
+        const rows = (result === null || result === void 0 ? void 0 : result.rows) || [];
+        // 获取主键列
+        const pkColumns = await this.getPostgreSQLPrimaryKeys(baseCfg, schema);
+        return rows.map((row) => {
+            const { value, isSerial } = this.normalizePostgreSQLDefaultValue(row.column_default);
+            return {
+                name: row.column_name,
+                type: row.data_type,
+                isNullable: row.is_nullable === 'YES',
+                isPrimaryKey: pkColumns.includes(row.column_name),
+                defaultValue: value,
+                maxLength: row.character_maximum_length,
+                isAutoIncrement: isSerial,
+            };
+        });
+    }
+    /**
+     * 获取 PostgreSQL 表主键列
+     */
+    async getPostgreSQLPrimaryKeys(baseCfg, schema) {
+        const sql = `
+      SELECT a.attname
+      FROM pg_index i
+      JOIN pg_class c ON i.indrelid = c.oid
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ANY(i.indkey)
+      WHERE n.nspname = '${schema}'
+        AND c.relname = '${this.config.baseTable}'
+        AND i.indisprimary
+    `.trim();
+        const result = await this.crudPro.executeSQL({
+            isNativeSQL: true,
+            sqlDatabase: baseCfg.sqlDatabase,
+            sqlDbType: baseCfg.sqlDbType,
+            executeSql: sql,
+        });
+        return ((result === null || result === void 0 ? void 0 : result.rows) || []).map((row) => row.attname);
+    }
+    /**
+     * 加载 SQL Server 表列信息
+     */
+    async loadSQLServerColumns(baseCfg) {
+        const sql = `
+      SELECT
+        c.name AS column_name,
+        t.name AS data_type,
+        c.max_length,
+        c.is_nullable,
+        c.is_identity,
+        dc.definition AS default_value
+      FROM sys.columns c
+      JOIN sys.types t ON c.user_type_id = t.user_type_id
+      LEFT JOIN sys.default_constraints dc ON dc.parent_column_id = c.column_id AND dc.parent_object_id = c.object_id
+      WHERE c.object_id = OBJECT_ID('${this.config.baseTable}')
+      ORDER BY c.column_id
+    `.trim();
+        const result = await this.crudPro.executeSQL({
+            isNativeSQL: true,
+            sqlDatabase: baseCfg.sqlDatabase,
+            sqlDbType: baseCfg.sqlDbType,
+            executeSql: sql,
+        });
+        const rows = (result === null || result === void 0 ? void 0 : result.rows) || [];
+        // 获取主键列
+        const pkColumns = await this.getSQLServerPrimaryKeys(baseCfg);
+        return rows.map((row) => {
+            let type = row.data_type;
+            if (row.max_length > 0 && ['varchar', 'nvarchar', 'char', 'nchar'].includes(row.data_type.toLowerCase())) {
+                type = `${row.data_type}(${row.max_length})`;
+            }
+            return {
+                name: row.column_name,
+                type,
+                isNullable: row.is_nullable,
+                isPrimaryKey: pkColumns.includes(row.column_name),
+                defaultValue: this.normalizeSQLServerDefaultValue(row.default_value),
+                isAutoIncrement: !!row.is_identity,
+            };
+        });
+    }
+    /**
+     * 获取 SQL Server 表主键列
+     */
+    async getSQLServerPrimaryKeys(baseCfg) {
+        const sql = `
+      SELECT c.name
+      FROM sys.indexes i
+      JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+      JOIN sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+      WHERE i.object_id = OBJECT_ID('${this.config.baseTable}')
+        AND i.is_primary_key = 1
+    `.trim();
+        const result = await this.crudPro.executeSQL({
+            isNativeSQL: true,
+            sqlDatabase: baseCfg.sqlDatabase,
+            sqlDbType: baseCfg.sqlDbType,
+            executeSql: sql,
+        });
+        return ((result === null || result === void 0 ? void 0 : result.rows) || []).map((row) => row.name);
+    }
+    /**
+     * 生成建表 SQL
+     */
+    generateCreateTableSql(tableName, columns, sqlDbType, options) {
+        switch (sqlDbType) {
+            case keys_1.SqlDbType.mysql:
+                return this.generateMySQLCreateSql(tableName, columns, options);
+            case keys_1.SqlDbType.postgres:
+                return this.generatePostgreSQLCreateSql(tableName, columns, options);
+            case keys_1.SqlDbType.sqlserver:
+                return this.generateSQLServerCreateSql(tableName, columns, options);
+            default:
+                throw new Error(`[ShardingTableCreator] 不支持的数据库类型: ${sqlDbType}`);
+        }
+    }
+    // ============ MySQL ============
+    generateMySQLCreateSql(tableName, columns, options) {
+        const columnDefs = [];
+        // 列定义
+        for (const col of columns) {
+            columnDefs.push(this.formatMySQLColumn(col));
+        }
+        // 主键
+        const pkColumns = columns.filter(c => c.isPrimaryKey).map(c => `\`${c.name}\``);
+        if (pkColumns.length > 0) {
+            columnDefs.push(`PRIMARY KEY (${pkColumns.join(', ')})`);
+        }
+        // 表选项
+        const tableOptions = options.tableOptions || 'ENGINE=InnoDB DEFAULT CHARSET=utf8mb4';
+        return `CREATE TABLE IF NOT EXISTS \`${tableName}\` (\n  ${columnDefs.join(',\n  ')}\n) ${tableOptions}`;
+    }
+    formatMySQLColumn(col) {
+        const parts = [`\`${col.name}\``];
+        // 类型
+        parts.push(col.type);
+        // NOT NULL
+        if (!col.isNullable) {
+            parts.push('NOT NULL');
+        }
+        // AUTO_INCREMENT
+        const isAutoIncrement = !!col.isAutoIncrement;
+        if (isAutoIncrement) {
+            parts.push('AUTO_INCREMENT');
+        }
+        // 默认值（AUTO_INCREMENT 列不设默认值）
+        if (!isAutoIncrement) {
+            if (col.defaultValue !== null && col.defaultValue !== undefined) {
+                parts.push(`DEFAULT ${this.formatDefaultValue(col.defaultValue, col.type)}`);
+            }
+            else if (col.isNullable) {
+                parts.push('DEFAULT NULL');
+            }
+        }
+        // 注释
+        if (col.comment) {
+            parts.push(`COMMENT '${this.escapeString(col.comment)}'`);
+        }
+        return parts.join(' ');
+    }
+    // ============ PostgreSQL ============
+    generatePostgreSQLCreateSql(tableName, columns, options) {
+        const columnDefs = [];
+        // 列定义
+        for (const col of columns) {
+            columnDefs.push(this.formatPostgreSQLColumn(col));
+        }
+        // 主键
+        const pkColumns = columns.filter(c => c.isPrimaryKey).map(c => `"${c.name}"`);
+        if (pkColumns.length > 0) {
+            columnDefs.push(`PRIMARY KEY (${pkColumns.join(', ')})`);
+        }
+        // 表选项（PostgreSQL 表选项通过 WITH 子句）
+        const tableOptions = options.tableOptions ? ` WITH (${options.tableOptions})` : '';
+        return `CREATE TABLE IF NOT EXISTS "${tableName}" (\n  ${columnDefs.join(',\n  ')}\n)${tableOptions}`;
+    }
+    formatPostgreSQLColumn(col) {
+        const parts = [`"${col.name}"`];
+        // 类型映射
+        const pgType = this.mapToPostgreSQLType(col.type);
+        parts.push(pgType);
+        // NOT NULL
+        if (!col.isNullable) {
+            parts.push('NOT NULL');
+        }
+        // 默认值
+        if (col.defaultValue !== null && col.defaultValue !== undefined) {
+            parts.push(`DEFAULT ${this.formatDefaultValue(col.defaultValue, col.type)}`);
+        }
+        return parts.join(' ');
+    }
+    mapToPostgreSQLType(mysqlType) {
+        // MySQL -> PostgreSQL 类型映射
+        const typeMap = {
+            'int': 'INTEGER',
+            'bigint': 'BIGINT',
+            'smallint': 'SMALLINT',
+            'tinyint': 'SMALLINT',
+            'varchar': 'VARCHAR',
+            'char': 'CHAR',
+            'text': 'TEXT',
+            'longtext': 'TEXT',
+            'mediumtext': 'TEXT',
+            'datetime': 'TIMESTAMP',
+            'timestamp': 'TIMESTAMP',
+            'date': 'DATE',
+            'time': 'TIME',
+            'decimal': 'NUMERIC',
+            'double': 'DOUBLE PRECISION',
+            'float': 'REAL',
+            'blob': 'BYTEA',
+            'longblob': 'BYTEA',
+            'mediumblob': 'BYTEA',
+            'json': 'JSONB',
+        };
+        // 提取基础类型（去掉长度等参数）
+        const baseType = mysqlType.toLowerCase().split('(')[0].trim();
+        const mapped = typeMap[baseType] || mysqlType.toUpperCase();
+        // 保留长度参数
+        const lengthMatch = mysqlType.match(/\((\d+)(,(\d+))?\)/);
+        if (lengthMatch && (baseType === 'varchar' || baseType === 'char' || baseType === 'decimal')) {
+            return mapped + '(' + lengthMatch[1] + (lengthMatch[3] ? ',' + lengthMatch[3] : '') + ')';
+        }
+        return mapped;
+    }
+    // ============ SQL Server ============
+    generateSQLServerCreateSql(tableName, columns, options) {
+        const columnDefs = [];
+        // 列定义
+        for (const col of columns) {
+            columnDefs.push(this.formatSQLServerColumn(col));
+        }
+        // 主键
+        const pkColumns = columns.filter(c => c.isPrimaryKey).map(c => `[${c.name}]`);
+        if (pkColumns.length > 0) {
+            columnDefs.push(`PRIMARY KEY (${pkColumns.join(', ')})`);
+        }
+        // 表选项
+        const tableOptions = options.tableOptions ? ` ${options.tableOptions}` : '';
+        return `IF NOT EXISTS (SELECT * FROM sys.tables WHERE name = '${tableName}')\n` +
+            `CREATE TABLE [${tableName}] (\n  ${columnDefs.join(',\n  ')}\n)${tableOptions}`;
+    }
+    formatSQLServerColumn(col) {
+        const parts = [`[${col.name}]`];
+        // 类型映射
+        const sqlServerType = this.mapToSQLServerType(col.type);
+        parts.push(sqlServerType);
+        // NOT NULL
+        if (!col.isNullable) {
+            parts.push('NOT NULL');
+        }
+        // 默认值（IDENTITY 列不设默认值）
+        const isAutoIncrement = !!col.isAutoIncrement;
+        if (!isAutoIncrement && col.defaultValue !== null && col.defaultValue !== undefined) {
+            parts.push(`DEFAULT ${this.formatDefaultValue(col.defaultValue, col.type)}`);
+        }
+        // 标识列（自增）
+        if (isAutoIncrement) {
+            parts.push('IDENTITY(1,1)');
+        }
+        return parts.join(' ');
+    }
+    mapToSQLServerType(mysqlType) {
+        const typeMap = {
+            'int': 'INT',
+            'bigint': 'BIGINT',
+            'smallint': 'SMALLINT',
+            'tinyint': 'TINYINT',
+            'varchar': 'NVARCHAR',
+            'char': 'NCHAR',
+            'text': 'NVARCHAR(MAX)',
+            'longtext': 'NVARCHAR(MAX)',
+            'datetime': 'DATETIME',
+            'timestamp': 'DATETIME2',
+            'date': 'DATE',
+            'time': 'TIME',
+            'decimal': 'DECIMAL',
+            'double': 'FLOAT',
+            'float': 'FLOAT',
+            'blob': 'VARBINARY(MAX)',
+            'json': 'NVARCHAR(MAX)',
+        };
+        const baseType = mysqlType.toLowerCase().split('(')[0].trim();
+        const mapped = typeMap[baseType] || mysqlType.toUpperCase();
+        // 保留长度参数
+        const lengthMatch = mysqlType.match(/\((\d+)(,(\d+))?\)/);
+        if (lengthMatch && (baseType === 'varchar' || baseType === 'char' || baseType === 'decimal')) {
+            const len = parseInt(lengthMatch[1]);
+            // SQL Server NVARCHAR 最大 4000
+            if (baseType === 'varchar' && len > 4000) {
+                return 'NVARCHAR(MAX)';
+            }
+            return mapped + '(' + len + (lengthMatch[3] ? ',' + lengthMatch[3] : '') + ')';
+        }
+        return mapped;
+    }
+    // ============ 系统目录默认值清洗 ============
+    /**
+     * 清理 SQL Server 系统目录中的默认值表达式
+     *
+     * sys.default_constraints.definition 返回格式如 ((1)), ('abc'), (getdate())
+     * 需要去除最外层括号，还原为可用的默认值
+     */
+    normalizeSQLServerDefaultValue(raw) {
+        if (!raw)
+            return undefined;
+        let val = raw.trim();
+        // 去除最外层成对括号（可能多层，如 ((1)) ）
+        while (val.startsWith('(') && val.endsWith(')')) {
+            let depth = 0;
+            let balanced = true;
+            for (let i = 0; i < val.length - 1; i++) {
+                if (val[i] === '(')
+                    depth++;
+                else if (val[i] === ')')
+                    depth--;
+                if (depth === 0 && i < val.length - 1) {
+                    balanced = false;
+                    break;
+                }
+            }
+            if (!balanced)
+                break;
+            val = val.slice(1, -1).trim();
+        }
+        // SQL 引号包裹的字符串：'hello' → 提取内容
+        if (val.startsWith("'") && val.endsWith("'")) {
+            return val.slice(1, -1).replace(/''/g, "'");
+        }
+        // 数字
+        if (/^-?\d+(\.\d+)?$/.test(val)) {
+            return parseFloat(val);
+        }
+        // 其他（函数表达式如 getdate()、newid() 等）直接返回字符串
+        return val;
+    }
+    /**
+     * 清理 PostgreSQL 系统目录中的默认值表达式
+     *
+     * column_default 返回值如：
+     * - nextval('xxx_seq'::regclass) → 序列自增，不应作为 DEFAULT
+     * - 'hello'::character varying → 带类型后缀的字符串默认值
+     * - 1, true, now() 等
+     */
+    normalizePostgreSQLDefaultValue(raw) {
+        if (!raw)
+            return { value: undefined, isSerial: false };
+        const val = raw.trim();
+        // 序列自增（SERIAL/BIGSERIAL 列）
+        if (val.startsWith('nextval(')) {
+            return { value: undefined, isSerial: true };
+        }
+        // 去除 ::type 后缀（PostgreSQL 类型转换语法）
+        let cleaned = val.replace(/::[\w."\[\]]+(\[\])?$/, '');
+        // SQL 引号包裹的字符串
+        if (cleaned.startsWith("'") && cleaned.endsWith("'")) {
+            return { value: cleaned.slice(1, -1).replace(/''/g, "'"), isSerial: false };
+        }
+        // 数字
+        if (/^-?\d+(\.\d+)?$/.test(cleaned)) {
+            return { value: parseFloat(cleaned), isSerial: false };
+        }
+        // 布尔
+        if (cleaned.toLowerCase() === 'true')
+            return { value: true, isSerial: false };
+        if (cleaned.toLowerCase() === 'false')
+            return { value: false, isSerial: false };
+        // 其他（函数表达式）
+        return { value: cleaned, isSerial: false };
+    }
+    // ============ 通用方法 ============
+    /**
+     * 格式化默认值
+     */
+    formatDefaultValue(value, colType) {
+        if (value === null || value === undefined) {
+            return 'NULL';
+        }
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        if (typeof value === 'boolean') {
+            return value ? 'TRUE' : 'FALSE';
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            // SQL 函数表达式（如 CURRENT_TIMESTAMP, GETDATE(), now()）
+            // 标识符后跟 ( 视为函数调用，直接输出不加引号
+            if (/^[a-zA-Z_]+\s*\(/.test(trimmed)
+                || ['CURRENT_TIMESTAMP', 'CURRENT_DATE', 'CURRENT_TIME'].includes(trimmed.toUpperCase())) {
+                return trimmed;
+            }
+            return `'${this.escapeString(value)}'`;
+        }
+        return String(value);
+    }
+    /**
+     * 转义字符串
+     */
+    escapeString(str) {
+        return str.replace(/'/g, "''");
+    }
+    /**
+     * 执行建表 SQL
+     */
+    async executeCreateSql(baseCfg, createSql) {
+        const sqlCfgModel = {
+            isNativeSQL: true,
+            sqlDatabase: baseCfg.sqlDatabase,
+            sqlDbType: baseCfg.sqlDbType,
+            executeSql: createSql,
+        };
+        await this.crudPro.executeSQL(sqlCfgModel);
+    }
+    /**
+     * 复制索引（可选功能）
+     *
+     * 从基表复制索引到分表。
+     * 注意：主键索引已在建表时创建，此处只复制普通索引。
+     */
+    async copyIndexes(tableName, baseCfg) {
+        try {
+            const indexDefs = await this.getIndexDefinitions(baseCfg);
+            for (const indexDef of indexDefs) {
+                // 跳过主键索引（已创建）
+                if (indexDef.isPrimary || !indexDef.createSql)
+                    continue;
+                // 替换表名（支持不同数据库的标识符语法）
+                const indexSql = this.replaceTableNameInIndexSql(indexDef.createSql, tableName, baseCfg.sqlDbType);
+                // 重命名索引以避免冲突
+                const renamedSql = this.renameIndex(indexSql, tableName, baseCfg.sqlDbType);
+                await this.executeCreateSql(baseCfg, renamedSql);
+            }
+        }
+        catch (error) {
+            console.warn('[ShardingTableCreator] 复制索引失败:', error);
+            // 索引复制失败不影响主流程
+        }
+    }
+    /**
+     * 在索引 SQL 中替换表名
+     *
+     * 支持 MySQL(反引号)、PostgreSQL(双引号)、SQL Server(方括号) 的标识符语法
+     */
+    replaceTableNameInIndexSql(indexSql, tableName, sqlDbType) {
+        const baseTable = this.config.baseTable;
+        if (sqlDbType === keys_1.SqlDbType.mysql) {
+            // MySQL: 反引号包裹
+            return indexSql.replace(new RegExp(`\\\`${this.escapeRegExp(baseTable)}\\\``, 'g'), `\`${tableName}\``);
+        }
+        else if (sqlDbType === keys_1.SqlDbType.postgres) {
+            // PostgreSQL: 双引号包裹
+            return indexSql.replace(new RegExp(`"${this.escapeRegExp(baseTable)}"`, 'g'), `"${tableName}"`);
+        }
+        else if (sqlDbType === keys_1.SqlDbType.sqlserver) {
+            // SQL Server: 方括号包裹
+            return indexSql.replace(new RegExp(`\\[${this.escapeRegExp(baseTable)}\\]`, 'g'), `[${tableName}]`);
+        }
+        return indexSql;
+    }
+    /**
+     * 获取基表的索引定义
+     *
+     * 支持 MySQL、PostgreSQL、SQL Server，返回可直接执行的 CREATE INDEX 语句
+     */
+    async getIndexDefinitions(baseCfg) {
+        const { sqlDbType } = baseCfg;
+        try {
+            if (sqlDbType === keys_1.SqlDbType.mysql) {
+                return this.getMySQLIndexDefinitions(baseCfg);
+            }
+            else if (sqlDbType === keys_1.SqlDbType.postgres) {
+                return this.getPostgreSQLIndexDefinitions(baseCfg);
+            }
+            else if (sqlDbType === keys_1.SqlDbType.sqlserver) {
+                return this.getSQLServerIndexDefinitions(baseCfg);
+            }
+        }
+        catch (error) {
+            console.warn('[ShardingTableCreator] 获取索引定义失败:', error);
+        }
+        return [];
+    }
+    /**
+     * 获取 MySQL 索引定义
+     */
+    async getMySQLIndexDefinitions(baseCfg) {
+        const sql = `
+      SELECT
+        INDEX_NAME,
+        COLUMN_NAME,
+        NON_UNIQUE,
+        INDEX_TYPE,
+        SEQ_IN_INDEX
+      FROM information_schema.STATISTICS
+      WHERE TABLE_SCHEMA = DATABASE()
+        AND TABLE_NAME = '${this.config.baseTable}'
+      ORDER BY INDEX_NAME, SEQ_IN_INDEX
+    `;
+        const result = await this.crudPro.executeSQL({
+            isNativeSQL: true,
+            sqlDatabase: baseCfg.sqlDatabase,
+            sqlDbType: baseCfg.sqlDbType,
+            executeSql: sql,
+        });
+        const rows = (result === null || result === void 0 ? void 0 : result.rows) || [];
+        // 按索引名分组
+        const indexMap = new Map();
+        for (const row of rows) {
+            const indexName = row.INDEX_NAME;
+            const columnName = row.COLUMN_NAME;
+            const isUnique = row.NON_UNIQUE === 0;
+            const isPrimary = indexName === 'PRIMARY';
+            if (!indexMap.has(indexName)) {
+                indexMap.set(indexName, { columns: [], isUnique, isPrimary });
+            }
+            indexMap.get(indexName).columns.push(columnName);
+        }
+        // 生成 CREATE INDEX 语句
+        const definitions = [];
+        for (const [indexName, info] of indexMap) {
+            const { columns, isUnique, isPrimary } = info;
+            if (isPrimary) {
+                // 主键索引在建表时已创建，标记为主键但不需要执行 SQL
+                definitions.push({ isPrimary: true, createSql: '' });
+                continue;
+            }
+            const columnList = columns.map(c => `\`${c}\``).join(', ');
+            const uniqueKeyword = isUnique ? 'UNIQUE ' : '';
+            const createSql = `CREATE ${uniqueKeyword}INDEX \`${indexName}\` ON \`${this.config.baseTable}\` (${columnList})`;
+            definitions.push({ isPrimary: false, createSql });
+        }
+        return definitions;
+    }
+    /**
+     * 获取 PostgreSQL 索引定义
+     */
+    async getPostgreSQLIndexDefinitions(baseCfg) {
+        const schema = 'public';
+        // 查询索引定义
+        const sql = `
+      SELECT
+        i.relname as index_name,
+        ix.indisprimary as is_primary,
+        ix.indisunique as is_unique,
+        pg_get_indexdef(ix.indexrelid) as index_def
+      FROM pg_index ix
+      JOIN pg_class t ON t.oid = ix.indrelid
+      JOIN pg_class i ON i.oid = ix.indexrelid
+      JOIN pg_namespace n ON n.oid = t.relnamespace
+      WHERE n.nspname = '${schema}'
+        AND t.relname = '${this.config.baseTable}'
+    `;
+        const result = await this.crudPro.executeSQL({
+            isNativeSQL: true,
+            sqlDatabase: baseCfg.sqlDatabase,
+            sqlDbType: baseCfg.sqlDbType,
+            executeSql: sql,
+        });
+        const rows = (result === null || result === void 0 ? void 0 : result.rows) || [];
+        return rows.map((row) => ({
+            isPrimary: row.is_primary,
+            createSql: row.index_def,
+        }));
+    }
+    /**
+     * 获取 SQL Server 索引定义
+     */
+    async getSQLServerIndexDefinitions(baseCfg) {
+        const sql = `
+      SELECT
+        i.name as index_name,
+        i.is_primary_key as is_primary,
+        i.is_unique as is_unique,
+        i.type_desc as index_type,
+        STUFF((
+          SELECT ', [' + c.name + ']'
+          FROM sys.index_columns ic
+          JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+          WHERE ic.object_id = i.object_id AND ic.index_id = i.index_id
+          ORDER BY ic.key_ordinal
+          FOR XML PATH('')
+        ), 1, 2, '') as column_list
+      FROM sys.indexes i
+      WHERE i.object_id = OBJECT_ID('${this.config.baseTable}')
+        AND i.name IS NOT NULL
+    `;
+        const result = await this.crudPro.executeSQL({
+            isNativeSQL: true,
+            sqlDatabase: baseCfg.sqlDatabase,
+            sqlDbType: baseCfg.sqlDbType,
+            executeSql: sql,
+        });
+        const rows = (result === null || result === void 0 ? void 0 : result.rows) || [];
+        return rows.map((row) => {
+            const isPrimary = row.is_primary;
+            const isUnique = row.is_unique;
+            const indexName = row.index_name;
+            const columnList = row.column_list;
+            const indexType = row.index_type === 'NONCLUSTERED' ? 'NONCLUSTERED' : 'CLUSTERED';
+            if (isPrimary) {
+                return { isPrimary: true, createSql: '' };
+            }
+            const uniqueKeyword = isUnique ? 'UNIQUE ' : '';
+            const createSql = `CREATE ${uniqueKeyword}${indexType} INDEX [${indexName}] ON [${this.config.baseTable}] (${columnList})`;
+            return { isPrimary: false, createSql };
+        });
+    }
+    /**
+     * 重命名索引（避免不同分表索引名冲突）
+     *
+     * 支持 MySQL、PostgreSQL、SQL Server 的标识符语法
+     */
+    renameIndex(indexSql, tableName, sqlDbType) {
+        // 提取表名后缀（如 202403）
+        const suffix = tableName.replace(this.config.baseTable + '_', '');
+        // 根据不同数据库类型使用不同的标识符包裹方式
+        let indexPattern;
+        let replacement;
+        if (sqlDbType === keys_1.SqlDbType.mysql) {
+            // MySQL: 反引号包裹
+            indexPattern = /INDEX `([^`]+)`/i;
+            replacement = `INDEX \`$1_${suffix}\``;
+        }
+        else if (sqlDbType === keys_1.SqlDbType.postgres) {
+            // PostgreSQL: 双引号包裹
+            indexPattern = /INDEX "([^"]+)"/i;
+            replacement = `INDEX "$1_${suffix}"`;
+        }
+        else if (sqlDbType === keys_1.SqlDbType.sqlserver) {
+            // SQL Server: 方括号包裹
+            indexPattern = /INDEX \[([^\]]+)\]/i;
+            replacement = `INDEX [$1_${suffix}]`;
+        }
+        else {
+            // 默认：无包裹（不太可能到达这里）
+            return indexSql;
+        }
+        return indexSql.replace(indexPattern, replacement);
+    }
+    /**
+     * 转义正则特殊字符
+     */
+    escapeRegExp(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+}
+exports.ShardingTableCreator = ShardingTableCreator;