baja-lite 1.0.5 → 1.0.7

package/es/sql.js

@@ -22,6 +22,8 @@ import { C2P, C2P2, P2C } from './object';
 import { format } from 'sql-formatter';
 import HTML from 'html-parse-stringify';
 import { convert } from './convert-xml';
+import { ArrayList } from './list';
+import LGet from 'lodash.get';
 // #region 常量
 const _daoDBName = Symbol('dbName');
 const _tableName = Symbol('tableName');
@@ -47,6 +49,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');
@@ -58,6 +62,7 @@ export const logger = process.env['NODE_ENV'] !== 'production' ? pino({
         target: 'pino-pretty'
     }
 }) : pino({ name: 'sql' });
+globalThis[_resultMap_SQLID] = {};
 // #endregion
 // #region 可选配置
 export var DBType;
@@ -69,6 +74,15 @@ export var DBType;
     DBType[DBType["Redis"] = 4] = "Redis";
     DBType[DBType["RedisLock"] = 5] = "RedisLock";
 })(DBType || (DBType = {}));
+;
+export var MapperIfUndefined;
+(function (MapperIfUndefined) {
+    MapperIfUndefined[MapperIfUndefined["Null"] = 0] = "Null";
+    MapperIfUndefined[MapperIfUndefined["Skip"] = 1] = "Skip";
+    MapperIfUndefined[MapperIfUndefined["Zero"] = 2] = "Zero";
+    MapperIfUndefined[MapperIfUndefined["EmptyString"] = 3] = "EmptyString";
+})(MapperIfUndefined || (MapperIfUndefined = {}));
+;
 export var SyncMode;
 (function (SyncMode) {
     /** 同步执行 */
@@ -145,17 +159,29 @@ export var TemplateResult;
     TemplateResult[TemplateResult["NotSureOne"] = 1] = "NotSureOne";
     /** 返回多条记录 */
     TemplateResult[TemplateResult["Many"] = 2] = "Many";
+    /** 返回多条记录并封装ArrayList */
+    TemplateResult[TemplateResult["ManyList"] = 3] = "ManyList";
     /** 仅查询记录数量 */
-    TemplateResult[TemplateResult["Count"] = 3] = "Count";
+    TemplateResult[TemplateResult["Count"] = 4] = "Count";
 })(TemplateResult || (TemplateResult = {}));
 export var SelectResult;
 (function (SelectResult) {
-    SelectResult[SelectResult["One_Row_One_Column_Assert"] = 0] = "One_Row_One_Column_Assert";
-    SelectResult[SelectResult["One_Row_One_Column_NotSure"] = 1] = "One_Row_One_Column_NotSure";
-    SelectResult[SelectResult["One_Row_Many_Column_Assert"] = 2] = "One_Row_Many_Column_Assert";
-    SelectResult[SelectResult["One_Row_Many_Column_NotSure"] = 3] = "One_Row_Many_Column_NotSure";
-    SelectResult[SelectResult["Many_Row_One_Column"] = 4] = "Many_Row_One_Column";
-    SelectResult[SelectResult["Many_Row_Many_Column"] = 5] = "Many_Row_Many_Column";
+    /** 一行一列 确定非空 */
+    SelectResult[SelectResult["R_C_Assert"] = 0] = "R_C_Assert";
+    /** 一行一列 可能空 */
+    SelectResult[SelectResult["R_C_NotSure"] = 1] = "R_C_NotSure";
+    /** 一行多列 确定非空 */
+    SelectResult[SelectResult["R_CS_Assert"] = 2] = "R_CS_Assert";
+    /** 一行多列 可能空 */
+    SelectResult[SelectResult["R_CS_NotSure"] = 3] = "R_CS_NotSure";
+    /** 多行一列 */
+    SelectResult[SelectResult["RS_C"] = 4] = "RS_C";
+    /** 多行一列并封装ArrayList */
+    SelectResult[SelectResult["RS_C_List"] = 5] = "RS_C_List";
+    /** 多行多列 */
+    SelectResult[SelectResult["RS_CS"] = 6] = "RS_CS";
+    /** 多行多列并封装ArrayList */
+    SelectResult[SelectResult["RS_CS_List"] = 7] = "RS_CS_List";
 })(SelectResult || (SelectResult = {}));
 export var SqlType;
 (function (SqlType) {
@@ -1201,26 +1227,73 @@ function replaceCdata(rawText) {
     }
     return rawText;
 }
+function _flatData(result, i, length, keys, V) {
+    var _d;
+    const key = keys[i];
+    if (i < length) {
+        result[_d = key] ?? (result[_d] = {});
+        i++;
+        _flatData(result[key], i, length, keys, V);
+    }
+    else {
+        result[key] = V;
+    }
+}
+/**
+ * ifUndefined默认是MapperIfUndefined.Skip
+ */
+export function flatData(options) {
+    if (typeof options.mapper === 'string') {
+        const name = options.mapper;
+        options.mapper = globalThis[_resultMap][name];
+        Throw.if(!options.mapper, `not found mapper!${name}`);
+    }
+    options.mapperIfUndefined ?? (options.mapperIfUndefined = MapperIfUndefined.Skip);
+    options.mapper = options.mapper;
+    const result = {};
+    for (const [columnName, keys, def] of options.mapper) {
+        let V = options.data[columnName];
+        if (V === undefined) {
+            if (options.mapperIfUndefined === MapperIfUndefined.Null) {
+                V = null;
+            }
+            else if (options.mapperIfUndefined === MapperIfUndefined.Zero) {
+                V = 0;
+            }
+            else if (options.mapperIfUndefined === MapperIfUndefined.EmptyString) {
+                V = '';
+            }
+            else if (def !== undefined) {
+                V = def;
+            }
+            else {
+                continue;
+            }
+        }
+        _flatData(result, 0, keys.length - 1, keys, V);
+    }
+    return result;
+}
 export class SqlCache {
     constructor() {
         this.sqlMap = {};
         this.sqlFNMap = {};
     }
-    async init(options) {
-        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!`);
+    async _read(jsMode, sqlDir, queryTypes, rootName) {
+        const sqlFis = globalThis[_fs].readdirSync(sqlDir);
+        for (const modeName of sqlFis) {
+            const file = globalThis[_path].join(sqlDir, modeName);
+            const stat = globalThis[_fs].statSync(file);
+            if (stat.isDirectory()) {
+                await this._read(jsMode, file, queryTypes, modeName);
+            }
+            else {
                 const extname = globalThis[_path].extname(modeName);
                 const name = globalThis[_path].basename(modeName, extname);
-                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++;
@@ -1228,36 +1301,88 @@ export class SqlCache {
                         logger.debug(`sql: ${source[0]} found!`);
                         source = parser.next();
                     }
+                    logger.debug(`sql: ${file} explain over[${ct}]!`);
                 }
-                else if (extname === '.js') {
-                    const obj = (await import(globalThis[_path].join(options.sqlDir, modeName))).default;
+                else if (jsMode === true && extname === '.js') {
+                    logger.debug(`sql: ${file} start explain!`);
+                    const obj = (await import(globalThis[_path].join(sqlDir, modeName))).default;
                     for (const [key, fn] of Object.entries(obj)) {
                         ct++;
-                        this.sqlMap[`${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()))[0];
                     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] ?? (globalThis[_resultMap] = {});
+                                            const keys = [];
+                                            this.readResultMap(am.children, keys, []);
+                                            globalThis[_resultMap][am.id] = keys;
+                                            logger.debug(`sql_resultMap: ${am.id} found!`);
+                                        }
+                                        else {
+                                            this.sqlMap[`${rootName || name}.${am.id}`] = am.children;
+                                            if (am.attrs['resultMap']) {
+                                                globalThis[_resultMap_SQLID][`${rootName || name}.${am.id}`] = am.attrs['resultMap'];
+                                                logger.debug(`sql: autoMapper: ${rootName || name}.${am.id}-${am.attrs['resultMap']}`);
+                                            }
+                                            logger.debug(`sql: ${rootName || name}.${am.id} found!`);
+                                            ct++;
+                                        }
                                     }
                                 }
                             }
                         }
                     }
