baja-lite 1.5.19 → 1.5.20

package/code.js

@@ -86,7 +86,8 @@ console.log(`
         "logicDeleteK"?: "逻辑删除字段名",
         "logicDeleteV"?: "逻辑删除值",如果是字符串需要这样 logicDeleteV: "'0'"
         "NotlogicDeleteV"?: "未逻辑删除值",如果是字符串需要这样 NotlogicDeleteV: "'0'",
-        "skipColumns"?: ["跳过的列名1", "跳过的列名2"]
+        "skipColumns"?: ["跳过的列名1", "跳过的列名2"],
+        "custom"?: (列名:string) => string; 该属性支持为每个数据库列自定义一个名称，例如 字段名为 ci_name 可通过custom改造为 Ci Name
     }
     command是生成命令，这里声明命令同时定义文件生成路径:可用下面的变量替换.同时必须有同名模板.
     路径是相对于项目根目录的
@@ -98,7 +99,7 @@ console.log(`
     **********************-----------
     模板文件
     请在项目根目录的code-template添加模板文件， 按照mustache(标签定义成了[ '<%', '%>' ])进行格式化,支持使用的变量：
-************* 以下假设表名为event_main_info,列名为sku_id，sku_name
+    ************* 以下假设表名为event_main_info,列名为sku_id，sku_name
     title						// 字符串,表的注释
 	
     tableName					// 字符串,event_main_info
@@ -109,7 +110,7 @@ console.log(`
     splitName					// 字符串,event/main/info
     SplitName					// 字符串,event/mainInfo
 	
-    columns						// 数组, 元素格式为{comment:注释,name: sku_id,Name: skuId,NAME: SkuId,Field:表示字段的注解,JSField_name, JSFieldName 分别表示JS的注解,Type:表示JS类型}
+    columns						// 数组, 元素格式为{comment:注释,name: sku_id,Name: skuId,NAME: SkuId,Field:表示字段的注解,JSField_name、JSFieldName 分别表示JS的注解,Type:表示JS类型,custom:自定义列名}
     column_names				// 数组, 元素是列名字符串，格式是 sku_id,sku_name
     ColumnNames					// 数组, 元素是列名字符串，格式是 skuId,skuName
     column_names_join 			// 字符串,列名join的字符串，格式是 "sku_id,sku_name"
@@ -141,12 +142,12 @@ console.log(`
     modelPath					// 模块名称实际就影响访问路径，所以这里会直接拼好controller的模块访问路径，如果模块为空，则该属性就是空字符串,否则是 /模块名称/
 	
     logicDelete					// 逻辑删除的查询条件，可以附加在sql条件的末尾，可能是空的
-    -----
-    命令 table1,table2,table3:模块名称
+    ---------------------------------------------------------------------------------------------------------------
+    .命令 table1,table2,table3:模块名称
     table=. 表示扫描全库表
     :模块名称 可以省略
     -----
-    force: 切换是否覆盖
+    .force: 切换是否覆盖
 `);
 try {
     const outputs = new Set();
@@ -272,6 +273,9 @@ try {
             r.Field = `@Field({${fields.join(',')}})`;
             r.JSField_name = `{${fields.join(',')}, P: '${r.name}'}`;
             r.JSFieldName = `{${fields.join(',')}, P: '${r.Name}'}`;
+            if (configData.custom) {
+                r.custom = configData.custom(r.name);
+            }
             return r;
         });
         conn.release();

package/index.d.ts

@@ -1,7 +1,6 @@
 import 'reflect-metadata';
 export * from './error.js';
 export * from './fn.js';
-export * from './list.js';
 export * from './math.js';
 export * from './object.js';
 export * from './snowflake.js';

package/index.js

@@ -1,7 +1,6 @@
 import 'reflect-metadata';
 export * from './error.js';
 export * from './fn.js';
-export * from './list.js';
 export * from './math.js';
 export * from './object.js';
 export * from './snowflake.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baja-lite",
-  "version": "1.5.19",
+  "version": "1.5.20",
   "description": "some util for self",
   "homepage": "https://github.com/void-soul/baja-lite",
   "repository": {

package/sql.d.ts

@@ -1516,26 +1516,6 @@ declare class StreamQuery<T extends object> {
     eqWith(key1: keyof T, key2: keyof T): this;
     /** AND key1 <> key2 */
     notEqWith(key1: keyof T, key2: keyof T): this;
-    /** AND key REGEXP :regexp */
-    regexp(key: keyof T, regexp: string, { paramName, breakExcuteIfEmpty }?: {
-        paramName?: string | undefined;
-        breakExcuteIfEmpty?: boolean | undefined;
-    }): this;
-    /** AND key NOT REGEXP :regexp */
-    notRegexp(key: keyof T, regexp: string, { paramName, breakExcuteIfEmpty }?: {
-        paramName?: string | undefined;
-        breakExcuteIfEmpty?: boolean | undefined;
-    }): this;
-    /** AND (key1 << 8) + key2 = value */
-    shiftEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
-        paramName?: string | undefined;
-        breakExcuteIfEmpty?: boolean | undefined;
-    }): this;
-    /** AND (key1 << 8) + key2 <> value */
-    shiftNotEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
-        paramName?: string | undefined;
-        breakExcuteIfEmpty?: boolean | undefined;
-    }): this;
     /** AND key > :value */
     grate(key: keyof T, value: string | number, { paramName, breakExcuteIfEmpty }?: {
         paramName?: string | undefined;
@@ -1564,6 +1544,36 @@ declare class StreamQuery<T extends object> {
     lessWith(key1: keyof T, key2: keyof T): this;
     /** AND key1 <= key2 */
     lessEqWith(key1: keyof T, key2: keyof T): this;
+    /** AND key REGEXP :regexp */
+    regexp(key: keyof T, regexp: string, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND key NOT REGEXP :regexp */
+    notRegexp(key: keyof T, regexp: string, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :regexp REGEXP key */
+    regexp2(key: keyof T, regexp: string, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :regexp NOT REGEXP key */
+    notRegexp2(key: keyof T, regexp: string, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND (key1 << 8) + key2 = value */
+    shiftEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND (key1 << 8) + key2 <> value */
+    shiftNotEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
     /** AND key LIKE CONCAT('%', :value, '%') */
     like(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
         paramName?: string | undefined;
@@ -1649,7 +1659,7 @@ declare class StreamQuery<T extends object> {
         breakExcuteIfEmpty?: boolean | undefined;
     }): this;
     /** AND key GLOB :value 注意：GLOB是大小写敏感like,这里不拼接%*/
-    PreciseGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+    preciseGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
         paramName?: string | undefined;
         skipEmptyString?: boolean | undefined;
         breakExcuteIfEmpty?: boolean | undefined;
@@ -1660,6 +1670,102 @@ declare class StreamQuery<T extends object> {
         skipEmptyString?: boolean | undefined;
         breakExcuteIfEmpty?: boolean | undefined;
     }): this;
+    /** AND :value LIKE CONCAT('%', key, '%') */
+    like2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT LIKE CONCAT('%', key, '%') */
+    notLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT LIKE CONCAT('%', key) */
+    leftLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value LIKE CONCAT('%', key) */
+    notLeftLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value LIKE CONCAT(key, '%') */
+    rightLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT LIKE CONCAT(key, '%') */
+    notRightLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value LIKE key 注意：不会拼接% */
+    PreciseLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT LIKE key 注意：不会拼接%*/
+    notPreciseLike2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value GLOB CONCAT('%', key, '%') 注意：GLOB是大小写敏感like */
+    glob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT GLOB CONCAT('%', key, '%') 注意：GLOB是大小写敏感like*/
+    notGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value GLOB CONCAT('%', key) 注意：GLOB是大小写敏感like*/
+    leftGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT GLOB CONCAT('%', key) 注意：GLOB是大小写敏感like*/
+    notLeftGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value GLOB CONCAT(key, '%') 注意：GLOB是大小写敏感like*/
+    rightGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT GLOB CONCAT(key, '%') 注意：GLOB是大小写敏感like*/
+    notRightGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value GLOB key 注意：GLOB是大小写敏感like,这里不拼接%*/
+    preciseGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND :value NOT GLOB key 注意：GLOB是大小写敏感like,这里不拼接%*/
+    notPreciseGlob2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
     /** AND key IN (:value) */
     in(key: keyof T, value: Array<string | number>, { paramName, breakExcuteIfEmpty }?: {
         paramName?: string | undefined;
@@ -1712,6 +1818,16 @@ declare class StreamQuery<T extends object> {
         paramName?: string | undefined;
         breakExcuteIfEmpty?: boolean | undefined;
     }): this;
+    /** AND POW(2, :value) & key */
+    pow2(key: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND NOT POW(2, :value) & key */
+    notPow2(key: keyof T, value: number, { paramName, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
     /** AND POW(2, key1) & key2 */
     powWith(key: keyof T, values: Array<number | string>, { paramName, breakExcuteIfEmpty }?: {
         paramName?: string | undefined;
@@ -1722,43 +1838,43 @@ declare class StreamQuery<T extends object> {
         paramName?: string | undefined;
         breakExcuteIfEmpty?: boolean | undefined;
     }): this;
-    /** AND MATCH(key1, key2, key3) AGAINST (:value) */
+    /** AND MATCH(key1, key2, key3...) AGAINST (:value) */
     match(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
         paramName?: string | undefined;
         skipEmptyString?: boolean | undefined;
         breakExcuteIfEmpty?: boolean | undefined;
     }): this;
-    /** AND NOT MATCH(key1, key2, key3) AGAINST (:value) */
+    /** AND NOT MATCH(key1, key2, key3...) AGAINST (:value) */
     notMatch(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
         paramName?: string | undefined;
         skipEmptyString?: boolean | undefined;
         breakExcuteIfEmpty?: boolean | undefined;
     }): this;
-    /** AND MATCH(key1, key2, key3) AGAINST (:value) IN BOOLEAN MODE*/
+    /** AND MATCH(key1, key2, key3...) AGAINST (:value) IN BOOLEAN MODE*/
     matchBoolean(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
         paramName?: string | undefined;
         skipEmptyString?: boolean | undefined;
         breakExcuteIfEmpty?: boolean | undefined;
     }): this;
-    /** AND NOT MATCH(key1, key2, key3) AGAINST (:value) IN BOOLEAN MODE */
+    /** AND NOT MATCH(key1, key2, key3...) AGAINST (:value) IN BOOLEAN MODE */
     notMatchBoolean(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
         paramName?: string | undefined;
         skipEmptyString?: boolean | undefined;
         breakExcuteIfEmpty?: boolean | undefined;
     }): this;
-    /** AND MATCH(key1, key2, key3) AGAINST (:value) WITH QUERY EXPANSION*/
+    /** AND MATCH(key1, key2, key3...) AGAINST (:value) WITH QUERY EXPANSION*/
     matchQuery(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
         paramName?: string | undefined;
         skipEmptyString?: boolean | undefined;
         breakExcuteIfEmpty?: boolean | undefined;
     }): this;
-    /** AND NOT MATCH(key1, key2, key3) AGAINST (:value) WITH QUERY EXPANSION*/
+    /** AND NOT MATCH(key1, key2, key3...) AGAINST (:value) WITH QUERY EXPANSION*/
     notMatchQuery(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
         paramName?: string | undefined;
         skipEmptyString?: boolean | undefined;
         breakExcuteIfEmpty?: boolean | undefined;
     }): this;
-    /** AND NOT LOCATE(key, :value) > 0 */
+    /** AND LOCATE(key, :value) > 0 */
     includes(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
         paramName?: string | undefined;
         skipEmptyString?: boolean | undefined;
@@ -1770,6 +1886,18 @@ declare class StreamQuery<T extends object> {
         skipEmptyString?: boolean | undefined;
         breakExcuteIfEmpty?: boolean | undefined;
     }): this;
+    /** AND LOCATE(:value, key) > 0 */
+    includes2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
+    /** AND NOT LOCATE(:value, key) = 0 */
+    notIncludes2(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfEmpty?: boolean | undefined;
+    }): this;
     /** AND FIND_IN_SET(:value, key) */
     findInSet(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfEmpty }?: {
         paramName?: string | undefined;
@@ -1784,6 +1912,14 @@ declare class StreamQuery<T extends object> {
     }): this;
     and(fn: StreamQuery<T> | ((stream: StreamQuery<T>) => boolean | void)): this;
     or(fn: StreamQuery<T> | ((stream: StreamQuery<T>) => boolean | void)): this;
+    /**
+     * sql WHERE 查询语句拼接：注意若有JOIN，需要写明别名。本表别名为t.例如:
+     * ```
+     * where('t.name > :name', {name: 1});
+     * where('(t.name > :name OR t.name <> :name)', {name: 1});
+     * ```
+     */
+    where(sql: string, param?: Record<string, any>): this;
     /** SET key = IFNULL(key, 0) + :value */
     incr(key: keyof T, value?: number): this;
     /** GROUP BY key1, key2, ... */
@@ -1819,8 +1955,16 @@ declare class StreamQuery<T extends object> {
         groupName?: string;
     }): this;
     select(...key: (keyof T)[]): this;
+    /**
+     * sql查询语句拼接：注意若有JOIN，需要写明别名。本表别名为t.例如:
+     * ```
+     * select2('t.name, t.age, ISNULL(t.type, :type)', {type: 1});
+     * select2('MAX(t.age) MAXAge');
+     * ```
+     */
     select2(sql: string, param?: Record<string, any>): this;
     update(key: keyof T, value: T[keyof T]): this;
+    /** update语句拼接：注意若有JOIN，需要写明别名。本表别名为t */
     update2(sql: string, param?: Record<string, any>): this;
     updateT(t: Partial<T>): this;
     /** SET key = REPLACE(key, :valueToFind,  :valueToReplace) */
@@ -1904,6 +2048,7 @@ declare class StreamQuery<T extends object> {
     }): number;
     private _where;
     private _;
+    private _2;
     private __;
     private _null;
     private _key;
@@ -1913,8 +2058,11 @@ declare class StreamQuery<T extends object> {
     private _shift;
     private _match;
     private _pow;
+    private _pow2;
     private _like;
+    private _like2;
     private _includes;
+    private _includes2;
 }
 /**
  获取REDIS客户端，

package/sql.js

@@ -3497,7 +3497,7 @@ class StreamQuery {
                     const paramKeys = {};
                     for (const [key, value] of Object.entries(t)) {
                         const pkey = `p${this._prefix}${this._index++}`;
-                        this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} = :${pkey} `);
+                        this._wheres.push(`AND t.${this[_fields][String(key)]?.C2()} = :${pkey} `);
                         this._param[pkey] = value;
                         if (paramName) {
                             paramKeys[key] = pkey;
@@ -3521,14 +3521,6 @@ class StreamQuery {
     eqWith(key1, key2) { return this._key(key1, key2, '='); }
     /** AND key1 <> key2 */
     notEqWith(key1, key2) { return this._key(key1, key2, '<>'); }
-    /** AND key REGEXP :regexp */
-    regexp(key, regexp, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, breakExcuteIfEmpty }); }
-    /** AND key NOT REGEXP :regexp */
-    notRegexp(key, regexp, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, not: 'NOT', breakExcuteIfEmpty }); }
-    /** AND (key1 << 8) + key2 = value */
-    shiftEq(key1, key2, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._shift(key1, key2, value, '=', { paramName, breakExcuteIfEmpty }); }
-    /** AND (key1 << 8) + key2 <> value */
-    shiftNotEq(key1, key2, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._shift(key1, key2, value, '<>', { paramName, breakExcuteIfEmpty }); }
     /** AND key > :value */
     grate(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._(key, value, '>', { paramName, skipEmptyString: true, breakExcuteIfEmpty }); }
     /** AND key >= :value */
