baja-lite 1.0.0

package/es/sql.js

@@ -0,0 +1,3338 @@
+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;
+var _d, _e, _f;
+import 'reflect-metadata';
+import { Throw } from './error';
+import tslib from 'tslib';
+import Sqlstring from 'sqlstring';
+import iterare from 'iterare';
+import { emptyString } from './string';
+import pino from 'pino';
+import { excuteSplit, ExcuteSplitMode, sleep } from './fn';
+import { add } from './math';
+// #region 常量
+const _daoDBName = Symbol('dbName');
+const _tableName = Symbol('tableName');
+const _ids = Symbol('ids');
+const _columns = Symbol('columns');
+const _columnsNoId = Symbol('columnsNoId');
+const _fields = Symbol('fields');
+const _stateFileName = Symbol('stateFileName');
+const _deleteState = Symbol('deleteState');
+const _transformer = Symbol('transformer');
+const _index = Symbol('index');
+const _def = Symbol('def');
+const _sqlCache = Symbol('sqlCache');
+const _dao = Symbol('dao');
+const _primaryDB = Symbol('primaryDB');
+const _dbType = Symbol('dbType');
+const _sqlite_version = Symbol('sqlite_version');
+const _daoConnection = Symbol('daoConnection');
+const _inTransaction = Symbol('inTransaction');
+const _daoDB = Symbol('daoDB');
+const _sqliteRemoteName = Symbol('sqliteRemoteName');
+const _SqlOption = Symbol('SqlOption');
+const _GlobalSqlOption = Symbol('GlobalSqlOption');
+const _EventBus = Symbol('EventBus');
+const _path = Symbol('path');
+const _fs = Symbol('fs');
+const logger = pino({
+    name: 'sql',
+    transport: {
+        target: 'pino-pretty'
+    }
+});
+// #endregion
+// #region 可选配置
+export var DBType;
+(function (DBType) {
+    DBType[DBType["Mysql"] = 0] = "Mysql";
+    DBType[DBType["Sqlite"] = 1] = "Sqlite";
+    DBType[DBType["Mongo"] = 2] = "Mongo";
+    DBType[DBType["SqliteRemote"] = 3] = "SqliteRemote";
+    DBType[DBType["Redis"] = 4] = "Redis";
+    DBType[DBType["RedisLock"] = 5] = "RedisLock";
+})(DBType || (DBType = {}));
+export var SqlSyncMode;
+(function (SqlSyncMode) {
+    /** 同步执行 */
+    SqlSyncMode[SqlSyncMode["Sync"] = 0] = "Sync";
+    /** 异步执行 */
+    SqlSyncMode[SqlSyncMode["Async"] = 1] = "Async";
+})(SqlSyncMode || (SqlSyncMode = {}));
+export var SqlInsertMode;
+(function (SqlInsertMode) {
+    /**
+    # 默认使用
+    ** 支持单个、批量,语法 `INSERT INTO XX VALUES (第一条数据), (第二条数据);`
+    ** 批量执行有性能优势，但无法利用数据库的sql预编译功能
+    */
+    SqlInsertMode[SqlInsertMode["Insert"] = 0] = "Insert";
+    /**
+    # 利用临时表
+    ## 执行步骤
+    1. 建立临时表(从正式表复制)
+    2. 数据全部进入临时表
+    3. 临时表数据转移到正式表: `INSERT INTO 正式表 SELECT * FROM 临时表`
+    4. 删除临时表
+    ## 注意
+    1. 适用于：主键不会冲突、非自增
+    2. 临时表的结构复制正式表
+     */
+    SqlInsertMode[SqlInsertMode["InsertWithTempTable"] = 1] = "InsertWithTempTable";
+    SqlInsertMode[SqlInsertMode["InsertIfNotExists"] = 2] = "InsertIfNotExists";
+    /**
+    # 插入或者更新
+    1. 判断依据是主键
+     */
+    SqlInsertMode[SqlInsertMode["Replace"] = 3] = "Replace";
+})(SqlInsertMode || (SqlInsertMode = {}));
+export var SqlDelMode;
+(function (SqlDelMode) {
+    /**
+     ##常规删除 默认
+     ### 例一
+     `DELETE FROM WHERE (id = 1) OR (id = 2)`
+     ### 例二
+     `DELETE FROM WHERE (id = 1 AND idx = 11) OR (id = 2 AND idx = 22)`
+    */
+    SqlDelMode[SqlDelMode["Common"] = 0] = "Common";
+    /*
+    ## 借助临时表
+    ### 注意：必须保证where的字段都相同，否则会漏删数据
+    DELETE FROM 正式表 INNER JOIN 临时表 WHERE 字段1 = 字段1 AND 字段2 = 字段2
+     */
+    SqlDelMode[SqlDelMode["TempTable"] = 1] = "TempTable";
+})(SqlDelMode || (SqlDelMode = {}));
+export var SqlSelectMode;
+(function (SqlSelectMode) {
+    /**
+     ##常规 默认
+     ### 例一
+     `SELECT * FROM WHERE (id = 1) OR (id = 2)`
+     ### 例二
+     `SELECT * FROM WHERE (id = 1 AND idx = 11) OR (id = 2 AND idx = 22)`
+    */
+    SqlSelectMode[SqlSelectMode["Common"] = 0] = "Common";
+    /*
+    ## 借助临时表
+    ### 注意：必须保证where的字段都相同，否则会漏删数据
+    SELECT * FROM 正式表 INNER JOIN 临时表 WHERE 字段1 = 字段1 AND 字段2 = 字段2
+     */
+    SqlSelectMode[SqlSelectMode["TempTable"] = 1] = "TempTable";
+})(SqlSelectMode || (SqlSelectMode = {}));
+export var SqlTemplateMode;
+(function (SqlTemplateMode) {
+    /** 确定返回一个，如果不是一个，将报错，返回类型是T */
+    SqlTemplateMode[SqlTemplateMode["AssertOne"] = 0] = "AssertOne";
+    /** 可能返回一个，返回类型是T|null */
+    SqlTemplateMode[SqlTemplateMode["NotSureOne"] = 1] = "NotSureOne";
+    /** 返回多个 */
+    SqlTemplateMode[SqlTemplateMode["Many"] = 2] = "Many";
+    /** 仅查询记录数量 */
+    SqlTemplateMode[SqlTemplateMode["Count"] = 3] = "Count";
+})(SqlTemplateMode || (SqlTemplateMode = {}));
+export var SqlQueryMode;
+(function (SqlQueryMode) {
+    SqlQueryMode[SqlQueryMode["One_Row_One_Column_Assert"] = 0] = "One_Row_One_Column_Assert";
+    SqlQueryMode[SqlQueryMode["One_Row_One_Column_NotSure"] = 1] = "One_Row_One_Column_NotSure";
+    SqlQueryMode[SqlQueryMode["One_Row_Many_Column_Assert"] = 2] = "One_Row_Many_Column_Assert";
+    SqlQueryMode[SqlQueryMode["One_Row_Many_Column_NotSure"] = 3] = "One_Row_Many_Column_NotSure";
+    SqlQueryMode[SqlQueryMode["Many_Row_One_Column"] = 4] = "Many_Row_One_Column";
+    SqlQueryMode[SqlQueryMode["Many_Row_Many_Column"] = 5] = "Many_Row_Many_Column";
+})(SqlQueryMode || (SqlQueryMode = {}));
+export var SqlType;
+(function (SqlType) {
+    SqlType[SqlType["bigint"] = 0] = "bigint";
+    SqlType[SqlType["char"] = 1] = "char";
+    SqlType[SqlType["decimal"] = 2] = "decimal";
+    SqlType[SqlType["int"] = 3] = "int";
+    SqlType[SqlType["longtext"] = 4] = "longtext";
+    SqlType[SqlType["mediumtext"] = 5] = "mediumtext";
+    SqlType[SqlType["smallint"] = 6] = "smallint";
+    SqlType[SqlType["text"] = 7] = "text";
+    SqlType[SqlType["tinyint"] = 8] = "tinyint";
+    SqlType[SqlType["varchar"] = 9] = "varchar";
+})(SqlType || (SqlType = {}));
+export const SqliteMemory = ':memory:';
+const _defOption = {
+    maxDeal: 500,
+    skipUndefined: true,
+    skipNull: true,
+    skipEmptyString: true
+};
+;
+class MysqlConnection {
+    constructor(conn) {
+        this[_a] = false;
+        this[_daoConnection] = conn;
+    }
+    execute(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (sync === SqlSyncMode.Sync) {
+            logger.warn('MYSQL not suppouted sync mode');
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(Sqlstring.format(sql, params));
+        }
+        return new Promise(async (resolve) => {
+            try {
+                const [_result] = await this[_daoConnection].execute(sql, params);
+                const result = _result;
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    logger.trace(result);
+                }
+                resolve({ affectedRows: result.affectedRows, insertId: result.insertId });
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        });
+    }
+    pluck(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SqlSyncMode.Sync) {
+            logger.warn('MYSQL not suppouted sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(Sqlstring.format(sql, params));
+        }
+        return new Promise(async (resolve) => {
+            try {
+                const [result] = await this[_daoConnection].query(sql, params);
+                if (result && result[0]) {
+                    const r = Object.values(result[0])[0];
+                    if (r === null)
+                        resolve(r);
+                    else
+                        resolve(r);
+                }
+                resolve(null);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        });
+    }
+    get(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SqlSyncMode.Sync) {
+            logger.warn('MYSQL not suppouted sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(Sqlstring.format(sql, params));
+        }
+        return new Promise(async (resolve) => {
+            try {
+                const [result] = await this[_daoConnection].query(sql, params);
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    logger.trace(result);
+                }
+                if (result && result[0])
+                    resolve(result[0]);
+                resolve(null);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        });
+    }
+    raw(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SqlSyncMode.Sync) {
+            logger.warn('MYSQL not suppouted sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(Sqlstring.format(sql, params));
+        }
+        return new Promise(async (resolve) => {
+            try {
+                const [result] = await this[_daoConnection].query(sql, params);
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    logger.trace(result);
+                }
+                if (result)
+                    resolve(result.map((i) => Object.values(i)[0]));
+                resolve([]);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        });
+    }
+    query(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SqlSyncMode.Sync) {
+            logger.warn('MYSQL not suppouted sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(Sqlstring.format(sql, params));
+        }
+        return new Promise(async (resolve) => {
+            try {
+                const [result] = await this[_daoConnection].query(sql, params);
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    logger.trace(result);
+                }
+                resolve(result);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        });
+    }
+    realse(sync) {
+        if (sync === SqlSyncMode.Sync) {
+            try {
+                this[_daoConnection]?.release();
+            }
+            catch (error) {
+            }
+        }
+        ;
+    }
+}
+_a = _inTransaction;
+class Mysql {
+    constructor(pool) {
+        this[_daoDB] = pool;
+    }
+    createConnection(sync) {
+        if (sync === SqlSyncMode.Sync) {
+            logger.error('MYSQL not suppouted sync mode');
+            return null;
+        }
+        ;
+        return new Promise(async (resolve) => {
+            const connection = await this[_daoDB].getConnection();
+            logger.debug('create new!');
+            resolve(new MysqlConnection(connection));
+        });
+    }
+    transaction(sync, fn, conn) {
+        if (sync === SqlSyncMode.Sync) {
+            logger.warn('MYSQL not suppouted sync mode');
+            return null;
+        }
+        ;
+        return new Promise(async (resolve) => {
+            let needCommit = false;
+            let newConn = false;
+            if (!conn) {
+                conn = await this.createConnection(SqlSyncMode.Async) ?? undefined;
+                newConn = true;
+            }
+            if (conn?.[_inTransaction] !== true) {
+                needCommit = true;
+                logger.debug('beginTransaction begin!');
+                await conn[_daoConnection].beginTransaction();
+                logger.debug('beginTransaction end!');
+            }
+            conn[_inTransaction] = true;
+            try {
+                const result = await fn(conn);
+                if (needCommit === true) {
+                    logger.debug('commit begin!');
+                    await conn[_daoConnection].commit();
+                    conn[_inTransaction] = false;
+                    logger.debug('commit end!');
+                }
+                resolve(result);
+            }
+            catch (error) {
+                logger.debug('rollback begin!');
+                await conn[_daoConnection].rollback();
+                logger.debug('rollback end!');
+                conn[_inTransaction] = false;
+                logger.error(error);
+                throw error;
+            }
+            finally {
+                try {
+                    if (needCommit === true) {
+                        conn[_inTransaction] = false;
+                    }
+                    if (newConn === true) {
+                        logger.debug('release begin!');
+                        conn[_daoConnection].release();
+                        logger.debug('release end!');
+                    }
+                }
+                catch (error) {
+                }
+            }
+        });
+    }
+    close(sync) {
+        if (sync === SqlSyncMode.Sync) {
+            this[_daoDB]?.destroy();
+        }
+        ;
+    }
+    backup(sync, name) {
+    }
+    remove(sync) {
+    }
+    restore(sync, name) {
+    }
+}
+class SqliteConnection {
+    constructor(conn) {
+        this[_b] = false;
+        this[_daoConnection] = conn;
+    }
+    execute(sync, sql, params) {
+        try {
+            logger.debug(sql, params ?? '');
+            if (!sql) {
+                return { affectedRows: 0, insertId: 0n };
+            }
+            ;
+            if (sync === SqlSyncMode.Async) {
+                logger.warn(`SQLITE not suppoted async mode`);
+                return { affectedRows: 0, insertId: 0n };
+            }
+            ;
+            if (globalThis[_GlobalSqlOption].log === 'trace') {
+                logger.trace(Sqlstring.format(sql, params));
+            }
+            const result = this[_daoConnection].prepare(sql).run(params ?? {});
+            if (globalThis[_GlobalSqlOption].log === 'trace') {
+                logger.trace(result);
+            }
+            const { changes, lastInsertRowid } = result;
+            return { affectedRows: changes, insertId: lastInsertRowid ? BigInt(lastInsertRowid) : 0n };
+        }
+        catch (error) {
+            logger.error(`
+                error: ${error},
+                sql: ${sql},
+                params: ${params}
+            `);
+            throw error;
+        }
+    }
+    pluck(sync, sql, params) {
+        try {
+            logger.debug(sql, params ?? '');
+            if (!sql) {
+                return null;
+            }
+            ;
+            if (sync === SqlSyncMode.Async) {
+                logger.warn(`SQLITE not suppoted async mode`);
+                return null;
+            }
+            ;
+            if (globalThis[_GlobalSqlOption].log === 'trace') {
+                logger.trace(Sqlstring.format(sql, params));
+            }
+            return this[_daoConnection].prepare(sql).pluck().get(params ?? {});
+        }
+        catch (error) {
+            logger.error(`
+                error: ${error},
+                sql: ${sql},
+                params: ${params}
+            `);
+            throw error;
+        }
+    }
+    get(sync, sql, params) {
+        try {
+            logger.debug(sql, params ?? '');
+            if (!sql) {
+                return null;
+            }
+            ;
+            if (sync === SqlSyncMode.Async) {
+                return null;
+            }
+            ;
+            if (globalThis[_GlobalSqlOption].log === 'trace') {
+                logger.trace(Sqlstring.format(sql, params));
+            }
+            return this[_daoConnection].prepare(sql).get(params ?? {});
+        }
+        catch (error) {
+            logger.error(`
+                error: ${error},
+                sql: ${sql},
+                params: ${params}
+            `);
+            throw error;
+        }
+    }
+    raw(sync, sql, params) {
+        try {
+            logger.debug(sql, params ?? '');
+            if (!sql) {
+                return [];
+            }
+            ;
+            if (sync === SqlSyncMode.Async) {
+                logger.warn(`SQLITE not suppoted async mode`);
+                return [];
+            }
+            ;
+            if (globalThis[_GlobalSqlOption].log === 'trace') {
+                logger.trace(Sqlstring.format(sql, params));
+            }
+            return this[_daoConnection].prepare(sql).raw().all(params ?? {});
+        }
+        catch (error) {
+            logger.error(`
+                error: ${error},
+                sql: ${sql},
+                params: ${params}
+            `);
+            throw error;
+        }
+    }
+    query(sync, sql, params) {
+        try {
+            logger.debug(sql, params ?? '');
+            if (!sql) {
+                return [];
+            }
+            ;
+            if (sync === SqlSyncMode.Async) {
+                logger.warn(`SQLITE not suppoted async mode`);
+                return [];
+            }
+            ;
+            if (globalThis[_GlobalSqlOption].log === 'trace') {
+                logger.trace(Sqlstring.format(sql, params));
+            }
+            return this[_daoConnection].prepare(sql).all(params ?? {});
+        }
+        catch (error) {
+            logger.error(`
+                error: ${error},
+                sql: ${sql},
+                params: ${params}
+            `);
+            throw error;
+        }
+    }
+    realse(sync) {
+    }
+}
+_b = _inTransaction;
+class Sqlite {
+    constructor(db) {
+        this[_daoDB] = db;
+        this[_daoDB].pragma('journal_mode = WAL');
+        this[_daoDB].exec(`
+            CREATE TABLE IF NOT EXISTS DUAL ( ______id INTEGER NOT NULL, PRIMARY KEY ( ______id ));
+            DELETE FROM DUAL;
+            INSERT INTO DUAL (______id ) VALUES ( 1 );
+            CREATE TABLE IF NOT EXISTS TABLE_VERSION (
+            ______tableName text NOT NULL,
+            ______version text NOT NULL,
+            PRIMARY KEY ( ______tableName )
+            );
+        `);
+    }
+    createConnection(sync) {
+        if (sync === SqlSyncMode.Async) {
+            logger.error(`SQLITE not suppoted async mode`);
+            return null;
+        }
+        ;
+        return new SqliteConnection(this[_daoDB]);
+    }
+    transaction(sync, fn, conn) {
+        if (sync === SqlSyncMode.Async) {
+            logger.warn(`SQLITE not suppoted async mode`);
+            return null;
+        }
+        ;
+        if (!conn) {
+            conn = this.createConnection(SqlSyncMode.Sync) ?? undefined;
+        }
+        if (conn[_inTransaction] !== true) {
+            return this[_daoDB].transaction(() => {
+                conn[_inTransaction] = true;
+                const rt = fn(conn);
+                conn[_inTransaction] = false;
+                return rt;
+            })();
+        }
+        else {
+            const rt = fn(conn);
+            return rt;
+        }
+    }
+    close(sync) {
+        if (sync === SqlSyncMode.Sync) {
+            this[_daoDB].close();
+        }
+        ;
+    }
+    backup(sync, name) {
+        if (sync === SqlSyncMode.Sync) {
+            this[_daoDB].backup(name);
+        }
+        ;
+    }
+    remove(sync) {
+    }
+    restore(sync, name) {
+    }
+}
+class SqliteRemoteConnection {
+    constructor(conn, name) {
+        this[_c] = false;
+        this[_daoConnection] = conn;
+        this[_sqliteRemoteName] = name;
+    }
+    execute(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (sync === SqlSyncMode.Sync) {
+            logger.warn('SqliteRemote not suppouted sync mode');
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(Sqlstring.format(sql, params));
+        }
+        return new Promise(async (resolve) => {
+            try {
+                const { affectedRows, insertId } = await this[_daoConnection].execute(this[_sqliteRemoteName], sql, params);
+                resolve({ affectedRows, insertId: insertId ? BigInt(insertId) : 0n });
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        });
+    }
+    pluck(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SqlSyncMode.Sync) {
+            logger.warn('SqliteRemote not suppouted sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(Sqlstring.format(sql, params));
+        }
+        return new Promise(async (resolve) => {
+            try {
+                const r = await this[_daoConnection].pluck(this[_sqliteRemoteName], sql, params);
+                resolve(r);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        });
+    }
+    get(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SqlSyncMode.Sync) {
+            logger.warn('SqliteRemote not suppouted sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(Sqlstring.format(sql, params));
+        }
+        return new Promise(async (resolve) => {
+            try {
+                const r = await this[_daoConnection].get(this[_sqliteRemoteName], sql, params);
+                resolve(r);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        });
+    }
+    raw(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SqlSyncMode.Sync) {
+            logger.warn('SqliteRemote not suppouted sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(Sqlstring.format(sql, params));
+        }
+        return new Promise(async (resolve) => {
+            try {
+                const r = await this[_daoConnection].raw(this[_sqliteRemoteName], sql, params);
+                resolve(r);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        });
+    }
+    query(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SqlSyncMode.Sync) {
+            logger.warn('SqliteRemote not suppouted sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(Sqlstring.format(sql, params));
+        }
+        return new Promise(async (resolve) => {
+            try {
+                const r = await this[_daoConnection].query(this[_sqliteRemoteName], sql, params);
+                resolve(r);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                throw error;
+            }
+        });
+    }
+    realse(sync) {
+    }
+}
+_c = _inTransaction;
+class SqliteRemote {
+    constructor(db, name) {
+        this[_daoDB] = db;
+        this[_sqliteRemoteName] = name;
+    }
+    createConnection(sync) {
+        if (sync === SqlSyncMode.Sync) {
+            logger.error('SQLITEREMOTE not suppouted sync mode');
+            return null;
+        }
+        ;
+        return new Promise(async (resolve) => {
+            resolve(new SqliteRemoteConnection(this[_daoDB], this[_sqliteRemoteName]));
+        });
+    }
+    transaction(sync, fn, conn) {
+        logger.warn(`SQLITEREMOTE not suppoted transaction`);
+        return null;
+    }
+    close(sync) {
+        if (sync === SqlSyncMode.Async) {
+            return new Promise(async () => {
+                await this[_daoConnection].close();
+            });
+        }
+        ;
+    }
+    backup(sync, name) {
+        if (sync === SqlSyncMode.Async) {
+            return new Promise(async () => {
+                await this[_daoConnection].backup(this[_sqliteRemoteName], name);
+            });
+        }
+        ;
+    }
+    remove(sync) {
+        if (sync === SqlSyncMode.Async) {
+            return new Promise(async () => {
+                await this[_daoConnection].remove();
+            });
+        }
+        ;
+    }
+    restore(sync, name) {
+        if (sync === SqlSyncMode.Async) {
+            return new Promise(async () => {
+                await this[_daoConnection].restore(this[_sqliteRemoteName], name);
+            });
+        }
+        ;
+    }
+}
+class SqlCache {
+    constructor() {
+        this.cache = {};
+    }
+    async init(options) {
+        if (options.sqlDir) {
+            const sqlFis = globalThis[_fs].readdirSync(options.sqlDir);
+            for (const modeName of sqlFis) {
+                const name = globalThis[_path].basename(modeName, globalThis[_path].extname(modeName));
+                const obj = await import(globalThis[_path].join(options.sqlDir, modeName));
+                for (const [key, fn] of Object.entries(obj)) {
+                    this.cache[`${name}.${String(key)}`] = fn;
+                }
+            }
+        }
+        else if (options.sqlCache) {
+            this.cache = options.sqlCache;
+        }
+    }
+    load(sqlid, params, context, isPage) {
+        const sqlSource = this.cache[sqlid];
+        Throw.if(!sqlSource, `指定的语句${sqlid}不存在!`);
+        if (typeof sqlSource === 'string') {
+            return sqlSource;
+        }
+        else {
+            return sqlSource(params, context, isPage);
+        }
+    }
+}
+// #endregion
+/**
+
+## 所有service中内置方法定义规则
+ ** 方法第一个参数必须是 sync: SyncMode
+ ** 方法最后一个参数必须是 option
+
+## sync 表示是否是同步方法
+
+因为mysql是异步、sqlite是同步，导致必须通过一个标识来区分，否则将必须为两种数据库设置不同的service，失去了意义
+
+## option 额外控制参数
+
+## length
+方法的参数数量
+ */
+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 = SqlSyncMode.Async);
+            const dbName = option?.dbName ?? this[_daoDBName] ?? _primaryDB;
+            option.dao = globalThis[_dao][this[_dbType]][dbName];
+            Throw.if(!option.dao, `not found db:${String(dbName)}(${this[_dbType]})`);
+            option.tableName = option?.tableName ?? this[_tableName];
+            const tableES = Sqlstring.escapeId(option.tableName);
+            if (this[_dbType] === DBType.Sqlite) {
+                Throw.if(option.sync === SqlSyncMode.Async, 'sqlite can not Async!');
+                // 连接共享
+                if (skipConn === false && !option.conn) {
+                    option.conn = option.dao.createConnection(SqlSyncMode.Sync);
+                }
+                else {
+                    needRealseConn = false;
+                }
+                if (skipConn === false) {
+                    const lastVersion = this[_sqlite_version] ?? '0.0.1';
+                    // 检查表
+                    const tableCheckResult = option.conn.pluck(SqlSyncMode.Sync, `SELECT COUNT(1) t FROM sqlite_master WHERE TYPE = 'table' AND name = ?`, [option.tableName]);
+                    if (tableCheckResult) {
+                        // 旧版本
+                        const tableVersion = option.conn.pluck(SqlSyncMode.Sync, 'SELECT ______version v from TABLE_VERSION WHERE ______tableName = ?', [option.tableName]);
+                        if (tableVersion && tableVersion < lastVersion) { // 发现需要升级的版本
+                            // 更新版本
+                            const columns = iterare(option.conn.query(SqlSyncMode.Sync, `PRAGMA table_info(${tableES})`))
+                                .filter(c => this[_fields].hasOwnProperty(c.name))
+                                .map(c => Sqlstring.escapeId(c.name))
+                                .join(',');
+                            const rtable = Sqlstring.escapeId(`${option.tableName}_${tableVersion.replace(/\./, '_')}`);
+                            option.conn.execute(SqlSyncMode.Sync, `DROP TABLE IF EXISTS ${rtable};`);
+                            option.conn.execute(SqlSyncMode.Sync, `ALTER TABLE ${tableES} RENAME TO ${rtable};`);
+                            option.conn.execute(SqlSyncMode.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]?.esName).join(',')})` : ''}
+                                );
+                            `);
+                            if (this[_index] && this[_index].length) {
+                                for (const index of this[_index]) {
+                                    option.conn.execute(SqlSyncMode.Sync, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableES} ("${index}");`);
+                                }
+                            }
+                            option.conn.execute(SqlSyncMode.Sync, `INSERT INTO ${tableES} (${columns}) SELECT ${columns} FROM ${rtable};`);
+                            option.conn.execute(SqlSyncMode.Sync, `INSERT INTO ${tableES} (${columns}) SELECT ${columns} FROM ${rtable};`);
+                            option.conn.execute(SqlSyncMode.Sync, `DROP TABLE IF EXISTS ${rtable};`);
+                            // 更新完毕，保存版本号
+                            option.conn.execute(SqlSyncMode.Sync, 'UPDATE TABLE_VERSION SET ______version = ? WHERE ______tableName = ?', [option.tableName, lastVersion]);
+                        }
+                        else if (!tableVersion) { // 不需要升级情况：没有旧的版本号
+                            option.conn.execute(SqlSyncMode.Sync, 'INSERT INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option.tableName, lastVersion]);
+                        }
+                    }
+                    else { // 表不存在
+                        // 创建表
+                        option.conn.execute(SqlSyncMode.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]?.esName).join(',')})` : ''}
+                    
+                            );
+                        `);
+                        if (this[_index] && this[_index].length) {
+                            for (const index of this[_index]) {
+                                option.conn.execute(SqlSyncMode.Sync, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableES} ("${index}");`);
+                            }
+                        }
+                        option.conn.execute(SqlSyncMode.Sync, 'INSERT OR REPLACE INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option.tableName, lastVersion]);
+                    }
+                }
+                try {
+                    const result = fn.call(this, ...args);
+                    logger.info(`${propertyKey}:${option.tableName}:use ${+new Date() - startTime}ms`);
+                    return result;
+                }
+                catch (error) {
+                    try {
+                        console.error(`service ${propertyKey} have an error:${error}, it's argumens: ${JSON.stringify(args.filter(i => typeof i !== 'object' || (typeof i === 'object' && !i.insert)))}`);
+                    }
+                    catch (error) {
+                    }
+                    throw error;
+                }
+                finally {
+                    if (needRealseConn && option && option.conn) {
+                        try {
+                            option.conn.realse(SqlSyncMode.Sync);
+                        }
+                        catch (error) {
+                        }
+                    }
+                }
+            }
+            else if (this[_dbType] === DBType.SqliteRemote) {
+                Throw.if(option.sync === SqlSyncMode.Sync, 'SqliteRemote remote can not sync!');
+                return new Promise(async (resolve) => {
+                    // 连接共享
+                    if (skipConn === false && !option.conn) {
+                        (option).conn = await option.dao.createConnection(SqlSyncMode.Async);
+                    }
+                    else {
+                        needRealseConn = false;
+                    }
+                    if (skipConn === false) {
+                        const lastVersion = this[_sqlite_version] ?? '0.0.1';
+                        // 检查表
+                        const tableCheckResult = await option.conn.pluck(SqlSyncMode.Async, `SELECT COUNT(1) t FROM sqlite_master WHERE TYPE = 'table' AND name = ?`, [option.tableName]);
+                        if (tableCheckResult) {
+                            // 旧版本
+                            const tableVersion = await option.conn.pluck(SqlSyncMode.Async, 'SELECT ______version v from TABLE_VERSION WHERE ______tableName = ?', [option.tableName]);
+                            if (tableVersion && tableVersion < lastVersion) { // 发现需要升级的版本
+                                // 更新版本
+                                const columns = iterare(await option.conn.query(SqlSyncMode.Async, `PRAGMA table_info(${tableES})`))
+                                    .filter(c => this[_fields].hasOwnProperty(c.name))
+                                    .map(c => Sqlstring.escapeId(c.name))
+                                    .join(',');
+                                const rtable = `${option.tableName}_${tableVersion.replace(/\./, '_')}`;
+                                await option.conn.execute(SqlSyncMode.Async, `DROP TABLE IF EXISTS ${rtable};`);
+                                await option.conn.execute(SqlSyncMode.Async, `ALTER TABLE ${tableES} RENAME TO ${rtable};`);
+                                await option.conn.execute(SqlSyncMode.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]?.esName).join(',')})` : ''}
+                                );
+                            `);
+                                if (this[_index] && this[_index].length) {
+                                    for (const index of this[_index]) {
+                                        await option.conn.execute(SqlSyncMode.Async, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableES} ("${index}");`);
+                                    }
+                                }
+                                await option.conn.execute(SqlSyncMode.Async, `INSERT INTO ${tableES} (${columns}) SELECT ${columns} FROM ${rtable};`);
+                                await option.conn.execute(SqlSyncMode.Async, `INSERT INTO ${tableES} (${columns}) SELECT ${columns} FROM ${rtable};`);
+                                await option.conn.execute(SqlSyncMode.Async, `DROP TABLE IF EXISTS ${rtable};`);
+                                // 更新完毕，保存版本号
+                                await option.conn.execute(SqlSyncMode.Async, 'UPDATE TABLE_VERSION SET ______version = ? WHERE ______tableName = ?', [option.tableName, lastVersion]);
+                            }
+                            else if (!tableVersion) { // 不需要升级情况：没有旧的版本号
+                                await option.conn.execute(SqlSyncMode.Async, 'INSERT INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option.tableName, lastVersion]);
+                            }
+                        }
+                        else { // 表不存在
+                            // 创建表
+                            await option.conn.execute(SqlSyncMode.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]?.esName).join(',')})` : ''}
+                            );
+                        `);
+                            if (this[_index] && this[_index].length) {
+                                for (const index of this[_index]) {
+                                    await option.conn.execute(SqlSyncMode.Async, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${Sqlstring.escapeId(option.tableName)} ("${index}");`);
+                                }
+                            }
+                            await option.conn.execute(SqlSyncMode.Async, 'INSERT OR REPLACE INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option.tableName, lastVersion]);
+                        }
+                    }
+                    try {
+                        const result = await fn.call(this, ...args);
+                        logger.info(`${propertyKey}:${option.tableName}:use ${+new Date() - startTime}ms`);
+                        resolve(result);
+                    }
+                    catch (error) {
+                        console.error(`service ${propertyKey} have an error:${error}, it's argumens: ${JSON.stringify(args.filter(i => typeof i !== 'object' || (typeof i === 'object' && !i.insert)))}`);
+                        throw error;
+                    }
+                    finally {
+                        if (needRealseConn && option && option.conn) {
+                            try {
+                                option.conn.realse(SqlSyncMode.Sync);
+                            }
+                            catch (error) {
+                            }
+                        }
+                    }
+                });
+            }
+            else if (this[_dbType] === DBType.Mysql) {
+                return new Promise(async (resolve) => {
+                    try {
+                        // 连接共享
+                        if (skipConn === false && !option.conn) {
+                            (option).conn = await option.dao.createConnection(SqlSyncMode.Async);
+                        }
+                        else {
+                            needRealseConn = false;
+                        }
+                        const result = await fn.call(this, ...args);
+                        logger.info(`${propertyKey}:${option.tableName}:use ${+new Date() - startTime}ms`);
+                        resolve(result);
+                    }
+                    catch (error) {
+                        console.error(`service ${propertyKey} have an error:${error}, it's argumens: ${JSON.stringify(args.filter(i => typeof i !== 'object' || (typeof i === 'object' && !i.insert)))}`);
+                        throw error;
+                    }
+                    finally {
+                        if (needRealseConn && option && option.conn) {
+                            try {
+                                option.conn.realse(SqlSyncMode.Sync);
+                            }
+                            catch (error) {
+                            }
+                        }
+                    }
+                });
+            }
+        };
+    };
+}
+const FieldFilter = (K, V, def, option) => {
+    let ret = 0;
+    if (V === null) {
+        if (option?.skipNull !== true) {
+            ret = 1;
+            V = option?.def === true && def && def.hasOwnProperty(K) ? def[K] : null;
+        }
+    }
+    else if (V === undefined) {
+        if (option?.skipUndefined !== true) {
+            ret = 1;
+            V = option?.def === true && def && def.hasOwnProperty(K) ? def[K] : null;
+        }
+    }
+    else if (emptyString(`${V ?? ''}`)) {
+        if (option?.skipEmptyString !== true) {
+            ret = 1;
+            V = option?.def === true && def && def.hasOwnProperty(K) ? def[K] : '';
+        }
+    }
+    else {
+        ret = 1;
+    }
+    if (ret === 1) {
+        option?.finalColumns?.add(K);
+        option?.tempColumns?.push(K);
+    }
+    return [ret, V];
+};
+const MYSQLCHARSET = `CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci`;
+export const Field = (config) => {
+    config.type ?? (config.type = SqlType.varchar);
+    return (object, propertyName) => {
+        const field = config;
+        field.name = propertyName;
+        field.esName = Sqlstring.escapeId(propertyName);
+        const hasDef = field.hasOwnProperty('def') === true;
+        switch (field.type) {
+            case SqlType.bigint: {
+                field[DBType.Mysql] = `${field.esName} bigint ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} integer`;
+                break;
+            }
+            case SqlType.char: {
+                field[DBType.Mysql] = `${field.esName} char(${config.length1 ?? 1}) ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.decimal: {
+                field[DBType.Mysql] = `${field.esName} decimal(${config.length1 ?? 1}, ${config.length2 ?? 2}) ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} `;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} real`;
+                break;
+            }
+            case SqlType.int: {
+                field[DBType.Mysql] = `${field.esName} int ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} integer`;
+                break;
+            }
+            case SqlType.longtext: {
+                field[DBType.Mysql] = `${field.esName} longtext ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.mediumtext: {
+                field[DBType.Mysql] = `${field.esName} mediumtext ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.smallint: {
+                field[DBType.Mysql] = `${field.esName} smallint ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.text: {
+                field[DBType.Mysql] = `${field.esName} text ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.tinyint: {
+                field[DBType.Mysql] = `${field.esName} tinyint ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.varchar: {
+                field[DBType.Mysql] = `${field.esName} varchar(${config.length1 ?? 1}) ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+        }
+        ;
+        let __fields = Reflect.getMetadata(_fields, object);
+        let __columns = Reflect.getMetadata(_columns, object);
+        let __columnsNoId = Reflect.getMetadata(_columnsNoId, object);
+        let __ids = Reflect.getMetadata(_ids, object);
+        let __index = Reflect.getMetadata(_index, object);
+        let __def = Reflect.getMetadata(_def, object);
+        if (!__fields) {
+            __fields = {};
+            __columns = [];
+            __columnsNoId = [];
+            __ids = [];
+            __index = [];
+            __def = {};
+        }
+        __fields[propertyName] = field;
+        __columns.push(propertyName);
+        if (field.id === true) {
+            __ids.push(propertyName);
+        }
+        else {
+            __columnsNoId.push(propertyName);
+        }
+        if (field.index === true) {
+            __index.push(propertyName);
+        }
+        if (hasDef) {
+            __def[propertyName] = field.def;
+        }
+        Reflect.defineMetadata(_fields, __fields, object);
+        Reflect.defineMetadata(_columns, __columns, object);
+        Reflect.defineMetadata(_columnsNoId, __columnsNoId, object);
+        Reflect.defineMetadata(_ids, __ids, object);
+        Reflect.defineMetadata(_index, __index, object);
+        Reflect.defineMetadata(_def, __def, object);
+        if (field.hasOwnProperty('logicDelete')) {
+            Reflect.defineMetadata(_deleteState, field.logicDelete, object);
+            Reflect.defineMetadata(_stateFileName, propertyName, object);
+        }
+    };
+};
+export const DB = (config) => {
+    return function (constructor) {
+        var _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+        const __ids = Reflect.getMetadata(_ids, config.clz.prototype) || new Array;
+        const __fields = Reflect.getMetadata(_fields, config.clz.prototype);
+        const __columns = Reflect.getMetadata(_columns, config.clz.prototype);
+        const __columnsNoId = __columns.filter((c) => __ids.includes(c) === false);
+        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);
+        return _t = class extends constructor {
+                constructor() {
+                    super(...arguments);
+                    this[_d] = config.tableName;
+                    this[_e] = config.dbName;
+                    this[_f] = config.dbType ?? DBType.Mysql;
+                    this[_g] = config.sqliteVersion;
+                    this[_h] = Object.assign({}, _defOption, config);
+                    this[_j] = __ids;
+                    this[_k] = __fields;
+                    this[_l] = __columns;
+                    this[_m] = __columnsNoId;
+                    this[_o] = __index;
+                    this[_p] = __def;
+                    this[_q] = __stateFileName;
+                    this[_r] = __deleteState;
+                    this[_s] = (data, option) => {
+                        return Object.fromEntries(iterare(option?.skipId === true ? __columnsNoId : __columns)
+                            .map(K => [K, FieldFilter(K, data[K], __def, option)])
+                            .filter(data => {
+                            if (data[1][0] === 1) {
+                                if (option?.onFieldExists) {
+                                    option.onFieldExists(data[0], data[1][1]);
+                                }
+                                return true;
+                            }
+                            else {
+                                return false;
+                            }
+                        })
+                            .map(data => [data[0], data[1][1]])
+                            .toArray());
+                    };
+                }
+            },
+            _d = _tableName,
+            _e = _daoDBName,
+            _f = _dbType,
+            _g = _sqlite_version,
+            _h = _SqlOption,
+            _j = _ids,
+            _k = _fields,
+            _l = _columns,
+            _m = _columnsNoId,
+            _o = _index,
+            _p = _def,
+            _q = _stateFileName,
+            _r = _deleteState,
+            _s = _transformer,
+            _t;
+    };
+};
+/**
+  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.name, 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 = Sqlstring.escapeId(option.tableName);
+        switch (option?.mode) {
+            case SqlInsertMode.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 = iterare(conditions).map(c => `${this[_fields][c]?.esName} = ?`).join(' AND ');
+                const finalColumns = new Set();
+                const whereColumns = conditions;
+                const params = datas
+                    .map(data => this[_transformer](data, { ...option, finalColumns, def: true }))
+                    .flatMap(data => {
+                    const result = [];
+                    const questMark = new Array();
+                    for (const column of finalColumns) {
+                        questMark.push('?');
+                        result.push(data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null);
+                    }
+                    for (const column of whereColumns) {
+                        questMark.push('?');
+                        result.push(data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null);
+                    }
+                    return result;
+                });
+                const quests = new Array(finalColumns.size).fill('?').join(',');
+                const columnNames = iterare(finalColumns).map(i => this[_fields][i]?.esName).join(',');
+                const selects = iterare(new Array(datas.length)).map(() => `SELECT ${quests} FROM DUAL WHERE NOT EXISTS (SELECT 1 FROM ${tableName} WHERE ${where})`).join(' UNION ALL ');
+                const sql = `INSERT INTO
+                        ${tableName}
+                        (${columnNames})
+                        ${selects};`;
+                sqls.push({ sql, params });
+            }
+            case SqlInsertMode.Replace: {
+                const finalColumns = new Set();
+                const params = datas
+                    .map(data => this[_transformer](data, { ...option, finalColumns, def: true }))
+                    .flatMap(data => {
+                    const result = [];
+                    const questMark = new Array();
+                    for (const column of finalColumns) {
+                        questMark.push('?');
+                        result.push(data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null);
+                    }
+                    return result;
+                });
+                const quests = new Array(finalColumns.size).fill('?').join(',');
+                const columnNames = iterare(finalColumns).map(i => this[_fields][i]?.esName).join(',');
+                const questMarks = iterare(new Array(datas.length)).map(() => `(${quests})`).join(',');
+                const sql = `
+                    ${this[_dbType] === DBType.Mysql ? '' : 'INSERT OR'} REPLACE INTO
+                    ${tableName}
+                    (${columnNames})
+                    VALUES ${questMarks};
+                `;
+                sqls.push({ sql, params });
+            }
+            case SqlInsertMode.Insert: {
+                const finalColumns = new Set();
+                const params = datas
+                    .map(data => this[_transformer](data, { ...option, finalColumns, def: true }))
+                    .flatMap(data => {
+                    const result = [];
+                    const questMark = new Array();
+                    for (const column of finalColumns) {
+                        questMark.push('?');
+                        result.push(data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null);
+                    }
+                    return result;
+                });
+                const quests = new Array(finalColumns.size).fill('?').join(',');
+                const columnNames = iterare(finalColumns).map(i => this[_fields][i]?.esName).join(',');
+                const questMarks = iterare(new Array(datas.length)).map(() => `(${quests})`).join(',');
+                const sql = `
+                    INSERT INTO
+                    ${tableName}
+                    (${columnNames})
+                    VALUES ${questMarks};
+                `;
+                sqls.push({ sql, params });
+            }
+            case SqlInsertMode.InsertWithTempTable: {
+                const tableTemp = `${option?.tableName}_${Math.random()}`.replace(/\./, '');
+                const tableTempESC = Sqlstring.escapeId(tableTemp);
+                sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+                const finalColumns = new Set();
+                const params = datas
+                    .map(data => this[_transformer](data, { ...option, finalColumns, def: true }))
+                    .flatMap(data => {
+                    const result = [];
+                    const questMark = new Array();
+                    for (const column of finalColumns) {
+                        questMark.push('?');
+                        result.push(data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null);
+                    }
+                    return result;
+                });
+                const _sqls = this._createTable({ tableName: tableTemp, temp: true, columns: Array.from(finalColumns) });
+                sqls.push(..._sqls);
+                const quests = new Array(finalColumns.size).fill('?').join(',');
+                const columnNames = iterare(finalColumns).map(i => this[_fields][i]?.esName).join(',');
+                const questMarks = iterare(new Array(datas.length)).map(() => `(${quests})`).join(',');
+                sqls.push({
+                    sql: `
+                        INSERT INTO
+                        ${tableTemp}
+                        (${columnNames})
+                        VALUES ${questMarks};
+                    `, params
+                });
+                sqls.push({
+                    sql: `INSERT INTO ${Sqlstring.escapeId(option.tableName)} (${columnNames})
+                        SELECT ${columnNames} FROM ${tableTemp};`
+                });
+                sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+            }
+        }
+        return sqls;
+    }
+    insert(option) {
+        option.mode ?? (option.mode = SqlInsertMode.Insert);
+        const isArray = option.data instanceof Array;
+        const datas = option.data instanceof Array ? option.data : [option.data];
+        if (option.sync === SqlSyncMode.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(SqlSyncMode.Sync, sql, params);
+                        if (dd.insertId) {
+                            result += dd.insertId;
+                        }
+                    }
+                    return result;
+                }, { everyLength: option?.every === true ? 1 : option?.maxDeal });
+                if (isArray)
+                    return result;
+                else
+                    return result[0];
+            };
+            if (option?.conn?.[_inTransaction] === true) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SqlSyncMode.Sync, fn, option?.conn);
+            }
+        }
+        else if (isArray) {
+            const fn = async () => {
+                return await option?.dao?.transaction(SqlSyncMode.Async, 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(SqlSyncMode.Async, sql, params);
+                            if (dd.insertId) {
+                                result += dd.insertId;
+                            }
+                        }
+                        return result;
+                    }, { everyLength: option?.every === true ? 1 : option?.maxDeal });
+                    return result;
+                }, option?.conn);
+            };
+            return new Promise(async (resolve) => {
+                if (option?.conn?.[_inTransaction] === true) {
+                    resolve((await fn()));
+                }
+                else {
+                    await option?.dao?.transaction(SqlSyncMode.Async, async () => resolve((await 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(SqlSyncMode.Async, sql, params);
+                        if (dd.insertId) {
+                            result += dd.insertId;
+                        }
+                    }
+                    return result;
+                }, { everyLength: 1 });
+                return result[0];
+            };
+            return new Promise(async (resolve) => {
+                if (option?.conn?.[_inTransaction] === true) {
+                    resolve((await fn()));
+                }
+                else {
+                    await option?.dao?.transaction(SqlSyncMode.Async, async () => resolve((await fn())), option?.conn);
+                }
+            });
+        }
+    }
+    _update(datas, option) {
+        const sqls = [];
+        const tableName = Sqlstring.escapeId(option?.tableName);
+        const where = `WHEN ${iterare(this[_ids]).map(c => `${this[_fields][c]?.esName} = ?`).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 = `UPDATE ${tableName} SET ${iterare(this[_columnsNoId])
+            .filter(K => columnMaps[K].where.length > 0)
+            .map(K => {
+            params.push(...columnMaps[K].params);
+            return `${this[_fields][K]?.esName} = CASE ${columnMaps[K].where.join(' ')} ELSE ${this[_fields][K]?.esName} END`;
+        })
+            .join(',')};`;
+        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 (option.sync === SqlSyncMode.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(SqlSyncMode.Sync, sql, params);
+                        if (dd.affectedRows) {
+                            result += dd.affectedRows;
+                        }
+                    }
+                    return result;
+                }, { everyLength: option?.maxDeal });
+                return result.reduce((a, b) => a + b);
+            };
+            if (option?.conn?.[_inTransaction] === true) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SqlSyncMode.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(SqlSyncMode.Async, sql, params);
+                        if (dd.affectedRows) {
+                            result += dd.affectedRows;
+                        }
+                    }
+                    return result;
+                }, { everyLength: option?.maxDeal });
+                return result.reduce((a, b) => a + b);
+            };
+            return new Promise(async (resolve) => {
+                if (option?.conn?.[_inTransaction] === true) {
+                    resolve((await fn()));
+                }
+                else {
+                    await option?.dao?.transaction(SqlSyncMode.Async, async () => resolve((await fn())), option?.conn);
+                }
+            });
+        }
+    }
+    delete(option) {
+        Throw.if(!!this[_ids] && this[_ids].length > 1 && !option.where, 'muit id must set where!');
+        Throw.if((!this[_ids] || this[_ids].length === 0) && !option.where, 'if not set id on class, must set where!');
+        Throw.if(!option.id && !option.where, '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, 'id and where only one can set!');
+        option.mode ?? (option.mode = SqlDelMode.Common);
+        const tableTemp = `${option?.tableName}_${Math.random()}`.replace(/\./, '');
+        const tableTempESC = Sqlstring.escapeId(tableTemp);
+        const tableNameESC = Sqlstring.escapeId(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];
+        const sqls = [];
+        if (option.mode === SqlDelMode.Common) {
+            const params = new Array();
+            const whereSql = iterare(wheres).map(where => {
+                return `(
+                    ${Object.entries(where).map(([K, V]) => {
+                    params.push(V);
+                    return `${K} = ?`;
+                }).join(' AND ')}
+                )`;
+            }).join(' OR ');
+            if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                sqls.push({
+                    sql: `
+                    UPDATE ${tableNameESC} SET ${this[_fields][this[_stateFileName]]?.esName} = ${Sqlstring.escape(this[_deleteState])}
+                    WHERE ${whereSql};
+                `, params
+                });
+            }
+            else {
+                sqls.push({ sql: `DELETE FROM ${tableNameESC} WHERE ${whereSql};`, 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 (this[_dbType]) {
+                case DBType.Mysql: {
+                    if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                        sqls.push({
+                            sql: `UPDATE ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields][K]?.esName} = b.${this[_fields][K]?.esName}`).join(' AND ')}
+                            SET a.${this[_fields][this[_stateFileName]]?.esName} = ${Sqlstring.escape(this[_deleteState])};`
+                        });
+                    }
+                    else {
+                        sqls.push({
+                            sql: `DELETE a.* FROM ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields][K]?.esName} = b.${this[_fields][K]?.esName}`).join(' AND ')};`
+                        });
+                    }
+                }
+                case DBType.Sqlite:
+                case DBType.SqliteRemote: {
+                    const columnNames = iterare(delWhere).map(K => this[_fields][K]?.esName).join(',');
+                    if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                        sqls.push({
+                            sql: `UPDATE ${tableNameESC} SET ${this[_fields][this[_stateFileName]]?.esName} = ${Sqlstring.escape(this[_deleteState])}
+                            WHERE (${columnNames}) IN (SELECT ${columnNames} FROM ${tableTempESC});`
+                        });
+                    }
+                    else {
+                        sqls.push({ sql: `DELETE FROM ${tableNameESC} WHERE (${columnNames}) IN (SELECT ${columnNames} FROM ${tableTempESC});` });
+                    }
+                }
+            }
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+        }
+        if (option.sync === SqlSyncMode.Sync) {
+            const fn = () => {
+                let result = 0;
+                for (const { sql, params } of sqls) {
+                    const dd = option.conn.execute(SqlSyncMode.Sync, sql, params);
+                    result += dd.affectedRows;
+                }
+                return result;
+            };
+            if (option?.conn?.[_inTransaction] === true) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SqlSyncMode.Sync, fn, option?.conn);
+            }
+        }
+        else {
+            const fn = async () => {
+                let result = 0;
+                for (const { sql, params } of sqls) {
+                    const dd = await option.conn.execute(SqlSyncMode.Async, sql, params);
+                    result += dd.affectedRows;
+                }
+                return result;
+            };
+            return new Promise(async (resolve) => {
+                if (option?.conn?.[_inTransaction] === true) {
+                    resolve((await fn()));
+                }
+                else {
+                    await option?.dao?.transaction(SqlSyncMode.Async, async () => resolve((await fn())), option?.conn);
+                }
+            });
+        }
+    }
+    _select(resultMode, result, error) {
+        switch (resultMode) {
+            case SqlTemplateMode.AssertOne: {
+                Throw.if(!result || result.length !== 1, error);
+                return result[0];
+            }
+            case SqlTemplateMode.NotSureOne: {
+                Throw.if(!result, error);
+                return result[0] ?? null;
+            }
+            case SqlTemplateMode.Many: {
+                return result;
+            }
+            case SqlTemplateMode.Count: {
+                return result[0].ct;
+            }
+        }
+    }
+    template(option) {
+        Throw.if(!!this[_ids] && this[_ids].length > 1 && !option.where, 'muit id must set where!');
+        Throw.if((!this[_ids] || this[_ids].length === 0) && !option.where, 'if not set id on class, must set where!');
+        Throw.if(!option.id && !option.where, '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, 'id and where only one can set!');
+        option.mode ?? (option.mode = SqlSelectMode.Common);
+        option.resultMode ?? (option.resultMode = SqlTemplateMode.AssertOne);
+        option.error ?? (option.error = 'error data!');
+        const tableTemp = `${option?.tableName}_${Math.random()}`.replace(/\./, '');
+        const tableTempESC = Sqlstring.escapeId(tableTemp);
+        const tableNameESC = Sqlstring.escapeId(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.resultMode === SqlTemplateMode.Count ? 'COUNT(1) ct' : iterare((option.columns ?? this[_columns])).map((K) => `a.${this[_fields][K]?.esName}`).join(',');
+        const wheres = option.where instanceof Array ? option.where : [option.where];
+        const sqls = [];
+        let resultIndex = -1;
+        if (option.mode === SqlSelectMode.Common) {
+            const params = new Array();
+            const whereSql = iterare(wheres).map(where => {
+                return `SELECT ${columns} FROM ${tableNameESC} a WHERE
+                    ${Object.entries(where).map(([K, V]) => {
+                    params.push(V);
+                    return `${K} = ?`;
+                }).join(' AND ')}`;
+            }).join(' UNION ALL ');
+            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: `SELECT ${columns} FROM ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields][K]?.esName} = b.${this[_fields][K]?.esName}`).join(' AND ')};` });
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+        }
+        if (option.sync === SqlSyncMode.Sync) {
+            let result;
+            for (let i = 0; i < sqls.length; i++) {
+                if (i === resultIndex) {
+                    result = option.conn.query(SqlSyncMode.Sync, sqls[i]?.sql, sqls[i]?.params);
+                }
+                else {
+                    option.conn.execute(SqlSyncMode.Sync, sqls[i]?.sql, sqls[i]?.params);
+                }
+            }
+            return this._select(option.resultMode, result, option.error);
+        }
+        else {
+            return new Promise(async (resolve) => {
+                let result;
+                for (let i = 0; i < sqls.length; i++) {
+                    if (i === resultIndex) {
+                        result = await option.conn.query(SqlSyncMode.Async, sqls[i]?.sql, sqls[i]?.params);
+                    }
+                    else {
+                        await option.conn.execute(SqlSyncMode.Async, sqls[i]?.sql, sqls[i]?.params);
+                    }
+                }
+                resolve(this._select(option.resultMode, result, option.error));
+            });
+        }
+    }
+    _query(resultMode, result, def, errorMsg, multiple) {
+        if (multiple === true) {
+            switch (resultMode) {
+                case SqlQueryMode.One_Row_One_Column_NotSure: {
+                    try {
+                        return result.map((r) => Object.values(r)[0]);
+                    }
+                    catch (error) {
+                    }
+                }
+                case SqlQueryMode.One_Row_One_Column_Assert: {
+                    try {
+                        return iterare(result).map((r) => Object.values(r)[0]).filter((r) => r !== null).toArray();
+                    }
+                    catch (error) {
+                    }
+                }
+                case SqlQueryMode.One_Row_Many_Column_NotSure: {
+                    try {
+                        return result.map((r) => r[0]);
+                    }
+                    catch (error) {
+                    }
+                }
+                case SqlQueryMode.One_Row_Many_Column_Assert: {
+                    try {
+                        return iterare(result).map((r) => r[0]).filter((r) => r !== null).toArray();
+                    }
+                    catch (error) {
+                    }
+                }
+                case SqlQueryMode.Many_Row_One_Column: {
+                    try {
+                        return result.map((rx) => rx.map((r) => Object.values(r)[0]));
+                    }
+                    catch (error) {
+                    }
+                }
+                case SqlQueryMode.Many_Row_Many_Column: {
+                    return result;
+                }
+            }
+        }
+        else {
+            switch (resultMode) {
+                case SqlQueryMode.One_Row_One_Column_NotSure: {
+                    try {
+                        return Object.values(result[0])[0];
+                    }
+                    catch (error) {
+                        return def;
+                    }
+                }
+                case SqlQueryMode.One_Row_One_Column_Assert: {
+                    try {
+                        return Object.values(result[0])[0];
+                    }
+                    catch (error) {
+                        if (def !== undefined)
+                            return def;
+                        Throw.now(errorMsg ?? 'not found data!');
+                    }
+                }
+                case SqlQueryMode.One_Row_Many_Column_NotSure: {
+                    return result[0] ?? null;
+                }
+                case SqlQueryMode.One_Row_Many_Column_Assert: {
+                    const data = result[0];
+                    Throw.if(data === null, errorMsg ?? 'not found data!');
+                    return data ?? null;
+                }
+                case SqlQueryMode.Many_Row_One_Column: {
+                    try {
+                        return result.map((r) => Object.values(r)[0]);
+                    }
+                    catch (error) {
+                        return def;
+                    }
+                }
+                case SqlQueryMode.Many_Row_Many_Column: {
+                    return result;
+                }
+            }
+        }
+    }
+    select(option) {
+        Throw.if(!option.sqlId && !option.sql, 'not found sql!');
+        option.resultMode ?? (option.resultMode = SqlQueryMode.Many_Row_Many_Column);
+        option.sql ?? (option.sql = globalThis[_sqlCache].load(option.sqlId, option.context, option.isPage));
+        option.defValue ?? (option.defValue = null);
+        logger.debug(option.sql);
+        const _params = Object.assign({}, option.context, option.params);
+        const params = [];
+        const sql = option.sql?.replace(/\:(\w+)/g, (txt, key) => {
+            if (_params.hasOwnProperty(key)) {
+                const V = _params[key];
+                params.push(V);
+                return Sqlstring.escape(_params[key]);
+            }
+            return txt;
+        });
+        if (option.sync === SqlSyncMode.Sync) {
+            const result = option.conn.query(SqlSyncMode.Sync, sql, params);
+            return this._query(option.resultMode, result, option.defValue, option.errorMsg, option.multiple);
+        }
+        else {
+            return new Promise(async (resolve) => {
+                const result = await option.conn.query(SqlSyncMode.Async, sql, params);
+                resolve(this._query(option.resultMode, result, option.defValue, option.errorMsg, option.multiple));
+            });
+        }
+    }
+    excute(option) {
+        Throw.if(!option.sqlId && !option.sql, 'not found sql!');
+        option.sql ?? (option.sql = globalThis[_sqlCache].load(option.sqlId, option.context));
+        logger.debug(option.sql);
+        const _params = Object.assign({}, option.context, option.params);
+        const params = [];
+        const sql = option.sql?.replace(/\:(\w+)/g, (txt, key) => {
+            if (_params.hasOwnProperty(key)) {
+                const V = _params[key];
+                params.push(V);
+                return Sqlstring.escape(_params[key]);
+            }
+            return txt;
+        });
+        if (option.sync === SqlSyncMode.Sync) {
+            const result = option.conn.execute(SqlSyncMode.Sync, sql, params);
+            return result.affectedRows;
+        }
+        else {
+            return new Promise(async (resolve) => {
+                const result = await option.conn.execute(SqlSyncMode.Async, sql, params);
+                resolve(result.affectedRows);
+            });
+        }
+    }
+    transaction(option) {
+        if (option.sync === SqlSyncMode.Sync) {
+            return option.dao.transaction(SqlSyncMode.Sync, option.fn);
+        }
+        else {
+            return new Promise(async (resolve) => {
+                const rt = await option.dao.transaction(SqlSyncMode.Async, option.fn);
+                resolve(rt);
+            });
+        }
+    }
+    stream(option) {
+        return new StreamQuery(option?.tableName ?? this[_tableName], this);
+    }
+    /**
+    #创建表
+    ** `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' } = {}) {
+        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 = Sqlstring.escapeId(tableName ?? this[_tableName]);
+        switch (this[_dbType]) {
+            case DBType.Mysql: {
+                let sql = `CREATE ${temp === true ? '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]?.esName).join(',')})  USING BTREE ` : ''}
+                    ${indexs && indexs.length ? `,${indexs.map(i => `KEY ${this[_fields][i]?.esName} (${this[_fields][i]?.esName})`).join(',')} ` : ''}
+                ) ENGINE=MEMORY;`;
+                sqls.push({ sql });
+                if (data && data.length > 0) {
+                    const params = [];
+                    let first = true;
+                    sql = `INSERT INTO ${tableName} (${columns.map(c => Sqlstring.escapeId(c)).join(',')})
+                    ${(data).map(d => {
+                        const r = `SELECT ${Object.entries(d).map(([K, V]) => {
+                            params.push(V);
+                            return `? ${first ? this[_fields][K]?.esName : ''}`;
+                        }).join(',')}`;
+                        first = false;
+                        return r;
+                    }).join(' UNION ALL ')}`;
+                    sqls.push({ sql, params });
+                }
+                break;
+            }
+            case DBType.Sqlite:
+            case DBType.SqliteRemote: {
+                let sql = `CREATE ${temp === true ? '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]?.esName).join(',')}) ` : ''}
+                );`;
+                sqls.push({ sql });
+                if (indexs) {
+                    for (const index of indexs) {
+                        sql = `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableName} (${this[_fields][index]?.esName});`;
+                        sqls.push({ sql });
+                    }
+                }
+                if (data && data.length > 0) {
+                    const params = [];
+                    let first = true;
+                    sql = `INSERT INTO ${tableName} (${columns.map(c => Sqlstring.escapeId(c)).join(',')})
+                    ${(data).map(d => {
+                        const r = `SELECT ${Object.entries(d).map(([K, V]) => {
+                            params.push(V);
+                            return `? ${first ? this[_fields][K]?.esName : ''}`;
+                        }).join(',')}`;
+                        first = false;
+                        return r;
+                    }).join(' UNION ALL ')}`;
+                    sqls.push({ sql, params });
+                }
+            }
+        }
+        return sqls;
+    }
+}
+__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, "excute", null);
+__decorate([
+    P(true),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "transaction", null);
+/** 是否进行下一个动作 */
+const IF_PROCEED = function () {
+    return function (_target, _propertyKey, descriptor) {
+        const fn = descriptor.value;
+        descriptor.value = function () {
+            if (this.if_proceed === true) {
+                // eslint-disable-next-line prefer-rest-params
+                const args = Array.from(arguments);
+                fn.call(this, ...args);
+            }
+            else {
+                this.if_proceed = true;
+            }
+            return this;
+        };
+    };
+};
+/*** 是否执行最终查询/操作*/
+const IF_EXEC = function (def) {
+    return function (_target, _propertyKey, descriptor) {
+        const fn = descriptor.value;
+        descriptor.value = async function () {
+            if (this.if_proceed === true && this.if_exec === true) {
+                // eslint-disable-next-line prefer-rest-params
+                const args = Array.from(arguments);
+                return await fn.call(this, ...args);
+            }
+            else {
+                return def;
+            }
+        };
+    };
+};
+class StreamCondition {
+    constructor() {
+        this._prefix = 0;
+        this._index = 0;
+        this._wheres = [];
+        this._andQuerys = [];
+        this._orQuerys = [];
+        this._paramKeys = {};
+        this._param = {};
+        this.if_proceed = true;
+        this.if_exec = true;
+        this._prefix = parseInt(`${Math.random() * 1000}`);
+    }
+    /** 将当前stream重置 */
+    reset() {
+        this._index = 0;
+        this._wheres.length = 0;
+        this._param = {};
+        this._paramKeys = {};
+        return this;
+    }
+    /** 为下次链条执行提供条件判断：非异步方法跳过，异步方法不执行并返回默认值 */
+    if(condition) {
+        this.if_proceed = condition;
+        return this;
+    }
+    eq(key, value, { name } = {}) { return this._(key, value, '=', { name }); }
+    eqT(t, { name } = {}) {
+        if (name && this._paramKeys[name]) {
+            for (const [key, pname] of Object.entries(this._paramKeys[name])) {
+                this._param[pname] = t[key];
+            }
+        }
+        else {
+            const paramKeys = {};
+            for (const [key, value] of Object.entries(t)) {
+                const pkey = `p${this._prefix}${this._index++}`;
+                this._wheres.push(`AND ${String(key)} = :${pkey} `);
+                this._param[pkey] = value;
+                if (name) {
+                    paramKeys[key] = pkey;
+                }
+            }
+            if (name) {
+                this._paramKeys[name] = paramKeys;
+            }
+        }
+        return this;
+    }
+    notEq(key, value, { name } = {}) { return this._(key, value, '<>', { name }); }
+    eqWith(key1, key2) { return this._key(key1, key2, '='); }
+    notEqWith(key1, key2) { return this._key(key1, key2, '<>'); }
+    regexp(key, regexp, { name } = {}) { return this._(key, regexp, 'REGEXP', { name }); }
+    notRegexp(key, regexp, { name } = {}) { return this._(key, regexp, 'REGEXP', { name, not: 'NOT' }); }
+    /** (key1 << 8) + key2 = value */
+    shiftEq(key1, key2, value, { name } = {}) { return this._shift(key1, key2, value, '=', { name }); }
+    /** (key1 << 8) + key2 <> value */
+    shiftNotEq(key1, key2, value, { name } = {}) { return this._shift(key1, key2, value, '<>', { name }); }
+    grate(key, value, { name } = {}) { return this._(key, value, '>', { name }); }
+    grateEq(key, value, { name } = {}) { return this._(key, value, '>=', { name }); }
+    grateWith(key1, key2) { return this._key(key1, key2, '>'); }
+    grateEqWith(key1, key2) { return this._key(key1, key2, '>='); }
+    less(key, value, { name } = {}) { return this._(key, value, '<', { name }); }
+    lessEq(key, value, { name } = {}) { return this._(key, value, '<=', { name }); }
+    lessWith(key1, key2) { return this._key(key1, key2, '<'); }
+    lessEqWith(key1, key2) { return this._key(key1, key2, '<='); }
+    like(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', right: '%', force }); }
+    notLike(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', right: '%', not: 'NOT', force }); }
+    leftLike(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', force }); }
+    notLeftLike(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', not: 'NOT', force }); }
+    rightLike(key, value, { name, force } = {}) { return this._like(key, value, { name, right: '%', force }); }
+    notRightLike(key, value, { name, force } = {}) { return this._like(key, value, { name, right: '%', not: 'NOT', force }); }
+    PreciseLike(key, value, { name, force } = {}) { return this._like(key, value, { name, force }); }
+    notPreciseLike(key, value, { name, force } = {}) { return this._like(key, value, { name, not: 'NOT', force }); }
+    glob(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', right: '%', force, op: 'glob' }); }
+    notGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', right: '%', not: 'NOT', force, op: 'glob' }); }
+    leftGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', force, op: 'glob' }); }
+    notLeftGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', not: 'NOT', force, op: 'glob' }); }
+    rightGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, right: '%', force, op: 'glob' }); }
+    notRightGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, right: '%', not: 'NOT', force, op: 'glob' }); }
+    PreciseGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, force, op: 'glob' }); }
+    notPreciseGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, not: 'NOT', force, op: 'glob' }); }
+    in(key, value, { name, force } = {}) { return this._in(key, value, { name, force }); }
+    notIn(key, value, { name, force } = {}) { return this._in(key, value, { name, not: 'NOT', force }); }
+    isNULL(key) { return this._null(key); }
+    isNotNULL(key) { return this._null(key, 'NOT'); }
+    between(key, value1, value2, { name } = {}) { return this._between(key, value1, value2, { name }); }
+    notBetween(key, value1, value2, { name } = {}) { return this._between(key, value1, value2, { name, not: 'NOT' }); }
+    pow(key, value, { name } = {}) { return this._pow(key, value, { name }); }
+    notPow(key, value, { name } = {}) { return this._pow(key, value, { name, not: 'NOT' }); }
+    powWith(key, values, { name } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { name }); }
+    notPowWith(key, values, { name } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { name, not: 'NOT' }); }
+    /** MATCH(key1, key2, key3) AGAINST (value) */
+    match(value, keys, { name } = {}) { return this._match(value, keys, { name }); }
+    /** NOT MATCH(key1, key2, key3) AGAINST (value) */
+    notMatch(value, keys, { name } = {}) { return this._match(value, keys, { name, not: 'NOT' }); }
+    /** MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE*/
+    matchBoolean(value, keys, { name } = {}) { return this._match(value, keys, { name, append: 'IN BOOLEAN MODE' }); }
+    /** NOT MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE */
+    notMatchBoolean(value, keys, { name } = {}) { return this._match(value, keys, { name, not: 'NOT', append: 'IN BOOLEAN MODE' }); }
+    /** MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
+    matchQuery(value, keys, { name } = {}) { return this._match(value, keys, { name, append: 'WITH QUERY EXPANSION' }); }
+    /** NOT MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
+    notMatchQuery(value, keys, { name } = {}) { return this._match(value, keys, { name, not: 'NOT', append: 'WITH QUERY EXPANSION' }); }
+    includes(key, value, { name } = {}) { return this._includes(key, value, { name }); }
+    notIncludes(key, value, { name } = {}) { return this._includes(key, value, { name, not: 'NOT' }); }
+    and(fn) { const stream = new StreamCondition(); const ret = fn(stream); if (ret !== false) {
+        this._andQuerys.push(stream);
+    } return this; }
+    or(fn) { const stream = new StreamCondition(); const ret = fn(stream); if (ret !== false) {
+        this._orQuerys.push(stream);
+    } return this; }
+    where() {
+        const wheres = new Array();
+        const sql = this._wheres.join(' ');
+        if (sql) {
+            wheres.push(`(${sql})`);
+        }
+        if (this._orQuerys.length > 0) {
+            for (const query of this._orQuerys) {
+                const { where, params } = query.where();
+                if (where) {
+                    wheres.push(` OR (${where}) `);
+                }
+                Object.assign(this._param, params);
+            }
+        }
+        if (this._andQuerys.length > 0) {
+            for (const query of this._andQuerys) {
+                const { where, params } = query.where();
+                if (where) {
+                    wheres.push(` AND (${where}) `);
+                }
+                Object.assign(this._param, params);
+            }
+        }
+        return { where: wheres.join(' '), params: this._param };
+    }
+    _(key, value, op, { not = '', name = '' } = {}) {
+        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+            this._param[this._paramKeys[name]] = value;
+        }
+        else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND ${String(key)} ${not} ${op} :${pkey} `);
+            this._param[pkey] = value;
+            if (name) {
+                this._paramKeys[name] = pkey;
+            }
+        }
+        return this;
+    }
+    _null(key, not = '') {
+        this._wheres.push(`AND ${String(key)} is ${not} null`);
+        return this;
+    }
+    _key(key1, key2, op, not = '') {
+        this._wheres.push(`AND ${String(key1)} ${not} ${op} ${String(key2)} `);
+        return this;
+    }
+    _between(key, value1, value2, { not = '', name = '' } = {}) {
+        if (name && this._paramKeys[name]) {
+            this._param[this._paramKeys[name][0]] = value1;
+            this._param[this._paramKeys[name][1]] = value2;
+        }
+        else {
+            const [pkey1, pkey2] = [`p${this._prefix}${this._index++}`, `p${this._prefix}${this._index++}`];
+            this._wheres.push(`AND ${String(key)} ${not} BETWEEN :${pkey1} AND :${pkey2}`);
+            this._param[pkey1] = value1;
+            this._param[pkey2] = value2;
+            if (name) {
+                this._paramKeys[name] = [pkey1, pkey2];
+            }
+        }
+        return this;
+    }
+    _in(key, value, { not = '', name = '', force = false } = {}) {
+        if (value && value.length > 0) {
+            if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+                this._param[this._paramKeys[name]] = value;
+            }
+            else {
+                const pkey = `p${this._prefix}${this._index++}`;
+                this._wheres.push(`AND ${String(key)} ${not} IN (:${pkey}) `);
+                this._param[pkey] = value;
+                if (name) {
+                    this._paramKeys[name] = pkey;
+                }
+            }
+        }
+        else if (force !== true) {
+            this.if_exec = false;
+        }
+        return this;
+    }
+    _shift(key1, key2, value, op, { not = '', name = '' } = {}) {
+        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+            this._param[this._paramKeys[name]] = value;
+        }
+        else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND (${String(key1)} << 8) + ${String(key2)} ${not} ${op} :${pkey} `);
+            this._param[pkey] = value;
+            if (name) {
+                this._paramKeys[name] = pkey;
+            }
+        }
+        return this;
+    }
+    _match(value, keys, { name, not, append } = {}) {
+        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+            this._param[this._paramKeys[name]] = value;
+        }
+        else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND MATCH(${keys.join(',')}) AGAINST (:${pkey} ${append ?? ''})`);
+            this._param[pkey] = value;
+            if (name) {
+                this._paramKeys[name] = pkey;
+            }
+        }
+        return this;
+    }
+    _pow(key, value, { name } = {}) {
+        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+            this._param[this._paramKeys[name]] = value;
+        }
+        else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND NOT POW(2, ${String(key)}) & :${pkey}`);
+            this._param[pkey] = value;
+            if (name) {
+                this._paramKeys[name] = pkey;
+            }
+        }
+        return this;
+    }
+    _like(key, value, { not = '', left = '', right = '', name = '', op = 'LIKE', force = false } = {}) {
+        if (value !== null && value !== undefined && value !== '') {
+            if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+                this._param[this._paramKeys[name]] = value;
+            }
+            else {
+                const pkey = `p${this._prefix}${this._index++}`;
+                this._wheres.push(`AND ${String(key)} ${not} ${op} CONCAT('${left}', :${pkey}, '${right}') `);
+                this._param[pkey] = value;
+                if (name) {
+                    this._paramKeys[name] = pkey;
+                }
+            }
+        }
+        else if (force !== true) {
+            this.if_exec = false;
+        }
+        return this;
+    }
+    _includes(key, value, { not = '', name = '' } = {}) {
+        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+            this._param[this._paramKeys[name]] = value;
+        }
+        else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND LOCATE(${String(key)}, :${pkey}) ${not ? '=' : ''}  0`);
+            this._param[pkey] = value;
+            if (name) {
+                this._paramKeys[name] = pkey;
+            }
+        }
+        return this;
+    }
+}
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Boolean]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "if", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "eq", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "eqT", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notEq", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "eqWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notEqWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "regexp", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notRegexp", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Number, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "shiftEq", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Number, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "shiftNotEq", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "grate", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "grateEq", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "grateWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "grateEqWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "less", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "lessEq", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "lessWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "lessEqWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "like", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "leftLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notLeftLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "rightLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notRightLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "PreciseLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notPreciseLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "glob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "leftGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notLeftGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "rightGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notRightGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "PreciseGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notPreciseGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "in", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notIn", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "isNULL", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "isNotNULL", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "between", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notBetween", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "pow", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notPow", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "powWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notPowWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "match", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notMatch", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "matchBoolean", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notMatchBoolean", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "matchQuery", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notMatchQuery", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "includes", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "notIncludes", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "and", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function]),
+    __metadata("design:returntype", void 0)
+], StreamCondition.prototype, "or", null);
+class StreamBuild extends StreamCondition {
+    constructor(table) {
+        super();
+        this._distinct = false;
+        this._columns = [];
+        this._updateColumns = [];
+        this._groups = [];
+        this._orders = [];
+        this._startRow = 0;
+        this._pageSize = 0;
+        this._table = table;
+    }
+    /** 将当前stream重置 */
+    reset() {
+        super.reset();
+        this._pageSize = 0;
+        this._startRow = 0;
+        this._orders.length = 0;
+        this._groups.length = 0;
+        this._columns.length = 0;
+        this._updateColumns.length = 0;
+        return this;
+    }
+    groupBy(key) { this._groups.push(key); return this; }
+    asc(...keys) { this._orders.push(...keys.map(key => `${String(key)} ASC`)); return this; }
+    desc(...keys) { this._orders.push(...keys.map(key => `${String(key)} DESC`)); return this; }
+    limit(startRow, pageSize) { this._startRow = startRow; this._pageSize = pageSize; return this; }
+    page(pageNumber, pageSize) { this._startRow = ((pageNumber || 1) - 1) * pageSize; this._pageSize = pageSize; return this; }
+    table(_table) { this._table = _table; return this; }
+    distinct(on = true) { this._distinct = on; return this; }
+    count(key, countName, distinct) { this._columns.push(`COUNT(${distinct ? 'DISTINCT' : ''} ${String(key)}) ${countName || `${String(key)}`}`); return this; }
+    sum(key, legName, distinct) { this._columns.push(`SUM(${distinct ? 'DISTINCT' : ''} ${String(key)}) ${legName || `${String(key)}`}`); return this; }
+    avg(key, legName, distinct) { this._columns.push(`AVG(${distinct ? 'DISTINCT' : ''} ${String(key)}) ${legName || `${String(key)}`}`); return this; }
+    max(key, legName, distinct) { this._columns.push(`MAX(${distinct ? 'DISTINCT' : ''} ${String(key)}) ${legName || `${String(key)}`}`); return this; }
+    min(key, legName, distinct) { this._columns.push(`MIN(${distinct ? 'DISTINCT' : ''} ${String(key)}) ${legName || `${String(key)}`}`); return this; }
+    groupConcat(key, param) {
+        this._columns.push(`GROUP_CONCAT(
+            ${param && param.distinct ? 'DISTINCT' : ''} ${String(key)}
+            ${param && param.asc && param.asc.length > 0 ? `ORDER BY ${param.asc.map(i => `${String(i)} ASC`)} ` : ''}
+            ${param && param.desc && param.desc.length > 0 ? `${param && param.asc && param.asc.length > 0 ? '' : 'ORDER BY'} ${param.desc.map(i => `${String(i)} DESC`)} ` : ''}
+            SEPARATOR '${param && param.separator || ','}'
+            ) ${param && param.groupName || `${String(key)}`}`);
+        return this;
+    }
+    selectColumn(...key) { this._columns.push(...(key.map(k => k))); return this; }
+    updateColumn(key, value) { this._updates ?? (this._updates = {}); this._updates[key] = value; return this; }
+    updateT(t) { this._updates ?? (this._updates = {}); Object.assign(this._updates, t); return this; }
+    replace(key, valueToFind, valueToReplace) {
+        const [pkey1, pkey2] = [`p${this._prefix}${this._index++}`, `p${this._prefix}${this._index++}`];
+        this._updateColumns.push(` ${String(key)} = REPLACE(${String(key)}, :${pkey1}, :${pkey2}) `);
+        this._param[pkey1] = valueToFind;
+        this._param[pkey2] = valueToReplace;
+        return this;
+    }
+}
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "groupBy", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "asc", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "desc", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Number]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "limit", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Number]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "page", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "table", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "distinct", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Boolean]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "count", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Boolean]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "sum", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Boolean]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "avg", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Boolean]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "max", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Boolean]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "min", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Object)
+], StreamBuild.prototype, "groupConcat", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "selectColumn", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "updateColumn", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "updateT", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamBuild.prototype, "replace", null);
+class StreamQuery extends StreamBuild {
+    constructor(table, service) {
+        super(table);
+        this._service = service;
+    }
+    select(option) {
+        option.sync ?? (option.sync = SqlSyncMode.Async);
+        const { where, params } = this.where();
+        const sql = `
+            SELECT
+            ${this._columns && this._columns.length > 0 ? this._columns.join(',') : '*'}
+            FROM ${this._table}
+            ${where ? ' WHERE ' : ''}
+            ${where}`;
+        if (option.sync === SqlSyncMode.Async) {
+            switch (option.resultMode) {
+                case SqlQueryMode.Many_Row_Many_Column: return this._service.select({ sync: SqlSyncMode.Async, resultMode: SqlQueryMode.Many_Row_Many_Column, errorMsg: option.errorMsg, sql, params });
+                case SqlQueryMode.Many_Row_One_Column: return this._service.select({ sync: SqlSyncMode.Async, resultMode: SqlQueryMode.Many_Row_One_Column, errorMsg: option.errorMsg, sql, params });
+                case SqlQueryMode.One_Row_Many_Column_Assert: return this._service.select({ sync: SqlSyncMode.Async, resultMode: SqlQueryMode.One_Row_Many_Column_Assert, errorMsg: option.errorMsg, sql, params });
+                case SqlQueryMode.One_Row_One_Column_Assert: return this._service.select({ sync: SqlSyncMode.Async, resultMode: SqlQueryMode.One_Row_One_Column_Assert, errorMsg: option.errorMsg, sql, params });
+                case SqlQueryMode.One_Row_Many_Column_NotSure: return this._service.select({ sync: SqlSyncMode.Async, resultMode: SqlQueryMode.One_Row_Many_Column_NotSure, errorMsg: option.errorMsg, sql, params });
+                case SqlQueryMode.One_Row_One_Column_NotSure: return this._service.select({ sync: SqlSyncMode.Async, resultMode: SqlQueryMode.One_Row_One_Column_NotSure, errorMsg: option.errorMsg, sql, params });
+            }
+        }
+        else {
+            switch (option.resultMode) {
+                case SqlQueryMode.Many_Row_Many_Column: return this._service.select({ sync: SqlSyncMode.Sync, resultMode: SqlQueryMode.Many_Row_Many_Column, errorMsg: option.errorMsg, sql, params });
+                case SqlQueryMode.Many_Row_One_Column: return this._service.select({ sync: SqlSyncMode.Sync, resultMode: SqlQueryMode.Many_Row_One_Column, errorMsg: option.errorMsg, sql, params });
+                case SqlQueryMode.One_Row_Many_Column_Assert: return this._service.select({ sync: SqlSyncMode.Sync, resultMode: SqlQueryMode.One_Row_Many_Column_Assert, errorMsg: option.errorMsg, sql, params });
+                case SqlQueryMode.One_Row_One_Column_Assert: return this._service.select({ sync: SqlSyncMode.Sync, resultMode: SqlQueryMode.One_Row_One_Column_Assert, errorMsg: option.errorMsg, sql, params });
+                case SqlQueryMode.One_Row_Many_Column_NotSure: return this._service.select({ sync: SqlSyncMode.Sync, resultMode: SqlQueryMode.One_Row_Many_Column_NotSure, errorMsg: option.errorMsg, sql, params });
+                case SqlQueryMode.One_Row_One_Column_NotSure: return this._service.select({ sync: SqlSyncMode.Sync, resultMode: SqlQueryMode.One_Row_One_Column_NotSure, errorMsg: option.errorMsg, sql, params });
+            }
+        }
+    }
+    update(option) {
+        option.sync ?? (option.sync = SqlSyncMode.Async);
+        const { where, params } = this.where();
+        const sets = new Array(...this._updateColumns);
+        if (this._updates) {
+            for (const [K, V] of Object.entries(this._updates)) {
+                const pkey = `p${this._prefix}${this._index++}`;
+                sets.push(` ${K} = :${pkey} `);
+                params[pkey] = V;
+            }
+        }
+        if (sets.length > 0) {
+            const sql = `UPDATE ${this._table} SET ${sets.join(',')} ${where}`;
+            if (option.sync === SqlSyncMode.Async) {
+                return this._service.excute({ sync: SqlSyncMode.Async, sql, params });
+            }
+            else {
+                return this._service.excute({ sync: SqlSyncMode.Sync, sql, params });
+            }
+        }
+        else {
+            return 0;
+        }
+    }
+    delete(option) {
+        option.sync ?? (option.sync = SqlSyncMode.Async);
+        const { where, params } = this.where();
+        const sql = `DELETE FROM ${this._table} ${where}`;
+        if (option.sync === SqlSyncMode.Async) {
+            return this._service.excute({ sync: SqlSyncMode.Async, sql, params });
+        }
+        else {
+            return this._service.excute({ sync: SqlSyncMode.Sync, sql, params });
+        }
+    }
+}
+__decorate([
+    IF_EXEC(null),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], StreamQuery.prototype, "select", null);
+__decorate([
+    IF_EXEC(0),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], StreamQuery.prototype, "update", null);
+__decorate([
+    IF_EXEC(0),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], StreamQuery.prototype, "delete", null);
+/**
+ 获取REDIS客户端，
+ # [查看库的API](https://github.com/redis/ioredis?tab=readme-ov-file)
+ # [REDIS API](http://doc.redisfans.com/)
+ REDIS 的API 可以直接用，将方法名转为小写
+ */
+export function getRedisDB(db) {
+    const rd = globalThis[_dao][DBType.Redis][db ?? _primaryDB];
+    Throw.if(!rd, 'not found redis!');
+    return rd;
+}
+/**
+ redlock
+ */
+export async function GetRedisLock(key, lockMaxActive) {
+    const lock = globalThis[_dao][DBType.RedisLock];
+    Throw.if(!lock, 'not found lock!');
+    const db = getRedisDB();
+    let initLock;
+    try {
+        initLock = await lock.acquire([`[lockex]${key}`], 5000);
+        const count = await db.get(key);
+        if (count === null || parseInt(count) < (lockMaxActive ?? 1)) {
+            await db.incr(key);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    catch (er) {
+        return await GetRedisLock(key, lockMaxActive);
+    }
+    finally {
+        if (initLock) {
+            try {
+                await initLock.release();
+                // eslint-disable-next-line no-empty
+            }
+            catch (error) {
+            }
+        }
+    }
+}
+;
+export async function excuteWithLock(config, fn__) {
+    const key = `[lock]${typeof config.key === 'function' ? config.key() : config.key}`;
+    const db = getRedisDB();
+    let wait_time = 0;
+    const fn = async () => {
+        const lock = await GetRedisLock(key, config.lockMaxActive);
+        if (lock === false) {
+            if (config.lockWait !== false && ((config.lockMaxWaitTime ?? 0) === 0 || (wait_time + (config.lockRetryInterval ?? 100)) <= (config.lockMaxWaitTime ?? 0))) {
+                logger.debug(`get lock ${key} fail, retry after ${config.lockRetryInterval ?? 100}ms...`);
+                await sleep(config.lockRetryInterval ?? 100);
+                wait_time += (config.lockRetryInterval ?? 100);
+                return await fn();
+            }
+            else {
+                logger.debug(`get lock ${key} fail`);
+                throw new Error(config.errorMessage || `get lock fail: ${key}`);
+            }
+        }
+        else {
+            logger.debug(`get lock ${key} ok!`);
+            await db.get('other').pexpire(key, config.lockMaxTime ?? 60000);
+            try {
+                return await fn__();
+            }
+            finally {
+                logger.debug(`unlock ${key} ok!`);
+                await db.get('other').decr(key);
+            }
+        }
+    };
+    return await fn();
+}
+/** 与缓存共用时，需要在缓存之前:有缓存则返回缓存,否则加锁执行并缓存,后续队列全部返回缓存,跳过执行 */
+export function MethodLock(config) {
+    return function (target, _propertyKey, descriptor) {
+        const fn__ = descriptor.value;
+        descriptor.value = async function (...args) {
+            config.key = typeof config.key === 'function' ? config.key.call(target, ...args) : config.key;
+            return await excuteWithLock(config, async () => await fn__.call(this, ...args));
+        };
+    };
+}
+async function setMethodCache(config, devid) {
+    const db = getRedisDB();
+    if (config.result !== null && config.result !== undefined) {
+        // 映射关系存放
+        if (config.clearKey && config.clearKey.length > 0) {
+            for (const clear of config.clearKey) {
+                await db.sadd(`[cache-parent]${clear}`, config.key);
+                await db.sadd(`[cache-child]${config.key}`, clear);
+            }
+        }
+        if (config.autoClearTime) { // 自动清空
+            await db.set(`[cache]${config.key}`, JSON.stringify(config.result), 'EX', config.autoClearTime * 60);
+            // 订阅：清空 clear list
+            if (config.clearKey && config.clearKey.length > 0) {
+                globalThis[_EventBus].on(`[cache]${config.key}`, async (key) => {
+                    await clearChild(key, true);
+                });
+            }
+        }
+        else {
+            await db.set(`[cache]${config.key}`, JSON.stringify(config.result));
+        }
+        if (devid) {
+            // 订阅：清空 clear list
+            globalThis[_EventBus].on(`user-${devid}`, async function (key) {
+                await clearChild(key);
+            });
+        }
+    }
+}
+export async function clearMethodCache(key) {
+    const db = getRedisDB();
+    let type = await db.type(`[cache-parent]${key}`);
+    if (type === 'set') {
+        await clearParent(key);
+    }
+    type = await db.type(`[cache]${key}`);
+    if (type !== 'none') {
+        await clearChild(key);
+    }
+}
+async function clearChild(key, skipDel = false) {
+    const db = getRedisDB();
+    if (skipDel === false) {
+        await db.del(`[cache]${key}`);
+    }
+    const childtype = await db.type(`[cache-child]${key}`);
+    if (childtype === 'set') {
+        const parentKeys = await db.smembers(`[cache-child]${key}`);
+        for (const clear of parentKeys) {
+            const type = await db.type(`[cache-parent]${clear}`);
+            if (type === 'set') {
+                await db.srem(`[cache-parent]${clear}`, key);
+            }
+        }
+        await db.del(`[cache-child]${key}`);
+    }
+}
+async function clearParent(clearKey) {
+    const db = getRedisDB();
+    const keys = await db.smembers(`[cache-parent]${clearKey}`);
+    if (keys) {
+        for (const key of keys) {
+            logger.debug(`cache ${key} cleared!`);
+            await clearChild(key);
+        }
+    }
+}
+export async function excuteWithCache(config, fn) {
+    const db = getRedisDB();
+    const cache = await db.get(`[cache]${config.key}`);
+    if (cache) {
+        logger.debug(`cache ${config.key} hit!`);
+        return JSON.parse(cache);
+    }
+    else {
+        logger.debug(`cache ${config.key} miss!`);
+        const result = await fn();
+        await setMethodCache({
+            key: config.key,
+            clearKey: config.clearKey,
+            autoClearTime: config.autoClearTime,
+            result
+        });
+        return result;
+    }
+}
+export function MethodCache(config) {
+    return function (target, _propertyKey, descriptor) {
+        const fn = descriptor.value;
+        descriptor.value = async function (...args) {
+            const key = typeof config.key === 'function' ? config.key.call(this, ...args) : config.key;
+            const db = getRedisDB();
+            const cache = await db.get('other').get(`[cache]${key}`);
+            if (cache) {
+                logger.debug(`cache ${key} hit!`);
+                return JSON.parse(cache);
+            }
+            else {
+                logger.debug(`cache ${key} miss!`);
+                const result = await fn.call(this, ...args);
+                const clearKey = config.clearKey ? typeof config.clearKey === 'function' ? config.clearKey.call(this, ...args) : config.clearKey : undefined;
+                await setMethodCache({
+                    key,
+                    clearKey,
+                    autoClearTime: config.autoClearTime,
+                    result
+                }, config.clearWithSession && this.ctx.me && this.ctx.me.devid);
+                return result;
+            }
+        };
+    };
+}
+export const LetsGo = async function (options) {
+    globalThis[_GlobalSqlOption] = Object.assign({}, _defOption, options);
+    if (options.sqlDir) {
+        globalThis[_path] = import('path');
+        globalThis[_fs] = import('fs');
+    }
+    logger.level = options.log ?? 'info';
+    globalThis[_sqlCache] = new SqlCache();
+    if (options.sqlCache || options.sqlDir) {
+        await globalThis[_sqlCache].init(options);
+    }
+    globalThis[_dao] = {
+        [DBType.Mongo]: {},
+        [DBType.Mysql]: {},
+        [DBType.Sqlite]: {},
+        [DBType.SqliteRemote]: {},
+        [DBType.Redis]: {}
+    };
+    if (options.Mysql) {
+        const { createPool } = await import('mysql2/promise');
+        if (options.Mysql['host']) {
+            globalThis[_dao][DBType.Mysql][_primaryDB] = new Mysql(createPool({
+                ...options.Mysql,
+                multipleStatements: true,
+                decimalNumbers: true,
+                supportBigNumbers: true
+            }));
+        }
+        else {
+            let flag = false;
+            for (const [key, option] of Object.entries(options.Mysql)) {
+                const db = new Mysql(createPool({
+                    ...option,
+                    multipleStatements: true,
+                    decimalNumbers: true,
+                    supportBigNumbers: true
+                }));
+                if (flag === false) {
+                    globalThis[_dao][DBType.Mysql][_primaryDB] = db;
+                    flag = true;
+                }
+                globalThis[_dao][DBType.Mysql][key] = db;
+            }
+        }
+    }
+    if (options.Sqlite) {
+        const BetterSqlite3 = await import('better-sqlite3');
+        if (typeof options.Sqlite === 'string') {
+            globalThis[_dao][DBType.Sqlite][_primaryDB] = new Sqlite(new BetterSqlite3.default(options.Sqlite, { fileMustExist: false }));
+        }
+        else {
+            let flag = false;
+            for (const [key, fileName] of Object.entries(options.Sqlite)) {
+                const db = new Sqlite(new BetterSqlite3.default(fileName, { fileMustExist: false }));
+                if (flag === false) {
+                    globalThis[_dao][DBType.Sqlite][_primaryDB] = db;
+                    flag = true;
+                }
+                globalThis[_dao][DBType.Sqlite][key] = db;
+            }
+        }
+    }
+    if (options.SqliteRemote) {
+        if (typeof options.SqliteRemote.db === 'string') {
+            await options.SqliteRemote.service.initDB(options.SqliteRemote.db);
+            globalThis[_dao][DBType.SqliteRemote][_primaryDB] = new SqliteRemote(options.SqliteRemote.service, options.SqliteRemote.db);
+        }
+        else {
+            let flag = false;
+            for (const [key, fileName] of Object.entries(options.SqliteRemote.db)) {
+                await options.SqliteRemote.service.initDB(fileName);
+                const db = new SqliteRemote(options.SqliteRemote.service, fileName);
+                if (flag === false) {
+                    globalThis[_dao][DBType.SqliteRemote][_primaryDB] = db;
+                    flag = true;
+                }
+                globalThis[_dao][DBType.SqliteRemote][key] = db;
+            }
+        }
+    }
+    if (options.Redis) {
+        const { Redis } = await import('ioredis');
+        if (options.Redis['host']) {
+            globalThis[_dao][DBType.Redis][_primaryDB] = new Redis(options.Redis);
+        }
+        else {
+            let flag = false;
+            for (const [key, option] of Object.entries(options.Redis)) {
+                const db = new Redis(option);
+                if (flag === false) {
+                    globalThis[_dao][DBType.Redis][_primaryDB] = db;
+                    flag = true;
+                }
+                globalThis[_dao][DBType.Redis][key] = db;
+            }
+        }
+        const clients = Object.values(globalThis[_dao][DBType.Redis]);
+        const Redlock = await import('Redlock');
+        globalThis[_dao][DBType.RedisLock] = new Redlock.default(clients, {
+            // The expected clock drift; for more details see:
+            // http://redis.io/topics/distlock
+            driftFactor: 0.01, // multiplied by lock ttl to determine drift time
+            // The max number of times Redlock will attempt to lock a resource
+            // before erroring.
+            retryCount: 10,
+            // the time in ms between attempts
+            retryDelay: 200, // time in ms
+            // the max time in ms randomly added to retries
+            // to improve performance under high contention
+            // see https://www.awsarchitectureblog.com/2015/03/backoff.html
+            retryJitter: 200, // time in ms
+            // The minimum remaining time on a lock before an extension is automatically
+            // attempted with the `using` API.
+            automaticExtensionThreshold: 500, // time in ms
+        });
+        const { EventEmitter } = await import('events');
+        const event = new EventEmitter({ captureRejections: true });
+        event.on('error', error => {
+            logger.error('event-bus', error);
+        });
+        globalThis[_EventBus] = event;
+    }
+};