midway-fatcms 0.0.8 → 0.0.9

package/dist/libs/crud-pro-quick/CrudProQuick.d.ts

@@ -87,10 +87,6 @@ export declare class CrudProQuick {
      * 构建辅助定位信息
      */
     private buildDebugInfo;
-    /**
-     * 格式化唯一性错误消息
-     */
-    private formatUniqueError;
     /**
      * 查询数据列表
      * @param reqJson 请求参数
@@ -156,6 +152,9 @@ export declare class CrudProQuick {
     update(reqJson: IRequestModel, sqlTable?: string): Promise<CrudWriteResult>;
     /**
      * 插入或更新数据记录（upsert）
+     * 限制：
+     *  - 必须有condition字段，用于判断记录是否存在
+     *  - 必须有data字段，用于指定插入/更新的内容
      * 内部使用 SIMPLE_INSERT_OR_UPDATE 模式，若记录已存在则更新，不存在则插入
      * @param reqJson 请求参数，data 为要插入/更新的内容，condition 为判断条件
      * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
@@ -205,6 +204,41 @@ export declare class CrudProQuick {
      * await quick.restore({ condition: { status: 'deleted' } });
      */
     restore(reqJson: IRequestModel, sqlTable?: string): Promise<CrudWriteResult>;
+    /**
+     * 保存数据记录（自动判断 INSERT 或 UPDATE）
+     *
+     * 只需传入 data，无需手动指定 condition。方法会自动从表结构中获取主键列，
+     * 根据 data 中是否包含主键值来决定操作类型：
+     * - data 包含主键且主键值不为 undefined/null → 调用 insertOrUpdate（先查后写，存在则更新，不存在则插入）
+     * - data 不包含主键或主键值为 undefined/null → 调用 insert（直接插入）
+     *
+     * **前置条件**：data 不能为空
+     *
+     * @param reqJson 请求参数，只需 data 字段
+     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
+     * @returns CrudUpsertResult 包含 affected、insertAffected、updateAffected、isExist 和 getRawContext()
+     *
+     * @example
+     * // 有主键 → 先查后写（存在则 UPDATE，不存在则 INSERT）
+     * await quick.save({ data: { id: 1, name: '张三' } });
+     *
+     * // 无主键 → 直接 INSERT
+     * await quick.save({ data: { name: '李四' } });
+     *
+     * // 主键值为 null → 视为无主键，直接 INSERT
+     * await quick.save({ data: { id: null, name: '王五' } });
+     */
+    save(reqJson: IRequestModel, sqlTable?: string): Promise<CrudUpsertResult>;
+    /**
+     * 获取表的主键列名列表
+     *
+     * 委托给 CrudPro.getPrimaryKeyColumns，复用 CrudProTableMetaService 的 getTableMeta 缓存，
+     * 避免重复查询数据库。
+     *
+     * @param sqlTable 表名
+     * @returns 主键列名数组，如果查询失败返回 ['id'] 作为保守默认值
+     */
+    private getPrimaryKeyColumns;
     /**
      * 根据主键 ID 查询单条记录
      *
@@ -229,9 +263,14 @@ export declare class CrudProQuick {
     /**
      * 根据主键 ID 列表查询多条记录
      *
-     * 等价于 `findList({ condition: { id: { $in: ids } } })`，但更简洁。
+     * 实现逻辑：
+     * 1. 先对 ids 去重，避免重复 ID 导致无效查询和重复结果
+     * 2. 若去重后为空，直接返回空结果
+     * 3. 若 ID 数量不超过批次大小，单次 findList 查询完成
+     * 4. 若 ID 数量超过批次大小，自动分批查询（每批默认 200 个 ID），
+     *    避免单次 IN 列表过大导致执行计划退化和内存尖峰，最后合并结果返回
      *
-     * @param ids 主键值数组
+     * @param ids 主键值数组（内部会自动去重）
      * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
      * @returns CrudQueryListResult 包含 rows、count 和 getRawContext()
      *
@@ -292,4 +331,52 @@ export declare class CrudProQuick {
      * // result 类型为 ExecuteSQLResult，实际运行时返回 ExecuteSQLUpdateResult
      */
     executeNativeSQL<T = Record<string, any>>(executeNativeSql: string, args?: any[]): Promise<ExecuteSQLResult<T>>;
+    /**
+     * findOne 的快捷方式，直接返回 row
+     *
+     * @example
+     * const row = await quick.getOne({ condition: { id: 1 } });
+     * // 等价于 (await quick.findOne({ condition: { id: 1 } })).row
+     */
+    getOne(reqJson: IRequestModel, sqlTable?: string): Promise<Record<string, any>>;
+    /**
+     * findUniqueOne 的快捷方式，直接返回 row
+     *
+     * @example
+     * const row = await quick.getUniqueOne({ condition: { order_id: 'ORD001' } });
+     * // 等价于 (await quick.findUniqueOne({ condition: { order_id: 'ORD001' } })).row
+     */
+    getUniqueOne(reqJson: IRequestModel, sqlTable?: string): Promise<Record<string, any>>;
+    /**
+     * findList 的快捷方式，直接返回 rows
+     *
+     * @example
+     * const rows = await quick.getList({ condition: { status: 'active' } });
+     * // 等价于 (await quick.findList({ condition: { status: 'active' } })).rows
+     */
+    getList(reqJson: IRequestModel, sqlTable?: string): Promise<Record<string, any>[]>;
+    /**
+     * findCount 的快捷方式，直接返回 count
+     *
+     * @example
+     * const count = await quick.getCount({ condition: { status: 'active' } });
+     * // 等价于 (await quick.findCount({ condition: { status: 'active' } })).count
+     */
+    getCount(reqJson: IRequestModel, sqlTable?: string): Promise<number>;
+    /**
+     * isExist 的快捷方式，直接返回 exists
+     *
+     * @example
+     * const exists = await quick.getIsExist({ condition: { id: 1 } });
+     * // 等价于 (await quick.isExist({ condition: { id: 1 } })).exists
+     */
+    getIsExist(reqJson: IRequestModel, sqlTable?: string): Promise<boolean>;
+    /**
+     * findOneById 的快捷方式，直接返回 row
+     *
+     * @example
+     * const row = await quick.getOneById(1);
+     * // 等价于 (await quick.findOneById(1)).row
+     */
+    getOneById(id: number | string, sqlTable?: string): Promise<Record<string, any>>;
 }