@@ -3545,6 +3537,18 @@ class StreamQuery {
     lessWith(key1, key2) { return this._key(key1, key2, '<'); }
     /** AND key1 <= key2 */
     lessEqWith(key1, key2) { return this._key(key1, key2, '<='); }
+    /** AND key REGEXP :regexp */
+    regexp(key, regexp, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, breakExcuteIfEmpty }); }
+    /** AND key NOT REGEXP :regexp */
+    notRegexp(key, regexp, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, not: 'NOT', breakExcuteIfEmpty }); }
+    /** AND :regexp REGEXP key */
+    regexp2(key, regexp, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._2(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, breakExcuteIfEmpty }); }
+    /** AND :regexp NOT REGEXP key */
+    notRegexp2(key, regexp, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._2(key, regexp, 'REGEXP', { paramName, skipEmptyString: true, not: 'NOT', breakExcuteIfEmpty }); }
+    /** AND (key1 << 8) + key2 = value */
+    shiftEq(key1, key2, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._shift(key1, key2, value, '=', { paramName, breakExcuteIfEmpty }); }
+    /** AND (key1 << 8) + key2 <> value */
+    shiftNotEq(key1, key2, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._shift(key1, key2, value, '<>', { paramName, breakExcuteIfEmpty }); }
     /** AND key LIKE CONCAT('%', :value, '%') */
     like(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfEmpty }); }
     /** AND key NOT LIKE CONCAT('%', :value, '%') */