+                    logger.debug(`sql: ${file} explain over[${ct}]!`);
                 }
-                logger.debug(`sql: ${modeName} explain over[${ct}]!`);
             }
         }
+    }
+    /**
+     *
+     * ```
+    // 第一个元素=列名，第二个元素是属性路径，
+    [
+        ['dit_id', ['id']], // 列名ditid,对应属性id
+        ['event_id', ['eventMainInfo', 'id']] // 列名event_id对应属性eventMainInfo.id
+    ]
+     * ```
+     * @param am
+     * @param keys
+     */
+    readResultMap(ams, keys, key) {
+        for (const am of ams) {
+            if (am.type === 'tag') {
+                if (am.name === 'result' || am.name === 'id') {
+                    keys.push([am.attrs['column'], [...key, am.attrs['property']]]);
+                }
+                else {
+                    this.readResultMap(am.children, keys, [...key, am.attrs['property']]);
+                }
+            }
+        }
+    }
+    async init(options) {
+        if (options.sqlMap) {
+            this.sqlMap = options.sqlMap;
+        }
+        const queryTypes = ['sql', 'select', 'insert', 'update', 'delete', 'resultMap'];
+        if (options.sqlDir) {
+            await this._read(options.jsMode === true, options.sqlDir, queryTypes, '');
+        }
         if (options.sqlFNMap) {
             this.sqlFNMap = options.sqlFNMap;
         }
@@ -1272,6 +1397,21 @@ export class SqlCache {
                 }
             }
         }