package/dist/libs/crud-pro-quick/CrudProQuick.js

@@ -4,7 +4,9 @@ exports.CrudProQuick = void 0;
 const keys_1 = require("../../libs/crud-pro/models/keys");
 const fixSoftDelete_1 = require("./fixSoftDelete");
 const CrudResult_1 = require("../../libs/crud-pro/models/CrudResult");
+const exceptions_1 = require("../../libs/crud-pro/exceptions");
 const DEFAULT_MAX_LIMIT = 10 * 10000;
+const DEFAULT_BATCH_SIZE_FOR_IDS_QUERY = 200;
 /**
  * 快捷 CRUD 操作封装器
  *
@@ -39,6 +41,7 @@ class CrudProQuick {
     constructor(args) {
         this.baseCfgModel = {
             maxLimit: DEFAULT_MAX_LIMIT,
+            batchSizeForIdsQuery: DEFAULT_BATCH_SIZE_FOR_IDS_QUERY,
         };
         this.sqlDatabase = args.sqlDatabase;
         this.sqlDbType = args.sqlDbType;
@@ -79,13 +82,19 @@ class CrudProQuick {
      * @returns CrudQueryOneResult 包含 row、found 和 getRawContext()
      */
     async findOne(reqJson, sqlTable) {
+        const effectiveTable = sqlTable || this.sqlTable;
         const cfgModel = {
-            sqlTable,
+            sqlTable: effectiveTable,
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
         };
         const ctx = await this.executeCrudByCfg(reqJson, cfgModel);
         const row = ctx.getOneObj();
-        return new CrudResult_1.CrudQueryOneResult({ row, rawContext: ctx, debugInfo: this.buildDebugInfo(sqlTable, reqJson.condition) });
+        return new CrudResult_1.CrudQueryOneResult({
+            row,
+            rawContext: ctx,
+            debugInfo: this.buildDebugInfo(effectiveTable, reqJson.condition),
+            fromTable: effectiveTable
+        });
     }
     /**
      * 查询唯一单条记录（期望结果为 0 条或 1 条）
@@ -118,14 +127,13 @@ class CrudProQuick {
         const ctx = await this.executeCrudByCfg(reqJson, cfgModel);
         const rows = ctx.getResRows();
         if (rows.length > 1) {
-            const debugInfo = this.buildDebugInfo(effectiveTable, reqJson.condition);
-            const errorMsg = this.formatUniqueError(rows.length, debugInfo);
-            throw new Error(errorMsg);
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.MORE_THAN_ONE_RECORDS_FOUND, '发现了不止一条数据');
         }
         return new CrudResult_1.CrudQueryOneResult({
             row: rows[0] || null,
             rawContext: ctx,
             debugInfo: this.buildDebugInfo(effectiveTable, reqJson.condition),
+            fromTable: effectiveTable,
         });
     }
     /**
@@ -141,29 +149,6 @@ class CrudProQuick {
         }
         return info;
     }
-    /**
-     * 格式化唯一性错误消息
-     */
-    formatUniqueError(foundCount, debugInfo) {
-        const parts = [
-            `[CrudProQuick] findUniqueOne 期望唯一一条记录，但查询到 ${foundCount} 条`,
-        ];
-        if (debugInfo.sqlDatabase) {
-            parts.push(`数据库: ${debugInfo.sqlDatabase}`);
-        }
-        if (debugInfo.sqlTable) {
-            parts.push(`表: ${debugInfo.sqlTable}`);
-        }
-        if (debugInfo.condition) {
-            try {
-                parts.push(`条件: ${JSON.stringify(debugInfo.condition)}`);
-            }
-            catch (_a) {
-                parts.push(`条件: [无法序列化]`);
-            }
-        }
-        return parts.join(' | ');
-    }
     /**
      * 查询数据列表
      * @param reqJson 请求参数
@@ -301,6 +286,9 @@ class CrudProQuick {
     }
     /**
      * 插入或更新数据记录（upsert）
+     * 限制：
+     *  - 必须有condition字段，用于判断记录是否存在
+     *  - 必须有data字段，用于指定插入/更新的内容
      * 内部使用 SIMPLE_INSERT_OR_UPDATE 模式，若记录已存在则更新，不存在则插入
      * @param reqJson 请求参数，data 为要插入/更新的内容，condition 为判断条件
      * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
@@ -315,7 +303,6 @@ class CrudProQuick {
         const ctx = await this.executeCrudByCfg(reqJson, cfgModel);
         const resModel = ctx.getResModel();
         return new CrudResult_1.CrudUpsertResult({
-            affected: resModel.affected,
             insertAffected: resModel.insert_affected,
             updateAffected: resModel.update_affected,
             isExist: (_a = resModel.is_exist) !== null && _a !== void 0 ? _a : false,
@@ -415,6 +402,91 @@ class CrudProQuick {
             rawContext: ctx,
         });
     }
+    /**
+     * 保存数据记录（自动判断 INSERT 或 UPDATE）
+     *
+     * 只需传入 data，无需手动指定 condition。方法会自动从表结构中获取主键列，
+     * 根据 data 中是否包含主键值来决定操作类型：
+     * - data 包含主键且主键值不为 undefined/null → 调用 insertOrUpdate（先查后写，存在则更新，不存在则插入）
+     * - data 不包含主键或主键值为 undefined/null → 调用 insert（直接插入）
+     *
+     * **前置条件**：data 不能为空
+     *
+     * @param reqJson 请求参数，只需 data 字段
+     * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
+     * @returns CrudUpsertResult 包含 affected、insertAffected、updateAffected、isExist 和 getRawContext()
+     *
+     * @example
+     * // 有主键 → 先查后写（存在则 UPDATE，不存在则 INSERT）
+     * await quick.save({ data: { id: 1, name: '张三' } });
+     *
+     * // 无主键 → 直接 INSERT
+     * await quick.save({ data: { name: '李四' } });
+     *
+     * // 主键值为 null → 视为无主键，直接 INSERT
+     * await quick.save({ data: { id: null, name: '王五' } });
+     */
+    async save(reqJson, sqlTable) {
+        if (!reqJson.data || Object.keys(reqJson.data).length === 0) {
+            throw new Error('[CrudProQuick] save 操作的 data 不能为空。data 用于指定保存的内容。');
+        }
+        const effectiveTable = sqlTable || this.sqlTable;
+        if (!effectiveTable) {
+            throw new Error('[CrudProQuick] sqlTable not found');
+        }
+        // 获取表的主键列
+        const primaryKeys = await this.getPrimaryKeyColumns(effectiveTable);
+        const data = reqJson.data;
+        // 检查 data 中是否包含所有主键且值有效
+        const hasPrimaryKeyValue = primaryKeys.length > 0 &&
+            primaryKeys.every(pk => pk in data && data[pk] !== undefined && data[pk] !== null);
+        if (hasPrimaryKeyValue) {
+            // 从 data 中提取主键作为 condition
+            const condition = {};
+            for (const pk of primaryKeys) {
+                condition[pk] = data[pk];
+            }
+            // 调用 insertOrUpdate（先查后写）
+            return this.insertOrUpdate({ ...reqJson, condition }, sqlTable);
+        }
+        const condition = reqJson.condition;
+        if (condition && Object.keys(condition).length > 0) {
+            return this.insertOrUpdate(reqJson, sqlTable);
+        }
+        // 无主键值 → 直接 INSERT
+        const insertResult = await this.insert(reqJson, sqlTable);
+        // 将 CrudWriteResult 转换为 CrudUpsertResult
+        return new CrudResult_1.CrudUpsertResult({
+            insertAffected: { affectedRows: insertResult.affectedRows, insertId: insertResult.insertId },
+            updateAffected: { affectedRows: 0, insertId: null },
+            isExist: false,
+            rawContext: insertResult.getRawContext(),
+        });
+    }
+    /**
+     * 获取表的主键列名列表
+     *
+     * 委托给 CrudPro.getPrimaryKeyColumns，复用 CrudProTableMetaService 的 getTableMeta 缓存，
+     * 避免重复查询数据库。
+     *
+     * @param sqlTable 表名
+     * @returns 主键列名数组，如果查询失败返回 ['id'] 作为保守默认值
+     */
+    async getPrimaryKeyColumns(sqlTable) {
+        try {
+            const crudPro = this.crudProFactory();
+            return await crudPro.getPrimaryKeyColumns({
+                sqlTable,
+                sqlDatabase: this.sqlDatabase,
+                sqlDbType: this.sqlDbType,
+            });
+        }
+        catch (error) {
+            // 查询失败时保守返回 ['id']，避免阻断正常流程
+            console.warn('[CrudProQuick] 获取主键列失败，使用默认值 ["id"]:', error);
+            return ['id'];
+        }
+    }
     /**
      * 根据主键 ID 查询单条记录
      *
@@ -441,9 +513,14 @@ class CrudProQuick {
     /**
      * 根据主键 ID 列表查询多条记录
      *
-     * 等价于 `findList({ condition: { id: { $in: ids } } })`，但更简洁。
+     * 实现逻辑：
+     * 1. 先对 ids 去重，避免重复 ID 导致无效查询和重复结果
+     * 2. 若去重后为空，直接返回空结果
+     * 3. 若 ID 数量不超过批次大小，单次 findList 查询完成
+     * 4. 若 ID 数量超过批次大小，自动分批查询（每批默认 200 个 ID），
+     *    避免单次 IN 列表过大导致执行计划退化和内存尖峰，最后合并结果返回
      *
-     * @param ids 主键值数组
+     * @param ids 主键值数组（内部会自动去重）
      * @param sqlTable 数据库表名，若构造实例时已设置全局 sqlTable 则可省略
      * @returns CrudQueryListResult 包含 rows、count 和 getRawContext()
      *
@@ -456,7 +533,24 @@ class CrudProQuick {
      * const result = await quick.findListByIds(['ORD001', 'ORD002'], 't_order');
      */
     async findListByIds(ids, sqlTable) {
-        return this.findList({ condition: { id: { $in: ids } } }, sqlTable);
+        // 去重：避免重复 ID 导致无效查询和重复结果
+        const uniqueIds = [...new Set(ids)];
+        const batchSize = this.baseCfgModel.batchSizeForIdsQuery || DEFAULT_BATCH_SIZE_FOR_IDS_QUERY;
+        if (uniqueIds.length === 0) {
+            return new CrudResult_1.CrudQueryListResult({ rows: [], rawContext: null });
+        }
+        if (uniqueIds.length <= batchSize) {
+            return this.findList({ condition: { id: { $in: uniqueIds } } }, sqlTable);
+        }
+        const allRows = [];
+        let lastRawContext = null;
+        for (let i = 0; i < uniqueIds.length; i += batchSize) {
+            const batchIds = uniqueIds.slice(i, i + batchSize);
+            const batchResult = await this.findList({ condition: { id: { $in: batchIds } } }, sqlTable);
+            allRows.push(...batchResult.rows);
+            lastRawContext = batchResult.getRawContext();
+        }
+        return new CrudResult_1.CrudQueryListResult({ rows: allRows, rawContext: lastRawContext });
     }
     /**
      * 执行自定义 SQL 语句（经 CrudPro 框架封装处理）
@@ -525,5 +619,71 @@ class CrudProQuick {
         };
         return await this.crudProFactory().executeSQL(sqlCfgModel);
     }
+    /**
+     * findOne 的快捷方式，直接返回 row
+     *
+     * @example
+     * const row = await quick.getOne({ condition: { id: 1 } });
+     * // 等价于 (await quick.findOne({ condition: { id: 1 } })).row
+     */
+    async getOne(reqJson, sqlTable) {
+        const res = await this.findOne(reqJson, sqlTable);
+        return res.row;
+    }
+    /**
+     * findUniqueOne 的快捷方式，直接返回 row
+     *
+     * @example
+     * const row = await quick.getUniqueOne({ condition: { order_id: 'ORD001' } });
+     * // 等价于 (await quick.findUniqueOne({ condition: { order_id: 'ORD001' } })).row
+     */
+    async getUniqueOne(reqJson, sqlTable) {
+        const res = await this.findUniqueOne(reqJson, sqlTable);
+        return res.row;
+    }
+    /**
+     * findList 的快捷方式，直接返回 rows
+     *
+     * @example
+     * const rows = await quick.getList({ condition: { status: 'active' } });
+     * // 等价于 (await quick.findList({ condition: { status: 'active' } })).rows
+     */
+    async getList(reqJson, sqlTable) {
+        const res = await this.findList(reqJson, sqlTable);
+        return res.rows;
+    }
+    /**
+     * findCount 的快捷方式，直接返回 count
+     *
+     * @example
+     * const count = await quick.getCount({ condition: { status: 'active' } });
+     * // 等价于 (await quick.findCount({ condition: { status: 'active' } })).count
+     */
+    async getCount(reqJson, sqlTable) {
+        const res = await this.findCount(reqJson, sqlTable);
+        return res.count;
+    }
+    /**
+     * isExist 的快捷方式，直接返回 exists
+     *
+     * @example
+     * const exists = await quick.getIsExist({ condition: { id: 1 } });
+     * // 等价于 (await quick.isExist({ condition: { id: 1 } })).exists
+     */
+    async getIsExist(reqJson, sqlTable) {
+        const res = await this.isExist(reqJson, sqlTable);
+        return res.exists;
+    }
+    /**
+     * findOneById 的快捷方式，直接返回 row
+     *
+     * @example
+     * const row = await quick.getOneById(1);
+     * // 等价于 (await quick.findOneById(1)).row
+     */
+    async getOneById(id, sqlTable) {
+        const res = await this.findOneById(id, sqlTable);
+        return res.row;
+    }
 }
 exports.CrudProQuick = CrudProQuick;

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