@@ -3574,9 +3578,41 @@ class StreamQuery {
     /** AND key NOT GLOB CONCAT(:value, '%') 注意：GLOB是大小写敏感like*/
     notRightGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfEmpty, op: 'GLOB' }); }
     /** AND key GLOB :value 注意：GLOB是大小写敏感like,这里不拼接%*/
-    PreciseGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfEmpty, op: 'GLOB' }); }
+    preciseGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, breakExcuteIfEmpty, op: 'GLOB' }); }
     /** AND key NOT GLOB :value 注意：GLOB是大小写敏感like,这里不拼接%*/
     notPreciseGlob(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfEmpty, op: 'GLOB' }); }
+    /** AND :value LIKE CONCAT('%', key, '%') */
+    like2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfEmpty }); }
+    /** AND :value NOT LIKE CONCAT('%', key, '%') */
+    notLike2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfEmpty }); }
+    /** AND :value NOT LIKE CONCAT('%', key) */
+    leftLike2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfEmpty }); }
+    /** AND :value LIKE CONCAT('%', key) */
+    notLeftLike2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfEmpty }); }
+    /** AND :value LIKE CONCAT(key, '%') */
+    rightLike2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfEmpty }); }
+    /** AND :value NOT LIKE CONCAT(key, '%') */
+    notRightLike2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfEmpty }); }
+    /** AND :value LIKE key 注意：不会拼接% */
+    PreciseLike2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, breakExcuteIfEmpty }); }
+    /** AND :value NOT LIKE key 注意：不会拼接%*/
+    notPreciseLike2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfEmpty }); }
+    /** AND :value GLOB CONCAT('%', key, '%') 注意：GLOB是大小写敏感like */
+    glob2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, left: '%', right: '%', breakExcuteIfEmpty, op: 'GLOB' }); }
+    /** AND :value NOT GLOB CONCAT('%', key, '%') 注意：GLOB是大小写敏感like*/
+    notGlob2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, left: '%', right: '%', not: 'NOT', breakExcuteIfEmpty, op: 'GLOB' }); }
+    /** AND :value GLOB CONCAT('%', key) 注意：GLOB是大小写敏感like*/
+    leftGlob2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, left: '%', breakExcuteIfEmpty, op: 'GLOB' }); }
+    /** AND :value NOT GLOB CONCAT('%', key) 注意：GLOB是大小写敏感like*/
+    notLeftGlob2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, left: '%', not: 'NOT', breakExcuteIfEmpty, op: 'GLOB' }); }
+    /** AND :value GLOB CONCAT(key, '%') 注意：GLOB是大小写敏感like*/
+    rightGlob2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, right: '%', breakExcuteIfEmpty, op: 'GLOB' }); }
+    /** AND :value NOT GLOB CONCAT(key, '%') 注意：GLOB是大小写敏感like*/
+    notRightGlob2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, right: '%', not: 'NOT', breakExcuteIfEmpty, op: 'GLOB' }); }
+    /** AND :value GLOB key 注意：GLOB是大小写敏感like,这里不拼接%*/
+    preciseGlob2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, breakExcuteIfEmpty, op: 'GLOB' }); }
+    /** AND :value NOT GLOB key 注意：GLOB是大小写敏感like,这里不拼接%*/
+    notPreciseGlob2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._like2(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfEmpty, op: 'GLOB' }); }
     /** AND key IN (:value) */
     in(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._in(key, value, { paramName, breakExcuteIfEmpty }); }
     /** AND key NOT IN (:value) */
