midway-fatcms 0.0.7 → 0.0.9

package/dist/libs/crud-sharding/ShardingMerger.d.ts

@@ -1,5 +1,6 @@
 import { CrudPro } from '../../libs/crud-pro/CrudPro';
 import { IRequestModel, IRequestCfgModel } from '../../libs/crud-pro/interfaces';
+import { ExecuteContext } from '../../libs/crud-pro/models/ExecuteContext';
 import { ShardingCountCache } from './ShardingCountCache';
 /**
  * 分页查询结果
@@ -7,6 +8,14 @@ import { ShardingCountCache } from './ShardingCountCache';
 export interface IShardingPageQueryResult {
     rows: any[];
     total_count: number;
+    lastCtx: ExecuteContext | null;
+}
+/**
+ * 列表查询结果
+ */
+export interface IShardingListQueryResult {
+    rows: any[];
+    lastCtx: ExecuteContext | null;
 }
 /**
  * 分表查询结果合并器
@@ -65,7 +74,7 @@ export declare class ShardingMerger {
      * @param maxRows 最大返回行数（默认 10000，防止 OOM）
      * @returns 数据列表
      */
-    mergeQuery(crudPro: CrudPro, tables: string[], reqJson: IRequestModel, cfgJson: IRequestCfgModel, maxRows?: number): Promise<any[]>;
+    mergeQuery(crudPro: CrudPro, tables: string[], reqJson: IRequestModel, cfgJson: IRequestCfgModel, maxRows?: number): Promise<IShardingListQueryResult>;
     /**
      * 根据各表数量和分页偏移，直接定位目标表
      *
@@ -95,23 +104,6 @@ export declare class ShardingMerger {
      * 支持 COUNT 缓存：历史时间分表使用缓存，当前表实时查询
      */
     private queryCountSafe;
-    /**
-     * 安全查询数据行（表不存在时返回空数组）
-     */
-    private queryRowsSafe;
-    /**
-     * 安全查询数据行（支持表内偏移，表不存在时返回空数组）
-     *
-     * 用于分页定位后，直接从某张表指定偏移处取数据
-     *
-     * @param crudPro CrudPro 实例
-     * @param table 分表名
-     * @param reqJson 请求参数
-     * @param cfgJson 配置
-     * @param innerOffset 表内偏移（跳过前 N 条）
-     * @param innerLimit 取多少条
-     */
-    private queryRowsSafeWithOffset;
     /**
      * 执行 COUNT 查询
      */

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