@@ -0,0 +1,78 @@
+import { IRequestModel, IRequestCfgModel } from '../../libs/crud-pro/interfaces';
+import { ExecuteContext } from '../../libs/crud-pro/models/ExecuteContext';
+import { KeysOfSimpleSQL } from '../../libs/crud-pro/models/keys';
+import { IShardingConfig, IShardingRouterContext, CrudProFactory } from './ShardingConfig';
+import { ShardingTableCreator } from './ShardingTableCreator';
+import { CrudWriteResult, CrudQueryOneResult, CrudQueryListResult, CrudQueryPageResult, CrudExistResult, CrudCountResult, CrudUpsertResult } from '../../libs/crud-pro/models/CrudResult';
+import { ShardingBatchInsertResult } from './ShardingResult';
+/**
+ * 分表 CRUD 基类
+ *
+ * 提供所有分表子类共用的基础设施方法，不包含任何路由逻辑。
+ * 路由逻辑由各子类自行实现。
+ *
+ * 子类：
+ * - ShardingByTimeCrud: 时间分表（YEAR/MONTH/DAY）
+ * - ShardingByHashCrud: 哈希分表
+ * - ShardingByKeyCrud: 键值分表
+ * - ShardingByCustomCrud: 自定义分表
+ */
+export declare abstract class ShardingBase {
+    protected readonly crudProFactory: CrudProFactory;
+    protected readonly config: IShardingConfig;
+    protected readonly tableCreator: ShardingTableCreator;
+    protected baseCfg: Partial<IRequestCfgModel>;
+    protected enableSoftDelete: boolean;
+    constructor(crudProFactory: CrudProFactory, config: IShardingConfig);
+    setBaseCfg(cfg: Partial<IRequestCfgModel>): this;
+    getConfig(): IShardingConfig;
+    setEnableSoftDelete(enable: boolean): this;
+    abstract insert(reqJson: IRequestModel): Promise<CrudWriteResult>;
+    abstract batchInsert(reqJson: IRequestModel): Promise<ShardingBatchInsertResult>;
+    abstract update(reqJson: IRequestModel): Promise<CrudWriteResult>;
+    abstract delete(reqJson: IRequestModel): Promise<CrudWriteResult>;
+    abstract restore(reqJson: IRequestModel): Promise<CrudWriteResult>;
+    abstract insertOrUpdate(reqJson: IRequestModel): Promise<CrudUpsertResult>;
+    abstract findOne<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryOneResult<T>>;
+    abstract findUniqueOne<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryOneResult<T>>;
+    abstract findList<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryListResult<T>>;
+    abstract findPage<T = Record<string, any>>(reqJson: IRequestModel): Promise<CrudQueryPageResult<T>>;
+    abstract findCount(reqJson: IRequestModel): Promise<CrudCountResult>;
+    abstract isExist(reqJson: IRequestModel): Promise<CrudExistResult>;
+    /**
+     * 判断当前路由上下文是否处于「插入阶段」（应从 data 提取分表字段）
+     *
+     * - INSERT / BATCH_INSERT → 始终从 data
+     * - 其余操作（QUERY / UPDATE / DELETE / INSERT_OR_UPDATE）→ 从 condition
+     */
+    protected static isInsertPhase(ctx: IShardingRouterContext): boolean;
+    protected buildCfg(sqlSimpleName: KeysOfSimpleSQL): IRequestCfgModel & {
+        enableSoftDelete?: boolean;
+    };
+    protected executeOnTable(table: string, reqJson: IRequestModel, sqlSimpleName: KeysOfSimpleSQL, extraCfg?: Partial<IRequestCfgModel>): Promise<ExecuteContext>;
+    protected findCountFromTable(table: string, reqJson: IRequestModel): Promise<{
+        count: number;
+        ctx: ExecuteContext | null;
+    }>;
+    protected isExistInTable(table: string, reqJson: IRequestModel): Promise<{
+        exists: boolean;
+        ctx: ExecuteContext | null;
+    }>;
+    protected getExistingTablesSet(skipCache?: boolean): Promise<Set<string>>;
+    protected isTableExists(tableName: string): Promise<boolean>;
+    protected createShardingTableIfNeeded(tableName: string): Promise<void>;
+    protected buildDebugInfo(sqlTable: string | undefined, condition: Record<string, any> | undefined): {
+        sqlDatabase: string;
+        sqlTable: string;
+        condition?: Record<string, any>;
+    };
+    protected formatUniqueError(foundCount: number, tables: string | string[], condition: Record<string, any> | undefined, isMultiTable?: boolean): string;
+    /**
+     * 获取所有以 baseTable_ 开头的已存在分表（按字典序排序）
+     */
+    protected getAllExistingShardingTables(): Promise<string[]>;
+    /**
+     * 过滤出真实存在的分表
+     */
+    protected filterExistingTables(candidateTables: string[]): Promise<string[]>;
+}