@@ -3591,12 +3627,12 @@ class StreamQuery {
     isNotNULL(key) { return this._null(key, 'NOT'); }
     /** AND (key IS NULL OR key = '') */
     isEmpty(key) {
-        this._wheres.push(`AND (${this[_fields][String(key)]?.C2()} IS NULL OR ${this[_fields][String(key)]?.C2()} = '')`);
+        this._wheres.push(`AND (t.${this[_fields][String(key)]?.C2()} IS NULL OR t.${this[_fields][String(key)]?.C2()} = '')`);
         return this;
     }
     /** AND key IS NOT NULL AND key <> ''*/
     isNotEmpty(key) {
-        this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} IS NOT NULL AND ${this[_fields][String(key)]?.C2()} <> ''`);
+        this._wheres.push(`AND t.${this[_fields][String(key)]?.C2()} IS NOT NULL AND t.${this[_fields][String(key)]?.C2()} <> ''`);
         return this;
     }
     /** AND key BETWEEN :value1 AND :value2 */
@@ -3607,26 +3643,34 @@ class StreamQuery {
     pow(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._pow(key, value, { paramName, breakExcuteIfEmpty }); }
     /** AND NOT POW(2, key) & :value */
     notPow(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._pow(key, value, { paramName, not: 'NOT', breakExcuteIfEmpty }); }
+    /** AND POW(2, :value) & key */
+    pow2(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._pow2(key, value, { paramName, breakExcuteIfEmpty }); }
+    /** AND NOT POW(2, :value) & key */
+    notPow2(key, value, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._pow2(key, value, { paramName, not: 'NOT', breakExcuteIfEmpty }); }
     /** AND POW(2, key1) & key2 */
     powWith(key, values, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, breakExcuteIfEmpty }); }
     /** AND NOT POW(2, key1) & key2 */
     notPowWith(key, values, { paramName = '', breakExcuteIfEmpty = true } = {}) { return this._pow(key, add(...values.map(value => Math.pow(2, +value))), { paramName, not: 'NOT', breakExcuteIfEmpty }); }
-    /** AND MATCH(key1, key2, key3) AGAINST (:value) */
+    /** AND MATCH(key1, key2, key3...) AGAINST (:value) */
     match(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfEmpty }); }
-    /** AND NOT MATCH(key1, key2, key3) AGAINST (:value) */
+    /** AND NOT MATCH(key1, key2, key3...) AGAINST (:value) */
     notMatch(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._match(value, keys, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfEmpty }); }
-    /** AND MATCH(key1, key2, key3) AGAINST (:value) IN BOOLEAN MODE*/
+    /** AND MATCH(key1, key2, key3...) AGAINST (:value) IN BOOLEAN MODE*/
     matchBoolean(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfEmpty, append: 'IN BOOLEAN MODE' }); }
-    /** AND NOT MATCH(key1, key2, key3) AGAINST (:value) IN BOOLEAN MODE */
+    /** AND NOT MATCH(key1, key2, key3...) AGAINST (:value) IN BOOLEAN MODE */
     notMatchBoolean(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfEmpty, not: 'NOT', append: 'IN BOOLEAN MODE' }); }
-    /** AND MATCH(key1, key2, key3) AGAINST (:value) WITH QUERY EXPANSION*/
+    /** AND MATCH(key1, key2, key3...) AGAINST (:value) WITH QUERY EXPANSION*/
     matchQuery(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfEmpty, append: 'WITH QUERY EXPANSION' }); }
-    /** AND NOT MATCH(key1, key2, key3) AGAINST (:value) WITH QUERY EXPANSION*/
+    /** AND NOT MATCH(key1, key2, key3...) AGAINST (:value) WITH QUERY EXPANSION*/
     notMatchQuery(value, keys, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._match(value, keys, { paramName, skipEmptyString, breakExcuteIfEmpty, not: 'NOT', append: 'WITH QUERY EXPANSION' }); }
-    /** AND NOT LOCATE(key, :value) > 0 */
+    /** AND LOCATE(key, :value) > 0 */
     includes(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._includes(key, value, { paramName, skipEmptyString, breakExcuteIfEmpty }); }
     /** AND NOT LOCATE(key, :value) = 0 */
     notIncludes(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._includes(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfEmpty }); }
+    /** AND LOCATE(:value, key) > 0 */
+    includes2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._includes2(key, value, { paramName, skipEmptyString, breakExcuteIfEmpty }); }
+    /** AND NOT LOCATE(:value, key) = 0 */
+    notIncludes2(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) { return this._includes2(key, value, { paramName, skipEmptyString, not: 'NOT', breakExcuteIfEmpty }); }
     /** AND FIND_IN_SET(:value, key) */
     findInSet(key, value, { paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) {
         if (value === null
@@ -3642,7 +3686,7 @@ class StreamQuery {
         }
         else {
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND FIND_IN_SET(:${pkey}, ${this[_fields][String(key)]?.C2()})`);
+            this._wheres.push(`AND FIND_IN_SET(:${pkey}, t.${this[_fields][String(key)]?.C2()})`);
             this._param[pkey] = value;
             if (paramName) {
                 this._paramKeys[paramName] = pkey;
@@ -3665,7 +3709,7 @@ class StreamQuery {
         }
         else {
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND FIND_IN_SET(${this[_fields][String(key)]?.C2()}, :${pkey})`);
+            this._wheres.push(`AND FIND_IN_SET(t.${this[_fields][String(key)]?.C2()}, :${pkey})`);
             this._param[pkey] = value;
             if (paramName) {
                 this._paramKeys[paramName] = pkey;
@@ -3699,51 +3743,73 @@ class StreamQuery {
         }
         return this;
     }
+    /**
+     * sql WHERE 查询语句拼接：注意若有JOIN，需要写明别名。本表别名为t.例如:
+     * ```
+     * where('t.name > :name', {name: 1});
+     * where('(t.name > :name OR t.name <> :name)', {name: 1});
+     * ```
+     */
+    where(sql, param) {
+        this._wheres.push(`AND ${sql}`);
+        if (param) {
+            Object.assign(this._param, param);
+        }
+        return this;
+    }
     /** SET key = IFNULL(key, 0) + :value */
     incr(key, value = 1) {
         const pkey = `p${this._prefix}${this._index++}`;
         const keyName = this[_fields][String(key)]?.C2();
-        this._updateColumns.push(`${keyName} = IFNULL(${keyName}, 0) + :${pkey}`);
+        this._updateColumns.push(`t.${keyName} = IFNULL(t.${keyName}, 0) + :${pkey}`);
         this._param[pkey] = value;
         return this;
     }
     /** GROUP BY key1, key2, ... */
-    groupBy(...keys) { this._groups.push(...keys.map(key => `${this[_fields][String(key)]?.C2()}`)); return this; }
+    groupBy(...keys) { this._groups.push(...keys.map(key => `t.${this[_fields][String(key)]?.C2()}`)); return this; }
     /** GROUP BY key1, key2, ... */
-    groupBy2(...keys) { this._groups.push(...keys.map(key => `${this[_fields][String(key)]?.C2()}`)); return this; }
+    groupBy2(...keys) { this._groups.push(...keys.map(key => `t.${this[_fields][String(key)]?.C2()}`)); return this; }
     /** ORDER BY key1 ASC, key2 ASC, ... */
-    asc(...keys) { this._orders.push(...keys.map(key => `${this[_fields][String(key)]?.C2()} ASC`)); return this; }
+    asc(...keys) { this._orders.push(...keys.map(key => `t.${this[_fields][String(key)]?.C2()} ASC`)); return this; }
     /** ORDER BY key1 ASC, key2 ASC, ... */
-    asc2(...keys) { this._orders.push(...keys.map(key => `${this[_fields][String(key)]?.C2()} ASC`)); return this; }
+    asc2(...keys) { this._orders.push(...keys.map(key => `t.${this[_fields][String(key)]?.C2()} ASC`)); return this; }
     /** ORDER BY key1 DESC, key2 DESC, ... */
-    desc(...keys) { this._orders.push(...keys.map(key => `${this[_fields][String(key)]?.C2()} DESC`)); return this; }
+    desc(...keys) { this._orders.push(...keys.map(key => `t.${this[_fields][String(key)]?.C2()} DESC`)); return this; }
     /** ORDER BY key1 DESC, key2 DESC, ... */
-    desc2(...keys) { this._orders.push(...keys.map(key => `${this[_fields][String(key)]?.C2()} ASC`)); return this; }
+    desc2(...keys) { this._orders.push(...keys.map(key => `t.${this[_fields][String(key)]?.C2()} ASC`)); return this; }
     /** LIMIT :startRow, :pageSize */
     limit(startRow, pageSize) { this._startRow = startRow; this._pageSize = pageSize; return this; }
     /** LIMIT ((:pageNumber || 1) - 1) * :pageSize, :pageSize */
     page(pageNumber, pageSize) { this._startRow = ((pageNumber || 1) - 1) * pageSize; this._pageSize = pageSize; return this; }
     distinct(on = true) { this._distinct = on; return this; }
     /** COUNT(DISTINCT key) */
-    countDistinct(key, countName) { this._columns.push(`COUNT(DISTINCT ${this[_fields][String(key)]?.C2()}) ${countName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
+    countDistinct(key, countName) { this._columns.push(`COUNT(DISTINCT t.${this[_fields][String(key)]?.C2()}) ${countName || `t.${this[_fields][String(key)]?.C2()}`}`); return this; }
     count(countName) { this._columns.push(`COUNT(1) ${countName ?? 'ct'}`); return this; }
-    sum(key, legName, distinct) { this._columns.push(`SUM(${distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}) ${legName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
-    avg(key, legName, distinct) { this._columns.push(`AVG(${distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}) ${legName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
-    max(key, legName, distinct) { this._columns.push(`MAX(${distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}) ${legName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
-    min(key, legName, distinct) { this._columns.push(`MIN(${distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}) ${legName || `${this[_fields][String(key)]?.C2()}`}`); return this; }
+    sum(key, legName, distinct) { this._columns.push(`SUM(${distinct ? 'DISTINCT' : ''} t.${this[_fields][String(key)]?.C2()}) ${legName || `t.${this[_fields][String(key)]?.C2()}`}`); return this; }
+    avg(key, legName, distinct) { this._columns.push(`AVG(${distinct ? 'DISTINCT' : ''} t.${this[_fields][String(key)]?.C2()}) ${legName || `t.${this[_fields][String(key)]?.C2()}`}`); return this; }
+    max(key, legName, distinct) { this._columns.push(`MAX(${distinct ? 'DISTINCT' : ''} t.${this[_fields][String(key)]?.C2()}) ${legName || `t.${this[_fields][String(key)]?.C2()}`}`); return this; }
+    min(key, legName, distinct) { this._columns.push(`MIN(${distinct ? 'DISTINCT' : ''} t.${this[_fields][String(key)]?.C2()}) ${legName || `t.${this[_fields][String(key)]?.C2()}`}`); return this; }
     /** GROUP_CONCAT([DISTINCT] key [ORDER BY :asc ASC] [ORDER BY :asc DESC] [SEPARATOR :separator]) */
     groupConcat(key, param) {
         this._columns.push(`GROUP_CONCAT(
-            ${param && param.distinct ? 'DISTINCT' : ''} ${this[_fields][String(key)]?.C2()}
-            ${param && param.asc && param.asc.length > 0 ? `ORDER BY ${param.asc.map(i => `${this[_fields][String(i)]?.C2()} ASC`)} ` : ''}
-            ${param && param.desc && param.desc.length > 0 ? `${param && param.asc && param.asc.length > 0 ? '' : 'ORDER BY'} ${param.desc.map(i => `${this[_fields][String(i)]?.C2()} DESC`)} ` : ''}
+            ${param && param.distinct ? 'DISTINCT' : ''} t.${this[_fields][String(key)]?.C2()}
+            ${param && param.asc && param.asc.length > 0 ? `ORDER BY ${param.asc.map(i => `t.${this[_fields][String(i)]?.C2()} ASC`)} ` : ''}
+            ${param && param.desc && param.desc.length > 0 ? `${param && param.asc && param.asc.length > 0 ? '' : 'ORDER BY'} ${param.desc.map(i => `t.${this[_fields][String(i)]?.C2()} DESC`)} ` : ''}
             SEPARATOR '${param && param.separator || ','}'
-            ) ${param && param.groupName || `${this[_fields][String(key)]?.C2()}`}`);
+            ) ${param && param.groupName || `t.${this[_fields][String(key)]?.C2()}`}`);
         return this;
     }
-    select(...key) { this._columns.push(...(key.map(k => this[_fields][String(k)].C3()))); return this; }
+    select(...key) { this._columns.push(...(key.map(k => `t.${this[_fields][String(k)].C3()}`))); return this; }
+    /**
+     * sql查询语句拼接：注意若有JOIN，需要写明别名。本表别名为t.例如:
+     * ```
+     * select2('t.name, t.age, ISNULL(t.type, :type)', {type: 1});
+     * select2('MAX(t.age) MAXAge');
+     * ```
+     */
     select2(sql, param) { this._columns.push(`${sql}`); Object.assign(this._param, param); return this; }
     update(key, value) { this._updates ?? (this._updates = {}); this._updates[this[_fields][String(key)]?.C2()] = value; return this; }
+    /** update语句拼接：注意若有JOIN，需要写明别名。本表别名为t */
     update2(sql, param) { this._updateColumns.push(sql); Object.assign(this._param, param); return this; }
     updateT(t) {
         this._updates ?? (this._updates = {});
@@ -3756,7 +3822,7 @@ class StreamQuery {
     /** SET key = REPLACE(key, :valueToFind,  :valueToReplace) */
     replace(key, valueToFind, valueToReplace) {
         const [pkey1, pkey2] = [`p${this._prefix}${this._index++}`, `p${this._prefix}${this._index++}`];
-        this._updateColumns.push(` ${this[_fields][String(key)]?.C2()} = REPLACE(${this[_fields][String(key)]?.C2()}, :${pkey1}, :${pkey2}) `);
+        this._updateColumns.push(` t.${this[_fields][String(key)]?.C2()} = REPLACE(t.${this[_fields][String(key)]?.C2()}, :${pkey1}, :${pkey2}) `);
         this._param[pkey1] = valueToFind;
         this._param[pkey2] = valueToReplace;
         return this;
@@ -3768,8 +3834,8 @@ class StreamQuery {
         const { where, params } = this._where();
         let sql = `
             SELECT
-            ${this._distinct ? 'DISTINCT' : ''} ${this._columns && this._columns.length > 0 ? this._columns.join(',') : this[_columns].map(key => this[_fields][String(key)]?.C3()).join(',')}
-            FROM ${option.tableName ?? this._service[_tableName]}
+            ${this._distinct ? 'DISTINCT' : ''} ${this._columns && this._columns.length > 0 ? this._columns.join(',') : this[_columns].map(key => `t.${this[_fields][String(key)]?.C3()}`).join(',')}
+            FROM ${option.tableName ?? this._service[_tableName]} t
             ${where ? ' WHERE ' : ''}
             ${where}
             ${this._groups.length > 0 ? `GROUP BY ${this._groups.join(',')} ` : ''}
@@ -3813,8 +3879,8 @@ class StreamQuery {
         };
         let sql = `
             SELECT
-            ${this._distinct ? 'DISTINCT' : ''} ${this._columns && this._columns.length > 0 ? this._columns.join(',') : this[_columns].map(key => this[_fields][String(key)]?.C3()).join(',')}
-            FROM ${option.tableName ?? this._service[_tableName]}
+            ${this._distinct ? 'DISTINCT' : ''} ${this._columns && this._columns.length > 0 ? this._columns.join(',') : this[_columns].map(key => `t.${this[_fields][String(key)]?.C3()}`).join(',')}
+            FROM ${option.tableName ?? this._service[_tableName]} t
             ${where ? ' WHERE ' : ''}
             ${where}
             ${this._groups.length > 0 ? `GROUP BY ${this._groups.join(',')} ` : ''}
@@ -3828,7 +3894,7 @@ class StreamQuery {
         }
         const sqlCount = `
             SELECT COUNT(1)
-            FROM ${option.tableName ?? this._service[_tableName]}
+            FROM ${option.tableName ?? this._service[_tableName]} t
             ${where ? ' WHERE ' : ''}
             ${where}
             ${this._groups.length > 0 ? `GROUP BY ${this._groups.join(',')} ` : ''}
@@ -3894,12 +3960,12 @@ class StreamQuery {
         if (this._updates) {
             for (const [K, V] of Object.entries(this._updates)) {
                 const pkey = `p${this._prefix}${this._index++}`;
-                sets.push(` ${K} = :${pkey} `);
+                sets.push(` t.${K} = :${pkey} `);
                 params[pkey] = V;
             }
         }
         if (sets.length > 0) {
-            const sql = `UPDATE ${option.tableName ?? this._service[_tableName]} SET ${sets.join(',')}
+            const sql = `UPDATE ${option.tableName ?? this._service[_tableName]} t SET ${sets.join(',')}
             ${where ? ' WHERE ' : ''}
             ${where}
             `;
@@ -3918,15 +3984,20 @@ class StreamQuery {
         option ?? (option = {});
         option.sync ?? (option.sync = SyncMode.Async);
         const { where, params } = this._where();
-        // const sql = `DELETE FROM ${option.tableName ?? this._service[_tableName]}
-        //     ${where ? ' WHERE ' : ''}
-        //     ${where}
-        // `;
+        const sql = `DELETE FROM ${option.tableName ?? this._service[_tableName]} t
+            ${where ? ' WHERE ' : ''}
+            ${where}
+        `;
+        // if (option.sync === SyncMode.Async) {
+        //     return this._service.delete({ ...option, sync: SyncMode.Async, whereSql: where, whereParams: params });
+        // } else {
+        //     return this._service.delete({ ...option, sync: SyncMode.Sync, whereSql: where, whereParams: params });
+        // }
         if (option.sync === SyncMode.Async) {
-            return this._service.delete({ ...option, sync: SyncMode.Async, whereSql: where, whereParams: params });
+            return this._service.excute({ ...option, sync: SyncMode.Async, sql, params });
         }
         else {
-            return this._service.delete({ ...option, sync: SyncMode.Sync, whereSql: where, whereParams: params });
+            return this._service.excute({ ...option, sync: SyncMode.Sync, sql, params });
         }
     }
     _where() {
@@ -3969,7 +4040,29 @@ class StreamQuery {
         }
         else {
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} ${not} ${op} :${pkey} `);
+            this._wheres.push(`AND t.${this[_fields][String(key)]?.C2()} ${not} ${op} :${pkey} `);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
+            }
+        }
+        return this;
+    }
+    _2(key, value, op, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) {
+        if (value === null
+            || value === undefined
+            || (emptyString(`${value ?? ''}`) && skipEmptyString)) {
+            if (breakExcuteIfEmpty) {
+                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 :${pkey} ${not} ${op} t.${this[_fields][String(key)]?.C2()}`);
             this._param[pkey] = value;
             if (paramName) {
                 this._paramKeys[paramName] = pkey;
@@ -3991,7 +4084,7 @@ class StreamQuery {
         }
         else {
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND (${keys.map(key => `${this[_fields][String(key)]?.C2()} ${not} ${op} :${pkey} `).join(' OR ')})`);
+            this._wheres.push(`AND (${keys.map(key => `t.${this[_fields][String(key)]?.C2()} ${not} ${op} :${pkey} `).join(' OR ')})`);
             this._param[pkey] = value;
             if (paramName) {
                 this._paramKeys[paramName] = pkey;
@@ -4000,11 +4093,11 @@ class StreamQuery {
         return this;
     }
     _null(key, not = '') {
-        this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} IS ${not} NULL`);
+        this._wheres.push(`AND t.${this[_fields][String(key)]?.C2()} IS ${not} NULL`);
         return this;
     }
     _key(key1, key2, op, not = '') {
-        this._wheres.push(`AND ${this[_fields][String(key1)]?.C2()} ${not} ${op} ${this[_fields][String(key2)]?.C2()} `);
+        this._wheres.push(`AND t.${this[_fields][String(key1)]?.C2()} ${not} ${op} t.${this[_fields][String(key2)]?.C2()} `);
         return this;
     }
     _between(key, value1, value2, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) {
@@ -4025,7 +4118,7 @@ class StreamQuery {
         }
         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._wheres.push(`AND t.${this[_fields][String(key)]?.C2()} ${not} BETWEEN :${pkey1} AND :${pkey2}`);
             this._param[pkey1] = value1;
             this._param[pkey2] = value2;
             if (paramName) {
@@ -4044,7 +4137,7 @@ class StreamQuery {
             }
             else {
                 const pkey = `p${this._prefix}${this._index++}`;
-                this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} ${not} IN (:${pkey}) `);
+                this._wheres.push(`AND t.${this[_fields][String(key)]?.C2()} ${not} IN (:${pkey}) `);
                 this._param[pkey] = value;
                 if (paramName) {
                     this._paramKeys[paramName] = pkey;
@@ -4064,7 +4157,7 @@ class StreamQuery {
             }
             else {
                 const pkey = `p${this._prefix}${this._index++}`;
-                this._wheres.push(`AND :${pkey} ${not} IN (${key.map(k => this[_fields][String(k)]?.C2()).join(',')}) `);
+                this._wheres.push(`AND :${pkey} ${not} IN (${key.map(k => `t.${this[_fields][String(k)]?.C2()}`).join(',')}) `);
                 this._param[pkey] = value;
                 if (paramName) {
                     this._paramKeys[paramName] = pkey;
@@ -4090,7 +4183,7 @@ class StreamQuery {
         }
         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._wheres.push(`AND (t.${this[_fields][String(key1)]?.C2()} << 8) + t.${this[_fields][String(key2)]?.C2()} ${not} ${op} :${pkey} `);
             this._param[pkey] = value;
             if (paramName) {
                 this._paramKeys[paramName] = pkey;
@@ -4112,7 +4205,7 @@ class StreamQuery {
         }
         else {
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND ${not} MATCH(${keys.map(key => this[_fields][String(key)]?.C2()).join(',')}) AGAINST (:${pkey} ${append ?? ''})`);
+            this._wheres.push(`AND ${not} MATCH(${keys.map(key => `t.${this[_fields][String(key)]?.C2()}`).join(',')}) AGAINST (:${pkey} ${append ?? ''})`);
             this._param[pkey] = value;
             if (paramName) {
                 this._paramKeys[paramName] = pkey;
@@ -4134,7 +4227,29 @@ class StreamQuery {
         }
         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, t.${this[_fields][String(key)]?.C2()}) & :${pkey}`);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
+            }
+        }
+        return this;
+    }
+    _pow2(key, value, { not = '', paramName = '', breakExcuteIfEmpty = true } = {}) {
+        if (value === null
+            || value === undefined
+            || emptyString(`${value ?? ''}`)) {
+            if (breakExcuteIfEmpty) {
+                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, :${pkey}) & t.${this[_fields][String(key)]?.C2()}`);
             this._param[pkey] = value;
             if (paramName) {
                 this._paramKeys[paramName] = pkey;
@@ -4156,7 +4271,29 @@ class StreamQuery {
         }
         else {
             const pkey = `p${this._prefix}${this._index++}`;
-            this._wheres.push(`AND ${this[_fields][String(key)]?.C2()} ${not} ${op} CONCAT('${left}', :${pkey}, '${right}') `);
+            this._wheres.push(`AND t.${this[_fields][String(key)]?.C2()} ${not} ${op} CONCAT('${left}', :${pkey}, '${right}') `);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
+            }
+        }
+        return this;
+    }
+    _like2(key, value, { not = '', left = '', right = '', paramName = '', op = 'LIKE', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) {
+        if (value === null
+            || value === undefined
+            || (emptyString(`${value ?? ''}`) && skipEmptyString)) {
+            if (breakExcuteIfEmpty) {
+                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 :${pkey} ${not} ${op} CONCAT('${left}',t.${this[_fields][String(key)]?.C2()}, '${right}') `);
             this._param[pkey] = value;
             if (paramName) {
                 this._paramKeys[paramName] = pkey;
@@ -4178,7 +4315,29 @@ class StreamQuery {
         }
         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(t.${this[_fields][String(key)]?.C2()}, :${pkey}) ${not ? '=' : '>'}  0`);
+            this._param[pkey] = value;
+            if (paramName) {
+                this._paramKeys[paramName] = pkey;
+            }
+        }
+        return this;
+    }
+    _includes2(key, value, { not = '', paramName = '', skipEmptyString = true, breakExcuteIfEmpty = true } = {}) {
+        if (value === null
+            || value === undefined
+            || (emptyString(`${value ?? ''}`) && skipEmptyString)) {
+            if (breakExcuteIfEmpty) {
+                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(:${pkey}, t.${this[_fields][String(key)]?.C2()}) ${not ? '=' : '>'}  0`);
             this._param[pkey] = value;
             if (paramName) {
                 this._paramKeys[paramName] = pkey;
@@ -4232,75 +4391,87 @@ __decorate([
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", void 0)
-], StreamQuery.prototype, "regexp", null);
+], StreamQuery.prototype, "grate", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", void 0)
-], StreamQuery.prototype, "notRegexp", null);
+], StreamQuery.prototype, "grateEq", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Number, Object]),
+    __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", void 0)
-], StreamQuery.prototype, "shiftEq", null);
+], StreamQuery.prototype, "grateWith", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Number, Object]),
+    __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", void 0)
-], StreamQuery.prototype, "shiftNotEq", null);
+], StreamQuery.prototype, "grateEqWith", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", void 0)
-], StreamQuery.prototype, "grate", null);
+], StreamQuery.prototype, "less", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", void 0)
-], StreamQuery.prototype, "grateEq", null);
+], StreamQuery.prototype, "lessEq", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", void 0)
-], StreamQuery.prototype, "grateWith", null);
+], StreamQuery.prototype, "lessWith", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", void 0)
-], StreamQuery.prototype, "grateEqWith", null);
+], StreamQuery.prototype, "lessEqWith", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:paramtypes", [Object, String, Object]),
     __metadata("design:returntype", void 0)
-], StreamQuery.prototype, "less", null);
+], StreamQuery.prototype, "regexp", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:paramtypes", [Object, String, Object]),
     __metadata("design:returntype", void 0)
-], StreamQuery.prototype, "lessEq", null);
+], StreamQuery.prototype, "notRegexp", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:paramtypes", [Object, String, Object]),
     __metadata("design:returntype", void 0)
-], StreamQuery.prototype, "lessWith", null);
+], StreamQuery.prototype, "regexp2", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:paramtypes", [Object, String, Object]),
     __metadata("design:returntype", void 0)
-], StreamQuery.prototype, "lessEqWith", null);
+], StreamQuery.prototype, "notRegexp2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Number, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "shiftEq", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Number, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "shiftNotEq", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
@@ -4390,13 +4561,109 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", void 0)
-], StreamQuery.prototype, "PreciseGlob", null);
+], StreamQuery.prototype, "preciseGlob", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", void 0)
 ], StreamQuery.prototype, "notPreciseGlob", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "like2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notLike2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "leftLike2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notLeftLike2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "rightLike2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notRightLike2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "PreciseLike2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notPreciseLike2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "glob2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notGlob2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "leftGlob2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notLeftGlob2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "rightGlob2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notRightGlob2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "preciseGlob2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notPreciseGlob2", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
@@ -4469,6 +4736,18 @@ __decorate([
     __metadata("design:paramtypes", [Object, Number, Object]),
     __metadata("design:returntype", void 0)
 ], StreamQuery.prototype, "notPow", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "pow2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notPow2", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
@@ -4529,6 +4808,18 @@ __decorate([
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", void 0)
 ], StreamQuery.prototype, "notIncludes", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "includes2", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "notIncludes2", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),
@@ -4553,6 +4844,12 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
 ], StreamQuery.prototype, "or", null);
+__decorate([
+    IF_PROCEED(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", void 0)
+], StreamQuery.prototype, "where", null);
 __decorate([
     IF_PROCEED(),
     __metadata("design:type", Function),

package/test-mysql.js

@@ -10,7 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { Field, SqlType } from 'baja-lite-field';
 import 'reflect-metadata';
 import { Boot } from './boot.js';
-import { ColumnMode, DB, SqlService } from './sql.js';
+import { ColumnMode, DB, SelectResult, SqlService } from './sql.js';
 class BaseAuditUser {
 }
 __decorate([
@@ -78,12 +78,6 @@ let BaseAuditUserService = class BaseAuditUserService extends SqlService {
 BaseAuditUserService = __decorate([
     DB({ tableName: 'base_audit_user', clz: BaseAuditUser })
 ], BaseAuditUserService);
-function select() {
-    return [];
-}
-function select2() {
-    return [];
-}
 export async function go2() {
     await Boot({
         Mysql: {
@@ -106,10 +100,8 @@ export async function go2() {
         }
     });
     const service = new BaseAuditUserService();
-    const data = await service.selectBatch({ sqlId: 'test.test', params: { realname: '张薇' } });
-    console.log(11, data[0][0]?.userProvinceCode);
-    console.log(11, data[1].length);
-    const dd = select2();
+    const rt = await service.stream().eq('auditId', '100987125344341382').select('labelName').where('audit_id > 0').excuteSelect({ selectResult: SelectResult.R_C_Assert });
+    console.log(rt);
     // const list = await service.transaction<number>({
     //     fn: async conn => {
     //         await service.stream().eq('baseType', '0').in('auditId', ['162400829591265280', '162201628882247680']).excuteSelect();