midway-fatcms 0.0.5 → 0.0.7

package/src/libs/crud-sharding/ShardingTableCreator.ts

@@ -0,0 +1,1007 @@
+import { CrudPro } from '@/libs/crud-pro/CrudPro';
+import { ITableColumn } from '@/libs/crud-pro/interfaces';
+import { SqlDbType } from '@/libs/crud-pro/models/keys';
+import { IShardingConfig, IShardingTableCreateOptions, IShardingTableCreateResult } from './ShardingConfig';
+
+/**
+ * 扩展列信息（在 ITableColumn 基础上增加分表建表所需的内部标记）
+ */
+interface IShardingTableColumn extends ITableColumn {
+  /** 是否自增列（由各数据库加载器从 EXTRA/identity 中识别） */
+  isAutoIncrement?: boolean;
+}
+
+/**
+ * 分表自动创建器
+ *
+ * 根据基表结构自动创建分表，支持 MySQL、PostgreSQL、SQL Server。
+ *
+ * @example
+ * const creator = new ShardingTableCreator(crudPro, config);
+ * await creator.createTableIfNeeded('t_order_202403', {
+ *   sqlDatabase: 'mydb',
+ *   sqlDbType: SqlDbType.mysql,
+ * });
+ */
+export class ShardingTableCreator {
+  constructor(
+    private readonly crudPro: CrudPro,
+    private readonly config: IShardingConfig
+  ) {
+    this.validateIdentifier(this.config.baseTable, 'baseTable');
+  }
+
+  /**
+   * 校验表名格式，防止 SQL 注入
+   * 只允许合法的数据库标识符：以字母或下划线开头，后续只能包含字母数字下划线
+   */
+  private validateIdentifier(tableName: string, fieldName: string): void {
+    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 创建结果
+   */
+  public async createTableIfNeeded(
+    tableName: string,
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType },
+    options: IShardingTableCreateOptions = {}
+  ): Promise<IShardingTableCreateResult> {
+    // 校验分表名格式，防止 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)),
+      };
+    }
+  }
+
+  /**
+   * 获取基表列信息
+   */
+  private async getBaseTableMeta(
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType }
+  ): Promise<{ columnDetails: ITableColumn[] } | null> {
+    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;
+    }
+  }
+
+  /**
+   * 根据数据库类型加载表列信息
+   */
+  private async loadTableColumns(
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType }
+  ): Promise<ITableColumn[]> {
+    const { sqlDbType } = baseCfg;
+
+    if (sqlDbType === SqlDbType.mysql) {
+      return this.loadMySQLColumns(baseCfg);
+    } else if (sqlDbType === SqlDbType.postgres) {
+      return this.loadPostgreSQLColumns(baseCfg);
+    } else if (sqlDbType === SqlDbType.sqlserver) {
+      return this.loadSQLServerColumns(baseCfg);
+    }
+
+    throw new Error(`[ShardingTableCreator] 不支持的数据库类型: ${sqlDbType}`);
+  }
+
+  /**
+   * 加载 MySQL 表列信息
+   */
+  private async loadMySQLColumns(
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType }
+  ): Promise<ITableColumn[]> {
+    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?.rows || [];
+    return rows.map((row: any) => ({
+      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: row.EXTRA?.includes('auto_increment') || false,
+    }));
+  }
+
+  /**
+   * 加载 PostgreSQL 表列信息
+   */
+  private async loadPostgreSQLColumns(
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType }
+  ): Promise<ITableColumn[]> {
+    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?.rows || [];
+
+    // 获取主键列
+    const pkColumns = await this.getPostgreSQLPrimaryKeys(baseCfg, schema);
+
+    return rows.map((row: any) => {
+      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 表主键列
+   */
+  private async getPostgreSQLPrimaryKeys(
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType },
+    schema: string
+  ): Promise<string[]> {
+    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?.rows || []).map((row: any) => row.attname);
+  }
+
+  /**
+   * 加载 SQL Server 表列信息
+   */
+  private async loadSQLServerColumns(
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType }
+  ): Promise<ITableColumn[]> {
+    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?.rows || [];
+
+    // 获取主键列
+    const pkColumns = await this.getSQLServerPrimaryKeys(baseCfg);
+
+    return rows.map((row: any) => {
+      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 表主键列
+   */
+  private async getSQLServerPrimaryKeys(
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType }
+  ): Promise<string[]> {
+    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?.rows || []).map((row: any) => row.name);
+  }
+
+  /**
+   * 生成建表 SQL
+   */
+  private generateCreateTableSql(
+    tableName: string,
+    columns: ITableColumn[],
+    sqlDbType: SqlDbType,
+    options: IShardingTableCreateOptions
+  ): string {
+    switch (sqlDbType) {
+      case SqlDbType.mysql:
+        return this.generateMySQLCreateSql(tableName, columns, options);
+      case SqlDbType.postgres:
+        return this.generatePostgreSQLCreateSql(tableName, columns, options);
+      case SqlDbType.sqlserver:
+        return this.generateSQLServerCreateSql(tableName, columns, options);
+      default:
+        throw new Error(`[ShardingTableCreator] 不支持的数据库类型: ${sqlDbType}`);
+    }
+  }
+
+  // ============ MySQL ============
+
+  private generateMySQLCreateSql(
+    tableName: string,
+    columns: ITableColumn[],
+    options: IShardingTableCreateOptions
+  ): string {
+    const columnDefs: string[] = [];
+
+    // 列定义
+    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}`;
+  }
+
+  private formatMySQLColumn(col: ITableColumn): string {
+    const parts: string[] = [`\`${col.name}\``];
+
+    // 类型
+    parts.push(col.type);
+
+    // NOT NULL
+    if (!col.isNullable) {
+      parts.push('NOT NULL');
+    }
+
+    // AUTO_INCREMENT
+    const isAutoIncrement = !!(col as IShardingTableColumn).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 ============
+
+  private generatePostgreSQLCreateSql(
+    tableName: string,
+    columns: ITableColumn[],
+    options: IShardingTableCreateOptions
+  ): string {
+    const columnDefs: string[] = [];
+
+    // 列定义
+    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}`;
+  }
+
+  private formatPostgreSQLColumn(col: ITableColumn): string {
+    const parts: string[] = [`"${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(' ');
+  }
+
+  private mapToPostgreSQLType(mysqlType: string): string {
+    // MySQL -> PostgreSQL 类型映射
+    const typeMap: Record<string, string> = {
+      '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 ============
+
+  private generateSQLServerCreateSql(
+    tableName: string,
+    columns: ITableColumn[],
+    options: IShardingTableCreateOptions
+  ): string {
+    const columnDefs: string[] = [];
+
+    // 列定义
+    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}`;
+  }
+
+  private formatSQLServerColumn(col: ITableColumn): string {
+    const parts: string[] = [`[${col.name}]`];
+
+    // 类型映射
+    const sqlServerType = this.mapToSQLServerType(col.type);
+    parts.push(sqlServerType);
+
+    // NOT NULL
+    if (!col.isNullable) {
+      parts.push('NOT NULL');
+    }
+
+    // 默认值（IDENTITY 列不设默认值）
+    const isAutoIncrement = !!(col as IShardingTableColumn).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(' ');
+  }
+
+  private mapToSQLServerType(mysqlType: string): string {
+    const typeMap: Record<string, string> = {
+      '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())
+   * 需要去除最外层括号，还原为可用的默认值
+   */
+  private normalizeSQLServerDefaultValue(raw: string | null): any {
+    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() 等
+   */
+  private normalizePostgreSQLDefaultValue(raw: string | null): { value: any; isSerial: boolean } {
+    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 };
+  }
+
+  // ============ 通用方法 ============
+
+  /**
+   * 格式化默认值
+   */
+  private formatDefaultValue(value: any, colType: string): string {
+    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);
+  }
+
+  /**
+   * 转义字符串
+   */
+  private escapeString(str: string): string {
+    return str.replace(/'/g, "''");
+  }
+
+  /**
+   * 执行建表 SQL
+   */
+  private async executeCreateSql(
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType },
+    createSql: string
+  ): Promise<void> {
+    const sqlCfgModel = {
+      isNativeSQL: true,
+      sqlDatabase: baseCfg.sqlDatabase,
+      sqlDbType: baseCfg.sqlDbType,
+      executeSql: createSql,
+    };
+
+    await this.crudPro.executeSQL(sqlCfgModel);
+  }
+
+  /**
+   * 复制索引（可选功能）
+   *
+   * 从基表复制索引到分表。
+   * 注意：主键索引已在建表时创建，此处只复制普通索引。
+   */
+  private async copyIndexes(
+    tableName: string,
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType }
+  ): Promise<void> {
+    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(方括号) 的标识符语法
+   */
+  private replaceTableNameInIndexSql(
+    indexSql: string,
+    tableName: string,
+    sqlDbType: SqlDbType
+  ): string {
+    const baseTable = this.config.baseTable;
+
+    if (sqlDbType === SqlDbType.mysql) {
+      // MySQL: 反引号包裹
+      return indexSql.replace(
+        new RegExp(`\\\`${this.escapeRegExp(baseTable)}\\\``, 'g'),
+        `\`${tableName}\``
+      );
+    } else if (sqlDbType === SqlDbType.postgres) {
+      // PostgreSQL: 双引号包裹
+      return indexSql.replace(
+        new RegExp(`"${this.escapeRegExp(baseTable)}"`, 'g'),
+        `"${tableName}"`
+      );
+    } else if (sqlDbType === SqlDbType.sqlserver) {
+      // SQL Server: 方括号包裹
+      return indexSql.replace(
+        new RegExp(`\\[${this.escapeRegExp(baseTable)}\\]`, 'g'),
+        `[${tableName}]`
+      );
+    }
+
+    return indexSql;
+  }
+
+  /**
+   * 获取基表的索引定义
+   *
+   * 支持 MySQL、PostgreSQL、SQL Server，返回可直接执行的 CREATE INDEX 语句
+   */
+  private async getIndexDefinitions(
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType }
+  ): Promise<Array<{ isPrimary: boolean; createSql: string }>> {
+    const { sqlDbType } = baseCfg;
+
+    try {
+      if (sqlDbType === SqlDbType.mysql) {
+        return this.getMySQLIndexDefinitions(baseCfg);
+      } else if (sqlDbType === SqlDbType.postgres) {
+        return this.getPostgreSQLIndexDefinitions(baseCfg);
+      } else if (sqlDbType === SqlDbType.sqlserver) {
+        return this.getSQLServerIndexDefinitions(baseCfg);
+      }
+    } catch (error) {
+      console.warn('[ShardingTableCreator] 获取索引定义失败:', error);
+    }
+
+    return [];
+  }
+
+  /**
+   * 获取 MySQL 索引定义
+   */
+  private async getMySQLIndexDefinitions(
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType }
+  ): Promise<Array<{ isPrimary: boolean; createSql: string }>> {
+    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?.rows || [];
+
+    // 按索引名分组
+    const indexMap = new Map<string, { columns: string[]; isUnique: boolean; isPrimary: boolean }>();
+
+    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: Array<{ isPrimary: boolean; createSql: string }> = [];
+
+    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 索引定义
+   */
+  private async getPostgreSQLIndexDefinitions(
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType }
+  ): Promise<Array<{ isPrimary: boolean; createSql: string }>> {
+    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?.rows || [];
+
+    return rows.map((row: any) => ({
+      isPrimary: row.is_primary,
+      createSql: row.index_def,
+    }));
+  }
+
+  /**
+   * 获取 SQL Server 索引定义
+   */
+  private async getSQLServerIndexDefinitions(
+    baseCfg: { sqlDatabase: string; sqlDbType: SqlDbType }
+  ): Promise<Array<{ isPrimary: boolean; createSql: string }>> {
+    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?.rows || [];
+
+    return rows.map((row: any) => {
+      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 的标识符语法
+   */
+  private renameIndex(indexSql: string, tableName: string, sqlDbType: SqlDbType): string {
+    // 提取表名后缀（如 202403）
+    const suffix = tableName.replace(this.config.baseTable + '_', '');
+
+    // 根据不同数据库类型使用不同的标识符包裹方式
+    let indexPattern: RegExp;
+    let replacement: string;
+
+    if (sqlDbType === SqlDbType.mysql) {
+      // MySQL: 反引号包裹
+      indexPattern = /INDEX `([^`]+)`/i;
+      replacement = `INDEX \`$1_${suffix}\``;
+    } else if (sqlDbType === SqlDbType.postgres) {
+      // PostgreSQL: 双引号包裹
+      indexPattern = /INDEX "([^"]+)"/i;
+      replacement = `INDEX "$1_${suffix}"`;
+    } else if (sqlDbType === SqlDbType.sqlserver) {
+      // SQL Server: 方括号包裹
+      indexPattern = /INDEX \[([^\]]+)\]/i;
+      replacement = `INDEX [$1_${suffix}]`;
+    } else {
+      // 默认：无包裹（不太可能到达这里）
+      return indexSql;
+    }
+
+    return indexSql.replace(indexPattern, replacement);
+  }
+
+  /**
+   * 转义正则特殊字符
+   */
+  private escapeRegExp(str: string): string {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+}