+        if (options.sqlMapperMap) {
+            globalThis[_resultMap] = options.sqlFNMap;
+        }
+        if (options.sqlMapperDir) {
+            const sqlFis = globalThis[_fs].readdirSync(options.sqlDir);
+            globalThis[_resultMap] ?? (globalThis[_resultMap] = {});
+            for (const modeName of sqlFis) {
+                const extname = globalThis[_path].extname(modeName);
+                const name = globalThis[_path].basename(modeName, extname);
+                const file = globalThis[_path].join(options.sqlDir, modeName);
+                if (extname === 'json') {
+                    globalThis[_resultMap][name] = JSON.parse(globalThis[_fs].readFileSync(file, { encoding: 'utf-8' }).toString());
+                }
+            }
+        }
     }
     load(sqlids, options) {
         let sqlSource;
@@ -1283,19 +1423,21 @@ 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);
+            const _sql = convert(sqlSource, options, matchSqlid, this.sqlMap);
+            console.log(_sql);
+            const sql = mustache.render(_sql, buildParam, this.sqlFNMap);
+            console.log(sql);
             return format(sql);
         }
         return '';
@@ -2338,9 +2480,10 @@ export class SqlService {
                 )`;
             }).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
                 });
@@ -2359,7 +2502,8 @@ export class SqlService {
                     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 {
@@ -2374,8 +2518,9 @@ export class SqlService {
                     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 {
@@ -2442,6 +2587,9 @@ export class SqlService {
             case TemplateResult.Count: {
                 return result[0].ct;
             }
+            case TemplateResult.ManyList: {
+                return new ArrayList(result[0]);
+            }
         }
     }
     template(option) {
@@ -2518,153 +2666,135 @@ export class SqlService {
             });
         }
     }
-    _select(templateResult, result, def, errorMsg, multiple, hump) {
-        if (multiple === true) {
-            switch (templateResult) {
-                case SelectResult.One_Row_One_Column_NotSure: {
-                    try {
-                        return result.map((r) => Object.values(r)[0]);
-                    }
-                    catch (error) {
-                    }
+    _select(templateResult, result, def, errorMsg, hump, mapper, mapperIfUndefined) {
+        switch (templateResult) {
+            case SelectResult.R_C_NotSure: {
+                try {
+                    return Object.values(result[0])[0];
                 }
-                case SelectResult.One_Row_One_Column_Assert: {
-                    try {
-                        return iterare(result).map((r) => Object.values(r)[0]).filter((r) => r !== null).toArray();
-                    }
-                    catch (error) {
-                    }
+                catch (error) {
+                    return def;
                 }
-                case SelectResult.One_Row_Many_Column_NotSure: {
-                    try {
-                        if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
-                            return result.map((r) => C2P2(r[0]));
-                        }
-                        return result.map((r) => r[0]);
-                    }
-                    catch (error) {
-                    }
+            }
+            case SelectResult.R_C_Assert: {
+                try {
+                    return Object.values(result[0])[0];
                 }
-                case SelectResult.One_Row_Many_Column_Assert: {
-                    try {
-                        if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
-                            return iterare(result).map((r) => C2P2(r[0])).filter((r) => r !== null).toArray();
-                        }
-                        return iterare(result).map((r) => r[0]).filter((r) => r !== null).toArray();
-                    }
-                    catch (error) {
-                    }
+                catch (error) {
+                    if (def !== undefined)
+                        return def;
+                    Throw.now(errorMsg ?? 'not found data!');
                 }
-                case SelectResult.Many_Row_One_Column: {
-                    try {
-                        return result.map((rx) => rx.map((r) => Object.values(r)[0]));
-                    }
-                    catch (error) {
-                    }
+            }
+            case SelectResult.R_CS_NotSure: {
+                if (mapper) {
+                    return flatData({ data: result[0], mapper, mapperIfUndefined });
                 }
-                case SelectResult.Many_Row_Many_Column: {
-                    if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
-                        return iterare(result).map((r) => r.map((rr) => C2P2(rr))).toArray();
-                    }
-                    else {
-                        return result;
-                    }
+                else if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
+                    return C2P2(result[0]) ?? null;
+                }
+                else {
+                    return result[0] ?? null;
                 }
             }
-        }
-        else {
-            switch (templateResult) {
-                case SelectResult.One_Row_One_Column_NotSure: {
-                    try {
-                        return Object.values(result[0])[0];
-                    }
-                    catch (error) {
-                        return def;
-                    }
+            case SelectResult.R_CS_Assert: {
+                const data = result[0];
+                Throw.if(data === null || data === undefined, errorMsg ?? 'not found data!');
+                if (mapper) {
+                    return flatData({ data, mapper, mapperIfUndefined });
                 }
-                case SelectResult.One_Row_One_Column_Assert: {
-                    try {
-                        return Object.values(result[0])[0];
-                    }
-                    catch (error) {
-                        if (def !== undefined)
-                            return def;
-                        Throw.now(errorMsg ?? 'not found data!');
-                    }
+                else if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
+                    return C2P2(data) ?? null;
                 }
-                case SelectResult.One_Row_Many_Column_NotSure: {
-                    if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
-                        return C2P2(result[0]) ?? null;
-                    }
-                    else {
-                        return result[0] ?? null;
-                    }
+                else {
+                    return data ?? null;
                 }
-                case SelectResult.One_Row_Many_Column_Assert: {
-                    const data = result[0];
-                    Throw.if(data === null || data === undefined, errorMsg ?? 'not found data!');
-                    if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
-                        return C2P2(data) ?? null;
-                    }
-                    else {
-                        return data ?? null;
-                    }
+            }
+            case SelectResult.RS_C: {
+                try {
+                    return result.map((r) => Object.values(r)[0]);
                 }
-                case SelectResult.Many_Row_One_Column: {
-                    try {
-                        return result.map((r) => Object.values(r)[0]);
-                    }
-                    catch (error) {
-                        return def;
-                    }
+                catch (error) {
+                    return result;
                 }
-                case SelectResult.Many_Row_Many_Column: {
-                    if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
-                        return iterare(result).map((r) => C2P2(r)).toArray();
-                    }
-                    else {
-                        return result;
-                    }
+            }
+            case SelectResult.RS_CS: {
+                if (mapper) {
+                    return iterare(result).map((data) => flatData({ data, mapper, mapperIfUndefined })).toArray();
+                }
+                else if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
+                    return iterare(result).map((r) => C2P2(r)).toArray();
+                }
+                else {
+                    return result;
+                }
+            }
+            case SelectResult.RS_C_List: {
+                try {
+                    return new ArrayList(result.map((r) => Object.values(r)[0]));
+                }
+                catch (error) {
+                    return new ArrayList();
+                }
+            }
+            case SelectResult.RS_CS_List: {
+                if (mapper) {
+                    return new ArrayList(iterare(result).map((data) => flatData({ data, mapper, mapperIfUndefined })).toArray());
+                }
+                else if (hump === true || (hump === undefined && globalThis[_Hump] === true)) {
+                    return new ArrayList(iterare(result).map((r) => C2P2(r)).toArray());
+                }
+                else {
+                    return new ArrayList();
                 }
             }
         }
     }
     select(option) {
         Throw.if(!option.sqlId && !option.sql, 'not found sql!');
-        option.selectResult ?? (option.selectResult = SelectResult.Many_Row_Many_Column);
+        option.selectResult ?? (option.selectResult = SelectResult.RS_CS);
         option.defValue ?? (option.defValue = null);
+        if (option.sqlId && globalThis[_resultMap_SQLID][option.sqlId] && !option.mapper) {
+            option.mapper = globalThis[_resultMap_SQLID][option.sqlId];
+        }
         const _params = Object.assign({}, option.context, option.params);
         option.sql ?? (option.sql = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: option.context, isCount: option.isCount, ..._params }));
         const params = [];
-        const sql = option.sql?.replace(/\:(\w+)/g, (txt, key) => {
-            if (_params.hasOwnProperty(key)) {
-                const V = _params[key];
-                params.push(V);
-                return Sqlstring.escape(_params[key]);
+        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(option.selectResult, result, option.defValue, option.errorMsg, option.multiple, option.hump);
+            return this._select(option.selectResult, result, option.defValue, option.errorMsg, option.hump, option.mapper, option.mapperIfUndefined);
         }
         else {
             return new Promise(async (resolve, reject) => {
                 try {
                     const result = await option.conn.query(SyncMode.Async, sql, params);
-                    resolve(this._select(option.selectResult, result, option.defValue, option.errorMsg, option.multiple));
+                    resolve(this._select(option.selectResult, result, option.defValue, option.errorMsg, option.hump, option.mapper, option.mapperIfUndefined));
                 }
                 catch (error) {
                     reject(error);
@@ -2678,22 +2808,28 @@ export class SqlService {
         option.sql ?? (option.sql = globalThis[_sqlCache].load(this._matchSqlid(option.sqlId), { ctx: option.context, ..._params }));
         const params = [];
         const sql = option.sql?.replace(/\:(\w+)/g, (txt, key) => {
-            if (_params.hasOwnProperty(key)) {
-                const V = _params[key];
-                params.push(V);
-                return Sqlstring.escape(_params[key]);
+            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;
         });
@@ -2774,7 +2910,7 @@ export class SqlService {
                     ...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)
@@ -2787,7 +2923,7 @@ export class SqlService {
                     ...option,
                     sql: sqlSum,
                     sync: SyncMode.Sync,
-                    selectResult: SelectResult.One_Row_Many_Column_Assert
+                    selectResult: SelectResult.R_CS_Assert
                 });
             }
             if (sql) {
@@ -2795,7 +2931,7 @@ export class SqlService {
                     ...option,
                     sql,
                     sync: SyncMode.Sync,
-                    selectResult: SelectResult.Many_Row_Many_Column
+                    selectResult: SelectResult.RS_CS
                 });
             }
             return result;
@@ -2808,7 +2944,7 @@ export class SqlService {
                             ...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)
@@ -2821,7 +2957,7 @@ export class SqlService {
                             ...option,
                             sql: sqlSum,
                             sync: SyncMode.Async,
-                            selectResult: SelectResult.One_Row_Many_Column_Assert
+                            selectResult: SelectResult.R_CS_Assert
                         });
                     }
                     if (sql) {
@@ -2829,7 +2965,7 @@ export class SqlService {
                             ...option,
                             sql,
                             sync: SyncMode.Async,
-                            selectResult: SelectResult.Many_Row_Many_Column
+                            selectResult: SelectResult.RS_CS
                         });
                     }
                     resolve(result);
@@ -3071,8 +3207,9 @@ class StreamQuery {
         this.if_proceed = condition;
         return this;
     }
-    eq(key, value, { name } = {}) { return this._(key, value, '=', { name }); }
-    eqT(t, { name } = {}) {
+    eq(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._(key, value, '=', { paramName, skipEmptyString, breakExcuteIfSkip }); }
+    eqT(t, { name: paramName = '', breakExcuteIfSkip = false } = {}) {
+        let exe = false;
         if (t) {
             t = this._service[_transformer](t, {
                 skipNull: true,
@@ -3081,8 +3218,8 @@ class StreamQuery {
             });
             const keys = Object.keys(t);
             if (keys.length > 0) {
-                if (name && this._paramKeys[name]) {
-                    for (const [key, pname] of Object.entries(this._paramKeys[name])) {
+                if (paramName && this._paramKeys[paramName]) {
+                    for (const [key, pname] of Object.entries(this._paramKeys[paramName])) {
                         this._param[pname] = t[key];
                     }
                 }
@@ -3092,75 +3229,79 @@ class StreamQuery {
                         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;
     }
-    notEq(key, value, { name } = {}) { return this._(key, value, '<>', { name }); }
+    notEq(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._(key, value, '<>', { paramName, skipEmptyString, breakExcuteIfSkip }); }
     eqWith(key1, key2) { return this._key(key1, key2, '='); }
     notEqWith(key1, key2) { return this._key(key1, key2, '<>'); }
-    regexp(key, regexp, { name } = {}) { return this._(key, regexp, 'REGEXP', { name }); }
-    notRegexp(key, regexp, { name } = {}) { return this._(key, regexp, 'REGEXP', { name, not: 'NOT' }); }
+    regexp(key, regexp, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
+    notRegexp(key, regexp, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, not: 'NOT', breakExcuteIfSkip }); }
     /** (key1 << 8) + key2 = value */
-    shiftEq(key1, key2, value, { name } = {}) { return this._shift(key1, key2, value, '=', { name }); }
+    shiftEq(key1, key2, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._shift(key1, key2, value, '=', { paramName, breakExcuteIfSkip }); }
     /** (key1 << 8) + key2 <> value */
-    shiftNotEq(key1, key2, value, { name } = {}) { return this._shift(key1, key2, value, '<>', { name }); }
-    grate(key, value, { name } = {}) { return this._(key, value, '>', { name }); }
-    grateEq(key, value, { name } = {}) { return this._(key, value, '>=', { name }); }
+    shiftNotEq(key1, key2, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._shift(key1, key2, value, '<>', { paramName, breakExcuteIfSkip }); }
+    grate(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '>', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
+    grateEq(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '>=', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
     grateWith(key1, key2) { return this._key(key1, key2, '>'); }
     grateEqWith(key1, key2) { return this._key(key1, key2, '>='); }
-    less(key, value, { name } = {}) { return this._(key, value, '<', { name }); }
-    lessEq(key, value, { name } = {}) { return this._(key, value, '<=', { name }); }
+    less(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '<', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
+    lessEq(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._(key, value, '<=', { paramName, skipEmptyString: true, breakExcuteIfSkip }); }
     lessWith(key1, key2) { return this._key(key1, key2, '<'); }
     lessEqWith(key1, key2) { return this._key(key1, key2, '<='); }
-    like(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', right: '%', force }); }
-    notLike(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', right: '%', not: 'NOT', force }); }
-    leftLike(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', force }); }
-    notLeftLike(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', not: 'NOT', force }); }
-    rightLike(key, value, { name, force } = {}) { return this._like(key, value, { name, right: '%', force }); }
-    notRightLike(key, value, { name, force } = {}) { return this._like(key, value, { name, right: '%', not: 'NOT', force }); }
-    PreciseLike(key, value, { name, force } = {}) { return this._like(key, value, { name, force }); }
-    notPreciseLike(key, value, { name, force } = {}) { return this._like(key, value, { name, not: 'NOT', force }); }
-    glob(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', right: '%', force, op: 'GLOB' }); }
-    notGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', right: '%', not: 'NOT', force, op: 'GLOB' }); }
-    leftGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', force, op: 'GLOB' }); }
-    notLeftGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, left: '%', not: 'NOT', force, op: 'GLOB' }); }
-    rightGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, right: '%', force, op: 'GLOB' }); }
-    notRightGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, right: '%', not: 'NOT', force, op: 'GLOB' }); }
-    PreciseGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, force, op: 'GLOB' }); }
-    notPreciseGlob(key, value, { name, force } = {}) { return this._like(key, value, { name, not: 'NOT', force, op: 'GLOB' }); }
-    in(key, value, { name, force } = {}) { return this._in(key, value, { name, force }); }
-    notIn(key, value, { name, force } = {}) { return this._in(key, value, { name, not: 'NOT', force }); }
+    like(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfSkip }); }
+    notLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfSkip }); }
+    leftLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfSkip }); }
+    notLeftLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfSkip }); }
+    rightLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfSkip }); }
+    notRightLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfSkip }); }
+    PreciseLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfSkip }); }
+    notPreciseLike(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
+    glob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfSkip, op: 'GLOB' }); }
+    notGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
+    leftGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfSkip, op: 'GLOB' }); }
+    notLeftGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
+    rightGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfSkip, op: 'GLOB' }); }
+    notRightGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
+    PreciseGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfSkip, op: 'GLOB' }); }
+    notPreciseGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._like(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip, op: 'GLOB' }); }
+    in(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._in(key, value, { paramName, breakExcuteIfSkip }); }
+    notIn(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._in(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
     isNULL(key) { return this._null(key); }
     isNotNULL(key) { return this._null(key, 'NOT'); }
-    between(key, value1, value2, { name } = {}) { return this._between(key, value1, value2, { name }); }
-    notBetween(key, value1, value2, { name } = {}) { return this._between(key, value1, value2, { name, not: 'NOT' }); }
-    pow(key, value, { name } = {}) { return this._pow(key, value, { name }); }
-    notPow(key, value, { name } = {}) { return this._pow(key, value, { name, not: 'NOT' }); }
-    powWith(key, values, { name } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { name }); }
-    notPowWith(key, values, { name } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { name, not: 'NOT' }); }
+    between(key, value1, value2, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._between(key, value1, value2, { paramName, skipEmptyString, breakExcuteIfSkip }); }
+    notBetween(key, value1, value2, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._between(key, value1, value2, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
+    pow(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, value, { paramName, breakExcuteIfSkip }); }
+    notPow(key, value, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, value, { paramName, not: 'NOT', breakExcuteIfSkip }); }
+    powWith(key, values, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, breakExcuteIfSkip }); }
+    notPowWith(key, values, { paramName = '', breakExcuteIfSkip = false } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, not: 'NOT', breakExcuteIfSkip }); }
     /** MATCH(key1, key2, key3) AGAINST (value) */
-    match(value, keys, { name } = {}) { return this._match(value, keys, { name }); }
+    match(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip }); }
     /** NOT MATCH(key1, key2, key3) AGAINST (value) */
-    notMatch(value, keys, { name } = {}) { return this._match(value, keys, { name, not: 'NOT' }); }
+    notMatch(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
     /** MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE*/
-    matchBoolean(value, keys, { name } = {}) { return this._match(value, keys, { name, append: 'IN BOOLEAN MODE' }); }
+    matchBoolean(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, append: 'IN BOOLEAN MODE' }); }
     /** NOT MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE */
-    notMatchBoolean(value, keys, { name } = {}) { return this._match(value, keys, { name, not: 'NOT', append: 'IN BOOLEAN MODE' }); }
+    notMatchBoolean(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, not: 'NOT', append: 'IN BOOLEAN MODE' }); }
     /** MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
-    matchQuery(value, keys, { name } = {}) { return this._match(value, keys, { name, append: 'WITH QUERY EXPANSION' }); }
+    matchQuery(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, append: 'WITH QUERY EXPANSION' }); }
     /** NOT MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
-    notMatchQuery(value, keys, { name } = {}) { return this._match(value, keys, { name, not: 'NOT', append: 'WITH QUERY EXPANSION' }); }
-    includes(key, value, { name } = {}) { return this._includes(key, value, { name }); }
-    notIncludes(key, value, { name } = {}) { return this._includes(key, value, { name, not: 'NOT' }); }
+    notMatchQuery(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfSkip, not: 'NOT', append: 'WITH QUERY EXPANSION' }); }
+    includes(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._includes(key, value, { paramName, skipEmptyString, breakExcuteIfSkip }); }
+    notIncludes(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) { return this._includes(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfSkip }); }
     and(fn) {
         if (fn instanceof StreamQuery) {
             this._andQuerys.push(fn);
@@ -3227,7 +3368,7 @@ class StreamQuery {
     excuteSelect(option) {
         option ?? (option = {});
         option.sync ?? (option.sync = SyncMode.Async);
-        option.selectResult ?? (option.selectResult = SelectResult.Many_Row_Many_Column);
+        option.selectResult ?? (option.selectResult = SelectResult.RS_CS);
         const { where, params } = this._where();
         let sql = `
             SELECT
