baja-lite 1.0.4 → 1.0.6

package/src/sql.ts

@@ -1,4 +1,3 @@
-import 'reflect-metadata';
 import { Throw } from './error';
 import tslib from 'tslib';
 import Sqlstring from 'sqlstring';
@@ -6,12 +5,21 @@ import iterare from 'iterare';
 import { emptyString } from './string';
 import pino from 'pino';
 import { excuteSplit, ExcuteSplitMode, sleep } from './fn';
-import { add } from './math';
+import { add, calc } from './math';
 import mustache, { PartialsOrLookupFn } from 'mustache';
+import { C2P, C2P2, P2C } from './object';
+import { format } from 'sql-formatter';
+import HTML from 'html-parse-stringify';
+import { XML, convert } from './convert-xml';
+import { ArrayList } from './list';
+import LGet from 'lodash.get';
 
 // #region 常量
 const _daoDBName = Symbol('dbName');
 const _tableName = Symbol('tableName');
+const _className = Symbol('className');
+const _ClassName = Symbol('ClassName');
+const _vueName = Symbol('vueName');
 const _ids = Symbol('ids');
 const _columns = Symbol('columns');
 const _columnsNoId = Symbol('columnsNoId');
@@ -21,9 +29,9 @@ 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');
+export const _sqlCache = Symbol('sqlMap');
+export const _dao = Symbol('dao');
+export const _primaryDB = Symbol('primaryDB');
 const _dbType = Symbol('dbType');
 const _sqlite_version = Symbol('sqlite_version');
 const _daoConnection = Symbol('daoConnection');
@@ -31,20 +39,26 @@ 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'
-    }
-});
+const _resultMap = Symbol('resultMap');
+const _resultMap_SQLID = Symbol('resultMap_SQLID');
+export const _Hump = Symbol('Hump');
+export const _GlobalSqlOption = Symbol('GlobalSqlOption');
+export const _EventBus = Symbol('EventBus');
+export const _path = Symbol('path');
+export const _fs = Symbol('fs');
+export const logger =
+    process.env['NODE_ENV'] !== 'production' ? pino({
+        name: 'sql',
+        transport: {
+            target: 'pino-pretty'
+        }
+    }) : pino({ name: 'sql' });
+globalThis[_resultMap_SQLID] = {};
 // #endregion
 
 // #region 可选配置
