baja-lite 1.3.27 → 1.3.28

package/sql.js

@@ -0,0 +1,4802 @@
+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 _b, _c, _d, _e;
+var _f, _g, _h, _j;
+import { decode, DecodeError, encode, ExtensionCodec } from "@msgpack/msgpack";
+import { _columns, _columnsNoId, _def, _deleteState, _fields, _Hump, _ids, _index, _logicIds, _stateFileName, DBType, Field } from 'baja-lite-field';
+import HTML from 'html-parse-stringify';
+import * as ite from 'iterare';
+import LGet from 'lodash.get';
+import mustache from 'mustache';
+import pino from 'pino';
+import { formatDialect, mysql, postgresql, sqlite } from 'sql-formatter';
+import tslib from 'tslib';
+import { convert } from './convert-xml.js';
+import { Throw } from './error.js';
+import { excuteSplit, ExcuteSplitMode, sleep } from './fn.js';
+import { ArrayList } from './list.js';
+import { add, calc, ten2Any } from './math.js';
+import { C2P, C2P2, P2C } from './object.js';
+import { emptyString } from './string.js';
+const iterate = ite.iterate;
+BigInt.prototype.toJSON = function () { return this.toString(); };
+const BIGINT_EXT_TYPE = 0;
+export const extensionCodec = new ExtensionCodec();
+extensionCodec.register({
+    type: BIGINT_EXT_TYPE,
+    encode(input) {
+        if (typeof input === "bigint") {
+            if (input <= Number.MAX_SAFE_INTEGER && input >= Number.MIN_SAFE_INTEGER) {
+                return encode(Number(input));
+            }
+            else {
+                return encode(String(input));
+            }
+        }
+        else {
+            return null;
+        }
+    },
+    decode(data) {
+        const val = decode(data);
+        if (!(typeof val === "string" || typeof val === "number")) {
+            throw new DecodeError(`unexpected BigInt source: ${val} (${typeof val})`);
+        }
+        return BigInt(val);
+    },
+});
+// #region 常量
+const _daoDBName = Symbol('dbName');
+const _tableName = Symbol('tableName');
+const _className = Symbol('className');
+const _ClassName = Symbol('ClassName');
+const _vueName = Symbol('vueName');
+const _transformer = Symbol('transformer');
+const _comment = Symbol('comment');
+export const _sqlCache = Symbol('sqlMap');
+export const _dao = Symbol('dao');
+export const _primaryDB = '______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 _resultMap = Symbol('resultMap');
+const _resultMap_SQLID = Symbol('resultMap_SQLID');
+export const _enums = Symbol('_enums');
+export const _GlobalSqlOption = Symbol('GlobalSqlOption');
+export const _EventBus = Symbol('EventBus');
+export const _path = Symbol('path');
+export const _fs = Symbol('fs');
+export const logger = process.env['NODE_ENV'] !== 'production' ? pino({
+    name: 'sql',
+    transport: {
+        target: 'pino-pretty'
+    }
+}) : pino({ name: 'sql' });
+globalThis[_resultMap_SQLID] = {};
+// #endregion
+// #region 可选配置
+export var MapperIfUndefined;
+(function (MapperIfUndefined) {
+    MapperIfUndefined[MapperIfUndefined["Null"] = 0] = "Null";
+    MapperIfUndefined[MapperIfUndefined["Skip"] = 1] = "Skip";
+    MapperIfUndefined[MapperIfUndefined["Zero"] = 2] = "Zero";
+    MapperIfUndefined[MapperIfUndefined["EmptyString"] = 3] = "EmptyString";
+})(MapperIfUndefined || (MapperIfUndefined = {}));
+;
+export var SyncMode;
+(function (SyncMode) {
+    /** 同步执行 */
+    SyncMode[SyncMode["Sync"] = 0] = "Sync";
+    /** 异步执行 */
+    SyncMode[SyncMode["Async"] = 1] = "Async";
+})(SyncMode || (SyncMode = {}));
+export var InsertMode;
+(function (InsertMode) {
+    /**
+    # 默认使用
+    ** 支持单个、批量,语法 `INSERT INTO XX VALUES (第一条数据), (第二条数据);`
+    ** 批量执行有性能优势，但无法利用数据库的sql预编译功能
+    */
+    InsertMode[InsertMode["Insert"] = 0] = "Insert";
+    /**
+    # 利用临时表
+    ## 执行步骤
+    1. 建立临时表(从正式表复制)
+    2. 数据全部进入临时表
+    3. 临时表数据转移到正式表: `INSERT INTO 正式表 SELECT * FROM 临时表`
+    4. 删除临时表
+    ## 注意
+    1. 适用于：主键不会冲突、非自增
+    2. 临时表的结构复制正式表
+     */
+    InsertMode[InsertMode["InsertWithTempTable"] = 1] = "InsertWithTempTable";
+    InsertMode[InsertMode["InsertIfNotExists"] = 2] = "InsertIfNotExists";
+    /**
+    # 插入或者更新
+    1. 判断依据是主键
+     */
+    InsertMode[InsertMode["Replace"] = 3] = "Replace";
+})(InsertMode || (InsertMode = {}));
+export var DeleteMode;
+(function (DeleteMode) {
+    /**
+     ##常规删除 默认
+     ### 例一
+     `DELETE FROM WHERE (id = 1) OR (id = 2)`
+     ### 例二
+     `DELETE FROM WHERE (id = 1 AND idx = 11) OR (id = 2 AND idx = 22)`
+    */
+    DeleteMode[DeleteMode["Common"] = 0] = "Common";
+    /*
+    ## 借助临时表
+    ### 注意：必须保证where的字段都相同，否则会漏删数据
+    DELETE FROM 正式表 INNER JOIN 临时表 WHERE 字段1 = 字段1 AND 字段2 = 字段2
+     */
+    DeleteMode[DeleteMode["TempTable"] = 1] = "TempTable";
+})(DeleteMode || (DeleteMode = {}));
+export var SelectMode;
+(function (SelectMode) {
+    /**
+     ##常规 默认
+     ### 例一
+     `SELECT * FROM WHERE (id = 1) OR (id = 2)`
+     ### 例二
+     `SELECT * FROM WHERE (id = 1 AND idx = 11) OR (id = 2 AND idx = 22)`
+    */
+    SelectMode[SelectMode["Common"] = 0] = "Common";
+    /*
+    ## 借助临时表
+    ### 注意：必须保证where的字段都相同，否则会漏删数据
+    SELECT * FROM 正式表 INNER JOIN 临时表 WHERE 字段1 = 字段1 AND 字段2 = 字段2
+     */
+    SelectMode[SelectMode["TempTable"] = 1] = "TempTable";
+})(SelectMode || (SelectMode = {}));
+export var TemplateResult;
+(function (TemplateResult) {
+    /** 确定返回一条记录，如果不是一个，将报错，返回类型是T */
+    TemplateResult[TemplateResult["AssertOne"] = 0] = "AssertOne";
+    /** 可能返回一条记录，返回类型是T|null */
+    TemplateResult[TemplateResult["NotSureOne"] = 1] = "NotSureOne";
+    /** 返回多条记录 */
+    TemplateResult[TemplateResult["Many"] = 2] = "Many";
+    /** 返回多条记录并封装ArrayList */
+    TemplateResult[TemplateResult["ManyList"] = 3] = "ManyList";
+    /** 仅查询记录数量 */
+    TemplateResult[TemplateResult["Count"] = 4] = "Count";
+})(TemplateResult || (TemplateResult = {}));
+export var SelectResult;
+(function (SelectResult) {
+    /** 一行一列 确定非空 */
+    SelectResult[SelectResult["R_C_Assert"] = 0] = "R_C_Assert";
+    /** 一行一列 可能空 */
+    SelectResult[SelectResult["R_C_NotSure"] = 1] = "R_C_NotSure";
+    /** 一行多列 确定非空 */
+    SelectResult[SelectResult["R_CS_Assert"] = 2] = "R_CS_Assert";
+    /** 一行多列 可能空 */
+    SelectResult[SelectResult["R_CS_NotSure"] = 3] = "R_CS_NotSure";
+    /** 多行一列 */
+    SelectResult[SelectResult["RS_C"] = 4] = "RS_C";
+    /** 多行一列并封装ArrayList */
+    SelectResult[SelectResult["RS_C_List"] = 5] = "RS_C_List";
+    /** 多行多列 */
+    SelectResult[SelectResult["RS_CS"] = 6] = "RS_CS";
+    /** 多行多列并封装ArrayList */
+    SelectResult[SelectResult["RS_CS_List"] = 7] = "RS_CS_List";
+})(SelectResult || (SelectResult = {}));
+export var ColumnMode;
+(function (ColumnMode) {
+    ColumnMode[ColumnMode["NONE"] = 0] = "NONE";
+    ColumnMode[ColumnMode["HUMP"] = 1] = "HUMP";
+})(ColumnMode || (ColumnMode = {}));
+export const SqliteMemory = ':memory:';
+export const _defOption = {
+    maxDeal: 500,
+    skipUndefined: true,
+    skipNull: true,
+    skipEmptyString: true
+};
+;
+class MysqlConnection {
+    constructor(conn) {
+        this[_b] = false;
+        this[_daoConnection] = conn;
+    }
+    execute(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('MYSQL not suppouted sync mode');
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            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}
+                `);
+                reject(error);
+            }
+        });
+    }
+    pluck(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('MYSQL not suppouted sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            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}
+                `);
+                reject(error);
+            }
+        });
+    }
+    get(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('MYSQL not suppouted sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            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}
+                `);
+                reject(error);
+            }
+        });
+    }
+    raw(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('MYSQL not suppouted sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            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}
+                `);
+                reject(error);
+            }
+        });
+    }
+    query(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('MYSQL not suppouted sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            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}
+                `);
+                reject(error);
+            }
+        });
+    }
+    realse(sync) {
+        if (sync === SyncMode.Sync) {
+            try {
+                this[_daoConnection]?.release();
+            }
+            catch (error) {
+            }
+        }
+        ;
+    }
+}
+_b = _inTransaction;
+export class Mysql {
+    constructor(pool) {
+        this[_daoDB] = pool;
+    }
+    async keepAlive() {
+        const connection = await this[_daoDB].getConnection();
+        connection.query('SELECT 1 FROM DUAL');
+        setTimeout(async () => await this.keepAlive(), 60000);
+    }
+    createConnection(sync) {
+        if (sync === SyncMode.Sync) {
+            logger.error('MYSQL not suppouted sync mode');
+            return null;
+        }
+        ;
+        return new Promise(async (resolve, reject) => {
+            try {
+                const connection = await this[_daoDB].getConnection();
+                logger.debug('create new connection!');
+                resolve(new MysqlConnection(connection));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    transaction(sync, fn, conn) {
+        if (sync === SyncMode.Sync) {
+            logger.warn('MYSQL not suppouted sync mode');
+            return null;
+        }
+        ;
+        return new Promise(async (resolve, reject) => {
+            let needCommit = false;
+            let newConn = false;
+            if (!conn) {
+                conn = await this.createConnection(SyncMode.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);
+                reject(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 === SyncMode.Sync) {
+            this[_daoDB]?.destroy();
+        }
+        ;
+    }
+    backup(sync, name) {
+    }
+    remove(sync) {
+    }
+    restore(sync, name) {
+    }
+}
+class PostgresqlConnection {
+    constructor(conn) {
+        this[_c] = false;
+        this[_daoConnection] = conn;
+    }
+    execute(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('Postgresql not suppouted sync mode');
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            try {
+                let index = 1;
+                const { rowCount } = await this[_daoConnection].query({
+                    text: sql.replace(/\?/g, () => `$${index++}`),
+                    values: params
+                });
+                const result = rowCount;
+                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}
+                `);
+                reject(error);
+            }
+        });
+    }
+    pluck(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('Postgresql not suppouted sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            try {
+                let index = 1;
+                const { rows } = await this[_daoConnection].query({
+                    text: sql.replace(/\?/g, () => `$${index++}`),
+                    values: params
+                });
+                if (rows && rows[0]) {
+                    const r = Object.values(rows[0])[0];
+                    if (r === null)
+                        resolve(r);
+                    else
+                        resolve(r);
+                }
+                resolve(null);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+    get(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('Postgresql not suppouted sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            try {
+                let index = 1;
+                const { rows } = await this[_daoConnection].query({
+                    text: sql.replace(/\?/g, () => `$${index++}`),
+                    values: params
+                });
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    logger.trace(rows);
+                }
+                if (rows && rows[0])
+                    resolve(rows[0]);
+                resolve(null);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+    raw(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('Postgresql not suppouted sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            try {
+                let index = 1;
+                const { rows } = await this[_daoConnection].query({
+                    text: sql.replace(/\?/g, () => `$${index++}`),
+                    values: params
+                });
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    logger.trace(rows);
+                }
+                if (rows)
+                    resolve(rows.map((i) => Object.values(i)[0]));
+                resolve([]);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+    query(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('Postgresql not suppouted sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            try {
+                let index = 1;
+                const { rows } = await this[_daoConnection].query({
+                    text: sql.replace(/\?/g, () => `$${index++}`),
+                    values: params
+                });
+                if (globalThis[_GlobalSqlOption].log === 'trace') {
+                    logger.trace(rows);
+                }
+                resolve(rows);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+    realse(sync) {
+        if (sync === SyncMode.Sync) {
+            try {
+                this[_daoConnection]?.release();
+            }
+            catch (error) {
+            }
+        }
+        ;
+    }
+}
+_c = _inTransaction;
+export class Postgresql {
+    constructor(pool) {
+        this[_daoDB] = pool;
+    }
+    async keepAlive() {
+        const connection = await this[_daoDB].connect();
+        connection.query('SELECT 1');
+        setTimeout(async () => await this.keepAlive(), 60000);
+    }
+    createConnection(sync) {
+        if (sync === SyncMode.Sync) {
+            logger.error('Postgresql not suppouted sync mode');
+            return null;
+        }
+        ;
+        return new Promise(async (resolve, reject) => {
+            try {
+                const connection = await this[_daoDB].connect();
+                logger.debug('create new connection!');
+                resolve(new PostgresqlConnection(connection));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    transaction(sync, fn, conn) {
+        if (sync === SyncMode.Sync) {
+            logger.warn('Postgresql not suppouted sync mode');
+            return null;
+        }
+        ;
+        return new Promise(async (resolve, reject) => {
+            let needCommit = false;
+            let newConn = false;
+            if (!conn) {
+                conn = await this.createConnection(SyncMode.Async) ?? undefined;
+                newConn = true;
+            }
+            if (conn?.[_inTransaction] !== true) {
+                needCommit = true;
+                logger.debug('beginTransaction begin!');
+                await conn[_daoConnection].query('BEGIN');
+                logger.debug('beginTransaction end!');
+            }
+            conn[_inTransaction] = true;
+            try {
+                const result = await fn(conn);
+                if (needCommit === true) {
+                    logger.debug('commit begin!');
+                    await conn[_daoConnection].query('COMMIT');
+                    conn[_inTransaction] = false;
+                    logger.debug('commit end!');
+                }
+                resolve(result);
+            }
+            catch (error) {
+                logger.debug('rollback begin!');
+                await conn[_daoConnection].query('ROLLBACK');
+                logger.debug('rollback end!');
+                conn[_inTransaction] = false;
+                logger.error(error);
+                reject(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 === SyncMode.Sync) {
+            this[_daoDB]?.end();
+        }
+        ;
+    }
+    backup(sync, name) {
+    }
+    remove(sync) {
+    }
+    restore(sync, name) {
+    }
+}
+class SqliteConnection {
+    constructor(conn) {
+        this[_d] = false;
+        this[_daoConnection] = conn;
+    }
+    execute(sync, sql, params) {
+        try {
+            logger.debug(sql, params ?? '');
+            if (!sql) {
+                return { affectedRows: 0, insertId: 0n };
+            }
+            ;
+            if (sync === SyncMode.Async) {
+                logger.warn(`SQLITE not suppoted async mode`);
+                return { affectedRows: 0, insertId: 0n };
+            }
+            ;
+            if (globalThis[_GlobalSqlOption].log === 'trace') {
+                logger.trace(`${sql}\n,${JSON.stringify(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 === SyncMode.Async) {
+                logger.warn(`SQLITE not suppoted async mode`);
+                return null;
+            }
+            ;
+            if (globalThis[_GlobalSqlOption].log === 'trace') {
+                logger.trace(`${sql}\n,${JSON.stringify(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 === SyncMode.Async) {
+                return null;
+            }
+            ;
+            if (globalThis[_GlobalSqlOption].log === 'trace') {
+                logger.trace(`${sql}\n,${JSON.stringify(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 === SyncMode.Async) {
+                logger.warn(`SQLITE not suppoted async mode`);
+                return [];
+            }
+            ;
+            if (globalThis[_GlobalSqlOption].log === 'trace') {
+                logger.trace(`${sql}\n,${JSON.stringify(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 === SyncMode.Async) {
+                logger.warn(`SQLITE not suppoted async mode`);
+                return [];
+            }
+            ;
+            if (globalThis[_GlobalSqlOption].log === 'trace') {
+                logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+            }
+            return this[_daoConnection].prepare(sql).all(params ?? {});
+        }
+        catch (error) {
+            logger.error(`
+                error: ${error},
+                sql: ${sql},
+                params: ${params}
+            `);
+            throw error;
+        }
+    }
+    realse(sync) {
+    }
+}
+_d = _inTransaction;
+export 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 === SyncMode.Async) {
+            logger.error(`SQLITE not suppoted async mode`);
+            return null;
+        }
+        ;
+        return new SqliteConnection(this[_daoDB]);
+    }
+    transaction(sync, fn, conn) {
+        if (sync === SyncMode.Async) {
+            logger.warn(`SQLITE not suppoted async mode`);
+            return null;
+        }
+        ;
+        if (!conn) {
+            conn = this.createConnection(SyncMode.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 === SyncMode.Sync) {
+            this[_daoDB].close();
+        }
+        ;
+    }
+    backup(sync, name) {
+        if (sync === SyncMode.Sync) {
+            this[_daoDB].backup(name);
+        }
+        ;
+    }
+    remove(sync) {
+    }
+    restore(sync, name) {
+    }
+}
+export class SqliteRemoteConnection {
+    constructor(conn, name) {
+        this[_e] = false;
+        this[_daoConnection] = conn;
+        this[_sqliteRemoteName] = name;
+    }
+    execute(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('SqliteRemote not suppouted sync mode');
+            return { affectedRows: 0, insertId: 0n };
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            try {
+                const data = await this[_daoConnection].execute(encode([this[_sqliteRemoteName], sql, params], { extensionCodec }));
+                const { affectedRows, insertId } = decode(data, { extensionCodec });
+                resolve({ affectedRows, insertId: insertId ? BigInt(insertId) : 0n });
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+    pluck(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('SqliteRemote not suppouted sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            try {
+                const data = await this[_daoConnection].pluck(encode([this[_sqliteRemoteName], sql, params], { extensionCodec }));
+                const r = decode(data, { extensionCodec });
+                resolve(r);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+    get(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return null;
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('SqliteRemote not suppouted sync mode');
+            return null;
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            try {
+                const data = await this[_daoConnection].get(encode([this[_sqliteRemoteName], sql, params], { extensionCodec }));
+                const r = decode(data, { extensionCodec });
+                resolve(r);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+    raw(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('SqliteRemote not suppouted sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            try {
+                const data = await this[_daoConnection].raw(encode([this[_sqliteRemoteName], sql, params], { extensionCodec }));
+                const r = decode(data, { extensionCodec });
+                resolve(r);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+    query(sync, sql, params) {
+        logger.debug(sql, params ?? '');
+        if (!sql) {
+            return [];
+        }
+        ;
+        if (sync === SyncMode.Sync) {
+            logger.warn('SqliteRemote not suppouted sync mode');
+            return [];
+        }
+        ;
+        if (globalThis[_GlobalSqlOption].log === 'trace') {
+            logger.trace(`${sql}\n,${JSON.stringify(params ?? '')}`);
+        }
+        return new Promise(async (resolve, reject) => {
+            try {
+                const data = await this[_daoConnection].query(encode([this[_sqliteRemoteName], sql, params], { extensionCodec }));
+                const r = decode(data, { extensionCodec });
+                resolve(r);
+            }
+            catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+    realse(sync) {
+    }
+}
+_e = _inTransaction;
+export class SqliteRemote {
+    constructor(db, name) {
+        this[_daoDB] = db;
+        this[_sqliteRemoteName] = name;
+    }
+    createConnection(sync) {
+        if (sync === SyncMode.Sync) {
+            logger.error('SQLITEREMOTE not suppouted sync mode');
+            return null;
+        }
+        ;
+        return new Promise(async (resolve, reject) => {
+            if (!this.connection) {
+                this.connection = new SqliteRemoteConnection(this[_daoDB], this[_sqliteRemoteName]);
+            }
+            try {
+                resolve(this.connection);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    transaction(sync, fn, conn) {
+        logger.warn(`SQLITEREMOTE not suppoted transaction`);
+        return null;
+    }
+    close(sync) {
+        if (sync === SyncMode.Async) {
+            return this[_daoDB]?.close(this[_sqliteRemoteName]);
+        }
+        ;
+    }
+    backup(sync, exportPath) {
+        if (sync === SyncMode.Async) {
+            return this[_daoDB]?.export(this[_sqliteRemoteName], exportPath);
+        }
+        ;
+    }
+    remove(sync) {
+    }
+    restore(sync, importPath) {
+        if (sync === SyncMode.Async) {
+            return this[_daoDB]?.restore(this[_sqliteRemoteName], importPath);
+        }
+        ;
+    }
+}
+class Build {
+    /**
+     *
+     * @param count 是否是count查询
+     * @param isSum  是否是sum查询
+     * @param param
+     */
+    constructor(isCount, isSum, param = {}) {
+        this.isCount = isCount;
+        this.isSum = isSum;
+        this.orderBy = param.sortName ? `${param.sortName} ${param.sortType ?? 'ASC'}` : '';
+        Object.assign(this, param);
+    }
+    /**
+     *
+     * 当分页时将函数内包含的内容替换为COUNT(1)
+     * @returns
+     * @memberof Build
+     */
+    page() {
+        return (text, render) => {
+            if (this.isCount === true) {
+                return Build.page;
+            }
+            else if (this.isSum !== true) {
+                return render(text);
+            }
+        };
+    }
+    /**
+   *
+   * 包含的内容只在汇总查询时有效，否则是空白
+   * @returns
+   * @memberof Build
+   */
+    sum() {
+        return (text, render) => {
+            if (this.isSum !== true) {
+                return '';
+            }
+            else {
+                return render(text);
+            }
+        };
+    }
+    /**
+     *
+     * 当分页时、汇总时忽略函数内包含的内容
+     * @returns
+     * @memberof Build
+     */
+    notPage() {
+        return (text, render) => {
+            if (this.isCount === true || this.isSum === true) {
+                return '';
+            }
+            else {
+                return render(text);
+            }
+        };
+    }
+    /**
+     *
+     * 将查询条件包起来，如果条件内容不为空，则自动添加WHERE,同时将第一个条件的and、or替换为空
+     * 例如:
+     * {{#whereTag}}
+     * and name = 1
+     * and page = 2
+     * {{/whereTag}}
+     * 输出
+     * where name = 1 and page = 2
+     * @returns
+     * @memberof Build
+     */
+    where() {
+        return (text, render) => {
+            let data = render(text).trim();
+            if (data) {
+                data = data.replace(/and|or/i, '');
+                return ` WHERE ${data} `;
+            }
+            else {
+                return '';
+            }
+        };
+    }
+    /**
+     * ```
+     * SELECT
+     * {{#hump}}
+     * a.event_id, a.event_name eventName
+     * {{/hump}}
+     * FROM...
+     * ```
+     * 编译后:
+     * ```
+     * SELECT
+     * a.event_id eventId, a.event_name eventName
+     * FROM...
+     * ```
+     */
+    hump() {
+        return (text, render) => {
+            let data = render(text).trim();
+            const datas = data.split(',');
+            for (let i = 0; i < datas.length; i++) {
+                if (datas[i]?.match(/\s|\t/) === null) {
+                    datas[i] = `${datas[i]} ${datas[i].replace(/[a-zA-Z0-9]+\./, '').replace(/_([a-z])/g, (a, b, c) => b.toUpperCase())}`;
+                }
+            }
+            return ` ${datas.join(',')} `;
+        };
+    }
+    /**
+     * 删除第一个and、or
+     * 删除最后一个,
+     * 删除最后一个;
+     * @memberof Build
+     */
+    trim() {
+        return (text, render) => {
+            let data = render(text);
+            data = data.trim();
+            if (data) {
+                data = data.replace(/(^and\s)|(^or\s)|(,$)|(;$)/i, '');
+                return data;
+            }
+            else {
+                return '';
+            }
+        };
+    }
+    /**
+     * 分页时将排序部分代码用此函数包起来，可以自动拼接order by
+     * 查询条数时，自动忽略此部分
+     * etc
+     * {{#order}} name desc, age asc {{/order}}
+     * ===
+     * ORDER BY name desc, age asc
+     * @returns
+     * @memberof Build
+     */
+    order() {
+        return (text, render) => {
+            if (this.isCount === true || this.isSum === true) {
+                return '';
+            }
+            else {
+                const orderBy = new Array();
+                if (this.orderBy) {
+                    orderBy.push(this.orderBy);
+                }
+                const renderOrder = render(text);
+                if (/\S/.test(renderOrder)) {
+                    orderBy.push(renderOrder);
+                }
+                return orderBy.length > 0 ? ` ORDER BY ${orderBy.join(',')} ` : '';
+            }
+        };
+    }
+    /**
+     *
+     * 分页时将分组部分代码用此函数包起来，可以自动拼接GROUP BY
+     * 当分页时、汇总时，自动忽略此部分
+     * etc
+     * {{#between}} name, age {{/between}}
+     * ===
+     * group by name.age
+     * @returns
+     * @memberof Build
+     */
+    group() {
+        return (text, render) => {
+            if (this.isCount === true || this.isSum === true) {
+                return '';
+            }
+            else {
+                const groupBy = render(text) || '';
+                return /\S/.test(groupBy) ? ` GROUP BY ${groupBy} ` : '';
+            }
+        };
+    }
+    /**
+     *
+     * beetween and
+     * etc.
+     * {{#between}} AND t.createtime | ({{createtime}}) {{/between}}
+     * createtime: 1,2
+     * ===
+     * AND t.createtime BETWEEN 1 AND 2
+     * @returns
+     * @memberof Build
+     */
+    between() {
+        return (text, render) => {
+            const result = render(text);
+            if (/\(([\w\W]+)\)/.exec(result)) {
+                return render(text).replace(/\(([\w\W]+)\)/, (a, b) => {
+                    if (a && b) {
+                        const xx = b.split(',');
+                        return `'${xx[0]}' AND '${xx[1]}'`;
+                    }
+                    else {
+                        return '';
+                    }
+                }).replace(/\|/, ' BETWEEN ');
+            }
+            else {
+                return '';
+            }
+        };
+    }
+    /**
+     *
+     * 距离计算,单位米
+     * etc
+     * {{#distance}} (t.longitude, t.latitude), ({{longitude}}, {{latitude}}) {{/distance}}
+     * ===
+     * ROUND(ST_DISTANCE(POINT(longitude1, latitude1), POINT({{longitude}}, {{latitude}}))*111195, 2)
+     * 可根据需求自行将数据转换为千米，例如
+     * {{#distance}} (t.longitude, t.latitude), ({{longitude}}, {{latitude}}) {{/distance}} / 1000
+     * @returns
+     * @memberof Build
+     */
+    distance() {
+        return (text, render) => {
+            const result = render(text);
+            if (/\(([^()]+)\)/.exec(result)) {
+                let index = 0;
+                return render(text).replace(/\(([^()]+)\)/g, (a, b) => {
+                    if (a && b) {
+                        const xx = b.split(',');
+                        if (index === 0) {
+                            index++;
+                            return ` ROUND(ST_DISTANCE(POINT(${xx[0]}, ${xx[1]}) `;
+                        }
+                        else {
+                            return ` POINT(${xx[0]}, ${xx[1]}))*111195, 2)`;
+                        }
+                    }
+                    else {
+                        return '';
+                    }
+                });
+            }
+            else {
+                return '';
+            }
+        };
+    }
+    /**
+     * * PROBLEM_TYPE = 枚举名
+     * * t.problemtype = 列名
+     *
+     * ```
+     * {{#enumTag}} PROBLEM_TYPE(t.problemtype) {{/enumTag}}
+     * ```
+     */
+    enum() {
+        return (text) => {
+            const matchs = text.match(/([a-zA-Z_]+)\(([^()]+)\)/);
+            if (matchs) {
+                const [_a, MapName, Column] = matchs;
+                if (MapName && Column) {
+                    const map = globalThis[_enums].GlobalMap[MapName.trim()];
+                    if (map) {
+                        return ` CASE
+    ${Object.entries(map).map(([k, v]) => `WHEN ${Column} = '${k}' THEN '${v}'`).join(' ')}
+    END `;
+                    }
+                }
+            }
+            return "''";
+        };
+    }
+}
+Build.page = 'COUNT(1) zccw1986 ';
+function replaceCdata(rawText) {
+    var cdataRegex = new RegExp('(<!\\[CDATA\\[)([\\s\\S]*?)(\\]\\]>)', 'g');
+    var matches = rawText.match(cdataRegex);
+    if (matches != null && matches.length > 0) {
+        for (var z = 0; z < matches.length; z++) {
+            var regex = new RegExp('(<!\\[CDATA\\[)([\\s\\S]*?)(\\]\\]>)', 'g');
+            var m = regex.exec(matches[z]);
+            var cdataText = m[2];
+            cdataText = cdataText.replace(/\&/g, '&amp;');
+            cdataText = cdataText.replace(/\</g, '&lt;');
+            cdataText = cdataText.replace(/\>/g, '&gt;');
+            cdataText = cdataText.replace(/\"/g, '&quot;');
+            rawText = rawText.replace(m[0], cdataText);
+        }
+    }
+    return rawText;
+}
+function _flatData(result, i, length, keys, V) {
+    var _f;
+    const key = keys[i];
+    if (i < length) {
+        result[_f = key] ?? (result[_f] = {});
+        i++;
+        _flatData(result[key], i, length, keys, V);
+    }
+    else {
+        result[key] = V;
+    }
+}
+/**
+ * ifUndefined默认是MapperIfUndefined.Skip
+ */
+export function flatData(options) {
+    if (typeof options.mapper === 'string') {
+        const name = options.mapper;
+        options.mapper = globalThis[_resultMap][name];
+        Throw.if(!options.mapper, `not found mapper!${name}`);
+    }
+    options.mapperIfUndefined ?? (options.mapperIfUndefined = MapperIfUndefined.Skip);
+    options.mapper = options.mapper;
+    const result = {};
+    for (const [columnName, keys, def] of options.mapper) {
+        let V = options.data[columnName];
+        if (V === undefined) {
+            if (options.mapperIfUndefined === MapperIfUndefined.Null) {
+                V = null;
+            }
+            else if (options.mapperIfUndefined === MapperIfUndefined.Zero) {
+                V = 0;
+            }
+            else if (options.mapperIfUndefined === MapperIfUndefined.EmptyString) {
+                V = '';
+            }
+            else if (def !== undefined) {
+                V = def;
+            }
+            else {
+                continue;
+            }
+        }
+        _flatData(result, 0, keys.length - 1, keys, V);
+    }
+    return result;
+}
+export class SqlCache {
+    constructor() {
+        this.sqlMap = {};
+        this.sqlFNMap = {};
+    }
+    async _read(jsMode, sqlDir, queryTypes, rootName) {
+        const sqlFis = globalThis[_fs].readdirSync(sqlDir);
+        for (const modeName of sqlFis) {
+            const file = globalThis[_path].join(sqlDir, modeName);
+            const stat = globalThis[_fs].statSync(file);
+            if (stat.isDirectory()) {
+                await this._read(jsMode, file, queryTypes, modeName);
+            }
+            else {
+                const extname = globalThis[_path].extname(modeName);
+                const name = globalThis[_path].basename(modeName, extname);
+                let ct = 0;
+                if (extname === '.mu') {
+                    logger.debug(`sql: ${file} start explain!`);
+                    const parser = new MUParser(rootName || name, globalThis[_fs].readFileSync(file, { encoding: 'utf-8' }).toString());
+                    let source = parser.next();
+                    while (source != null) {
+                        ct++;
+                        this.sqlMap[source[0]] = source[1];
+                        logger.debug(`sql: ${source[0]} found!`);
+                        source = parser.next();
+                    }
+                    logger.debug(`sql: ${file} explain over[${ct}]!`);
+                }
+                else if (jsMode === true && extname === '.js') {
+                    logger.debug(`sql: ${file} start explain!`);
+                    const obj = (await import(globalThis[_path].join(sqlDir, modeName))).default;
+                    for (const [key, fn] of Object.entries(obj)) {
+                        ct++;
+                        this.sqlMap[`${rootName || name}.${String(key)}`] = fn;
+                    }
+                    logger.debug(`sql: ${file} explain over[${ct}]!`);
+                }
+                else if (extname === '.xml') {
+                    logger.debug(`sql: ${file} start explain!`);
+                    const root = HTML.parse(replaceCdata(globalThis[_fs].readFileSync(file, { encoding: 'utf-8' }).toString()))[0];
+                    if (root) {
+                        const mappers = root.children;
+                        for (const mapper of mappers) {
+                            if (mapper.type === 'tag' && mapper.name === 'mapper') {
+                                for (const am of mapper.children) {
+                                    if (am.type === 'tag') {
+                                        Throw.if(!queryTypes.includes(am.name), `${rootName} ${name}错误,${am.name}不支持!`);
+                                        am.id = am.attrs['id'];
+                                        Throw.if(!am.id, `${rootName} ${name}错误,没有为此块设置id:${am}`);
+                                        if (am.name === 'resultMap') {
+                                            ct++;
+                                            globalThis[_resultMap] ?? (globalThis[_resultMap] = {});
+                                            const keys = [];
+                                            this.readResultMap(am.children, keys, []);
+                                            globalThis[_resultMap][am.id] = keys;
+                                            logger.debug(`sql_resultMap: ${am.id} found!`);
+                                        }
+                                        else {
+                                            this.sqlMap[`${rootName || name}.${am.id}`] = am.children;
+                                            if (am.attrs['resultMap']) {
+                                                globalThis[_resultMap_SQLID][`${rootName || name}.${am.id}`] = am.attrs['resultMap'];
+                                                logger.debug(`sql: autoMapper: ${rootName || name}.${am.id}-${am.attrs['resultMap']}`);
+                                            }
+                                            logger.debug(`sql: ${rootName || name}.${am.id} found!`);
+                                            ct++;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    logger.debug(`sql: ${file} explain over[${ct}]!`);
+                }
+            }
+        }
+    }
+    /**
+     *
+     * ```
+    // 第一个元素=列名，第二个元素是属性路径，
+    [
+        ['dit_id', ['id']], // 列名ditid,对应属性id
+        ['event_id', ['eventMainInfo', 'id']] // 列名event_id对应属性eventMainInfo.id
+    ]
+     * ```
+     * @param am
+     * @param keys
+     */
+    readResultMap(ams, keys, key) {
+        for (const am of ams) {
+            if (am.type === 'tag') {
+                if (am.name === 'result' || am.name === 'id') {
+                    keys.push([am.attrs['column'], [...key, am.attrs['property']]]);
+                }
+                else {
+                    this.readResultMap(am.children, keys, [...key, am.attrs['property']]);
+                }
+            }
+        }
+    }
+    async init(options) {
+        if (options.sqlMap) {
+            this.sqlMap = options.sqlMap;
+        }
+        const queryTypes = ['sql', 'select', 'insert', 'update', 'delete', 'resultMap'];
+        if (options.sqlDir) {
+            await this._read(options.jsMode === true, options.sqlDir, queryTypes, '');
+        }
+        if (options.sqlFNMap) {
+            this.sqlFNMap = options.sqlFNMap;
+        }
+        if (options.sqlFNDir) {
+            const sqlFis = globalThis[_fs].readdirSync(options.sqlDir);
+            for (const modeName of sqlFis) {
+                const extname = globalThis[_path].extname(modeName);
+                const name = globalThis[_path].basename(modeName, extname);
+                const file = globalThis[_path].join(options.sqlDir, modeName);
+                if (extname === 'mu') {
+                    this.sqlFNMap[name] = globalThis[_fs].readFileSync(file, { encoding: 'utf-8' }).toString();
+                }
+            }
+        }
+        if (options.sqlMapperMap) {
+            globalThis[_resultMap] = options.sqlFNMap;
+        }
+        if (options.sqlMapperDir) {
+            const sqlFis = globalThis[_fs].readdirSync(options.sqlDir);
+            globalThis[_resultMap] ?? (globalThis[_resultMap] = {});
+            for (const modeName of sqlFis) {
+                const extname = globalThis[_path].extname(modeName);
+                const name = globalThis[_path].basename(modeName, extname);
+                const file = globalThis[_path].join(options.sqlDir, modeName);
+                if (extname === 'json') {
+                    globalThis[_resultMap][name] = JSON.parse(globalThis[_fs].readFileSync(file, { encoding: 'utf-8' }).toString());
+                }
+            }
+        }
+    }
+    load(sqlids, options) {
+        let sqlSource;
+        for (const sqlid of sqlids) {
+            sqlSource = this.sqlMap[sqlid];
+            if (sqlSource) {
+                break;
+            }
+        }
+        const matchSqlid = sqlids.map(i => i.split('.')[0]);
+        Throw.if(!sqlSource, `指定的语句${sqlids.join('|')}不存在!`);
+        const buildParam = new Build(options.isCount === true, options.isSum === true, options);
+        if (typeof sqlSource === 'function') {
+            const _sql = sqlSource(options);
+            return mustache.render(_sql, buildParam, this.sqlFNMap);
+        }
+        else if (typeof sqlSource === 'string') {
+            return mustache.render(sqlSource, buildParam, this.sqlFNMap);
+        }
+        else if (typeof sqlSource === 'object') {
+            const _sql = convert(sqlSource, options, matchSqlid, this.sqlMap);
+            return mustache.render(_sql, buildParam, this.sqlFNMap);
+        }
+        return '';
+    }
+}
+// #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 = SyncMode.Async);
+            option.tableName = option?.tableName ?? this[_tableName];
+            option.dbName = option?.dbName ?? this[_daoDBName] ?? _primaryDB;
+            option.dbType = this[_dbType] ?? globalThis[_GlobalSqlOption].dbType ?? DBType.Mysql;
+            option.dao = globalThis[_dao][option.dbType][option.dbName];
+            if (option.dbType === DBType.Sqlite) {
+                if (!option.dao) {
+                    const db = new Sqlite(new globalThis[_GlobalSqlOption].BetterSqlite3(option.dbName, { fileMustExist: false }));
+                    if (globalThis[_dao][option.dbType][_primaryDB] === undefined) {
+                        globalThis[_dao][option.dbType][_primaryDB] = db;
+                    }
+                    globalThis[_dao][option.dbType][option.dbName] = db;
+                    option.dao = db;
+                }
+                Throw.if(option.sync === SyncMode.Async, 'sqlite can not Async!');
+                // 连接共享
+                if (skipConn === false && !option.conn) {
+                    option.conn = option.dao.createConnection(SyncMode.Sync);
+                }
+                else {
+                    needRealseConn = false;
+                }
+                try {
+                    const result = fn.call(this, ...args);
+                    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(SyncMode.Sync);
+                        }
+                        catch (error) {
+                        }
+                    }
+                }
+            }
+            else if (option.dbType === DBType.SqliteRemote) {
+                if (!option.dao) {
+                    globalThis[_GlobalSqlOption].SqliteRemote.service.initDB(option.dbName);
+                    const db = new SqliteRemote(globalThis[_GlobalSqlOption].SqliteRemote.service, option.dbName);
+                    if (globalThis[_dao][option.dbType][_primaryDB] === undefined) {
+                        globalThis[_dao][option.dbType][_primaryDB] = db;
+                    }
+                    globalThis[_dao][option.dbType][option.dbName] = db;
+                    option.dao = db;
+                }
+                Throw.if(option.sync === SyncMode.Sync, 'SqliteRemote remote can not sync!');
+                return new Promise(async (resolve, reject) => {
+                    // 连接共享
+                    if (skipConn === false && !option.conn) {
+                        (option).conn = await option.dao.createConnection(SyncMode.Async);
+                    }
+                    else {
+                        needRealseConn = false;
+                    }
+                    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)))}`);
+                        reject(error);
+                    }
+                    finally {
+                        if (needRealseConn && option && option.conn) {
+                            try {
+                                option.conn.realse(SyncMode.Sync);
+                            }
+                            catch (error) {
+                            }
+                        }
+                    }
+                });
+            }
+            else if (option.dbType === DBType.Mysql) {
+                Throw.if(!option.dao, `not found db:${String(option.dbName)}(${option.dbType})`);
+                return new Promise(async (resolve, reject) => {
+                    try {
+                        // 连接共享
+                        if (skipConn === false && !option.conn) {
+                            (option).conn = await option.dao.createConnection(SyncMode.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)))}`);
+                        reject(error);
+                    }
+                    finally {
+                        if (needRealseConn && option && option.conn) {
+                            try {
+                                option.conn.realse(SyncMode.Sync);
+                            }
+                            catch (error) {
+                            }
+                        }
+                    }
+                });
+            }
+            else if (option.dbType === DBType.Postgresql) {
+                Throw.if(!option.dao, `not found db:${String(option.dbName)}(${option.dbType})`);
+                return new Promise(async (resolve, reject) => {
+                    try {
+                        // 连接共享
+                        if (skipConn === false && !option.conn) {
+                            (option).conn = await option.dao.createConnection(SyncMode.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)))}`);
+                        reject(error);
+                    }
+                    finally {
+                        if (needRealseConn && option && option.conn) {
+                            try {
+                                option.conn.realse(SyncMode.Sync);
+                            }
+                            catch (error) {
+                            }
+                        }
+                    }
+                });
+            }
+        };
+    };
+}
+const FieldFilter = (K, V, def, uuidColumn, option) => {
+    let ret = 0;
+    // 如果是插入操作且字段是UUID，则不进行空值检查
+    // 只有在非插入或者非UUID时，进行空置检查
+    if (option?.insert === true && uuidColumn === true) {
+        ret = 1;
+        if (V === undefined || emptyString(`${V ?? ''}`)) {
+            V = null;
+        }
+    }
+    else {
+        if (V === null) {
+            if (option?.skipNull !== true) {
+                ret = 1;
+                V = option?.insert === true && def && def.hasOwnProperty(K) ? def[K] : null;
+            }
+        }
+        else if (V === undefined) {
+            if (option?.skipUndefined !== true) {
+                ret = 1;
+                V = option?.insert === true && def && def.hasOwnProperty(K) ? def[K] : null;
+            }
+        }
+        else if (emptyString(`${V ?? ''}`)) {
+            if (option?.skipEmptyString !== true) {
+                ret = 1;
+                V = option?.insert === 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 formatDialects = {
+    [DBType.Mysql]: mysql,
+    [DBType.Sqlite]: sqlite,
+    [DBType.SqliteRemote]: sqlite,
+    [DBType.Postgresql]: postgresql,
+};
+export const DB = (config) => {
+    return function (constructor) {
+        var _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
+        const __ids = Reflect.getMetadata(_ids, config.clz.prototype) || new Array;
+        const __logicIds = Reflect.getMetadata(_logicIds, config.clz.prototype) || new Array;
+        const __fields = Reflect.getMetadata(_fields, config.clz.prototype);
+        const __columns = Reflect.getMetadata(_columns, config.clz.prototype);
+        const __columnsNoId = Reflect.getMetadata(_columnsNoId, config.clz.prototype);
+        const __stateFileName = Reflect.getMetadata(_stateFileName, config.clz.prototype);
+        const __deleteState = Reflect.getMetadata(_deleteState, config.clz.prototype);
+        const __index = Reflect.getMetadata(_index, config.clz.prototype);
+        const __def = Reflect.getMetadata(_def, config.clz.prototype);
+        const __dbType = config.dbType;
+        const className = config.tableName?.replace(/_(\w)/g, (a, b) => b.toUpperCase());
+        const ClassName = className?.replace(/\w/, (v) => v.toUpperCase());
+        const vueName = config.tableName?.replace(/_/g, '-');
+        return _0 = class extends constructor {
+                constructor() {
+                    super(...arguments);
+                    this[_f] = config.tableName;
+                    this[_g] = className;
+                    this[_h] = ClassName;
+                    this[_j] = vueName;
+                    this[_k] = config.dbName;
+                    this[_l] = __dbType;
+                    this[_m] = config.sqliteVersion;
+                    this[_o] = Object.assign({}, _defOption, config);
+                    this[_p] = __ids;
+                    this[_q] = __logicIds;
+                    this[_r] = __fields;
+                    this[_s] = __columns;
+                    this[_t] = __columnsNoId;
+                    this[_u] = __index;
+                    this[_v] = __def;
+                    this[_w] = config.comment;
+                    this[_x] = __stateFileName;
+                    this[_y] = __deleteState;
+                    this[_z] = (data, option) => {
+                        return Object.fromEntries(iterate(option?.skipId === true ? __columnsNoId : __columns)
+                            .map(K => [K, FieldFilter(K, data[K], __def, __fields[K].uuid === true || __fields[K].uuidShort === true, option)])
+                            .filter(data => {
+                            if (data[1][0] === 1) {
+                                if (__fields[data[0]].Data2SQL) {
+                                    data[1][1] = __fields[data[0]].Data2SQL(data[1][1]);
+                                }
+                                if (option?.onFieldExists) {
+                                    option.onFieldExists(data[0], data[1][1]);
+                                }
+                                return true;
+                            }
+                            else {
+                                return false;
+                            }
+                        })
+                            .map(data => [data[0], data[1][1]])
+                            .toArray());
+                    };
+                }
+            },
+            _f = _tableName,
+            _g = _className,
+            _h = _ClassName,
+            _j = _vueName,
+            _k = _daoDBName,
+            _l = _dbType,
+            _m = _sqlite_version,
+            _o = _SqlOption,
+            _p = _ids,
+            _q = _logicIds,
+            _r = _fields,
+            _s = _columns,
+            _t = _columnsNoId,
+            _u = _index,
+            _v = _def,
+            _w = _comment,
+            _x = _stateFileName,
+            _y = _deleteState,
+            _z = _transformer,
+            _0;
+    };
+};
+/**
+  js项目中实体类注解替代品，只要确保函数被执行即可,举例：
+  ```
+  // 声明一个class
+    export class AmaFuck {}
+    DeclareClass(AmaFuck, [
+        { type: "String", name: "SellerSKU" },
+        { type: "String", name: "SellerSKU2" },
+        { type: "String", name: "site" }
+    ]);
+  ```
+ */
+export function DeclareClass(clz, FieldOptions) {
+    for (const item of FieldOptions) {
+        tslib.__decorate([Field(item)], clz.prototype, item.P, void 0);
+    }
+}
+/**
+ JS项目中，service注解代替,举例：
+ ```
+ // 声明一个service,注意这里的let
+    export let AmaService = class AmaService extends SqlService {};
+    AmaService = DeclareService(AmaService, {
+        tableName: "ama_fuck2",
+        clz: AmaFuck,
+        dbType: DBType.Sqlite,
+        sqliteVersion: "0.0.3"
+    });
+ ```
+ */
+export function DeclareService(clz, config) {
+    return tslib.__decorate([DB(config)], clz);
+}
+/**
+ ## 数据库服务
+ ### 注解DB
+ 
+ ### 泛型 T，同DB注解中的clz
+ ** 服务中所有方法默认以该类型为准
+ **
+ 
+ */
+export class SqlService {
+    _insert(datas, option) {
+        const sqls = [];
+        const tableName = option.tableName;
+        switch (option?.mode) {
+            case InsertMode.InsertIfNotExists: {
+                const conditions = option.existConditionOtherThanIds || this[_ids];
+                Throw.if(!conditions, 'not found where condition for insertIfNotExists!');
+                Throw.if(conditions.length === 0, 'insertIfNotExists must have not null where!');
+                const where = iterate(conditions).map(c => `${this[_fields][c]?.C2()} = ?`).join(' AND ');
+                const finalColumns = new Set();
+                const whereColumns = conditions;
+                const params = [];
+                const questMarks = datas
+                    .map(data => this[_transformer](data, { ...option, finalColumns, insert: true }))
+                    .map(data => {
+                    const questMark = new Array();
+                    for (const column of finalColumns) {
+                        const V = data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null;
+                        if (V === null) {
+                            const field = this[_fields][column];
+                            if (field?.uuid) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push('gen_random_uuid()');
+                                        break;
+                                    default:
+                                        questMark.push('UUID()');
+                                        break;
+                                }
+                            }
+                            else if (field?.uuidShort) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push(`encode(uuid_send(gen_random_uuid()::uuid),'base64')`);
+                                        break;
+                                    case DBType.Mysql:
+                                        questMark.push('UUID_SHORT()');
+                                        break;
+                                    default:
+                                        questMark.push('?');
+                                        params.push(V);
+                                        break;
+                                }
+                            }
+                            else {
+                                questMark.push('?');
+                                params.push(V);
+                            }
+                        }
+                        else {
+                            questMark.push('?');
+                            params.push(V);
+                        }
+                    }
+                    for (const column of whereColumns) {
+                        params.push(data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null);
+                    }
+                    return `SELECT ${questMark.join(',')} FROM DUAL WHERE NOT EXISTS (SELECT 1 FROM ${tableName} WHERE ${where})`;
+                });
+                const columnNames = iterate(finalColumns).map(i => this[_fields][i]?.C2()).join(',');
+                const sql = formatDialect(`INSERT INTO
+                ${tableName}
+                (${columnNames})
+                ${questMarks.join(' UNION ALL ')};`, { dialect: formatDialects[option.dbType] });
+                sqls.push({ sql, params });
+                break;
+            }
+            case InsertMode.Replace: {
+                const finalColumns = new Set();
+                const params = [];
+                const questMarks = datas
+                    .map(data => this[_transformer](data, { ...option, finalColumns, insert: true }))
+                    .map(data => {
+                    const questMark = new Array();
+                    for (const column of finalColumns) {
+                        const V = data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null;
+                        if (V === null) {
+                            const field = this[_fields][column];
+                            if (field?.uuid) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push('gen_random_uuid()');
+                                        break;
+                                    default:
+                                        questMark.push('UUID()');
+                                        break;
+                                }
+                            }
+                            else if (field?.uuidShort) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push(`encode(uuid_send(gen_random_uuid()::uuid),'base64')`);
+                                        break;
+                                    case DBType.Mysql:
+                                        questMark.push('UUID_SHORT()');
+                                        break;
+                                    default:
+                                        questMark.push('?');
+                                        params.push(V);
+                                        break;
+                                }
+                            }
+                            else {
+                                questMark.push('?');
+                                params.push(V);
+                            }
+                        }
+                        else {
+                            questMark.push('?');
+                            params.push(V);
+                        }
+                    }
+                    return `(${questMark.join(',')})`;
+                });
+                const columnNames = iterate(finalColumns).map(i => this[_fields][i]?.C2()).join(',');
+                const sql = formatDialect(`
+                    ${option.dbType === DBType.Mysql ? '' : 'INSERT OR'} REPLACE INTO
+                    ${tableName}
+                    (${columnNames})
+                    VALUES ${questMarks};
+                `, { dialect: formatDialects[option.dbType] });
+                sqls.push({ sql, params });
+                break;
+            }
+            case InsertMode.Insert: {
+                const finalColumns = new Set();
+                const params = [];
+                const questMarks = datas
+                    .map(data => this[_transformer](data, { ...option, finalColumns, insert: true }))
+                    .map(data => {
+                    const questMark = new Array();
+                    for (const column of finalColumns) {
+                        const V = data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null;
+                        if (V === null) {
+                            const field = this[_fields][column];
+                            if (field?.uuid) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push('gen_random_uuid()');
+                                        break;
+                                    default:
+                                        questMark.push('UUID()');
+                                        break;
+                                }
+                            }
+                            else if (field?.uuidShort) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push(`encode(uuid_send(gen_random_uuid()::uuid),'base64')`);
+                                        break;
+                                    case DBType.Mysql:
+                                        questMark.push('UUID_SHORT()');
+                                        break;
+                                    default:
+                                        questMark.push('?');
+                                        params.push(V);
+                                        break;
+                                }
+                            }
+                            else {
+                                questMark.push('?');
+                                params.push(V);
+                            }
+                        }
+                        else {
+                            questMark.push('?');
+                            params.push(V);
+                        }
+                    }
+                    return `(${questMark.join(',')})`;
+                });
+                const columnNames = iterate(finalColumns).map(i => this[_fields][i]?.C2()).join(',');
+                const sql = formatDialect(`
+                    INSERT INTO
+                    ${tableName}
+                    (${columnNames})
+                    VALUES ${questMarks};
+                `, { dialect: formatDialects[option.dbType] });
+                sqls.push({ sql, params });
+                break;
+            }
+            case InsertMode.InsertWithTempTable: {
+                const tableTemp = `${option?.tableName}_${Math.random()}`.replace(/\./, '');
+                const tableTempESC = tableTemp;
+                sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+                const finalColumns = new Set();
+                const params = [];
+                const questMarks = datas
+                    .map(data => this[_transformer](data, { ...option, finalColumns, insert: true }))
+                    .map(data => {
+                    const questMark = new Array();
+                    for (const column of finalColumns) {
+                        const V = data.hasOwnProperty(column)
+                            ? data[column]
+                            : this[_def] && this[_def].hasOwnProperty(column)
+                                ? this[_def][column]
+                                : null;
+                        if (V === null) {
+                            const field = this[_fields][column];
+                            if (field?.uuid) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push('gen_random_uuid()');
+                                        break;
+                                    default:
+                                        questMark.push('UUID()');
+                                        break;
+                                }
+                            }
+                            else if (field?.uuidShort) {
+                                switch (option.dbType) {
+                                    case DBType.Postgresql:
+                                        questMark.push(`encode(uuid_send(gen_random_uuid()::uuid),'base64')`);
+                                        break;
+                                    case DBType.Mysql:
+                                        questMark.push('UUID_SHORT()');
+                                        break;
+                                    default:
+                                        questMark.push('?');
+                                        params.push(V);
+                                        break;
+                                }
+                            }
+                            else {
+                                questMark.push('?');
+                                params.push(V);
+                            }
+                        }
+                        else {
+                            questMark.push('?');
+                            params.push(V);
+                        }
+                    }
+                    return `(${questMark.join(',')})`;
+                });
+                const _sqls = this._createTable({ tableName: tableTemp, temp: true, columns: Array.from(finalColumns) });
+                sqls.push(..._sqls);
+                const columnNames = iterate(finalColumns).map(i => this[_fields][i]?.C2()).join(',');
+                sqls.push({
+                    sql: formatDialect(`
+                        INSERT INTO
+                        ${tableTemp}
+                        (${columnNames})
+                        VALUES ${questMarks};
+                    `, { dialect: formatDialects[option.dbType] }), params
+                });
+                sqls.push({
+                    sql: formatDialect(`INSERT INTO ${option.tableName} (${columnNames})
+                        SELECT ${columnNames} FROM ${tableTemp};`, { dialect: formatDialects[option.dbType] })
+                });
+                sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+                break;
+            }
+        }
+        return sqls;
+    }
+    insert(option) {
+        option.mode ?? (option.mode = InsertMode.Insert);
+        const isArray = option.data instanceof Array;
+        const datas = option.data instanceof Array ? option.data : [option.data];
+        if (datas.length === 0)
+            return 0n;
+        if (option.sync === SyncMode.Sync) {
+            const fn = () => {
+                const result = excuteSplit(ExcuteSplitMode.SyncTrust, datas, _data => {
+                    const sqls = this._insert(_data, option);
+                    let result = 0n;
+                    for (const { sql, params } of sqls) {
+                        const dd = option.conn.execute(SyncMode.Sync, sql, params);
+                        if (dd.insertId) {
+                            result += BigInt(dd.insertId);
+                        }
+                    }
+                    return result;
+                }, { everyLength: option?.every === true ? 1 : option?.maxDeal });
+                if (isArray)
+                    return result;
+                else
+                    return result[0];
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Sync, fn, option?.conn);
+            }
+        }
+        else if (isArray) {
+            const fn = async () => {
+                const result = await excuteSplit(ExcuteSplitMode.AsyncTrust, datas, async (_data) => {
+                    const sqls = this._insert(_data, option);
+                    let result = 0n;
+                    for (const { sql, params } of sqls) {
+                        const dd = await option.conn.execute(SyncMode.Async, sql, params);
+                        if (dd.insertId) {
+                            result += BigInt(dd.insertId);
+                        }
+                    }
+                    return result;
+                }, { everyLength: option?.every === true ? 1 : option?.maxDeal });
+                return result;
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Async, fn, option?.conn);
+            }
+        }
+        else {
+            const fn = async () => {
+                const result = await excuteSplit(ExcuteSplitMode.AsyncTrust, datas, async (_data) => {
+                    const sqls = this._insert(_data, option);
+                    let result = 0n;
+                    for (const { sql, params } of sqls) {
+                        const dd = await option.conn.execute(SyncMode.Async, sql, params);
+                        if (dd.insertId) {
+                            result += dd.insertId;
+                        }
+                    }
+                    return result;
+                }, { everyLength: 1 });
+                return result[0];
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Async, fn, option?.conn);
+            }
+        }
+    }
+    _update(datas, option) {
+        const sqls = [];
+        const tableName = option?.tableName;
+        const where = `WHEN ${iterate(this[_ids]).map(c => `${this[_fields][c]?.C2()} = ?`).join(' AND ')} THEN ?`;
+        const columnMaps = Object.fromEntries(this[_columnsNoId].map(c => [c, {
+                where: new Array(),
+                params: []
+            }]));
+        const params = [];
+        for (const data of datas) {
+            const ids = this[_ids].map(i => {
+                Throw.if(!data[i], `UPDATE ID NOT EXISTS!${JSON.stringify(data)}`);
+                return data[i];
+            });
+            this[_transformer](data, {
+                ...option,
+                skipId: true,
+                onFieldExists: (K, V) => {
+                    columnMaps[K]?.where.push(where);
+                    columnMaps[K]?.params.push(...ids, V);
+                }
+            });
+        }
+        const sql = formatDialect(`UPDATE ${tableName} SET ${iterate(this[_columnsNoId])
+            .filter(K => columnMaps[K].where.length > 0)
+            .map(K => {
+            params.push(...columnMaps[K].params);
+            return `${this[_fields][K]?.C2()} = CASE ${columnMaps[K].where.join(' ')} ELSE ${this[_fields][K]?.C2()} END`;
+        })
+            .join(',')};`, { dialect: formatDialects[option.dbType] });
+        sqls.push({ sql, params });
+        return sqls;
+    }
+    update(option) {
+        Throw.if(!this[_ids] || this[_ids].length === 0, 'not found id');
+        const datas = option.data instanceof Array ? option.data : [option.data];
+        if (datas.length === 0)
+            return 0;
+        if (option.sync === SyncMode.Sync) {
+            const fn = () => {
+                const result = excuteSplit(ExcuteSplitMode.SyncTrust, datas, _data => {
+                    const sqls = this._update(_data, option);
+                    let result = 0;
+                    for (const { sql, params } of sqls) {
+                        const dd = option.conn.execute(SyncMode.Sync, sql, params);
+                        if (dd.affectedRows) {
+                            result += dd.affectedRows;
+                        }
+                    }
+                    return result;
+                }, { everyLength: option?.maxDeal });
+                return result.length > 0 ? result.reduce((a, b) => a + b) : 0;
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Sync, fn, option?.conn);
+            }
+        }
+        else {
+            const fn = async () => {
+                const result = await excuteSplit(ExcuteSplitMode.AsyncTrust, datas, async (_data) => {
+                    const sqls = this._update(_data, option);
+                    let result = 0;
+                    for (const { sql, params } of sqls) {
+                        const dd = await option.conn.execute(SyncMode.Async, sql, params);
+                        if (dd.affectedRows) {
+                            result += dd.affectedRows;
+                        }
+                    }
+                    return result;
+                }, { everyLength: option?.maxDeal });
+                return result.length > 0 ? result.reduce((a, b) => a + b) : 0;
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Async, 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 = DeleteMode.Common);
+        const tableTemp = `${option?.tableName}_${Math.random()}`.replace(/\./, '');
+        const tableTempESC = tableTemp;
+        const tableNameESC = option?.tableName;
+        if (option.id) {
+            const idName = this[_ids][0];
+            const ids = option.id instanceof Array ? option.id : [option.id];
+            option.where = ids.map(i => ({ [idName]: i }));
+        }
+        const wheres = option.where instanceof Array ? option.where : [option.where];
+        if (wheres.length === 0) {
+            return 0;
+        }
+        const sqls = [];
+        if (option.mode === DeleteMode.Common) {
+            const params = new Array();
+            const whereSql = iterate(wheres).map(where => {
+                return `(
+                    ${Object.entries(where).map(([K, V]) => {
+                    params.push(V);
+                    return `${this[_fields][K]?.C2()} = ?`;
+                }).join(' AND ')}
+                )`;
+            }).join(' OR ');
+            if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                params.unshift(this[_deleteState]);
+                sqls.push({
+                    sql: formatDialect(`
+                    UPDATE ${tableNameESC} SET ${this[_fields][this[_stateFileName]]?.C2()} = ?
+                    WHERE ${whereSql};
+                `, { dialect: formatDialects[option.dbType] }), params
+                });
+            }
+            else {
+                sqls.push({ sql: formatDialect(`DELETE FROM ${tableNameESC} WHERE ${whereSql};`, { dialect: formatDialects[option.dbType] }), params });
+            }
+        }
+        else {
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+            const delWhere = Object.keys(wheres[0]);
+            const _sqls = this._createTable({ tableName: tableTemp, temp: true, columns: delWhere, data: wheres, index: 'all', id: 'none' });
+            sqls.push(..._sqls);
+            switch (option.dbType) {
+                case DBType.Mysql: {
+                    if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                        sqls.push({
+                            sql: formatDialect(`UPDATE ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields][K]?.C2()} = b.${this[_fields][K]?.C2()}`).join(' AND ')}
+                            SET a.${this[_fields][this[_stateFileName]]?.C2()} = ?;`, { dialect: formatDialects[option.dbType] }),
+                            params: [this[_deleteState]]
+                        });
+                    }
+                    else {
+                        sqls.push({
+                            sql: formatDialect(`DELETE a.* FROM ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields][K]?.C2()} = b.${this[_fields][K]?.C2()}`).join(' AND ')};`, { dialect: formatDialects[option.dbType] })
+                        });
+                    }
+                    break;
+                }
+                case DBType.Sqlite:
+                case DBType.SqliteRemote: {
+                    const columnNames = iterate(delWhere).map(K => this[_fields][K]?.C2()).join(',');
+                    if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                        sqls.push({
+                            sql: formatDialect(`UPDATE ${tableNameESC} SET ${this[_fields][this[_stateFileName]]?.C2()} = ?
+                            WHERE (${columnNames}) IN (SELECT ${columnNames} FROM ${tableTempESC});`, { dialect: formatDialects[option.dbType] }),
+                            params: [this[_deleteState]]
+                        });
+                    }
+                    else {
+                        sqls.push({ sql: formatDialect(`DELETE FROM ${tableNameESC} WHERE (${columnNames}) IN (SELECT ${columnNames} FROM ${tableTempESC});`, { dialect: formatDialects[option.dbType] }) });
+                    }
+                    break;
+                }
+            }
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+        }
+        if (option.sync === SyncMode.Sync) {
+            const fn = () => {
+                let result = 0;
+                for (const { sql, params } of sqls) {
+                    const dd = option.conn.execute(SyncMode.Sync, sql, params);
+                    result += dd.affectedRows;
+                }
+                return result;
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Sync, fn, option?.conn);
+            }
+        }
+        else {
+            const fn = async () => {
+                let result = 0;
+                for (const { sql, params } of sqls) {
+                    const dd = await option.conn.execute(SyncMode.Async, sql, params);
+                    result += dd.affectedRows;
+                }
+                return result;
+            };
+            if (option.dbType === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
+                return fn();
+            }
+            else {
+                return option?.dao?.transaction(SyncMode.Async, fn, option?.conn);
+            }
+        }
+    }
+    _template(templateResult, result, error) {
+        switch (templateResult) {
+            case TemplateResult.AssertOne: {
+                Throw.if(!result || result.length !== 1, error);
+                return result[0];
+            }
+            case TemplateResult.NotSureOne: {
+                return result && result.length > 0 ? result[0] ?? null : null;
+            }
+            case TemplateResult.Many: {
+                return result;
+            }
+            case TemplateResult.Count: {
+                return result[0].ct;
+            }
+            case TemplateResult.ManyList: {
+                return new ArrayList(result[0]);
+            }
+        }
+    }
+    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 = SelectMode.Common);
+        option.templateResult ?? (option.templateResult = TemplateResult.AssertOne);
+        option.error ?? (option.error = 'error data!');
+        const tableTemp = `${option?.tableName}_${Math.random()}`.replace(/\./, '');
+        const tableTempESC = tableTemp;
+        const tableNameESC = option?.tableName;
+        if (option.id) {
+            const idName = this[_ids][0];
+            const ids = option.id instanceof Array ? option.id : [option.id];
+            option.where = ids.map(i => ({ [idName]: i }));
+        }
+        const columns = option.templateResult === TemplateResult.Count ? 'COUNT(1) ct' : iterate((option.columns ?? this[_columns])).map((K) => `a.${this[_fields][K]?.C3()}`).join(',');
+        const wheres = option.where instanceof Array ? option.where : [option.where];
+        const sqls = [];
+        let resultIndex = -1;
+        if (option.mode === SelectMode.Common) {
+            const params = new Array();
+            const whereSql = formatDialect(iterate(wheres).map(where => this[_transformer](where, option)).map(where => {
+                return `SELECT ${columns} FROM ${tableNameESC} a WHERE
+                    ${Object.entries(where).map(([K, V]) => {
+                    params.push(V);
+                    return `${this[_fields][K]?.C2()} = ?`;
+                }).join(' AND ')}`;
+            }).join(' UNION ALL '), { dialect: formatDialects[option.dbType] });
+            sqls.push({ sql: whereSql, params });
+            resultIndex = 0;
+        }
+        else {
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+            const delWhere = Object.keys(wheres[0]);
+            const _sqls = this._createTable({ tableName: tableTemp, temp: true, columns: delWhere, data: wheres, index: 'all', id: 'none' });
+            sqls.push(..._sqls);
+            resultIndex = sqls.length;
+            sqls.push({ sql: formatDialect(`SELECT ${columns} FROM ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields][K]?.C2()} = b.${this[_fields][K]?.C2()}`).join(' AND ')};`, { dialect: formatDialects[option.dbType] }) });
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+        }
+        if (option.sync === SyncMode.Sync) {
+            let result;
+            for (let i = 0; i < sqls.length; i++) {
+                if (i === resultIndex) {
+                    result = option.conn.query(SyncMode.Sync, sqls[i]?.sql, sqls[i]?.params);
+                }
+                else {
+                    option.conn.execute(SyncMode.Sync, sqls[i]?.sql, sqls[i]?.params);
+                }
+            }
+            return this._template(option.templateResult, result, option.error);
+        }
+        else {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    let result;
+                    for (let i = 0; i < sqls.length; i++) {
+                        if (i === resultIndex) {
+                            result = await option.conn.query(SyncMode.Async, sqls[i]?.sql, sqls[i]?.params);
+                        }
+                        else {
+                            await option.conn.execute(SyncMode.Async, sqls[i]?.sql, sqls[i]?.params);
+                        }
+                    }
+                    resolve(this._template(option.templateResult, result, option.error));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+    }
+    _select(templateResult, result, def, errorMsg, hump, mapper, mapperIfUndefined) {
+        switch (templateResult) {
+            case SelectResult.R_C_NotSure: {
+                try {
+                    return Object.values(result[0])[0];
+                }
+                catch (error) {
+                    return def;
+                }
+            }
+            case SelectResult.R_C_Assert: {
+                try {
+                    return Object.values(result[0])[0];
+                }
+                catch (error) {
+                    if (def !== undefined)
+                        return def;
+                    Throw.now(errorMsg ?? 'not found data!');
+                }
+            }
+            case SelectResult.R_CS_NotSure: {
+                if (mapper) {
+                    return flatData({ data: result[0], mapper, mapperIfUndefined });
+                }
+                else if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
+                    return C2P2(result[0]) ?? null;
+                }
+                else {
+                    return result[0] ?? null;
+                }
+            }
+            case SelectResult.R_CS_Assert: {
+                const data = result[0];
+                Throw.if(data === null || data === undefined, errorMsg ?? 'not found data!');
+                if (mapper) {
+                    return flatData({ data, mapper, mapperIfUndefined });
+                }
+                else if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
+                    return C2P2(data) ?? null;
+                }
+                else {
+                    return data ?? null;
+                }
+            }
+            case SelectResult.RS_C: {
+                try {
+                    return result.map((r) => Object.values(r)[0]);
+                }
+                catch (error) {
+                    return result;
+                }
+            }
+            case SelectResult.RS_CS: {
+                if (mapper) {
+                    return iterate(result).map((data) => flatData({ data, mapper, mapperIfUndefined })).toArray();
+                }
+                else if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
+                    return iterate(result).map((r) => C2P2(r)).toArray();
+                }
+                else {
+                    return result;
+                }
+            }
+            case SelectResult.RS_C_List: {
+                try {
+                    return new ArrayList(result.map((r) => Object.values(r)[0]));
+                }
+                catch (error) {
+                    return new ArrayList();
+                }
+            }
+            case SelectResult.RS_CS_List: {
+                if (mapper) {
+                    return new ArrayList(iterate(result).map((data) => flatData({ data, mapper, mapperIfUndefined })).toArray());
+                }
+                else if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
+                    return new ArrayList(iterate(result).map((r) => C2P2(r)).toArray());
+                }
+                else {
+                    return new ArrayList();
+                }
+            }
+        }
+    }
+    select(option) {
+        Throw.if(!option.sqlId && !option.sql, 'not found sql!');
+        option.selectResult ?? (option.selectResult = SelectResult.RS_CS);
+        option.defValue ?? (option.defValue = null);
+        if (option.sqlId && globalThis[_resultMap_SQLID][option.sqlId] && !option.mapper) {
+            option.mapper = globalThis[_resultMap_SQLID][option.sqlId];
+        }
+        const _params = Object.assign({}, option.context, option.params);
+        option.sql ?? (option.sql = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: option.context, isCount: option.isCount, ..._params }));
+        const { sql, params } = this._generSql(option.dbType, option.sql, _params);
+        if (option.sync === SyncMode.Sync) {
+            const result = option.conn.query(SyncMode.Sync, sql, params);
+            return this._select(option.selectResult, result, option.defValue, option.errorMsg, option.hump, option.mapper, option.mapperIfUndefined);
+        }
+        else {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    const result = await option.conn.query(SyncMode.Async, sql, params);
+                    resolve(this._select(option.selectResult, result, option.defValue, option.errorMsg, option.hump, option.mapper, option.mapperIfUndefined));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+    }
+    excute(option) {
+        Throw.if(!option.sqlId && !option.sql, 'not found sql!');
+        const _params = Object.assign({}, option.context, option.params);
+        option.sql ?? (option.sql = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: option.context, ..._params }));
+        const { sql, params } = this._generSql(option.dbType, option.sql, _params);
+        if (option.sync === SyncMode.Sync) {
+            const result = option.conn.execute(SyncMode.Sync, sql, params);
+            return result.affectedRows;
+        }
+        else {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    const result = await option.conn.execute(SyncMode.Async, sql, params);
+                    resolve(result.affectedRows);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+    }
+    transaction(option) {
+        if (option.sync === SyncMode.Sync) {
+            return option.dao.transaction(SyncMode.Sync, option.fn);
+        }
+        else {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    const rt = await option.dao.transaction(SyncMode.Async, option.fn);
+                    resolve(rt);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+    }
+    stream() {
+        return new StreamQuery(this, this[_fields], this[_columns]);
+    }
+    page(option) {
+        const result = {
+            sum: {},
+            records: [],
+            size: 0,
+            total: 0
+        };
+        option.pageNumber ?? (option.pageNumber = 1);
+        option.pageSize ?? (option.pageSize = 0);
+        if (option.hump === true || (option.hump === undefined && globalThis[_Hump] === true) && option.sortName) {
+            option.sortName = P2C(option.sortName);
+        }
+        Object.assign(option.params, {
+            limitStart: calc(option.pageNumber).sub(1).mul(option.pageSize).over(),
+            limitEnd: option.pageSize - 0,
+            sortName: option.sortName ?? undefined,
+            sortType: option.sortType ?? undefined
+        });
+        let sql = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: option.context, isCount: false, ...option.params });
+        let sqlSum = '';
+        let sqlCount = '';
+        if (option.sumSelf === true) {
+            sqlSum = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: option.context, isCount: false, isSum: true, ...option.params });
+        }
+        if (option.limitSelf !== true) {
+            if (option.countSelf !== true) {
+            }
+            if (option.pageSize > 0) {
+                sql = `${sql} LIMIT ${option.params['limitStart']}, ${option.pageSize}`;
+            }
+        }
+        if (option.pageSize > 0) {
+            if (option.countSelf === true) {
+                sqlCount = globalThis[_sqlCache].load(this._matchSqlid(`${option.sqlId}_count`), { ctx: option.context, isCount: true, isSum: false, ...option.params });
+            }
+            else {
+                sqlCount = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: option.context, isCount: true, isSum: false, ...option.params });
+            }
+        }
+        if (option.sync === SyncMode.Sync) {
+            if (sqlCount) {
+                result.total = this.select({
+                    ...option,
+                    sql: sqlCount,
+                    sync: SyncMode.Sync,
+                    selectResult: SelectResult.R_C_Assert
+                });
+                result.size = calc(result.total)
+                    .add(option.pageSize - 1)
+                    .div(option.pageSize)
+                    .round(0, 2)
+                    .over();
+            }
+            if (sqlSum) {
+                result.sum = this.select({
+                    ...option,
+                    sql: sqlSum,
+                    sync: SyncMode.Sync,
+                    selectResult: SelectResult.R_CS_Assert
+                });
+            }
+            if (sql) {
+                result.records = this.select({
+                    ...option,
+                    sql,
+                    sync: SyncMode.Sync,
+                    selectResult: SelectResult.RS_CS
+                });
+            }
+            return result;
+        }
+        else {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    if (sqlCount) {
+                        result.total = await this.select({
+                            ...option,
+                            sql: sqlCount,
+                            sync: SyncMode.Async,
+                            selectResult: SelectResult.R_C_Assert
+                        });
+                        result.size = calc(result.total)
+                            .add(option.pageSize ?? 10 - 1)
+                            .div(option.pageSize)
+                            .round(0, 2)
+                            .over();
+                    }
+                    if (sqlSum) {
+                        result.sum = await this.select({
+                            ...option,
+                            sql: sqlSum,
+                            sync: SyncMode.Async,
+                            selectResult: SelectResult.R_CS_Assert
+                        });
+                    }
+                    if (sql) {
+                        result.records = await this.select({
+                            ...option,
+                            sql,
+                            sync: SyncMode.Async,
+                            selectResult: SelectResult.RS_CS
+                        });
+                    }
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+    }
+    /**
+     * 导出数据，可以为EJS-EXCEL直接使用
+     * @param list
+     * @returns
+     */
+    exp(list) {
+        Throw.if(list.length === 0, 'not found data!');
+        const columnTitles = new Array();
+        const keys = this[_fields] ?
+            iterate(Object.entries(this[_fields]))
+                .filter(([K, F]) => (F.id !== true && F.exportable !== false) || (F.id === true && F.exportable === true))
+                .map(([K, F]) => {
+                columnTitles.push(F.comment ?? K);
+                return K;
+            }).toArray()
+            : Object.keys(list[0]).filter(K => !this[_ids]?.includes(K));
+        const title = this[_comment] ?? this[_tableName];
+        const titleSpan = `A1:${ten2Any(keys.length)}1`;
+        const datas = list.map(data => keys.map(k => data[k] ?? ''));
+        return { title, titleSpan, columnTitles, datas };
+    }
+    /**
+     * 导入数据的模板
+     * @returns
+     */
+    imp() {
+        Throw.if(!this[_fields], 'not set fields!');
+        const columnTitles = new Array();
+        const keys = iterate(Object.entries(this[_fields]))
+            .filter(([K, F]) => (F.id !== true && F.exportable !== false) || (F.id === true && F.exportable === true))
+            .map(([K, F]) => {
+            columnTitles.push(F.comment ?? K);
+            return K;
+        }).toArray();
+        const title = this[_comment] ?? this[_tableName];
+        const titleSpan = `A1:${ten2Any(keys.length)}1`;
+        return { title, titleSpan, columnTitles };
+    }
+    init(option) {
+        var _f;
+        const tableES = option.tableName;
+        (_f = option).force ?? (_f.force = false);
+        if (option.dbType === DBType.Sqlite) {
+            if (option?.force) {
+                option.conn.execute(SyncMode.Sync, `DROP TABLE IF EXISTS ${tableES};`);
+            }
+            const lastVersion = this[_sqlite_version] ?? '0.0.1';
+            // 检查表
+            const tableCheckResult = option.conn.pluck(SyncMode.Sync, `SELECT COUNT(1) t FROM sqlite_master WHERE TYPE = 'table' AND name = ?`, [option.tableName]);
+            if (tableCheckResult) {
+                // 旧版本
+                const tableVersion = option.conn.pluck(SyncMode.Sync, 'SELECT ______version v from TABLE_VERSION WHERE ______tableName = ?', [option.tableName]);
+                if (tableVersion && tableVersion < lastVersion) { // 发现需要升级的版本
+                    // 更新版本
+                    const columns = iterate(option.conn.query(SyncMode.Sync, `PRAGMA table_info(${tableES})`))
+                        .filter(c => this[_fields].hasOwnProperty(C2P(c.name, globalThis[_Hump])))
+                        .map(c => c.name)
+                        .join(',');
+                    const rtable = `${option.tableName}_${tableVersion.replace(/\./, '_')}`;
+                    option.conn.execute(SyncMode.Sync, `DROP TABLE IF EXISTS ${rtable};`);
+                    option.conn.execute(SyncMode.Sync, `ALTER TABLE ${tableES} RENAME TO ${rtable};`);
+                    option.conn.execute(SyncMode.Sync, `
+                        CREATE TABLE IF NOT EXISTS ${tableES}(
+                            ${Object.values(this[_fields]).map(K => K[DBType.Sqlite]()).join(',')}
+                            ${this[_ids] && this[_ids].length ? `, PRIMARY KEY (${this[_ids].map(i => this[_fields][i]?.C2()).join(',')})` : ''}
+                        );
+                    `);
+                    if (this[_index] && this[_index].length) {
+                        for (const index of this[_index]) {
+                            option.conn.execute(SyncMode.Sync, `CREATE INDEX ${`${index}_${Math.random()}`.replace(/\./, '')} ON ${tableES} ("${this[_fields][index]?.C2()}");`);
+                        }
+                    }
+                    option.conn.execute(SyncMode.Sync, `INSERT INTO ${tableES} (${columns}) SELECT ${columns} FROM ${rtable};`);
+                    option.conn.execute(SyncMode.Sync, `INSERT INTO ${tableES} (${columns}) SELECT ${columns} FROM ${rtable};`);
+                    option.conn.execute(SyncMode.Sync, `DROP TABLE IF EXISTS ${rtable};`);
+                    // 更新完毕，保存版本号
+                    option.conn.execute(SyncMode.Sync, 'UPDATE TABLE_VERSION SET ______version = ? WHERE ______tableName = ?', [option.tableName, lastVersion]);
+                }
+                else if (!tableVersion) { // 不需要升级情况：没有旧的版本号
+                    option.conn.execute(SyncMode.Sync, 'INSERT INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option.tableName, lastVersion]);
+                }
+            }
+            else { // 表不存在
+                // 创建表
+                option.conn.execute(SyncMode.Sync, `
+                    CREATE TABLE IF NOT EXISTS ${tableES} (
+                        ${Object.values(this[_fields]).map(K => K[DBType.Sqlite]()).join(',')}
+                        ${this[_ids] && this[_ids].length ? `, PRIMARY KEY (${this[_ids].map(i => this[_fields][i]?.C2()).join(',')})` : ''}
+            
+                    );
+                `);
+                if (this[_index] && this[_index].length) {
+                    for (const index of this[_index]) {
+                        option.conn.execute(SyncMode.Sync, `CREATE INDEX ${`${index}_${Math.random()}`.replace(/\./, '')} ON ${tableES} ("${this[_fields][index]?.C2()}");`);
+                    }
+                }
+                option.conn.execute(SyncMode.Sync, 'INSERT OR REPLACE INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option.tableName, lastVersion]);
+            }
+        }
+        else if (option.dbType === DBType.SqliteRemote) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    if (option?.force) {
+                        await option.conn.execute(SyncMode.Async, `DROP TABLE IF EXISTS ${tableES};`);
+                    }
+                    const lastVersion = this[_sqlite_version] ?? '0.0.1';
+                    // 检查表
+                    const tableCheckResult = await option.conn.pluck(SyncMode.Async, `SELECT COUNT(1) t FROM sqlite_master WHERE TYPE = 'table' AND name = ?`, [option.tableName]);
+                    if (tableCheckResult) {
+                        // 旧版本
+                        const tableVersion = await option.conn.pluck(SyncMode.Async, 'SELECT ______version v from TABLE_VERSION WHERE ______tableName = ?', [option.tableName]);
+                        if (tableVersion && tableVersion < lastVersion) { // 发现需要升级的版本
+                            // 更新版本
+                            const columns = iterate(await option.conn.query(SyncMode.Async, `PRAGMA table_info(${tableES})`))
+                                .filter(c => this[_fields].hasOwnProperty(C2P(c.name, globalThis[_Hump])))
+                                .map(c => c.name)
+                                .join(',');
+                            const rtable = `${option.tableName}_${tableVersion.replace(/\./, '_')}`;
+                            await option.conn.execute(SyncMode.Async, `DROP TABLE IF EXISTS ${rtable};`);
+                            await option.conn.execute(SyncMode.Async, `ALTER TABLE ${tableES} RENAME TO ${rtable};`);
+                            await option.conn.execute(SyncMode.Async, `
+                            CREATE TABLE IF NOT EXISTS ${tableES}(
+                                ${Object.values(this[_fields]).map(K => K[DBType.Sqlite]()).join(',')}
+                                ${this[_ids] && this[_ids].length ? `, PRIMARY KEY (${this[_ids].map(i => this[_fields][i]?.C2()).join(',')})` : ''}
+                            );
+                        `);
+                            if (this[_index] && this[_index].length) {
+                                for (const index of this[_index]) {
+                                    await option.conn.execute(SyncMode.Async, `CREATE INDEX ${`${index}_${Math.random()}`.replace(/\./, '')} ON ${tableES} ("${this[_fields][index]?.C2()}");`);
+                                }
+                            }
+                            await option.conn.execute(SyncMode.Async, `INSERT INTO ${tableES} (${columns}) SELECT ${columns} FROM ${rtable};`);
+                            await option.conn.execute(SyncMode.Async, `INSERT INTO ${tableES} (${columns}) SELECT ${columns} FROM ${rtable};`);
+                            await option.conn.execute(SyncMode.Async, `DROP TABLE IF EXISTS ${rtable};`);
+                            // 更新完毕，保存版本号
+                            await option.conn.execute(SyncMode.Async, 'UPDATE TABLE_VERSION SET ______version = ? WHERE ______tableName = ?', [option.tableName, lastVersion]);
+                        }
+                        else if (!tableVersion) { // 不需要升级情况：没有旧的版本号
+                            await option.conn.execute(SyncMode.Async, 'INSERT INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option.tableName, lastVersion]);
+                        }
+                    }
+                    else { // 表不存在
+                        // 创建表
+                        await option.conn.execute(SyncMode.Async, `
+                        CREATE TABLE IF NOT EXISTS ${tableES}(
+                            ${Object.values(this[_fields]).map(K => K[DBType.Sqlite]()).join(',')}
+                            ${this[_ids] && this[_ids].length ? `, PRIMARY KEY (${this[_ids].map(i => this[_fields][i]?.C2()).join(',')})` : ''}
+                        );
+                    `);
+                        if (this[_index] && this[_index].length) {
+                            for (const index of this[_index]) {
+                                await option.conn.execute(SyncMode.Async, `CREATE INDEX ${`${index}_${Math.random()}`.replace(/\./, '')} ON ${option.tableName} ("${this[_fields][index]?.C2()}");`);
+                            }
+                        }
+                        await option.conn.execute(SyncMode.Async, 'INSERT OR REPLACE INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option.tableName, lastVersion]);
+                    }
+                    resolve();
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+    }
+    close(option) {
+        delete globalThis[_dao][option.dbType][option.dbName];
+        if (option?.sync === SyncMode.Async) {
+            return option.dao.close(SyncMode.Async);
+        }
+        else if (option?.sync === SyncMode.Sync) {
+            option.dao.close(SyncMode.Sync);
+        }
+    }
+    /**
+    #创建表
+    ** `tableName` 表名称
+    ** `temp` 是否是临时表，默认true
+    ** `columns` 字符串数组，默认是当前实体类全部字段，通过`columns` 可以创建部分字段临时表
+    ** `id` 表的主键设置 4种：
+    1. `auto`: `columns`中已经在当前实体类配置的ID作为主键 `默认`
+    2. `all`: `columns`中所有字段全部当主键
+    3. `none`: 没有主键
+    4. 自定义字段名称：字符串数组
+    ** `index` 表的索引，设置方式同ID
+     */
+    _createTable({ tableName, temp = true, columns, data, id = 'auto', index = 'auto', dbType } = {}) {
+        const sqls = [];
+        columns = columns || this[_columns];
+        let ids;
+        if (id === 'auto') {
+            ids = this[_ids]?.filter(i => columns?.includes(i));
+        }
+        else if (id === 'all') {
+            ids = columns;
+        }
+        else if (id === 'none') {
+            ids = undefined;
+        }
+        else {
+            ids = id;
+        }
+        let indexs;
+        if (index === 'auto') {
+            indexs = this[_index]?.filter(i => columns?.includes(i));
+        }
+        else if (index === 'all') {
+            indexs = columns;
+        }
+        else if (index === 'none') {
+            indexs = undefined;
+        }
+        else {
+            indexs = index;
+        }
+        tableName = tableName ?? this[_tableName];
+        switch (dbType) {
+            case DBType.Mysql: {
+                let sql = formatDialect(`CREATE ${temp === 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]?.C2()).join(',')})  USING BTREE ` : ''}
+                    ${indexs && indexs.length ? `,${indexs.map(i => `KEY ${this[_fields][i]?.C2()} (${this[_fields][i]?.C2()})`).join(',')} ` : ''}
+                ) ENGINE=MEMORY;`, { dialect: mysql });
+                sqls.push({ sql });
+                if (data && data.length > 0) {
+                    const params = [];
+                    let first = true;
+                    sql = formatDialect(`INSERT INTO ${tableName} (${columns.map(c => this[_fields][c]?.C2()).join(',')})
+                    ${(data).map(d => {
+                        const r = `SELECT ${Object.entries(d).map(([K, V]) => {
+                            params.push(V);
+                            return `? ${first ? this[_fields][K]?.C2() : ''}`;
+                        }).join(',')}`;
+                        first = false;
+                        return r;
+                    }).join(' UNION ALL ')}`, { dialect: mysql });
+                    sqls.push({ sql, params });
+                }
+                break;
+            }
+            case DBType.Sqlite:
+            case DBType.SqliteRemote: {
+                let sql = formatDialect(`CREATE ${temp === 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]?.C2()).join(',')}) ` : ''}
+                );`, { dialect: sqlite });
+                sqls.push({ sql });
+                if (indexs) {
+                    for (const index of indexs) {
+                        sql = formatDialect(`CREATE INDEX ${`${index}_${Math.random()}`.replace(/\./, '')} ON ${tableName} (${this[_fields][index]?.C2()});`, { dialect: sqlite });
+                        sqls.push({ sql });
+                    }
+                }
+                if (data && data.length > 0) {
+                    const params = [];
+                    let first = true;
+                    sql = formatDialect(`INSERT INTO ${tableName} (${columns.map(c => this[_fields][c]?.C2()).join(',')})
+                    ${(data).map(d => {
+                        const r = `SELECT ${Object.entries(d).map(([K, V]) => {
+                            params.push(V);
+                            return `? ${first ? this[_fields][K]?.C2() : ''}`;
+                        }).join(',')}`;
+                        first = false;
+                        return r;
+                    }).join(' UNION ALL ')}`, { dialect: sqlite });
+                    sqls.push({ sql, params });
+                }
+                break;
+            }
+        }
+        return sqls;
+    }
+    _matchSqlid(sqlid) {
+        sqlid ?? (sqlid = '');
+        if (sqlid.includes('.'))
+            return [sqlid];
+        else
+            return [`${this[_tableName]}.${sqlid}`, `${this[_className]}.${sqlid}`, `${this[_ClassName]}.${sqlid}`, `${this[_vueName]}.${sqlid}`];
+    }
+    _setParam(v, ps) {
+        if (v instanceof Array) {
+            ps.push(...v);
+            return v.map(i => '?').join(',');
+        }
+        else {
+            ps.push(v);
+            return '?';
+        }
+    }
+    _generSql(dbType, _sql, _params) {
+        const params = [];
+        const sql = formatDialect(_sql?.replace(/\:(\w+)/g, (txt, key) => {
+            let V = LGet(_params, key);
+            if (V !== undefined) {
+                return this._setParam(V, params);
+            }
+            const _key = C2P(key);
+            V = LGet(_params, _key);
+            if (V !== undefined) {
+                return this._setParam(V, params);
+            }
+            const __key = P2C(key);
+            V = LGet(_params, __key);
+            if (V !== undefined) {
+                return this._setParam(V, params);
+            }
+            return txt;
+        }), { dialect: formatDialects[dbType] });
+        return { params, sql };
+    }
+}
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "insert", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "update", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "delete", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "template", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "select", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "excute", null);
+__decorate([
+    P(true),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "transaction", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "page", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "init", null);
+__decorate([
+    P(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], SqlService.prototype, "close", null);
+/** 是否进行下一个动作 */
+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 StreamQuery {
+    constructor(service, __fields, __columns) {
+        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._distinct = false;
+        this._columns = [];
+        this._updateColumns = [];
+        this._groups = [];
+        this._orders = [];
+        this._startRow = 0;
+        this._pageSize = 0;
+        this._prefix = parseInt(`${Math.random() * 1000}`);
+        this._service = service;
+        this[_fields] = __fields;
+        this[_columns] = __columns;
+    }
+    /** 将当前stream重置 */
+    reset() {
+        this._index = 0;
+        this._wheres.length = 0;
+        this._param = {};
+        this._paramKeys = {};
+        this._pageSize = 0;
+        this._startRow = 0;
+        this._orders.length = 0;
+        this._groups.length = 0;
+        this._columns.length = 0;
+        this._updateColumns.length = 0;
+        return this;
+    }
+    // #region 条件
+    /** 为下次链条执行提供条件判断：非异步方法跳过，异步方法不执行并返回默认值 */
+    if(condition) {
+        this.if_proceed = condition;
+        return this;
+    }
+    eqs(keys, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this.__(keys, value, '=', { paramName, skipEmptyString, breakExcuteIfSkip }); }
+    eq(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._(key, value, '=', { paramName, skipEmptyString, breakExcuteIfSkip }); }
+    eqT(t, { name: paramName = '', breakExcuteIfSkip = false } = {}) {
+        let exe = false;
+        if (t) {
+            t = this._service[_transformer](t, {
+                skipNull: true,
+                skipUndefined: true,
+                skipEmptyString: true
+            });
+            const keys = Object.keys(t);
+            if (keys.length > 0) {
+                if (paramName && this._paramKeys[paramName]) {
+                    for (const [key, pname] of Object.entries(this._paramKeys[paramName])) {
+                        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 ${this[_fields][String(key)]?.C2()} = :${pkey} `);
+                        this._param[pkey] = value;
+                        if (paramName) {
+                            paramKeys[key] = pkey;
+                        }
+                    }
+                    if (paramName) {
+                        this._paramKeys[paramName] = paramKeys;
+                    }
+                }
+                exe = true;
+            }
+        }
+        if (breakExcuteIfSkip === true && exe === false) {
+            this.if_exec = false;
+        }
+        return this;
+    }
+    notEq(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._(key, value, '<>', { paramName, skipEmptyString, breakExcuteIfSkip }); }
+    eqWith(key1, key2) { return this._key(key1, key2, '='); }
+    notEqWith(key1, key2) { return this._key(key1, key2, '<>'); }
+    regexp(key, regexp, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
+    notRegexp(key, regexp, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, not: 'NOT', breakExcuteIfSkip }); }
+    /** (key1 << 8) + key2 = value */
+    shiftEq(key1, key2, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._shift(key1, key2, value, '=', { paramName, breakExcuteIfSkip }); }
+    /** (key1 << 8) + key2 <> value */
+    shiftNotEq(key1, key2, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._shift(key1, key2, value, '<>', { paramName, breakExcuteIfSkip }); }
+    grate(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '>', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
+    grateEq(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '>=', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
+    grateWith(key1, key2) { return this._key(key1, key2, '>'); }
+    grateEqWith(key1, key2) { return this._key(key1, key2, '>='); }
+    less(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '<', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
+    lessEq(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '<=', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
+    lessWith(key1, key2) { return this._key(key1, key2, '<'); }
+    lessEqWith(key1, key2) { return this._key(key1, key2, '<='); }
+    like(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfSkip }); }
+    notLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfSkip }); }
+    leftLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfSkip }); }
+    notLeftLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfSkip }); }
+    rightLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfSkip }); }
+    notRightLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfSkip }); }
+    PreciseLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfSkip }); }
+    notPreciseLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
+    glob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfSkip, op: 'GLOB' }); }
+    notGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
+    leftGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfSkip, op: 'GLOB' }); }
+    notLeftGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
+    rightGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfSkip, op: 'GLOB' }); }
+    notRightGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
+    PreciseGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfSkip, op: 'GLOB' }); }
+    notPreciseGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
+    in(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._in(key, value, { paramName, breakExcuteIfSkip }); }
+    notIn(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._in(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
+    in2(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._in2(key, value, { paramName, breakExcuteIfSkip }); }
+    notIn2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._in2(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
+    isNULL(key) { return this._null(key); }
+    isNotNULL(key) { return this._null(key, 'NOT'); }
+    between(key, value1, value2, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._between(key, value1, value2, { paramName, skipEmptyString, breakExcuteIfSkip }); }
+    notBetween(key, value1, value2, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._between(key, value1, value2, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
+    pow(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, value, { paramName, breakExcuteIfSkip }); }
+    notPow(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, value, { paramName, not: 'NOT', breakExcuteIfSkip }); }
+    powWith(key, values, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, breakExcuteIfSkip }); }
+    notPowWith(key, values, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, not: 'NOT', breakExcuteIfSkip }); }
+    /** MATCH(key1, key2, key3) AGAINST (value) */
+    match(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip }); }
+    /** NOT MATCH(key1, key2, key3) AGAINST (value) */
+    notMatch(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
+    /** MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE*/
+    matchBoolean(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, append: 'IN BOOLEAN MODE' }); }
+    /** NOT MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE */
+    notMatchBoolean(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, not: 'NOT', append: 'IN BOOLEAN MODE' }); }
+    /** MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
+    matchQuery(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, append: 'WITH QUERY EXPANSION' }); }
+    /** NOT MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
+    notMatchQuery(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, not: 'NOT', append: 'WITH QUERY EXPANSION' }); }
+    includes(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._includes(key, value, { paramName, skipEmptyString, breakExcuteIfSkip }); }
+    notIncludes(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._includes(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
+    and(fn) {
+        if (fn instanceof StreamQuery) {
+            this._andQuerys.push(fn);
+        }
+        else {
+            const stream = new StreamQuery(this._service, this[_fields], this[_columns]);
+            const ret = fn(stream);
+            if (ret !== false) {
+                this._andQuerys.push(stream);
+            }
+        }
+        return this;
+    }
+    or(fn) {
+        if (fn instanceof StreamQuery) {
+            this._andQuerys.push(fn);
+        }
+        else {
+            const stream = new StreamQuery(this._service, this[_fields], this[_columns]);
+            const ret = fn(stream);
+            if (ret !== false) {
+                this._orQuerys.push(stream);
+            }
+        }
+        return this;
+    }
+    groupBy(...keys) { this._groups.push(...keys.map(key => `${this[_fields][String(key)]?.C2()}`)); return this; }
+    groupBy2(...keys) { this._groups.push(...keys.map(key => `${this[_fields][String(key)]?.C2()}`)); return this; }
+    asc(...keys) { this._orders.push(...keys.map(key => `${this[_fields][String(key)]?.C2()} ASC`)); return this; }
+    asc2(...keys) { this._orders.push(...keys.map(key => `${this[_fields][String(key)]?.C2()} ASC`)); return this; }
+    desc(...keys) { this._orders.push(...keys.map(key => `${this[_fields][String(key)]?.C2()} DESC`)); return this; }
+    desc2(...keys) { this._orders.push(...keys.map(key => `${this[_fields][String(key)]?.C2()} ASC`)); 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; }
+    distinct(on = true) { this._distinct = on; return this; }
+    countDistinct(key, countName) { this._columns.push(`COUNT(DISTINCT ${this[_fields][String(key)]?.C2()}) ${countName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
+    count(countName) { this._columns.push(`COUNT(1) ${countName ?? 'ct'}`); return this; }
+    sum(key, legName, distinct) { this._columns.push(`SUM(${distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}) ${legName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
+    avg(key, legName, distinct) { this._columns.push(`AVG(${distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}) ${legName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
+    max(key, legName, distinct) { this._columns.push(`MAX(${distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}) ${legName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
+    min(key, legName, distinct) { this._columns.push(`MIN(${distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}) ${legName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
+    groupConcat(key, param) {
+        this._columns.push(`GROUP_CONCAT(
+            ${param && param.distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}
+            ${param && param.asc && param.asc.length > 0 ? `ORDER BY ${param.asc.map(i => `${this[_fields][String(i)]?.C2()} ASC`)} ` : ''}
+            ${param && param.desc && param.desc.length > 0 ? `${param && param.asc && param.asc.length > 0 ? '' : 'ORDER BY'} ${param.desc.map(i => `${this[_fields][String(i)]?.C2()} DESC`)} ` : ''}
+            SEPARATOR '${param && param.separator || ','}'
+            ) ${param && param.groupName || `${this[_fields][String(key)]?.C2()}`}`);
+        return this;
+    }
+    select(...key) { this._columns.push(...(key.map(k => this[_fields][String(k)].C3()))); return this; }
+    select2(sql, param) { this._columns.push(`${sql}`); Object.assign(this._param, param); return this; }
+    update(key, value) { this._updates ?? (this._updates = {}); this._updates[this[_fields][String(key)]?.C2()] = value; return this; }
+    update2(sql, param) { this._updateColumns.push(sql); Object.assign(this._param, param); return this; }
+    updateT(t) {
+        this._updates ?? (this._updates = {});
+        for (const [key, value] of Object.entries(t)) {
+            this._updates[this[_fields][String(key)]?.C2()] = value;
+        }
+        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(` ${this[_fields][String(key)]?.C2()} = REPLACE(${this[_fields][String(key)]?.C2()}, :${pkey1}, :${pkey2}) `);
+        this._param[pkey1] = valueToFind;
+        this._param[pkey2] = valueToReplace;
+        return this;
+    }
+    excuteSelect(option) {
+        option ?? (option = {});
+        option.sync ?? (option.sync = SyncMode.Async);
+        option.selectResult ?? (option.selectResult = SelectResult.RS_CS);
+        const { where, params } = this._where();
+        let sql = `
+            SELECT
+            ${this._distinct ? 'DISTINCT' : ''} ${this._columns && this._columns.length > 0 ? this._columns.join(',') : this[_columns].map(key => this[_fields][String(key)]?.C3()).join(',')}
+            FROM ${option.tableName ?? this._service[_tableName]}
+            ${where ? ' WHERE ' : ''}
+            ${where}
+            ${this._groups.length > 0 ? `GROUP BY ${this._groups.join(',')} ` : ''}
+            ${this._orders.length > 0 ? `ORDER BY ${this._orders.join(',')} ` : ''}
+        `;
+        if (this._startRow && this._pageSize) {
+            sql += `LIMIT ${this._startRow}, ${this._pageSize}`;
+        }
+        else if (this._startRow) {
+            sql += `LIMIT ${this._startRow}`;
+        }
+        if (option.sync === SyncMode.Async) {
+            switch (option.selectResult) {
+                case SelectResult.RS_CS: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.RS_CS, sql, params });
+                case SelectResult.RS_C: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.RS_C, sql, params });
+                case SelectResult.RS_CS_List: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.RS_CS_List, sql, params });
+                case SelectResult.RS_C_List: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.RS_C_List, sql, params });
+                case SelectResult.R_CS_Assert: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.R_CS_Assert, sql, params });
+                case SelectResult.R_C_Assert: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.R_C_Assert, sql, params });
+                case SelectResult.R_CS_NotSure: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.R_CS_NotSure, sql, params });
+                case SelectResult.R_C_NotSure: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.R_C_NotSure, sql, params });
+            }
+        }
+        else {
+            switch (option.selectResult) {
+                case SelectResult.RS_CS: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.RS_CS, sql, params });
+                case SelectResult.RS_C: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.RS_C, sql, params });
+                case SelectResult.RS_CS_List: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.RS_CS_List, sql, params });
+                case SelectResult.RS_C_List: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.RS_C_List, sql, params });
+                case SelectResult.R_CS_Assert: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.R_CS_Assert, sql, params });
+                case SelectResult.R_C_Assert: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.R_C_Assert, sql, params });
+                case SelectResult.R_CS_NotSure: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.R_CS_NotSure, sql, params });
+                case SelectResult.R_C_NotSure: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.R_C_NotSure, sql, params });
+            }
+        }
+    }
+    excutePage(option) {
+        option ?? (option = {});
+        option.sync ?? (option.sync = SyncMode.Async);
+        const { where, params } = this._where();
+        const result = {
+            records: [],
+            size: 0,
+            total: 0
+        };
+        let sql = `
+            SELECT
+            ${this._distinct ? 'DISTINCT' : ''} ${this._columns && this._columns.length > 0 ? this._columns.join(',') : this[_columns].map(key => this[_fields][String(key)]?.C3()).join(',')}
+            FROM ${option.tableName ?? this._service[_tableName]}
+            ${where ? ' WHERE ' : ''}
+            ${where}
+            ${this._groups.length > 0 ? `GROUP BY ${this._groups.join(',')} ` : ''}
+            ${this._orders.length > 0 ? `ORDER BY ${this._orders.join(',')} ` : ''}
+        `;
+        if (this._startRow && this._pageSize) {
+            sql += `LIMIT ${this._startRow}, ${this._pageSize}`;
+        }
+        else if (this._startRow) {
+            sql += `LIMIT ${this._startRow}`;
+        }
+        const sqlCount = `
+            SELECT COUNT(1)
+            FROM ${option.tableName ?? this._service[_tableName]}
+            ${where ? ' WHERE ' : ''}
+            ${where}
+            ${this._groups.length > 0 ? `GROUP BY ${this._groups.join(',')} ` : ''}
+            ${this._orders.length > 0 ? `ORDER BY ${this._orders.join(',')} ` : ''}
+        `;
+        if (option.sync === SyncMode.Sync) {
+            result.total = this._service.select({
+                ...option,
+                params,
+                sql: sqlCount,
+                sync: SyncMode.Sync,
+                selectResult: SelectResult.R_C_Assert
+            });
+            result.size = calc(result.total)
+                .add(this._pageSize - 1)
+                .div(this._pageSize)
+                .round(0, 2)
+                .over();
+            result.records = this._service.select({
+                ...option,
+                params,
+                sql,
+                sync: SyncMode.Sync,
+                selectResult: SelectResult.RS_CS
+            });
+            return result;
+        }
+        else {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    result.total = await this._service.select({
+                        ...option,
+                        params,
+                        sql: sqlCount,
+                        sync: SyncMode.Async,
+                        selectResult: SelectResult.R_C_Assert
+                    });
+                    result.size = calc(result.total)
+                        .add(this._pageSize - 1)
+                        .div(this._pageSize)
+                        .round(0, 2)
+                        .over();
+                    result.records = await this._service.select({
+                        ...option,
+                        params,
+                        sql,
+                        sync: SyncMode.Async,
+                        selectResult: SelectResult.RS_CS
+                    });
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+    }
+    excuteUpdate(option) {
+        option ?? (option = {});
+        option.sync ?? (option.sync = SyncMode.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 ${option.tableName ?? this._service[_tableName]} SET ${sets.join(',')}
+            ${where ? ' WHERE ' : ''}
+            ${where}
+            `;
+            if (option.sync === SyncMode.Async) {
+                return this._service.excute({ ...option, sync: SyncMode.Async, sql, params });
+            }
+            else {
+                return this._service.excute({ ...option, sync: SyncMode.Sync, sql, params });
+            }
+        }
+        else {
+            return 0;
+        }
+    }
+    excuteDelete(option) {
+        option ?? (option = {});
+        option.sync ?? (option.sync = SyncMode.Async);
+        const { where, params } = this._where();
+        const sql = `DELETE FROM ${option.tableName ?? this._service[_tableName]}
+            ${where ? ' WHERE ' : ''}
+            ${where}
+        `;
+        if (option.sync === SyncMode.Async) {
+            return this._service.excute({ ...option, sync: SyncMode.Async, sql, params });
+        }
+        else {
+            return this._service.excute({ ...option, sync: SyncMode.Sync, sql, params });
+        }
+    }
+    _where() {
+        const wheres = new Array();
+        const sql = this._wheres.join(' ');
+        if (sql) {
+            wheres.push(`(${sql.replace(/^and|^or/i, '')})`);
+        }
+        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 = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (value === null
+            || value === undefined
+            || (emptyString(`${value ?? ''}`) && skipEmptyString === true)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName]] = value;
+        }
+        else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} ${not} ${op} :${pkey} `);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
+            }
+        }
+        return this;
+    }
+    __(keys, value, op, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (value === null
+            || value === undefined
+            || (emptyString(`${value ?? ''}`) && skipEmptyString === true)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName]] = value;
+        }
+        else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND (${keys.map(key => `${this[_fields][String(key)]?.C2()} ${not} ${op} :${pkey} `).join(' OR ')})`);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
+            }
+        }
+        return this;
+    }
+    _null(key, not = '') {
+        this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} IS ${not} NULL`);
+        return this;
+    }
+    _key(key1, key2, op, not = '') {
+        this._wheres.push(`AND ${this[_fields][String(key1)]?.C2()} ${not} ${op} ${this[_fields][String(key2)]?.C2()} `);
+        return this;
+    }
+    _between(key, value1, value2, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (value1 === null
+            || value1 === undefined
+            || (emptyString(`${value1 ?? ''}`) && skipEmptyString === true)
+            || value2 === null
+            || value2 === undefined
+            || (emptyString(`${value2 ?? ''}`) && skipEmptyString === true)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName && this._paramKeys[paramName]) {
+            this._param[this._paramKeys[paramName][0]] = value1;
+            this._param[this._paramKeys[paramName][1]] = value2;
+        }
+        else {
+            const [pkey1, pkey2] = [`p${this._prefix}${this._index++}`, `p${this._prefix}${this._index++}`];
+            this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} ${not} BETWEEN :${pkey1} AND :${pkey2}`);
+            this._param[pkey1] = value1;
+            this._param[pkey2] = value2;
+            if (paramName) {
+                this._paramKeys[paramName] = [pkey1, pkey2];
+            }
+        }
+        return this;
+    }
+    _in(key, value, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (value && value.length > 0 && skipEmptyString === true) {
+            value = value.filter(v => !emptyString(`${v ?? ''}`));
+        }
+        if (value && value.length > 0) {
+            if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+                this._param[this._paramKeys[paramName]] = value;
+            }
+            else {
+                const pkey = `p${this._prefix}${this._index++}`;
+                this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} ${not} IN (:${pkey}) `);
+                this._param[pkey] = value;
+                if (paramName) {
+                    this._paramKeys[paramName] = pkey;
+                }
+            }
+        }
+        else if (breakExcuteIfSkip !== true) {
+            this.if_exec = false;
+        }
+        return this;
+    }
+    _in2(key, value, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        const skip = emptyString(`${value ?? ''}`) && skipEmptyString === true;
+        if (!skip) {
+            if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+                this._param[this._paramKeys[paramName]] = value;
+            }
+            else {
+                const pkey = `p${this._prefix}${this._index++}`;
+                this._wheres.push(`AND :${pkey} ${not} IN (${key.map(k => this[_fields][String(k)]?.C2()).join(',')}) `);
+                this._param[pkey] = value;
+                if (paramName) {
+                    this._paramKeys[paramName] = pkey;
+                }
+            }
+        }
+        else if (breakExcuteIfSkip !== true) {
+            this.if_exec = false;
+        }
+        return this;
+    }
+    _shift(key1, key2, value, op, { not = '', paramName = '', breakExcuteIfSkip = false } = {}) {
+        if (value === null
+            || value === undefined
+            || emptyString(`${value ?? ''}`)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName]] = value;
+        }
+        else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND (${this[_fields][String(key1)]?.C2()} << 8) + ${this[_fields][String(key2)]?.C2()} ${not} ${op} :${pkey} `);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
+            }
+        }
+        return this;
+    }
+    _match(value, keys, { paramName = '', not = '', append = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (value === null
+            || value === undefined
+            || emptyString(`${value ?? ''}`)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName]] = value;
+        }
+        else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND ${not} MATCH(${keys.map(key => this[_fields][String(key)]?.C2()).join(',')}) AGAINST (:${pkey} ${append ?? ''})`);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
+            }
+        }
+        return this;
+    }
+    _pow(key, value, { not = '', paramName = '', breakExcuteIfSkip = false } = {}) {
+        if (value === null
+            || value === undefined
+            || emptyString(`${value ?? ''}`)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName]] = value;
+        }
+        else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND ${not} POW(2, ${this[_fields][String(key)]?.C2()}) & :${pkey}`);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
+            }
+        }
+        return this;
+    }
+    _like(key, value, { not = '', left = '', right = '', paramName = '', op = 'LIKE', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (value === null
+            || value === undefined
+            || (emptyString(`${value ?? ''}`) && skipEmptyString === true)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName]] = value;
+        }
+        else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} ${not} ${op} CONCAT('${left}', :${pkey}, '${right}') `);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
+            }
+        }
+        return this;
+    }
+    _includes(key, value, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = true } = {}) {
+        if (value === null
+            || value === undefined
+            || (emptyString(`${value ?? ''}`) && skipEmptyString === true)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName]] = value;
+        }
+        else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND LOCATE(${this[_fields][String(key)]?.C2()}, :${pkey}) ${not ? '=' : '>'}  0`);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
+            }
+        }
+        return this;
+    }
+}
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Boolean]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "if", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "eqs", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "eq", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "eqT", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notEq", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "eqWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notEqWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "regexp", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notRegexp", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Number, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "shiftEq", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Number, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "shiftNotEq", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "grate", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "grateEq", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "grateWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "grateEqWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "less", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "lessEq", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "lessWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "lessEqWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "like", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "leftLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notLeftLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "rightLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notRightLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "PreciseLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notPreciseLike", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "glob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "leftGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notLeftGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "rightGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notRightGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "PreciseGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notPreciseGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "in", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notIn", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "in2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notIn2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "isNULL", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "isNotNULL", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "between", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notBetween", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "pow", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notPow", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "powWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notPowWith", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "match", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notMatch", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "matchBoolean", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notMatchBoolean", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "matchQuery", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notMatchQuery", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "includes", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notIncludes", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "and", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "or", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "groupBy", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "groupBy2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "asc", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "asc2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "desc", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "desc2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Number]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "limit", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Number]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "page", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "distinct", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "countDistinct", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "count", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Boolean]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "sum", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Boolean]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "avg", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Boolean]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "max", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Boolean]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "min", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Object)
+], StreamQuery.prototype, "groupConcat", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "select", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "select2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "update", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "update2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "updateT", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "replace", null);
+__decorate([
+    IF_EXEC(null),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], StreamQuery.prototype, "excuteSelect", null);
+__decorate([
+    IF_EXEC(null),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], StreamQuery.prototype, "excutePage", null);
+__decorate([
+    IF_EXEC(0),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], StreamQuery.prototype, "excuteUpdate", null);
+__decorate([
+    IF_EXEC(0),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], StreamQuery.prototype, "excuteDelete", null);
+/**
+ 获取REDIS客户端，
+ # [查看库的API](https://github.com/redis/ioredis?tab=readme-ov-file)
+ # [REDIS API](http://doc.redisfans.com/)
+ REDIS 的API 可以直接用，将方法名转为小写
+ ```
+ // 设置<Redis>来获得代码提示
+ getRedisDB<Redis>('').exists(?)
+ ```
+ */
+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;
+            }
+        };
+    };
+}
+class MUParser {
+    constructor(modelName, file) {
+        this.linNumber = 0;
+        this.lastLine = '';
+        this.lastlastLine = '';
+        this.status = 0;
+        this.lineSeparator = '\n';
+        this.modelName = modelName;
+        this.files = file.replace(/\r/g, '').split(this.lineSeparator);
+        this.skipHeader();
+    }
+    next() {
+        let sqlId = this.readSqlId();
+        if (this.status === MUParser.END) {
+            return null;
+        }
+        // 去掉可能的尾部空格
+        sqlId = sqlId.trim();
+        this.skipComment();
+        if (this.status === MUParser.END) {
+            return null;
+        }
+        const sql = this.readSql();
+        return [`${this.modelName}.${sqlId}`, sql];
+    }
+    skipHeader() {
+        while (true) {
+            const line = this.nextLine();
+            if (this.status === MUParser.END) {
+                return;
+            }
+            if (line.startsWith('===')) {
+                return;
+            }
+        }
+    }
+    nextLine() {
+        const line = this.files[this.linNumber];
+        this.linNumber++;
+        if (line === undefined) {
+            this.status = MUParser.END;
+        }
+        // 保存最后读的俩行
+        this.lastlastLine = this.lastLine;
+        this.lastLine = line;
+        return line;
+    }
+    readSqlId() {
+        return this.lastlastLine;
+    }
+    skipComment() {
+        let findComment = false;
+        while (true) {
+            let line = this.nextLine();
+            if (this.status === MUParser.END) {
+                return;
+            }
+            line = line.trim();
+            if (!findComment && line.length === 0) {
+                continue;
+            }
+            if (line.startsWith('*')) {
+                // 注释符号
+                findComment = true;
+                continue;
+            }
+            else {
+                if (line.length === 0) {
+                    continue;
+                }
+                else if (line.startsWith('```') || line.startsWith('~~~')) {
+                    // 忽略以code block开头的符号
+                    continue;
+                }
+                else {
+                    // 注释结束
+                    return;
+                }
+            }
+        }
+    }
+    readSql() {
+        const list = [];
+        list.push(this.lastLine);
+        while (true) {
+            const line = this.nextLine();
+            if (this.status === MUParser.END) {
+                return this.getBuildSql(list);
+            }
+            if (line.startsWith('===')) {
+                // 删除下一个sqlId表示
+                list.pop();
+                return this.getBuildSql(list);
+            }
+            list.push(line);
+        }
+    }
+    getBuildSql(list) {
+        const sb = [];
+        for (const str of list) {
+            const s = str.trim();
+            if (s.startsWith('```') || s.startsWith('~~~')) {
+                // 忽略以code block开头的符号
+                continue;
+            }
+            sb.push(str);
+        }
+        return sb.join(this.lineSeparator);
+    }
+}
+MUParser.END = 1;