@@ -3235,6 +3376,8 @@ class StreamQuery {
             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}`;
@@ -3244,25 +3387,113 @@ class StreamQuery {
         }
         if (option.sync === SyncMode.Async) {
             switch (option.selectResult) {
-                case SelectResult.Many_Row_Many_Column: return this._service.select({ sync: SyncMode.Async, selectResult: SelectResult.Many_Row_Many_Column, errorMsg: option.errorMsg, sql, params });
-                case SelectResult.Many_Row_One_Column: return this._service.select({ 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({ 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({ 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({ 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({ sync: SyncMode.Async, selectResult: SelectResult.One_Row_One_Column_NotSure, errorMsg: option.errorMsg, sql, params });
+                case SelectResult.RS_CS: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.RS_CS, sql, params });
+                case SelectResult.RS_C: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.RS_C, sql, params });
+                case SelectResult.RS_CS_List: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.RS_CS_List, sql, params });
+                case SelectResult.RS_C_List: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.RS_C_List, sql, params });
+                case SelectResult.R_CS_Assert: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.R_CS_Assert, sql, params });
+                case SelectResult.R_C_Assert: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.R_C_Assert, sql, params });
+                case SelectResult.R_CS_NotSure: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.R_CS_NotSure, sql, params });
+                case SelectResult.R_C_NotSure: return this._service.select({ ...option, sync: SyncMode.Async, selectResult: SelectResult.R_C_NotSure, sql, params });
             }
         }
         else {
             switch (option.selectResult) {
-                case SelectResult.Many_Row_Many_Column: return this._service.select({ sync: SyncMode.Sync, selectResult: SelectResult.Many_Row_Many_Column, errorMsg: option.errorMsg, sql, params });
-                case SelectResult.Many_Row_One_Column: return this._service.select({ 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({ 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({ 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({ 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({ sync: SyncMode.Sync, selectResult: SelectResult.One_Row_One_Column_NotSure, errorMsg: option.errorMsg, sql, params });
+                case SelectResult.RS_CS: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.RS_CS, sql, params });
+                case SelectResult.RS_C: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.RS_C, sql, params });
+                case SelectResult.RS_CS_List: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.RS_CS_List, sql, params });
+                case SelectResult.RS_C_List: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.RS_C_List, sql, params });
+                case SelectResult.R_CS_Assert: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.R_CS_Assert, sql, params });
+                case SelectResult.R_C_Assert: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.R_C_Assert, sql, params });
+                case SelectResult.R_CS_NotSure: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.R_CS_NotSure, sql, params });
+                case SelectResult.R_C_NotSure: return this._service.select({ ...option, sync: SyncMode.Sync, selectResult: SelectResult.R_C_NotSure, sql, params });
             }
         }
     }
+    excutePage(option) {
+        option ?? (option = {});
+        option.sync ?? (option.sync = SyncMode.Async);
+        const { where, params } = this._where();
+        const result = {
+            records: [],
+            size: 0,
+            total: 0
+        };
+        let sql = `
+            SELECT
+            ${this._distinct ? 'DISTINCT' : ''} ${this._columns && this._columns.length > 0 ? this._columns.join(',') : this[_columns].map(key => this[_fields][String(key)]?.C3()).join(',')}
+            FROM ${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({
+                ...option,
+                params,
+                sql: sqlCount,
+                sync: SyncMode.Sync,
+                selectResult: SelectResult.R_C_Assert
+            });
+            result.size = calc(result.total)
+                .add(this._pageSize - 1)
+                .div(this._pageSize)
+                .round(0, 2)
+                .over();
+            result.records = this._service.select({
+                ...option,
+                params,
+                sql,
+                sync: SyncMode.Sync,
+                selectResult: SelectResult.RS_CS
+            });
+            return result;
+        }
+        else {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    result.total = await this._service.select({
+                        ...option,
+                        params,
+                        sql: sqlCount,
+                        sync: SyncMode.Async,
+                        selectResult: SelectResult.R_C_Assert
+                    });
+                    result.size = calc(result.total)
+                        .add(this._pageSize - 1)
+                        .div(this._pageSize)
+                        .round(0, 2)
+                        .over();
+                    result.records = await this._service.select({
+                        ...option,
+                        params,
+                        sql,
+                        sync: SyncMode.Async,
+                        selectResult: SelectResult.RS_CS
+                    });
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+    }
     excuteUpdate(option) {
         option ?? (option = {});
         option.sync ?? (option.sync = SyncMode.Async);
@@ -3326,16 +3557,25 @@ class StreamQuery {
         }
         return { where: wheres.join(' '), params: this._param };
     }