-export enum DBType { Mysql, Sqlite, Mongo, SqliteRemote, Redis, RedisLock }
+export enum DBType { Mysql, Sqlite, Mongo, SqliteRemote, Redis, RedisLock };
+export enum MapperIfUndefined { Null, Skip, Zero, EmptyString };
 export enum SyncMode {
     /** 同步执行 */
     Sync,
@@ -116,16 +130,28 @@ export enum TemplateResult {
     NotSureOne,
     /** 返回多条记录 */
     Many,
+    /** 返回多条记录并封装ArrayList */
+    ManyList,
     /** 仅查询记录数量 */
     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
+    /** 一行一列 确定非空 */
+    R_C_Assert,
+    /** 一行一列 可能空 */
+    R_C_NotSure,
+    /** 一行多列 确定非空 */
+    R_CS_Assert,
+    /** 一行多列 可能空 */
+    R_CS_NotSure,
+    /** 多行一列 */
+    RS_C,
+    /** 多行一列并封装ArrayList */
+    RS_C_List,
+    /** 多行多列 */
+    RS_CS,
+    /** 多行多列并封装ArrayList */
+    RS_CS_List
 }
 export enum SqlType {
     tinyint,
@@ -171,6 +197,9 @@ export enum SqlType {
     geometrycollection
 
 }
+export enum ColumnMode {
+    NONE, HUMP
+}
 export const SqliteMemory = ':memory:';
 // #endregion
 
@@ -186,7 +215,7 @@ interface MethodOption {
     /** 调用时，仅在开启事务时需要主动传入,传入方式： */
     conn?: Connection | null;
 }
-const _defOption = {
+export const _defOption = {
     maxDeal: 500,
     skipUndefined: true,
     skipNull: true,
@@ -232,7 +261,7 @@ interface ServiceOption {
     ```
     可以继承该接口来约束格式
  */
-interface GlobalSqlOption {
+export interface GlobalSqlOptionForWeb {
     /** 增改忽略Undefined */
     skipUndefined?: boolean;
     /** 增改忽略NULL */
@@ -241,6 +270,59 @@ interface GlobalSqlOption {
     skipEmptyString?: boolean;
     /** 批量增改时，每次执行最多处理的记录数量 */
     maxDeal?: number;
+    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',
+    /**
+     作用与sqlDir类似，不同在于sqlMap`不需要`目录，而是直接指定一个sqlModel对象，对象的格式和sqlDir的文件内容一样。
+     ** 适用于简单使用
+     */
+    sqlMap?: _SqlModel;
+    /**
+     作用与sqlFnDir类似，不同在于sqlFNMap`不需要`目录，而是直接指定一个 Record<string, string>，对象的格式和sqlFnDir的文件内容一样。
+     ** 适用于简单使用
+     */
+    sqlFNMap?: Record<string, string>;
+    /**
+    // 第一个元素=列名，第二个元素是属性路径，
+    [
+        ['dit_id', ['id']], // 列名ditid,对应属性id
+        ['event_id', ['eventMainInfo', 'id']] // 列名event_id对应属性eventMainInfo.id
+    ]
+     */
+    sqlMapperMap?: SqlMappers;
+}
+/**
+ # 全局行为配置文件
+   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)
+    }
+    ```
+    可以继承该接口来约束格式
+ */
+export interface GlobalSqlOption extends GlobalSqlOptionForWeb {
     /**
        初始化MYSQL链接 支持多数据源
        ## 单一数据源: 直接传入Mysql2的连接配置
@@ -282,27 +364,6 @@ interface GlobalSqlOption {
        路径 = `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`,内容为:
      ```
@@ -335,22 +396,27 @@ interface GlobalSqlOption {
     ## 也支持.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的文件内容一样。
-     ** 适用于简单使用
+      ## 映射数据为对象，文件名就是模板名
+    ```
+    // 第一个元素=列名，第二个元素是属性路径，
+    // 该目录下可存放json文件，内容如下
+    //
+    // 可以在查询时使用，优先级高于hump
+    // 例如:
+    [
+        ['dit_id', ['id'], 可选的默认值], // 列名ditid,对应属性id,当未查询返回时，使用默认值
+        ['event_id', ['eventMainInfo', 'id']] // 列名event_id对应属性eventMainInfo.id,当未查询返回时，该属性不存在
+    ]
+    ```
      */
-    sqlFNMap?: Record<string, string>;
-
+    sqlMapperDir?: 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)
     ```
@@ -375,23 +441,64 @@ interface GlobalSqlOption {
     ```
      */
     Redis?: Record<string, Record<string, any>> | Record<string, any>;
+
+    /**
+     * `列名与属性映射` 是否自动将下划线转为驼峰，默认NONE，即不转.
+     * 当设置为columnMode.HUMP时，切记将代码生成器中属性名称改对
+     * # 自定义sql查询时，无法自动转换哦,可使用标签转换：
+     *```
+        SELECT
+     *  {{#hump}} seller_sku2, seller_sku {{/hump}}
+     * ```
+     * 转换为
+     *```
+        SELECT
+     *  {{#hump}} seller_sku2 sellerSku2, seller_sku sellerSku {{/hump}}
+     * ```
+     */
+    columnMode?: ColumnMode;
+    /**
+     * 读取查询语句时，是否扫描JS文件？
+     * JS文件需要默认导出一个 SqlModel对象
+     */
+    jsMode?: boolean;
 }
+
 interface FieldOption extends Object {
     type?: SqlType;
-    name?: string;
+    /** @deprecated 属性名称:TS注解不需要，JS手动注入需要 */
+    P?: string;
     length?: number;
     scale?: number;
     def?: any;
     index?: boolean;
     id?: boolean;
-    logicDelete?: string;
+    logicDelete?: string | number;
+    /** 仅在生成 表时有效 */
     notNull?: boolean;
+    comment?: string;
+    /** sqlite 无效,与UUID只能有一个 */
+    uuidShort?: boolean;
+    /** 与uuidShort只能有一个 */
+    uuid?: boolean;
 }
 interface AField extends FieldOption {
-    esName: string;
-    [DBType.Mysql]: string;
-    [DBType.Sqlite]: string;
-    [DBType.SqliteRemote]: string;
+    /** 安全列名 */
+    C2: () => string;
+    /** @deprecated 数据列名称 */
+    C?: () => string;
+    /** 查询用：b_id bId */
+    C3: () => string;
+
+    [DBType.Mysql]: () => string;
+    [DBType.Sqlite]: () => string;
+    [DBType.SqliteRemote]: () => string;
+}
+export interface PageQuery<L> {
+    sum?: Record<string, number>;
+    total?: number;
+    size?: number;
+    records?: L[];
 }
 // #endregion
 
@@ -399,14 +506,14 @@ interface AField extends FieldOption {
 /** 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>;
+    pluck<One_Row_Many_Column = any>(dbName: string, sql?: string, params?: any): Promise<One_Row_Many_Column | null>;
+    get<One_Row_Many_Column = any>(dbName: string, sql?: string, params?: any): Promise<One_Row_Many_Column | null>;
     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>;
+    export(dbName: string): Promise<void>;
+    restore(dbName: string, fromName: string): Promise<void>;
 };
 interface Connection {
     [_daoConnection]: any;
@@ -617,7 +724,7 @@ class MysqlConnection implements Connection {
         };
     }
 }
-class Mysql implements Dao {
+export class Mysql implements Dao {
     [_daoDB]: any;
     constructor(pool: any) {
         this[_daoDB] = pool;
@@ -633,7 +740,7 @@ class Mysql implements Dao {
         return new Promise<Connection>(async (resolve, reject) => {
             try {
                 const connection = await this[_daoDB].getConnection();
-                logger.debug('create new!');
+                logger.debug('create new connection!');
                 resolve(new MysqlConnection(connection));
             } catch (error) {
                 reject(error);
@@ -851,7 +958,7 @@ class SqliteConnection implements Connection {
     realse(sync: SyncMode): Promise<void> | void {
     }
 }
-class Sqlite implements Dao {
+export class Sqlite implements Dao {
     [_daoDB]: any;
     constructor(db: any) {
         this[_daoDB] = db;
@@ -929,7 +1036,7 @@ class Sqlite implements Dao {
     restore(sync: SyncMode, name: string): Promise<void> | void {
     }
 }
-class SqliteRemoteConnection implements Connection {
+export class SqliteRemoteConnection implements Connection {
     [_daoConnection]: SqliteRemoteInterface;
     [_sqliteRemoteName]: string;
     [_inTransaction] = false;
@@ -1078,7 +1185,7 @@ class SqliteRemoteConnection implements Connection {
     realse(sync: SyncMode): Promise<void> | void {
     }
 }
-class SqliteRemote implements Dao {
+export class SqliteRemote implements Dao {
     [_sqliteRemoteName]: string;
     [_daoDB]: SqliteRemoteInterface;
 
@@ -1095,8 +1202,12 @@ class SqliteRemote implements Dao {
             logger.error('SQLITEREMOTE not suppouted sync mode');
             return null;
         };
-        return new Promise<Connection>(async resolve => {
-            resolve(new SqliteRemoteConnection(this[_daoDB], this[_sqliteRemoteName]));
+        return new Promise<Connection>(async (resolve, reject) => {
+            try {
+                resolve(new SqliteRemoteConnection(this[_daoDB], this[_sqliteRemoteName]));
+            } catch (error) {
+                reject(error);
+            }
         });
     }
 
@@ -1112,8 +1223,12 @@ class SqliteRemote implements Dao {
     close(sync: SyncMode.Async): Promise<void>;
     close(sync: SyncMode): Promise<void> | void {
         if (sync === SyncMode.Async) {
-            return new Promise(async () => {
-                await this[_daoConnection].close();
+            return new Promise(async (resolve, reject) => {
+                try {
+                    await this[_daoConnection].close();
+                } catch (error) {
+                    reject(error);
+                }
             });
         };
     }
@@ -1122,8 +1237,12 @@ class SqliteRemote implements Dao {
     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);
+            return new Promise(async (resolve, reject) => {
+                try {
+                    await this[_daoConnection].backup(this[_sqliteRemoteName], name);
+                } catch (error) {
+                    reject(error);
+                }
             });
         };
     }
@@ -1132,8 +1251,12 @@ class SqliteRemote implements Dao {
     remove(sync: SyncMode.Async): Promise<void>;
     remove(sync: SyncMode): Promise<void> | void {
         if (sync === SyncMode.Async) {
-            return new Promise(async () => {
-                await this[_daoConnection].remove();
+            return new Promise(async (resolve, reject) => {
+                try {
+                    await this[_daoConnection].remove();
+                } catch (error) {
+                    reject(error);
+                }
             });
         };
     }
@@ -1142,8 +1265,12 @@ class SqliteRemote implements Dao {
     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);
+            return new Promise(async (resolve, reject) => {
+                try {
+                    await this[_daoConnection].restore(this[_sqliteRemoteName], name);
+                } catch (error) {
+                    reject(error);
+                }
             });
         };
     }
@@ -1151,6 +1278,8 @@ class SqliteRemote implements Dao {
 // #endregion
 
 // #region 查询sql
+export type SqlMapper = ([string, string[], any?])[];
+export type SqlMappers = Record<string, SqlMapper>;
 export type SqlModel = Record<string, string | (
     (options: {
         ctx: any;
@@ -1162,6 +1291,17 @@ export type SqlModel = Record<string, string | (
         [k: string]: any;
     }) => string
 )>;
+type _SqlModel = Record<string, string | (
+    (options: {
+        ctx: any;
+        isCount?: boolean;
+        isSum?: boolean;
+        limitStart?: number;
+        limitEnd?: number;
+        orderBy?: string;
+        [k: string]: any;
+    }) => string
+) | XML[]>;
 class Build {
     private static page = 'COUNT(1) zccw1986 ';
     private isCount: boolean;
@@ -1188,7 +1328,7 @@ class Build {
      * @returns
      * @memberof Build
      */
-    pageTag() {
+    page() {
         return (text: string, render: (text: string) => string) => {
             if (this.isCount === true) {
                 return Build.page;
@@ -1199,11 +1339,11 @@ class Build {
     }
     /**
    *
-   * 汇总查询专用
+   * 包含的内容只在汇总查询时有效，否则是空白
    * @returns
    * @memberof Build
    */
-    sumTag() {
+    sum() {
         return (text: string, render: (text: string) => string) => {
             if (this.isSum !== true) {
                 return '';
@@ -1212,13 +1352,14 @@ class Build {
             }
         };
     }
+
     /**
      *
      * 当分页时、汇总时忽略函数内包含的内容
      * @returns
      * @memberof Build
      */
-    pageIgnoreTag() {
+    notPage() {
         return (text: string, render: (text: string) => string) => {
             if (this.isCount === true || this.isSum === true) {
                 return '';
@@ -1242,8 +1383,7 @@ class Build {
      */
     where() {
         return (text: string, render: (text: string) => string) => {
-            let data = render(text);
-            data = data.trim();
+            let data = render(text).trim();
             if (data) {
                 data = data.replace(/and|or/i, '');
                 return ` WHERE ${data} `;
@@ -1252,6 +1392,33 @@ class Build {
             }
         };
     }
+    /**
+     * ```
+     * SELECT
+     * {{#hump}}
+     * a.event_id, a.event_name eventName
+     * {{/hump}}
+     * FROM...
+     * ```
+     * 编译后:
+     * ```
+     * SELECT
+     * a.event_id eventId, a.event_name eventName
+     * FROM...
+     * ```
+     */
+    hump() {
+        return (text: string, render: (text: string) => string) => {
+            let data = render(text).trim();
+            const datas = data.split(',');
+            for (let i = 0; i < datas.length; i++) {
+                if (datas[i]?.match(/\s|\t/) === null) {
+                    datas[i] = `${datas[i]} ${datas[i]!.replace(/[a-zA-Z0-9]+\./, '').replace(/_([a-z])/g, (a, b, c) => b.toUpperCase())}`;
+                }
+            }
+            return datas.join(',');
+        };
+    }
     /**
      * 删除第一个and、or
      * 删除最后一个,
@@ -1274,13 +1441,13 @@ class Build {
      * 分页时将排序部分代码用此函数包起来，可以自动拼接order by
      * 查询条数时，自动忽略此部分
      * etc
-     * {{#orderTag}} name desc, age asc {{/orderTag}}
+     * {{#order}} name desc, age asc {{/order}}
      * ===
      * ORDER BY name desc, age asc
      * @returns
      * @memberof Build
      */
-    orderTag() {
+    order() {
         return (text: string, render: (text: string) => string) => {
             if (this.isCount === true || this.isSum === true) {
                 return '';
@@ -1295,7 +1462,7 @@ class Build {
             }
         };
     }
-    limitTag() {
+    limit() {
         return (text: string, render: (text: string) => string) => {
             if (this.isCount === true || this.isSum === true) {
                 return '';
@@ -1315,13 +1482,13 @@ class Build {
      * 分页时将分组部分代码用此函数包起来，可以自动拼接GROUP BY
      * 当分页时、汇总时，自动忽略此部分
      * etc
-     * {{#groupTag}} name, age {{/groupTag}}
+     * {{#between}} name, age {{/between}}
      * ===
      * group by name.age
      * @returns
      * @memberof Build
      */
-    groupTag() {
+    group() {
         return (text: string, render: (text: string) => string) => {
             if (this.isCount === true || this.isSum === true) {
                 return '';
@@ -1365,15 +1532,15 @@ class Build {
      *
      * 距离计算,单位米
      * etc
-     * {{#distanceTag}} (t.longitude, t.latitude), ({{longitude}}, {{latitude}}) {{/distanceTag}}
+     * {{#distance}} (t.longitude, t.latitude), ({{longitude}}, {{latitude}}) {{/distance}}
      * ===
      * ROUND(ST_DISTANCE(POINT(longitude1, latitude1), POINT({{longitude}}, {{latitude}}))*111195, 2)
      * 可根据需求自行将数据转换为千米，例如
-     * {{#distanceTag}} (t.longitude, t.latitude), ({{longitude}}, {{latitude}}) {{/distanceTag}} / 1000
+     * {{#distance}} (t.longitude, t.latitude), ({{longitude}}, {{latitude}}) {{/distance}} / 1000
      * @returns
      * @memberof Build
      */
-    distanceTag() {
+    distance() {
         return (text: string, render: (text: string) => string) => {
             const result = render(text);
             if (/\(([^()]+)\)/.exec(result)) {
@@ -1397,38 +1564,178 @@ class Build {
         };
     }
 }
-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;
+
+function replaceCdata(rawText: string) {
+    var cdataRegex = new RegExp('(<!\\[CDATA\\[)([\\s\\S]*?)(\\]\\]>)', 'g');
+    var matches = rawText.match(cdataRegex);
+
+    if (matches != null && matches.length > 0) {
+        for (var z = 0; z < matches.length; z++) {
+            var regex = new RegExp('(<!\\[CDATA\\[)([\\s\\S]*?)(\\]\\]>)', 'g');
+            var m = regex.exec(matches[z]!);
+
+            var cdataText = m![2];
+            cdataText = cdataText!.replace(/\&/g, '&amp;');
+            cdataText = cdataText!.replace(/\</g, '&lt;');
+            cdataText = cdataText!.replace(/\>/g, '&gt;');
+            cdataText = cdataText!.replace(/\"/g, '&quot;');
+
+            rawText = rawText.replace(m![0], cdataText);
         }
-        if (options.sqlDir) {
-            const sqlFis = globalThis[_fs].readdirSync(options.sqlDir);
-            for (const modeName of sqlFis) {
+    }
+    return rawText;
+}
+function _flatData(result: any, i: number, length: number, keys: string[], V: any) {
+    const key = keys[i];
+    if (i < length) {
+        result[key!] ??= {};
+        i++;
+        _flatData(result[key!], i, length, keys, V);
+    } else {
+        result[key!] = V;
+    }
+}
+/**
+ * ifUndefined默认是MapperIfUndefined.Skip
+ */
+export function flatData<M>(options: { data: any; mapper: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): M {
+    if (typeof options.mapper === 'string') {
+        const name = options.mapper;
+        options.mapper = globalThis[_resultMap][name];
+        Throw.if(!options.mapper, `not found mapper!${name}`);
+    }
+    options.mapperIfUndefined ??= MapperIfUndefined.Skip;
+    options.mapper = options.mapper as SqlMapper;
+    const result: any = {};
+    for (const [columnName, keys, def] of options.mapper) {
+        let V = options.data[columnName];
+        if (V === undefined) {
+            if (options.mapperIfUndefined === MapperIfUndefined.Null) {
+                V = null;
+            } else if (options.mapperIfUndefined === MapperIfUndefined.Zero) {
+                V = 0;
+            } else if (options.mapperIfUndefined === MapperIfUndefined.EmptyString) {
+                V = '';
+            } else if (def !== undefined) {
+                V = def;
+            } else {
+                continue;
+            }
+        }
+        _flatData(result, 0, keys.length - 1, keys, V);
+    }
+    return result;
+}
+
+export class SqlCache {
+    private sqlMap: _SqlModel = {};
+    private sqlFNMap: PartialsOrLookupFn = {};
+    private async _read(jsMode: boolean, sqlDir: string, queryTypes: string[], rootName: string) {
+        const sqlFis = globalThis[_fs].readdirSync(sqlDir);
+        for (const modeName of sqlFis) {
+            const file = globalThis[_path].join(sqlDir, modeName);
+            const stat = globalThis[_fs].statSync(file);
+            if (stat.isDirectory()) {
+                await this._read(jsMode, file, queryTypes, modeName);
+            } else {
                 const extname = globalThis[_path].extname(modeName);
                 const name = globalThis[_path].basename(modeName, extname);
-                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 ct = 0;
+                if (extname === '.mu') {
+                    logger.debug(`sql: ${file} start explain!`);
+                    const parser = new MUParser(rootName || name, globalThis[_fs].readFileSync(file, { encoding: 'utf-8' }).toString());
                     let source = parser.next();
                     while (source != null) {
+                        ct++;
                         this.sqlMap[source[0]] = source[1];
                         logger.debug(`sql: ${source[0]} found!`);
                         source = parser.next();
                     }
-                } else if (extname === '.js') {
-                    const obj = (await import(globalThis[_path].join(options.sqlDir, modeName))).default as SqlModel;
+                    logger.debug(`sql: ${file} explain over[${ct}]!`);
+                } else if (jsMode === true && extname === '.js') {
+                    logger.debug(`sql: ${file} start explain!`);
+                    const obj = (await import(globalThis[_path].join(sqlDir, modeName))).default as _SqlModel;
                     for (const [key, fn] of Object.entries(obj)) {
-                        this.sqlMap[`${name}.${String(key)}`] = fn;
+                        ct++;
+
+                        this.sqlMap[`${rootName || name}.${String(key)}`] = fn;
+                    }
+                    logger.debug(`sql: ${file} explain over[${ct}]!`);
+                } else if (extname === '.xml') {
+                    logger.debug(`sql: ${file} start explain!`);
+                    const root = (HTML.parse(replaceCdata(globalThis[_fs].readFileSync(file, { encoding: 'utf-8' }).toString())) as XML[])[0];
+                    if (root) {
+                        const mappers = root.children;
+                        for (const mapper of mappers) {
+                            if (mapper.type === 'tag' && mapper.name === 'mapper') {
+                                for (const am of mapper.children) {
+                                    if (am.type === 'tag') {
+                                        Throw.if(!queryTypes.includes(am.name), `${rootName} ${name}错误,${am.name}不支持!`);
+                                        am.id = am.attrs['id'];
+                                        Throw.if(!am.id, `${rootName} ${name}错误,没有为此块设置id:${am}`);
+                                        if (am.name === 'resultMap') {
+                                            ct++;
+                                            globalThis[_resultMap] ??= {};
+                                            const keys: SqlMapper = [];
+                                            this.readResultMap(am.children, keys, []);
+                                            globalThis[_resultMap][am.id!] = keys;
+                                            logger.debug(`sql_resultMap: ${am.id!} found!`);
+                                        } else {
+                                            this.sqlMap[`${rootName || name}.${am.id!}`] = am.children;
+                                            if (am.attrs['resultMap']) {
+                                                globalThis[_resultMap_SQLID][`${rootName || name}.${am.id!}`] = am.attrs['resultMap'];
+                                                logger.debug(`sql: autoMapper: ${rootName || name}.${am.id!}-${am.attrs['resultMap']}`);
+                                            }
+                                            logger.debug(`sql: ${rootName || name}.${am.id!} found!`);
+                                            ct++;
+                                        }
+                                    }
+                                }
+                            }
+                        }
                     }
+                    logger.debug(`sql: ${file} explain over[${ct}]!`);
+                }
+
+            }
+        }
+    }
+    /**
+     *
+     * ```
+    // 第一个元素=列名，第二个元素是属性路径，
+    [
+        ['dit_id', ['id']], // 列名ditid,对应属性id
+        ['event_id', ['eventMainInfo', 'id']] // 列名event_id对应属性eventMainInfo.id
+    ]
+     * ```
+     * @param am
+     * @param keys 
+     */
+    private readResultMap(ams: XML[], keys: SqlMapper, key: string[]) {
+        for (const am of ams) {
+            if (am.type === 'tag') {
+                if (am.name === 'result' || am.name === 'id') {
+                    keys.push([am.attrs['column']!, [...key, am.attrs['property']!]]);
+                } else {
+                    this.readResultMap(am.children, keys, [...key, am.attrs['property']!])
                 }
             }
         }
+    }
+    async init(options: {
+        sqlMap?: _SqlModel; sqlDir?: string;
+        sqlFNMap?: Record<string, string>; sqlFNDir?: string;
+        sqlMapperMap?: SqlMappers; sqlMapperDir?: string;
+        jsMode?: boolean;
+    }) {
+        if (options.sqlMap) {
+            this.sqlMap = options.sqlMap;
+        }
+        const queryTypes = ['sql', 'select', 'insert', 'update', 'delete', 'resultMap'];
+        if (options.sqlDir) {
+            await this._read(options.jsMode === true, options.sqlDir, queryTypes, '');
+        }
         if (options.sqlFNMap) {
             this.sqlFNMap = options.sqlFNMap;
         }
@@ -1443,8 +1750,23 @@ class SqlCache {
                 }
             }
         }
+        if (options.sqlMapperMap) {
+            globalThis[_resultMap] = options.sqlFNMap;
+        }
+        if (options.sqlMapperDir) {
+            const sqlFis = globalThis[_fs].readdirSync(options.sqlDir);
+            globalThis[_resultMap] ??= {};
+            for (const modeName of sqlFis) {
+                const extname = globalThis[_path].extname(modeName);
+                const name = globalThis[_path].basename(modeName, extname);
+                const file = globalThis[_path].join(options.sqlDir, modeName);
+                if (extname === 'json') {
+                    globalThis[_resultMap][name] = JSON.parse(globalThis[_fs].readFileSync(file, { encoding: 'utf-8' }).toString());
+                }
+            }
+        }
     }
-    load(sqlid: string, options: {
+    load(sqlids: string[], options: {
         ctx: any;
         isCount?: boolean;
         isSum?: boolean;
@@ -1453,13 +1775,31 @@ class SqlCache {
         orderBy?: string;
         [k: string]: any;
     }): string {
-        const sqlSource = this.sqlMap[sqlid];
-        Throw.if(!sqlSource, `指定的语句${sqlid}不存在!`);
-        const _sql = typeof sqlSource === 'function' ? sqlSource(options) : sqlSource!;
+        let sqlSource: any;
+        for (const sqlid of sqlids) {
+            sqlSource = this.sqlMap[sqlid];
+            if (sqlSource) {
+                break;
+            }
+        }
+        const matchSqlid = sqlids.map(i => i.split('.')[0]!);
+        Throw.if(!sqlSource, `指定的语句${sqlids.join('|')}不存在!`);
         const buildParam = new Build(options.isCount === true, options.isSum === true, options);
-        const sql = mustache.render(_sql, buildParam, this.sqlFNMap);
-        logger.debug(sqlid, sql);
-        return sql;
+        if (typeof sqlSource === 'function') {
+            const _sql = sqlSource(options);
+            const sql = mustache.render(_sql, buildParam, this.sqlFNMap);
+            return format(sql);
+        } else if (typeof sqlSource === 'string') {
+            const sql = mustache.render(sqlSource, buildParam, this.sqlFNMap);
+            return format(sql);
+        } else if (typeof sqlSource === 'object') {
+            const _sql = convert(sqlSource, options, matchSqlid, this.sqlMap as Record<string, XML[]>);
+            console.log(_sql);
+            const sql = mustache.render(_sql, buildParam, this.sqlFNMap);
+            console.log(sql);
+            return format(sql);
+        }
+        return '';
     }
 }
 // #endregion
@@ -1489,6 +1829,8 @@ function P<T extends object>(skipConn = false) {
             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;
+            const dddx = this[_dbType];
+            logger.info(dddx);
             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];
@@ -1511,7 +1853,7 @@ function P<T extends object>(skipConn = false) {
                         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))
+                                .filter(c => this[_fields]!.hasOwnProperty(C2P(c.name, globalThis[_Hump])))
                                 .map(c => Sqlstring.escapeId(c.name))
                                 .join(',');
 
@@ -1520,13 +1862,13 @@ function P<T extends object>(skipConn = false) {
                             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(',')})` : ''}
+                                    ${Object.values(this[_fields]!).map(K => K[DBType.Sqlite]()).join(',')}
+                                    ${this[_ids] && this[_ids].length ? `, PRIMARY KEY (${this[_ids].map(i => this[_fields]![i]?.C2()).join(',')})` : ''}
                                 );
                             `);
                             if (this[_index] && this[_index].length) {
                                 for (const index of this[_index]) {
-                                    option!.conn!.execute(SyncMode.Sync, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableES} ("${index}");`);
+                                    option!.conn!.execute(SyncMode.Sync, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableES} ("${this[_fields]![index]?.C2()}");`);
                                 }
                             }
                             option!.conn!.execute(SyncMode.Sync, `INSERT INTO ${tableES} (${columns}) SELECT ${columns} FROM ${rtable};`);
@@ -1541,14 +1883,14 @@ function P<T extends object>(skipConn = false) {
                         // 创建表
                         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(',')})` : ''}
+                                ${Object.values(this[_fields]!).map(K => K[DBType.Sqlite]()).join(',')}
+                                ${this[_ids] && this[_ids].length ? `, PRIMARY KEY (${this[_ids].map(i => this[_fields]![i]?.C2()).join(',')})` : ''}
                     
                             );
                         `);
                         if (this[_index] && this[_index].length) {
                             for (const index of this[_index]) {
-                                option!.conn!.execute(SyncMode.Sync, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableES} ("${index}");`);
+                                option!.conn!.execute(SyncMode.Sync, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableES} ("${this[_fields]![index]?.C2()}");`);
                             }
                         }
                         option!.conn!.execute(SyncMode.Sync, 'INSERT OR REPLACE INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option!.tableName, lastVersion]);
@@ -1592,7 +1934,7 @@ function P<T extends object>(skipConn = false) {
                             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))
+                                    .filter(c => this[_fields]!.hasOwnProperty(C2P(c.name, globalThis[_Hump])))
                                     .map(c => Sqlstring.escapeId(c.name))
                                     .join(',');
 
@@ -1601,13 +1943,13 @@ function P<T extends object>(skipConn = false) {
                                 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(',')})` : ''}
+                                    ${Object.values(this[_fields]!).map(K => K[DBType.Sqlite]()).join(',')}
+                                    ${this[_ids] && this[_ids].length ? `, PRIMARY KEY (${this[_ids].map(i => this[_fields]![i]?.C2()).join(',')})` : ''}
                                 );
                             `);
                                 if (this[_index] && this[_index].length) {
                                     for (const index of this[_index]) {
-                                        await option!.conn!.execute(SyncMode.Async, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableES} ("${index}");`);
+                                        await option!.conn!.execute(SyncMode.Async, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableES} ("${this[_fields]![index]?.C2()}");`);
                                     }
                                 }
                                 await option!.conn!.execute(SyncMode.Async, `INSERT INTO ${tableES} (${columns}) SELECT ${columns} FROM ${rtable};`);
@@ -1622,13 +1964,13 @@ function P<T extends object>(skipConn = false) {
                             // 创建表
                             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(',')})` : ''}
+                                ${Object.values(this[_fields]!).map(K => K[DBType.Sqlite]()).join(',')}
+                                ${this[_ids] && this[_ids].length ? `, PRIMARY KEY (${this[_ids].map(i => this[_fields]![i]?.C2()).join(',')})` : ''}
                             );
                         `);
                             if (this[_index] && this[_index].length) {
                                 for (const index of this[_index]) {
-                                    await option!.conn!.execute(SyncMode.Async, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${Sqlstring.escapeId(option!.tableName)} ("${index}");`);
+                                    await option!.conn!.execute(SyncMode.Async, `CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${Sqlstring.escapeId(option!.tableName)} ("${this[_fields]![index]?.C2()}");`);
                                 }
                             }
                             await option!.conn!.execute(SyncMode.Async, 'INSERT OR REPLACE INTO TABLE_VERSION (______tableName, ______version ) VALUES ( ?, ? )', [option!.tableName, lastVersion]);
@@ -1682,27 +2024,40 @@ function P<T extends object>(skipConn = false) {
     };
 }
 const FieldFilter = (
-    K: string, V: any, def: any,
-    option?: MethodOption & { finalColumns?: Set<string>; tempColumns?: Array<string>; def?: boolean; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; }
+    K: string, V: any, def: any, uuidColumn: boolean,
+    option?: MethodOption & { finalColumns?: Set<string>; tempColumns?: Array<string>; insert?: 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) {
+    // 如果是插入操作且字段是UUID，则不进行空值检查
+    // 只有在非插入或者非UUID时，进行空置检查
+    if (option?.insert === true && uuidColumn === true) {
+        ret = 1;
+        if (V === undefined) {
+            V = null;
+        } else if (emptyString(`${V ?? ''}`)) {
+            V = '';
+        } else {
             ret = 1;
-            V = option?.def === true && def && def.hasOwnProperty(K) ? def[K] : null;
         }
-    } else if (emptyString(`${V ?? ''}`)) {
-        if (option?.skipEmptyString !== true) {
+    } else {
+        if (V === null) {
+            if (option?.skipNull !== true) {
+                ret = 1;
+                V = option?.insert === true && def && def.hasOwnProperty(K) ? def[K] : null;
+            }
+        } else if (V === undefined) {
+            if (option?.skipUndefined !== true) {
+                ret = 1;
+                V = option?.insert === true && def && def.hasOwnProperty(K) ? def[K] : null;
+            }
+        } else if (emptyString(`${V ?? ''}`)) {
+            if (option?.skipEmptyString !== true) {
+                ret = 1;
+                V = option?.insert === true && def && def.hasOwnProperty(K) ? def[K] : '';
+            }
+        } else {
             ret = 1;
-            V = option?.def === true && def && def.hasOwnProperty(K) ? def[K] : '';
         }
-    } else {
-        ret = 1;
     }
     if (ret === 1) {
         option?.finalColumns?.add(K);
@@ -1710,204 +2065,203 @@ const FieldFilter = (
     }
     return [ret, V];
 }
-const MYSQLCHARSET = `CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci`
+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);
+        field.P = propertyName;
+        field.C = () => P2C(propertyName, globalThis[_Hump]);
+        field.C2 = () => Sqlstring.escapeId(P2C(propertyName, globalThis[_Hump]));
+        field.C3 = () => `${Sqlstring.escapeId(P2C(propertyName, globalThis[_Hump]))} ${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`;
+                field[DBType.Mysql] = () => `${field.C2()} tinyint ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} smallint ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} smallint ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} int ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} bigint ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} float(${config.length ?? 1}, ${config.scale ?? 2}) ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? `DEFAULT '${field.def}'` : ''} `;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} double(${config.length ?? 1}, ${config.scale ?? 2}) ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? `DEFAULT '${field.def}'` : ''} `;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} decimal(${config.length ?? 1}, ${config.scale ?? 2}) ${config.notNull === true ? 'NOT NULL' : ''} ${hasDef ? `DEFAULT '${field.def}'` : ''} `;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} longtext ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} mediumtext ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} text ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} date ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} time ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} year ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} datetime ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} timestamp ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} char(${config.length ?? 1}) ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} varchar(${config.length ?? 1}) ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} tinyblob ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} tinytext ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} binary ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} text ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} mediumblob ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} mediumtext ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} longblob ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} longtext ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} set ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} enum ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} json ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} geometry ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} point ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} linestring ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} polygon ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} multipoint ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} multilinestring ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} multipolygon ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} 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`;
+                field[DBType.Mysql] = () => `${field.C2()} geometrycollection ${config.notNull === true ? 'NOT NULL' : ''} ${MYSQLCHARSET} ${hasDef ? `DEFAULT '${field.def}'` : ''}`;
+                field[DBType.SqliteRemote] = field[DBType.Sqlite] = () => `${field.C2()} text`;
                 break;
             }
         };
@@ -1939,7 +2293,6 @@ export const Field = (config: FieldOption) => {
         if (hasDef) {
             __def[propertyName] = field.def;
         }
-
         Reflect.defineMetadata(_fields, __fields, object);
         Reflect.defineMetadata(_columns, __columns, object);
         Reflect.defineMetadata(_columnsNoId, __columnsNoId, object);
@@ -1962,8 +2315,14 @@ export const DB = (config: ServiceOption) => {
         const __deleteState = Reflect.getMetadata(_deleteState, config.clz.prototype);
         const __index = Reflect.getMetadata(_index, config.clz.prototype);
         const __def = Reflect.getMetadata(_def, config.clz.prototype);
+        const className = config.tableName?.replace(/_(\w)/g, (a: string, b: string) => b.toUpperCase());
+        const ClassName = className?.replace(/\w/, (v: string) => v.toUpperCase());
+        const vueName = config.tableName?.replace(/_/g, '-');
         return class extends constructor {
             [_tableName] = config.tableName;
+            [_className] = className;
+            [_ClassName] = ClassName;
+            [_vueName] = vueName;
             [_daoDBName] = config.dbName;
             [_dbType] = config.dbType ?? DBType.Mysql;
             [_sqlite_version] = config.sqliteVersion;
@@ -1983,14 +2342,17 @@ export const DB = (config: ServiceOption) => {
                 option?: MethodOption & {
                     finalColumns?: Set<string>;
                     tempColumns?: Array<string>;
-                    def?: boolean;
+                    insert?: boolean;
                     skipId?: boolean;
+                    skipNull?: boolean;
+                    skipUndefined?: boolean;
+                    skipEmptyString?: 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)])
+                        .map(K => [K, FieldFilter(K as string, data[K as string], __def, __fields[K as string].uuid === true || __fields[K as string].uuidShort === true, option)])
                         .filter(data => {
                             if ((data[1] as any)[0] === 1) {
                                 if (option?.onFieldExists) {
@@ -2022,7 +2384,7 @@ export const DB = (config: ServiceOption) => {
  */
 export function DeclareClass(clz: any, FieldOptions: FieldOption[]) {
     for (const item of FieldOptions) {
-        tslib.__decorate([Field(item)], clz.prototype, item.name, void 0);
+        tslib.__decorate([Field(item)], clz.prototype, item.P, void 0);
     }
 }
 /**
@@ -2052,6 +2414,9 @@ export function DeclareService(clz: any, config: ServiceOption) {
  */
 export class SqlService<T extends object> {
     private [_tableName]?: string;
+    private [_className]?: string;
+    private [_ClassName]?: string;
+    private [_vueName]?: string;
     private [_daoDBName]?: string;
     private [_ids]?: string[];
     private [_fields]?: Record<string, AField>;
@@ -2064,12 +2429,21 @@ export class SqlService<T extends object> {
     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>;
+    public [_transformer]?: <L = T>(data: Partial<L>, option?: MethodOption & {
+        finalColumns?: Set<string>;
+        insert?: boolean;
+        skipId?: boolean;
+        skipNull?: boolean;
+        skipUndefined?: boolean;
+        skipEmptyString?: boolean;
+        onFieldExists?: (K: string, V: any) => void;
+    }) => Partial<T>;
     private _insert(
         datas: Partial<T>[],
         option: MethodOption & {
             mode?: InsertMode;
             existConditionOtherThanIds?: (keyof T)[];
+            replaceWithDef?: boolean;
         }): { sql: string; params?: any[] }[] {
         const sqls: { sql: string; params?: any[] }[] = [];
         const tableName = Sqlstring.escapeId(option!.tableName);
@@ -2078,28 +2452,37 @@ export class SqlService<T extends object> {
                 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 where = iterare<string>(conditions! as string[]).map(c => `${this[_fields]![c]?.C2()} = ?`).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 params: any[] = [];
+                const questMarks = datas
+                    .map(data => this[_transformer]!(data, { ...option, finalColumns, insert: true }))
+                    .map(data => {
                         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
-                            );
+                            const V = data.hasOwnProperty(column)
+                                ? data[column]
+                                : this[_def] && this[_def].hasOwnProperty(column)
+                                    ? this[_def][column]
+                                    : null;
+                            if (V === null) {
+                                const field = this[_fields]![column];
+                                if (field?.uuid) {
+                                    questMark.push('UUID()');
+                                } else if (field?.uuidShort && this[_dbType] === DBType.Mysql) {
+                                    questMark.push('UUID_SHORT()');
+                                } else {
+                                    questMark.push('?');
+                                    params.push(V);
+                                }
+                            } else {
+                                questMark.push('?');
+                                params.push(V);
+                            }
                         }
-
                         for (const column of whereColumns) {
-                            questMark.push('?');
-                            result.push(
+                            params.push(
                                 data.hasOwnProperty(column)
                                     ? data[column]
                                     : this[_def] && this[_def].hasOwnProperty(column)
@@ -2107,118 +2490,147 @@ export class SqlService<T extends object> {
                                         : null
                             );
                         }
-                        return result;
+                        return `SELECT ${questMark.join(',')} FROM DUAL WHERE NOT EXISTS (SELECT 1 FROM ${tableName} WHERE ${where})`;
                     });
-                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};`;
+                const columnNames = iterare<string>(finalColumns).map(i => this[_fields]![i]?.C2()).join(',');
+                const sql = format(`INSERT INTO
+                ${tableName}
+                (${columnNames})
+                ${questMarks.join(' UNION ALL ')};`);
                 sqls.push({ sql, params });
+                break;
             }
             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 params: any[] = [];
+                const questMarks = datas
+                    .map(data => this[_transformer]!(data, { ...option, finalColumns, insert: true }))
+                    .map(data => {
                         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
-                            );
+                            const V = data.hasOwnProperty(column)
+                                ? data[column]
+                                : this[_def] && this[_def].hasOwnProperty(column)
+                                    ? this[_def][column]
+                                    : null;
+                            if (V === null) {
+                                const field = this[_fields]![column];
+                                if (field?.uuid) {
+                                    questMark.push('UUID()');
+                                } else if (field?.uuidShort && this[_dbType] === DBType.Mysql) {
+                                    questMark.push('UUID_SHORT()');
+                                } else {
+                                    questMark.push('?');
+                                    params.push(V);
+                                }
+                            } else {
+                                questMark.push('?');
+                                params.push(V);
+                            }
                         }
-                        return result;
+                        return `(${questMark.join(',')})`;
                     });
-                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 = `
+                const columnNames = iterare(finalColumns).map(i => this[_fields]![i]?.C2()).join(',');
+                const sql = format(`
                     ${this[_dbType] === DBType.Mysql ? '' : 'INSERT OR'} REPLACE INTO
                     ${tableName}
                     (${columnNames})
                     VALUES ${questMarks};
-                `;
+                `);
                 sqls.push({ sql, params });
+                break;
             }
             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 params: any[] = [];
+                const questMarks = datas
+                    .map(data => this[_transformer]!(data, { ...option, finalColumns, insert: true }))
+                    .map(data => {
                         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
-                            );
+                            const V = data.hasOwnProperty(column)
+                                ? data[column]
+                                : this[_def] && this[_def].hasOwnProperty(column)
+                                    ? this[_def][column]
+                                    : null;
+                            if (V === null) {
+                                const field = this[_fields]![column];
+                                if (field?.uuid) {
+                                    questMark.push('UUID()');
+                                } else if (field?.uuidShort && this[_dbType] === DBType.Mysql) {
+                                    questMark.push('UUID_SHORT()');
+                                } else {
+                                    questMark.push('?');
+                                    params.push(V);
+                                }
+                            } else {
+                                questMark.push('?');
+                                params.push(V);
+                            }
                         }
-                        return result;
+                        return `(${questMark.join(',')})`;
                     });
-                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 = `
+                const columnNames = iterare(finalColumns).map(i => this[_fields]![i]?.C2()).join(',');
+                const sql = format(`
                     INSERT INTO
                     ${tableName}
                     (${columnNames})
                     VALUES ${questMarks};
-                `;
+                `);
+
                 sqls.push({ sql, params });
+                break;
             }
             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 params: any[] = [];
+                const questMarks = datas
+                    .map(data => this[_transformer]!(data, { ...option, finalColumns, insert: true }))
+                    .map(data => {
                         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 V = data.hasOwnProperty(column)
+                                ? data[column]
+                                : this[_def] && this[_def].hasOwnProperty(column)
+                                    ? this[_def][column]
+                                    : null;
+                            if (V === null) {
+                                const field = this[_fields]![column];
+                                if (field?.uuid) {
+                                    questMark.push('UUID()');
+                                } else if (field?.uuidShort && this[_dbType] === DBType.Mysql) {
+                                    questMark.push('UUID_SHORT()');
+                                } else {
+                                    questMark.push('?');
+                                    params.push(V);
+                                }
+                            } else {
+                                questMark.push('?');
+                                params.push(V);
+                            }
+                        }
+                        return `(${questMark.join(',')})`
                     });
                 const _sqls = this._createTable({ tableName: tableTemp, temp: true, columns: Array.from(finalColumns) })!;
                 sqls.push(..._sqls);
-
-                const 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 columnNames = iterare(finalColumns).map(i => this[_fields]![i]?.C2()).join(',');
                 sqls.push({
-                    sql: `
+                    sql: format(`
                         INSERT INTO
                         ${tableTemp}
                         (${columnNames})
                         VALUES ${questMarks};
-                    `, params
+                    `), params
                 });
                 sqls.push({
-                    sql: `INSERT INTO ${Sqlstring.escapeId(option.tableName)} (${columnNames})
-                        SELECT ${columnNames} FROM ${tableTemp};`
+                    sql: format(`INSERT INTO ${Sqlstring.escapeId(option.tableName)} (${columnNames})
+                        SELECT ${columnNames} FROM ${tableTemp};`)
                 });
                 sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
+                break;
             }
         }
         return sqls;
@@ -2244,18 +2656,19 @@ export class SqlService<T extends object> {
         2. `insertIfNotExists`: 通过主键或者existConditionOtherThanIds字段判断数据是否存在，不存在才插入,存在则不执行
         3. `replace`: 只支持用主键判断, 存在更新, 不存在插入
     11. `existConditionOtherThanIds`: insertIfNotExists时判断同一记录的字段名称，默认情况下按照ID判断，设置existConditionOtherThanIds后，不用id
+    12. `replaceWithDef` replace时，是否带入默认值? 默认true
     ### 返回值是最后一次插入的主键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[];
+    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; replaceWithDef?: boolean; }): 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; replaceWithDef?: boolean; }): 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; replaceWithDef?: boolean; }): 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; replaceWithDef?: boolean; }): 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[]> {
+    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; replaceWithDef?: boolean; }): 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];
@@ -2278,7 +2691,7 @@ export class SqlService<T extends object> {
                 if (isArray) return result;
                 else return result[0]!;
             };
-            if (option?.conn?.[_inTransaction] === true) {
+            if (this[_dbType] === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
                 return fn();
             } else {
                 return option?.dao?.transaction(SyncMode.Sync, fn, option?.conn)!;
@@ -2303,11 +2716,15 @@ export class SqlService<T extends object> {
                     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);
+            return new Promise<bigint[]>(async (resolve, reject) => {
+                try {
+                    if (this[_dbType] === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
+                        resolve((await fn())!);
+                    } else {
+                        await option?.dao?.transaction(SyncMode.Async, async () => resolve((await fn())!), option?.conn);
+                    }
+                } catch (error) {
+                    reject(error);
                 }
             });
         } else {
@@ -2328,11 +2745,15 @@ export class SqlService<T extends object> {
                 );
                 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);
+            return new Promise<bigint>(async (resolve, reject) => {
+                try {
+                    if (this[_dbType] === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
+                        resolve((await fn())!);
+                    } else {
+                        await option?.dao?.transaction(SyncMode.Async, async () => resolve((await fn())!), option?.conn);
+                    }
+                } catch (error) {
+                    reject(error);
                 }
             });
         }
@@ -2341,7 +2762,7 @@ export class SqlService<T extends object> {
     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 where = `WHEN ${iterare(this[_ids]!).map(c => `${this[_fields]![c]?.C2()} = ?`).join(' AND ')} THEN ?`;
         const columnMaps: Record<string, {
             where: string[];
             params: any[];
@@ -2366,13 +2787,13 @@ export class SqlService<T extends object> {
                 }
             );
         }
-        const sql = `UPDATE ${tableName} SET ${iterare(this[_columnsNoId]!)
+        const sql = format(`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`
+                return `${this[_fields]![K]?.C2()} = CASE ${columnMaps[K]!.where.join(' ')} ELSE ${this[_fields]![K]?.C2()} END`
             })
-            .join(',')};`
+            .join(',')};`);
         sqls.push({ sql, params });
         return sqls;
     }
@@ -2418,7 +2839,7 @@ export class SqlService<T extends object> {
                 );
                 return result.reduce((a, b) => a + b);
             };
-            if (option?.conn?.[_inTransaction] === true) {
+            if (this[_dbType] === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
                 return fn();
             } else {
                 return option?.dao?.transaction(SyncMode.Sync, fn, option?.conn)!;
@@ -2441,11 +2862,15 @@ export class SqlService<T extends object> {
                 );
                 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);
+            return new Promise<number>(async (resolve, reject) => {
+                try {
+                    if (this[_dbType] === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
+                        resolve((await fn())!);
+                    } else {
+                        await option?.dao?.transaction(SyncMode.Async, async () => resolve((await fn())!), option?.conn);
+                    }
+                } catch (error) {
+                    reject(error);
                 }
             });
         }
@@ -2507,19 +2932,20 @@ export class SqlService<T extends object> {
                 return `(
                     ${Object.entries(where).map(([K, V]) => {
                     params.push(V);
-                    return `${K} = ?`;
+                    return `${this[_fields]![K]?.C2()} = ?`;
                 }).join(' AND ')}
                 )`;
             }).join(' OR ');
             if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                params.unshift(this[_deleteState]);
                 sqls.push({
-                    sql: `
-                    UPDATE ${tableNameESC} SET ${this[_fields]![this[_stateFileName]]?.esName} = ${Sqlstring.escape(this[_deleteState])}
+                    sql: format(`
+                    UPDATE ${tableNameESC} SET ${this[_fields]![this[_stateFileName]]?.C2()} = ?
                     WHERE ${whereSql};
-                `, params
+                `), params
                 });
             } else {
-                sqls.push({ sql: `DELETE FROM ${tableNameESC} WHERE ${whereSql};`, params });
+                sqls.push({ sql: format(`DELETE FROM ${tableNameESC} WHERE ${whereSql};`), params });
             }
         } else {
             sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
@@ -2530,26 +2956,30 @@ export class SqlService<T extends object> {
                 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])};`
+                            sql: format(`UPDATE ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields]![K]?.C2()} = b.${this[_fields]![K]?.C2()}`).join(' AND ')}
+                            SET a.${this[_fields]![this[_stateFileName]]?.C2()} = ?;`),
+                            params: [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 ')};`
+                            sql: format(`DELETE a.* FROM ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields]![K]?.C2()} = b.${this[_fields]![K]?.C2()}`).join(' AND ')};`)
                         });
                     }
+                    break;
                 }
                 case DBType.Sqlite:
                 case DBType.SqliteRemote: {
-                    const columnNames = iterare(delWhere).map(K => this[_fields]![K]?.esName).join(',');
+                    const columnNames = iterare(delWhere).map(K => this[_fields]![K]?.C2()).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});`
+                            sql: format(`UPDATE ${tableNameESC} SET ${this[_fields]![this[_stateFileName]]?.C2()} = ?
+                            WHERE (${columnNames}) IN (SELECT ${columnNames} FROM ${tableTempESC});`),
+                            params: [this[_deleteState]]
                         });
                     } else {
-                        sqls.push({ sql: `DELETE FROM ${tableNameESC} WHERE (${columnNames}) IN (SELECT ${columnNames} FROM ${tableTempESC});` });
+                        sqls.push({ sql: format(`DELETE FROM ${tableNameESC} WHERE (${columnNames}) IN (SELECT ${columnNames} FROM ${tableTempESC});`) });
                     }
+                    break;
                 }
             }
             sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
@@ -2564,7 +2994,7 @@ export class SqlService<T extends object> {
                 }
                 return result;
             };
-            if (option?.conn?.[_inTransaction] === true) {
+            if (this[_dbType] === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
                 return fn();
             } else {
                 return option?.dao?.transaction(SyncMode.Sync, fn, option?.conn)!;
@@ -2578,11 +3008,15 @@ export class SqlService<T extends object> {
                 }
                 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);
+            return new Promise<number>(async (resolve, reject) => {
+                try {
+                    if (this[_dbType] === DBType.SqliteRemote || option?.conn?.[_inTransaction] === true) {
+                        resolve((await fn())!);
+                    } else {
+                        await option?.dao?.transaction(SyncMode.Async, async () => resolve((await fn())!), option?.conn);
+                    }
+                } catch (error) {
+                    reject(error);
                 }
             });
         }
@@ -2604,6 +3038,9 @@ export class SqlService<T extends object> {
             case TemplateResult.Count: {
                 return result[0].ct;
             }
+            case TemplateResult.ManyList: {
+                return new ArrayList(result[0]);
+            }
         }
     }
     /**
@@ -2629,20 +3066,18 @@ export class SqlService<T extends object> {
     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[]>;
+    template<L = T>(option: MethodOption & { sync: SyncMode.Sync; templateResult?: TemplateResult.AssertOne; id?: string | number | Array<string | number>; where?: Partial<L> | Array<Partial<L>>; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; mode?: SelectMode; error?: string; columns?: (keyof L)[]; }): L;
+    template<L = T>(option: MethodOption & { sync?: SyncMode.Async; templateResult?: TemplateResult.AssertOne; id?: string | number | Array<string | number>; where?: Partial<L> | Array<Partial<L>>; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; mode?: SelectMode; error?: string; columns?: (keyof L)[]; }): Promise<L>;
+    template<L = T>(option: MethodOption & { sync: SyncMode.Sync; templateResult: TemplateResult.Count; id?: string | number | Array<string | number>; where?: Partial<L> | Array<Partial<L>>; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; mode?: SelectMode; error?: string; columns?: (keyof L)[]; }): number;
+    template<L = T>(option: MethodOption & { sync?: SyncMode.Async; templateResult: TemplateResult.Count; id?: string | number | Array<string | number>; where?: Partial<L> | Array<Partial<L>>; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; mode?: SelectMode; error?: string; columns?: (keyof L)[]; }): Promise<number>;
+    template<L = T>(option: MethodOption & { sync: SyncMode.Sync; templateResult: TemplateResult.NotSureOne; id?: string | number | Array<string | number>; where?: Partial<L> | Array<Partial<L>>; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; mode?: SelectMode; error?: string; columns?: (keyof L)[]; }): L | null;
+    template<L = T>(option: MethodOption & { sync?: SyncMode.Async; templateResult: TemplateResult.NotSureOne; id?: string | number | Array<string | number>; where?: Partial<L> | Array<Partial<L>>; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; mode?: SelectMode; error?: string; columns?: (keyof L)[]; }): Promise<L | null>;
+    template<L = T>(option: MethodOption & { sync: SyncMode.Sync; templateResult: TemplateResult.Many; id?: string | number | Array<string | number>; where?: Partial<L> | Array<Partial<L>>; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; mode?: SelectMode; error?: string; columns?: (keyof L)[]; }): L[];
+    template<L = T>(option: MethodOption & { sync?: SyncMode.Async; templateResult: TemplateResult.Many; id?: string | number | Array<string | number>; where?: Partial<L> | Array<Partial<L>>; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; mode?: SelectMode; error?: string; columns?: (keyof L)[]; }): Promise<L[]>;
+    template<L = T>(option: MethodOption & { sync: SyncMode.Sync; templateResult: TemplateResult.ManyList; id?: string | number | Array<string | number>; where?: Partial<L> | Array<Partial<L>>; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; mode?: SelectMode; error?: string; columns?: (keyof L)[]; }): ArrayList<L>;
+    template<L = T>(option: MethodOption & { sync?: SyncMode.Async; templateResult: TemplateResult.ManyList; id?: string | number | Array<string | number>; where?: Partial<L> | Array<Partial<L>>; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; mode?: SelectMode; error?: string; columns?: (keyof L)[]; }): Promise<ArrayList<L>>;
     @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[]> {
+    template<L = T>(option: MethodOption & { sync?: SyncMode; templateResult?: TemplateResult; id?: string | number | Array<string | number>; where?: Partial<L> | Array<Partial<L>>; skipUndefined?: boolean; skipNull?: boolean; skipEmptyString?: boolean; mode?: SelectMode; error?: string; columns?: (keyof L)[]; }): number | L | null | L[] | ArrayList<L> | Promise<number | L | null | L[] | ArrayList<L>> {
         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!');
@@ -2659,30 +3094,30 @@ export class SqlService<T extends object> {
         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>>;
+            option.where = ids.map(i => ({ [idName]: i })) as Array<Partial<L>>;
         }
-        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 columns = option.templateResult === TemplateResult.Count ? 'COUNT(1) ct' : iterare((option.columns as unknown as string[] ?? this[_columns])!).map((K: any) => `a.${this[_fields]![K]?.C3()}`).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 => {
+            const whereSql = format(iterare(wheres).map(where => this[_transformer]!(where, option)).map(where => {
                 return `SELECT ${columns} FROM ${tableNameESC} a WHERE
                     ${Object.entries(where).map(([K, V]) => {
                     params.push(V);
-                    return `${K} = ?`;
+                    return `${this[_fields]![K]?.C2()} = ?`;
                 }).join(' AND ')}`;
-            }).join(' UNION ALL ');
+            }).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' })!;
+            const _sqls = this._createTable<L>({ 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: format(`SELECT ${columns} FROM ${tableNameESC} a INNER JOIN ${tableTempESC} b ON ${delWhere.map(K => `a.${this[_fields]![K]?.C2()} = b.${this[_fields]![K]?.C2()}`).join(' AND ')};`) });
             sqls.push({ sql: `DROP TABLE IF EXISTS ${tableTempESC};` });
         }
 
@@ -2697,112 +3132,113 @@ export class SqlService<T extends object> {
             }
             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);
+            return new Promise<L | null | L[]>(async (resolve, reject) => {
+                try {
+                    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));
+                } catch (error) {
+                    reject(error);
                 }
-                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[];
+
+    private _select<L = T>(templateResult: SelectResult, result: any, def: L | null, errorMsg?: string, hump?: boolean, mapper?: string | SqlMapper, mapperIfUndefined?: MapperIfUndefined) {
+        switch (templateResult) {
+            case SelectResult.R_C_NotSure: {
+                try {
+                    return Object.values(result[0])[0] as L;
+                } catch (error) {
+                    return def;
                 }
             }
-        } 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.R_C_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: {
+            }
+            case SelectResult.R_CS_NotSure: {
+                if (mapper) {
+                    return flatData<L>({ data: result[0], mapper, mapperIfUndefined });
+                } else if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
+                    return (C2P2(result[0]) as L) ?? null;
+                } else {
                     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!');
+
+            }
+            case SelectResult.R_CS_Assert: {
+                const data = result[0] as L;
+                Throw.if(data === null || data === undefined, errorMsg ?? 'not found data!');
+                if (mapper) {
+                    return flatData<L>({ data, mapper, mapperIfUndefined });
+                } else if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
+                    return C2P2(data as any) ?? null;
+                } else {
                     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.RS_C: {
+                try {
+                    return result.map((r: any) => Object.values(r)[0] as L);
+                } catch (error) {
+                    return result as L[];
                 }
-                case SelectResult.Many_Row_Many_Column: {
+            }
+            case SelectResult.RS_CS: {
+                if (mapper) {
+                    return iterare(result).map((data: any) => flatData<L>({ data, mapper, mapperIfUndefined })).toArray();
+                } else if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
+                    return iterare(result).map((r: any) => C2P2(r) as L).toArray();
+                } else {
                     return result as L[];
                 }
             }
+            case SelectResult.RS_C_List: {
+                try {
+                    return new ArrayList<L>(result.map((r: any) => Object.values(r)[0] as L));
+                } catch (error) {
+                    return new ArrayList<L>();
+                }
+            }
+            case SelectResult.RS_CS_List: {
+                if (mapper) {
+                    return new ArrayList<L>(iterare(result).map((data: any) => flatData<L>({ data, mapper, mapperIfUndefined })).toArray());
+                } else if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
+                    return new ArrayList<L>(iterare(result).map((r: any) => C2P2(r) as L).toArray());
+                } else {
+                    return new ArrayList<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[默认]
+    1. `templateResult`: 返回值类型断言，6种, R表示行，C表示列，带S表示复数
+        1. R_C_Assert,
+        2. R_C_NotSure,
+        3. R_CS_Assert,
+        4. R_CS_NotSure,
+        5. RS_C,
+        6. RS_C_List
+        7. RS_CS[默认]
+        8. RS_CS_List
     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']]`
+    5. 禁止一次查询多个语句
     6. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
     7. `conn`: 仅在开启事务时需要主动传入,传入示例:
         ```
@@ -2811,38 +3247,66 @@ export class SqlService<T extends object> {
             });
         ```
     9.  `dao`: 永远不需要传入该值
+    10. `hump`: 是否将列名改为驼峰写法？默认情况下按照全局配置
+    11. `mapper`: 列名-属性 映射工具，优先级高于hump
 
      */
-    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;
+    select<L = T>(option: MethodOption & { sync?: SyncMode.Async; selectResult?: SelectResult.RS_CS | SelectResult.RS_C; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; errorMsg?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): Promise<L[]>;
+    select<L = T>(option: MethodOption & { sync?: SyncMode.Async; selectResult: SelectResult.RS_CS_List | SelectResult.RS_C_List; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; errorMsg?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): Promise<ArrayList<L>>;
+    select<L = T>(option: MethodOption & { sync?: SyncMode.Async; selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; errorMsg?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): Promise<L>;
+    select<L = T>(option: MethodOption & { sync?: SyncMode.Async; selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; errorMsg?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): Promise<L | null>;
+    select<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult?: SelectResult.RS_CS | SelectResult.RS_C; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; errorMsg?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): L[];
+    select<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult: SelectResult.RS_CS_List | SelectResult.RS_C_List; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; errorMsg?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): ArrayList<L>;
+    select<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; errorMsg?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): L;
+    select<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; errorMsg?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): 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[]> {
+    select<L = T>(option: MethodOption & { sync?: SyncMode; selectResult?: SelectResult; sqlId?: string; sql?: string; params?: Record<string, any>; context?: any; isCount?: boolean; defValue?: L | null; errorMsg?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): null | L | L[] | ArrayList<L> | Promise<null | L | L[] | ArrayList<L>> {
         Throw.if(!option.sqlId && !option.sql, 'not found sql!');
-        option.selectResult ??= SelectResult.Many_Row_Many_Column;
+        option.selectResult ??= SelectResult.RS_CS;
         option.defValue ??= null;
+        if (option.sqlId && globalThis[_resultMap_SQLID][option.sqlId] && !option.mapper) {
+            option.mapper = globalThis[_resultMap_SQLID][option.sqlId];
+        }
         const _params = Object.assign({}, option.context, option.params);
-        option.sql ??= globalThis[_sqlCache].load(option.sqlId, { ctx: option.context, isCount: option.isCount, ..._params });
-        logger.debug(option.sql);
+        option.sql ??= globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: option.context, isCount: option.isCount, ..._params });
         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]);
+        const sql = option.sql?.replace(/\:([A-Za-z0-9._]+)/g, (txt, key) => {
+            let V = LGet(_params, key);
+            if (V) {
+                if (V !== undefined) {
+                    params.push(V);
+                }
+                return '?';
+            }
+            const _key = C2P(key);
+            V = LGet(_params, _key);
+            if (V) {
+                if (V !== undefined) {
+                    params.push(V);
+                }
+                return '?';
+            }
+            const __key = P2C(key);
+            V = LGet(_params, __key);
+            if (V) {
+                if (V !== undefined) {
+                    params.push(V);
+                }
+                return '?';
             }
             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);
+            return this._select<L>(option.selectResult, result, option.defValue, option.errorMsg, option.hump, option.mapper, option.mapperIfUndefined);
         } 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));
+            return new Promise<L | null | L[]>(async (resolve, reject) => {
+                try {
+                    const result = await option!.conn!.query(SyncMode.Async, sql, params);
+                    resolve(this._select<L>(option.selectResult!, result, option.defValue!, option.errorMsg, option.hump, option.mapper, option.mapperIfUndefined));
+                } catch (error) {
+                    reject(error);
+                }
             });
         }
     }
@@ -2860,7 +3324,7 @@ export class SqlService<T extends object> {
              });
          ```
      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;
@@ -2868,14 +3332,31 @@ export class SqlService<T extends object> {
     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);
+        option.sql ??= globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: option.context, ..._params });
         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]);
+            let V = LGet(_params, key);
+            if (V) {
+                if (V !== undefined) {
+                    params.push(V);
+                }
+                return '?';
+            }
+            const _key = C2P(key);
+            V = LGet(_params, _key);
+            if (V) {
+                if (V !== undefined) {
+                    params.push(V);
+                }
+                return '?';
+            }
+            const __key = P2C(key);
+            V = LGet(_params, __key);
+            if (V) {
+                if (V !== undefined) {
+                    params.push(V);
+                }
+                return '?';
             }
             return txt;
         });
@@ -2883,9 +3364,13 @@ export class SqlService<T extends object> {
             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);
+            return new Promise<number>(async (resolve, reject) => {
+                try {
+                    const result = await option!.conn!.execute(SyncMode.Async, sql, params);
+                    resolve(result.affectedRows);
+                } catch (error) {
+                    reject(error);
+                }
             });
         }
     }
@@ -2914,15 +3399,129 @@ export class SqlService<T extends object> {
         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);
+            return new Promise(async (resolve, reject) => {
+                try {
+                    const rt = await option!.dao!.transaction(SyncMode.Async, option.fn as (conn: Connection) => Promise<L>);
+                    resolve(rt);
+                } catch (error) {
+                    reject(error);
+                }
             });
         }
     }
 
-    stream(option?: MethodOption) {
-        return new StreamQuery(option?.tableName ?? this[_tableName]!, this);
+    stream<L extends object = T>(option?: MethodOption) {
+        return new StreamQuery<L>(option?.tableName ?? this[_tableName]!, this as any, this[_fields]!, this[_columns]!);
+    }
+
+
+    page<L = T>(option: MethodOption & { sync?: SyncMode.Async; sqlId: string; context?: any; params: Record<string, any>; pageSize: number; pageNumber: number; limitSelf?: boolean; countSelf?: boolean; sumSelf?: boolean; orderBy?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): Promise<PageQuery<L>>;
+    page<L = T>(option: MethodOption & { sync: SyncMode.Sync; sqlId: string; context?: any; params: Record<string, any>; pageSize: number; pageNumber: number; limitSelf?: boolean; countSelf?: boolean; sumSelf?: boolean; orderBy?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): PageQuery<L>;
+    @P<T>()
+    page<L = T>(option: MethodOption & { sync?: SyncMode; sqlId: string; context?: any; params: Record<string, any>; pageSize: number; pageNumber: number; limitSelf?: boolean; countSelf?: boolean; sumSelf?: boolean; orderBy?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): PageQuery<L> | Promise<PageQuery<L>> {
+        const result: PageQuery<L> = {
+            sum: {},
+            records: [],
+            size: 0,
+            total: 0
+        };
+        Object.assign(option.params, {
+            limitStart: calc(option.pageNumber).sub(1).mul(option.pageSize).over(),
+            limitEnd: calc(option.pageSize).over(),
+            orderBy: option.orderBy
+        });
+        let sql = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: option.context, isCount: false, ...option.params });
+        let sqlSum = '';
+        let sqlCount = '';
+        if (option.sumSelf === true) {
+            sqlSum = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: option.context, isCount: false, isSum: true, ...option.params });
+        }
+        if (option.limitSelf !== true) {
+            if (option.countSelf !== true) {
+            }
+            if (option.orderBy) {
+                sql = `${sql} ORDER BY ${option.orderBy}`;
+            }
+            if (option.pageSize > 0) {
+                sql = `${sql} LIMIT ${option.params['limitStart']}, ${option.pageSize}`;
+            }
+        }
+        if (option.pageSize > 0) {
+            if (option.countSelf === true) {
+                sqlCount = globalThis[_sqlCache].load(this._matchSqlid(`${option.sqlId}_count`), { ctx: option.context, isCount: true, isSum: false, ...option.params });
+            } else {
+                sqlCount = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: option.context, isCount: true, isSum: false, ...option.params });
+            }
+        }
+        if (option.sync === SyncMode.Sync) {
+            if (sqlCount) {
+                result.total = this.select<number>({
+                    ...option,
+                    sql: sqlCount,
+                    sync: SyncMode.Sync,
+                    selectResult: SelectResult.R_C_Assert
+                });
+                result.size = calc(result.total)
+                    .add(option.pageSize - 1)
+                    .div(option.pageSize)
+                    .round(0, 2)
+                    .over();
+            }
+            if (sqlSum) {
+                result.sum = this.select<Record<string, number>>({
+                    ...option,
+                    sql: sqlSum,
+                    sync: SyncMode.Sync,
+                    selectResult: SelectResult.R_CS_Assert
+                });
+            }
+            if (sql) {
+                result.records = this.select<L>({
+                    ...option,
+                    sql,
+                    sync: SyncMode.Sync,
+                    selectResult: SelectResult.RS_CS
+                });
+            }
+            return result;
+        } else {
+            return new Promise<PageQuery<L>>(async (resolve, reject) => {
+                try {
+                    if (sqlCount) {
+                        result.total = await this.select<number>({
+                            ...option,
+                            sql: sqlCount,
+                            sync: SyncMode.Async,
+                            selectResult: SelectResult.R_C_Assert
+                        });
+                        result.size = calc(result.total)
+                            .add(option.pageSize - 1)
+                            .div(option.pageSize)
+                            .round(0, 2)
+                            .over();
+                    }
+                    if (sqlSum) {
+                        result.sum = await this.select<Record<string, number>>({
+                            ...option,
+                            sql: sqlSum,
+                            sync: SyncMode.Async,
+                            selectResult: SelectResult.R_CS_Assert
+                        });
+                    }
+                    if (sql) {
+                        result.records = await this.select<L>({
+                            ...option,
+                            sql,
+                            sync: SyncMode.Async,
+                            selectResult: SelectResult.RS_CS
+                        });
+                    }
+                    resolve(result);
+                } catch (error) {
+                    reject(error);
+                }
+            });
+        }
     }
 
     /**
@@ -2937,11 +3536,11 @@ export class SqlService<T extends object> {
     4. 自定义字段名称：字符串数组
     ** `index` 表的索引，设置方式同ID
      */
-    private _createTable({ tableName, temp = true, columns, data, id = 'auto', index = 'auto' }: {
+    private _createTable<L = T>({ tableName, temp = true, columns, data, id = 'auto', index = 'auto' }: {
         tableName?: string;
         temp?: boolean,
         columns?: string[];
-        data?: Array<Partial<T>>;
+        data?: Array<Partial<L>>;
         id?: 'auto' | 'all' | 'none' | string[];
         index?: 'auto' | 'all' | 'none' | string[];
     } = {}): { sql: string; params?: any[] }[] {
@@ -2970,66 +3569,73 @@ export class SqlService<T extends object> {
         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;`;
+                let sql = format(`CREATE ${temp === true ? 'TEMPORARY' : ''} TABLE IF NOT EXISTS ${tableName}(
+                    ${columns.map(K => this[_fields]![K]![DBType.Mysql]()).join(',')}
+                    ${ids && ids.length ? `,PRIMARY KEY (${ids.map(i => this[_fields]![i]?.C2()).join(',')})  USING BTREE ` : ''}
+                    ${indexs && indexs.length ? `,${indexs.map(i => `KEY ${this[_fields]![i]?.C2()} (${this[_fields]![i]?.C2()})`).join(',')} ` : ''}
+                ) ENGINE=MEMORY;`);
                 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(',')})
+                    sql = format(`INSERT INTO ${tableName} (${columns.map(c => this[_fields]![c]?.C2()).join(',')})
                     ${(data).map(d => {
                         const r = `SELECT ${Object.entries(d).map(([K, V]) => {
                             params.push(V);
-                            return `? ${first ? this[_fields]![K]?.esName : ''}`;
+                            return `? ${first ? this[_fields]![K]?.C2() : ''}`;
                         }).join(',')}`;
                         first = false;
                         return r;
-                    }).join(' UNION ALL ')}`;
+                    }).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(',')}) ` : ''}
-                );`;
+                let sql = format(`CREATE ${temp === true ? 'TEMPORARY' : ''} TABLE IF NOT EXISTS ${tableName}(
+                    ${columns.map(K => this[_fields]![K]![DBType.Sqlite]()).join(',')}
+                    ${ids && ids.length ? `,PRIMARY KEY (${ids.map(i => this[_fields]![i]?.C2()).join(',')}) ` : ''}
+                );`);
                 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});`;
+                        sql = format(`CREATE INDEX ${Sqlstring.escapeId(`${index}_${Math.random()}`.replace(/\./, ''))} ON ${tableName} (${this[_fields]![index]?.C2()});`);
                         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(',')})
+                    sql = format(`INSERT INTO ${tableName} (${columns.map(c => this[_fields]![c]?.C2()).join(',')})
                     ${(data).map(d => {
                         const r = `SELECT ${Object.entries(d).map(([K, V]) => {
                             params.push(V);
-                            return `? ${first ? this[_fields]![K]?.esName : ''}`;
+                            return `? ${first ? this[_fields]![K]?.C2() : ''}`;
                         }).join(',')}`;
                         first = false;
                         return r;
-                    }).join(' UNION ALL ')}`;
+                    }).join(' UNION ALL ')}`);
                     sqls.push({ sql, params });
                 }
+                break;
             }
         }
         return sqls;
     }
 
+    private _matchSqlid(sqlid?: string) {
+        sqlid ??= '';
+        if (sqlid.includes('.')) return [sqlid];
+        else return [`${this[_tableName]}.${sqlid}`, `${this[_className]}.${sqlid}`, `${this[_ClassName]}.${sqlid}`, `${this[_vueName]}.${sqlid}`];
+    }
+
 }
 /** 是否进行下一个动作 */
 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>) {
+        descriptor.value = function (this: StreamQuery<T>) {
             if (this.if_proceed === true) {
                 // eslint-disable-next-line prefer-rest-params
                 const args = Array.from(arguments);
@@ -3056,21 +3662,42 @@ const IF_EXEC = function <T extends object>(def: any) {
         };
     };
 };
-class StreamCondition<T extends object> {
-    protected _prefix = 0;
-    protected _index = 0;
+class StreamQuery<T extends object> {
+    private _prefix = 0;
+    private _index = 0;
 
-    protected _wheres: string[] = [];
+    private _wheres: string[] = [];
 
-    protected _andQuerys: StreamCondition<T>[] = [];
-    protected _orQuerys: StreamCondition<T>[] = [];
+    private _andQuerys: StreamQuery<T>[] = [];
+    private _orQuerys: StreamQuery<T>[] = [];
 
-    protected _paramKeys: Record<string, string[] | Record<string, string> | string> = {};
-    protected _param: Record<string, any> = {};
+    private _paramKeys: Record<string, string[] | Record<string, string> | string> = {};
+    private _param: Record<string, any> = {};
     public if_proceed = true;
     public if_exec = true;
-    constructor() {
+    private _table: string;
+
+    private _distinct = false;
+    private _columns: string[] = [];
+
+    private _updates?: Partial<T>;
+    private _updateColumns: string[] = [];
+
+    private _groups: string[] = [];
+    private _orders: string[] = [];
+
+    private _startRow = 0;
+    private _pageSize = 0;
+
+    private _service: SqlService<T>;
+    private [_fields]: Record<string, AField>;
+    private [_columns]: string[];
+    constructor(table: string, service: SqlService<T>, __fields: Record<string, AField>, __columns: string[]) {
         this._prefix = parseInt(`${Math.random() * 1000}`);
+        this._table = table;
+        this._service = service;
+        this[_fields] = __fields;
+        this[_columns] = __columns;
     }
     /** 将当前stream重置 */
     reset() {
@@ -3078,8 +3705,15 @@ class StreamCondition<T extends object> {
         this._wheres.length = 0;
         this._param = {};
         this._paramKeys = {};
+        this._pageSize = 0;
+        this._startRow = 0;
+        this._orders.length = 0;
+        this._groups.length = 0;
+        this._columns.length = 0;
+        this._updateColumns.length = 0;
         return this;
     }
+    // #region 条件
     /** 为下次链条执行提供条件判断：非异步方法跳过，异步方法不执行并返回默认值 */
     @IF_PROCEED<T>()
     if(condition: boolean) {
@@ -3087,148 +3721,418 @@ class StreamCondition<T extends object> {
         return this;
     }
     @IF_PROCEED<T>()
-    eq(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._(key, value, '=', { name }); }
+    eq(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._(key, value, '=', { paramName, skipEmptyString, breakExcuteIfSkip }); }
     @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;
+    eqT(t: Partial<T>, { name: paramName = '', breakExcuteIfSkip = false } = {}) {
+        let exe = false;
+        if (t) {
+            t = this._service[_transformer]!(t, {
+                skipNull: true,
+                skipUndefined: true,
+                skipEmptyString: true
+            });
+            const keys = Object.keys(t);
+            if (keys.length > 0) {
+                if (paramName && this._paramKeys[paramName]) {
+                    for (const [key, pname] of Object.entries(this._paramKeys[paramName] 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 ${this[_fields]![String(key)]?.C2()} = :${pkey} `);
+                        this._param[pkey] = value;
+                        if (paramName) {
+                            paramKeys[key] = pkey;
+                        }
+                    }
+                    if (paramName) {
+                        this._paramKeys[paramName] = paramKeys;
+                    }
                 }
+                exe = true;
             }
-            if (name) {
-                this._paramKeys[name] = paramKeys;
-            }
+        }
+        if (breakExcuteIfSkip === true && exe === false) {
+            this.if_exec = false;
         }
         return this;
     }
     @IF_PROCEED<T>()
-    notEq(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._(key, value, '<>', { name }); }
+    notEq(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._(key, value, '<>', { paramName, skipEmptyString, breakExcuteIfSkip }); }
     @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 }); }
+    regexp(key: keyof T, regexp: string, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
     @IF_PROCEED<T>()
-    notRegexp(key: keyof T, regexp: string, { name }: { name?: string } = {}) { return this._(key, regexp, 'REGEXP', { name, not: 'NOT' }); }
+    notRegexp(key: keyof T, regexp: string, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, not: 'NOT', breakExcuteIfSkip }); }
     /** (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 }); }
+    shiftEq(key1: keyof T, key2: keyof T, value: number, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._shift(key1, key2, value, '=', { paramName, breakExcuteIfSkip }); }
     /** (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 }); }
+    shiftNotEq(key1: keyof T, key2: keyof T, value: number, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._shift(key1, key2, value, '<>', { paramName, breakExcuteIfSkip }); }
     @IF_PROCEED<T>()
-    grate(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._(key, value, '>', { name }); }
+    grate(key: keyof T, value: string | number, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '>', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
     @IF_PROCEED<T>()
-    grateEq(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._(key, value, '>=', { name }); }
+    grateEq(key: keyof T, value: string | number, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '>=', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
     @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 }); }
+    less(key: keyof T, value: string | number, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '<', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
     @IF_PROCEED<T>()
-    lessEq(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._(key, value, '<=', { name }); }
+    lessEq(key: keyof T, value: string | number, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '<=', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
     @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 }); }
+    like(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfSkip }); }
     @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 }); }
+    notLike(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfSkip }); }
     @IF_PROCEED<T>()
-    leftLike(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, left: '%', force }); }
+    leftLike(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfSkip }); }
     @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 }); }
+    notLeftLike(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfSkip }); }
     @IF_PROCEED<T>()
-    rightLike(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, right: '%', force }); }
+    rightLike(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfSkip }); }
     @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 }); }
+    notRightLike(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfSkip }); }
     @IF_PROCEED<T>()
-    PreciseLike(key: keyof T, value: string | number, { name, force }: { name?: string; force?: boolean; } = {}) { return this._like(key, value, { name, force }); }
+    PreciseLike(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfSkip }); }
     @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 }); }
+    notPreciseLike(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
     @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' }); }
+    glob(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfSkip, 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' }); }
+    notGlob(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfSkip, 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' }); }
+    leftGlob(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfSkip, 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' }); }
+    notLeftGlob(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfSkip, 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' }); }
+    rightGlob(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfSkip, 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' }); }
+    notRightGlob(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfSkip, 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' }); }
+    PreciseGlob(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfSkip, 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' }); }
+    notPreciseGlob(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip, 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 }); }
+    in(key: keyof T, value: Array<string | number>, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._in(key, value, { paramName, breakExcuteIfSkip }); }
     @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 }); }
+    notIn(key: keyof T, value: Array<string | number>, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._in(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
     @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 }); }
+    between(key: keyof T, value1: string | number, value2: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._between(key, value1, value2, { paramName, skipEmptyString, breakExcuteIfSkip }); }
     @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' }); }
+    notBetween(key: keyof T, value1: string | number, value2: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._between(key, value1, value2, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
     @IF_PROCEED<T>()
-    pow(key: keyof T, value: number, { name }: { name?: string } = {}) { return this._pow(key, value, { name }); }
+    pow(key: keyof T, value: number, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, value, { paramName, breakExcuteIfSkip }); }
     @IF_PROCEED<T>()
-    notPow(key: keyof T, value: number, { name }: { name?: string } = {}) { return this._pow(key, value, { name, not: 'NOT' }); }
+    notPow(key: keyof T, value: number, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, value, { paramName, not: 'NOT', breakExcuteIfSkip }); }
     @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 }); }
+    powWith(key: keyof T, values: Array<number | string>, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, breakExcuteIfSkip }); }
     @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' }); }
+    notPowWith(key: keyof T, values: Array<number | string>, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, not: 'NOT', breakExcuteIfSkip }); }
     /** MATCH(key1, key2, key3) AGAINST (value) */
     @IF_PROCEED<T>()
-    match(value: string, keys: (keyof T)[], { name }: { name?: string } = {}) { return this._match(value, keys, { name }); }
+    match(value: string, keys: (keyof T)[], { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip }); }
     /** 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' }); }
+    notMatch(value: string, keys: (keyof T)[], { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
     /** 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' }); }
+    matchBoolean(value: string, keys: (keyof T)[], { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, append: 'IN BOOLEAN MODE' }); }
     /** NOT MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE */
     @IF_PROCEED<T>()
-    notMatchBoolean(value: string, keys: (keyof T)[], { name }: { name?: string } = {}) { return this._match(value, keys, { name, not: 'NOT', append: 'IN BOOLEAN MODE' }); }
+    notMatchBoolean(value: string, keys: (keyof T)[], { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, not: 'NOT', append: 'IN BOOLEAN MODE' }); }
     /** MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
     @IF_PROCEED<T>()
-    matchQuery(value: string, keys: (keyof T)[], { name }: { name?: string } = {}) { return this._match(value, keys, { name, append: 'WITH QUERY EXPANSION' }); }
+    matchQuery(value: string, keys: (keyof T)[], { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, append: 'WITH QUERY EXPANSION' }); }
     /** NOT MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
     @IF_PROCEED<T>()
-    notMatchQuery(value: string, keys: (keyof T)[], { name }: { name?: string } = {}) { return this._match(value, keys, { name, not: 'NOT', append: 'WITH QUERY EXPANSION' }); }
+    notMatchQuery(value: string, keys: (keyof T)[], { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, 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 }); }
+    includes(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._includes(key, value, { paramName, skipEmptyString, breakExcuteIfSkip }); }
     @IF_PROCEED<T>()
-    notIncludes(key: keyof T, value: string | number, { name }: { name?: string } = {}) { return this._includes(key, value, { name, not: 'NOT' }); }
+    notIncludes(key: keyof T, value: string | number, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._includes(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
     @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; }
+    and(fn: StreamQuery<T> | ((stream: StreamQuery<T>) => boolean | void)) {
+        if (fn instanceof StreamQuery) {
+            this._andQuerys.push(fn);
+        } else {
+            const stream = new StreamQuery<T>(this._table, this._service, this[_fields], this[_columns]);
+            const ret = fn(stream);
+            if (ret !== false) { this._andQuerys.push(stream); }
+        }
+        return this;
+    }
+    @IF_PROCEED<T>()
+    or(fn: StreamQuery<T> | ((stream: StreamQuery<T>) => boolean | void)) {
+        if (fn instanceof StreamQuery) {
+            this._andQuerys.push(fn);
+        } else {
+            const stream = new StreamQuery<T>(this._table, this._service, this[_fields], this[_columns]!);
+            const ret = fn(stream);
+            if (ret !== false) { this._orQuerys.push(stream); }
+        }
+        return this;
+    }
+
+    @IF_PROCEED<T>()
+    groupBy(...keys: (keyof T)[]) { this._groups.push(...keys.map(key => `${this[_fields]![String(key)]?.C2()}`)); return this; }
+    @IF_PROCEED<T>()
+    groupBy2(...keys: string[]) { this._groups.push(...keys); return this; }
+    @IF_PROCEED<T>()
+    asc(...keys: (keyof T)[]) { this._orders.push(...keys.map(key => `${this[_fields]![String(key)]?.C2()} ASC`)); return this; }
+    @IF_PROCEED<T>()
+    asc2(...keys: string[]) { this._orders.push(...keys.map(key => `${key} ASC`)); return this; }
+    @IF_PROCEED<T>()
+    desc(...keys: (keyof T)[]) { this._orders.push(...keys.map(key => `${this[_fields]![String(key)]?.C2()} DESC`)); return this; }
+    @IF_PROCEED<T>()
+    desc2(...keys: string[]) { this._orders.push(...keys.map(key => `${key} ASC`)); return this; }
+    @IF_PROCEED<T>()
+    limit(startRow: number, pageSize: number) { this._startRow = startRow; this._pageSize = pageSize; 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() {
+    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>()
+    countDistinct(key: keyof T, countName?: string,) { this._columns.push(`COUNT(DISTINCT ${this[_fields]![String(key)]?.C2()}) ${countName || `${this[_fields]![String(key)]?.C2()}`}`); return this; }
+    @IF_PROCEED<T>()
+    count(countName?: string) { this._columns.push(`COUNT(1) ${countName ?? 'ct'}`); return this; }
+    @IF_PROCEED<T>()
+    sum(key: keyof T, legName?: string, distinct?: boolean) { this._columns.push(`SUM(${distinct ? 'DISTINCT' : ''} ${this[_fields]![String(key)]?.C2()}) ${legName || `${this[_fields]![String(key)]?.C2()}`}`); return this; }
+    @IF_PROCEED<T>()
+    avg(key: keyof T, legName?: string, distinct?: boolean) { this._columns.push(`AVG(${distinct ? 'DISTINCT' : ''} ${this[_fields]![String(key)]?.C2()}) ${legName || `${this[_fields]![String(key)]?.C2()}`}`); return this; }
+    @IF_PROCEED<T>()
+    max(key: keyof T, legName?: string, distinct?: boolean) { this._columns.push(`MAX(${distinct ? 'DISTINCT' : ''} ${this[_fields]![String(key)]?.C2()}) ${legName || `${this[_fields]![String(key)]?.C2()}`}`); return this; }
+    @IF_PROCEED<T>()
+    min(key: keyof T, legName?: string, distinct?: boolean) { this._columns.push(`MIN(${distinct ? 'DISTINCT' : ''} ${this[_fields]![String(key)]?.C2()}) ${legName || `${this[_fields]![String(key)]?.C2()}`}`); 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' : ''} ${this[_fields]![String(key)]?.C2()}
+            ${param && param.asc && param.asc.length > 0 ? `ORDER BY ${param.asc.map(i => `${this[_fields]![String(i)]?.C2()} ASC`)} ` : ''}
+            ${param && param.desc && param.desc.length > 0 ? `${param && param.asc && param.asc.length > 0 ? '' : 'ORDER BY'} ${param.desc.map(i => `${this[_fields]![String(i)]?.C2()} DESC`)} ` : ''}
+            SEPARATOR '${param && param.separator || ','}'
+            ) ${param && param.groupName || `${this[_fields]![String(key)]?.C2()}`}`);
+        return this;
+    }
+    @IF_PROCEED<T>()
+    select(...key: (keyof T)[]) { this._columns.push(...(key.map(k => this[_fields]![String(k)]!.C3()))); return this; }
+    @IF_PROCEED<T>()
+    select2(sql: string, param?: Record<string, any>) { this._columns.push(`${sql}`); Object.assign(this._param, param); return this; }
+    @IF_PROCEED<T>()
+    update(key: keyof T, value: T[keyof T]) { this._updates ??= {}; this._updates[key] = value; return this; }
+    @IF_PROCEED<T>()
+    update2(sql: string, param?: Record<string, any>) { this._updateColumns.push(sql); Object.assign(this._param, param); 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(` ${this[_fields]![String(key)]?.C2()} = REPLACE(${this[_fields]![String(key)]?.C2()}, :${pkey1}, :${pkey2}) `);
+        this._param[pkey1] = valueToFind as any;
+        this._param[pkey2] = valueToReplace as any;
+        return this;
+    }
+    // #endregion
+
+    excuteSelect<L = T>(option?: MethodOption & { sync?: SyncMode.Async; selectResult?: SelectResult.RS_CS | SelectResult.RS_C; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): Promise<L[]>;
+    excuteSelect<L = T>(option?: MethodOption & { sync?: SyncMode.Async; selectResult?: SelectResult.RS_CS_List | SelectResult.RS_C_List; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): Promise<ArrayList<L>>;
+    excuteSelect<L = T>(option: MethodOption & { sync?: SyncMode.Async; selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert; errorMsg?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): Promise<L>;
+    excuteSelect<L = T>(option: MethodOption & { sync?: SyncMode.Async; selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): Promise<L | null>;
+    excuteSelect<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult: SelectResult.RS_CS | SelectResult.RS_C; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): L[];
+    excuteSelect<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult: SelectResult.RS_CS_List | SelectResult.RS_C_List; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): ArrayList<L>;
+    excuteSelect<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert; errorMsg?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): L;
+    excuteSelect<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): L | null;
+    @IF_EXEC<T>(null)
+    excuteSelect<L = T>(option?: MethodOption & { sync?: SyncMode; selectResult?: SelectResult; errorMsg?: string; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): null | L | L[] | ArrayList<L> | Promise<null | L | L[] | ArrayList<L>> {
+        option ??= {};
+        option.sync ??= SyncMode.Async;
+        option.selectResult ??= SelectResult.RS_CS;
+        const { where, params } = this._where();
+        let sql = `
+            SELECT
+            ${this._distinct ? 'DISTINCT' : ''} ${this._columns && this._columns.length > 0 ? this._columns.join(',') : this[_columns].map(key => this[_fields]![String(key)]?.C3()).join(',')}
+            FROM ${this._table}
+            ${where ? ' WHERE ' : ''}
+            ${where}
+            ${this._groups.length > 0 ? `GROUP BY ${this._groups.join(',')} ` : ''}
+            ${this._orders.length > 0 ? `ORDER BY ${this._orders.join(',')} ` : ''}
+        `;
+        if (this._startRow && this._pageSize) {
+            sql += `LIMIT ${this._startRow}, ${this._pageSize}`;
+        } else if (this._startRow) {
+            sql += `LIMIT ${this._startRow}`;
+        }
+        if (option.sync === SyncMode.Async) {
+            switch (option.selectResult) {
+                case SelectResult.RS_CS: return this._service.select<L>({ ...option, sync: SyncMode.Async, selectResult: SelectResult.RS_CS, sql, params });
+                case SelectResult.RS_C: return this._service.select<L>({ ...option, sync: SyncMode.Async, selectResult: SelectResult.RS_C, sql, params });
+                case SelectResult.RS_CS_List: return this._service.select<L>({ ...option, sync: SyncMode.Async, selectResult: SelectResult.RS_CS_List, sql, params });
+                case SelectResult.RS_C_List: return this._service.select<L>({ ...option, sync: SyncMode.Async, selectResult: SelectResult.RS_C_List, sql, params });
+                case SelectResult.R_CS_Assert: return this._service.select<L>({ ...option, sync: SyncMode.Async, selectResult: SelectResult.R_CS_Assert, sql, params });
+                case SelectResult.R_C_Assert: return this._service.select<L>({ ...option, sync: SyncMode.Async, selectResult: SelectResult.R_C_Assert, sql, params });
+                case SelectResult.R_CS_NotSure: return this._service.select<L>({ ...option, sync: SyncMode.Async, selectResult: SelectResult.R_CS_NotSure, sql, params });
+                case SelectResult.R_C_NotSure: return this._service.select<L>({ ...option, sync: SyncMode.Async, selectResult: SelectResult.R_C_NotSure, sql, params });
+            }
+        } else {
+            switch (option.selectResult) {
+                case SelectResult.RS_CS: return this._service.select<L>({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.RS_CS, sql, params });
+                case SelectResult.RS_C: return this._service.select<L>({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.RS_C, sql, params });
+                case SelectResult.RS_CS_List: return this._service.select<L>({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.RS_CS_List, sql, params });
+                case SelectResult.RS_C_List: return this._service.select<L>({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.RS_C_List, sql, params });
+                case SelectResult.R_CS_Assert: return this._service.select<L>({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.R_CS_Assert, sql, params });
+                case SelectResult.R_C_Assert: return this._service.select<L>({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.R_C_Assert, sql, params });
+                case SelectResult.R_CS_NotSure: return this._service.select<L>({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.R_CS_NotSure, sql, params });
+                case SelectResult.R_C_NotSure: return this._service.select<L>({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.R_C_NotSure, sql, params });
+            }
+        }
+    }
+    @IF_EXEC<T>(null)
+    excutePage<L = T>(option?: MethodOption & { sync?: SyncMode; hump?: boolean; mapper?: string | SqlMapper; mapperIfUndefined?: MapperIfUndefined; }): PageQuery<L> | Promise<PageQuery<L>> {
+        option ??= {};
+        option.sync ??= SyncMode.Async;
+        const { where, params } = this._where();
+        const result: PageQuery<L> = {
+            records: [],
+            size: 0,
+            total: 0
+        };
+        let sql = `
+            SELECT
+            ${this._distinct ? 'DISTINCT' : ''} ${this._columns && this._columns.length > 0 ? this._columns.join(',') : this[_columns].map(key => this[_fields]![String(key)]?.C3()).join(',')}
+            FROM ${this._table}
+            ${where ? ' WHERE ' : ''}
+            ${where}
+            ${this._groups.length > 0 ? `GROUP BY ${this._groups.join(',')} ` : ''}
+            ${this._orders.length > 0 ? `ORDER BY ${this._orders.join(',')} ` : ''}
+        `;
+        if (this._startRow && this._pageSize) {
+            sql += `LIMIT ${this._startRow}, ${this._pageSize}`;
+        } else if (this._startRow) {
+            sql += `LIMIT ${this._startRow}`;
+        }
+        const sqlCount = `
+            SELECT COUNT(1)
+            FROM ${this._table}
+            ${where ? ' WHERE ' : ''}
+            ${where}
+            ${this._groups.length > 0 ? `GROUP BY ${this._groups.join(',')} ` : ''}
+            ${this._orders.length > 0 ? `ORDER BY ${this._orders.join(',')} ` : ''}
+        `;
+        if (option.sync === SyncMode.Sync) {
+            result.total = this._service.select<number>({
+                ...option,
+                params,
+                sql: sqlCount,
+                sync: SyncMode.Sync,
+                selectResult: SelectResult.R_C_Assert
+            });
+            result.size = calc(result.total)
+                .add(this._pageSize - 1)
+                .div(this._pageSize)
+                .round(0, 2)
+                .over();
+            result.records = this._service.select<L>({
+                ...option,
+                params,
+                sql,
+                sync: SyncMode.Sync,
+                selectResult: SelectResult.RS_CS
+            });
+            return result;
+        } else {
+            return new Promise<PageQuery<L>>(async (resolve, reject) => {
+                try {
+                    result.total = await this._service.select<number>({
+                        ...option,
+                        params,
+                        sql: sqlCount,
+                        sync: SyncMode.Async,
+                        selectResult: SelectResult.R_C_Assert
+                    });
+                    result.size = calc(result.total)
+                        .add(this._pageSize - 1)
+                        .div(this._pageSize)
+                        .round(0, 2)
+                        .over();
+                    result.records = await this._service.select<L>({
+                        ...option,
+                        params,
+                        sql,
+                        sync: SyncMode.Async,
+                        selectResult: SelectResult.RS_CS
+                    });
+                    resolve(result);
+                } catch (error) {
+                    reject(error);
+                }
+            });
+        }
+    }
+    excuteUpdate(option?: MethodOption & { sync?: SyncMode.Async }): Promise<number>;
+    excuteUpdate(option: MethodOption & { sync: SyncMode.Sync }): number;
+    @IF_EXEC<T>(0)
+    excuteUpdate(option?: MethodOption & { sync?: SyncMode }): number | Promise<number> {
+        option ??= {};
+        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;
+        }
+    }
+    excuteDelete(option?: MethodOption & { sync?: SyncMode.Async }): Promise<number>;
+    excuteDelete(option: MethodOption & { sync: SyncMode.Sync }): number;
+    @IF_EXEC<T>(0)
+    excuteDelete(option?: MethodOption & { sync?: SyncMode }): number | Promise<number> {
+        option ??= {};
+        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 });
+        }
+    }
+    private _where() {
         const wheres = new Array<string>();
         const sql = this._wheres.join(' ');
         if (sql) {
-            wheres.push(`(${sql})`);
+            wheres.push(`(${sql.replace(/^and|^or/i, '')})`);
         }
         if (this._orQuerys.length > 0) {
             for (const query of this._orQuerys) {
-                const { where, params } = query.where();
+                const { where, params } = query._where();
                 if (where) {
                     wheres.push(` OR (${where}) `);
                 }
@@ -3237,7 +4141,7 @@ class StreamCondition<T extends object> {
         }
         if (this._andQuerys.length > 0) {
             for (const query of this._andQuerys) {
-                const { where, params } = query.where();
+                const { where, params } = query._where();
                 if (where) {
                     wheres.push(` AND (${where}) `);
                 }
@@ -3246,288 +4150,198 @@ class StreamCondition<T extends object> {
         }
         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;
+    private _(key: keyof T, value: any, op: string, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (
+            value === null
+            || value === undefined
+            || (emptyString(`${value ?? ''}`) && skipEmptyString === true)
+        ) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName] as string] = value;
         } else {
+            paramName
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND ${String(key)} ${not} ${op} :${pkey} `);
+            this._wheres.push(`AND ${this[_fields]![String(key)]?.C2()} ${not} ${op} :${pkey} `);
             this._param[pkey] = value;
-            if (name) {
-                this._paramKeys[name] = pkey;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
             }
         }
         return this;
     }
     private _null(key: keyof T, not = ''): this {
-        this._wheres.push(`AND ${String(key)} is ${not} null`);
+        this._wheres.push(`AND ${this[_fields]![String(key)]?.C2()} 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)} `);
+        this._wheres.push(`AND ${this[_fields]![String(key1)]?.C2()} ${not} ${op} ${this[_fields]![String(key2)]?.C2()} `);
         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;
+    private _between(key: keyof T, value1: string | number, value2: string | number, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (
+            value1 === null
+            || value1 === undefined
+            || (emptyString(`${value1 ?? ''}`) && skipEmptyString === true)
+            || value2 === null
+            || value2 === undefined
+            || (emptyString(`${value2 ?? ''}`) && skipEmptyString === true)
+        ) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName && this._paramKeys[paramName]) {
+            this._param[this._paramKeys[paramName]![0]] = value1;
+            this._param[this._paramKeys[paramName]![1]] = value2;
         } else {
             const [pkey1, pkey2] = [`p${this._prefix}${this._index++}`, `p${this._prefix}${this._index++}`];
-            this._wheres.push(`AND ${String(key)} ${not} BETWEEN :${pkey1} AND :${pkey2}`);
+            this._wheres.push(`AND ${this[_fields]![String(key)]?.C2()} ${not} BETWEEN :${pkey1} AND :${pkey2}`);
             this._param[pkey1] = value1;
             this._param[pkey2] = value2;
-            if (name) {
-                this._paramKeys[name] = [pkey1, pkey2];
+            if (paramName) {
+                this._paramKeys[paramName] = [pkey1, pkey2];
             }
         }
         return this;
     }
-    private _in(key: keyof T, value: any, { not = '', name = '', force = false } = {}) {
+    private _in(key: keyof T, value: any, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
         if (value && value.length > 0) {
-            if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
-                this._param[this._paramKeys[name] as string] = value;
+            if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+                this._param[this._paramKeys[paramName] as string] = value;
             } else {
                 const pkey = `p${this._prefix}${this._index++}`;
-                this._wheres.push(`AND ${String(key)} ${not} IN (:${pkey}) `);
+                this._wheres.push(`AND ${this[_fields]![String(key)]?.C2()} ${not} IN (:${pkey}) `);
                 this._param[pkey] = value;
-                if (name) {
-                    this._paramKeys[name] = pkey;
+                if (paramName) {
+                    this._paramKeys[paramName] = pkey;
                 }
             }
-        } else if (force !== true) {
+        } else if (breakExcuteIfSkip !== 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;
+    private _shift(key1: keyof T, key2: keyof T, value: number, op: string, { not = '', paramName = '', breakExcuteIfSkip = false } = {}) {
+        if (
+            value === null
+            || value === undefined
+            || emptyString(`${value ?? ''}`)
+        ) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
             }
+            return this;
         }
-        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;
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName] as string] = value;
         } else {
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND MATCH(${keys.join(',')}) AGAINST (:${pkey} ${append ?? ''})`);
+            this._wheres.push(`AND (${this[_fields]![String(key1)]?.C2()} << 8) + ${this[_fields]![String(key2)]?.C2()} ${not} ${op} :${pkey} `);
             this._param[pkey] = value;
-            if (name) {
-                this._paramKeys[name] = pkey;
+            if (paramName) {
+                this._paramKeys[paramName] = 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;
+    private _match(value: string, keys: (keyof T)[], { paramName = '', not = '', append = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (
+            value === null
+            || value === undefined
+            || emptyString(`${value ?? ''}`)
+        ) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName] as string] = value;
         } else {
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND NOT POW(2, ${String(key)}) & :${pkey}`);
+            this._wheres.push(`AND ${not} MATCH(${keys.map(key => this[_fields]![String(key)]?.C2()).join(',')}) AGAINST (:${pkey} ${append ?? ''})`);
             this._param[pkey] = value;
-            if (name) {
-                this._paramKeys[name] = pkey;
+            if (paramName) {
+                this._paramKeys[paramName] = 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;
-                }
+    private _pow(key: keyof T, value: number, { not = '', paramName = '', breakExcuteIfSkip = false } = {}) {
+        if (
+            value === null
+            || value === undefined
+            || emptyString(`${value ?? ''}`)
+        ) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
             }
-        } else if (force !== true) {
-            this.if_exec = false;
+            return this;
         }
-        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;
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName] as string] = value;
         } else {
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND LOCATE(${String(key)}, :${pkey}) ${not ? '=' : ''}  0`);
+            this._wheres.push(`AND ${not} POW(2, ${this[_fields]![String(key)]?.C2()}) & :${pkey}`);
             this._param[pkey] = value;
-            if (name) {
-                this._paramKeys[name] = pkey;
+            if (paramName) {
+                this._paramKeys[paramName] = 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 });
+    private _like(key: keyof T, value: any, { not = '', left = '', right = '', paramName = '', op = 'LIKE', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (
+            value === null
+            || value === undefined
+            || (emptyString(`${value ?? ''}`) && skipEmptyString === true)
+        ) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
             }
+            return this;
+        }
+
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName] as string] = value;
         } 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 });
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND ${this[_fields]![String(key)]?.C2()} ${not} ${op} CONCAT('${left}', :${pkey}, '${right}') `);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
             }
         }
+        return this;
     }
-    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;
+    private _includes(key: keyof T, value: any, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = true } = {}) {
+        if (
+            value === null
+            || value === undefined
+            || (emptyString(`${value ?? ''}`) && skipEmptyString === true)
+        ) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
             }
+            return this;
         }
-        if (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 });
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName] as string] = value;
         } else {
-            return this._service.excute({ sync: SyncMode.Sync, sql, params });
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND LOCATE(${this[_fields]![String(key)]?.C2()}, :${pkey}) ${not ? '=' : '>'}  0`);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
+            }
         }
+        return this;
     }
 }
 /**
@@ -3535,11 +4349,15 @@ class StreamQuery<T extends object> extends StreamBuild<T>{
  # [查看库的API](https://github.com/redis/ioredis?tab=readme-ov-file)
  # [REDIS API](http://doc.redisfans.com/)
  REDIS 的API 可以直接用，将方法名转为小写
+ ```
+ // 设置<Redis>来获得代码提示
+ getRedisDB<Redis>('').exists(?)
+ ```
  */
-export function getRedisDB(db?: string) {
+export function getRedisDB<T = any>(db?: string): T {
     const rd = globalThis[_dao][DBType.Redis][db ?? _primaryDB];
     Throw.if(!rd, 'not found redis!');
-    return rd;
+    return rd as T;
 }
 /**
  redlock
@@ -3776,13 +4594,12 @@ export function MethodCache<T = any>(config: {
         };
     };
 }
-
 class MUParser {
     static END = 1;
     private modelName: string;
     private linNumber = 0;
-    private lastLine?: string;
-    private lastlastLine?: string;
+    private lastLine: string = '';
+    private lastlastLine: string = '';
     private status = 0;
     private lineSeparator = '\n';
     private files: string[];
@@ -3792,8 +4609,8 @@ class MUParser {
         this.skipHeader();
     }
     next(): [string, string] | null {
-        let sqlId: string | undefined = this.readSqlId();
-        if (this.status === MUParser.END || !sqlId) {
+        let sqlId: string = this.readSqlId();
+        if (this.status === MUParser.END) {
             return null;
         }
         // 去掉可能的尾部空格
@@ -3807,14 +4624,17 @@ class MUParser {
     }
     private skipHeader(): void {
         while (true) {
-            const line: string | undefined = this.nextLine();
-            if (!line) { return; }
-            if (this.status === MUParser.END) { return; }
-            if (line.startsWith('===')) { return; }
+            const line: string = this.nextLine();
+            if (this.status === MUParser.END) {
+                return;
+            }
+            if (line.startsWith('===')) {
+                return;
+            }
         }
     }
-    private nextLine(): string | undefined {
-        const line: string | undefined = this.files[this.linNumber];
+    private nextLine(): string {
+        const line: string = this.files[this.linNumber]!;
         this.linNumber++;
         if (line === undefined) {
             this.status = MUParser.END;
@@ -3824,14 +4644,14 @@ class MUParser {
         this.lastLine = line;
         return line;
     }
-    private readSqlId(): string | undefined {
+    private readSqlId(): string {
         return this.lastlastLine;
     }
     private skipComment(): void {
         let findComment = false;
         while (true) {
-            let line: string | undefined = this.nextLine();
-            if (this.status === MUParser.END || !line) {
+            let line: string = this.nextLine();
+            if (this.status === MUParser.END) {
                 return;
             }
             line = line.trim();
@@ -3857,26 +4677,20 @@ class MUParser {
     }
     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 '';
-                }
+        list.push(this.lastLine);
+        while (true) {
+            const line: string = this.nextLine();
+
+            if (this.status === MUParser.END) {
+                return this.getBuildSql(list);
             }
-        } else {
-            return '';
+
+            if (line.startsWith('===')) {
+                // 删除下一个sqlId表示
+                list.pop();
+                return this.getBuildSql(list);
+            }
+            list.push(line);
         }
     }
     private getBuildSql(list: string[]): string {
@@ -3892,130 +4706,3 @@ class MUParser {
         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;
-    }
-}