baja-lite 1.8.7 → 1.8.9

package/db/service.js

@@ -0,0 +1,1651 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var _a, _b, _c;
+import { _columns, _columnsNoId, _def, _deleteState, _fields, _Hump, _ids, _index, _logicIds, _stateFileName, DBType, Field, LGet, } from 'baja-lite-field';
+import * as ite from 'iterare';
+import { formatDialect, mysql, postgresql, sqlite } from 'sql-formatter';
+import tslib from 'tslib';
+import { Throw } from '../error.js';
+import { excuteSplit, ExcuteSplitMode } from '../fn.js';
+import { calc, ten2Any } from '../math.js';
+import { C2P, C2P2, P2C } from '../object.js';
+import { snowflake } from '../snowflake.js';
+import { emptyString } from '../string.js';
+import { _ClassName, _className, _comment, _Context, _dao, _DataConvert, _daoDBName, _dbType, _GlobalSqlOption, _inTransaction, _LoggerService, _primaryDB, _resultMap_SQLID, _sqlCache, _SqlOption, _sqlite_version, _tableName, _transformer, _vueName, } from '../const/symbols.js';
+import { DeleteMode, InsertMode, SelectMode, SelectResult, SyncMode, TemplateResult, _defOption, } from '../const/types.js';
+import { Sqlite } from './dao/sqlite.js';
+import { SqliteRemote } from './dao/sqlite-remote.js';
+import { flatData } from './sql-template.js';
+import { StreamQuery } from './stream-query.js';
+const iterate = ite.iterate;
+const formatDialects = {
+    [DBType.Mysql]: mysql,
+    [DBType.Sqlite]: sqlite,
+    [DBType.SqliteRemote]: sqlite,
+    [DBType.Postgresql]: postgresql,
+};
+function P(skipConn = false) {
+    return (_target, propertyKey, descriptor) => {
+        const fn = descriptor.value;
+        descriptor.value = function (...args) {
+            let needRealseConn = true;
+            const startTime = +new Date();
+            // option
+            const option = args[0] = Object.assign({}, globalThis[_GlobalSqlOption], this[_SqlOption], args[0]);
+            option.sync ?? (option.sync = SyncMode.Async);
+            option.tableName = option?.tableName ?? this[_tableName];
+            option.dbName = option?.dbName ?? this[_daoDBName] ?? _primaryDB;
+            option.dbType = this[_dbType] ?? globalThis[_GlobalSqlOption].dbType ?? DBType.Mysql;
+            option.dao = globalThis[_dao][option.dbType][option.dbName];
+            // 错误日志输出函数：原实现里 `let args = ''` 把外层 rest 参数 `args` 给遮蔽了，
+            // 导致 args.length 永远是 0，params 日志永远打不出来，生产排查时丢失关键上下文。
+            const dumpArgs = (callArgs) => {
+                if (callArgs.length > 0 && callArgs[0] && callArgs[0].params) {
+                    try {
+                        return JSON.stringify(callArgs[0].params);
+                    }
+                    catch {
+                        return '<unserializable params>';
+                    }
+                }
+                return '';
+            };
+            if (option.dbType === DBType.Sqlite) {
+                if (!option.dao) {
+                    const db = new Sqlite(new globalThis[_GlobalSqlOption].BetterSqlite3(option.dbName, { fileMustExist: false }));
+                    if (globalThis[_dao][option.dbType][_primaryDB] === undefined) {
+                        globalThis[_dao][option.dbType][_primaryDB] = db;
+                    }
+                    globalThis[_dao][option.dbType][option.dbName] = db;
+                    option.dao = db;
+                }
+                Throw.if(option.sync === SyncMode.Async, 'sqlite can not Async!');
+                // 连接共享
+                if (skipConn === false && !option.conn) {
+                    option.conn = option.dao.createConnection(SyncMode.Sync);
+                }
+                else {
+                    needRealseConn = false;
+                }
+                try {
+                    const result = fn.call(this, ...args);
+                    globalThis[_LoggerService].log(`${propertyKey}:${option.sqlId ?? option.tableName}:use ${+new Date() - startTime}ms`);
+                    return result;
+                }
+                catch (error) {
+                    console.error(`${option.sqlId ?? option.tableName} service ${propertyKey} have an error:${error}, it's argumens: ${dumpArgs(args)}`);
+                    throw error;
+                }
+                finally {
+                    if (needRealseConn && option && option.conn) {
+                        try {
+                            option.conn.release(SyncMode.Sync);
+                        }
+                        catch (error) {
+                        }
+                    }
+                }
+            }
+            else if (option.dbType === DBType.SqliteRemote) {
+                if (!option.dao) {
+                    globalThis[_GlobalSqlOption].SqliteRemote.service.initDB(option.dbName);
+                    const db = new SqliteRemote(globalThis[_GlobalSqlOption].SqliteRemote.service, option.dbName);
+                    if (globalThis[_dao][option.dbType][_primaryDB] === undefined) {
+                        globalThis[_dao][option.dbType][_primaryDB] = db;
+                    }
+                    globalThis[_dao][option.dbType][option.dbName] = db;
+                    option.dao = db;
+                }
+                Throw.if(option.sync === SyncMode.Sync, 'SqliteRemote remote can not sync!');
+                return (async () => {
+                    try {
+                        // 连接共享
+                        if (skipConn === false && !option.conn) {
+                            (option).conn = await option.dao.createConnection(SyncMode.Async);
+                        }
+                        else {
+                            needRealseConn = false;
+                        }
+                        const result = await fn.call(this, ...args);
+                        globalThis[_LoggerService].log(`${propertyKey}:${option.sqlId ?? option.tableName}:use ${+new Date() - startTime}ms`);
+                        return result;
+                    }
+                    catch (error) {
+                        console.error(`${option.sqlId ?? option.tableName} service ${propertyKey} have an error:${error}, it's argumens: ${dumpArgs(args)}`);
+                        throw error;
+                    }
+                    finally {
+                        if (needRealseConn && option && option.conn) {
+                            try {
+                                await option.conn.release(SyncMode.Async);
+                            }
+                            catch (error) {
+                            }
+                        }
+                    }
+                })();
+            }
+            else if (option.dbType === DBType.Mysql) {
+                Throw.if(!option.dao, `not found db:${String(option.dbName)}(${option.dbType})`);
+                return (async () => {
+                    try {
+                        // 连接共享
+                        if (skipConn === false && !option.conn) {
+                            (option).conn = await option.dao.createConnection(SyncMode.Async);
+                        }
+                        else {
+                            needRealseConn = false;
+                        }
+                        const result = await fn.call(this, ...args);
+                        globalThis[_LoggerService].log(`${propertyKey}:${option.sqlId ?? option.tableName}:use ${+new Date() - startTime}ms`);
+                        return result;
+                    }
+                    catch (error) {
+                        console.error(`${option.sqlId ?? option.tableName} service ${propertyKey} have an error:${error}, it's argumens: ${dumpArgs(args)}`);
+                        throw error;
+                    }
+                    finally {
+                        if (needRealseConn && option && option.conn) {
+                            try {
+                                await option.conn.release(SyncMode.Async);
+                            }
+                            catch (error) {
+                            }
+                        }
+                    }
+                })();
+            }
+            else if (option.dbType === DBType.Postgresql) {
+                Throw.if(!option.dao, `not found db:${String(option.dbName)}(${option.dbType})`);
+                return (async () => {
+                    try {
+                        // 连接共享
+                        if (skipConn === false && !option.conn) {
+                            (option).conn = await option.dao.createConnection(SyncMode.Async);
+                        }
+                        else {
+                            needRealseConn = false;
+                        }
+                        const result = await fn.call(this, ...args);
+                        globalThis[_LoggerService].log(`${propertyKey}:${option.sqlId ?? option.tableName}:use ${+new Date() - startTime}ms`);
+                        return result;
+                    }
+                    catch (error) {
+                        console.error(`${option.sqlId ?? option.tableName} service ${propertyKey} have an error:${error}, it's argumens: ${dumpArgs(args)}`);
+                        throw error;
+                    }
+                    finally {
+                        if (needRealseConn && option && option.conn) {
+                            try {
+                                await option.conn.release(SyncMode.Async);
+                            }
+                            catch (error) {
+                            }
+                        }
+                    }
+                })();
+            }
+        };
+    };
+}
+const FieldFilter = (K, V, def, uuidColumn, option) => {
+    let ret = 0;
+    // 如果是插入操作且字段是UUID，则不进行空值检查
+    // 只有在非插入或者非UUID时，进行空置检查
+    if (option?.insert && uuidColumn) {
+        ret = 1;
+        if (V === undefined || emptyString(`${V ?? ''}`)) {
+            V = null;
+        }
+    }
+    else {
+        if (V === null) {
+            if (option?.skipNull !== true) {
+                ret = 1;
+                V = option?.insert && def && def.hasOwnProperty(K) ? def[K] : null;
+            }
+        }
+        else if (V === undefined) {
+            if (option?.skipUndefined !== true) {
+                ret = 1;
+                V = option?.insert && def && def.hasOwnProperty(K) ? def[K] : null;
+            }
+        }
+        else if (emptyString(`${V ?? ''}`)) {
+            if (option?.skipEmptyString !== true) {
+                ret = 1;
+                V = option?.insert && def && def.hasOwnProperty(K) ? def[K] : '';
+            }
+        }
+        else {
+            ret = 1;
+        }
+    }
+    if (ret === 1) {
+        option?.finalColumns?.add(K);
+        option?.tempColumns?.push(K);
+    }
+    return [ret, V];
+};
+export const DB = (config) => {
+    return function (constructor) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+        const __ids = Reflect.getMetadata(_ids, config.clz.prototype) || new Array;
+        const __logicIds = Reflect.getMetadata(_logicIds, config.clz.prototype) || new Array;
+        const __fields = Reflect.getMetadata(_fields, config.clz.prototype);
+        const __columns = Reflect.getMetadata(_columns, config.clz.prototype);
+        const __columnsNoId = Reflect.getMetadata(_columnsNoId, config.clz.prototype);
+        const __stateFileName = Reflect.getMetadata(_stateFileName, config.clz.prototype);
+        const __deleteState = Reflect.getMetadata(_deleteState, config.clz.prototype);
+        const __index = Reflect.getMetadata(_index, config.clz.prototype);
+        const __def = Reflect.getMetadata(_def, config.clz.prototype);
+        const __dbType = config.dbType;
+        const className = config.tableName?.replace(/_(\w)/g, (a, b) => b.toUpperCase());
+        const ClassName = className?.replace(/\w/, (v) => v.toUpperCase());
+        const vueName = config.tableName?.replace(/_/g, '-');
+        return _v = class extends constructor {
+                constructor() {
+                    super(...arguments);
+                    this[_a] = config.tableName;
+                    this[_b] = className;
+                    this[_c] = ClassName;
+                    this[_d] = vueName;
+                    this[_e] = config.dbName;
+                    this[_f] = __dbType;
+                    this[_g] = config.sqliteVersion;
+                    this[_h] = Object.assign({}, _defOption, config);
+                    this[_j] = __ids;
+                    this[_k] = __logicIds;
+                    this[_l] = __fields;
+                    this[_m] = __columns;
+                    this[_o] = __columnsNoId;
+                    this[_p] = __index;
+                    this[_q] = __def;
+                    this[_r] = config.comment;
+                    this[_s] = __stateFileName;
+                    this[_t] = __deleteState;
+                    this[_u] = (data, option) => {
+                        return Object.fromEntries(iterate(option?.skipId ? __columnsNoId : __columns)
+                            .map(K => [K, FieldFilter(K, data[K], __def, __fields[K].uuid || __fields[K].uuidShort, option)])
+                            .filter(data => {
+                            if (data[1][0] === 1) {
+                                if (__fields[data[0]].Data2SQL) {
+                                    data[1][1] = __fields[data[0]].Data2SQL(data[1][1]);
+                                }
+                                if (option?.onFieldExists) {
+                                    option.onFieldExists(data[0], data[1][1]);
+                                }
+                                return true;
+                            }
+                            else {
+                                return false;
+                            }
+                        })
+                            .map(data => [data[0], data[1][1]])
+                            .toArray());
+                    };
+                }
+            },
+            _a = _tableName,
+            _b = _className,
+            _c = _ClassName,
+            _d = _vueName,
+            _e = _daoDBName,
+            _f = _dbType,
+            _g = _sqlite_version,
+            _h = _SqlOption,
+            _j = _ids,
+            _k = _logicIds,
+            _l = _fields,
+            _m = _columns,
+            _o = _columnsNoId,
+            _p = _index,
+            _q = _def,
+            _r = _comment,
+            _s = _stateFileName,
+            _t = _deleteState,
+            _u = _transformer,
+            _v;
+    };
+};
+/**
+  js项目中实体类注解替代品，只要确保函数被执行即可,举例：
+  ```
+  // 声明一个class
+    export class AmaFuck {}
+    DeclareClass(AmaFuck, [
+        { type: "String", name: "SellerSKU" },
+        { type: "String", name: "SellerSKU2" },
+        { type: "String", name: "site" }
+    ]);
+  ```
+ */
+export function DeclareClass(clz, FieldOptions) {
+    for (const item of FieldOptions) {
+        tslib.__decorate([Field(item)], clz.prototype, item.P, void 0);
+    }
+}
+/**
+ JS项目中，service注解代替,举例：
+ ```
+ // 声明一个service,注意这里的let
+    export let AmaService = class AmaService extends SqlService {};
+    AmaService = DeclareService(AmaService, {
+        tableName: "ama_fuck2",
+        clz: AmaFuck,
+        dbType: DBType.Sqlite,
+        sqliteVersion: "0.0.3"
+    });
+ ```
+ */
+export function DeclareService(clz, config) {
+    return tslib.__decorate([DB(config)], clz);
+}
+/**
+ ## 数据库服务
+ ### 注解DB
+ 
+ ### 泛型 T，同DB注解中的clz
+ ** 服务中所有方法默认以该类型为准
+ **
+ 
+ */
+export class SqlService {
+    _insert(datas, option) {
+        const sqls = [];
+        const tableName = option.tableName;
+        switch (option?.mode) {
+            case InsertMode.InsertIfNotExists: {
+                const conditions = option.existConditionOtherThanIds || this[_ids];
+                Throw.if(!conditions, 'not found where condition for insertIfNotExists!');
+                Throw.if(conditions.length === 0, 'insertIfNotExists must have not null where!');
+                const where = iterate(conditions).map(c => `${this[_fields][c]?.C2()} = ?`).join(' AND ');
+                const finalColumns = new Set();
+                const whereColumns = conditions;
+                const params = [];
+                const questMarks = datas
+                    .map(data => this[_transformer](data, { ...option, finalColumns, insert: true }))
+                    .map(data => {
+                    const questMark = new Array();
+                    for (const column of finalColumns) {
+                        const V = data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null;
+                        if (V === null) {
+                            const field = this[_fields][column];
+                            if (field?.uuid) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push('gen_random_uuid()');
+                                        break;
+                                    default:
+                                        questMark.push('UUID()');
+                                        break;
+                                }
+                            }
+                            else if (field?.uuidShort) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push(`encode(uuid_send(gen_random_uuid()::uuid),'base64')`);
+                                        break;
+                                    case DBType.Mysql:
+                                        questMark.push('UUID_SHORT()');
+                                        break;
+                                    default:
+                                        questMark.push('?');
+                                        params.push(V);
+                                        break;
+                                }
+                            }
+                            else {
+                                questMark.push('?');
+                                params.push(V);
+                            }
+                        }
+                        else {
+                            questMark.push('?');
+                            params.push(V);
+                        }
+                    }
+                    for (const column of whereColumns) {
+                        params.push(data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null);
+                    }
+                    return `SELECT ${questMark.join(',')} FROM DUAL WHERE NOT EXISTS (SELECT 1 FROM ${tableName} WHERE ${where})`;
+                });
+                const columnNames = iterate(finalColumns).map(i => this[_fields][i]?.C2()).join(',');
+                const sql = formatDialect(`INSERT INTO
+                ${tableName}
+                (${columnNames})
+                ${questMarks.join(' UNION ALL ')};`, { dialect: formatDialects[option.dbType] });
+                sqls.push({ sql, params });
+                break;
+            }
+            case InsertMode.Replace: {
+                const finalColumns = new Set();
+                const params = [];
+                const questMarks = datas
+                    .map(data => this[_transformer](data, { ...option, finalColumns, insert: true }))
+                    .map(data => {
+                    const questMark = new Array();
+                    for (const column of finalColumns) {
+                        const V = data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null;
+                        if (V === null) {
+                            const field = this[_fields][column];
+                            if (field?.uuid) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push('gen_random_uuid()');
+                                        break;
+                                    default:
+                                        questMark.push('UUID()');
+                                        break;
+                                }
+                            }
+                            else if (field?.uuidShort) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push(`encode(uuid_send(gen_random_uuid()::uuid),'base64')`);
+                                        break;
+                                    case DBType.Mysql:
+                                        questMark.push('UUID_SHORT()');
+                                        break;
+                                    default:
+                                        questMark.push('?');
+                                        params.push(V);
+                                        break;
+                                }
+                            }
+                            else {
+                                questMark.push('?');
+                                params.push(V);
+                            }
+                        }
+                        else {
+                            questMark.push('?');
+                            params.push(V);
+                        }
+                    }
+                    return `(${questMark.join(',')})`;
+                });
+                const columnNames = iterate(finalColumns).map(i => this[_fields][i]?.C2()).join(',');
+                const sql = formatDialect(`
+                    ${option.dbType === DBType.Mysql ? '' : 'INSERT OR'} REPLACE INTO
+                    ${tableName}
+                    (${columnNames})
+                    VALUES ${questMarks};
+                `, { dialect: formatDialects[option.dbType] });
+                sqls.push({ sql, params });
+                break;
+            }
+            case InsertMode.Insert: {
+                const finalColumns = new Set();
+                const params = [];
+                const questMarks = datas
+                    .map(data => this[_transformer](data, { ...option, finalColumns, insert: true }))
+                    .map(data => {
+                    const questMark = new Array();
+                    for (const column of finalColumns) {
+                        const V = data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null;
+                        if (V === null) {
+                            const field = this[_fields][column];
+                            if (field?.uuid) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push('gen_random_uuid()');
+                                        break;
+                                    default:
+                                        questMark.push('UUID()');
+                                        break;
+                                }
+                            }
+                            else if (field?.uuidShort) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push(`encode(uuid_send(gen_random_uuid()::uuid),'base64')`);
+                                        break;
+                                    case DBType.Mysql:
+                                        questMark.push('UUID_SHORT()');
+                                        break;
+                                    default:
+                                        questMark.push('?');
+                                        params.push(V);
+                                        break;
+                                }
+                            }
+                            else {
+                                questMark.push('?');
+                                params.push(V);
+                            }
+                        }
+                        else {
+                            questMark.push('?');
+                            params.push(V);
+                        }
+                    }
+                    return `(${questMark.join(',')})`;
+                });
+                const columnNames = iterate(finalColumns).map(i => this[_fields][i]?.C2()).join(',');
+                const sql = formatDialect(`
+                    INSERT INTO
+                    ${tableName}
+                    (${columnNames})
+                    VALUES ${questMarks};
+                `, { dialect: formatDialects[option.dbType] });
+                sqls.push({ sql, params });
+                break;
+            }
+            case InsertMode.InsertWithTempTable: {
+                // 用 snowflake 替代 Math.random()——Math.random() 在高并发下可能碰撞，
+                // 同一连接里多次 InsertWithTempTable 会因为撞名 DDL 报错。
+                const tableTemp = `${option?.tableName}_${snowflake.generate()}`;
+                const tableTempESC = tableTemp;
+                sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+                const finalColumns = new Set();
+                const params = [];
+                const questMarks = datas
+                    .map(data => this[_transformer](data, { ...option, finalColumns, insert: true }))
+                    .map(data => {
+                    const questMark = new Array();
+                    for (const column of finalColumns) {
+                        const V = data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null;
+                        if (V === null) {
+                            const field = this[_fields][column];
+                            if (field?.uuid) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push('gen_random_uuid()');
+                                        break;
+                                    default:
+                                        questMark.push('UUID()');
+                                        break;
+                                }
+                            }
+                            else if (field?.uuidShort) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push(`encode(uuid_send(gen_random_uuid()::uuid),'base64')`);
+                                        break;
+                                    case DBType.Mysql:
+                                        questMark.push('UUID_SHORT()');
+                                        break;
+                                    default:
+                                        questMark.push('?');
+                                        params.push(V);
+                                        break;
+                                }
+                            }
+                            else {
+                                questMark.push('?');
+                                params.push(V);
+                            }
+                        }
+                        else {
+                            questMark.push('?');
+                            params.push(V);
+                        }
+                    }
+                    return `(${questMark.join(',')})`;
+                });
+                const _sqls = this._createTable({ tableName: tableTemp, temp: true, columns: Array.from(finalColumns) });
+                sqls.push(..._sqls);
+                const columnNames = iterate(finalColumns).map(i => this[_fields][i]?.C2()).join(',');
+                sqls.push({
+                    sql: formatDialect(`
+                        INSERT INTO
+                        ${tableTemp}
+                        (${columnNames})
+                        VALUES ${questMarks};
+                    `, { dialect: formatDialects[option.dbType] }), params
+                });
+                sqls.push({
+                    sql: formatDialect(`INSERT INTO ${option.tableName} (${columnNames})
+                        SELECT ${columnNames} FROM ${tableTemp};`, { dialect: formatDialects[option.dbType] })
+                });
+                sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+                break;
+            }
+        }
+        return sqls;
+    }
+    insert(option) {
+        option.mode ?? (option.mode = InsertMode.Insert);
+        const isArray = option.data instanceof Array;
+        const datas = option.data instanceof Array ? option.data : [option.data];
+        if (datas.length === 0)
+            return 0n;
+        if (option.sync === SyncMode.Sync) {
+            const fn = () => {
+                const result = excuteSplit(ExcuteSplitMode.SyncTrust, datas, _data => {
+                    const sqls = this._insert(_data, option);
+                    let result = 0n;
+                    for (const { sql, params } of sqls) {
+                        const dd = option.conn.execute(SyncMode.Sync, sql, params);
+                        if (dd.insertId) {
+                            result += BigInt(dd.insertId);
+                        }
+                    }
+                    return result;
+                }, { everyLength: option?.every ? 1 : option?.maxDeal });
+                if (isArray)
+                    return result;
+                else
+                    return result[0];
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction]) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Sync, fn, option?.conn);
+            }
+        }
+        else if (isArray) {
+            const fn = async () => {
+                const result = await excuteSplit(ExcuteSplitMode.AsyncTrust, datas, async (_data) => {
+                    const sqls = this._insert(_data, option);
+                    let result = 0n;
+                    for (const { sql, params } of sqls) {
+                        const dd = await option.conn.execute(SyncMode.Async, sql, params);
+                        if (dd.insertId) {
+                            result += BigInt(dd.insertId);
+                        }
+                    }
+                    return result;
+                }, { everyLength: option?.every ? 1 : option?.maxDeal });
+                return result;
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction]) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Async, fn, option?.conn);
+            }
+        }
+        else {
+            const fn = async () => {
+                const result = await excuteSplit(ExcuteSplitMode.AsyncTrust, datas, async (_data) => {
+                    const sqls = this._insert(_data, option);
+                    let result = 0n;
+                    for (const { sql, params } of sqls) {
+                        const dd = await option.conn.execute(SyncMode.Async, sql, params);
+                        if (dd.insertId) {
+                            result += BigInt(dd.insertId);
+                        }
+                    }
+                    return result;
+                }, { everyLength: 1 });
+                return result[0];
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction]) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Async, fn, option?.conn);
+            }
+        }
+    }
+    _update(datas, option) {
+        const sqls = [];
+        const tableName = option?.tableName;
+        const where = `WHEN ${iterate(this[_ids]).map(c => `${this[_fields][c]?.C2()} = ?`).join(' AND ')} THEN ?`;
+        const columnMaps = Object.fromEntries(this[_columnsNoId].map(c => [c, {
+                where: new Array(),
+                params: []
+            }]));
+        const params = [];
+        for (const data of datas) {
+            const ids = this[_ids].map(i => {
+                Throw.if(!data[i], `UPDATE ID NOT EXISTS!${JSON.stringify(data)}`);
+                return data[i];
+            });
+            this[_transformer](data, {
+                ...option,
+                skipId: true,
+                onFieldExists: (K, V) => {
+                    columnMaps[K]?.where.push(where);
+                    columnMaps[K]?.params.push(...ids, V);
+                }
+            });
+        }
+        const sql = formatDialect(`UPDATE ${tableName} SET ${iterate(this[_columnsNoId])
+            .filter(K => columnMaps[K].where.length > 0)
+            .map(K => {
+            params.push(...columnMaps[K].params);
+            return `${this[_fields][K]?.C2()} = CASE ${columnMaps[K].where.join(' ')} ELSE ${this[_fields][K]?.C2()} END`;
+        })
+            .join(',')};`, { dialect: formatDialects[option.dbType] });
+        sqls.push({ sql, params });
+        return sqls;
+    }
+    update(option) {
+        Throw.if(!this[_ids] || this[_ids].length === 0, 'not found id');
+        const datas = option.data instanceof Array ? option.data : [option.data];
+        if (datas.length === 0)
+            return 0;
+        if (option.sync === SyncMode.Sync) {
+            const fn = () => {
+                const result = excuteSplit(ExcuteSplitMode.SyncTrust, datas, _data => {
+                    const sqls = this._update(_data, option);
+                    let result = 0;
+                    for (const { sql, params } of sqls) {
+                        const dd = option.conn.execute(SyncMode.Sync, sql, params);
+                        if (dd.affectedRows) {
+                            result += dd.affectedRows;
+                        }
+                    }
+                    return result;
+                }, { everyLength: option?.maxDeal });
+                return result.length > 0 ? result.reduce((a, b) => a + b) : 0;
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction]) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Sync, fn, option?.conn);
+            }
+        }
+        else {
+            const fn = async () => {
+                const result = await excuteSplit(ExcuteSplitMode.AsyncTrust, datas, async (_data) => {
+                    const sqls = this._update(_data, option);
+                    let result = 0;
+                    for (const { sql, params } of sqls) {
+                        const dd = await option.conn.execute(SyncMode.Async, sql, params);
+                        if (dd.affectedRows) {
+                            result += dd.affectedRows;
+                        }
+                    }
+                    return result;
+                }, { everyLength: option?.maxDeal });
+                return result.length > 0 ? result.reduce((a, b) => a + b) : 0;
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction]) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Async, fn, option?.conn);
+            }
+        }
+    }
+    delete(option) {
+        Throw.if(!!this[_ids] && this[_ids].length > 1 && !option.where && !option.whereSql, 'muit id must set where!');
+        Throw.if((!this[_ids] || this[_ids].length === 0) && !option.where && !option.whereSql, 'if not set id on class, must set where!');
+        Throw.if(!option.id && !option.where && !option.whereSql, 'not found id or where!');
+        Throw.if(!!option.id && !!this[_ids] && this[_ids].length > 1, 'muit id must set where!');
+        Throw.if(!!option.id && !!option.where && !option.whereSql, 'id and where only one can set!');
+        option.mode ?? (option.mode = DeleteMode.Common);
+        const tableTemp = `${option?.tableName}_${snowflake.generate()}`;
+        const tableTempESC = tableTemp;
+        const tableNameESC = option?.tableName;
+        if (option.id) {
+            const idName = this[_ids][0];
+            const ids = option.id instanceof Array ? option.id : [option.id];
+            option.where = ids.map(i => ({ [idName]: i }));
+        }
+        const wheres = option.where instanceof Array ? option.where : [option.where];
+        if (wheres.length === 0 && (!option.whereSql || !option.whereParams)) {
+            return 0;
+        }
+        if (option.whereSql && option.whereParams) {
+            option.mode = DeleteMode.Common;
+        }
+        const sqls = [];
+        if (option.mode === DeleteMode.Common) {
+            let params;
+            let whereSql;
+            if (option.whereSql && option.whereParams) {
+                const gen = this._generSql(option.dbType, option.whereSql, option.whereParams);
+                whereSql = gen.sql;
+                params = gen.params;
+            }
+            else {
+                params = new Array();
+                whereSql = iterate(wheres).map(where => {
+                    return `(
+                        ${Object.entries(where).map(([K, V]) => {
+                        params.push(V);
+                        return `${this[_fields][K]?.C2()} = ?`;
+                    }).join(' AND ')}
+                    )`;
+                }).join(' OR ');
+            }
+            if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                params.unshift(this[_deleteState]);
+                sqls.push({
+                    sql: formatDialect(`
+                    UPDATE ${tableNameESC} SET ${this[_fields][this[_stateFileName]]?.C2()} = ?
+                    WHERE ${whereSql};
+                `, { dialect: formatDialects[option.dbType] }), params
+                });
+            }
+            else {
+                sqls.push({ sql: formatDialect(`DELETE FROM ${tableNameESC} WHERE ${whereSql};`, { dialect: formatDialects[option.dbType] }), params });
+            }
+        }
+        else {
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+            const delWhere = Object.keys(wheres[0]);
+            const _sqls = this._createTable({ tableName: tableTemp, temp: true, columns: delWhere, data: wheres, index: 'all', id: 'none' });
+            sqls.push(..._sqls);
+            switch (option.dbType) {
+                case DBType.Mysql: {
+                    if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                        sqls.push({
+                            sql: formatDialect(`UPDATE ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields][K]?.C2()} = b.${this[_fields][K]?.C2()}`).join(' AND ')}
+                            SET a.${this[_fields][this[_stateFileName]]?.C2()} = ?;`, { dialect: formatDialects[option.dbType] }),
+                            params: [this[_deleteState]]
+                        });
+                    }
+                    else {
+                        sqls.push({
+                            sql: formatDialect(`DELETE a.* FROM ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields][K]?.C2()} = b.${this[_fields][K]?.C2()}`).join(' AND ')};`, { dialect: formatDialects[option.dbType] })
+                        });
+                    }
+                    break;
+                }
+                case DBType.Sqlite:
+                case DBType.SqliteRemote: {
+                    const columnNames = iterate(delWhere).map(K => this[_fields][K]?.C2()).join(',');
+                    if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                        sqls.push({
+                            sql: formatDialect(`UPDATE ${tableNameESC} SET ${this[_fields][this[_stateFileName]]?.C2()} = ?
+                            WHERE (${columnNames}) IN (SELECT ${columnNames} FROM ${tableTempESC});`, { dialect: formatDialects[option.dbType] }),
+                            params: [this[_deleteState]]
+                        });
+                    }
+                    else {
+                        sqls.push({ sql: formatDialect(`DELETE FROM ${tableNameESC} WHERE (${columnNames}) IN (SELECT ${columnNames} FROM ${tableTempESC});`, { dialect: formatDialects[option.dbType] }) });
+                    }
+                    break;
+                }
+            }
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+        }
+        if (option.sync === SyncMode.Sync) {
+            const fn = () => {
+                let result = 0;
+                for (const { sql, params } of sqls) {
+                    const dd = option.conn.execute(SyncMode.Sync, sql, params);
+                    result += dd.affectedRows;
+                }
+                return result;
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction]) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Sync, fn, option?.conn);
+            }
+        }
+        else {
+            const fn = async () => {
+                let result = 0;
+                for (const { sql, params } of sqls) {
+                    const dd = await option.conn.execute(SyncMode.Async, sql, params);
+                    result += dd.affectedRows;
+                }
+                return result;
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction]) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Async, fn, option?.conn);
+            }
+        }
+    }
+    _template(templateResult, result, error) {
+        switch (templateResult) {
+            case TemplateResult.AssertOne: {
+                Throw.if(!result || result.length !== 1, error);
+                return result[0];
+            }
+            case TemplateResult.NotSureOne: {
+                return result && result.length > 0 ? result[0] ?? null : null;
+            }
+            case TemplateResult.Many: {
+                return result;
+            }
+            case TemplateResult.Count: {
+                return result[0].ct;
+            }
+        }
+    }
+    template(option) {
+        Throw.if(!!this[_ids] && this[_ids].length > 1 && !option.where, `muit id must set where!(${option.tableName})`);
+        Throw.if((!this[_ids] || this[_ids].length === 0) && !option.where, `if not set id on class, must set where!(${option.tableName})`);
+        Throw.if(!option.id && !option.where, `not found id or where!(${option.tableName})`);
+        Throw.if(!!option.id && !!this[_ids] && this[_ids].length > 1, `muit id must set where!(${option.tableName})`);
+        Throw.if(!!option.id && !!option.where, `id and where only one can set!(${option.tableName})`);
+        option.mode ?? (option.mode = SelectMode.Common);
+        option.templateResult ?? (option.templateResult = TemplateResult.AssertOne);
+        option.error ?? (option.error = 'error data!');
+        const tableTemp = `${option?.tableName}_${snowflake.generate()}`;
+        const tableTempESC = tableTemp;
+        const tableNameESC = option?.tableName;
+        if (option.id) {
+            const idName = this[_ids][0];
+            const ids = option.id instanceof Array ? option.id : [option.id];
+            option.where = ids.map(i => ({ [idName]: i }));
+        }
+        const columns = option.templateResult === TemplateResult.Count ? 'COUNT(1) ct' : iterate((option.columns ?? this[_columns])).map((K) => `a.${this[_fields][K]?.C3()}`).join(',');
+        const wheres = option.where instanceof Array ? option.where : [option.where];
+        const sqls = [];
+        let resultIndex = -1;
+        if (option.mode === SelectMode.Common) {
+            const params = new Array();
+            const whereSql = formatDialect(iterate(wheres).map(where => this[_transformer](where, option)).map(where => {
+                return `SELECT ${columns} FROM ${tableNameESC} a WHERE
+                    ${Object.entries(where).map(([K, V]) => {
+                    params.push(V);
+                    return `${this[_fields][K]?.C2()} = ?`;
+                }).join(' AND ')}`;
+            }).join(' UNION ALL '), { dialect: formatDialects[option.dbType] });
+            sqls.push({ sql: whereSql, params });
+            resultIndex = 0;
+        }
+        else {
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+            const delWhere = Object.keys(wheres[0]);
+            const _sqls = this._createTable({ tableName: tableTemp, temp: true, columns: delWhere, data: wheres, index: 'all', id: 'none' });
+            sqls.push(..._sqls);
+            resultIndex = sqls.length;
+            sqls.push({ sql: formatDialect(`SELECT ${columns} FROM ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields][K]?.C2()} = b.${this[_fields][K]?.C2()}`).join(' AND ')};`, { dialect: formatDialects[option.dbType] }) });
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+        }
+        if (option.sync === SyncMode.Sync) {
+            let result;
+            for (let i = 0; i < sqls.length; i++) {
+                if (i === resultIndex) {
+                    result = option.conn.query(SyncMode.Sync, sqls[i]?.sql, sqls[i]?.params);
+                }
+                else {
+                    option.conn.execute(SyncMode.Sync, sqls[i]?.sql, sqls[i]?.params);
+                }
+            }
+            return this._template(option.templateResult, result, option.error);
+        }
+        else {
+            return (async () => {
+                let result;
+                for (let i = 0; i < sqls.length; i++) {
+                    if (i === resultIndex) {
+                        result = await option.conn.query(SyncMode.Async, sqls[i]?.sql, sqls[i]?.params);
+                    }
+                    else {
+                        await option.conn.execute(SyncMode.Async, sqls[i]?.sql, sqls[i]?.params);
+                    }
+                }
+                return this._template(option.templateResult, result, option.error);
+            })();
+        }
+    }
+    _select(templateResult, result, def, errorMsg, hump, mapper, mapperIfUndefined, dataConvert) {
+        switch (templateResult) {
+            case SelectResult.R_C_NotSure: {
+                try {
+                    if (dataConvert) {
+                        const key = Object.keys(result[0])[0];
+                        const value = Object.values(result[0])[0];
+                        if (key && dataConvert[key] && globalThis[_DataConvert][dataConvert[key]]) {
+                            return globalThis[_DataConvert][dataConvert[key]](value);
+                        }
+                    }
+                    return Object.values(result[0])[0];
+                }
+                catch (error) {
+                    return def;
+                }
+            }
+            case SelectResult.R_C_Assert: {
+                try {
+                    if (dataConvert) {
+                        const key = Object.keys(result[0])[0];
+                        const value = Object.values(result[0])[0];
+                        if (key && dataConvert[key] && globalThis[_DataConvert][dataConvert[key]]) {
+                            return globalThis[_DataConvert][dataConvert[key]](value);
+                        }
+                    }
+                    return Object.values(result[0])[0];
+                }
+                catch (error) {
+                    if (def !== undefined)
+                        return def;
+                    Throw.now(errorMsg ?? 'not found data!');
+                }
+            }
+            case SelectResult.R_CS_NotSure: {
+                if (mapper) {
+                    return flatData({ data: result[0], mapper, mapperIfUndefined });
+                }
+                else {
+                    hump = hump === true || (hump === undefined && globalThis[_Hump] === true);
+                    const __dataConvert = dataConvert ? Object.fromEntries(Object.entries(dataConvert).map(([k, v]) => [k, globalThis[_DataConvert][v]])) : undefined;
+                    if (hump || __dataConvert) {
+                        return C2P2(result[0], hump, __dataConvert) ?? null;
+                    }
+                    else {
+                        return result[0] ?? null;
+                    }
+                }
+            }
+            case SelectResult.R_CS_Assert: {
+                const data = result[0];
+                Throw.if(data === null || data === undefined, errorMsg ?? 'not found data!');
+                if (mapper) {
+                    return flatData({ data, mapper, mapperIfUndefined });
+                }
+                else {
+                    hump = hump === true || (hump === undefined && globalThis[_Hump] === true);
+                    const __dataConvert = dataConvert ? Object.fromEntries(Object.entries(dataConvert).map(([k, v]) => [k, globalThis[_DataConvert][v]])) : undefined;
+                    if (hump || __dataConvert) {
+                        return C2P2(data, hump, __dataConvert) ?? null;
+                    }
+                    else {
+                        return data;
+                    }
+                }
+            }
+            case SelectResult.RS_C: {
+                try {
+                    if (dataConvert) {
+                        const key = Object.keys(result[0])[0];
+                        if (key && dataConvert[key] && globalThis[_DataConvert][dataConvert[key]]) {
+                            return result.map((r) => globalThis[_DataConvert][dataConvert[key]](Object.values(r)[0]));
+                        }
+                    }
+                    return result.map((r) => Object.values(r)[0]);
+                }
+                catch (error) {
+                    return result;
+                }
+            }
+            case SelectResult.RS_CS: {
+                if (mapper) {
+                    return iterate(result).map((data) => flatData({ data, mapper, mapperIfUndefined })).toArray();
+                }
+                else {
+                    hump = hump === true || (hump === undefined && globalThis[_Hump] === true);
+                    const __dataConvert = dataConvert ? Object.fromEntries(Object.entries(dataConvert).map(([k, v]) => [k, globalThis[_DataConvert][v]])) : undefined;
+                    if (hump || __dataConvert) {
+                        return iterate(result).map((r) => C2P2(r, hump, __dataConvert)).toArray();
+                    }
+                    else {
+                        return result;
+                    }
+                }
+            }
+        }
+    }
+    select(option) {
+        Throw.if(!option.sqlId && !option.sql, 'not found sql!');
+        option.selectResult ?? (option.selectResult = SelectResult.RS_CS);
+        option.defValue ?? (option.defValue = null);
+        if (option.sqlId && globalThis[_resultMap_SQLID][option.sqlId] && !option.mapper) {
+            option.mapper = globalThis[_resultMap_SQLID][option.sqlId];
+        }
+        const _params = Object.assign({}, option.params);
+        option.sql ?? (option.sql = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: Object.assign({}, option.context, globalThis[_Context]), isCount: option.isCount, ..._params }));
+        const { sql, params } = this._generSql(option.dbType, option.sql, _params);
+        if (option.sync === SyncMode.Sync) {
+            const result = option.conn.query(SyncMode.Sync, sql, params);
+            return this._select(option.selectResult, result, option.defValue, option.errorMsg, option.hump, option.mapper, option.mapperIfUndefined, option.dataConvert);
+        }
+        else {
+            return (async () => {
+                const result = await option.conn.query(SyncMode.Async, sql, params);
+                return this._select(option.selectResult, result, option.defValue, option.errorMsg, option.hump, option.mapper, option.mapperIfUndefined, option.dataConvert);
+            })();
+        }
+    }
+    selectBatch(option) {
+        Throw.if(!option.sqlId && !option.sql, 'not found sql!');
+        option.selectResult ?? (option.selectResult = SelectResult.RS_CS);
+        if (option.sqlId && globalThis[_resultMap_SQLID][option.sqlId] && !option.mapper) {
+            option.mapper = globalThis[_resultMap_SQLID][option.sqlId];
+        }
+        const _params = Object.assign({}, option.params);
+        option.sql ?? (option.sql = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: Object.assign({}, option.context, globalThis[_Context]), isCount: false, ..._params }));
+        const { sql, params } = this._generSql(option.dbType, option.sql, _params);
+        if (option.sync === SyncMode.Sync) {
+            const result = option.conn.query(SyncMode.Sync, sql, params);
+            return result.map(item => this._select(option.selectResult, item, null, undefined, option.hump, option.mapper, option.mapperIfUndefined, option.dataConvert));
+        }
+        else {
+            return (async () => {
+                const result = await option.conn.query(SyncMode.Async, sql, params);
+                return result.map(item => this._select(option.selectResult, item, null, undefined, option.hump, option.mapper, option.mapperIfUndefined, option.dataConvert));
+            })();
+        }
+    }
+    excute(option) {
+        Throw.if(!option.sqlId && !option.sql, 'not found sql!');
+        const _params = Object.assign({}, option.params);
+        option.sql ?? (option.sql = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: Object.assign({}, option.context, globalThis[_Context]), ..._params }));
+        const { sql, params } = this._generSql(option.dbType, option.sql, _params);
+        if (option.sync === SyncMode.Sync) {
+            const result = option.conn.execute(SyncMode.Sync, sql, params);
+            return result.affectedRows;
+        }
+        else {
+            return (async () => {
+                const result = await option.conn.execute(SyncMode.Async, sql, params);
+                return result.affectedRows;
+            })();
+        }
+    }
+    transaction(option) {
+        if (option.sync === SyncMode.Sync) {
+            return option.dao.transaction(SyncMode.Sync, option.fn, option.conn);
+        }
+        else {
+            return option.dao.transaction(SyncMode.Async, option.fn, option.conn);
+        }
+    }
+    stream() {
+        return new StreamQuery(this, this[_fields], this[_columns]);
+    }
+    page(option) {
+        const result = {
+            sum: {},
+            records: [],
+            size: 0,
+            total: 0
+        };
+        option.pageNumber ?? (option.pageNumber = 1);
+        option.pageSize ?? (option.pageSize = 0);
+        if (option.hump || (option.hump === undefined && globalThis[_Hump]) && option.sortName) {
+            option.sortName = P2C(option.sortName);
+        }
+        // 不要 Object.assign 进调用方的 params——@P 装饰器对 option 只做了浅拷贝，
+        // option.params 仍指向用户传入的对象，原写法会把分页字段写回去污染下一次调用。
+        option.params = Object.assign({}, option.params, {
+            limitStart: calc(option.pageNumber).sub(1).mul(option.pageSize).over(),
+            limitEnd: option.pageSize - 0,
+            sortName: option.sortName ?? undefined,
+            sortType: option.sortType ?? undefined
+        });
+        const ctx = Object.assign({}, option.context, globalThis[_Context]);
+        let sql = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx, isCount: false, ...option.params });
+        let sqlSum = '';
+        let sqlCount = '';
+        if (option.sum) {
+            if (option.sumSelf) {
+                sqlCount = globalThis[_sqlCache].load(this._matchSqlid(`${option.sqlId}_sum`), { ctx, isCount: false, isSum: true, ...option.params });
+            }
+            else {
+                sqlSum = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx, isCount: false, isSum: true, ...option.params });
+            }
+        }
+        if (option.limitSelf !== true && option.pageSize > 0) {
+            sql = `${sql} LIMIT ${option.params['limitStart']}, ${option.pageSize}`;
+        }
+        if (option.pageSize > 0) {
+            if (option.countSelf) {
+                sqlCount = globalThis[_sqlCache].load(this._matchSqlid(`${option.sqlId}_count`), { ctx, isCount: true, isSum: false, ...option.params });
+            }
+            else {
+                sqlCount = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx, isCount: true, isSum: false, ...option.params });
+            }
+        }
+        if (option.sync === SyncMode.Sync) {
+            if (sqlCount) {
+                result.total = this.select({
+                    ...option,
+                    sql: sqlCount,
+                    sync: SyncMode.Sync,
+                    selectResult: SelectResult.R_C_Assert
+                });
+                result.size = calc(result.total)
+                    .add(option.pageSize - 1)
+                    .div(option.pageSize)
+                    .round(0, 2)
+                    .over();
+            }
+            if (sqlSum) {
+                result.sum = this.select({
+                    ...option,
+                    sql: sqlSum,
+                    sync: SyncMode.Sync,
+                    selectResult: SelectResult.R_CS_Assert
+                });
+            }
+            if (sql) {
+                result.records = this.select({
+                    ...option,
+                    sql,
+                    sync: SyncMode.Sync,
+                    selectResult: SelectResult.RS_CS
+                });
+            }
+            return result;
+        }
+        else {
+            return (async () => {
+                if (sqlCount) {
+                    result.total = await this.select({
+                        ...option,
+                        sql: sqlCount,
+                        sync: SyncMode.Async,
+                        selectResult: SelectResult.R_C_Assert
+                    });
+                    // 修正运算符优先级：`option.pageSize ?? 10 - 1` 被解析为 `pageSize ?? 9`，
+                    // 而同步分支用的是 `option.pageSize - 1`，行为不一致。
+                    result.size = calc(result.total)
+                        .add((option.pageSize ?? 10) - 1)
+                        .div(option.pageSize)
+                        .round(0, 2)
+                        .over();
+                }
+                if (sqlSum) {
+                    result.sum = await this.select({
+                        ...option,
+                        sql: sqlSum,
+                        sync: SyncMode.Async,
+                        selectResult: SelectResult.R_CS_Assert
+                    });
+                }
+                if (sql) {
+                    result.records = await this.select({
+                        ...option,
+                        sql,
+                        sync: SyncMode.Async,
+                        selectResult: SelectResult.RS_CS
+                    });
+                }
+                return result;
+            })();
+        }
+    }
+    /**
+     * 导出数据，可以为EJS-EXCEL直接使用
+     * @param list
+     * @returns
+     */
+    exp(list) {
+        Throw.if(list.length === 0, 'not found data!');
+        const columnTitles = new Array();
+        const keys = this[_fields] ?
+            iterate(Object.entries(this[_fields]))
+                .filter(([K, F]) => (F.id !== true && F.exportable !== false) || (F.id === true && F.exportable === true))
+                .map(([K, F]) => {
+                columnTitles.push(F.comment ?? K);
+                return K;
+            }).toArray()
+            : Object.keys(list[0]).filter(K => !this[_ids]?.includes(K));
+        const title = this[_comment] ?? this[_tableName];
+        const titleSpan = `A1:${ten2Any(keys.length)}1`;
+        const datas = list.map(data => keys.map(k => data[k] ?? ''));
+        return { title, titleSpan, columnTitles, datas };
+    }
+    /**
+     * 导入数据的模板
+     * @returns
+     */
+    imp() {
+        Throw.if(!this[_fields], 'not set fields!');
+        const columnTitles = new Array();
+        const keys = iterate(Object.entries(this[_fields]))
+            .filter(([K, F]) => (F.id !== true && F.exportable !== false) || (F.id === true && F.exportable === true))
+            .map(([K, F]) => {
+            columnTitles.push(F.comment ?? K);
+            return K;
+        }).toArray();
+        const title = this[_comment] ?? this[_tableName];
+        const titleSpan = `A1:${ten2Any(keys.length)}1`;
+        return { title, titleSpan, columnTitles };
+    }
+    init(option) {
+        var _a;
+        const tableES = option.tableName;
+        (_a = option).force ?? (_a.force = false);
+        if (option.dbType === DBType.Sqlite) {
+            if (option?.force) {
+                option.conn.execute(SyncMode.Sync, `DROP TABLE IF EXISTS ${tableES};`);
+            }
+            const lastVersion = this[_sqlite_version] ?? '1';
+            // 检查表
+            const tableCheckResult = option.conn.pluck(SyncMode.Sync, `SELECT COUNT(1) t FROM sqlite_master WHERE TYPE = 'table' AND name = ?`, [option.tableName]);
+            if (tableCheckResult) {
+                // 旧版本
+                const tableVersion = option.conn.pluck(SyncMode.Sync, 'SELECT ______version v from TABLE_VERSION WHERE ______tableName = ?', [option.tableName]);
+                if (tableVersion && tableVersion < lastVersion) { // 发现需要升级的版本
+                    // 更新版本
+                    const columns = iterate(option.conn.query(SyncMode.Sync, `PRAGMA table_info(${tableES})`))
+                        .filter(c => this[_fields].hasOwnProperty(C2P(c.name, globalThis[_Hump])))
+                        .map(c => c.name)
+                        .join(',');
+                    const rtable = `${option.tableName}_${tableVersion.replace(/\./, '_')}`;
+                    option.conn.execute(SyncMode.Sync, `DROP TABLE IF EXISTS ${rtable};`);
+                    option.conn.execute(SyncMode.Sync, `ALTER TABLE ${tableES} RENAME TO ${rtable};`);
+                    option.conn.execute(SyncMode.Sync, `
+                        CREATE TABLE IF NOT EXISTS ${tableES}(
+                            ${Object.values(this[_fields]).map(K => K[DBType.Sqlite]()).join(',')}
+                            ${this[_ids] && this[_ids].length ? `, PRIMARY KEY (${this[_ids].map(i => this[_fields][i]?.C2()).join(',')})` : ''}
+                        );
+                    `);
+                    if (this[_index] && this[_index].length) {
+                        for (const index of this[_index]) {
+                            option.conn.execute(SyncMode.Sync, `CREATE INDEX ${`${index}_${Math.random()}`.replace(/\./, '')} ON ${tableES} ("${this[_fields][index]?.C2()}");`);
+                        }
+                    }
+                    option.conn.execute(SyncMode.Sync, `INSERT INTO ${tableES} (${columns}) SELECT ${columns} FROM ${rtable};`);
+                    option.conn.execute(SyncMode.Sync, `DROP TABLE IF EXISTS ${rtable};`);
+                    // 更新完毕，保存版本号
+                    option.conn.execute(SyncMode.Sync, 'UPDATE TABLE_VERSION SET ______version = ? WHERE ______tableName = ?', [option.tableName, lastVersion]);
+                }
+                else if (!tableVersion) { // 不需要升级情况：没有旧的版本号
+                    option.conn.execute(SyncMode.Sync, 'INSERT INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option.tableName, lastVersion]);
+                }
+            }
+            else { // 表不存在
+                // 创建表
+                option.conn.execute(SyncMode.Sync, `
+                    CREATE TABLE IF NOT EXISTS ${tableES} (
+                        ${Object.values(this[_fields]).map(K => K[DBType.Sqlite]()).join(',')}
+                        ${this[_ids] && this[_ids].length ? `, PRIMARY KEY (${this[_ids].map(i => this[_fields][i]?.C2()).join(',')})` : ''}
+            
+                    );
+                `);
+                if (this[_index] && this[_index].length) {
+                    for (const index of this[_index]) {
+                        option.conn.execute(SyncMode.Sync, `CREATE INDEX ${`${index}_${Math.random()}`.replace(/\./, '')} ON ${tableES} ("${this[_fields][index]?.C2()}");`);
+                    }
+                }
+                option.conn.execute(SyncMode.Sync, 'INSERT OR REPLACE INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option.tableName, lastVersion]);
+            }
+        }
+        else if (option.dbType === DBType.SqliteRemote) {
+            return (async () => {
+                if (option?.force) {
+                    await option.conn.execute(SyncMode.Async, `DROP TABLE IF EXISTS ${tableES};`);
+                }
+                const lastVersion = this[_sqlite_version] ?? '1';
+                // 检查表
+                const tableCheckResult = await option.conn.pluck(SyncMode.Async, `SELECT COUNT(1) t FROM sqlite_master WHERE TYPE = 'table' AND name = ?`, [option.tableName]);
+                if (tableCheckResult) {
+                    // 旧版本
+                    const tableVersion = await option.conn.pluck(SyncMode.Async, 'SELECT ______version v from TABLE_VERSION WHERE ______tableName = ?', [option.tableName]);
+                    if (tableVersion && tableVersion < lastVersion) { // 发现需要升级的版本
+                        // 更新版本
+                        const columns = iterate(await option.conn.query(SyncMode.Async, `PRAGMA table_info(${tableES})`))
+                            .filter(c => this[_fields].hasOwnProperty(C2P(c.name, globalThis[_Hump])))
+                            .map(c => c.name)
+                            .join(',');
+                        const rtable = `${option.tableName}_${tableVersion.replace(/\./, '_')}`;
+                        await option.conn.execute(SyncMode.Async, `DROP TABLE IF EXISTS ${rtable};`);
+                        await option.conn.execute(SyncMode.Async, `ALTER TABLE ${tableES} RENAME TO ${rtable};`);
+                        await option.conn.execute(SyncMode.Async, `
+                        CREATE TABLE IF NOT EXISTS ${tableES}(
+                            ${Object.values(this[_fields]).map(K => K[DBType.Sqlite]()).join(',')}
+                            ${this[_ids] && this[_ids].length ? `, PRIMARY KEY (${this[_ids].map(i => this[_fields][i]?.C2()).join(',')})` : ''}
+                        );
+                    `);
+                        if (this[_index] && this[_index].length) {
+                            for (const index of this[_index]) {
+                                await option.conn.execute(SyncMode.Async, `CREATE INDEX ${`${index}_${Math.random()}`.replace(/\./, '')} ON ${tableES} ("${this[_fields][index]?.C2()}");`);
+                            }
+                        }
+                        await option.conn.execute(SyncMode.Async, `INSERT INTO ${tableES} (${columns}) SELECT ${columns} FROM ${rtable};`);
+                        await option.conn.execute(SyncMode.Async, `DROP TABLE IF EXISTS ${rtable};`);
+                        // 更新完毕，保存版本号
+                        await option.conn.execute(SyncMode.Async, 'UPDATE TABLE_VERSION SET ______version = ? WHERE ______tableName = ?', [option.tableName, lastVersion]);
+                    }
+                    else if (!tableVersion) { // 不需要升级情况：没有旧的版本号
+                        await option.conn.execute(SyncMode.Async, 'INSERT INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option.tableName, lastVersion]);
+                    }
+                }
+                else { // 表不存在
+                    // 创建表
+                    await option.conn.execute(SyncMode.Async, `
+                    CREATE TABLE IF NOT EXISTS ${tableES}(
+                        ${Object.values(this[_fields]).map(K => K[DBType.Sqlite]()).join(',')}
+                        ${this[_ids] && this[_ids].length ? `, PRIMARY KEY (${this[_ids].map(i => this[_fields][i]?.C2()).join(',')})` : ''}
+                    );
+                `);
+                    if (this[_index] && this[_index].length) {
+                        for (const index of this[_index]) {
+                            await option.conn.execute(SyncMode.Async, `CREATE INDEX ${`${index}_${Math.random()}`.replace(/\./, '')} ON ${option.tableName} ("${this[_fields][index]?.C2()}");`);
+                        }
+                    }
+                    await option.conn.execute(SyncMode.Async, 'INSERT OR REPLACE INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option.tableName, lastVersion]);
+                }
+            })();
+        }
+    }
+    close(option) {
+        delete globalThis[_dao][option.dbType][option.dbName];
+        if (option?.sync === SyncMode.Async) {
+            return option.dao.close(SyncMode.Async);
+        }
+        else if (option?.sync === SyncMode.Sync) {
+            option.dao.close(SyncMode.Sync);
+        }
+    }
+    /**
+    #创建表
+    ** `tableName` 表名称
+    ** `temp` 是否是临时表，默认true
+    ** `columns` 字符串数组，默认是当前实体类全部字段，通过`columns` 可以创建部分字段临时表
+    ** `id` 表的主键设置 4种：
+    1. `auto`: `columns`中已经在当前实体类配置的ID作为主键 `默认`
+    2. `all`: `columns`中所有字段全部当主键
+    3. `none`: 没有主键
+    4. 自定义字段名称：字符串数组
+    ** `index` 表的索引，设置方式同ID
+     */
+    _createTable({ tableName, temp = true, columns, data, id = 'auto', index = 'auto', dbType } = {}) {
+        const sqls = [];
+        columns = columns || this[_columns];
+        let ids;
+        if (id === 'auto') {
+            ids = this[_ids]?.filter(i => columns?.includes(i));
+        }
+        else if (id === 'all') {
+            ids = columns;
+        }
+        else if (id === 'none') {
+            ids = undefined;
+        }
+        else {
+            ids = id;
+        }
+        let indexs;
+        if (index === 'auto') {
+            indexs = this[_index]?.filter(i => columns?.includes(i));
+        }
+        else if (index === 'all') {
+            indexs = columns;
+        }
+        else if (index === 'none') {
+            indexs = undefined;
+        }
+        else {
+            indexs = index;
+        }
+        tableName = tableName ?? this[_tableName];
+        switch (dbType) {
+            case DBType.Mysql: {
+                let sql = formatDialect(`CREATE ${temp ? 'TEMPORARY' : ''} TABLE IF NOT EXISTS ${tableName}(
+                    ${columns.map(K => this[_fields][K][DBType.Mysql]()).join(',')}
+                    ${ids && ids.length ? `,PRIMARY KEY (${ids.map(i => this[_fields][i]?.C2()).join(',')})  USING BTREE ` : ''}
+                    ${indexs && indexs.length ? `,${indexs.map(i => `KEY ${this[_fields][i]?.C2()} (${this[_fields][i]?.C2()})`).join(',')} ` : ''}
+                ) ENGINE=MEMORY;`, { dialect: mysql });
+                sqls.push({ sql });
+                if (data && data.length > 0) {
+                    const params = [];
+                    let first = true;
+                    sql = formatDialect(`INSERT INTO ${tableName} (${columns.map(c => this[_fields][c]?.C2()).join(',')})
+                    ${(data).map(d => {
+                        const r = `SELECT ${Object.entries(d).map(([K, V]) => {
+                            params.push(V);
+                            return `? ${first ? this[_fields][K]?.C2() : ''}`;
+                        }).join(',')}`;
+                        first = false;
+                        return r;
+                    }).join(' UNION ALL ')}`, { dialect: mysql });
+                    sqls.push({ sql, params });
+                }
+                break;
+            }
+            case DBType.Sqlite:
+            case DBType.SqliteRemote: {
+                let sql = formatDialect(`CREATE ${temp ? 'TEMPORARY' : ''} TABLE IF NOT EXISTS ${tableName}(
+                    ${columns.map(K => this[_fields][K][DBType.Sqlite]()).join(',')}
+                    ${ids && ids.length ? `,PRIMARY KEY (${ids.map(i => this[_fields][i]?.C2()).join(',')}) ` : ''}
+                );`, { dialect: sqlite });
+                sqls.push({ sql });
+                if (indexs) {
+                    for (const index of indexs) {
+                        sql = formatDialect(`CREATE INDEX ${`${index}_${Math.random()}`.replace(/\./, '')} ON ${tableName} (${this[_fields][index]?.C2()});`, { dialect: sqlite });
+                        sqls.push({ sql });
+                    }
+                }
+                if (data && data.length > 0) {
+                    const params = [];
+                    let first = true;
+                    sql = formatDialect(`INSERT INTO ${tableName} (${columns.map(c => this[_fields][c]?.C2()).join(',')})
+                    ${(data).map(d => {
+                        const r = `SELECT ${Object.entries(d).map(([K, V]) => {
+                            params.push(V);
+                            return `? ${first ? this[_fields][K]?.C2() : ''}`;
+                        }).join(',')}`;
+                        first = false;
+                        return r;
+                    }).join(' UNION ALL ')}`, { dialect: sqlite });
+                    sqls.push({ sql, params });
+                }
+                break;
+            }
+        }
+        return sqls;
+    }
+    _matchSqlid(sqlid) {
+        sqlid ?? (sqlid = '');
+        if (sqlid.includes('.'))
+            return [sqlid];
+        else
+            return [`${this[_tableName]}.${sqlid}`, `${this[_className]}.${sqlid}`, `${this[_ClassName]}.${sqlid}`, `${this[_vueName]}.${sqlid}`];
+    }
+    _setParam(v, ps) {
+        if (v instanceof Array) {
+            ps.push(...v);
+            return v.map(i => '?').join(',');
+        }
+        else {
+            ps.push(v);
+            return '?';
+        }
+    }
+    _generSql(dbType, _sql, _params) {
+        const params = [];
+        const sql = formatDialect(_sql?.replace(/\:([\w.]+)/g, (txt, key) => {
+            let V = LGet(_params, key);
+            if (V !== undefined) {
+                return this._setParam(V, params);
+            }
+            const _key = C2P(key);
+            V = LGet(_params, _key);
+            if (V !== undefined) {
+                return this._setParam(V, params);
+            }
+            const __key = P2C(key);
+            V = LGet(_params, __key);
+            if (V !== undefined) {
+                return this._setParam(V, params);
+            }
+            return txt;
+        }), { dialect: formatDialects[dbType] });
+        return { params, sql };
+    }
+}
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "insert", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "update", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "delete", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "template", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "select", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "selectBatch", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "excute", null);
+__decorate([
+    P(true),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "transaction", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "page", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "init", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "close", null);