@@ -46,25 +46,36 @@ class ShardingMerger {
         const { pageNo = 1, pageSize = 10 } = reqJson;
         const offset = (pageNo - 1) * pageSize;
         const targetEnd = offset + pageSize; // 需要取到第几条
-        // 1. 并行查询所有分表的记录数
-        const countPromises = tables.map(table => this.queryCountSafe(crudPro, table, reqJson, cfgJson));
-        const counts = await Promise.all(countPromises);
+        // 1. 串行查询所有分表的记录数
+        const counts = [];
+        for (const table of tables) {
+            const count = await this.queryCountSafe(crudPro, table, reqJson, cfgJson);
+            counts.push(count);
+        }
         const totalCount = counts.reduce((sum, c) => sum + c, 0);
         // 总数为0，直接返回
         if (totalCount === 0) {
-            return { rows: [], total_count: 0 };
+            return { rows: [], total_count: 0, lastCtx: null };
         }
         // 2. 根据累计数量直接定位目标表
         const targetTables = this.locateTargetTables(tables, counts, offset, targetEnd);
         // 3. 只查询包含目标数据的分表
         let allRows = [];
+        let lastCtx = null;
         for (const target of targetTables) {
-            const rows = await this.queryRowsSafeWithOffset(crudPro, target.table, reqJson, cfgJson, target.innerOffset, target.innerLimit);
-            allRows = allRows.concat(rows);
+            try {
+                const ctx = await this.executeQueryWithOffset(crudPro, target.table, reqJson, cfgJson, target.innerOffset, target.innerLimit);
+                lastCtx = ctx;
+                allRows = allRows.concat(ctx.getResRows() || []);
+            }
+            catch (e) {
+                // 表不存在或其他错误，跳过
+            }
         }
         return {
             rows: allRows,
             total_count: totalCount,
+            lastCtx,
         };
     }
     /**
@@ -88,20 +99,27 @@ class ShardingMerger {
     async mergeQuery(crudPro, tables, reqJson, cfgJson, maxRows = 10000) {
         // 串行查询分表，按表顺序拼接，达到上限即停
         let allRows = [];
+        let lastCtx = null;
         for (const table of tables) {
             const needMore = maxRows - allRows.length;
             if (needMore <= 0) {
                 break;
             }
-            const rows = await this.queryRowsSafe(crudPro, table, reqJson, cfgJson, needMore);
-            allRows = allRows.concat(rows);
+            try {
+                const ctx = await this.executeQuery(crudPro, table, reqJson, cfgJson, needMore);
+                lastCtx = ctx;
+                allRows = allRows.concat(ctx.getResRows() || []);
+            }
+            catch (e) {
+                // 表不存在或其他错误，跳过
+            }
             // 达到上限后停止，不再查询后续表
             if (allRows.length >= maxRows) {
                 allRows = allRows.slice(0, maxRows);
                 break;
             }
         }
-        return allRows;
+        return { rows: allRows, lastCtx };
     }
     // ============ 私有方法：分页定位 ============
     /**
@@ -192,41 +210,6 @@ class ShardingMerger {
             return 0;
         }
     }
-    /**
-     * 安全查询数据行（表不存在时返回空数组）
-     */
-    async queryRowsSafe(crudPro, table, reqJson, cfgJson, limit) {
-        try {
-            const ctx = await this.executeQuery(crudPro, table, reqJson, cfgJson, limit);
-            return ctx.getResRows() || [];
-        }
-        catch (e) {
-            // 表不存在或其他错误，返回空数组
-            return [];
-        }
-    }
-    /**
-     * 安全查询数据行（支持表内偏移，表不存在时返回空数组）
-     *
-     * 用于分页定位后，直接从某张表指定偏移处取数据
-     *
-     * @param crudPro CrudPro 实例
-     * @param table 分表名
-     * @param reqJson 请求参数
-     * @param cfgJson 配置
-     * @param innerOffset 表内偏移（跳过前 N 条）
-     * @param innerLimit 取多少条
-     */
-    async queryRowsSafeWithOffset(crudPro, table, reqJson, cfgJson, innerOffset, innerLimit) {
-        try {
-            const ctx = await this.executeQueryWithOffset(crudPro, table, reqJson, cfgJson, innerOffset, innerLimit);
-            return ctx.getResRows() || [];
-        }
-        catch (e) {
-            // 表不存在或其他错误，返回空数组
-            return [];
-        }
-    }
     /**
      * 执行 COUNT 查询
      */

package/dist/libs/crud-sharding/ShardingResult.d.ts

@@ -0,0 +1,33 @@
+import { ExecuteContext } from '../../libs/crud-pro/models/ExecuteContext';
+import { CrudResultBase } from '../../libs/crud-pro/models/CrudResult';
+/** 分表批量插入结果 */
+declare class ShardingBatchInsertResult extends CrudResultBase {
+    readonly totalAffected: number;
+    readonly tableResults: Array<{
+        table: string;
+        affected: number;
+        rowCount: number;
+    }>;
+    readonly tableCount: number;
+    readonly success: boolean;
+    readonly errors: Array<{
+        table: string;
+        error: Error;
+    }>;
+    constructor(data: {
+        totalAffected: number;
+        tableResults: Array<{
+            table: string;
+            affected: number;
+            rowCount: number;
+        }>;
+        tableCount: number;
+        success: boolean;
+        errors: Array<{
+            table: string;
+            error: Error;
+        }>;
+        lastContext: ExecuteContext;
+    });
+}
+export { ShardingBatchInsertResult };

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardingBatchInsertResult = void 0;
+const CrudResult_1 = require("../../libs/crud-pro/models/CrudResult");
+/** 分表批量插入结果 */
+class ShardingBatchInsertResult extends CrudResult_1.CrudResultBase {
+    constructor(data) {
+        super(data.lastContext);
+        this.totalAffected = data.totalAffected;
+        this.tableResults = data.tableResults;
+        this.tableCount = data.tableCount;
+        this.success = data.success;
+        this.errors = data.errors;
+    }
+}
+exports.ShardingBatchInsertResult = ShardingBatchInsertResult;

package/dist/libs/crud-sharding/ShardingTableCreator.d.ts

@@ -1,6 +1,5 @@
-import { CrudPro } from '../../libs/crud-pro/CrudPro';
 import { SqlDbType } from '../../libs/crud-pro/models/keys';
