baja-lite 1.0.5 → 1.0.7

package/src/sql.ts

@@ -11,6 +11,8 @@ 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');
@@ -37,6 +39,8 @@ const _inTransaction = Symbol('inTransaction');
 const _daoDB = Symbol('daoDB');
 const _sqliteRemoteName = Symbol('sqliteRemoteName');
 const _SqlOption = Symbol('SqlOption');
+const _resultMap = Symbol('resultMap');
+const _resultMap_SQLID = Symbol('resultMap_SQLID');
 export const _Hump = Symbol('Hump');
 export const _GlobalSqlOption = Symbol('GlobalSqlOption');
 export const _EventBus = Symbol('EventBus');
@@ -49,10 +53,12 @@ export const logger =
             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,
@@ -124,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,
@@ -243,7 +261,7 @@ interface ServiceOption {
     ```
     可以继承该接口来约束格式
  */
-export interface GlobalSqlOption2 {
+export interface GlobalSqlOptionForWeb {
     /** 增改忽略Undefined */
     skipUndefined?: boolean;
     /** 增改忽略NULL */
@@ -277,12 +295,20 @@ export interface GlobalSqlOption2 {
      作用与sqlDir类似，不同在于sqlMap`不需要`目录，而是直接指定一个sqlModel对象，对象的格式和sqlDir的文件内容一样。
      ** 适用于简单使用
      */
-    sqlMap?: SqlModel;
+    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;
 }
 /**
  # 全局行为配置文件
@@ -296,7 +322,7 @@ export interface GlobalSqlOption2 {
     ```
     可以继承该接口来约束格式
  */
-export interface GlobalSqlOption extends GlobalSqlOption2 {
+export interface GlobalSqlOption extends GlobalSqlOptionForWeb {
     /**
        初始化MYSQL链接 支持多数据源
        ## 单一数据源: 直接传入Mysql2的连接配置
@@ -372,9 +398,25 @@ export interface GlobalSqlOption extends GlobalSqlOption2 {
     sqlDir?: string;
     /**
     ## [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;
+
+    /**
+      ## 映射数据为对象，文件名就是模板名
+    ```
+    // 第一个元素=列名，第二个元素是属性路径，
+    // 该目录下可存放json文件，内容如下
+    //
+    // 可以在查询时使用，优先级高于hump
+    // 例如:
+    [
+        ['dit_id', ['id'], 可选的默认值], // 列名ditid,对应属性id,当未查询返回时，使用默认值
+        ['event_id', ['eventMainInfo', 'id']] // 列名event_id对应属性eventMainInfo.id,当未查询返回时，该属性不存在
+    ]
+    ```
+     */
+    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)
     ```
@@ -415,6 +457,11 @@ export interface GlobalSqlOption extends GlobalSqlOption2 {
      * ```
      */
     columnMode?: ColumnMode;
+    /**
+     * 读取查询语句时，是否扫描JS文件？
+     * JS文件需要默认导出一个 SqlModel对象
+     */
+    jsMode?: boolean;
 }
 
 interface FieldOption extends Object {
@@ -1231,6 +1278,8 @@ export 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;
@@ -1241,6 +1290,17 @@ export type SqlModel = Record<string, string | (
         orderBy?: 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 ';
@@ -1525,30 +1585,65 @@ function replaceCdata(rawText: string) {
     }
     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 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;
-        }
-        const queryTypes = ['sql', 'select', 'insert', 'update', 'delete'];
-        if (options.sqlDir) {
-            const sqlFis = globalThis[_fs].readdirSync(options.sqlDir);
-            for (const modeName of sqlFis) {
-                logger.debug(`sql: ${modeName} start explain!`);
+    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);
                 let ct = 0;
                 if (extname === '.mu') {
-                    const parser = new MUParser(name, globalThis[_fs].readFileSync(file, { encoding: 'utf-8' }).toString());
+                    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++;
@@ -1556,37 +1651,91 @@ export class SqlCache {
                         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)) {
                         ct++;
 
-                        this.sqlMap[`${name}.${String(key)}`] = fn;
+                        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){
+                    if (root) {
                         const mappers = root.children;
                         for (const mapper of mappers) {
-                            console.log(mapper);
                             if (mapper.type === 'tag' && mapper.name === 'mapper') {
                                 for (const am of mapper.children) {
                                     if (am.type === 'tag') {
-                                        Throw.if(!queryTypes.includes(am.name), `${name}错误,${am.name}不支持!`);
+                                        Throw.if(!queryTypes.includes(am.name), `${rootName} ${name}错误,${am.name}不支持!`);
                                         am.id = am.attrs['id'];
-                                        Throw.if(!am.id, `${name}错误,没有为此块设置id:${am}`);
-                                        this.sqlMap[`${name}.${am.id!}`] = am.children;
+                                        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']!])
                 }
-                logger.debug(`sql: ${modeName} explain over[${ct}]!`);
             }
         }
+    }
+    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;
         }
@@ -1601,6 +1750,21 @@ export 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(sqlids: string[], options: {
         ctx: any;
@@ -1620,17 +1784,19 @@ export class SqlCache {
         }
         const matchSqlid = sqlids.map(i => i.split('.')[0]!);
         Throw.if(!sqlSource, `指定的语句${sqlids.join('|')}不存在!`);
+        const buildParam = new Build(options.isCount === true, options.isSum === true, options);
         if (typeof sqlSource === 'function') {
             const _sql = sqlSource(options);
-            const buildParam = new Build(options.isCount === true, options.isSum === true, options);
             const sql = mustache.render(_sql, buildParam, this.sqlFNMap);
             return format(sql);
         } else if (typeof sqlSource === 'string') {
-            const buildParam = new Build(options.isCount === true, options.isSum === true, options);
             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[]>);
+            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 '';
@@ -2771,9 +2937,10 @@ export class SqlService<T extends object> {
                 )`;
             }).join(' OR ');
             if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
+                params.unshift(this[_deleteState]);
                 sqls.push({
                     sql: format(`
-                    UPDATE ${tableNameESC} SET ${this[_fields]![this[_stateFileName]]?.C2()} = ${Sqlstring.escape(this[_deleteState])}
+                    UPDATE ${tableNameESC} SET ${this[_fields]![this[_stateFileName]]?.C2()} = ?
                     WHERE ${whereSql};
                 `), params
                 });
@@ -2790,7 +2957,8 @@ export class SqlService<T extends object> {
                     if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
                         sqls.push({
                             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()} = ${Sqlstring.escape(this[_deleteState])};`)
+                            SET a.${this[_fields]![this[_stateFileName]]?.C2()} = ?;`),
+                            params: [this[_deleteState]]
                         });
                     } else {
                         sqls.push({
@@ -2804,8 +2972,9 @@ export class SqlService<T extends object> {
                     const columnNames = iterare(delWhere).map(K => this[_fields]![K]?.C2()).join(',');
                     if (this[_stateFileName] !== undefined && option.forceDelete !== true) {
                         sqls.push({
-                            sql: format(`UPDATE ${tableNameESC} SET ${this[_fields]![this[_stateFileName]]?.C2()} = ${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: format(`DELETE FROM ${tableNameESC} WHERE (${columnNames}) IN (SELECT ${columnNames} FROM ${tableTempESC});`) });
@@ -2869,6 +3038,9 @@ export class SqlService<T extends object> {
             case TemplateResult.Count: {
                 return result[0].ct;
             }
+            case TemplateResult.ManyList: {
+                return new ArrayList(result[0]);
+            }
         }
     }
     /**
@@ -2894,20 +3066,18 @@ export class SqlService<T extends object> {
     8.  `dao`: 永远不需要传入该值
 
      */
-    template<L = T>(option: MethodOption & { 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.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 & { 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.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 & { 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.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 & { 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.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.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<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[] | Promise<number | L | null | L[]> {
+    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!');
@@ -2980,100 +3150,75 @@ export class SqlService<T extends object> {
         }
     }
 
-    private _select<L = T>(templateResult: SelectResult, result: any, def: L | null, errorMsg?: string, multiple?: boolean, hump?: 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 {
-                        if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
-                            return result.map((r: any) => C2P2(r[0]) as L);
-                        }
-                        return result.map((r: any) => r[0] as L);
-                    } catch (error) {
-                    }
-                }
-                case SelectResult.One_Row_Many_Column_Assert: {
-                    try {
-                        if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
-                            return iterare(result).map((r: any) => C2P2(r[0]) as L).filter((r: L) => r !== null).toArray();
-                        }
-                        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: {
-                    if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
-                        return iterare(result).map((r: any) => r.map((rr: any) => C2P2(rr) as L)).toArray();
-                    } else {
-                        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.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_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_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_NotSure: {
-                    if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
-                        return (C2P2(result[0]) as L) ?? null;
-                    } else {
-                        return (result[0] as L) ?? null;
-                    }
 
+            }
+            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.One_Row_Many_Column_Assert: {
-                    const data = result[0] as L;
-                    Throw.if(data === null || data === undefined, errorMsg ?? 'not found data!');
-                    if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
-                        return C2P2(data as any) ?? null;
-                    } else {
-                        return data ?? null;
-                    }
+            }
+            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_One_Column: {
-                    try {
-                        return result.map((r: any) => Object.values(r)[0] as L);
-                    } catch (error) {
-                        return def;
-                    }
+            }
+            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.Many_Row_Many_Column: {
-                    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>();
                 }
             }
         }
@@ -3081,20 +3226,19 @@ export class SqlService<T extends object> {
     /**
     # 自由查询
     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`: 仅在开启事务时需要主动传入,传入示例:
         ```
@@ -3103,50 +3247,63 @@ export class SqlService<T extends object> {
             });
         ```
     9.  `dao`: 永远不需要传入该值
+    10. `hump`: 是否将列名改为驼峰写法？默认情况下按照全局配置
+    11. `mapper`: 列名-属性 映射工具，优先级高于hump
 
      */
-    select<L = T>(option: MethodOption & { hump?: boolean; 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 & { hump?: boolean; 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 & { hump?: boolean; 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 & { hump?: boolean; 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 & { hump?: boolean; 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 & { hump?: boolean; 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 & { hump?: boolean; 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(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);
-            if (_params.hasOwnProperty(_key)) {
-                const V = _params[_key];
-                params.push(V);
-                return Sqlstring.escape(_params[_key]);
+            V = LGet(_params, _key);
+            if (V) {
+                if (V !== undefined) {
+                    params.push(V);
+                }
+                return '?';
             }
             const __key = P2C(key);
-            if (_params.hasOwnProperty(__key)) {
-                const V = _params[__key];
-                params.push(V);
-                return Sqlstring.escape(_params[__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, option.hump);
+            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, reject) => {
                 try {
                     const result = await option!.conn!.query(SyncMode.Async, sql, params);
-                    resolve(this._select<L>(option.selectResult!, result, option.defValue!, option.errorMsg, option.multiple));
+                    resolve(this._select<L>(option.selectResult!, result, option.defValue!, option.errorMsg, option.hump, option.mapper, option.mapperIfUndefined));
                 } catch (error) {
                     reject(error);
                 }
@@ -3167,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;
@@ -3178,22 +3335,28 @@ export class SqlService<T extends object> {
         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);
-            if (_params.hasOwnProperty(_key)) {
-                const V = _params[_key];
-                params.push(V);
-                return Sqlstring.escape(_params[_key]);
+            V = LGet(_params, _key);
+            if (V) {
+                if (V !== undefined) {
+                    params.push(V);
+                }
+                return '?';
             }
             const __key = P2C(key);
-            if (_params.hasOwnProperty(__key)) {
-                const V = _params[__key];
-                params.push(V);
-                return Sqlstring.escape(_params[__key]);
+            V = LGet(_params, __key);
+            if (V) {
+                if (V !== undefined) {
+                    params.push(V);
+                }
+                return '?';
             }
             return txt;
         });
@@ -3252,10 +3415,10 @@ export class SqlService<T extends object> {
     }
 
 
-    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; }): 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; }): PageQuery<L>;
+    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; }): PageQuery<L> | Promise<PageQuery<L>> {
+    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: [],
@@ -3296,7 +3459,7 @@ export class SqlService<T extends object> {
                     ...option,
                     sql: sqlCount,
                     sync: SyncMode.Sync,
-                    selectResult: SelectResult.One_Row_One_Column_Assert
+                    selectResult: SelectResult.R_C_Assert
                 });
                 result.size = calc(result.total)
                     .add(option.pageSize - 1)
@@ -3309,7 +3472,7 @@ export class SqlService<T extends object> {
                     ...option,
                     sql: sqlSum,
                     sync: SyncMode.Sync,
-                    selectResult: SelectResult.One_Row_Many_Column_Assert
+                    selectResult: SelectResult.R_CS_Assert
                 });
             }
             if (sql) {
@@ -3317,7 +3480,7 @@ export class SqlService<T extends object> {
                     ...option,
                     sql,
                     sync: SyncMode.Sync,
-                    selectResult: SelectResult.Many_Row_Many_Column
+                    selectResult: SelectResult.RS_CS
                 });
             }
             return result;
@@ -3329,7 +3492,7 @@ export class SqlService<T extends object> {
                             ...option,
                             sql: sqlCount,
                             sync: SyncMode.Async,
-                            selectResult: SelectResult.One_Row_One_Column_Assert
+                            selectResult: SelectResult.R_C_Assert
                         });
                         result.size = calc(result.total)
                             .add(option.pageSize - 1)
@@ -3342,7 +3505,7 @@ export class SqlService<T extends object> {
                             ...option,
                             sql: sqlSum,
                             sync: SyncMode.Async,
-                            selectResult: SelectResult.One_Row_Many_Column_Assert
+                            selectResult: SelectResult.R_CS_Assert
                         });
                     }
                     if (sql) {
@@ -3350,7 +3513,7 @@ export class SqlService<T extends object> {
                             ...option,
                             sql,
                             sync: SyncMode.Async,
-                            selectResult: SelectResult.Many_Row_Many_Column
+                            selectResult: SelectResult.RS_CS
                         });
                     }
                     resolve(result);
@@ -3463,7 +3626,7 @@ export class SqlService<T extends object> {
 
     private _matchSqlid(sqlid?: string) {
         sqlid ??= '';
-        if(sqlid.includes('.')) return [sqlid];
+        if (sqlid.includes('.')) return [sqlid];
         else return [`${this[_tableName]}.${sqlid}`, `${this[_className]}.${sqlid}`, `${this[_ClassName]}.${sqlid}`, `${this[_vueName]}.${sqlid}`];
     }
 
@@ -3558,9 +3721,10 @@ class StreamQuery<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 } = {}) {
+    eqT(t: Partial<T>, { name: paramName = '', breakExcuteIfSkip = false } = {}) {
+        let exe = false;
         if (t) {
             t = this._service[_transformer]!(t, {
                 skipNull: true,
@@ -3569,8 +3733,8 @@ class StreamQuery<T extends object> {
             });
             const keys = Object.keys(t);
             if (keys.length > 0) {
-                if (name && this._paramKeys[name]) {
-                    for (const [key, pname] of Object.entries(this._paramKeys[name] as Record<string, string>)) {
+                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 {
@@ -3579,124 +3743,128 @@ class StreamQuery<T extends object> {
                         const pkey = `p${this._prefix}${this._index++}`;
                         this._wheres.push(`AND ${this[_fields]![String(key)]?.C2()} = :${pkey} `);
                         this._param[pkey] = value;
-                        if (name) {
+                        if (paramName) {
                             paramKeys[key] = pkey;
                         }
                     }
-                    if (name) {
-                        this._paramKeys[name] = paramKeys;
+                    if (paramName) {
+                        this._paramKeys[paramName] = paramKeys;
                     }
                 }
+                exe = true;
             }
         }
+        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: StreamQuery<T> | ((stream: StreamQuery<T>) => boolean | void)) {
         if (fn instanceof StreamQuery) {
@@ -3782,17 +3950,19 @@ class StreamQuery<T extends object> {
     }
     // #endregion
 
-    excuteSelect<L = T>(option?: MethodOption & { sync?: SyncMode.Async; selectResult?: SelectResult.Many_Row_Many_Column | SelectResult.Many_Row_One_Column; }): Promise<L[]>;
-    excuteSelect<L = T>(option: MethodOption & { sync?: SyncMode.Async; selectResult: SelectResult.One_Row_Many_Column_Assert | SelectResult.One_Row_One_Column_Assert; errorMsg?: string; }): Promise<L>;
-    excuteSelect<L = T>(option: MethodOption & { sync?: SyncMode.Async; selectResult: SelectResult.One_Row_Many_Column_NotSure | SelectResult.One_Row_One_Column_NotSure; }): Promise<L | null>;
-    excuteSelect<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult: SelectResult.Many_Row_Many_Column | SelectResult.Many_Row_One_Column; }): L[];
-    excuteSelect<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult: SelectResult.One_Row_Many_Column_Assert | SelectResult.One_Row_One_Column_Assert; errorMsg?: string; }): L;
-    excuteSelect<L = T>(option: MethodOption & { sync: SyncMode.Sync; selectResult: SelectResult.One_Row_Many_Column_NotSure | SelectResult.One_Row_One_Column_NotSure; }): L | null;
+    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; }): null | L | L[] | Promise<null | L | L[]> {
+    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.Many_Row_Many_Column;
+        option.selectResult ??= SelectResult.RS_CS;
         const { where, params } = this._where();
         let sql = `
             SELECT
@@ -3800,6 +3970,8 @@ class StreamQuery<T extends object> {
             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}`;
@@ -3808,24 +3980,110 @@ class StreamQuery<T extends object> {
         }
         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 });
+                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.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 });
+                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)
@@ -3892,15 +4150,26 @@ class StreamQuery<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 ${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;
@@ -3913,103 +4182,163 @@ class StreamQuery<T extends object> {
         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 ${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 ${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;
+    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;
+        }
+        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 (${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 _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;
+    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 MATCH(${keys.map(key => this[_fields]![String(key)]?.C2()).join(',')}) AGAINST (:${pkey} ${append ?? ''})`);
+            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 _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 _pow(key: keyof T, value: number, { not = '', paramName = '', breakExcuteIfSkip = false } = {}) {
+        if (
+            value === null
+            || value === undefined
+            || emptyString(`${value ?? ''}`)
+        ) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName] as string] = value;
         } else {
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND NOT POW(2, ${this[_fields]![String(key)]?.C2()}) & :${pkey}`);
+            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;
     }
-    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 ${this[_fields]![String(key)]?.C2()} ${not} ${op} CONCAT('${left}', :${pkey}, '${right}') `);
-                this._param[pkey] = value;
-                if (name) {
-                    this._paramKeys[name] = pkey;
-                }
+    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 {
+            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;
             }
-        } else if (force !== true) {
-            this.if_exec = false;
         }
         return this;
     }
-    private _includes(key: keyof T, value: any, { not = '', name = '' } = {}) {
-        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
-            this._param[this._paramKeys[name] as string] = value;
+    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 (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(${this[_fields]![String(key)]?.C2()}, :${pkey}) ${not ? '=' : ''}  0`);
+            this._wheres.push(`AND LOCATE(${this[_fields]![String(key)]?.C2()}, :${pkey}) ${not ? '=' : '>'}  0`);
             this._param[pkey] = value;
-            if (name) {
-                this._paramKeys[name] = pkey;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
             }
         }
         return this;