baja-lite 1.0.2 → 1.0.3

package/src/sql.ts

@@ -0,0 +1,4021 @@
+import 'reflect-metadata';
+import { Throw } from './error';
+import tslib from 'tslib';
+import Sqlstring from 'sqlstring';
+import iterare from 'iterare';
+import { emptyString } from './string';
+import pino from 'pino';
+import { excuteSplit, ExcuteSplitMode, sleep } from './fn';
+import { add } from './math';
+import mustache, { PartialsOrLookupFn } from 'mustache';
+
+// #region 常量
+const _daoDBName = Symbol('dbName');
+const _tableName = Symbol('tableName');
+const _ids = Symbol('ids');
+const _columns = Symbol('columns');
+const _columnsNoId = Symbol('columnsNoId');
+const _fields = Symbol('fields');
+const _stateFileName = Symbol('stateFileName');
+const _deleteState = Symbol('deleteState');
+const _transformer = Symbol('transformer');
+const _index = Symbol('index');
+const _def = Symbol('def');
+const _sqlCache = Symbol('sqlMap');
+const _dao = Symbol('dao');
+const _primaryDB = Symbol('primaryDB');
+const _dbType = Symbol('dbType');
+const _sqlite_version = Symbol('sqlite_version');
+const _daoConnection = Symbol('daoConnection');
+const _inTransaction = Symbol('inTransaction');
+const _daoDB = Symbol('daoDB');
+const _sqliteRemoteName = Symbol('sqliteRemoteName');
+const _SqlOption = Symbol('SqlOption');
+const _GlobalSqlOption = Symbol('GlobalSqlOption');
+const _EventBus = Symbol('EventBus');
+const _path = Symbol('path');
+const _fs = Symbol('fs');
+const logger = pino({
+    name: 'sql',
+    transport: {
+        target: 'pino-pretty'
+    }
+});
+// #endregion
+
+// #region 可选配置
+export enum DBType { Mysql, Sqlite, Mongo, SqliteRemote, Redis, RedisLock }
+export enum SyncMode {
+    /** 同步执行 */
+    Sync,
+    /** 异步执行 */
+    Async
+}
+export enum InsertMode {
+    /**
+    # 默认使用
+    ** 支持单个、批量,语法 `INSERT INTO XX VALUES (第一条数据), (第二条数据);`
+    ** 批量执行有性能优势，但无法利用数据库的sql预编译功能
+    */
+    Insert,
+    /**
+    # 利用临时表
+    ## 执行步骤
+    1. 建立临时表(从正式表复制)
+    2. 数据全部进入临时表
+    3. 临时表数据转移到正式表: `INSERT INTO 正式表 SELECT * FROM 临时表`
+    4. 删除临时表
+    ## 注意
+    1. 适用于：主键不会冲突、非自增
+    2. 临时表的结构复制正式表
+     */
+    InsertWithTempTable,
+    InsertIfNotExists,
+    /**
+    # 插入或者更新
+    1. 判断依据是主键
+     */
+    Replace
+}
+export enum DeleteMode {
+    /**
+     ##常规删除 默认
+     ### 例一
+     `DELETE FROM WHERE (id = 1) OR (id = 2)`
+     ### 例二
+     `DELETE FROM WHERE (id = 1 AND idx = 11) OR (id = 2 AND idx = 22)`
+    */
+    Common,
+    /*
+    ## 借助临时表
+    ### 注意：必须保证where的字段都相同，否则会漏删数据
+    DELETE FROM 正式表 INNER JOIN 临时表 WHERE 字段1 = 字段1 AND 字段2 = 字段2
+     */
+    TempTable
+}
+export enum SelectMode {
+    /**
+     ##常规 默认
+     ### 例一
+     `SELECT * FROM WHERE (id = 1) OR (id = 2)`
+     ### 例二
+     `SELECT * FROM WHERE (id = 1 AND idx = 11) OR (id = 2 AND idx = 22)`
+    */
+    Common,
+    /*
+    ## 借助临时表
+    ### 注意：必须保证where的字段都相同，否则会漏删数据
+    SELECT * FROM 正式表 INNER JOIN 临时表 WHERE 字段1 = 字段1 AND 字段2 = 字段2
+     */
+    TempTable
+}
+export enum TemplateResult {
+    /** 确定返回一条记录，如果不是一个，将报错，返回类型是T */
+    AssertOne,
+    /** 可能返回一条记录，返回类型是T|null */
+    NotSureOne,
+    /** 返回多条记录 */
+    Many,
+    /** 仅查询记录数量 */
+    Count
+}
+export enum SelectResult {
+    One_Row_One_Column_Assert,
+    One_Row_One_Column_NotSure,
+    One_Row_Many_Column_Assert,
+    One_Row_Many_Column_NotSure,
+    Many_Row_One_Column,
+    Many_Row_Many_Column
+}
+export enum SqlType {
+    tinyint,
+    smallint,
+    mediumint,
+    int,
+    bigint,
+
+    float,
+    double,
+    decimal,
+
+
+    date,
+    time,
+    year,
+    datetime,
+    timestamp,
+
+    char,
+    varchar,
+    tinyblob,
+    tinytext,
+    blob,
+    text,
+    mediumblob,
+    mediumtext,
+    longblob,
+    longtext,
+
+    set,
+    enum,
+
+    json,
+
+    geometry,
+    point,
+    linestring,
+    polygon,
+    multipoint,
+    multilinestring,
+    multipolygon,
+    geometrycollection
+
+}
+export const SqliteMemory = ':memory:';
+// #endregion
+
+// #region 选项
+interface MethodOption {
+    tableName?: string;
+    /** 数据库、连接名称，对于MYSQL、mongo，适用于多数据源，对于sqlite，适用于不同的数据库文件  */
+    dbName?: string;
+    /** 调用时，永远不需要传
+     * @deprecated
+     * */
+    dao?: Dao;
+    /** 调用时，仅在开启事务时需要主动传入,传入方式： */
+    conn?: Connection | null;
+}
+const _defOption = {
+    maxDeal: 500,
+    skipUndefined: true,
+    skipNull: true,
+    skipEmptyString: true
+};
+/**
+ 数据服务注解
+ */
+interface ServiceOption {
+    /** 增改忽略Undefined */
+    skipUndefined?: boolean;
+    /** 增改忽略NULL */
+    skipNull?: boolean;
+    /** 增改忽略空字符串 */
+    skipEmptyString?: boolean;
+    /** 批量增改时，每次执行最多处理的记录数量 */
+    maxDeal?: number;
+    tableName?: string;
+    /** 数据库、连接名称，对于MYSQL、mongo，适用于多数据源，对于sqlite，适用于不同的数据库文件  */
+    dbName?: string;
+    /** 调用时，永远不需要传
+     * @deprecated
+     * */
+    dao?: Dao;
+    /** 调用时，仅在开启事务时需要主动传入,传入方式： */
+    conn?: Connection | null;
+    /** 对应的实体类,必须是Class */
+    clz?: any;
+    /** 默认mysql */
+    dbType?: DBType;
+    /** SQLite版本以及升级为该版本时需要执行的SQL,初始版本为0.0.1,切记每个位置不要变为两位数*/
+    sqliteVersion?: string;
+}
+/**
+ # 全局行为配置文件
+   MYSQL编码： 'utf8mb4', utf8mb4_general_ci'
+ ### `sqlDir?: string;` 数据库查询语句存放目录.存放格式为 export.default 的js、ts， 存放内容满足格式：
+
+    ```
+    interface SqlModel {
+        [key: string]: string | ((params: { [k: string]: any }, context: any, isCount?: boolean) => string)
+    }
+    ```
+    可以继承该接口来约束格式
+ */
+interface GlobalSqlOption {
+    /** 增改忽略Undefined */
+    skipUndefined?: boolean;
+    /** 增改忽略NULL */
+    skipNull?: boolean;
+    /** 增改忽略空字符串 */
+    skipEmptyString?: boolean;
+    /** 批量增改时，每次执行最多处理的记录数量 */
+    maxDeal?: number;
+    /**
+       初始化MYSQL链接 支持多数据源
+       ## 单一数据源: 直接传入Mysql2的连接配置
+       [MYSQL初始化文档](https://github.com/mysqljs/mysql#connection-options)
+       ```
+       Mysql: {
+          host: '127.0.0.1',
+          ...
+       }
+       ```
+       ## 多数据源：传入多个Mysql2的连接配置
+       ```
+       Mysql: {
+          db1: {
+              host: '127.0.0.1',
+              ...
+          },
+          db2: {
+              host: '127.0.0.1',
+              ...
+          },
+          ...
+       }
+       ```
+      */
+    Mysql?: Record<string, Record<string, any>> | Record<string, any>;
+    /**
+     ## 单一数据源
+     ```
+     Sqlite: 'd:/1.db'
+     ```
+     ## 多数据源：传入多个Mysql2的连接配置
+     ```
+       Sqlite: {
+            db1: 'd:/1.db',
+            db2: 'd:/2.db'
+       }
+     ```
+       路径 = `SqliteMemory` 将创建内存库
+     */
+    Sqlite?: Record<string, string> | string,
+    SqliteRemote?: {
+        /**
+         ## 单一数据源
+        ```
+        db: 'd:/1.db'
+        ```
+        ## 多数据源：传入多个Mysql2的连接配置
+        ```
+        db: {
+                db1: 'd:/1.db',
+                db2: 'd:/2.db'
+        }
+        ```
+        不支持 `SqliteMemory`
+        */
+        db: Record<string, string> | string,
+        /** 远程SQLITE接口实现，适用于Electron, 采用Ipc 的handel机制实现 */
+        service: SqliteRemoteInterface
+    },
+    /** 日志等级 */
+    log?: 'trace' | 'debug' | 'info' | 'warn',
+    /**
+     ## 日志文件存放路径,该目录下文件名是模块名，例如有一个文件名为 `user.js`,内容为:
+     ```
+       export default {
+            'sql_1': 'SELECT * FROM user WHERE username = :username',
+            'sql_2': (options: {
+                ctx: any;
+                isCount?: boolean;
+                limitStart?: number;
+                limitEnd?: number;
+                orderBy?: string;
+                [k: string]: any;
+            }) => {
+                return   `
+                    SELECT * FROM user u LEFT JOIN organ o ON u.orgid = o.orgid
+                    WHERE o.orgid = :orgid;
+                `;
+            }
+        } as SqlModel;
+     ```
+     ** 可以看到，sql语句支持直接映射一个sql语句，也可以通过函数返回,返回字符串支持[mustache](https://github.com/janl/mustache.js)
+     ** 上面的文件中，将注册两个SQL：`user.sql_1` 和 `user.sql_2`.
+     ** `[k: string]: any;` 是用查询时传入的参数，可以指定为任意类型，可以用来生成sql，例如进行循环语句
+     ** ctx 是框架的上下文，可以自行指定类型
+     ** 其他 是保留参数
+     ** 函数类型中，可以调用自己定义的通用sql
+     ### 注意
+     1. 不要直接拼接参数：不安全且效率低
+     2. sqlite不支持多语句拼接
+    ## 也支持.mu文件,格式略
+    */
+    sqlDir?: string;
+    /**
+     作用与sqlDir类似，不同在于sqlMap`不需要`目录，而是直接指定一个sqlModel对象，对象的格式和sqlDir的文件内容一样。
+     ** 适用于简单使用
+     */
+    sqlMap?: SqlModel;
+    /**
+    ## [mustache](https://mustache.github.io/) 编译时的[模板](https://github.com/janl/mustache.js#:~:text=requires%20only%20this%3A-,%7B%7B%3E%20next_more%7D%7D,-Why%3F%20Because%20the)
+      ** 文件名就是模板名
+     */
+    sqlFNDir?: string;
+    /**
+     作用与sqlFnDir类似，不同在于sqlFNMap`不需要`目录，而是直接指定一个 Record<string, string>，对象的格式和sqlFnDir的文件内容一样。
+     ** 适用于简单使用
+     */
+    sqlFNMap?: Record<string, string>;
+
+    /**
+     [REDIS初始化文档](https://github.com/redis/ioredis?tab=readme-ov-file#:~:text=connect%20to%20by%3A-,new%20Redis()%3B,-//%20Connect%20to%20127.0.0.1)
+    ```
+    Redis: {
+        host: '127.0.0.1',
+        ...
+    }
+    ```
+    ## 多数据源：传入多个Redis的连接配置
+    ```
+    Redis: {
+        db1: {
+            host: '127.0.0.1',
+            ...
+        },
+        db2: {
+            host: '127.0.0.1',
+            ...
+        },
+        ...
+    }
+    ```
+     */
+    Redis?: Record<string, Record<string, any>> | Record<string, any>;
+}
+interface FieldOption extends Object {
+    type?: SqlType;
+    name?: string;
+    length?: number;
+    scale?: number;
+    def?: any;
+    index?: boolean;
+    id?: boolean;
+    logicDelete?: string;
+    notNull?: boolean;
+}
+interface AField extends FieldOption {
+    esName: string;
+    [DBType.Mysql]: string;
+    [DBType.Sqlite]: string;
+    [DBType.SqliteRemote]: string;
+}
+// #endregion
+
+// #region 数据方言
+/** sqlite electron服务端需要支持的接口 */
+export interface SqliteRemoteInterface {
+    execute(dbName: string, sql?: string, params?: any): | Promise<{ affectedRows: number; insertId: bigint; }>
+    pluck<One_Row_Many_Column = any>(dbName: string, sql?: string, params?: any): Promise<One_Row_Many_Column | undefined>;
+    get<One_Row_Many_Column = any>(dbName: string, sql?: string, params?: any): Promise<One_Row_Many_Column | undefined>;
+    raw<Many_Row_One_Column = any>(dbName: string, sql?: string, params?: any): Promise<Many_Row_One_Column[]>;
+    query<Many_Row_Many_Column = any>(dbName: string, sql?: string, params?: any): Promise<Many_Row_Many_Column[]>;
+
+    initDB(dbName: string): Promise<void>;
+    backup(dbName: string, name: string): Promise<void>;
+    restore(dbName: string, name: string): Promise<void>;
+};
+interface Connection {
+    [_daoConnection]: any;
+    [_inTransaction]: boolean;
+    execute(sync: SyncMode.Sync, sql?: string, params?: any): { affectedRows: number; insertId: bigint; };
+    execute(sync: SyncMode.Async, sql?: string, params?: any): | Promise<{ affectedRows: number; insertId: bigint; }>;
+    /** 一行一列 */
+    pluck<One_Row_One_Column = any>(sync: SyncMode.Sync, sql?: string, params?: any): One_Row_One_Column | null;
+    pluck<One_Row_One_Column = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<One_Row_One_Column | null>;
+    /** 一行多列 */
+    get<One_Row_Many_Column = any>(sync: SyncMode.Sync, sql?: string, params?: any): One_Row_Many_Column | null;
+    get<One_Row_Many_Column = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<One_Row_Many_Column | null>;
+    /** 多行一列 */
+    raw<Many_Row_One_Column = any>(sync: SyncMode.Sync, sql?: string, params?: any): Many_Row_One_Column[];
+    raw<Many_Row_One_Column = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<Many_Row_One_Column[]>;
+    /** 多行多列 */
+    query<Many_Row_Many_Column = any>(sync: SyncMode.Sync, sql?: string, params?: any): Many_Row_Many_Column[];
+    query<Many_Row_Many_Column = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<Many_Row_Many_Column[]>;
+    realse(sync: SyncMode.Sync): void;
+    realse(sync: SyncMode.Async): Promise<void>;
+}
+interface Dao {
+    [_daoDB]: any;
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    close(sync: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    backup(sync: SyncMode.Sync, name: string): void;
+    backup(sync: SyncMode.Async, name: string): Promise<void>;
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    restore(sync: SyncMode.Sync, name: string): void;
+    restore(sync: SyncMode.Async, name: string): Promise<void>;
+}
+class MysqlConnection implements Connection {
+    [_daoConnection]: any;
+    [_inTransaction] = false;
+    constructor(conn: any) {
+        this[_daoConnection] = conn;
+    }
+
+    execute(sync: SyncMode.Sync, sql?: string, params?: any): { affectedRows: number; insertId: bigint; };
+    execute(sync: SyncMode.Async, sql?: string, params?: any): Promise<{ affectedRows: number; insertId: bigint; }>;
+    execute(sync: SyncMode, sql?: string, params?: any): { affectedRows: number; insertId: bigint; } | Promise<{ affectedRows: number; insertId: bigint; }> {
+        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(Sqlstring.format(sql!, params));
+        }
+        return new Promise<{ affectedRows: number; insertId: bigint; }>(async (resolve, reject) => {
+            try {
+                const [_result] = await this[_daoConnection].execute(sql, params);
+                const result = _result as any;
+                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<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    pluck<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    pluck<T = any>(sync: SyncMode, sql?: string, params?: any): T | null | Promise<T | null> {
+        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(Sqlstring.format(sql!, params));
+        }
+        return new Promise<T | null>(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 as T);
+                }
+                resolve(null);
+            } catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+
+    get<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    get<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    get<T = any>(sync: SyncMode, sql?: string, params?: any): T | null | Promise<T | null> {
+        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(Sqlstring.format(sql!, params));
+        }
+        return new Promise<T | null>(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] as T);
+                resolve(null);
+            } catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+
+    raw<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    raw<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    raw<T = any>(sync: SyncMode, sql?: string, params?: any): T[] | Promise<T[]> {
+        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(Sqlstring.format(sql!, params));
+        }
+        return new Promise<T[]>(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: any) => Object.values(i)[0]));
+                resolve([]);
+            } catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+
+    query<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    query<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    query<T = any>(sync: SyncMode, sql?: string, params?: any): T[] | Promise<T[]> {
+        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(Sqlstring.format(sql!, params));
+        }
+        return new Promise<T[]>(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: SyncMode.Sync): void;
+    realse(sync: SyncMode.Async): Promise<void>;
+    realse(sync: SyncMode): Promise<void> | void {
+        if (sync === SyncMode.Sync) {
+            try {
+                this[_daoConnection]?.release();
+            } catch (error) {
+
+            }
+        };
+    }
+}
+class Mysql implements Dao {
+    [_daoDB]: any;
+    constructor(pool: any) {
+        this[_daoDB] = pool;
+    }
+
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    createConnection(sync: SyncMode): Connection | null | Promise<Connection | null> {
+        if (sync === SyncMode.Sync) {
+            logger.error('MYSQL not suppouted sync mode');
+            return null;
+        };
+        return new Promise<Connection>(async (resolve, reject) => {
+            try {
+                const connection = await this[_daoDB].getConnection();
+                logger.debug('create new!');
+                resolve(new MysqlConnection(connection));
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    transaction<T = any>(sync: SyncMode, fn: (conn: Connection) => T | Promise<T>, conn?: Connection | null): T | null | Promise<T | null> {
+        if (sync === SyncMode.Sync) {
+            logger.warn('MYSQL not suppouted sync mode');
+            return null;
+        };
+        return new Promise<T>(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: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    close(sync: SyncMode): Promise<void> | void {
+        if (sync === SyncMode.Sync) {
+            this[_daoDB]?.destroy();
+        };
+    }
+
+    backup(sync: SyncMode.Sync, name: string): void;
+    backup(sync: SyncMode.Async, name: string): Promise<void>;
+    backup(sync: SyncMode, name: string): Promise<void> | void {
+    }
+
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    remove(sync: SyncMode): Promise<void> | void {
+    }
+
+    restore(sync: SyncMode.Sync, name: string): void;
+    restore(sync: SyncMode.Async, name: string): Promise<void>;
+    restore(sync: SyncMode, name: string): Promise<void> | void {
+    }
+}
+class SqliteConnection implements Connection {
+    [_daoConnection]: any;
+    [_inTransaction] = false;
+    constructor(conn: any) {
+        this[_daoConnection] = conn;
+    }
+
+    execute(sync: SyncMode.Sync, sql?: string, params?: any): { affectedRows: number; insertId: bigint; };
+    execute(sync: SyncMode.Async, sql?: string, params?: any): Promise<{ affectedRows: number; insertId: bigint; }>;
+    execute(sync: SyncMode, sql?: string, params?: any): { affectedRows: number; insertId: bigint; } | Promise<{ affectedRows: number; insertId: bigint; }> {
+        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(Sqlstring.format(sql!, params));
+            }
+            const result = this[_daoConnection].prepare(sql).run(params ?? {});
+            if (globalThis[_GlobalSqlOption].log === 'trace') {
+                logger.trace(result);
+            }
+            const { changes, lastInsertRowid } = result;
+            return { affectedRows: changes, insertId: lastInsertRowid ? BigInt(lastInsertRowid) : 0n };
+        } catch (error) {
+            logger.error(`
+                error: ${error},
+                sql: ${sql},
+                params: ${params}
+            `);
+            throw error;
+        }
+    }
+
+    pluck<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    pluck<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    pluck<T = any>(sync: SyncMode, sql?: string, params?: any): T | null | Promise<T | null> {
+        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(Sqlstring.format(sql!, params));
+            }
+            return this[_daoConnection].prepare(sql).pluck().get(params ?? {});
+        } catch (error) {
+            logger.error(`
+                error: ${error},
+                sql: ${sql},
+                params: ${params}
+            `);
+            throw error;
+        }
+    }
+
+    get<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    get<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    get<T = any>(sync: SyncMode, sql?: string, params?: any): T | null | Promise<T | null> {
+        try {
+            logger.debug(sql, params ?? '');
+            if (!sql) { return null };
+            if (sync === SyncMode.Async) { return null };
+            if (globalThis[_GlobalSqlOption].log === 'trace') {
+                logger.trace(Sqlstring.format(sql!, params));
+            }
+            return this[_daoConnection].prepare(sql).get(params ?? {});
+        } catch (error) {
+            logger.error(`
+                error: ${error},
+                sql: ${sql},
+                params: ${params}
+            `);
+            throw error;
+        }
+    }
+
+    raw<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    raw<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    raw<T = any>(sync: SyncMode, sql?: string, params?: any): T[] | Promise<T[]> {
+        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(Sqlstring.format(sql!, params));
+            }
+            return this[_daoConnection].prepare(sql).raw().all(params ?? {});
+        } catch (error) {
+            logger.error(`
+                error: ${error},
+                sql: ${sql},
+                params: ${params}
+            `);
+            throw error;
+        }
+    }
+
+    query<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    query<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    query<T = any>(sync: SyncMode, sql?: string, params?: any): T[] | Promise<T[]> {
+        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(Sqlstring.format(sql!, params));
+            }
+            return this[_daoConnection].prepare(sql).all(params ?? {});
+        } catch (error) {
+            logger.error(`
+                error: ${error},
+                sql: ${sql},
+                params: ${params}
+            `);
+            throw error;
+        }
+    }
+
+    realse(sync: SyncMode.Sync): void;
+    realse(sync: SyncMode.Async): Promise<void>;
+    realse(sync: SyncMode): Promise<void> | void {
+    }
+}
+class Sqlite implements Dao {
+    [_daoDB]: any;
+    constructor(db: any) {
+        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: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    createConnection(sync: SyncMode): Connection | null | Promise<Connection | null> {
+        if (sync === SyncMode.Async) {
+            logger.error(`SQLITE not suppoted async mode`);
+            return null;
+        };
+        return new SqliteConnection(this[_daoDB]);
+    }
+
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    transaction<T = any>(sync: SyncMode, fn: (conn: Connection) => T | Promise<T>, conn?: Connection | null): T | null | Promise<T | null> {
+        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: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    close(sync: SyncMode): Promise<void> | void {
+        if (sync === SyncMode.Sync) {
+            this[_daoDB].close();
+        };
+    }
+
+    backup(sync: SyncMode.Sync, name: string): void;
+    backup(sync: SyncMode.Async, name: string): Promise<void>;
+    backup(sync: SyncMode, name: string): Promise<void> | void {
+        if (sync === SyncMode.Sync) {
+            this[_daoDB].backup(name);
+        };
+    }
+
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    remove(sync: SyncMode): Promise<void> | void {
+    }
+
+    restore(sync: SyncMode.Sync, name: string): void;
+    restore(sync: SyncMode.Async, name: string): Promise<void>;
+    restore(sync: SyncMode, name: string): Promise<void> | void {
+    }
+}
+class SqliteRemoteConnection implements Connection {
+    [_daoConnection]: SqliteRemoteInterface;
+    [_sqliteRemoteName]: string;
+    [_inTransaction] = false;
+    constructor(conn: SqliteRemoteInterface, name: string) {
+        this[_daoConnection] = conn;
+        this[_sqliteRemoteName] = name;
+    }
+
+    execute(sync: SyncMode.Sync, sql?: string, params?: any): { affectedRows: number; insertId: bigint; };
+    execute(sync: SyncMode.Async, sql?: string, params?: any): Promise<{ affectedRows: number; insertId: bigint; }>;
+    execute(sync: SyncMode, sql?: string, params?: any): { affectedRows: number; insertId: bigint; } | Promise<{ affectedRows: number; insertId: bigint; }> {
+        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(Sqlstring.format(sql!, params));
+        }
+        return new Promise<{ affectedRows: number; insertId: bigint; }>(async (resolve, reject) => {
+            try {
+                const { affectedRows, insertId } = await this[_daoConnection].execute(this[_sqliteRemoteName], sql, params);
+                resolve({ affectedRows, insertId: insertId ? BigInt(insertId) : 0n });
+            } catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+
+    pluck<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    pluck<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    pluck<T = any>(sync: SyncMode, sql?: string, params?: any): T | null | Promise<T | null> {
+        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(Sqlstring.format(sql!, params));
+        }
+        return new Promise<T | null>(async (resolve, reject) => {
+            try {
+                const r = await this[_daoConnection].pluck(this[_sqliteRemoteName], sql, params);
+                resolve(r);
+            } catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+
+    get<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    get<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    get<T = any>(sync: SyncMode, sql?: string, params?: any): T | null | Promise<T | null> {
+        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(Sqlstring.format(sql!, params));
+        }
+        return new Promise<T | null>(async (resolve, reject) => {
+            try {
+                const r = await this[_daoConnection].get(this[_sqliteRemoteName], sql, params);
+                resolve(r);
+            } catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+
+    raw<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    raw<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    raw<T = any>(sync: SyncMode, sql?: string, params?: any): T[] | Promise<T[]> {
+        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(Sqlstring.format(sql!, params));
+        }
+        return new Promise<T[]>(async (resolve, reject) => {
+            try {
+                const r = await this[_daoConnection].raw(this[_sqliteRemoteName], sql, params);
+                resolve(r);
+            } catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+
+    query<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    query<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    query<T = any>(sync: SyncMode, sql?: string, params?: any): T[] | Promise<T[]> {
+        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(Sqlstring.format(sql!, params));
+        }
+        return new Promise<T[]>(async (resolve, reject) => {
+            try {
+                const r = await this[_daoConnection].query(this[_sqliteRemoteName], sql, params);
+                resolve(r);
+            } catch (error) {
+                logger.error(`
+                    error: ${error},
+                    sql: ${sql},
+                    params: ${params}
+                `);
+                reject(error);
+            }
+        });
+    }
+
+    realse(sync: SyncMode.Sync): void;
+    realse(sync: SyncMode.Async): Promise<void>;
+    realse(sync: SyncMode): Promise<void> | void {
+    }
+}
+class SqliteRemote implements Dao {
+    [_sqliteRemoteName]: string;
+    [_daoDB]: SqliteRemoteInterface;
+
+    constructor(db: SqliteRemoteInterface, name: string) {
+        this[_daoDB] = db;
+        this[_sqliteRemoteName] = name;
+    }
+
+
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    createConnection(sync: SyncMode): Connection | null | Promise<Connection | null> {
+        if (sync === SyncMode.Sync) {
+            logger.error('SQLITEREMOTE not suppouted sync mode');
+            return null;
+        };
+        return new Promise<Connection>(async resolve => {
+            resolve(new SqliteRemoteConnection(this[_daoDB], this[_sqliteRemoteName]));
+        });
+    }
+
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    transaction<T = any>(sync: SyncMode, fn: (conn: Connection) => T | Promise<T>, conn?: Connection | null): T | null | Promise<T | null> {
+        logger.warn(`SQLITEREMOTE not suppoted transaction`);
+        return null;
+    }
+
+
+    close(sync: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    close(sync: SyncMode): Promise<void> | void {
+        if (sync === SyncMode.Async) {
+            return new Promise(async () => {
+                await this[_daoConnection].close();
+            });
+        };
+    }
+
+    backup(sync: SyncMode.Sync, name: string): void;
+    backup(sync: SyncMode.Async, name: string): Promise<void>;
+    backup(sync: SyncMode, name: string): Promise<void> | void {
+        if (sync === SyncMode.Async) {
+            return new Promise(async () => {
+                await this[_daoConnection].backup(this[_sqliteRemoteName], name);
+            });
+        };
+    }
+
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    remove(sync: SyncMode): Promise<void> | void {
+        if (sync === SyncMode.Async) {
+            return new Promise(async () => {
+                await this[_daoConnection].remove();
+            });
+        };
+    }
+
+    restore(sync: SyncMode.Sync, name: string): void;
+    restore(sync: SyncMode.Async, name: string): Promise<void>;
+    restore(sync: SyncMode, name: string): Promise<void> | void {
+        if (sync === SyncMode.Async) {
+            return new Promise(async () => {
+                await this[_daoConnection].restore(this[_sqliteRemoteName], name);
+            });
+        };
+    }
+}
+// #endregion
+
+// #region 查询sql
+export type SqlModel = Record<string, string | (
+    (options: {
+        ctx: any;
+        isCount?: boolean;
+        isSum?: boolean;
+        limitStart?: number;
+        limitEnd?: number;
+        orderBy?: string;
+        [k: string]: any;
+    }) => string
+)>;
+class Build {
+    private static page = 'COUNT(1) zccw1986 ';
+    private isCount: boolean;
+    private isSum: boolean;
+    private brage = { haveOrderBy: false, haveLimit: false };
+    /**
+     *
+     * @param count 是否是count查询
+     * @param isSum  是否是sum查询
+     * @param param 
+     */
+    constructor(
+        isCount: boolean,
+        isSum: boolean,
+        param: { [propName: string]: any } = {}
+    ) {
+        this.isCount = isCount;
+        this.isSum = isSum;
+        Object.assign(this, param);
+    }
+    /**
+     *
+     * 当分页时将函数内包含的内容替换为COUNT(1)
+     * @returns
+     * @memberof Build
+     */
+    pageTag() {
+        return (text: string, render: (text: string) => string) => {
+            if (this.isCount === true) {
+                return Build.page;
+            } else if (this.isSum !== true) {
+                return render(text);
+            }
+        };
+    }
+    /**
+   *
+   * 汇总查询专用
+   * @returns
+   * @memberof Build
+   */
+    sumTag() {
+        return (text: string, render: (text: string) => string) => {
+            if (this.isSum !== true) {
+                return '';
+            } else {
+                return render(text);
+            }
+        };
+    }
+    /**
+     *
+     * 当分页时、汇总时忽略函数内包含的内容
+     * @returns
+     * @memberof Build
+     */
+    pageIgnoreTag() {
+        return (text: string, render: (text: string) => string) => {
+            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: string, render: (text: string) => string) => {
+            let data = render(text);
+            data = data.trim();
+            if (data) {
+                data = data.replace(/and|or/i, '');
+                return ` WHERE ${data} `;
+            } else {
+                return '';
+            }
+        };
+    }
+    /**
+     * 删除第一个and、or
+     * 删除最后一个,
+     * 删除最后一个;
+     * @memberof Build
+     */
+    trim() {
+        return (text: string, render: (text: string) => string) => {
+            let data = render(text);
+            data = data.trim();
+            if (data) {
+                data = data.replace(/(^and\s)|(^or\s)|(,$)|(;$)/i, '');
+                return data;
+            } else {
+                return '';
+            }
+        };
+    }
+    /**
+     * 分页时将排序部分代码用此函数包起来，可以自动拼接order by
+     * 查询条数时，自动忽略此部分
+     * etc
+     * {{#orderTag}} name desc, age asc {{/orderTag}}
+     * ===
+     * ORDER BY name desc, age asc
+     * @returns
+     * @memberof Build
+     */
+    orderTag() {
+        return (text: string, render: (text: string) => string) => {
+            if (this.isCount === true || this.isSum === true) {
+                return '';
+            } else {
+                this.brage.haveOrderBy = true;
+                const orderBy = new Array<string>();
+                const renderOrder = render(text);
+                if (/\S/.test(renderOrder)) {
+                    orderBy.push(renderOrder);
+                }
+                return orderBy.length > 0 ? ` ORDER BY ${orderBy.join(',')} ` : '';
+            }
+        };
+    }
+    limitTag() {
+        return (text: string, render: (text: string) => string) => {
+            if (this.isCount === true || this.isSum === true) {
+                return '';
+            } else {
+                this.brage.haveOrderBy = true;
+                const orderBy = new Array<string>();
+                const renderOrder = render(text);
+                if (/\S/.test(renderOrder)) {
+                    orderBy.push(renderOrder);
+                }
+                return orderBy.length > 0 ? ` ORDER BY ${orderBy.join(',')} ` : '';
+            }
+        };
+    }
+    /**
+     *
+     * 分页时将分组部分代码用此函数包起来，可以自动拼接GROUP BY
+     * 当分页时、汇总时，自动忽略此部分
+     * etc
+     * {{#groupTag}} name, age {{/groupTag}}
+     * ===
+     * group by name.age
+     * @returns
+     * @memberof Build
+     */
+    groupTag() {
+        return (text: string, render: (text: string) => string) => {
+            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: string, render: (text: string) => string) => {
+            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
+     * {{#distanceTag}} (t.longitude, t.latitude), ({{longitude}}, {{latitude}}) {{/distanceTag}}
+     * ===
+     * ROUND(ST_DISTANCE(POINT(longitude1, latitude1), POINT({{longitude}}, {{latitude}}))*111195, 2)
+     * 可根据需求自行将数据转换为千米，例如
+     * {{#distanceTag}} (t.longitude, t.latitude), ({{longitude}}, {{latitude}}) {{/distanceTag}} / 1000
+     * @returns
+     * @memberof Build
+     */
+    distanceTag() {
+        return (text: string, render: (text: string) => string) => {
+            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 '';
+            }
+        };
+    }
+}
+class SqlCache {
+    private sqlMap: SqlModel = {};
+    private sqlFNMap: PartialsOrLookupFn = {};
+    async init(options: {
+        sqlMap?: SqlModel; sqlDir?: string;
+        sqlFNMap?: Record<string, string>; sqlFNDir?: string;
+    }) {
+        if (options.sqlMap) {
+            this.sqlMap = options.sqlMap;
+        }
+        if (options.sqlDir) {
+            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') {
+                    const parser = new MUParser(name, globalThis[_fs].readFileSync(file, { encoding: 'utf-8' }).toString());
+                    let source = parser.next();
+                    while (source != null) {
+                        this.sqlMap[source[0]] = source[1];
+                        logger.debug(`sql: ${source[0]} found!`);
+                        source = parser.next();
+                    }
+                } else if (extname === '.js') {
+                    const obj = (await import(globalThis[_path].join(options.sqlDir, modeName))).default as SqlModel;
+                    for (const [key, fn] of Object.entries(obj)) {
+                        this.sqlMap[`${name}.${String(key)}`] = fn;
+                    }
+                }
+            }
+        }
+        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();
+                }
+            }
+        }
+    }
+    load(sqlid: string, options: {
+        ctx: any;
+        isCount?: boolean;
+        isSum?: boolean;
+        limitStart?: number;
+        limitEnd?: number;
+        orderBy?: string;
+        [k: string]: any;
+    }): string {
+        const sqlSource = this.sqlMap[sqlid];
+        Throw.if(!sqlSource, `指定的语句${sqlid}不存在!`);
+        const _sql = typeof sqlSource === 'function' ? sqlSource(options) : sqlSource!;
+        const buildParam = new Build(options.isCount === true, options.isSum === true, options);
+        const sql = mustache.render(_sql, buildParam, this.sqlFNMap);
+        logger.debug(sqlid, sql);
+        return sql;
+    }
+}
+// #endregion
+
+/**
+
+## 所有service中内置方法定义规则
+ ** 方法第一个参数必须是 sync: SyncMode
+ ** 方法最后一个参数必须是 option
+
+## sync 表示是否是同步方法
+
+因为mysql是异步、sqlite是同步，导致必须通过一个标识来区分，否则将必须为两种数据库设置不同的service，失去了意义
+
+## option 额外控制参数
+
+## length
+方法的参数数量
+ */
+function P<T extends object>(skipConn = false) {
+    return (_target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+        const fn = descriptor.value;
+        descriptor.value = function (this: SqlService<T>, ...args: any[]) {
+            let needRealseConn = true;
+            const startTime = +new Date();
+            // option
+            const option = args[0] = Object.assign({}, globalThis[_GlobalSqlOption], this[_SqlOption], args[0]) as (MethodOption & { sync?: SyncMode; });
+            option.sync ??= SyncMode.Async;
+            const dbName = option?.dbName ?? this[_daoDBName] ?? _primaryDB;
+            option!.dao = globalThis[_dao][this[_dbType]!][dbName] as Dao;
+            Throw.if(!option!.dao, `not found db:${String(dbName)}(${this[_dbType]})`);
+            option!.tableName = option?.tableName ?? this[_tableName];
+            const tableES = Sqlstring.escapeId(option!.tableName);
+            if (this[_dbType] === DBType.Sqlite) {
+                Throw.if(option.sync === SyncMode.Async, 'sqlite can not Async!')
+                // 连接共享
+                if (skipConn === false && !option!.conn) {
+                    option!.conn = option!.dao.createConnection(SyncMode.Sync)!;
+                } else {
+                    needRealseConn = false;
+                }
+                if (skipConn === false) {
+                    const lastVersion = this[_sqlite_version] ?? '0.0.1';
+                    // 检查表
+                    const tableCheckResult = option!.conn!.pluck<number>(SyncMode.Sync, `SELECT COUNT(1) t FROM sqlite_master WHERE TYPE = 'table' AND name = ?`, [option!.tableName]);
+                    if (tableCheckResult) {
+                        // 旧版本
+                        const tableVersion = option!.conn!.pluck<string>(SyncMode.Sync, 'SELECT ______version v from TABLE_VERSION WHERE ______tableName = ?', [option!.tableName]);
+                        if (tableVersion && tableVersion < lastVersion) { // 发现需要升级的版本
+                            // 更新版本
+                            const columns = iterare<{ name: string }>(option!.conn!.query(SyncMode.Sync, `PRAGMA table_info(${tableES})`))
+                                .filter(c => this[_fields]!.hasOwnProperty(c.name))
+                                .map(c => Sqlstring.escapeId(c.name))
+                                .join(',');
+
+                            const rtable = Sqlstring.escapeId(`${option!.tableName}_${tableVersion.replace(/\./, '_')}`);
+                            option!.conn!.execute(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]?.esName).join(',')})` : ''}
+                                );
+                            `);
+                            if (this[_index] && this[_index].length) {
+                                for (const index of this[_index]) {
+                                    option!.conn!.execute(SyncMode.Sync, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableES} ("${index}");`);
+                                }
+                            }
+                            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]?.esName).join(',')})` : ''}
+                    
+                            );
+                        `);
+                        if (this[_index] && this[_index].length) {
+                            for (const index of this[_index]) {
+                                option!.conn!.execute(SyncMode.Sync, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableES} ("${index}");`);
+                            }
+                        }
+                        option!.conn!.execute(SyncMode.Sync, 'INSERT OR REPLACE INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option!.tableName, lastVersion]);
+                    }
+                }
+                try {
+                    const result = fn.call(this, ...args);
+                    logger.info(`${propertyKey}:${option!.tableName}:use ${+new Date() - startTime}ms`);
+                    return result;
+                } catch (error) {
+                    try {
+                        console.error(`service ${propertyKey} have an error:${error}, it's argumens: ${JSON.stringify(args.filter(i => typeof i !== 'object' || (typeof i === 'object' && !i.insert)))}`)
+                    } catch (error) {
+
+                    }
+                    throw error;
+                } finally {
+                    if (needRealseConn && option && option!.conn) {
+                        try {
+                            option!.conn!.realse(SyncMode.Sync);
+                        } catch (error) {
+                        }
+                    }
+                }
+            } else if (this[_dbType] === DBType.SqliteRemote) {
+                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;
+                    }
+                    if (skipConn === false) {
+                        const lastVersion = this[_sqlite_version] ?? '0.0.1';
+                        // 检查表
+                        const tableCheckResult = await option!.conn!.pluck<number>(SyncMode.Async, `SELECT COUNT(1) t FROM sqlite_master WHERE TYPE = 'table' AND name = ?`, [option!.tableName]);
+                        if (tableCheckResult) {
+                            // 旧版本
+                            const tableVersion = await option!.conn!.pluck<string>(SyncMode.Async, 'SELECT ______version v from TABLE_VERSION WHERE ______tableName = ?', [option!.tableName]);
+                            if (tableVersion && tableVersion < lastVersion) { // 发现需要升级的版本
+                                // 更新版本
+                                const columns = iterare<{ name: string }>(await option!.conn!.query(SyncMode.Async, `PRAGMA table_info(${tableES})`))
+                                    .filter(c => this[_fields]!.hasOwnProperty(c.name))
+                                    .map(c => Sqlstring.escapeId(c.name))
+                                    .join(',');
+
+                                const rtable = `${option!.tableName}_${tableVersion.replace(/\./, '_')}`;
+                                await option!.conn!.execute(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]?.esName).join(',')})` : ''}
+                                );
+                            `);
+                                if (this[_index] && this[_index].length) {
+                                    for (const index of this[_index]) {
+                                        await option!.conn!.execute(SyncMode.Async, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableES} ("${index}");`);
+                                    }
+                                }
+                                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]?.esName).join(',')})` : ''}
+                            );
+                        `);
+                            if (this[_index] && this[_index].length) {
+                                for (const index of this[_index]) {
+                                    await option!.conn!.execute(SyncMode.Async, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${Sqlstring.escapeId(option!.tableName)} ("${index}");`);
+                                }
+                            }
+                            await option!.conn!.execute(SyncMode.Async, 'INSERT OR REPLACE INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option!.tableName, lastVersion]);
+                        }
+                    }
+                    try {
+                        const result = await fn.call(this, ...args);
+                        logger.info(`${propertyKey}:${option!.tableName}:use ${+new Date() - startTime}ms`);
+                        resolve(result);
+                    } catch (error) {
+                        console.error(`service ${propertyKey} have an error:${error}, it's argumens: ${JSON.stringify(args.filter(i => typeof i !== 'object' || (typeof i === 'object' && !i.insert)))}`)
+                        reject(error);
+                    } finally {
+                        if (needRealseConn && option && option!.conn) {
+                            try {
+                                option!.conn!.realse(SyncMode.Sync);
+                            } catch (error) {
+
+                            }
+                        }
+                    }
+                });
+
+            } else if (this[_dbType] === DBType.Mysql) {
+                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: string, V: any, def: any,
+    option?: MethodOption & { finalColumns?: Set<string>; tempColumns?: Array<string>; def?: boolean; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; }
+) => {
+    let ret = 0;
+    if (V === null) {
+        if (option?.skipNull !== true) {
+            ret = 1;
+            V = option?.def === true && def && def.hasOwnProperty(K) ? def[K] : null;
+        }
+    } else if (V === undefined) {
+        if (option?.skipUndefined !== true) {
+            ret = 1;
+            V = option?.def === true && def && def.hasOwnProperty(K) ? def[K] : null;
+        }
+    } else if (emptyString(`${V ?? ''}`)) {
+        if (option?.skipEmptyString !== true) {
+            ret = 1;
+            V = option?.def === true && def && def.hasOwnProperty(K) ? def[K] : '';
+        }
+    } else {
+        ret = 1;
+    }
+    if (ret === 1) {
+        option?.finalColumns?.add(K);
+        option?.tempColumns?.push(K);
+    }
+    return [ret, V];
+}
+const MYSQLCHARSET = `CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci`
+export const Field = (config: FieldOption) => {
+    config.type ??= SqlType.varchar;
+    return (object: object, propertyName: string) => {
+        const field = config as AField;
+        field.name = propertyName;
+        field.esName = Sqlstring.escapeId(propertyName);
+        const hasDef = field.hasOwnProperty('def') === true;
+        switch (field.type) {
+            case SqlType.tinyint: {
+                field[DBType.Mysql] = `${field.esName} tinyint ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} integer`;
+                break;
+            }
+            case SqlType.smallint: {
+                field[DBType.Mysql] = `${field.esName} smallint ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} integer`;
+                break;
+            }
+            case SqlType.mediumint: {
+                field[DBType.Mysql] = `${field.esName} smallint ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} integer`;
+                break;
+            }
+            case SqlType.int: {
+                field[DBType.Mysql] = `${field.esName} int ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} integer`;
+                break;
+            }
+            case SqlType.bigint: {
+                field[DBType.Mysql] = `${field.esName} bigint ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} integer`;
+                break;
+            }
+
+            case SqlType.float: {
+                field[DBType.Mysql] = `${field.esName} float(${config.length ?? 1}, ${config.scale ?? 2}) ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} `;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} real`;
+                break;
+            }
+            case SqlType.double: {
+                field[DBType.Mysql] = `${field.esName} double(${config.length ?? 1}, ${config.scale ?? 2}) ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} `;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} real`;
+                break;
+            }
+            case SqlType.decimal: {
+                field[DBType.Mysql] = `${field.esName} decimal(${config.length ?? 1}, ${config.scale ?? 2}) ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} `;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} real`;
+                break;
+            }
+
+            case SqlType.longtext: {
+                field[DBType.Mysql] = `${field.esName} longtext ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.mediumtext: {
+                field[DBType.Mysql] = `${field.esName} mediumtext ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.text: {
+                field[DBType.Mysql] = `${field.esName} text ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+
+            case SqlType.date: {
+                field[DBType.Mysql] = `${field.esName} date ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.time: {
+                field[DBType.Mysql] = `${field.esName} time ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.year: {
+                field[DBType.Mysql] = `${field.esName} year ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.datetime: {
+                field[DBType.Mysql] = `${field.esName} datetime ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.timestamp: {
+                field[DBType.Mysql] = `${field.esName} timestamp ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} integer`;
+                break;
+            }
+
+            case SqlType.char: {
+                field[DBType.Mysql] = `${field.esName} char(${config.length ?? 1}) ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.varchar: {
+                field[DBType.Mysql] = `${field.esName} varchar(${config.length ?? 1}) ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.tinyblob: {
+                field[DBType.Mysql] = `${field.esName} tinyblob ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.tinytext: {
+                field[DBType.Mysql] = `${field.esName} tinytext ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.blob: {
+                field[DBType.Mysql] = `${field.esName} binary ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.text: {
+                field[DBType.Mysql] = `${field.esName} text ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.mediumblob: {
+                field[DBType.Mysql] = `${field.esName} mediumblob ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.mediumtext: {
+                field[DBType.Mysql] = `${field.esName} mediumtext ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.longblob: {
+                field[DBType.Mysql] = `${field.esName} longblob ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.longtext: {
+                field[DBType.Mysql] = `${field.esName} longtext ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+
+            case SqlType.set: {
+                field[DBType.Mysql] = `${field.esName} set ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.enum: {
+                field[DBType.Mysql] = `${field.esName} enum ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.json: {
+                field[DBType.Mysql] = `${field.esName} json ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+
+            case SqlType.geometry: {
+                field[DBType.Mysql] = `${field.esName} geometry ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.point: {
+                field[DBType.Mysql] = `${field.esName} point ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.linestring: {
+                field[DBType.Mysql] = `${field.esName} linestring ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.polygon: {
+                field[DBType.Mysql] = `${field.esName} polygon ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.multipoint: {
+                field[DBType.Mysql] = `${field.esName} multipoint ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.multilinestring: {
+                field[DBType.Mysql] = `${field.esName} multilinestring ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.multipolygon: {
+                field[DBType.Mysql] = `${field.esName} multipolygon ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+            case SqlType.geometrycollection: {
+                field[DBType.Mysql] = `${field.esName} geometrycollection ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? field.def : ''} ${MYSQLCHARSET}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = `${field.esName} text`;
+                break;
+            }
+        };
+        let __fields = Reflect.getMetadata(_fields, object);
+        let __columns = Reflect.getMetadata(_columns, object);
+        let __columnsNoId = Reflect.getMetadata(_columnsNoId, object);
+        let __ids = Reflect.getMetadata(_ids, object);
+        let __index = Reflect.getMetadata(_index, object);
+        let __def = Reflect.getMetadata(_def, object);
+
+        if (!__fields) {
+            __fields = {};
+            __columns = [];
+            __columnsNoId = [];
+            __ids = [];
+            __index = [];
+            __def = {};
+        }
+        __fields[propertyName] = field;
+        __columns.push(propertyName);
+        if (field.id === true) {
+            __ids.push(propertyName);
+        } else {
+            __columnsNoId.push(propertyName);
+        }
+        if (field.index === true) {
+            __index.push(propertyName);
+        }
+        if (hasDef) {
+            __def[propertyName] = field.def;
+        }
+
+        Reflect.defineMetadata(_fields, __fields, object);
+        Reflect.defineMetadata(_columns, __columns, object);
+        Reflect.defineMetadata(_columnsNoId, __columnsNoId, object);
+        Reflect.defineMetadata(_ids, __ids, object);
+        Reflect.defineMetadata(_index, __index, object);
+        Reflect.defineMetadata(_def, __def, object);
+        if (field.hasOwnProperty('logicDelete')) {
+            Reflect.defineMetadata(_deleteState, field.logicDelete, object);
+            Reflect.defineMetadata(_stateFileName, propertyName, object);
+        }
+    };
+}
+export const DB = (config: ServiceOption) => {
+    return function <C extends { new(...args: any[]): {} }>(constructor: C) {
+        const __ids = Reflect.getMetadata(_ids, config.clz.prototype) || new Array<string>;
+        const __fields = Reflect.getMetadata(_fields, config.clz.prototype);
+        const __columns = Reflect.getMetadata(_columns, config.clz.prototype);
+        const __columnsNoId = __columns.filter((c: string) => __ids.includes(c) === false);
+        const __stateFileName = Reflect.getMetadata(_stateFileName, config.clz.prototype);
+        const __deleteState = Reflect.getMetadata(_deleteState, config.clz.prototype);
+        const __index = Reflect.getMetadata(_index, config.clz.prototype);
+        const __def = Reflect.getMetadata(_def, config.clz.prototype);
+        return class extends constructor {
+            [_tableName] = config.tableName;
+            [_daoDBName] = config.dbName;
+            [_dbType] = config.dbType ?? DBType.Mysql;
+            [_sqlite_version] = config.sqliteVersion;
+            [_SqlOption] = Object.assign({}, _defOption, config);
+
+            [_ids] = __ids;
+            [_fields] = __fields;
+            [_columns] = __columns;
+            [_columnsNoId] = __columnsNoId;
+            [_index] = __index;
+            [_def] = __def;
+            [_stateFileName] = __stateFileName;
+            [_deleteState] = __deleteState;
+
+            [_transformer] = <L extends Object>(
+                data: L,
+                option?: MethodOption & {
+                    finalColumns?: Set<string>;
+                    tempColumns?: Array<string>;
+                    def?: boolean;
+                    skipId?: boolean;
+                    onFieldExists?: (K: string, V: any) => void;
+                }
+            ) => {
+                return Object.fromEntries(
+                    iterare(option?.skipId === true ? __columnsNoId : __columns)
+                        .map(K => [K, FieldFilter(K as string, data[K as string], __def, option)])
+                        .filter(data => {
+                            if ((data[1] as any)[0] === 1) {
+                                if (option?.onFieldExists) {
+                                    option.onFieldExists(data[0] as string, (data[1] as any)[1]);
+                                }
+                                return true;
+                            } else {
+                                return false;
+                            }
+                        })
+                        .map(data => [data[0], (data[1] as any)[1]])
+                        .toArray()
+                );
+            };
+        };
+    }
+};
+/**
+  js项目中实体类注解替代品，只要确保函数被执行即可,举例：
+  ```
+  // 声明一个class
+    export class AmaFuck {}
+    DeclareClass(AmaFuck, [
+        { type: "String", name: "SellerSKU" },
+        { type: "String", name: "SellerSKU2" },
+        { type: "String", name: "site" }
+    ]);
+  ```
+ */
+export function DeclareClass(clz: any, FieldOptions: FieldOption[]) {
+    for (const item of FieldOptions) {
+        tslib.__decorate([Field(item)], clz.prototype, item.name, void 0);
+    }
+}
+/**
+ JS项目中，service注解代替,举例：
+ ```
+ // 声明一个service,注意这里的let
+    export let AmaService = class AmaService extends SqlService {};
+    AmaService = DeclareService(AmaService, {
+        tableName: "ama_fuck2",
+        clz: AmaFuck,
+        dbType: DBType.Sqlite,
+        sqliteVersion: "0.0.3"
+    });
+ ```
+ */
+export function DeclareService(clz: any, config: ServiceOption) {
+    return tslib.__decorate([DB(config)], clz)
+}
+/**
+ ## 数据库服务
+ ### 注解DB
+ 
+ ### 泛型 T，同DB注解中的clz
+ ** 服务中所有方法默认以该类型为准
+ **
+ 
+ */
+export class SqlService<T extends object> {
+    private [_tableName]?: string;
+    private [_daoDBName]?: string;
+    private [_ids]?: string[];
+    private [_fields]?: Record<string, AField>;
+    private [_columns]?: string[];
+    private [_columnsNoId]?: string[];
+    private [_stateFileName]?: string;
+    private [_deleteState]?: string;
+    private [_SqlOption]?: ServiceOption;
+    private [_dbType]?: DBType;
+    private [_sqlite_version]?: string;
+    private [_index]?: string[];
+    private [_def]?: Partial<T>;
+    private [_transformer]?: (data: Partial<T>, option?: MethodOption & { finalColumns?: Set<string>; def?: boolean; skipId?: boolean; onFieldExists?: (K: string, V: any) => void; }) => Partial<T>;
+    private _insert(
+        datas: Partial<T>[],
+        option: MethodOption & {
+            mode?: InsertMode;
+            existConditionOtherThanIds?: (keyof T)[];
+        }): { sql: string; params?: any[] }[] {
+        const sqls: { sql: string; params?: any[] }[] = [];
+        const tableName = Sqlstring.escapeId(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 = iterare<string>(conditions! as string[]).map(c => `${this[_fields]![c]?.esName} = ?`).join(' AND ');
+                const finalColumns = new Set<string>();
+                const whereColumns = conditions! as string[];
+                const params = datas
+                    .map(data => this[_transformer]!(data, { ...option, finalColumns, def: true }))
+                    .flatMap(data => {
+                        const result: any[] = [];
+                        const questMark = new Array<string>();
+                        for (const column of finalColumns) {
+                            questMark.push('?');
+                            result.push(
+                                data.hasOwnProperty(column)
+                                    ? data[column]
+                                    : this[_def] && this[_def].hasOwnProperty(column)
+                                        ? this[_def][column]
+                                        : null
+                            );
+                        }
+
+                        for (const column of whereColumns) {
+                            questMark.push('?');
+                            result.push(
+                                data.hasOwnProperty(column)
+                                    ? data[column]
+                                    : this[_def] && this[_def].hasOwnProperty(column)
+                                        ? this[_def][column]
+                                        : null
+                            );
+                        }
+                        return result;
+                    });
+                const quests = new Array<string>(finalColumns.size).fill('?').join(',');
+                const columnNames = iterare<string>(finalColumns).map(i => this[_fields]![i]?.esName).join(',');
+                const selects = iterare<string>(new Array<string>(datas.length)).map(() => `SELECT ${quests} FROM DUAL WHERE NOT EXISTS (SELECT 1 FROM ${tableName} WHERE ${where})`).join(' UNION ALL ');
+                const sql = `INSERT INTO
+                        ${tableName}
+                        (${columnNames})
+                        ${selects};`;
+                sqls.push({ sql, params });
+            }
+            case InsertMode.Replace: {
+                const finalColumns = new Set<string>();
+                const params = datas
+                    .map(data => this[_transformer]!(data, { ...option, finalColumns, def: true }))
+                    .flatMap(data => {
+                        const result: any[] = [];
+                        const questMark = new Array<string>();
+                        for (const column of finalColumns) {
+                            questMark.push('?');
+                            result.push(
+                                data.hasOwnProperty(column)
+                                    ? data[column]
+                                    : this[_def] && this[_def].hasOwnProperty(column)
+                                        ? this[_def][column]
+                                        : null
+                            );
+                        }
+                        return result;
+                    });
+                const quests = new Array<string>(finalColumns.size).fill('?').join(',');
+                const columnNames = iterare<string>(finalColumns).map(i => this[_fields]![i]?.esName).join(',');
+                const questMarks = iterare<string>(new Array<string>(datas.length)).map(() => `(${quests})`).join(',');
+                const sql = `
+                    ${this[_dbType] === DBType.Mysql ? '' : 'INSERT OR'} REPLACE INTO
+                    ${tableName}
+                    (${columnNames})
+                    VALUES ${questMarks};
+                `;
+                sqls.push({ sql, params });
+            }
+            case InsertMode.Insert: {
+                const finalColumns = new Set<string>();
+                const params = datas
+                    .map(data => this[_transformer]!(data, { ...option, finalColumns, def: true }))
+                    .flatMap(data => {
+                        const result: any[] = [];
+                        const questMark = new Array<string>();
+                        for (const column of finalColumns) {
+                            questMark.push('?');
+                            result.push(
+                                data.hasOwnProperty(column)
+                                    ? data[column]
+                                    : this[_def] && this[_def].hasOwnProperty(column)
+                                        ? this[_def][column]
+                                        : null
+                            );
+                        }
+                        return result;
+                    });
+                const quests = new Array<string>(finalColumns.size).fill('?').join(',');
+                const columnNames = iterare(finalColumns).map(i => this[_fields]![i]?.esName).join(',');
+                const questMarks = iterare(new Array<string>(datas.length)).map(() => `(${quests})`).join(',');
+                const sql = `
+                    INSERT INTO
+                    ${tableName}
+                    (${columnNames})
+                    VALUES ${questMarks};
+                `;
+                sqls.push({ sql, params });
+            }
+            case InsertMode.InsertWithTempTable: {
+                const tableTemp = `${option?.tableName}_${Math.random()}`.replace(/\./, '');
+                const tableTempESC = Sqlstring.escapeId(tableTemp);
+                sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+                const finalColumns = new Set<string>();
+                const params = datas
+                    .map(data => this[_transformer]!(data, { ...option, finalColumns, def: true }))
+                    .flatMap(data => {
+                        const result: any[] = [];
+                        const questMark = new Array<string>();
+                        for (const column of finalColumns) {
+                            questMark.push('?');
+                            result.push(
+                                data.hasOwnProperty(column)
+                                    ? data[column]
+                                    : this[_def] && this[_def].hasOwnProperty(column)
+                                        ? this[_def][column]
+                                        : null
+                            );
+                        }
+                        return result;
+                    });
+                const _sqls = this._createTable({ tableName: tableTemp, temp: true, columns: Array.from(finalColumns) })!;
+                sqls.push(..._sqls);
+
+                const quests = new Array<string>(finalColumns.size).fill('?').join(',');
+                const columnNames = iterare(finalColumns).map(i => this[_fields]![i]?.esName).join(',');
+                const questMarks = iterare(new Array<string>(datas.length)).map(() => `(${quests})`).join(',');
+                sqls.push({
+                    sql: `
+                        INSERT INTO
+                        ${tableTemp}
+                        (${columnNames})
+                        VALUES ${questMarks};
+                    `, params
+                });
+                sqls.push({
+                    sql: `INSERT INTO ${Sqlstring.escapeId(option.tableName)} (${columnNames})
+                        SELECT ${columnNames} FROM ${tableTemp};`
+                });
+                sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+            }
+        }
+        return sqls;
+    }
+    /**
+    0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认 `异步`
+    1. `data`：可是数组或者单对象
+    2. `skipUndefined`: boolean; 是否不处理值为undefined的字段,默认 true
+    3. `skipNull`: boolean; 是否不处理值为null的字段,默认 true
+    4. `skipEmptyString`: boolean; 是否不处理值为空字符串(`注意：多个空格也算空字符串`)的字段,默认 true
+    5. `maxDeal`: number; 批量处理时，每次处理多少个？默认500
+    6. `tableName`: 默认使用service注解的`tableName`,可以在某个方法中覆盖
+    7. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+    8. `conn`: 仅在开启事务时需要主动传入,传入示例:
+        ```
+            service.transaction(async conn => {
+                service.insert({conn});
+            });
+        ```
+    9.  `dao`: 永远不需要传入该值
+    10. `mode` :默认`insert`，可选如下
+        1. `insert`: 默认
+        2. `insertIfNotExists`: 通过主键或者existConditionOtherThanIds字段判断数据是否存在，不存在才插入,存在则不执行
+        3. `replace`: 只支持用主键判断, 存在更新, 不存在插入
+    11. `existConditionOtherThanIds`: insertIfNotExists时判断同一记录的字段名称，默认情况下按照ID判断，设置existConditionOtherThanIds后，不用id
+    ### 返回值是最后一次插入的主键ID，对于自增ID表适用
+    1. 如果主键是自增批量操作，且期望返回所有记录的ID，那么需要设置 `option 中的 every = true`,此时效率降低
+     * @param {{[P in keyof T]?: T[P]}} data
+     * @param {MethodOption} [option]
+     * @memberof SqlServer
+     */
+    insert(option: MethodOption & { data: Partial<T>; sync?: SyncMode.Async; mode?: InsertMode; existConditionOtherThanIds?: (keyof T)[]; every?: boolean; temp?: boolean; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; maxDeal?: number; }): Promise<bigint>;
+    insert(option: MethodOption & { data: Partial<T>[]; sync?: SyncMode.Async; mode?: InsertMode; existConditionOtherThanIds?: (keyof T)[]; every?: boolean; temp?: boolean; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; maxDeal?: number; }): Promise<bigint[]>;
+    insert(option: MethodOption & { data: Partial<T>; sync: SyncMode.Sync; mode?: InsertMode; existConditionOtherThanIds?: (keyof T)[]; every?: boolean; temp?: boolean; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; maxDeal?: number; }): bigint;
+    insert(option: MethodOption & { data: Partial<T>[]; sync: SyncMode.Sync; mode?: InsertMode; existConditionOtherThanIds?: (keyof T)[]; every?: boolean; temp?: boolean; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; maxDeal?: number; }): bigint[];
+    @P<T>()
+    insert(option: MethodOption & { data: Partial<T> | Array<Partial<T>>; sync?: SyncMode; mode?: InsertMode; existConditionOtherThanIds?: (keyof T)[]; every?: boolean; temp?: boolean; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; maxDeal?: number; }): bigint | bigint[] | Promise<bigint> | Promise<bigint[]> {
+        option.mode ??= InsertMode.Insert;
+        const isArray = option.data instanceof Array;
+        const datas = option.data instanceof Array ? option.data : [option.data];
+        if (option.sync === SyncMode.Sync) {
+            const fn = () => {
+                const result = excuteSplit<Partial<T>, bigint>(
+                    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 += dd.insertId; }
+                        }
+                        return result;
+                    },
+                    { everyLength: option?.every === true ? 1 : option?.maxDeal }
+                );
+                if (isArray) return result;
+                else return result[0]!;
+            };
+            if (option?.conn?.[_inTransaction] === true) {
+                return fn();
+            } else {
+                return option?.dao?.transaction(SyncMode.Sync, fn, option?.conn)!;
+            }
+        } else if (isArray) {
+            const fn = async () => {
+                return await option?.dao?.transaction(SyncMode.Async, async () => {
+                    const result = await excuteSplit<Partial<T>, bigint>(
+                        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: option?.every === true ? 1 : option?.maxDeal }
+                    );
+                    return result;
+                }, option?.conn);
+            };
+            return new Promise<bigint[]>(async (resolve) => {
+                if (option?.conn?.[_inTransaction] === true) {
+                    resolve((await fn())!);
+                } else {
+                    await option?.dao?.transaction(SyncMode.Async, async () => resolve((await fn())!), option?.conn);
+                }
+            });
+        } else {
+            const fn = async () => {
+                const result = await excuteSplit<Partial<T>, bigint>(
+                    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]!;
+            };
+            return new Promise<bigint>(async (resolve) => {
+                if (option?.conn?.[_inTransaction] === true) {
+                    resolve((await fn())!);
+                } else {
+                    await option?.dao?.transaction(SyncMode.Async, async () => resolve((await fn())!), option?.conn);
+                }
+            });
+        }
+    }
+
+    private _update(datas: Array<Partial<T>>, option: MethodOption): { sql: string; params?: any[] }[] {
+        const sqls: { sql: string; params?: any[] }[] = [];
+        const tableName = Sqlstring.escapeId(option?.tableName);
+        const where = `WHEN ${iterare(this[_ids]!).map(c => `${this[_fields]![c]?.esName} = ?`).join(' AND ')} THEN ?`;
+        const columnMaps: Record<string, {
+            where: string[];
+            params: any[];
+        }> = Object.fromEntries(this[_columnsNoId]!.map(c => [c, {
+            where: new Array<string>(),
+            params: []
+        }]));
+        const params: any[] = [];
+        for (const data of datas) {
+            const ids = this[_ids]!.map(i => {
+                Throw.if(!data[i], `UPDATE ID NOT EXISTS!${JSON.stringify(data)}`);
+                return data[i];
+            });
+            this[_transformer]!(data,
+                {
+                    ...option,
+                    skipId: true,
+                    onFieldExists: (K, V) => {
+                        columnMaps[K]?.where.push(where);
+                        columnMaps[K]?.params.push(...ids, V);
+                    }
+                }
+            );
+        }
+        const sql = `UPDATE ${tableName} SET ${iterare(this[_columnsNoId]!)
+            .filter(K => columnMaps[K]!.where.length > 0)
+            .map(K => {
+                params.push(...columnMaps[K]!.params);
+                return `${this[_fields]![K]?.esName} = CASE ${columnMaps[K]!.where.join(' ')} ELSE ${this[_fields]![K]?.esName} END`
+            })
+            .join(',')};`
+        sqls.push({ sql, params });
+        return sqls;
+    }
+    /**
+    ## 根据主键修改
+    0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
+    1. `data`：可是数组或者单对象
+    2. `skipUndefined`: boolean; 是否不处理值为undefined的字段,默认 true
+    3. `skipNull`: boolean; 是否不处理值为null的字段,默认 true
+    4. `skipEmptyString`: boolean; 是否不处理值为空字符串(`注意：多个空格也算空字符串`)的字段,默认 true
+    5. `maxDeal`: number; 批量处理时，每次处理多少个？默认500
+    6. `tableName`: 默认使用service注解的`tableName`,可以在某个方法中覆盖
+    7. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+    8. `conn`: 仅在开启事务时需要主动传入,传入示例:
+        ```
+            service.transaction(async conn => {
+                service.insert({conn});
+            });
+        ```
+    9.  `dao`: 永远不需要传入该值
+     */
+    update(option: MethodOption & { data: Partial<T> | Array<Partial<T>>; sync?: SyncMode.Async; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; maxDeal?: number; }): Promise<number>;
+    update(option: MethodOption & { data: Partial<T> | Array<Partial<T>>; sync: SyncMode.Sync; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; maxDeal?: number; }): number;
+    @P<T>()
+    update(option: MethodOption & { data: Partial<T> | Array<Partial<T>>; sync?: SyncMode; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; maxDeal?: number; }): Promise<number> | number {
+        Throw.if(!this[_ids] || this[_ids].length === 0, 'not found id')
+        const datas = option.data instanceof Array ? option.data : [option.data];
+        if (option.sync === SyncMode.Sync) {
+            const fn = () => {
+                const result = excuteSplit<Partial<T>, number>(
+                    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.reduce((a, b) => a + b);
+            };
+            if (option?.conn?.[_inTransaction] === true) {
+                return fn();
+            } else {
+                return option?.dao?.transaction(SyncMode.Sync, fn, option?.conn)!;
+            }
+        } else {
+            const fn = async () => {
+                const result = await excuteSplit<Partial<T>, number>(
+                    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.reduce((a, b) => a + b);
+            };
+            return new Promise<number>(async (resolve) => {
+                if (option?.conn?.[_inTransaction] === true) {
+                    resolve((await fn())!);
+                } else {
+                    await option?.dao?.transaction(SyncMode.Async, async () => resolve((await fn())!), option?.conn);
+                }
+            });
+        }
+    }
+
+    /**
+    ## 删除
+    0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
+    1. 支持按ID删除：可以单个ID或者ID数组 `需要实体类只有一个ID`
+    2. 支持实体类删除: 用于多个ID或者按实体类某些字段删除
+    3. 两种模式：`mode`=`Common` 或者 `TempTable`
+    3. 如果数据多，使用 `TempTable`模式
+    4. 当设置实体类的字段有 `logicDelete` ，将进行逻辑删除，除非设置 forceDelete = true
+    6. `tableName`: 默认使用service注解的`tableName`,可以在某个方法中覆盖
+    7. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+    8. `conn`: 仅在开启事务时需要主动传入,传入示例:
+        ```
+            service.transaction(async conn => {
+                service.insert({conn});
+            });
+        ```
+    9.  `dao`: 永远不需要传入该值
+    */
+    delete(option: MethodOption & { sync?: SyncMode.Async; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: DeleteMode; forceDelete?: boolean; }): Promise<number>;
+    delete(option: MethodOption & { sync: SyncMode.Sync; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: DeleteMode; forceDelete?: boolean; }): number;
+    @P<T>()
+    delete(
+        option: MethodOption & {
+            sync?: SyncMode,
+            id?: string | number | Array<string | number>;
+            where?: Partial<T> | Array<Partial<T>>;
+            mode?: DeleteMode;
+            forceDelete?: boolean;
+        }
+    ): Promise<number> | number {
+        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 ??= DeleteMode.Common;
+        const tableTemp = `${option?.tableName}_${Math.random()}`.replace(/\./, '');
+        const tableTempESC = Sqlstring.escapeId(tableTemp);
+        const tableNameESC = Sqlstring.escapeId(option?.tableName);
+
+        if (option.id) {
+            const idName = this[_ids]![0]!;
+            const ids = option.id instanceof Array ? option.id : [option.id];
+            option.where = ids.map(i => ({ [idName]: i })) as Array<Partial<T>>;
+        }
+
+        const wheres = option.where instanceof Array ? option.where : [option.where!];
+
+        const sqls: { sql: string; params?: any[] }[] = [];
+        if (option.mode === DeleteMode.Common) {
+            const params = new Array<any>();
+            const whereSql = iterare(wheres).map(where => {
+                return `(
+                    ${Object.entries(where).map(([K, V]) => {
+                    params.push(V);
+                    return `${K} = ?`;
+                }).join(' AND ')}
+                )`;
+            }).join(' OR ');
+            if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                sqls.push({
+                    sql: `
+                    UPDATE ${tableNameESC} SET ${this[_fields]![this[_stateFileName]]?.esName} = ${Sqlstring.escape(this[_deleteState])}
+                    WHERE ${whereSql};
+                `, params
+                });
+            } else {
+                sqls.push({ sql: `DELETE FROM ${tableNameESC} WHERE ${whereSql};`, params });
+            }
+        } else {
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+            const delWhere = Object.keys(wheres[0] as unknown as any);
+            const _sqls = this._createTable({ tableName: tableTemp, temp: true, columns: delWhere, data: wheres, index: 'all', id: 'none' })!;
+            sqls.push(..._sqls);
+            switch (this[_dbType]) {
+                case DBType.Mysql: {
+                    if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                        sqls.push({
+                            sql: `UPDATE ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields]![K]?.esName} = b.${this[_fields]![K]?.esName}`).join(' AND ')}
+                            SET a.${this[_fields]![this[_stateFileName]]?.esName} = ${Sqlstring.escape(this[_deleteState])};`
+                        });
+                    } else {
+                        sqls.push({
+                            sql: `DELETE a.* FROM ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields]![K]?.esName} = b.${this[_fields]![K]?.esName}`).join(' AND ')};`
+                        });
+                    }
+                }
+                case DBType.Sqlite:
+                case DBType.SqliteRemote: {
+                    const columnNames = iterare(delWhere).map(K => this[_fields]![K]?.esName).join(',');
+                    if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                        sqls.push({
+                            sql: `UPDATE ${tableNameESC} SET ${this[_fields]![this[_stateFileName]]?.esName} = ${Sqlstring.escape(this[_deleteState])}
+                            WHERE (${columnNames}) IN (SELECT ${columnNames} FROM ${tableTempESC});`
+                        });
+                    } else {
+                        sqls.push({ sql: `DELETE FROM ${tableNameESC} WHERE (${columnNames}) IN (SELECT ${columnNames} FROM ${tableTempESC});` });
+                    }
+                }
+            }
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+        }
+
+        if (option.sync === 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?.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;
+            };
+            return new Promise<number>(async (resolve) => {
+                if (option?.conn?.[_inTransaction] === true) {
+                    resolve((await fn())!);
+                } else {
+                    await option?.dao?.transaction(SyncMode.Async, async () => resolve((await fn())!), option?.conn);
+                }
+            });
+        }
+    }
+
+    private _template(templateResult: TemplateResult, result: any, error?: string) {
+        switch (templateResult) {
+            case TemplateResult.AssertOne: {
+                Throw.if(!result || result.length !== 1, error);
+                return result[0] as T;
+            }
+            case TemplateResult.NotSureOne: {
+                Throw.if(!result, error);
+                return (result[0] as T) ?? null;
+            }
+            case TemplateResult.Many: {
+                return result;
+            }
+            case TemplateResult.Count: {
+                return result[0].ct;
+            }
+        }
+    }
+    /**
+    #根据条件查询对象
+    ## 特点：快速、简单，可快速根据某些字段是否等于来查询返回，可以查询记录和记录数
+    0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
+    1. `templateResult`: 返回值类型断言，4种
+        1. `AssertOne` 确定返回一个，如果不是一个，将报错，返回类型是T `默认`
+        2. `NotSureOne` 可能返回一个，返回类型是T|null
+        3. `Many` 返回多个
+        4. `Count` 返回记录数
+    2. 支持按ID查询：可以单个ID或者ID数组 `需要实体类只有一个ID`
+    3. 支持实体类查询: 用于多个ID或者按实体类某些字段查询
+    4. 两种查询方式：`mode`=`Common`(默认) 或者 `TempTable`
+    5. `tableName`: 默认使用service注解的`tableName`,可以在某个方法中覆盖
+    6. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+    7. `conn`: 仅在开启事务时需要主动传入,传入示例:
+        ```
+            service.transaction(async conn => {
+                service.insert({conn});
+            });
+        ```
+    8.  `dao`: 永远不需要传入该值
+
+     */
+    template(option: MethodOption & { templateResult?: TemplateResult.AssertOne; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: SelectMode; error?: string; columns?: (keyof T)[]; }): Promise<T>;
+    template(option: MethodOption & { sync: SyncMode.Sync; templateResult?: TemplateResult.AssertOne; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: SelectMode; error?: string; columns?: (keyof T)[]; }): T;
+    template(option: MethodOption & { sync: SyncMode.Async; templateResult?: TemplateResult.AssertOne; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: SelectMode; error?: string; columns?: (keyof T)[]; }): Promise<T>;
+    template(option: MethodOption & { templateResult: TemplateResult.Count; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: SelectMode; error?: string; columns?: (keyof T)[]; }): Promise<number>;
+    template(option: MethodOption & { sync: SyncMode.Sync; templateResult: TemplateResult.Count; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: SelectMode; error?: string; columns?: (keyof T)[]; }): number;
+    template(option: MethodOption & { sync: SyncMode.Async; templateResult: TemplateResult.Count; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: SelectMode; error?: string; columns?: (keyof T)[]; }): Promise<number>;
+    template(option: MethodOption & { templateResult: TemplateResult.NotSureOne; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: SelectMode; error?: string; columns?: (keyof T)[]; }): Promise<T | null>;
+    template(option: MethodOption & { sync: SyncMode.Sync; templateResult: TemplateResult.NotSureOne; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: SelectMode; error?: string; columns?: (keyof T)[]; }): T | null;
+    template(option: MethodOption & { sync: SyncMode.Async; templateResult: TemplateResult.NotSureOne; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: SelectMode; error?: string; columns?: (keyof T)[]; }): Promise<T | null>;
+    template(option: MethodOption & { templateResult: TemplateResult.Many; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: SelectMode; error?: string; columns?: (keyof T)[]; }): Promise<T[]>;
+    template(option: MethodOption & { sync: SyncMode.Sync; templateResult: TemplateResult.Many; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: SelectMode; error?: string; columns?: (keyof T)[]; }): T[];
+    template(option: MethodOption & { sync: SyncMode.Async; templateResult: TemplateResult.Many; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: SelectMode; error?: string; columns?: (keyof T)[]; }): Promise<T[]>;
+    @P<T>()
+    template(option: MethodOption & { sync?: SyncMode; templateResult?: TemplateResult; id?: string | number | Array<string | number>; where?: Partial<T> | Array<Partial<T>>; mode?: SelectMode; error?: string; columns?: (keyof T)[]; }): number | T | null | T[] | Promise<number | T | null | T[]> {
+        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 ??= SelectMode.Common;
+        option.templateResult ??= TemplateResult.AssertOne;
+        option.error ??= 'error data!';
+        const tableTemp = `${option?.tableName}_${Math.random()}`.replace(/\./, '');
+        const tableTempESC = Sqlstring.escapeId(tableTemp);
+        const tableNameESC = Sqlstring.escapeId(option?.tableName);
+
+        if (option.id) {
+            const idName = this[_ids]![0]!;
+            const ids = option.id instanceof Array ? option.id : [option.id];
+            option.where = ids.map(i => ({ [idName]: i })) as Array<Partial<T>>;
+        }
+        const columns = option.templateResult === TemplateResult.Count ? 'COUNT(1) ct' : iterare((option.columns as unknown as string[] ?? this[_columns])!).map((K: any) => `a.${this[_fields]![K]?.esName}`).join(',');
+        const wheres = option.where instanceof Array ? option.where : [option.where!];
+        const sqls: { sql: string; params?: any[] }[] = [];
+        let resultIndex = -1;
+        if (option.mode === SelectMode.Common) {
+            const params = new Array<any>();
+            const whereSql = iterare(wheres).map(where => {
+                return `SELECT ${columns} FROM ${tableNameESC} a WHERE
+                    ${Object.entries(where).map(([K, V]) => {
+                    params.push(V);
+                    return `${K} = ?`;
+                }).join(' AND ')}`;
+            }).join(' UNION ALL ');
+            sqls.push({ sql: whereSql, params });
+            resultIndex = 0;
+        } else {
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+            const delWhere = Object.keys(wheres[0] as unknown as any);
+            const _sqls = this._createTable({ tableName: tableTemp, temp: true, columns: delWhere, data: wheres, index: 'all', id: 'none' })!;
+            sqls.push(..._sqls);
+            resultIndex = sqls.length;
+            sqls.push({ sql: `SELECT ${columns} FROM ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields]![K]?.esName} = b.${this[_fields]![K]?.esName}`).join(' AND ')};` });
+            sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+        }
+
+        if (option.sync === SyncMode.Sync) {
+            let result: any;
+            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<T | null | T[]>(async (resolve) => {
+                let result: any;
+                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));
+            });
+        }
+    }
+
+    private _select<L = T>(templateResult: SelectResult, result: any, def: L | null, errorMsg?: string, multiple?: boolean) {
+        if (multiple === true) {
+            switch (templateResult) {
+                case SelectResult.One_Row_One_Column_NotSure: {
+                    try {
+                        return result.map((r: any) => Object.values(r)[0] as L);
+                    } catch (error) {
+                    }
+                }
+                case SelectResult.One_Row_One_Column_Assert: {
+                    try {
+                        return iterare(result).map((r: any) => Object.values(r)[0] as L).filter((r: L) => r !== null).toArray();
+                    } catch (error) {
+                    }
+                }
+                case SelectResult.One_Row_Many_Column_NotSure: {
+                    try {
+                        return result.map((r: any) => r[0] as L);
+                    } catch (error) {
+                    }
+                }
+                case SelectResult.One_Row_Many_Column_Assert: {
+                    try {
+                        return iterare(result).map((r: any) => r[0] as L).filter((r: L) => r !== null).toArray();
+                    } catch (error) {
+                    }
+                }
+                case SelectResult.Many_Row_One_Column: {
+                    try {
+                        return result.map((rx: any) => rx.map((r: any) => Object.values(r)[0] as L));
+                    } catch (error) {
+                    }
+                }
+                case SelectResult.Many_Row_Many_Column: {
+                    return result as L[];
+                }
+            }
+        } else {
+            switch (templateResult) {
+                case SelectResult.One_Row_One_Column_NotSure: {
+                    try {
+                        return Object.values(result[0])[0] as L;
+                    } catch (error) {
+                        return def;
+                    }
+                }
+                case SelectResult.One_Row_One_Column_Assert: {
+                    try {
+                        return Object.values(result[0])[0] as L;
+                    } catch (error) {
+                        if (def !== undefined) return def;
+                        Throw.now(errorMsg ?? 'not found data!');
+                    }
+                }
+                case SelectResult.One_Row_Many_Column_NotSure: {
+                    return (result[0] as L) ?? null;
+                }
+                case SelectResult.One_Row_Many_Column_Assert: {
+                    const data = result[0] as L;
+                    Throw.if(data === null, errorMsg ?? 'not found data!');
+                    return data ?? null;
+                }
+                case SelectResult.Many_Row_One_Column: {
+                    try {
+                        return result.map((r: any) => Object.values(r)[0] as L);
+                    } catch (error) {
+                        return def;
+                    }
+                }
+                case SelectResult.Many_Row_Many_Column: {
+                    return result as L[];
+                }
+            }
+        }
+    }
+    /**
+    # 自由查询
+    0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
+    1. `templateResult`: 返回值类型断言，三种
+        1. One_Row_One_Column_Assert,
+        2. One_Row_One_Column_NotSure,
+        3. One_Row_Many_Column_Assert,
+        4. One_Row_Many_Column_NotSure,
+        5. Many_Row_One_Column,
+        6. Many_Row_Many_Column[默认]
+    2. `sql` 或者 `sqlid`
+    3. `params`
+    4. `defValue`: One_Row_One_Column 时有效
+    5. `multiple`: = true 时表示多重sql查询，且每个sql的结果都是相同的resultMode, 此时 `One_Row_One_Column` `Many_Row_One_Column` `One_Row_Many_Column` 将按多重数组解析，`Many_Row_Many_Column` 不变，此时需要自己手动指定返回类型.
+        此时 `One_Row_One_Column` 将返回多个单值组成的数组: `[1, 'ok', 3]`
+             `One_Row_Many_Column` 将返回多个对象组成的数组: `[{ob1}, {ob2}, {ob3}]`
+             `Many_Row_One_Column` 将返回多个单值数组组成的数组: `[[1,2,3],  ['a', 'b']]`
+    6. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+    7. `conn`: 仅在开启事务时需要主动传入,传入示例:
+        ```
+            service.transaction(async conn => {
+                service.insert({conn});
+            });
+        ```
+    9.  `dao`: 永远不需要传入该值
+
+     */
+    select<L = T>(option: MethodOption & { sync?: SyncMode.Async; selectResult?: SelectResult.Many_Row_Many_Column | SelectResult.Many_Row_One_Column; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; multiple?: boolean; errorMsg?: string }): Promise<L[]>;
+    select<L = T>(option: MethodOption & { sync?: SyncMode.Async; selectResult: SelectResult.One_Row_Many_Column_Assert | SelectResult.One_Row_One_Column_Assert; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; multiple?: boolean; errorMsg?: string; }): Promise<L>;
+    select<L = T>(option: MethodOption & { sync?: SyncMode.Async; selectResult: SelectResult.One_Row_Many_Column_NotSure | SelectResult.One_Row_One_Column_NotSure; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; multiple?: boolean; errorMsg?: string }): Promise<L | null>;
+    select<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult?: SelectResult.Many_Row_Many_Column | SelectResult.Many_Row_One_Column; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; multiple?: boolean; errorMsg?: string }): L[];
+    select<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult: SelectResult.One_Row_Many_Column_Assert | SelectResult.One_Row_One_Column_Assert; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; multiple?: boolean; errorMsg?: string; }): L;
+    select<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult: SelectResult.One_Row_Many_Column_NotSure | SelectResult.One_Row_One_Column_NotSure; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; multiple?: boolean; errorMsg?: string }): L | null;
+    @P<T>()
+    select<L = T>(option: MethodOption & { sync?: SyncMode; selectResult?: SelectResult; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; multiple?: boolean; errorMsg?: string; }): null | L | L[] | Promise<null | L | L[]> {
+        Throw.if(!option.sqlId && !option.sql, 'not found sql!');
+        option.selectResult ??= SelectResult.Many_Row_Many_Column;
+        option.defValue ??= null;
+        const _params = Object.assign({}, option.context, option.params);
+        option.sql ??= globalThis[_sqlCache].load(option.sqlId, { ctx: option.context, isCount: option.isCount, ..._params });
+        logger.debug(option.sql);
+        const params: any[] = [];
+        const sql = option.sql?.replace(/\:(\w+)/g, (txt, key) => {
+            if (_params.hasOwnProperty(key)) {
+                const V = _params[key];
+                params.push(V);
+                return Sqlstring.escape(_params[key]);
+            }
+            return txt;
+        });
+        if (option.sync === SyncMode.Sync) {
+            const result = option!.conn!.query(SyncMode.Sync, sql, params);
+            return this._select<L>(option.selectResult, result, option.defValue, option.errorMsg, option.multiple);
+        } else {
+            return new Promise<L | null | L[]>(async (resolve) => {
+                const result = await option!.conn!.query(SyncMode.Async, sql, params);
+                resolve(this._select<L>(option.selectResult!, result, option.defValue!, option.errorMsg, option.multiple));
+            });
+        }
+    }
+
+    /**
+     # 自由执行sql
+     0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
+     1. `sql` 或者 `sqlid`
+     2. `params`
+     3. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
+     4. `conn`: 仅在开启事务时需要主动传入,传入示例:
+         ```
+             service.transaction(async conn => {
+                 service.insert({conn});
+             });
+         ```
+     5.  `dao`: 永远不需要传入该值
+ 
+      */
+    excute<L = T>(option: MethodOption & { sync?: SyncMode.Async; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; }): Promise<number>;
+    excute<L = T>(option: MethodOption & { sync: SyncMode.Sync; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; }): number;
+    @P<T>()
+    excute<L = T>(option: MethodOption & { sync?: SyncMode; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; }): number | Promise<number> {
+        Throw.if(!option.sqlId && !option.sql, 'not found sql!');
+        const _params = Object.assign({}, option.context, option.params);
+        option.sql ??= globalThis[_sqlCache].load(option.sqlId, { ctx: option.context, ..._params });
+        logger.debug(option.sql);
+        const params: any[] = [];
+        const sql = option.sql?.replace(/\:(\w+)/g, (txt, key) => {
+            if (_params.hasOwnProperty(key)) {
+                const V = _params[key];
+                params.push(V);
+                return Sqlstring.escape(_params[key]);
+            }
+            return txt;
+        });
+        if (option.sync === SyncMode.Sync) {
+            const result = option!.conn!.execute(SyncMode.Sync, sql, params);
+            return result.affectedRows;
+        } else {
+            return new Promise<number>(async (resolve) => {
+                const result = await option!.conn!.execute(SyncMode.Async, sql, params);
+                resolve(result.affectedRows);
+            });
+        }
+    }
+
+    /**
+     ### 开启事务
+     ### 这里面的所有数据方法，都必须传递CONN，否则会引起
+     # 死锁
+     ### 举例说明：
+     #### 假设有两条代码，都操作同一个表A，其中代码1传了conn，但代码2没有传
+     #### 代码1：插入数据，代码2：更新数据
+     #### 二者操作的是不同的数据
+     #### 以上为前提，开始分析：
+     ** 当事务打开后，会创建一个连接1，开始执行代码1
+     ** 代码1执行完毕，由于`transaction`方法尚未结束，所以不会提交事务。
+     ** 代码1是插入数据，因此会导致全表锁
+     ** 代码2开始执行，由于没有传入conn，所以会创建一个新的连接2
+     ** 代码2执行时，会等待连接1的锁释放
+     ** 但是连接1的锁是在`transaction`方法执行完后才会提交并释放锁，这导致死循环，开启死锁
+     **
+     */
+    transaction<L = T>(option: MethodOption & { sync?: SyncMode.Async; fn: (conn: Connection) => Promise<L>; }): Promise<L | null>;
+    transaction<L = T>(option: MethodOption & { sync: SyncMode.Sync; fn: (conn: Connection) => L; }): L | null;
+    @P<T>(true)
+    transaction<L = T>(option: MethodOption & { sync?: SyncMode; fn: (conn: Connection) => L | Promise<L>; }): L | null | Promise<L | null> {
+        if (option.sync === SyncMode.Sync) {
+            return option!.dao!.transaction(SyncMode.Sync, option.fn as (conn: Connection) => L)!;
+        } else {
+            return new Promise(async (resolve) => {
+                const rt = await option!.dao!.transaction(SyncMode.Async, option.fn as (conn: Connection) => Promise<L>);
+                resolve(rt);
+            });
+        }
+    }
+
+    stream(option?: MethodOption) {
+        return new StreamQuery(option?.tableName ?? this[_tableName]!, this);
+    }
+
+    /**
+    #创建表
+    ** `tableName` 表名称
+    ** `temp` 是否是临时表，默认true
+    ** `columns` 字符串数组，默认是当前实体类全部字段，通过`columns` 可以创建部分字段临时表
+    ** `id` 表的主键设置 4种：
+    1. `auto`: `columns`中已经在当前实体类配置的ID作为主键 `默认`
+    2. `all`: `columns`中所有字段全部当主键
+    3. `none`: 没有主键
+    4. 自定义字段名称：字符串数组
+    ** `index` 表的索引，设置方式同ID
+     */
+    private _createTable({ tableName, temp = true, columns, data, id = 'auto', index = 'auto' }: {
+        tableName?: string;
+        temp?: boolean,
+        columns?: string[];
+        data?: Array<Partial<T>>;
+        id?: 'auto' | 'all' | 'none' | string[];
+        index?: 'auto' | 'all' | 'none' | string[];
+    } = {}): { sql: string; params?: any[] }[] {
+        const sqls: { sql: string; params?: any[] }[] = [];
+        columns = columns || this[_columns]!;
+        let ids: string[] | undefined;
+        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: string[] | undefined;
+        if (index === 'auto') {
+            indexs = this[_index]?.filter(i => columns?.includes(i));
+        } else if (index === 'all') {
+            indexs = columns;
+        } else if (index === 'none') {
+            indexs = undefined;
+        } else {
+            indexs = index;
+        }
+        tableName = Sqlstring.escapeId(tableName ?? this[_tableName]);
+        switch (this[_dbType]) {
+            case DBType.Mysql: {
+                let sql = `CREATE ${temp === true ? 'TEMPORARY' : ''} TABLE IF NOT EXISTS ${tableName}(
+                    ${columns.map(K => this[_fields]![K]![DBType.Mysql]).join(',')}
+                    ${ids && ids.length ? `,PRIMARY KEY (${ids.map(i => this[_fields]![i]?.esName).join(',')})  USING BTREE ` : ''}
+                    ${indexs && indexs.length ? `,${indexs.map(i => `KEY ${this[_fields]![i]?.esName} (${this[_fields]![i]?.esName})`).join(',')} ` : ''}
+                ) ENGINE=MEMORY;`;
+                sqls.push({ sql });
+                if (data && data.length > 0) {
+                    const params: any[] = [];
+                    let first = true;
+                    sql = `INSERT INTO ${tableName} (${columns.map(c => Sqlstring.escapeId(c)).join(',')})
+                    ${(data).map(d => {
+                        const r = `SELECT ${Object.entries(d).map(([K, V]) => {
+                            params.push(V);
+                            return `? ${first ? this[_fields]![K]?.esName : ''}`;
+                        }).join(',')}`;
+                        first = false;
+                        return r;
+                    }).join(' UNION ALL ')}`;
+                    sqls.push({ sql, params });
+                }
+                break;
+            }
+            case DBType.Sqlite:
+            case DBType.SqliteRemote: {
+                let sql = `CREATE ${temp === true ? 'TEMPORARY' : ''} TABLE IF NOT EXISTS ${tableName}(
+                    ${columns.map(K => this[_fields]![K]![DBType.Sqlite]).join(',')}
+                    ${ids && ids.length ? `,PRIMARY KEY (${ids.map(i => this[_fields]![i]?.esName).join(',')}) ` : ''}
+                );`;
+                sqls.push({ sql });
+                if (indexs) {
+                    for (const index of indexs) {
+                        sql = `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableName} (${this[_fields]![index]?.esName});`;
+                        sqls.push({ sql });
+                    }
+                }
+                if (data && data.length > 0) {
+                    const params: any[] = [];
+                    let first = true;
+                    sql = `INSERT INTO ${tableName} (${columns.map(c => Sqlstring.escapeId(c)).join(',')})
+                    ${(data).map(d => {
+                        const r = `SELECT ${Object.entries(d).map(([K, V]) => {
+                            params.push(V);
+                            return `? ${first ? this[_fields]![K]?.esName : ''}`;
+                        }).join(',')}`;
+                        first = false;
+                        return r;
+                    }).join(' UNION ALL ')}`;
+                    sqls.push({ sql, params });
+                }
+            }
+        }
+        return sqls;
+    }
+
+}
+/** 是否进行下一个动作 */
+const IF_PROCEED = function <T extends object>() {
+    return function (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
+        const fn = descriptor.value;
+        descriptor.value = function (this: StreamCondition<T>) {
+            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 <T extends object>(def: any) {
+    return function (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) {
+        const fn = descriptor.value;
+        descriptor.value = async function (this: StreamQuery<T>) {
+            if (this.if_proceed === true && this.if_exec === true) {
+                // eslint-disable-next-line prefer-rest-params
+                const args = Array.from(arguments);
+                return await fn.call(this, ...args);
+            } else {
+                return def;
+            }
+        };
+    };
+};
+class StreamCondition<T extends object> {
+    protected _prefix = 0;
+    protected _index = 0;
+
+    protected _wheres: string[] = [];
+
+    protected _andQuerys: StreamCondition<T>[] = [];
+    protected _orQuerys: StreamCondition<T>[] = [];
+
+    protected _paramKeys: Record<string, string[] | Record<string, string> | string> = {};
+    protected _param: Record<string, any> = {};
+    public if_proceed = true;
+    public if_exec = true;
+    constructor() {
+        this._prefix = parseInt(`${Math.random() * 1000}`);
+    }
+    /** 将当前stream重置 */
+    reset() {
+        this._index = 0;
+        this._wheres.length = 0;
+        this._param = {};
+        this._paramKeys = {};
+        return this;
+    }
+    /** 为下次链条执行提供条件判断：非异步方法跳过，异步方法不执行并返回默认值 */
+    @IF_PROCEED<T>()
+    if(condition: boolean) {
+        this.if_proceed = condition;
+        return this;
+    }
+    @IF_PROCEED<T>()
+    eq(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._(key, value, '=', { name }); }
+    @IF_PROCEED<T>()
+    eqT(t: Partial<T>, { name }: { name?: string } = {}) {
+        if (name && this._paramKeys[name]) {
+            for (const [key, pname] of Object.entries(this._paramKeys[name] as Record<string, string>)) {
+                this._param[pname as string] = t[key];
+            }
+        } else {
+            const paramKeys: Record<string, string> = {};
+            for (const [key, value] of Object.entries(t)) {
+                const pkey = `p${this._prefix}${this._index++}`;
+                this._wheres.push(`AND ${String(key)} = :${pkey} `);
+                this._param[pkey] = value;
+                if (name) {
+                    paramKeys[key] = pkey;
+                }
+            }
+            if (name) {
+                this._paramKeys[name] = paramKeys;
+            }
+        }
+        return this;
+    }
+    @IF_PROCEED<T>()
+    notEq(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._(key, value, '<>', { name }); }
+    @IF_PROCEED<T>()
+    eqWith(key1: keyof T, key2: keyof T) { return this._key(key1, key2, '='); }
+    @IF_PROCEED<T>()
+    notEqWith(key1: keyof T, key2: keyof T) { return this._key(key1, key2, '<>'); }
+    @IF_PROCEED<T>()
+    regexp(key: keyof T, regexp: string, { name }: { name?: string } = {}) { return this._(key, regexp, 'REGEXP', { name }); }
+    @IF_PROCEED<T>()
+    notRegexp(key: keyof T, regexp: string, { name }: { name?: string } = {}) { return this._(key, regexp, 'REGEXP', { name, not: 'NOT' }); }
+    /** (key1 << 8) + key2 = value */
+    @IF_PROCEED<T>()
+    shiftEq(key1: keyof T, key2: keyof T, value: number, { name }: { name?: string } = {}) { return this._shift(key1, key2, value, '=', { name }); }
+    /** (key1 << 8) + key2 <> value */
+    @IF_PROCEED<T>()
+    shiftNotEq(key1: keyof T, key2: keyof T, value: number, { name }: { name?: string } = {}) { return this._shift(key1, key2, value, '<>', { name }); }
+    @IF_PROCEED<T>()
+    grate(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._(key, value, '>', { name }); }
+    @IF_PROCEED<T>()
+    grateEq(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._(key, value, '>=', { name }); }
+    @IF_PROCEED<T>()
+    grateWith(key1: keyof T, key2: keyof T) { return this._key(key1, key2, '>'); }
+    @IF_PROCEED<T>()
+    grateEqWith(key1: keyof T, key2: keyof T) { return this._key(key1, key2, '>='); }
+    @IF_PROCEED<T>()
+    less(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._(key, value, '<', { name }); }
+    @IF_PROCEED<T>()
+    lessEq(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._(key, value, '<=', { name }); }
+    @IF_PROCEED<T>()
+    lessWith(key1: keyof T, key2: keyof T) { return this._key(key1, key2, '<'); }
+    @IF_PROCEED<T>()
+    lessEqWith(key1: keyof T, key2: keyof T) { return this._key(key1, key2, '<='); }
+    @IF_PROCEED<T>()
+    like(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, left: '%', right: '%', force }); }
+    @IF_PROCEED<T>()
+    notLike(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, left: '%', right: '%', not: 'NOT', force }); }
+    @IF_PROCEED<T>()
+    leftLike(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, left: '%', force }); }
+    @IF_PROCEED<T>()
+    notLeftLike(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, left: '%', not: 'NOT', force }); }
+    @IF_PROCEED<T>()
+    rightLike(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, right: '%', force }); }
+    @IF_PROCEED<T>()
+    notRightLike(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, right: '%', not: 'NOT', force }); }
+    @IF_PROCEED<T>()
+    PreciseLike(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, force }); }
+    @IF_PROCEED<T>()
+    notPreciseLike(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, not: 'NOT', force }); }
+    @IF_PROCEED<T>()
+    glob(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, left: '%', right: '%', force, op: 'glob' }); }
+    @IF_PROCEED<T>()
+    notGlob(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, left: '%', right: '%', not: 'NOT', force, op: 'glob' }); }
+    @IF_PROCEED<T>()
+    leftGlob(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, left: '%', force, op: 'glob' }); }
+    @IF_PROCEED<T>()
+    notLeftGlob(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, left: '%', not: 'NOT', force, op: 'glob' }); }
+    @IF_PROCEED<T>()
+    rightGlob(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, right: '%', force, op: 'glob' }); }
+    @IF_PROCEED<T>()
+    notRightGlob(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, right: '%', not: 'NOT', force, op: 'glob' }); }
+    @IF_PROCEED<T>()
+    PreciseGlob(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, force, op: 'glob' }); }
+    @IF_PROCEED<T>()
+    notPreciseGlob(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, not: 'NOT', force, op: 'glob' }); }
+    @IF_PROCEED<T>()
+    in(key: keyof T, value: Array<string | number>, { name, force }: { name?: string; force?: boolean; } = {}) { return this._in(key, value, { name, force }); }
+    @IF_PROCEED<T>()
+    notIn(key: keyof T, value: Array<string | number>, { name, force }: { name?: string; force?: boolean; } = {}) { return this._in(key, value, { name, not: 'NOT', force }); }
+    @IF_PROCEED<T>()
+    isNULL(key: keyof T) { return this._null(key); }
+    @IF_PROCEED<T>()
+    isNotNULL(key: keyof T) { return this._null(key, 'NOT'); }
+    @IF_PROCEED<T>()
+    between(key: keyof T, value1: string | number, value2: string | number, { name }: { name?: string } = {}) { return this._between(key, value1, value2, { name }); }
+    @IF_PROCEED<T>()
+    notBetween(key: keyof T, value1: string | number, value2: string | number, { name }: { name?: string } = {}) { return this._between(key, value1, value2, { name, not: 'NOT' }); }
+    @IF_PROCEED<T>()
+    pow(key: keyof T, value: number, { name }: { name?: string } = {}) { return this._pow(key, value, { name }); }
+    @IF_PROCEED<T>()
+    notPow(key: keyof T, value: number, { name }: { name?: string } = {}) { return this._pow(key, value, { name, not: 'NOT' }); }
+    @IF_PROCEED<T>()
+    powWith(key: keyof T, values: Array<number | string>, { name }: { name?: string } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { name }); }
+    @IF_PROCEED<T>()
+    notPowWith(key: keyof T, values: Array<number | string>, { name }: { name?: string } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { name, not: 'NOT' }); }
+    /** MATCH(key1, key2, key3) AGAINST (value) */
+    @IF_PROCEED<T>()
+    match(value: string, keys: (keyof T)[], { name }: { name?: string } = {}) { return this._match(value, keys, { name }); }
+    /** NOT MATCH(key1, key2, key3) AGAINST (value) */
+    @IF_PROCEED<T>()
+    notMatch(value: string, keys: (keyof T)[], { name }: { name?: string } = {}) { return this._match(value, keys, { name, not: 'NOT' }); }
+    /** MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE*/
+    @IF_PROCEED<T>()
+    matchBoolean(value: string, keys: (keyof T)[], { name }: { name?: string } = {}) { return this._match(value, keys, { name, append: 'IN BOOLEAN MODE' }); }
+    /** NOT MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE */
+    @IF_PROCEED<T>()
+    notMatchBoolean(value: string, keys: (keyof T)[], { name }: { name?: string } = {}) { return this._match(value, keys, { name, not: 'NOT', append: 'IN BOOLEAN MODE' }); }
+    /** MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
+    @IF_PROCEED<T>()
+    matchQuery(value: string, keys: (keyof T)[], { name }: { name?: string } = {}) { return this._match(value, keys, { name, append: 'WITH QUERY EXPANSION' }); }
+    /** NOT MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
+    @IF_PROCEED<T>()
+    notMatchQuery(value: string, keys: (keyof T)[], { name }: { name?: string } = {}) { return this._match(value, keys, { name, not: 'NOT', append: 'WITH QUERY EXPANSION' }); }
+    @IF_PROCEED<T>()
+    includes(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._includes(key, value, { name }); }
+    @IF_PROCEED<T>()
+    notIncludes(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._includes(key, value, { name, not: 'NOT' }); }
+    @IF_PROCEED<T>()
+    and(fn: (stream: StreamCondition<T>) => boolean | void) { const stream = new StreamCondition<T>(); const ret = fn(stream); if (ret !== false) { this._andQuerys.push(stream); } return this; }
+    @IF_PROCEED<T>()
+    or(fn: (stream: StreamCondition<T>) => boolean | void) { const stream = new StreamCondition<T>(); const ret = fn(stream); if (ret !== false) { this._orQuerys.push(stream); } return this; }
+    protected where() {
+        const wheres = new Array<string>();
+        const sql = this._wheres.join(' ');
+        if (sql) {
+            wheres.push(`(${sql})`);
+        }
+        if (this._orQuerys.length > 0) {
+            for (const query of this._orQuerys) {
+                const { where, params } = query.where();
+                if (where) {
+                    wheres.push(` OR (${where}) `);
+                }
+                Object.assign(this._param, params);
+            }
+        }
+        if (this._andQuerys.length > 0) {
+            for (const query of this._andQuerys) {
+                const { where, params } = query.where();
+                if (where) {
+                    wheres.push(` AND (${where}) `);
+                }
+                Object.assign(this._param, params);
+            }
+        }
+        return { where: wheres.join(' '), params: this._param };
+    }
+    private _(key: keyof T, value: any, op: string, { not = '', name = '' } = {}) {
+        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+            this._param[this._paramKeys[name] as string] = value;
+        } else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND ${String(key)} ${not} ${op} :${pkey} `);
+            this._param[pkey] = value;
+            if (name) {
+                this._paramKeys[name] = pkey;
+            }
+        }
+        return this;
+    }
+    private _null(key: keyof T, not = ''): this {
+        this._wheres.push(`AND ${String(key)} is ${not} null`);
+        return this;
+    }
+    private _key(key1: keyof T, key2: keyof T, op: string, not = '') {
+        this._wheres.push(`AND ${String(key1)} ${not} ${op} ${String(key2)} `);
+        return this;
+    }
+    private _between(key: keyof T, value1: string | number, value2: string | number, { not = '', name = '' } = {}) {
+        if (name && this._paramKeys[name]) {
+            this._param[this._paramKeys[name]![0]] = value1;
+            this._param[this._paramKeys[name]![1]] = value2;
+        } else {
+            const [pkey1, pkey2] = [`p${this._prefix}${this._index++}`, `p${this._prefix}${this._index++}`];
+            this._wheres.push(`AND ${String(key)} ${not} BETWEEN :${pkey1} AND :${pkey2}`);
+            this._param[pkey1] = value1;
+            this._param[pkey2] = value2;
+            if (name) {
+                this._paramKeys[name] = [pkey1, pkey2];
+            }
+        }
+        return this;
+    }
+    private _in(key: keyof T, value: any, { not = '', name = '', force = false } = {}) {
+        if (value && value.length > 0) {
+            if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+                this._param[this._paramKeys[name] as string] = value;
+            } else {
+                const pkey = `p${this._prefix}${this._index++}`;
+                this._wheres.push(`AND ${String(key)} ${not} IN (:${pkey}) `);
+                this._param[pkey] = value;
+                if (name) {
+                    this._paramKeys[name] = pkey;
+                }
+            }
+        } else if (force !== true) {
+            this.if_exec = false;
+        }
+        return this;
+    }
+    private _shift(key1: keyof T, key2: keyof T, value: number, op: string, { not = '', name = '' } = {}) {
+        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+            this._param[this._paramKeys[name] as string] = value;
+        } else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND (${String(key1)} << 8) + ${String(key2)} ${not} ${op} :${pkey} `);
+            this._param[pkey] = value;
+            if (name) {
+                this._paramKeys[name] = pkey;
+            }
+        }
+        return this;
+    }
+    private _match(value: string, keys: (keyof T)[], { name, not, append }: { name?: string; not?: string; append?: string; } = {}) {
+        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+            this._param[this._paramKeys[name] as string] = value;
+        } else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND MATCH(${keys.join(',')}) AGAINST (:${pkey} ${append ?? ''})`);
+            this._param[pkey] = value;
+            if (name) {
+                this._paramKeys[name] = pkey;
+            }
+        }
+        return this;
+    }
+    private _pow(key: keyof T, value: number, { name }: { name?: string; not?: string; } = {}) {
+        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+            this._param[this._paramKeys[name] as string] = value;
+        } else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND NOT POW(2, ${String(key)}) & :${pkey}`);
+            this._param[pkey] = value;
+            if (name) {
+                this._paramKeys[name] = pkey;
+            }
+        }
+        return this;
+    }
+    private _like(key: keyof T, value: any, { not = '', left = '', right = '', name = '', op = 'LIKE', force = false } = {}) {
+        if (value !== null && value !== undefined && value !== '') {
+            if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+                this._param[this._paramKeys[name] as string] = value;
+            } else {
+                const pkey = `p${this._prefix}${this._index++}`;
+                this._wheres.push(`AND ${String(key)} ${not} ${op} CONCAT('${left}', :${pkey}, '${right}') `);
+                this._param[pkey] = value;
+                if (name) {
+                    this._paramKeys[name] = pkey;
+                }
+            }
+        } else if (force !== true) {
+            this.if_exec = false;
+        }
+        return this;
+    }
+    private _includes(key: keyof T, value: any, { not = '', name = '' } = {}) {
+        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
+            this._param[this._paramKeys[name] as string] = value;
+        } else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND LOCATE(${String(key)}, :${pkey}) ${not ? '=' : ''}  0`);
+            this._param[pkey] = value;
+            if (name) {
+                this._paramKeys[name] = pkey;
+            }
+        }
+        return this;
+    }
+}
+class StreamBuild<T extends object> extends StreamCondition<T>{
+    protected _table: string;
+
+    protected _distinct = false;
+    protected _columns: string[] = [];
+
+    protected _updates?: Partial<T>;
+    protected _updateColumns: string[] = [];
+
+    protected _groups: (keyof T)[] = [];
+    protected _orders: string[] = [];
+
+    protected _startRow = 0;
+    protected _pageSize = 0;
+
+    constructor(table: string) {
+        super();
+        this._table = table;
+    }
+    /** 将当前stream重置 */
+    reset() {
+        super.reset();
+        this._pageSize = 0;
+        this._startRow = 0;
+        this._orders.length = 0;
+        this._groups.length = 0;
+        this._columns.length = 0;
+        this._updateColumns.length = 0;
+        return this;
+    }
+    @IF_PROCEED<T>()
+    groupBy(key: keyof T) { this._groups.push(key); return this; }
+    @IF_PROCEED<T>()
+    asc(...keys: (keyof T)[]) { this._orders.push(...keys.map(key => `${String(key)} ASC`)); return this; }
+    @IF_PROCEED<T>()
+    desc(...keys: (keyof T)[]) { this._orders.push(...keys.map(key => `${String(key)} DESC`)); return this; }
+    @IF_PROCEED<T>()
+    limit(startRow: number, pageSize: number) { this._startRow = startRow; this._pageSize = pageSize; return this; }
+    @IF_PROCEED<T>()
+    page(pageNumber: number, pageSize: number) { this._startRow = ((pageNumber || 1) - 1) * pageSize; this._pageSize = pageSize; return this; }
+    @IF_PROCEED<T>()
+    table(_table: string) { this._table = _table; return this; }
+    @IF_PROCEED<T>()
+    distinct(on = true) { this._distinct = on; return this; }
+    @IF_PROCEED<T>()
+    count(key: keyof T, countName?: string, distinct?: boolean) { this._columns.push(`COUNT(${distinct ? 'DISTINCT' : ''} ${String(key)}) ${countName || `${String(key)}`}`); return this; }
+    @IF_PROCEED<T>()
+    sum(key: keyof T, legName?: string, distinct?: boolean) { this._columns.push(`SUM(${distinct ? 'DISTINCT' : ''} ${String(key)}) ${legName || `${String(key)}`}`); return this; }
+    @IF_PROCEED<T>()
+    avg(key: keyof T, legName?: string, distinct?: boolean) { this._columns.push(`AVG(${distinct ? 'DISTINCT' : ''} ${String(key)}) ${legName || `${String(key)}`}`); return this; }
+    @IF_PROCEED<T>()
+    max(key: keyof T, legName?: string, distinct?: boolean) { this._columns.push(`MAX(${distinct ? 'DISTINCT' : ''} ${String(key)}) ${legName || `${String(key)}`}`); return this; }
+    @IF_PROCEED<T>()
+    min(key: keyof T, legName?: string, distinct?: boolean) { this._columns.push(`MIN(${distinct ? 'DISTINCT' : ''} ${String(key)}) ${legName || `${String(key)}`}`); return this; }
+    @IF_PROCEED<T>()
+    groupConcat(key: keyof T, param?: { distinct?: boolean, separator?: string, asc?: (keyof T)[], desc?: (keyof T)[], groupName?: string }): this {
+        this._columns.push(`GROUP_CONCAT(
+            ${param && param.distinct ? 'DISTINCT' : ''} ${String(key)}
+            ${param && param.asc && param.asc.length > 0 ? `ORDER BY ${param.asc.map(i => `${String(i)} ASC`)} ` : ''}
+            ${param && param.desc && param.desc.length > 0 ? `${param && param.asc && param.asc.length > 0 ? '' : 'ORDER BY'} ${param.desc.map(i => `${String(i)} DESC`)} ` : ''}
+            SEPARATOR '${param && param.separator || ','}'
+            ) ${param && param.groupName || `${String(key)}`}`);
+        return this;
+    }
+    @IF_PROCEED<T>()
+    selectColumn(...key: (keyof T)[]) { this._columns.push(...(key.map(k => k as string))); return this; }
+    @IF_PROCEED<T>()
+    updateColumn(key: keyof T, value: T[keyof T]) { this._updates ??= {}; this._updates[key] = value; return this; }
+    @IF_PROCEED<T>()
+    updateT(t: Partial<T>) { this._updates ??= {}; Object.assign(this._updates, t); return this; }
+    @IF_PROCEED<T>()
+    replace(key: keyof T, valueToFind: T[keyof T], valueToReplace: T[keyof T]) {
+        const [pkey1, pkey2] = [`p${this._prefix}${this._index++}`, `p${this._prefix}${this._index++}`];
+        this._updateColumns.push(` ${String(key)} = REPLACE(${String(key)}, :${pkey1}, :${pkey2}) `);
+        this._param[pkey1] = valueToFind as any;
+        this._param[pkey2] = valueToReplace as any;
+        return this;
+    }
+}
+class StreamQuery<T extends object> extends StreamBuild<T>{
+    private _service: SqlService<T>;
+    constructor(table: string, service: SqlService<T>) {
+        super(table);
+        this._service = service;
+    }
+    select<L = T>(option: { sync?: SyncMode.Async; selectResult: SelectResult.Many_Row_Many_Column | SelectResult.Many_Row_One_Column; }): Promise<L[]>;
+    select<L = T>(option: { sync?: SyncMode.Async; selectResult: SelectResult.One_Row_Many_Column_Assert | SelectResult.One_Row_One_Column_Assert; errorMsg?: string; }): Promise<L>;
+    select<L = T>(option: { sync?: SyncMode.Async; selectResult: SelectResult.One_Row_Many_Column_NotSure | SelectResult.One_Row_One_Column_NotSure; }): Promise<L | null>;
+    select<L = T>(option: { sync: SyncMode.Sync; selectResult: SelectResult.Many_Row_Many_Column | SelectResult.Many_Row_One_Column; }): L[];
+    select<L = T>(option: { sync: SyncMode.Sync; selectResult: SelectResult.One_Row_Many_Column_Assert | SelectResult.One_Row_One_Column_Assert; errorMsg?: string; }): L;
+    select<L = T>(option: { sync: SyncMode.Sync; selectResult: SelectResult.One_Row_Many_Column_NotSure | SelectResult.One_Row_One_Column_NotSure; }): L | null;
+    @IF_EXEC<T>(null)
+    select<L = T>(option: { sync?: SyncMode; selectResult: SelectResult; errorMsg?: string; }): null | L | L[] | Promise<null | L | L[]> {
+        option.sync ??= SyncMode.Async;
+        const { where, params } = this.where();
+        const sql = `
+            SELECT
+            ${this._columns && this._columns.length > 0 ? this._columns.join(',') : '*'}
+            FROM ${this._table}
+            ${where ? ' WHERE ' : ''}
+            ${where}`;
+
+        if (option.sync === SyncMode.Async) {
+            switch (option.selectResult) {
+                case SelectResult.Many_Row_Many_Column: return this._service.select<L>({ sync: SyncMode.Async, selectResult: SelectResult.Many_Row_Many_Column, errorMsg: option.errorMsg, sql, params });
+                case SelectResult.Many_Row_One_Column: return this._service.select<L>({ sync: SyncMode.Async, selectResult: SelectResult.Many_Row_One_Column, errorMsg: option.errorMsg, sql, params });
+                case SelectResult.One_Row_Many_Column_Assert: return this._service.select<L>({ sync: SyncMode.Async, selectResult: SelectResult.One_Row_Many_Column_Assert, errorMsg: option.errorMsg, sql, params });
+                case SelectResult.One_Row_One_Column_Assert: return this._service.select<L>({ sync: SyncMode.Async, selectResult: SelectResult.One_Row_One_Column_Assert, errorMsg: option.errorMsg, sql, params });
+                case SelectResult.One_Row_Many_Column_NotSure: return this._service.select<L>({ sync: SyncMode.Async, selectResult: SelectResult.One_Row_Many_Column_NotSure, errorMsg: option.errorMsg, sql, params });
+                case SelectResult.One_Row_One_Column_NotSure: return this._service.select<L>({ sync: SyncMode.Async, selectResult: SelectResult.One_Row_One_Column_NotSure, errorMsg: option.errorMsg, sql, params });
+            }
+        } else {
+            switch (option.selectResult) {
+                case SelectResult.Many_Row_Many_Column: return this._service.select<L>({ sync: SyncMode.Sync, selectResult: SelectResult.Many_Row_Many_Column, errorMsg: option.errorMsg, sql, params });
+                case SelectResult.Many_Row_One_Column: return this._service.select<L>({ sync: SyncMode.Sync, selectResult: SelectResult.Many_Row_One_Column, errorMsg: option.errorMsg, sql, params });
+                case SelectResult.One_Row_Many_Column_Assert: return this._service.select<L>({ sync: SyncMode.Sync, selectResult: SelectResult.One_Row_Many_Column_Assert, errorMsg: option.errorMsg, sql, params });
+                case SelectResult.One_Row_One_Column_Assert: return this._service.select<L>({ sync: SyncMode.Sync, selectResult: SelectResult.One_Row_One_Column_Assert, errorMsg: option.errorMsg, sql, params });
+                case SelectResult.One_Row_Many_Column_NotSure: return this._service.select<L>({ sync: SyncMode.Sync, selectResult: SelectResult.One_Row_Many_Column_NotSure, errorMsg: option.errorMsg, sql, params });
+                case SelectResult.One_Row_One_Column_NotSure: return this._service.select<L>({ sync: SyncMode.Sync, selectResult: SelectResult.One_Row_One_Column_NotSure, errorMsg: option.errorMsg, sql, params });
+            }
+        }
+    }
+    update(option: { sync?: SyncMode.Async }): Promise<number>;
+    update(option: { sync: SyncMode.Sync }): number;
+    @IF_EXEC<T>(0)
+    update(option: { sync?: SyncMode }): number | Promise<number> {
+        option.sync ??= SyncMode.Async;
+        const { where, params } = this.where();
+        const sets = new Array<string>(...this._updateColumns);
+        if (this._updates) {
+            for (const [K, V] of Object.entries(this._updates)) {
+                const pkey = `p${this._prefix}${this._index++}`;
+                sets.push(` ${K} = :${pkey} `);
+                params[pkey] = V;
+            }
+        }
+        if (sets.length > 0) {
+            const sql = `UPDATE ${this._table} SET ${sets.join(',')} ${where}`;
+            if (option.sync === SyncMode.Async) {
+                return this._service.excute({ sync: SyncMode.Async, sql, params });
+            } else {
+                return this._service.excute({ sync: SyncMode.Sync, sql, params });
+            }
+        } else {
+            return 0;
+        }
+    }
+    delete(option: { sync?: SyncMode.Async }): Promise<number>;
+    delete(option: { sync: SyncMode.Sync }): number;
+    @IF_EXEC<T>(0)
+    delete(option: { sync?: SyncMode }): number | Promise<number> {
+        option.sync ??= SyncMode.Async;
+        const { where, params } = this.where();
+        const sql = `DELETE FROM ${this._table} ${where}`;
+        if (option.sync === SyncMode.Async) {
+            return this._service.excute({ sync: SyncMode.Async, sql, params });
+        } else {
+            return this._service.excute({ sync: SyncMode.Sync, sql, params });
+        }
+    }
+}
+/**
+ 获取REDIS客户端，
+ # [查看库的API](https://github.com/redis/ioredis?tab=readme-ov-file)
+ # [REDIS API](http://doc.redisfans.com/)
+ REDIS 的API 可以直接用，将方法名转为小写
+ */
+export function getRedisDB(db?: string) {
+    const rd = globalThis[_dao][DBType.Redis][db ?? _primaryDB];
+    Throw.if(!rd, 'not found redis!');
+    return rd;
+}
+/**
+ redlock
+ */
+export async function GetRedisLock(key: string, lockMaxActive?: number) {
+    const lock = globalThis[_dao][DBType.RedisLock];
+    Throw.if(!lock, 'not found lock!');
+    const db = getRedisDB();
+    let initLock: any;
+    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: any) {
+        return await GetRedisLock(key, lockMaxActive);
+    } finally {
+        if (initLock) {
+            try {
+                await initLock.release();
+                // eslint-disable-next-line no-empty
+            } catch (error: any) {
+            }
+        }
+    }
+};
+export async function excuteWithLock<T>(config: {
+    /** 返回缓存key,参数=方法的参数+当前用户对象，可以用来清空缓存。 */
+    key: ((...args: any[]) => string) | string;
+    /** 被锁定线程是否sleep直到解锁为止? 默认true */
+    lockWait?: boolean;
+    /** 当设置了lockWait=true时，等待多少【毫秒】进行一次锁查询? 默认：100MS */
+    lockRetryInterval?: number;
+    /** 当设置了lockWait=true时，等待多少【毫秒】即视为超时，放弃本次访问？默认：永不放弃 */
+    lockMaxWaitTime?: number;
+    /** 错误信息 */
+    errorMessage?: string;
+    /** 允许的并发数，默认：1 */
+    lockMaxActive?: number;
+    /** 单个锁多少【毫秒】后自动释放?默认：60*1000MS  */
+    lockMaxTime?: number;
+}, fn__: () => Promise<T>) {
+    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<T = any>(config: {
+    /** 返回缓存key,参数=方法的参数[注意：必须和主方法的参数数量、完全一致，同时会追加一个当前用户对象]+当前用户对象，可以用来清空缓存。 */
+    key: ((this: T, ...args: any[]) => string) | string;
+    /** 被锁定线程是否sleep直到解锁为止? 默认true */
+    lockWait?: boolean;
+    /** 当设置了lockWait=true时，等待多少【毫秒】进行一次锁查询? 默认100ms */
+    lockRetryInterval?: number;
+    /** 当设置了lockWait=true时，等待多少【毫秒】即视为超时，放弃本次访问？默认永不放弃 */
+    lockMaxWaitTime?: number;
+    /** 错误信息 */
+    errorMessage?: string;
+    /** 允许的并发数，默认=1 */
+    lockMaxActive?: number;
+    /** 单个锁多少【毫秒】后自动释放?即时任务没有执行完毕或者没有主动释放锁?  */
+    lockMaxTime?: number;
+}) {
+    return function (target: T, _propertyKey: string, descriptor: PropertyDescriptor) {
+        const fn__ = descriptor.value;
+        descriptor.value = async function (this: any, ...args: any[]) {
+            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: {
+        key: string;
+        clearKey?: string[];
+        /** 自动清空缓存的时间，单位分钟 */
+        autoClearTime?: number;
+        result: any;
+    },
+    devid?: string | false | undefined
+) {
+    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: string) => {
+                    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: string) {
+                await clearChild(key);
+            });
+        }
+    }
+}
+export async function clearMethodCache(key: string) {
+    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: string, 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: string) {
+    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<T>(config: {
+    /** 返回缓存key,参数=方法的参数+当前用户对象，可以用来清空缓存。 */
+    key: string;
+    /** 返回缓存清除key,参数=方法的参数+当前用户对象，可以用来批量清空缓存 */
+    clearKey?: string[];
+    /** 自动清空缓存的时间，单位分钟 */
+    autoClearTime?: number;
+    /** 随着当前用户sesion的清空而一起清空 */
+    clearWithSession?: boolean;
+}, fn: () => Promise<T>) {
+    const db = getRedisDB();
+    const cache = await db.get(`[cache]${config.key}`);
+    if (cache) {
+        logger.debug(`cache ${config.key} hit!`);
+        return JSON.parse(cache as string);
+    } 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<T = any>(config: {
+    /** 返回缓存key,参数=方法的参数[注意：必须和主方法的参数数量、完全一致，同时会追加一个当前用户对象]+当前用户对象，可以用来清空缓存。 */
+    key: ((this: T, ...args: any[]) => string) | string;
+    /** 返回缓存清除key,参数=方法的参数[注意：必须和主方法的参数数量、完全一致，同时会追加一个当前用户对象]+当前用户对象，可以用来批量清空缓存 */
+    clearKey?: ((this: T, ...args: any[]) => string[]) | string[];
+    /** 自动清空缓存的时间，单位分钟 */
+    autoClearTime?: number;
+    /** 随着当前用户sesion的清空而一起清空 */
+    clearWithSession?: boolean;
+}) {
+    return function (target: T, _propertyKey: string, descriptor: PropertyDescriptor) {
+        const fn = descriptor.value;
+        descriptor.value = async function (this: any, ...args: any[]) {
+            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 {
+    static END = 1;
+    private modelName: string;
+    private linNumber = 0;
+    private lastLine?: string;
+    private lastlastLine?: string;
+    private status = 0;
+    private lineSeparator = '\n';
+    private files: string[];
+    constructor(modelName: string, file: string) {
+        this.modelName = modelName;
+        this.files = file.replace(/\r/g, '').split(this.lineSeparator);
+        this.skipHeader();
+    }
+    next(): [string, string] | null {
+        let sqlId: string | undefined = this.readSqlId();
+        if (this.status === MUParser.END || !sqlId) {
+            return null;
+        }
+        // 去掉可能的尾部空格
+        sqlId = sqlId.trim();
+        this.skipComment();
+        if (this.status === MUParser.END) {
+            return null;
+        }
+        const sql: string = this.readSql();
+        return [`${this.modelName}.${sqlId}`, sql];
+    }
+    private skipHeader(): void {
+        while (true) {
+            const line: string | undefined = this.nextLine();
+            if (!line) { return; }
+            if (this.status === MUParser.END) { return; }
+            if (line.startsWith('===')) { return; }
+        }
+    }
+    private nextLine(): string | undefined {
+        const line: string | undefined = this.files[this.linNumber];
+        this.linNumber++;
+        if (line === undefined) {
+            this.status = MUParser.END;
+        }
+        // 保存最后读的俩行
+        this.lastlastLine = this.lastLine;
+        this.lastLine = line;
+        return line;
+    }
+    private readSqlId(): string | undefined {
+        return this.lastlastLine;
+    }
+    private skipComment(): void {
+        let findComment = false;
+        while (true) {
+            let line: string | undefined = this.nextLine();
+            if (this.status === MUParser.END || !line) {
+                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;
+                }
+            }
+        }
+    }
+    private readSql(): string {
+        const list: string[] = [];
+        if (this.lastLine) {
+            list.push(this.lastLine);
+            while (true) {
+                const line: string | undefined = this.nextLine();
+                if (line) {
+                    if (this.status === MUParser.END) {
+                        return this.getBuildSql(list);
+                    }
+                    if (line.startsWith('===')) {
+                        // 删除下一个sqlId表示
+                        list.pop();
+                        return this.getBuildSql(list);
+                    }
+                    list.push(line);
+                } else {
+                    return '';
+                }
+            }
+        } else {
+            return '';
+        }
+    }
+    private getBuildSql(list: string[]): string {
+        const sb: string[] = [];
+        for (const str of list) {
+            const s: string = str.trim();
+            if (s.startsWith('```') || s.startsWith('~~~')) {
+                // 忽略以code block开头的符号
+                continue;
+            }
+            sb.push(str);
+        }
+        return sb.join(this.lineSeparator);
+    }
+}
+
+export const Boot = async function (options: GlobalSqlOption) {
+    globalThis[_GlobalSqlOption] = Object.assign({}, _defOption, options);
+    if (options.sqlDir) {
+        globalThis[_path] = await import('path');
+        globalThis[_fs] = await import('fs');
+    }
+    logger.level = options.log ?? 'info';
+    globalThis[_sqlCache] = new SqlCache();
+    if (options.sqlMap || options.sqlDir) {
+        await globalThis[_sqlCache].init(options);
+    }
+    globalThis[_dao] = {
+        [DBType.Mongo]: {},
+        [DBType.Mysql]: {},
+        [DBType.Sqlite]: {},
+        [DBType.SqliteRemote]: {},
+        [DBType.Redis]: {}
+    };
+    if (options.Mysql) {
+        const { createPool } = await import('mysql2/promise');
+        if (options.Mysql['host']) {
+            globalThis[_dao][DBType.Mysql][_primaryDB] = new Mysql(createPool({
+                ...options.Mysql,
+                multipleStatements: true,
+                decimalNumbers: true,
+                supportBigNumbers: true
+            }));
+        } else {
+            let flag = false;
+            for (const [key, option] of Object.entries(options.Mysql)) {
+                const db = new Mysql(createPool({
+                    ...option,
+                    multipleStatements: true,
+                    decimalNumbers: true,
+                    supportBigNumbers: true
+                }));
+                if (flag === false) {
+                    globalThis[_dao][DBType.Mysql][_primaryDB] = db;
+                    flag = true;
+                }
+                globalThis[_dao][DBType.Mysql][key] = db;
+            }
+        }
+    }
+    if (options.Sqlite) {
+        const BetterSqlite3 = await import('better-sqlite3');
+        if (typeof options.Sqlite === 'string') {
+            globalThis[_dao][DBType.Sqlite][_primaryDB] = new Sqlite(new BetterSqlite3.default(options.Sqlite, { fileMustExist: false }));
+        } else {
+            let flag = false;
+            for (const [key, fileName] of Object.entries(options.Sqlite)) {
+                const db = new Sqlite(new BetterSqlite3.default(fileName, { fileMustExist: false }));
+                if (flag === false) {
+                    globalThis[_dao][DBType.Sqlite][_primaryDB] = db;
+                    flag = true;
+                }
+                globalThis[_dao][DBType.Sqlite][key] = db;
+            }
+        }
+    }
+    if (options.SqliteRemote) {
+        if (typeof options.SqliteRemote.db === 'string') {
+            await options.SqliteRemote.service.initDB(options.SqliteRemote.db);
+            globalThis[_dao][DBType.SqliteRemote][_primaryDB] = new SqliteRemote(options.SqliteRemote.service, options.SqliteRemote.db);
+        } else {
+            let flag = false;
+            for (const [key, fileName] of Object.entries(options.SqliteRemote.db)) {
+                await options.SqliteRemote.service.initDB(fileName);
+                const db = new SqliteRemote(options.SqliteRemote.service, fileName);
+                if (flag === false) {
+                    globalThis[_dao][DBType.SqliteRemote][_primaryDB] = db;
+                    flag = true;
+                }
+                globalThis[_dao][DBType.SqliteRemote][key] = db;
+            }
+        }
+    }
+    if (options.Redis) {
+        const { Redis } = await import('ioredis');
+        if (options.Redis['host']) {
+            globalThis[_dao][DBType.Redis][_primaryDB] = new Redis(options.Redis);
+        } else {
+            let flag = false;
+            for (const [key, option] of Object.entries(options.Redis)) {
+                const db = new Redis(option);
+                if (flag === false) {
+                    globalThis[_dao][DBType.Redis][_primaryDB] = db;
+                    flag = true;
+                }
+                globalThis[_dao][DBType.Redis][key] = db;
+            }
+        }
+        const clients = Object.values(globalThis[_dao][DBType.Redis]) as any;
+        const Redlock = await import('redlock');
+        globalThis[_dao][DBType.RedisLock] = new Redlock.default(
+            clients,
+            {
+                // The expected clock drift; for more details see:
+                // http://redis.io/topics/distlock
+                driftFactor: 0.01, // multiplied by lock ttl to determine drift time
+
+                // The max number of times Redlock will attempt to lock a resource
+                // before erroring.
+                retryCount: 10,
+
+                // the time in ms between attempts
+                retryDelay: 200, // time in ms
+
+                // the max time in ms randomly added to retries
+                // to improve performance under high contention
+                // see https://www.awsarchitectureblog.com/2015/03/backoff.html
+                retryJitter: 200, // time in ms
+
+                // The minimum remaining time on a lock before an extension is automatically
+                // attempted with the `using` API.
+                automaticExtensionThreshold: 500, // time in ms
+            }
+        );
+        const { EventEmitter } = await import('events');
+        const event = new EventEmitter({ captureRejections: true });
+        event.on('error', error => {
+            logger.error('event-bus', error);
+        });
+        globalThis[_EventBus] = event;
+    }
+}