-import { IShardingConfig, IShardingTableCreateOptions, IShardingTableCreateResult } from './ShardingConfig';
+import { CrudProFactory, IShardingConfig, IShardingTableCreateOptions, IShardingTableCreateResult } from './ShardingConfig';
 /**
  * 分表自动创建器
  *
@@ -14,9 +13,9 @@ import { IShardingConfig, IShardingTableCreateOptions, IShardingTableCreateResul
  * });
  */
 export declare class ShardingTableCreator {
-    private readonly crudPro;
+    private readonly crudProFactory;
     private readonly config;
-    constructor(crudPro: CrudPro, config: IShardingConfig);
+    constructor(crudProFactory: CrudProFactory, config: IShardingConfig);
     /**
      * 校验表名格式，防止 SQL 注入
      * 只允许合法的数据库标识符：以字母或下划线开头，后续只能包含字母数字下划线
@@ -34,6 +33,12 @@ export declare class ShardingTableCreator {
         sqlDatabase: string;
         sqlDbType: SqlDbType;
     }, options?: IShardingTableCreateOptions): Promise<IShardingTableCreateResult>;
+    /**
+     * 检查表是否已存在
+     * 复用 CrudPro.getAllTableInfos 接口，使用缓存提升性能
+     * DDL 操作本身具有幂等性（CREATE TABLE IF NOT EXISTS），缓存短暂延迟可接受
+     */
+    private checkTableExists;
     /**
      * 获取基表列信息
      */
@@ -102,6 +107,10 @@ export declare class ShardingTableCreator {
      * 执行建表 SQL
      */
     private executeCreateSql;
+    /**
+     * 判断是否为"已存在"类错误（表已存在、索引已存在等）
+     */
+    private isDuplicateError;
     /**
      * 复制索引（可选功能）
      *
@@ -109,6 +118,14 @@ export declare class ShardingTableCreator {
      * 注意：主键索引已在建表时创建，此处只复制普通索引。
      */
     private copyIndexes;
+    /**
+     * 获取目标表已存在的所有索引名
+     */
+    private getExistingIndexNames;
+    /**
+     * 从 CREATE INDEX 语句中提取索引名
+     */
+    private extractIndexName;
     /**
      * 在索引 SQL 中替换表名
      *

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

@@ -15,8 +15,8 @@ const keys_1 = require("../../libs/crud-pro/models/keys");
  * });
  */
 class ShardingTableCreator {
-    constructor(crudPro, config) {
-        this.crudPro = crudPro;
+    constructor(crudProFactory, config) {
+        this.crudProFactory = crudProFactory;
         this.config = config;
         this.validateIdentifier(this.config.baseTable, 'baseTable');
     }
@@ -46,28 +46,50 @@ class ShardingTableCreator {
         // 校验分表名格式，防止 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) {
+        // 0. 先检查表是否已存在
+        const tableExists = await this.checkTableExists(tableName, baseCfg);
+        if (tableExists) {
+            // 表已存在，跳过创建和索引复制
+            return { success: true, tableName, createSql: '' };
+        }
+        // 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) {
+            try {
                 await this.copyIndexes(tableName, baseCfg);
             }
-            return { success: true, tableName, createSql };
+            catch (e) {
+                console.error("copyIndexes", e);
+            }
+        }
+        return { success: true, tableName, createSql };
+    }
+    /**
+     * 检查表是否已存在
+     * 复用 CrudPro.getAllTableInfos 接口，使用缓存提升性能
+     * DDL 操作本身具有幂等性（CREATE TABLE IF NOT EXISTS），缓存短暂延迟可接受
+     */
+    async checkTableExists(tableName, baseCfg) {
+        try {
+            const { tables } = await this.crudProFactory().getAllTableInfos({
+                sqlDatabase: baseCfg.sqlDatabase,
+                sqlDbType: baseCfg.sqlDbType,
+            }, { skipCache: false } // 使用缓存，避免每次建表都直查数据库
+            );
+            return tables.some(t => t.name === tableName);
         }
         catch (error) {
-            return {
-                success: false,
-                tableName,
-                error: error instanceof Error ? error : new Error(String(error)),
-            };
+            console.warn('[ShardingTableCreator] 检查表存在性失败:', error);
+            // 检查失败时，假设表不存在，继续尝试创建
+            return false;
         }
     }
     /**
@@ -107,20 +129,19 @@ class ShardingTableCreator {
      */
     async loadMySQLColumns(baseCfg) {
         const sql = `
-      SELECT 
-        COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_KEY, 
+      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({
+        const rows = await this.crudProFactory().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 ({
@@ -150,13 +171,12 @@ class ShardingTableCreator {
       WHERE table_schema = '${schema}' AND table_name = '${this.config.baseTable}'
       ORDER BY ordinal_position
     `.trim();
-        const result = await this.crudPro.executeSQL({
+        const rows = await this.crudProFactory().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) => {
@@ -186,13 +206,13 @@ class ShardingTableCreator {
         AND c.relname = '${this.config.baseTable}'
         AND i.indisprimary
     `.trim();
-        const result = await this.crudPro.executeSQL({
+        const result = await this.crudProFactory().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);
+        }) || [];
+        return result.map((row) => row.attname);
     }
     /**
      * 加载 SQL Server 表列信息
@@ -212,13 +232,12 @@ class ShardingTableCreator {
       WHERE c.object_id = OBJECT_ID('${this.config.baseTable}')
       ORDER BY c.column_id
     `.trim();
-        const result = await this.crudPro.executeSQL({
+        const rows = await this.crudProFactory().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) => {
@@ -248,13 +267,13 @@ class ShardingTableCreator {
       WHERE i.object_id = OBJECT_ID('${this.config.baseTable}')
         AND i.is_primary_key = 1
     `.trim();
-        const result = await this.crudPro.executeSQL({
+        const result = await this.crudProFactory().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);
+        }) || [];
+        return result.map((row) => row.name);
     }
     /**
      * 生成建表 SQL
@@ -560,14 +579,44 @@ class ShardingTableCreator {
     /**
      * 执行建表 SQL
      */
-    async executeCreateSql(baseCfg, createSql) {
+    async executeCreateSql(baseCfg, createSql, options = {}) {
         const sqlCfgModel = {
             isNativeSQL: true,
             sqlDatabase: baseCfg.sqlDatabase,
             sqlDbType: baseCfg.sqlDbType,
             executeSql: createSql,
         };
-        await this.crudPro.executeSQL(sqlCfgModel);
+        try {
+            await this.crudProFactory().executeSQL(sqlCfgModel);
+        }
+        catch (error) {
+            // 静默处理 DDL "已存在"类错误（表已存在、索引已存在等）
+            if (options.silentDuplicate && this.isDuplicateError(error)) {
+                return;
+            }
+            throw error;
+        }
+    }
+    /**
+     * 判断是否为"已存在"类错误（表已存在、索引已存在等）
+     */
+    isDuplicateError(error) {
+        if (!error)
+            return false;
+        const code = error.code || error.errno;
+        const message = error.message || '';
+        // MySQL: ER_TABLE_EXISTS_ERROR (1050), ER_DUP_KEYNAME (1061)
+        // PostgreSQL: 42P07 (duplicate_table), 42P06 (duplicate_schema)
+        // SQL Server: 错误消息包含 "already exists"
+        return code === 'ER_TABLE_EXISTS_ERROR' ||
+            code === 'ER_DUP_KEYNAME' ||
+            code === 1050 ||
+            code === 1061 ||
+            code === '42P07' ||
+            code === '42P06' ||
+            message.includes('already exists') ||
+            message.includes('Duplicate') ||
+            message.includes('Table') && message.includes('already exists');
     }
     /**
      * 复制索引（可选功能）
@@ -576,23 +625,111 @@ class ShardingTableCreator {
      * 注意：主键索引已在建表时创建，此处只复制普通索引。
      */
     async copyIndexes(tableName, baseCfg) {
-        try {
-            const indexDefs = await this.getIndexDefinitions(baseCfg);
-            for (const indexDef of indexDefs) {
-                // 跳过主键索引（已创建）
-                if (indexDef.isPrimary || !indexDef.createSql)
-                    continue;
-                // 替换表名（支持不同数据库的标识符语法）
+        const indexDefs = await this.getIndexDefinitions(baseCfg);
+        // 过滤掉主键索引和空定义
+        const validIndexDefs = indexDefs.filter(def => !def.isPrimary && def.createSql);
+        if (validIndexDefs.length === 0) {
+            return;
+        }
+        // 一次性获取目标表已存在的所有索引名
+        const existingIndexNames = await this.getExistingIndexNames(tableName, baseCfg);
+        // 用于去重的 Set，防止同一请求中重复创建同名索引
+        const createdIndexNames = new Set();
+        for (const indexDef of validIndexDefs) {
+            try {
+                // 替换表名
                 const indexSql = this.replaceTableNameInIndexSql(indexDef.createSql, tableName, baseCfg.sqlDbType);
-                // 重命名索引以避免冲突
+                // 重命名索引
                 const renamedSql = this.renameIndex(indexSql, tableName, baseCfg.sqlDbType);
-                await this.executeCreateSql(baseCfg, renamedSql);
+                // 提取新索引名
+                const newIndexName = this.extractIndexName(renamedSql, baseCfg.sqlDbType);
+                // 如果索引已存在（数据库中或本次请求已创建），跳过创建
+                if (existingIndexNames.has(newIndexName) || createdIndexNames.has(newIndexName)) {
+                    continue;
+                }
+                console.info('[ShardingTableCreator] 准备创建索引 =>' + newIndexName + "  ===> renamedSql" + renamedSql);
+                // 使用 silentDuplicate 静默处理"索引已存在"错误
+                await this.executeCreateSql(baseCfg, renamedSql, { silentDuplicate: true });
+                // 创建成功后添加到已创建列表，防止重复创建
+                createdIndexNames.add(newIndexName);
+            }
+            catch (error) {
+                // 非预期错误，记录日志
+                console.warn('[ShardingTableCreator] 创建索引失败:', (error === null || error === void 0 ? void 0 : error.message) || error);
+            }
+        }
+    }
+    /**
+     * 获取目标表已存在的所有索引名
+     */
+    async getExistingIndexNames(tableName, baseCfg) {
+        const indexNames = new Set();
+        try {
+            if (baseCfg.sqlDbType === keys_1.SqlDbType.mysql) {
+                const sql = `
+          SELECT INDEX_NAME
+          FROM information_schema.STATISTICS
+          WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = '${tableName}'
+        `;
+                const result = await this.crudProFactory().executeSQL({
+                    isNativeSQL: true,
+                    sqlDatabase: baseCfg.sqlDatabase,
+                    sqlDbType: baseCfg.sqlDbType,
+                    executeSql: sql,
+                });
+                result.forEach(row => indexNames.add(row.INDEX_NAME));
+            }
+            else if (baseCfg.sqlDbType === keys_1.SqlDbType.postgres) {
+                const sql = `
+          SELECT indexname
+          FROM pg_indexes
+          WHERE schemaname = 'public' AND tablename = '${tableName}'
+        `;
+                const result = await this.crudProFactory().executeSQL({
+                    isNativeSQL: true,
+                    sqlDatabase: baseCfg.sqlDatabase,
+                    sqlDbType: baseCfg.sqlDbType,
+                    executeSql: sql,
+                });
+                result.forEach(row => indexNames.add(row.indexname));
+            }
+            else if (baseCfg.sqlDbType === keys_1.SqlDbType.sqlserver) {
+                const sql = `
+          SELECT name
+          FROM sys.indexes
+          WHERE object_id = OBJECT_ID('${tableName}')
+        `;
+                const result = await this.crudProFactory().executeSQL({
+                    isNativeSQL: true,
+                    sqlDatabase: baseCfg.sqlDatabase,
+                    sqlDbType: baseCfg.sqlDbType,
+                    executeSql: sql,
+                });
+                result.forEach(row => indexNames.add(row.name));
             }
         }
         catch (error) {
-            console.warn('[ShardingTableCreator] 复制索引失败:', error);
-            // 索引复制失败不影响主流程
+            console.warn('[ShardingTableCreator] 获取已存在索引列表失败:', error);
         }
+        return indexNames;
+    }
+    /**
+     * 从 CREATE INDEX 语句中提取索引名
+     */
+    extractIndexName(indexSql, sqlDbType) {
+        if (sqlDbType === keys_1.SqlDbType.mysql) {
+            const match = indexSql.match(/INDEX `([^`]+)`/i);
+            return match ? match[1] : '';
+        }
+        else if (sqlDbType === keys_1.SqlDbType.postgres) {
+            const match = indexSql.match(/INDEX "([^"]+)"/i);
+            return match ? match[1] : '';
+        }
+        else if (sqlDbType === keys_1.SqlDbType.sqlserver) {
+            const match = indexSql.match(/INDEX \[([^\]]+)\]/i);
+            return match ? match[1] : '';
+        }
+        return '';
     }
     /**
      * 在索引 SQL 中替换表名
@@ -654,13 +791,12 @@ class ShardingTableCreator {
         AND TABLE_NAME = '${this.config.baseTable}'
       ORDER BY INDEX_NAME, SEQ_IN_INDEX
     `;
-        const result = await this.crudPro.executeSQL({
+        const rows = await this.crudProFactory().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) {
@@ -708,13 +844,12 @@ class ShardingTableCreator {
       WHERE n.nspname = '${schema}'
         AND t.relname = '${this.config.baseTable}'
     `;
-        const result = await this.crudPro.executeSQL({
+        const rows = await this.crudProFactory().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,
@@ -742,13 +877,12 @@ class ShardingTableCreator {
       WHERE i.object_id = OBJECT_ID('${this.config.baseTable}')
         AND i.name IS NOT NULL
     `;
-        const result = await this.crudPro.executeSQL({
+        const rows = await this.crudProFactory().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;