-    _(key, value, op, { not = '', name = '' } = {}) {
-        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
-            this._param[this._paramKeys[name]] = value;
+    _(key, value, op, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (value === null
+            || value === undefined
+            || (emptyString(`${value ?? ''}`) && skipEmptyString === true)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName]] = value;
         }
         else {
+            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;
@@ -3348,112 +3588,158 @@ class StreamQuery {
         this._wheres.push(`AND ${this[_fields][String(key1)]?.C2()} ${not} ${op} ${this[_fields][String(key2)]?.C2()} `);
         return this;
     }
-    _between(key, value1, value2, { not = '', name = '' } = {}) {
-        if (name && this._paramKeys[name]) {
-            this._param[this._paramKeys[name][0]] = value1;
-            this._param[this._paramKeys[name][1]] = value2;
+    _between(key, value1, value2, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (value1 === null
+            || value1 === undefined
+            || (emptyString(`${value1 ?? ''}`) && skipEmptyString === true)
+            || value2 === null
+            || value2 === undefined
+            || (emptyString(`${value2 ?? ''}`) && skipEmptyString === true)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName && this._paramKeys[paramName]) {
+            this._param[this._paramKeys[paramName][0]] = value1;
+            this._param[this._paramKeys[paramName][1]] = value2;
         }
         else {
             const [pkey1, pkey2] = [`p${this._prefix}${this._index++}`, `p${this._prefix}${this._index++}`];
             this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} ${not} BETWEEN :${pkey1} AND :${pkey2}`);
             this._param[pkey1] = value1;
             this._param[pkey2] = value2;
-            if (name) {
-                this._paramKeys[name] = [pkey1, pkey2];
+            if (paramName) {
+                this._paramKeys[paramName] = [pkey1, pkey2];
             }
         }
         return this;
     }
-    _in(key, value, { not = '', name = '', force = false } = {}) {
+    _in(key, value, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
         if (value && value.length > 0) {
-            if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
-                this._param[this._paramKeys[name]] = value;
+            if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+                this._param[this._paramKeys[paramName]] = value;
             }
             else {
                 const pkey = `p${this._prefix}${this._index++}`;
                 this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} ${not} IN (:${pkey}) `);
                 this._param[pkey] = value;
-                if (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;
     }
-    _shift(key1, key2, value, op, { not = '', name = '' } = {}) {
-        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
-            this._param[this._paramKeys[name]] = value;
+    _shift(key1, key2, value, op, { not = '', paramName = '', breakExcuteIfSkip = false } = {}) {
+        if (value === null
+            || value === undefined
+            || emptyString(`${value ?? ''}`)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName]] = value;
         }
         else {
             const pkey = `p${this._prefix}${this._index++}`;
             this._wheres.push(`AND (${this[_fields][String(key1)]?.C2()} << 8) + ${this[_fields][String(key2)]?.C2()} ${not} ${op} :${pkey} `);
             this._param[pkey] = value;
-            if (name) {
-                this._paramKeys[name] = pkey;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
             }
         }
         return this;
     }
-    _match(value, keys, { name, not, append } = {}) {
-        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
-            this._param[this._paramKeys[name]] = value;
+    _match(value, keys, { paramName = '', not = '', append = '', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (value === null
+            || value === undefined
+            || emptyString(`${value ?? ''}`)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName]] = value;
         }
         else {
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND 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;
     }
-    _pow(key, value, { name } = {}) {
-        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
-            this._param[this._paramKeys[name]] = value;
+    _pow(key, value, { not = '', paramName = '', breakExcuteIfSkip = false } = {}) {
+        if (value === null
+            || value === undefined
+            || emptyString(`${value ?? ''}`)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName]] = value;
         }
         else {
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND NOT POW(2, ${this[_fields][String(key)]?.C2()}) & :${pkey}`);
+            this._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;
     }
-    _like(key, value, { not = '', left = '', right = '', name = '', op = 'LIKE', force = false } = {}) {
-        if (value !== null && value !== undefined && value !== '') {
-            if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
-                this._param[this._paramKeys[name]] = value;
-            }
-            else {
-                const pkey = `p${this._prefix}${this._index++}`;
-                this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} ${not} ${op} CONCAT('${left}', :${pkey}, '${right}') `);
-                this._param[pkey] = value;
-                if (name) {
-                    this._paramKeys[name] = pkey;
-                }
+    _like(key, value, { not = '', left = '', right = '', paramName = '', op = 'LIKE', skipEmptyString = true, breakExcuteIfSkip = false } = {}) {
+        if (value === null
+            || value === undefined
+            || (emptyString(`${value ?? ''}`) && skipEmptyString === true)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
             }
+            return this;
         }
-        else if (force !== true) {
-            this.if_exec = false;
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName]] = value;
+        }
+        else {
+            const pkey = `p${this._prefix}${this._index++}`;
+            this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} ${not} ${op} CONCAT('${left}', :${pkey}, '${right}') `);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
+            }
         }
         return this;
     }
-    _includes(key, value, { not = '', name = '' } = {}) {
-        if (name !== undefined && this._paramKeys.hasOwnProperty(name)) {
-            this._param[this._paramKeys[name]] = value;
+    _includes(key, value, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfSkip = true } = {}) {
+        if (value === null
+            || value === undefined
+            || (emptyString(`${value ?? ''}`) && skipEmptyString === true)) {
+            if (breakExcuteIfSkip === true) {
+                this.if_exec = false;
+            }
+            return this;
+        }
+        if (paramName !== undefined && this._paramKeys.hasOwnProperty(paramName)) {
+            this._param[this._paramKeys[paramName]] = value;
         }
         else {
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND LOCATE(${this[_fields][String(key)]?.C2()}, :${pkey}) ${not ? '=' : ''}  0`);
+            this._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;
@@ -3927,6 +4213,12 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Object)
 ], StreamQuery.prototype, "excuteSelect", null);
+__decorate([
+    IF_EXEC(null),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], StreamQuery.prototype, "excutePage", null);
 __decorate([
     IF_EXEC(0),
     __metadata("design:type", Function),