koishi-plugin-kkk 3.7.2 → 3.9.0

package/lib/karin/module/db/statistics.js

@@ -1,18 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StatisticsDBBase = exports.resolveMetricBucket = exports.METRIC_BUCKETS = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
+const koishi_1 = require("koishi");
 const node_karin_1 = require("../../../compat/node-karin.js");
-const root_1 = require("../../../compat/root.js");
-const sqlite3_1 = __importDefault(require("../../../compat/sqlite3.js"));
-// 直接吃 @/root 而不是 @/module/utils 桶：桶会把 ./Common 拖进来，
-// 而 Common 又回头 import @/module（含本文件），形成环。
-const root_2 = require("../../root");
-const migration_1 = require("./migration");
+const model_1 = require("./model");
 /**
  * 指标的分桶边界（左闭右开）。`duration` 单位毫秒。
  *
@@ -55,29 +46,27 @@ const resolveMetricBucket = (metric, value) => {
     return (buckets.find((bucket) => value < bucket.max) ?? buckets[buckets.length - 1]).label;
 };
 exports.resolveMetricBucket = resolveMetricBucket;
-/** 统计数据库操作类 */
+/** UTC 日期（YYYY-MM-DD），与旧版 sqlite 里 `date('now')` 的口径一致 */
+const today = () => new Date().toISOString().split('T')[0];
+/** 当前时间戳（ISO 字符串） */
+const now = () => new Date().toISOString();
+/** 统计数据库操作类（基于 Koishi 原生数据库服务） */
 class StatisticsDBBase {
-    db;
-    dbPath;
-    migrationManager;
-    /**
-     * @param dbPath 数据库文件路径；缺省用插件数据目录。
-     *   显式传入只为测试：生产链路由 `getStatisticsDB()` 单例统一构造，不该走这个参数。
-     */
-    constructor(dbPath) {
-        this.dbPath = dbPath ?? node_path_1.default.join(`${root_1.karinPathBase}/${root_2.Root.pluginName}/data`, 'statistics.db');
-        this.migrationManager = new migration_1.MigrationManager(this.dbPath);
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    get db() {
+        return this.ctx.database;
     }
     /**
      * 关闭数据库连接。
-     * 生产链路上进程退出即可，不需要显式调用；测试里必须关，否则 Windows 下临时目录删不掉。
+     *
+     * 现在连接由 Koishi 的数据库服务统一管理，这里不需要做任何事；
+     * 保留这个方法只是为了兼容老调用方（测试脚本会调）。
      */
     async close() {
-        if (!this.db)
-            return;
-        await new Promise((resolve, reject) => {
-            this.db.close((err) => (err ? reject(err) : resolve()));
-        });
+        /* 由 Koishi 托管，无需手动关闭 */
     }
     /**
      * 初始化数据库
@@ -85,12 +74,7 @@ class StatisticsDBBase {
     async init() {
         try {
             node_karin_1.logger.debug(node_karin_1.logger.green('--------------------------[StatisticsDB] 开始初始化数据库--------------------------'));
-            node_karin_1.logger.debug('[StatisticsDB] 正在连接数据库...');
-            // 创建数据库连接
-            node_fs_1.default.mkdirSync(node_path_1.default.dirname(this.dbPath), { recursive: true });
-            this.db = new sqlite3_1.default.Database(this.dbPath);
-            // 创建表结构
-            await this.createTables();
+            node_karin_1.logger.debug('[StatisticsDB] 使用 Koishi 原生数据库服务，表已由 ctx.model.extend 注册');
             node_karin_1.logger.debug('[StatisticsDB] 数据库模型同步成功');
             // 初始化全局统计数据
             await this.initGlobalStatistics();
@@ -104,139 +88,17 @@ class StatisticsDBBase {
         }
         return this;
     }
-    /**
-     * 创建数据库表结构
-     */
-    async createTables() {
-        const queries = [
-            // 创建解析统计表
-            `CREATE TABLE IF NOT EXISTS ParseStatistics (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        groupId TEXT NOT NULL,
-        userId TEXT NOT NULL,
-        platform TEXT NOT NULL,
-        parseCount INTEGER DEFAULT 0,
-        createdAt TEXT DEFAULT CURRENT_TIMESTAMP,
-        updatedAt TEXT DEFAULT CURRENT_TIMESTAMP,
-        UNIQUE(groupId, userId, platform)
-      )`,
-            // 创建解析历史表
-            `CREATE TABLE IF NOT EXISTS ParseHistory (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        date TEXT NOT NULL UNIQUE,
-        totalParses INTEGER DEFAULT 0,
-        douyin INTEGER DEFAULT 0,
-        bilibili INTEGER DEFAULT 0,
-        kuaishou INTEGER DEFAULT 0,
-        xiaohongshu INTEGER DEFAULT 0,
-        createdAt TEXT DEFAULT CURRENT_TIMESTAMP
-      )`,
-            // 创建全局统计表
-            `CREATE TABLE IF NOT EXISTS GlobalStatistics (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        updatedAt TEXT DEFAULT CURRENT_TIMESTAMP
-      )`,
-            // 群维度日粒度：ParseHistory 只有全局日粒度，画不出单群趋势
-            `CREATE TABLE IF NOT EXISTS GroupParseHistory (
-        groupId TEXT NOT NULL,
-        date TEXT NOT NULL,
-        platform TEXT NOT NULL,
-        parseCount INTEGER DEFAULT 0,
-        updatedAt TEXT DEFAULT CURRENT_TIMESTAMP,
-        PRIMARY KEY (groupId, date, platform)
-      )`,
-            // 小时粒度活跃分布：行数有界（群数 × 24 × 4），可以按小时永久聚合
-            `CREATE TABLE IF NOT EXISTS ParseHourStats (
-        groupId TEXT NOT NULL,
-        hour INTEGER NOT NULL,
-        platform TEXT NOT NULL,
-        parseCount INTEGER DEFAULT 0,
-        updatedAt TEXT DEFAULT CURRENT_TIMESTAMP,
-        PRIMARY KEY (groupId, hour, platform)
-      )`,
-            // 内容形态分布：支撑「平台 × 形态」图
-            `CREATE TABLE IF NOT EXISTS ParseWorkTypeStats (
-        groupId TEXT NOT NULL,
-        platform TEXT NOT NULL,
-        workType TEXT NOT NULL,
-        parseCount INTEGER DEFAULT 0,
-        updatedAt TEXT DEFAULT CURRENT_TIMESTAMP,
-        PRIMARY KEY (groupId, platform, workType)
-      )`,
-            // 解析耗时 / 作品时长 / 作品点赞的分桶分布。
-            // 存桶而不是原值：原值每次解析都不同，行数会随解析次数无限涨；
-            // 分桶后行数上界是 群数 × 指标数 × 桶数。
-            `CREATE TABLE IF NOT EXISTS ParseMetricStats (
-        groupId TEXT NOT NULL,
-        metric TEXT NOT NULL,
-        bucket TEXT NOT NULL,
-        parseCount INTEGER DEFAULT 0,
-        updatedAt TEXT DEFAULT CURRENT_TIMESTAMP,
-        PRIMARY KEY (groupId, metric, bucket)
-      )`
-        ];
-        for (const query of queries) {
-            await this.runQuery(query);
-        }
-    }
     /**
      * 初始化全局统计数据
      */
     async initGlobalStatistics() {
-        const keys = ['totalGroups', 'totalParses'];
-        for (const key of keys) {
-            const exists = await this.getQuery('SELECT * FROM GlobalStatistics WHERE key = ?', [key]);
-            if (!exists) {
-                await this.runQuery('INSERT INTO GlobalStatistics (key, value, updatedAt) VALUES (?, ?, ?)', [key, '0', new Date().toISOString()]);
-            }
+        for (const key of ['totalGroups', 'totalParses']) {
+            const [row] = await this.db.get(model_1.TABLE.statsGlobal, { key });
+            if (row)
+                continue;
+            await this.db.create(model_1.TABLE.statsGlobal, { key, value: 0, updatedAt: now() });
         }
     }
-    /**
-     * 执行SQL查询
-     */
-    runQuery(sql, params = []) {
-        return new Promise((resolve, reject) => {
-            this.db.run(sql, params, function (err) {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve({ lastID: this.lastID, changes: this.changes });
-                }
-            });
-        });
-    }
-    /**
-     * 执行SQL查询并获取单个结果
-     */
-    getQuery(sql, params = []) {
-        return new Promise((resolve, reject) => {
-            this.db.get(sql, params, (err, row) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(row);
-                }
-            });
-        });
-    }
-    /**
-     * 执行SQL查询并获取所有结果
-     */
-    allQuery(sql, params = []) {
-        return new Promise((resolve, reject) => {
-            this.db.all(sql, params, (err, rows) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(rows);
-                }
-            });
-        });
-    }
     /**
      * 记录解析统计
      * @param groupId 群组ID
@@ -246,30 +108,40 @@ class StatisticsDBBase {
      * @param options.durationMs 本次解析耗时（毫秒）
      */
     async recordParse(groupId, userId, platform, options = {}) {
-        const now = new Date().toISOString();
-        const today = new Date().toISOString().split('T')[0];
+        const time = now();
+        const date = today();
         // 检查是否已存在该用户在该群组的统计记录
-        const existing = await this.getQuery('SELECT * FROM ParseStatistics WHERE groupId = ? AND userId = ? AND platform = ?', [groupId, userId, platform]);
+        const [existing] = await this.db.get(model_1.TABLE.statsParse, { groupId, userId, platform });
         if (existing) {
             // 更新解析次数
-            await this.runQuery('UPDATE ParseStatistics SET parseCount = parseCount + 1, updatedAt = ? WHERE groupId = ? AND userId = ? AND platform = ?', [now, groupId, userId, platform]);
+            await this.db.set(model_1.TABLE.statsParse, { groupId, userId, platform }, (row) => ({
+                parseCount: koishi_1.$.add(koishi_1.$.ifNull(row.parseCount, 0), 1),
+                updatedAt: time
+            }));
         }
         else {
             // 创建新记录
-            await this.runQuery('INSERT INTO ParseStatistics (groupId, userId, platform, parseCount, createdAt, updatedAt) VALUES (?, ?, ?, 1, ?, ?)', [groupId, userId, platform, now, now]);
+            await this.db.create(model_1.TABLE.statsParse, {
+                groupId,
+                userId,
+                platform,
+                parseCount: 1,
+                createdAt: time,
+                updatedAt: time
+            });
             // 检查是否是新群组
-            const groupExists = await this.getQuery('SELECT COUNT(DISTINCT groupId) as count FROM ParseStatistics WHERE groupId = ?', [groupId]);
-            if (groupExists && groupExists.count === 1) {
+            const groupRows = await this.db.get(model_1.TABLE.statsParse, { groupId }, { limit: 2 });
+            if (groupRows.length === 1) {
                 await this.incrementTotalGroups();
             }
         }
         // 更新总解析次数
         await this.incrementTotalParses();
         // 更新每日历史记录
-        await this.updateDailyHistory(today, platform);
+        await this.updateDailyHistory(date, platform);
         // 以下是本次新增的维度。任何一张写失败都不该让解析主流程或其它维度受影响，
         // 所以逐条兜住，只记日志。
-        await this.safeIncrement('群维度日粒度', () => this.incrementGroupHistory(groupId, today, platform));
+        await this.safeIncrement('群维度日粒度', () => this.incrementGroupHistory(groupId, date, platform));
         await this.safeIncrement('活跃时段', () => this.incrementHourStats(groupId, new Date().getHours(), platform));
         if (options.workType) {
             await this.safeIncrement('内容形态', () => this.incrementWorkTypeStats(groupId, platform, options.workType));
@@ -295,29 +167,49 @@ class StatisticsDBBase {
      * 群维度日粒度自增
      */
     async incrementGroupHistory(groupId, date, platform) {
-        await this.runQuery(`INSERT INTO GroupParseHistory (groupId, date, platform, parseCount, updatedAt) VALUES (?, ?, ?, 1, ?)
-       ON CONFLICT(groupId, date, platform) DO UPDATE SET parseCount = parseCount + 1, updatedAt = excluded.updatedAt`, [groupId, date, platform, new Date().toISOString()]);
+        await this.db.upsert(model_1.TABLE.statsGroupHistory, (row) => [{
+                groupId,
+                date,
+                platform,
+                parseCount: koishi_1.$.add(koishi_1.$.ifNull(row.parseCount, 0), 1),
+                updatedAt: now()
+            }]);
     }
     /**
      * 小时粒度自增
      */
     async incrementHourStats(groupId, hour, platform) {
-        await this.runQuery(`INSERT INTO ParseHourStats (groupId, hour, platform, parseCount, updatedAt) VALUES (?, ?, ?, 1, ?)
-       ON CONFLICT(groupId, hour, platform) DO UPDATE SET parseCount = parseCount + 1, updatedAt = excluded.updatedAt`, [groupId, hour, platform, new Date().toISOString()]);
+        await this.db.upsert(model_1.TABLE.statsHour, (row) => [{
+                groupId,
+                hour,
+                platform,
+                parseCount: koishi_1.$.add(koishi_1.$.ifNull(row.parseCount, 0), 1),
+                updatedAt: now()
+            }]);
     }
     /**
      * 内容形态自增
      */
     async incrementWorkTypeStats(groupId, platform, workType) {
-        await this.runQuery(`INSERT INTO ParseWorkTypeStats (groupId, platform, workType, parseCount, updatedAt) VALUES (?, ?, ?, 1, ?)
-       ON CONFLICT(groupId, platform, workType) DO UPDATE SET parseCount = parseCount + 1, updatedAt = excluded.updatedAt`, [groupId, platform, workType, new Date().toISOString()]);
+        await this.db.upsert(model_1.TABLE.statsWorkType, (row) => [{
+                groupId,
+                platform,
+                workType,
+                parseCount: koishi_1.$.add(koishi_1.$.ifNull(row.parseCount, 0), 1),
+                updatedAt: now()
+            }]);
     }
     /**
      * 指标分桶自增
      */
     async incrementMetricStats(groupId, metric, bucket) {
-        await this.runQuery(`INSERT INTO ParseMetricStats (groupId, metric, bucket, parseCount, updatedAt) VALUES (?, ?, ?, 1, ?)
-       ON CONFLICT(groupId, metric, bucket) DO UPDATE SET parseCount = parseCount + 1, updatedAt = excluded.updatedAt`, [groupId, metric, bucket, new Date().toISOString()]);
+        await this.db.upsert(model_1.TABLE.statsMetric, (row) => [{
+                groupId,
+                metric,
+                bucket,
+                parseCount: koishi_1.$.add(koishi_1.$.ifNull(row.parseCount, 0), 1),
+                updatedAt: now()
+            }]);
     }
     /**
      * 更新每日历史记录
@@ -325,21 +217,24 @@ class StatisticsDBBase {
      * @param platform 平台类型
      */
     async updateDailyHistory(date, platform) {
-        const now = new Date().toISOString();
         try {
-            const existing = await this.getQuery('SELECT * FROM ParseHistory WHERE date = ?', [date]);
+            const [existing] = await this.db.get(model_1.TABLE.statsHistory, { date });
             if (existing) {
-                await this.runQuery(`UPDATE ParseHistory SET totalParses = totalParses + 1, ${platform} = ${platform} + 1 WHERE date = ?`, [date]);
+                await this.db.set(model_1.TABLE.statsHistory, { date }, (row) => ({
+                    totalParses: koishi_1.$.add(koishi_1.$.ifNull(row.totalParses, 0), 1),
+                    [platform]: koishi_1.$.add(koishi_1.$.ifNull(row[platform], 0), 1)
+                }));
             }
             else {
-                await this.runQuery('INSERT INTO ParseHistory (date, totalParses, douyin, bilibili, kuaishou, xiaohongshu, createdAt) VALUES (?, 1, ?, ?, ?, ?, ?)', [
+                await this.db.create(model_1.TABLE.statsHistory, {
                     date,
-                    platform === 'douyin' ? 1 : 0,
-                    platform === 'bilibili' ? 1 : 0,
-                    platform === 'kuaishou' ? 1 : 0,
-                    platform === 'xiaohongshu' ? 1 : 0,
-                    now
-                ]);
+                    totalParses: 1,
+                    douyin: platform === 'douyin' ? 1 : 0,
+                    bilibili: platform === 'bilibili' ? 1 : 0,
+                    kuaishou: platform === 'kuaishou' ? 1 : 0,
+                    xiaohongshu: platform === 'xiaohongshu' ? 1 : 0,
+                    createdAt: now()
+                });
             }
         }
         catch (error) {
@@ -351,7 +246,10 @@ class StatisticsDBBase {
      * @param days 天数，默认30天
      */
     async getRecentHistory(days = 30) {
-        return await this.allQuery('SELECT * FROM ParseHistory ORDER BY date DESC LIMIT ?', [days]);
+        return (await this.db.get(model_1.TABLE.statsHistory, {}, {
+            sort: { date: 'desc' },
+            limit: days
+        }));
     }
     /**
      * 从现有统计数据同步历史记录（用于迁移后的数据修复）
@@ -359,32 +257,36 @@ class StatisticsDBBase {
     async syncHistoryFromStats() {
         try {
             // 检查 ParseHistory 表是否为空
-            const historyCount = await this.getQuery('SELECT COUNT(*) as count FROM ParseHistory');
+            const historyRows = await this.db.get(model_1.TABLE.statsHistory, {}, { limit: 1 });
             // 如果已有历史数据，不需要同步
-            if (historyCount && historyCount.count > 0) {
+            if (historyRows.length)
                 return;
-            }
             // 获取所有统计数据
-            const allStats = await this.getAllStatistics();
+            const allStats = await this.db.get(model_1.TABLE.statsParse, {});
             // 按日期和平台聚合
             const dateMap = new Map();
             for (const stat of allStats) {
                 const date = stat.createdAt.split('T')[0];
                 if (!dateMap.has(date)) {
-                    dateMap.set(date, {
-                        douyin: 0,
-                        bilibili: 0,
-                        kuaishou: 0,
-                        xiaohongshu: 0
-                    });
+                    dateMap.set(date, { douyin: 0, bilibili: 0, kuaishou: 0, xiaohongshu: 0 });
                 }
                 const dateData = dateMap.get(date);
-                dateData[stat.platform] += stat.parseCount;
+                if (stat.platform in dateData) {
+                    dateData[stat.platform] += stat.parseCount ?? 0;
+                }
             }
             // 插入历史记录
             for (const [date, platforms] of dateMap.entries()) {
                 const totalParses = platforms.douyin + platforms.bilibili + platforms.kuaishou + platforms.xiaohongshu;
-                await this.runQuery('INSERT OR IGNORE INTO ParseHistory (date, totalParses, douyin, bilibili, kuaishou, xiaohongshu, createdAt) VALUES (?, ?, ?, ?, ?, ?, ?)', [date, totalParses, platforms.douyin, platforms.bilibili, platforms.kuaishou, platforms.xiaohongshu, new Date().toISOString()]);
+                await this.db.create(model_1.TABLE.statsHistory, {
+                    date,
+                    totalParses,
+                    douyin: platforms.douyin,
+                    bilibili: platforms.bilibili,
+                    kuaishou: platforms.kuaishou,
+                    xiaohongshu: platforms.xiaohongshu,
+                    createdAt: now()
+                });
             }
             node_karin_1.logger.info(`[StatisticsDB] 已同步 ${dateMap.size} 天的历史数据`);
         }
@@ -397,145 +299,185 @@ class StatisticsDBBase {
      * @param groupId 群组ID
      */
     async getGroupStatistics(groupId) {
-        return await this.allQuery('SELECT * FROM ParseStatistics WHERE groupId = ? ORDER BY platform, userId', [groupId]);
+        return (await this.db.get(model_1.TABLE.statsParse, { groupId }, {
+            sort: { platform: 'asc', userId: 'asc' }
+        }));
     }
     /**
      * 获取群组的唯一用户数
      * @param groupId 群组ID
      */
     async getGroupUniqueUsers(groupId) {
-        const result = await this.getQuery('SELECT COUNT(DISTINCT userId) as count FROM ParseStatistics WHERE groupId = ?', [
-            groupId
-        ]);
-        return result?.count || 0;
+        const rows = await this.db.get(model_1.TABLE.statsParse, { groupId });
+        return new Set(rows.map((row) => row.userId)).size;
     }
     /**
      * 获取全局唯一用户数
      */
     async getTotalUniqueUsers() {
-        const result = await this.getQuery('SELECT COUNT(DISTINCT userId) as count FROM ParseStatistics');
-        return result?.count || 0;
+        const rows = await this.db.get(model_1.TABLE.statsParse, {});
+        return new Set(rows.map((row) => row.userId)).size;
     }
     /**
      * 获取所有群组的解析统计
      */
     async getAllStatistics() {
-        return await this.allQuery('SELECT * FROM ParseStatistics ORDER BY groupId, platform');
+        return (await this.db.get(model_1.TABLE.statsParse, {}, {
+            sort: { groupId: 'asc', platform: 'asc' }
+        }));
     }
     /**
      * 获取平台总解析次数
      * @param platform 平台类型
      */
     async getPlatformTotalParses(platform) {
-        const result = await this.getQuery('SELECT SUM(parseCount) as total FROM ParseStatistics WHERE platform = ?', [
-            platform
-        ]);
-        return result?.total || 0;
+        const rows = await this.db.get(model_1.TABLE.statsParse, { platform });
+        return rows.reduce((sum, row) => sum + (Number(row.parseCount) || 0), 0);
     }
     /**
      * 获取某个群最近 N 天的日粒度记录（按日期升序，便于直接喂折线图）
      *
-     * 日期口径与写入端一致，都取 `toISOString()` 的 UTC 日期；
-     * SQLite 的 `date('now')` 同样是 UTC，两边不会错位。
+     * 日期口径与写入端一致，都取 `toISOString()` 的 UTC 日期。
      * @param groupId 群组ID
      * @param days 天数，默认 30 天
      */
     async getGroupRecentHistory(groupId, days = 30) {
-        return await this.allQuery(`SELECT * FROM GroupParseHistory
-       WHERE groupId = ? AND date >= date('now', ?)
-       ORDER BY date`, [groupId, `-${Math.max(0, days - 1)} days`]);
+        const from = new Date();
+        from.setUTCDate(from.getUTCDate() - Math.max(0, days - 1));
+        const cutoff = from.toISOString().split('T')[0];
+        return (await this.db.get(model_1.TABLE.statsGroupHistory, {
+            groupId,
+            date: { $gte: cutoff }
+        }, { sort: { date: 'asc' } }));
     }
     /**
      * 获取某个群有解析记录的天数（不限于最近 N 天）
      * @param groupId 群组ID
      */
     async getGroupActiveDays(groupId) {
-        const result = await this.getQuery('SELECT COUNT(DISTINCT date) as count FROM GroupParseHistory WHERE groupId = ?', [groupId]);
-        return result?.count || 0;
+        const rows = await this.db.get(model_1.TABLE.statsGroupHistory, { groupId });
+        return new Set(rows.map((row) => row.date)).size;
     }
     /**
      * 获取某个群的小时粒度分布（0-23，缺失的小时由调用方补零）
      * @param groupId 群组ID
      */
     async getGroupHourStats(groupId) {
-        return await this.allQuery('SELECT * FROM ParseHourStats WHERE groupId = ? ORDER BY hour', [groupId]);
+        return (await this.db.get(model_1.TABLE.statsHour, { groupId }, { sort: { hour: 'asc' } }));
     }
     /**
      * 获取某个群的内容形态分布
      * @param groupId 群组ID
      */
     async getGroupWorkTypeStats(groupId) {
-        return await this.allQuery('SELECT * FROM ParseWorkTypeStats WHERE groupId = ? ORDER BY parseCount DESC', [groupId]);
+        return (await this.db.get(model_1.TABLE.statsWorkType, { groupId }, {
+            sort: { parseCount: 'desc' }
+        }));
     }
     /**
      * 获取全局内容形态分布（按平台 × 形态聚合）
      */
     async getGlobalWorkTypeStats() {
-        return await this.allQuery(`SELECT groupId, platform, workType, SUM(parseCount) as parseCount, MAX(updatedAt) as updatedAt
-       FROM ParseWorkTypeStats GROUP BY platform, workType ORDER BY platform, parseCount DESC`);
+        const rows = await this.db.get(model_1.TABLE.statsWorkType, {});
+        const map = new Map();
+        for (const row of rows) {
+            const key = row.platform + '' + row.workType;
+            const current = map.get(key);
+            if (current) {
+                current.parseCount += Number(row.parseCount) || 0;
+                if ((row.updatedAt ?? '') > (current.updatedAt ?? ''))
+                    current.updatedAt = row.updatedAt;
+            }
+            else {
+                map.set(key, { ...row, parseCount: Number(row.parseCount) || 0 });
+            }
+        }
+        return [...map.values()].sort((a, b) => {
+            if (a.platform !== b.platform)
+                return a.platform < b.platform ? -1 : 1;
+            return (Number(b.parseCount) || 0) - (Number(a.parseCount) || 0);
+        });
     }
     /**
      * 获取某个群的指标分桶分布（耗时 / 作品时长 / 点赞）
      * @param groupId 群组ID
      */
     async getGroupMetricStats(groupId) {
-        return await this.allQuery('SELECT metric, bucket, SUM(parseCount) as count FROM ParseMetricStats WHERE groupId = ? GROUP BY metric, bucket', [groupId]);
+        const rows = await this.db.get(model_1.TABLE.statsMetric, { groupId });
+        return aggregateMetrics(rows);
     }
     /**
      * 获取全局指标分桶分布（耗时 / 作品时长 / 点赞）
      */
     async getGlobalMetricStats() {
-        return await this.allQuery('SELECT metric, bucket, SUM(parseCount) as count FROM ParseMetricStats GROUP BY metric, bucket');
+        const rows = await this.db.get(model_1.TABLE.statsMetric, {});
+        return aggregateMetrics(rows);
     }
     /**
      * 取全局日粒度趋势里「数据可信」的起始日期。
      * @returns 可信起始日（YYYY-MM-DD）；一行可信数据都没有时返回 undefined
      */
     async getHistoryCompleteFrom() {
+        // 老库回填（syncHistoryFromStats）会把用户的历史总次数全记在他首次解析那天，
         // 那批行的特征是 date 与写入时间 createdAt 不在同一天；
         // 增量写入的行两者必然同天（都取 UTC）。据此切出可信区间的起点。
-        const result = await this.getQuery('SELECT MIN(date) as date FROM ParseHistory WHERE date = substr(createdAt, 1, 10)');
-        return result?.date || undefined;
+        const rows = await this.db.get(model_1.TABLE.statsHistory, {});
+        let min;
+        for (const row of rows) {
+            if (!row.date || row.date !== String(row.createdAt ?? '').slice(0, 10))
+                continue;
+            if (!min || row.date < min)
+                min = row.date;
+        }
+        return min;
     }
     /**
      * 获取每个群首次被记录解析的日期（群增长曲线的数据源）
      */
     async getGroupFirstSeen() {
-        return await this.allQuery('SELECT groupId, MIN(createdAt) as firstSeen FROM ParseStatistics GROUP BY groupId');
+        const rows = await this.db.get(model_1.TABLE.statsParse, {});
+        const map = new Map();
+        for (const row of rows) {
+            if (!row.createdAt)
+                continue;
+            const current = map.get(row.groupId);
+            if (!current || row.createdAt < current)
+                map.set(row.groupId, row.createdAt);
+        }
+        return [...map.entries()].map(([groupId, firstSeen]) => ({ groupId, firstSeen }));
     }
     /**
      * 获取总群组数
      */
     async getTotalGroups() {
-        const result = await this.getQuery('SELECT COUNT(DISTINCT groupId) as count FROM ParseStatistics');
-        return result?.count || 0;
+        const rows = await this.db.get(model_1.TABLE.statsParse, {});
+        return new Set(rows.map((row) => row.groupId)).size;
     }
     /**
      * 获取总解析次数
      */
     async getTotalParses() {
-        const result = await this.getQuery('SELECT value FROM GlobalStatistics WHERE key = ?', ['totalParses']);
-        return parseInt(result?.value || '0', 10);
+        const [row] = await this.db.get(model_1.TABLE.statsGlobal, { key: 'totalParses' });
+        return Number(row?.value ?? 0) || 0;
     }
     /**
      * 增加总群组数
      */
     async incrementTotalGroups() {
         const totalGroups = await this.getTotalGroups();
-        await this.runQuery('UPDATE GlobalStatistics SET value = ?, updatedAt = ? WHERE key = ?', [
-            totalGroups.toString(),
-            new Date().toISOString(),
-            'totalGroups'
-        ]);
+        await this.db.set(model_1.TABLE.statsGlobal, { key: 'totalGroups' }, {
+            value: totalGroups,
+            updatedAt: now()
+        });
     }
     /**
      * 增加总解析次数
      */
     async incrementTotalParses() {
-        await this.runQuery('UPDATE GlobalStatistics SET value = value + 1, updatedAt = ? WHERE key = ?', [
-            new Date().toISOString(),
-            'totalParses'
-        ]);
+        await this.db.set(model_1.TABLE.statsGlobal, { key: 'totalParses' }, (row) => ({
+            value: koishi_1.$.add(koishi_1.$.ifNull(row.value, 0), 1),
+            updatedAt: now()
+        }));
     }
     /**
      * 获取全局统计摘要
@@ -557,3 +499,16 @@ class StatisticsDBBase {
     }
 }
 exports.StatisticsDBBase = StatisticsDBBase;
+/** 把指标分桶行按 `metric + bucket` 聚合求和 */
+function aggregateMetrics(rows) {
+    const map = new Map();
+    for (const row of rows) {
+        const key = row.metric + '' + row.bucket;
+        const current = map.get(key);
+        if (current)
+            current.count += Number(row.parseCount) || 0;
+        else
+            map.set(key, { metric: row.metric, bucket: row.bucket, count: Number(row.parseCount) || 0 });
+    }
+    return [...map.values()];
+}