midway-fatcms 0.0.7 → 0.0.8

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

@@ -10,6 +10,15 @@ import { ShardingCountCache, shardingHashCondition } from './ShardingCountCache'
 export interface IShardingPageQueryResult {
   rows: any[];
   total_count: number;
+  lastCtx: ExecuteContext | null;
+}
+
+/**
+ * 列表查询结果
+ */
+export interface IShardingListQueryResult {
+  rows: any[];
+  lastCtx: ExecuteContext | null;
 }
 
 /**
@@ -63,16 +72,17 @@ export class ShardingMerger {
     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: number[] = [];
+    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. 根据累计数量直接定位目标表
@@ -80,17 +90,21 @@ export class ShardingMerger {
 
     // 3. 只查询包含目标数据的分表
     let allRows: any[] = [];
+    let lastCtx: ExecuteContext | null = 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,
     };
   }
 
@@ -118,9 +132,10 @@ export class ShardingMerger {
     reqJson: IRequestModel,
     cfgJson: IRequestCfgModel,
     maxRows: number = 10000
-  ): Promise<any[]> {
+  ): Promise<IShardingListQueryResult> {
     // 串行查询分表，按表顺序拼接，达到上限即停
     let allRows: any[] = [];
+    let lastCtx: ExecuteContext | null = null;
 
     for (const table of tables) {
       const needMore = maxRows - allRows.length;
@@ -128,8 +143,13 @@ export class ShardingMerger {
         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) {
@@ -138,7 +158,7 @@ export class ShardingMerger {
       }
     }
 
-    return allRows;
+    return { rows: allRows, lastCtx };
   }
 
   // ============ 私有方法：分页定位 ============
@@ -256,54 +276,6 @@ export class ShardingMerger {
     }
   }
 
-  /**
-   * 安全查询数据行（表不存在时返回空数组）
-   */
-  private async queryRowsSafe(
-    crudPro: CrudPro,
-    table: string,
-    reqJson: IRequestModel,
-    cfgJson: IRequestCfgModel,
-    limit?: number
-  ): Promise<any[]> {
-    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 取多少条
-   */
-  private async queryRowsSafeWithOffset(
-    crudPro: CrudPro,
-    table: string,
-    reqJson: IRequestModel,
-    cfgJson: IRequestCfgModel,
-    innerOffset: number,
-    innerLimit: number
-  ): Promise<any[]> {
-    try {
-      const ctx = await this.executeQueryWithOffset(crudPro, table, reqJson, cfgJson, innerOffset, innerLimit);
-      return ctx.getResRows() || [];
-    } catch (e) {
-      // 表不存在或其他错误，返回空数组
-      return [];
-    }
-  }
-
   /**
    * 执行 COUNT 查询
    */

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

@@ -0,0 +1,29 @@
+import { ExecuteContext } from '@/libs/crud-pro/models/ExecuteContext';
+import { CrudResultBase } from '@/libs/crud-pro/models/CrudResult';
+
+/** 分表批量插入结果 */
+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;
+  }) {
+    super(data.lastContext);
+    this.totalAffected = data.totalAffected;
+    this.tableResults = data.tableResults;
+    this.tableCount = data.tableCount;
+    this.success = data.success;
+    this.errors = data.errors;
+  }
+}
+
+export { ShardingBatchInsertResult };

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

@@ -166,6 +166,8 @@ export class ShardingRouter {
       return this.formatTableName(baseTable, suffix, config);
     }
 
+    // 时间分表写操作必须包含时间字段
+    // 但查询操作允许回退到 recentTableCount
     const recentCount = this.getRecentCountByGranularity(granularity, config);
     return this.getRecentTables(baseTable, granularity, recentCount, config);
   }
@@ -241,9 +243,10 @@ export class ShardingRouter {
       return this.intersectWithCondition(recentTables, config, condition);
     }
 
-    // 未配置 recentTableCount：所有表与条件取交集，最多取3张
+    // 未配置 recentTableCount：所有表与条件取交集，最多取默认数量
     const intersected = this.intersectWithCondition(shardingTables, config, condition);
-    return intersected.slice(0, 3);
+    const defaultCount = this.getDefaultRecentCount(config);
+    return intersected.slice(0, defaultCount);
   }
 
   private intersectWithCondition(
@@ -268,6 +271,7 @@ export class ShardingRouter {
       return tables.includes(targetTable) ? [targetTable] : [];
     }
 
+    // condition 存在但不包含时间字段，返回所有表（按时间降序）
     return this.sortTablesByTimeDesc(tables);
   }
 
@@ -437,6 +441,8 @@ export class ShardingRouter {
     return tables;
   }
 
+  // ============ 格式化 ============
+
   private getRecentTables(
     baseTable: string,
     granularity: ShardingTimeGranularity,
@@ -473,15 +479,30 @@ export class ShardingRouter {
 
     switch (granularity) {
       case 'year':
-        return 3;
+        return 2;
       case 'month':
-        return 12;
+        return 3;
       case 'day':
         return 7;
     }
   }
 
-  // ============ 计算相关 ============
+  private getDefaultRecentCount(config: IShardingConfig): number {
+    if (config.recentTableCount !== undefined && config.recentTableCount > 0) {
+      return config.recentTableCount;
+    }
+
+    switch (config.type) {
+      case ShardingType.YEAR:
+        return 2;
+      case ShardingType.MONTH:
+        return 3;
+      case ShardingType.DAY:
+        return 7;
+      default:
+        return 3;
+    }
+  }
 
   private calculateRangeIndex(value: any, count: number): number {
     if (typeof value === 'number') {
@@ -503,7 +524,7 @@ export class ShardingRouter {
     return hash;
   }
 
-  // ============ 格式化 ============
+  // ============ 表名格式化 ============
 
   private formatTableName(baseTable: string, suffix: string, config: IShardingConfig): string {
     const formattedSuffix = config.suffixFormatter ? config.suffixFormatter(suffix) : suffix;