baja-lite 1.0.4 → 1.0.6

package/cjs/sql.d.ts

@@ -1,6 +1,10 @@
-import 'reflect-metadata';
+import { XML } from './convert-xml';
+import { ArrayList } from './list';
 declare const _daoDBName: unique symbol;
 declare const _tableName: unique symbol;
+declare const _className: unique symbol;
+declare const _ClassName: unique symbol;
+declare const _vueName: unique symbol;
 declare const _ids: unique symbol;
 declare const _columns: unique symbol;
 declare const _columnsNoId: unique symbol;
@@ -10,12 +14,22 @@ declare const _deleteState: unique symbol;
 declare const _transformer: unique symbol;
 declare const _index: unique symbol;
 declare const _def: unique symbol;
+export declare const _sqlCache: unique symbol;
+export declare const _dao: unique symbol;
+export declare const _primaryDB: unique symbol;
 declare const _dbType: unique symbol;
 declare const _sqlite_version: unique symbol;
 declare const _daoConnection: unique symbol;
 declare const _inTransaction: unique symbol;
 declare const _daoDB: unique symbol;
+declare const _sqliteRemoteName: unique symbol;
 declare const _SqlOption: unique symbol;
+export declare const _Hump: unique symbol;
+export declare const _GlobalSqlOption: unique symbol;
+export declare const _EventBus: unique symbol;
+export declare const _path: unique symbol;
+export declare const _fs: unique symbol;
+export declare const logger: import("pino").Logger<never>;
 export declare enum DBType {
     Mysql = 0,
     Sqlite = 1,
@@ -24,6 +38,12 @@ export declare enum DBType {
     Redis = 4,
     RedisLock = 5
 }
+export declare enum MapperIfUndefined {
+    Null = 0,
+    Skip = 1,
+    Zero = 2,
+    EmptyString = 3
+}
 export declare enum SyncMode {
     /** 同步执行 */
     Sync = 0,
@@ -85,16 +105,28 @@ export declare enum TemplateResult {
     NotSureOne = 1,
     /** 返回多条记录 */
     Many = 2,
+    /** 返回多条记录并封装ArrayList */
+    ManyList = 3,
     /** 仅查询记录数量 */
-    Count = 3
+    Count = 4
 }
 export declare enum SelectResult {
-    One_Row_One_Column_Assert = 0,
-    One_Row_One_Column_NotSure = 1,
-    One_Row_Many_Column_Assert = 2,
-    One_Row_Many_Column_NotSure = 3,
-    Many_Row_One_Column = 4,
-    Many_Row_Many_Column = 5
+    /** 一行一列 确定非空 */
+    R_C_Assert = 0,
+    /** 一行一列 可能空 */
+    R_C_NotSure = 1,
+    /** 一行多列 确定非空 */
+    R_CS_Assert = 2,
+    /** 一行多列 可能空 */
+    R_CS_NotSure = 3,
+    /** 多行一列 */
+    RS_C = 4,
+    /** 多行一列并封装ArrayList */
+    RS_C_List = 5,
+    /** 多行多列 */
+    RS_CS = 6,
+    /** 多行多列并封装ArrayList */
+    RS_CS_List = 7
 }
 export declare enum SqlType {
     tinyint = 0,
@@ -132,6 +164,10 @@ export declare enum SqlType {
     multipolygon = 32,
     geometrycollection = 33
 }
+export declare enum ColumnMode {
+    NONE = 0,
+    HUMP = 1
+}
 export declare const SqliteMemory = ":memory:";
 interface MethodOption {
     tableName?: string;
@@ -144,6 +180,12 @@ interface MethodOption {
     /** 调用时，仅在开启事务时需要主动传入,传入方式： */
     conn?: Connection | null;
 }
+export declare const _defOption: {
+    maxDeal: number;
+    skipUndefined: boolean;
+    skipNull: boolean;
+    skipEmptyString: boolean;
+};
 /**
  数据服务注解
  */
@@ -184,7 +226,7 @@ interface ServiceOption {
     ```
     可以继承该接口来约束格式
  */
-interface GlobalSqlOption {
+export interface GlobalSqlOptionForWeb {
     /** 增改忽略Undefined */
     skipUndefined?: boolean;
     /** 增改忽略NULL */
@@ -193,6 +235,59 @@ interface GlobalSqlOption {
     skipEmptyString?: boolean;
     /** 批量增改时，每次执行最多处理的记录数量 */
     maxDeal?: number;
+    SqliteRemote?: {
+        /**
+         ## 单一数据源
+        ```
+        db: 'd:/1.db'
+        ```
+        ## 多数据源：传入多个Mysql2的连接配置
+        ```
+        db: {
+                db1: 'd:/1.db',
+                db2: 'd:/2.db'
+        }
+        ```
+        不支持 `SqliteMemory`
+        */
+        db: Record<string, string> | string;
+        /** 远程SQLITE接口实现，适用于Electron, 采用Ipc 的handel机制实现 */
+        service: SqliteRemoteInterface;
+    };
+    /** 日志等级 */
+    log?: 'trace' | 'debug' | 'info' | 'warn';
+    /**
+     作用与sqlDir类似，不同在于sqlMap`不需要`目录，而是直接指定一个sqlModel对象，对象的格式和sqlDir的文件内容一样。
+     ** 适用于简单使用
+     */
+    sqlMap?: _SqlModel;
+    /**
+     作用与sqlFnDir类似，不同在于sqlFNMap`不需要`目录，而是直接指定一个 Record<string, string>，对象的格式和sqlFnDir的文件内容一样。
+     ** 适用于简单使用
+     */
+    sqlFNMap?: Record<string, string>;
+    /**
+    // 第一个元素=列名，第二个元素是属性路径，
+    [
+        ['dit_id', ['id']], // 列名ditid,对应属性id
+        ['event_id', ['eventMainInfo', 'id']] // 列名event_id对应属性eventMainInfo.id
+    ]
+     */
+    sqlMapperMap?: SqlMappers;
+}
+/**
+ # 全局行为配置文件
+   MYSQL编码： 'utf8mb4', utf8mb4_general_ci'
+ ### `sqlDir?: string;` 数据库查询语句存放目录.存放格式为 export.default 的js、ts， 存放内容满足格式：
+ 
+    ```
+    interface SqlModel {
+        [key: string]: string | ((params: { [k: string]: any }, context: any, isCount?: boolean) => string)
+    }
+    ```
+    可以继承该接口来约束格式
+ */
+export interface GlobalSqlOption extends GlobalSqlOptionForWeb {
     /**
        初始化MYSQL链接 支持多数据源
        ## 单一数据源: 直接传入Mysql2的连接配置
@@ -234,27 +329,6 @@ interface GlobalSqlOption {
        路径 = `SqliteMemory` 将创建内存库
      */
     Sqlite?: Record<string, string> | string;
-    SqliteRemote?: {
-        /**
-         ## 单一数据源
-        ```
-        db: 'd:/1.db'
-        ```
-        ## 多数据源：传入多个Mysql2的连接配置
-        ```
-        db: {
-                db1: 'd:/1.db',
-                db2: 'd:/2.db'
-        }
-        ```
-        不支持 `SqliteMemory`
-        */
-        db: Record<string, string> | string;
-        /** 远程SQLITE接口实现，适用于Electron, 采用Ipc 的handel机制实现 */
-        service: SqliteRemoteInterface;
-    };
-    /** 日志等级 */
-    log?: 'trace' | 'debug' | 'info' | 'warn';
     /**
      ## 日志文件存放路径,该目录下文件名是模块名，例如有一个文件名为 `user.js`,内容为:
      ```
@@ -287,21 +361,26 @@ interface GlobalSqlOption {
     ## 也支持.mu文件,格式略
     */
     sqlDir?: string;
-    /**
-     作用与sqlDir类似，不同在于sqlMap`不需要`目录，而是直接指定一个sqlModel对象，对象的格式和sqlDir的文件内容一样。
-     ** 适用于简单使用
-     */
-    sqlMap?: SqlModel;
     /**
     ## [mustache](https://mustache.github.io/) 编译时的[模板](https://github.com/janl/mustache.js#:~:text=requires%20only%20this%3A-,%7B%7B%3E%20next_more%7D%7D,-Why%3F%20Because%20the)
-      ** 文件名就是模板名
+      ## 文件名就是模板名
      */
     sqlFNDir?: string;
     /**
-     作用与sqlFnDir类似，不同在于sqlFNMap`不需要`目录，而是直接指定一个 Record<string, string>，对象的格式和sqlFnDir的文件内容一样。
-     ** 适用于简单使用
+      ## 映射数据为对象，文件名就是模板名
+    ```
+    // 第一个元素=列名，第二个元素是属性路径，
+    // 该目录下可存放json文件，内容如下
+    //
+    // 可以在查询时使用，优先级高于hump
+    // 例如:
+    [
+        ['dit_id', ['id'], 可选的默认值], // 列名ditid,对应属性id,当未查询返回时，使用默认值
+        ['event_id', ['eventMainInfo', 'id']] // 列名event_id对应属性eventMainInfo.id,当未查询返回时，该属性不存在
+    ]
+    ```
      */
-    sqlFNMap?: Record<string, string>;
+    sqlMapperDir?: string;
     /**
      [REDIS初始化文档](https://github.com/redis/ioredis?tab=readme-ov-file#:~:text=connect%20to%20by%3A-,new%20Redis()%3B,-//%20Connect%20to%20127.0.0.1)
     ```
@@ -326,17 +405,61 @@ interface GlobalSqlOption {
     ```
      */
     Redis?: Record<string, Record<string, any>> | Record<string, any>;
+    /**
+     * `列名与属性映射` 是否自动将下划线转为驼峰，默认NONE，即不转.
+     * 当设置为columnMode.HUMP时，切记将代码生成器中属性名称改对
+     * # 自定义sql查询时，无法自动转换哦,可使用标签转换：
+     *```
+        SELECT
+     *  {{#hump}} seller_sku2, seller_sku {{/hump}}
+     * ```
+     * 转换为
+     *```
+        SELECT
+     *  {{#hump}} seller_sku2 sellerSku2, seller_sku sellerSku {{/hump}}
+     * ```
+     */
+    columnMode?: ColumnMode;
+    /**
+     * 读取查询语句时，是否扫描JS文件？
+     * JS文件需要默认导出一个 SqlModel对象
+     */
+    jsMode?: boolean;
 }
 interface FieldOption extends Object {
     type?: SqlType;
-    name?: string;
+    /** @deprecated 属性名称:TS注解不需要，JS手动注入需要 */
+    P?: string;
     length?: number;
     scale?: number;
     def?: any;
     index?: boolean;
     id?: boolean;
-    logicDelete?: string;
+    logicDelete?: string | number;
+    /** 仅在生成 表时有效 */
     notNull?: boolean;
+    comment?: string;
+    /** sqlite 无效,与UUID只能有一个 */
+    uuidShort?: boolean;
+    /** 与uuidShort只能有一个 */
+    uuid?: boolean;
+}
+interface AField extends FieldOption {
+    /** 安全列名 */
+    C2: () => string;
+    /** @deprecated 数据列名称 */
+    C?: () => string;
+    /** 查询用：b_id bId */
+    C3: () => string;
+    [DBType.Mysql]: () => string;
+    [DBType.Sqlite]: () => string;
+    [DBType.SqliteRemote]: () => string;
+}
+export interface PageQuery<L> {
+    sum?: Record<string, number>;
+    total?: number;
+    size?: number;
+    records?: L[];
 }
 /** sqlite electron服务端需要支持的接口 */
 export interface SqliteRemoteInterface {
@@ -344,13 +467,13 @@ export interface SqliteRemoteInterface {
         affectedRows: number;
         insertId: bigint;
     }>;
-    pluck<One_Row_Many_Column = any>(dbName: string, sql?: string, params?: any): Promise<One_Row_Many_Column | undefined>;
-    get<One_Row_Many_Column = any>(dbName: string, sql?: string, params?: any): Promise<One_Row_Many_Column | undefined>;
+    pluck<One_Row_Many_Column = any>(dbName: string, sql?: string, params?: any): Promise<One_Row_Many_Column | null>;
+    get<One_Row_Many_Column = any>(dbName: string, sql?: string, params?: any): Promise<One_Row_Many_Column | null>;
     raw<Many_Row_One_Column = any>(dbName: string, sql?: string, params?: any): Promise<Many_Row_One_Column[]>;
     query<Many_Row_Many_Column = any>(dbName: string, sql?: string, params?: any): Promise<Many_Row_Many_Column[]>;
     initDB(dbName: string): Promise<void>;
-    backup(dbName: string, name: string): Promise<void>;
-    restore(dbName: string, name: string): Promise<void>;
+    export(dbName: string): Promise<void>;
+    restore(dbName: string, fromName: string): Promise<void>;
 }
 interface Connection {
     [_daoConnection]: any;
@@ -393,6 +516,81 @@ interface Dao {
     restore(sync: SyncMode.Sync, name: string): void;
     restore(sync: SyncMode.Async, name: string): Promise<void>;
 }
+export declare class Mysql implements Dao {
+    [_daoDB]: any;
+    constructor(pool: any);
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    close(sync: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    backup(sync: SyncMode.Sync, name: string): void;
+    backup(sync: SyncMode.Async, name: string): Promise<void>;
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    restore(sync: SyncMode.Sync, name: string): void;
+    restore(sync: SyncMode.Async, name: string): Promise<void>;
+}
+export declare class Sqlite implements Dao {
+    [_daoDB]: any;
+    constructor(db: any);
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    close(sync: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    backup(sync: SyncMode.Sync, name: string): void;
+    backup(sync: SyncMode.Async, name: string): Promise<void>;
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    restore(sync: SyncMode.Sync, name: string): void;
+    restore(sync: SyncMode.Async, name: string): Promise<void>;
+}
+export declare class SqliteRemoteConnection implements Connection {
+    [_daoConnection]: SqliteRemoteInterface;
+    [_sqliteRemoteName]: string;
+    [_inTransaction]: boolean;
+    constructor(conn: SqliteRemoteInterface, name: string);
+    execute(sync: SyncMode.Sync, sql?: string, params?: any): {
+        affectedRows: number;
+        insertId: bigint;
+    };
+    execute(sync: SyncMode.Async, sql?: string, params?: any): Promise<{
+        affectedRows: number;
+        insertId: bigint;
+    }>;
+    pluck<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    pluck<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    get<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T | null;
+    get<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T | null>;
+    raw<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    raw<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    query<T = any>(sync: SyncMode.Sync, sql?: string, params?: any): T[];
+    query<T = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<T[]>;
+    realse(sync: SyncMode.Sync): void;
+    realse(sync: SyncMode.Async): Promise<void>;
+}
+export declare class SqliteRemote implements Dao {
+    [_sqliteRemoteName]: string;
+    [_daoDB]: SqliteRemoteInterface;
+    constructor(db: SqliteRemoteInterface, name: string);
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    close(sync: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    backup(sync: SyncMode.Sync, name: string): void;
+    backup(sync: SyncMode.Async, name: string): Promise<void>;
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    restore(sync: SyncMode.Sync, name: string): void;
+    restore(sync: SyncMode.Async, name: string): Promise<void>;
+}
+export type SqlMapper = ([string, string[], any?])[];
+export type SqlMappers = Record<string, SqlMapper>;
 export type SqlModel = Record<string, string | ((options: {
     ctx: any;
     isCount?: boolean;
@@ -402,10 +600,68 @@ export type SqlModel = Record<string, string | ((options: {
     orderBy?: string;
     [k: string]: any;
 }) => string)>;
+type _SqlModel = Record<string, string | ((options: {
+    ctx: any;
+    isCount?: boolean;
+    isSum?: boolean;
+    limitStart?: number;
+    limitEnd?: number;
+    orderBy?: string;
+    [k: string]: any;
+}) => string) | XML[]>;
+/**
+ * ifUndefined默认是MapperIfUndefined.Skip
+ */
+export declare function flatData<M>(options: {
+    data: any;
+    mapper: string | SqlMapper;
+    mapperIfUndefined?: MapperIfUndefined;
+}): M;
+export declare class SqlCache {
+    private sqlMap;
+    private sqlFNMap;
+    private _read;
+    /**
+     *
+     * ```
+    // 第一个元素=列名，第二个元素是属性路径，
+    [
+        ['dit_id', ['id']], // 列名ditid,对应属性id
+        ['event_id', ['eventMainInfo', 'id']] // 列名event_id对应属性eventMainInfo.id
+    ]
+     * ```
+     * @param am
+     * @param keys
+     */
+    private readResultMap;
+    init(options: {
+        sqlMap?: _SqlModel;
+        sqlDir?: string;
+        sqlFNMap?: Record<string, string>;
+        sqlFNDir?: string;
+        sqlMapperMap?: SqlMappers;
+        sqlMapperDir?: string;
+        jsMode?: boolean;
+    }): Promise<void>;
+    load(sqlids: string[], options: {
+        ctx: any;
+        isCount?: boolean;
+        isSum?: boolean;
+        limitStart?: number;
+        limitEnd?: number;
+        orderBy?: string;
+        [k: string]: any;
+    }): string;
+}
 export declare const Field: (config: FieldOption) => (object: object, propertyName: string) => void;
-export declare const DB: (config: ServiceOption) => <C extends new (...args: any[]) => {}>(constructor: C) => {
+export declare const DB: (config: ServiceOption) => <C extends {
+    new (...args: any[]): {};
+}>(constructor: C) => {
     new (...args: any[]): {
         [_tableName]: string | undefined;
+        [_className]: string | undefined;
+        [_ClassName]: string | undefined;
+        [_vueName]: string | undefined;
         [_daoDBName]: string | undefined;
         [_dbType]: DBType;
         [_sqlite_version]: string | undefined;
@@ -426,8 +682,11 @@ export declare const DB: (config: ServiceOption) => <C extends new (...args: any
         [_transformer]: <L extends Object>(data: L, option?: MethodOption & {
             finalColumns?: Set<string>;
             tempColumns?: Array<string>;
-            def?: boolean;
+            insert?: boolean;
             skipId?: boolean;
+            skipNull?: boolean;
+            skipUndefined?: boolean;
+            skipEmptyString?: boolean;
             onFieldExists?: (K: string, V: any) => void;
         }) => any;
     };
@@ -470,6 +729,9 @@ export declare function DeclareService(clz: any, config: ServiceOption): any;
  */
 export declare class SqlService<T extends object> {
     private [_tableName]?;
+    private [_className]?;
+    private [_ClassName]?;
+    private [_vueName]?;
     private [_daoDBName]?;
     private [_ids]?;
     private [_fields]?;
@@ -482,7 +744,15 @@ export declare class SqlService<T extends object> {
     private [_sqlite_version]?;
     private [_index]?;
     private [_def]?;
-    private [_transformer]?;
+    [_transformer]?: <L = T>(data: Partial<L>, option?: MethodOption & {
+        finalColumns?: Set<string>;
+        insert?: boolean;
+        skipId?: boolean;
+        skipNull?: boolean;
+        skipUndefined?: boolean;
+        skipEmptyString?: boolean;
+        onFieldExists?: (K: string, V: any) => void;
+    }) => Partial<T>;
     private _insert;
     /**
     0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认 `异步`
@@ -505,6 +775,7 @@ export declare class SqlService<T extends object> {
         2. `insertIfNotExists`: 通过主键或者existConditionOtherThanIds字段判断数据是否存在，不存在才插入,存在则不执行
         3. `replace`: 只支持用主键判断, 存在更新, 不存在插入
     11. `existConditionOtherThanIds`: insertIfNotExists时判断同一记录的字段名称，默认情况下按照ID判断，设置existConditionOtherThanIds后，不用id
+    12. `replaceWithDef` replace时，是否带入默认值? 默认true
     ### 返回值是最后一次插入的主键ID，对于自增ID表适用
     1. 如果主键是自增批量操作，且期望返回所有记录的ID，那么需要设置 `option 中的 every = true`,此时效率降低
      * @param {{[P in keyof T]?: T[P]}} data
@@ -522,6 +793,7 @@ export declare class SqlService<T extends object> {
         skipNull?: boolean;
         skipEmptyString?: boolean;
         maxDeal?: number;
+        replaceWithDef?: boolean;
     }): Promise<bigint>;
     insert(option: MethodOption & {
         data: Partial<T>[];
@@ -534,6 +806,7 @@ export declare class SqlService<T extends object> {
         skipNull?: boolean;
         skipEmptyString?: boolean;
         maxDeal?: number;
+        replaceWithDef?: boolean;
     }): Promise<bigint[]>;
     insert(option: MethodOption & {
         data: Partial<T>;
@@ -546,6 +819,7 @@ export declare class SqlService<T extends object> {
         skipNull?: boolean;
         skipEmptyString?: boolean;
         maxDeal?: number;
+        replaceWithDef?: boolean;
     }): bigint;
     insert(option: MethodOption & {
         data: Partial<T>[];
@@ -558,6 +832,7 @@ export declare class SqlService<T extends object> {
         skipNull?: boolean;
         skipEmptyString?: boolean;
         maxDeal?: number;
+        replaceWithDef?: boolean;
     }): bigint[];
     private _update;
     /**
@@ -650,128 +925,143 @@ export declare class SqlService<T extends object> {
     8.  `dao`: 永远不需要传入该值
 
      */
-    template(option: MethodOption & {
-        templateResult?: TemplateResult.AssertOne;
-        id?: string | number | Array<string | number>;
-        where?: Partial<T> | Array<Partial<T>>;
-        mode?: SelectMode;
-        error?: string;
-        columns?: (keyof T)[];
-    }): Promise<T>;
-    template(option: MethodOption & {
+    template<L = T>(option: MethodOption & {
         sync: SyncMode.Sync;
         templateResult?: TemplateResult.AssertOne;
         id?: string | number | Array<string | number>;
-        where?: Partial<T> | Array<Partial<T>>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
         mode?: SelectMode;
         error?: string;
-        columns?: (keyof T)[];
-    }): T;
-    template(option: MethodOption & {
-        sync: SyncMode.Async;
+        columns?: (keyof L)[];
+    }): L;
+    template<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
         templateResult?: TemplateResult.AssertOne;
         id?: string | number | Array<string | number>;
-        where?: Partial<T> | Array<Partial<T>>;
-        mode?: SelectMode;
-        error?: string;
-        columns?: (keyof T)[];
-    }): Promise<T>;
-    template(option: MethodOption & {
-        templateResult: TemplateResult.Count;
-        id?: string | number | Array<string | number>;
-        where?: Partial<T> | Array<Partial<T>>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
         mode?: SelectMode;
         error?: string;
-        columns?: (keyof T)[];
-    }): Promise<number>;
-    template(option: MethodOption & {
+        columns?: (keyof L)[];
+    }): Promise<L>;
+    template<L = T>(option: MethodOption & {
         sync: SyncMode.Sync;
         templateResult: TemplateResult.Count;
         id?: string | number | Array<string | number>;
-        where?: Partial<T> | Array<Partial<T>>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
         mode?: SelectMode;
         error?: string;
-        columns?: (keyof T)[];
+        columns?: (keyof L)[];
     }): number;
-    template(option: MethodOption & {
-        sync: SyncMode.Async;
+    template<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
         templateResult: TemplateResult.Count;
         id?: string | number | Array<string | number>;
-        where?: Partial<T> | Array<Partial<T>>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
         mode?: SelectMode;
         error?: string;
-        columns?: (keyof T)[];
+        columns?: (keyof L)[];
     }): Promise<number>;
-    template(option: MethodOption & {
+    template<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
         templateResult: TemplateResult.NotSureOne;
         id?: string | number | Array<string | number>;
-        where?: Partial<T> | Array<Partial<T>>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
         mode?: SelectMode;
         error?: string;
-        columns?: (keyof T)[];
-    }): Promise<T | null>;
-    template(option: MethodOption & {
-        sync: SyncMode.Sync;
+        columns?: (keyof L)[];
+    }): L | null;
+    template<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
         templateResult: TemplateResult.NotSureOne;
         id?: string | number | Array<string | number>;
-        where?: Partial<T> | Array<Partial<T>>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
         mode?: SelectMode;
         error?: string;
-        columns?: (keyof T)[];
-    }): T | null;
-    template(option: MethodOption & {
-        sync: SyncMode.Async;
-        templateResult: TemplateResult.NotSureOne;
+        columns?: (keyof L)[];
+    }): Promise<L | null>;
+    template<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        templateResult: TemplateResult.Many;
         id?: string | number | Array<string | number>;
-        where?: Partial<T> | Array<Partial<T>>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
         mode?: SelectMode;
         error?: string;
-        columns?: (keyof T)[];
-    }): Promise<T | null>;
-    template(option: MethodOption & {
+        columns?: (keyof L)[];
+    }): L[];
+    template<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
         templateResult: TemplateResult.Many;
         id?: string | number | Array<string | number>;
-        where?: Partial<T> | Array<Partial<T>>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
         mode?: SelectMode;
         error?: string;
-        columns?: (keyof T)[];
-    }): Promise<T[]>;
-    template(option: MethodOption & {
+        columns?: (keyof L)[];
+    }): Promise<L[]>;
+    template<L = T>(option: MethodOption & {
         sync: SyncMode.Sync;
-        templateResult: TemplateResult.Many;
+        templateResult: TemplateResult.ManyList;
         id?: string | number | Array<string | number>;
-        where?: Partial<T> | Array<Partial<T>>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
         mode?: SelectMode;
         error?: string;
-        columns?: (keyof T)[];
-    }): T[];
-    template(option: MethodOption & {
-        sync: SyncMode.Async;
-        templateResult: TemplateResult.Many;
+        columns?: (keyof L)[];
+    }): ArrayList<L>;
+    template<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        templateResult: TemplateResult.ManyList;
         id?: string | number | Array<string | number>;
-        where?: Partial<T> | Array<Partial<T>>;
+        where?: Partial<L> | Array<Partial<L>>;
+        skipUndefined?: boolean;
+        skipNull?: boolean;
+        skipEmptyString?: boolean;
         mode?: SelectMode;
         error?: string;
-        columns?: (keyof T)[];
-    }): Promise<T[]>;
+        columns?: (keyof L)[];
+    }): Promise<ArrayList<L>>;
     private _select;
     /**
     # 自由查询
     0. `sync`: 同步（sqlite）或者异步（mysql、remote），影响返回值类型,默认`异步模式`
-    1. `templateResult`: 返回值类型断言，三种
-        1. One_Row_One_Column_Assert,
-        2. One_Row_One_Column_NotSure,
-        3. One_Row_Many_Column_Assert,
-        4. One_Row_Many_Column_NotSure,
-        5. Many_Row_One_Column,
-        6. Many_Row_Many_Column[默认]
+    1. `templateResult`: 返回值类型断言，6种, R表示行，C表示列，带S表示复数
+        1. R_C_Assert,
+        2. R_C_NotSure,
+        3. R_CS_Assert,
+        4. R_CS_NotSure,
+        5. RS_C,
+        6. RS_C_List
+        7. RS_CS[默认]
+        8. RS_CS_List
     2. `sql` 或者 `sqlid`
     3. `params`
     4. `defValue`: One_Row_One_Column 时有效
-    5. `multiple`: = true 时表示多重sql查询，且每个sql的结果都是相同的resultMode, 此时 `One_Row_One_Column` `Many_Row_One_Column` `One_Row_Many_Column` 将按多重数组解析，`Many_Row_Many_Column` 不变，此时需要自己手动指定返回类型.
-        此时 `One_Row_One_Column` 将返回多个单值组成的数组: `[1, 'ok', 3]`
-             `One_Row_Many_Column` 将返回多个对象组成的数组: `[{ob1}, {ob2}, {ob3}]`
-             `Many_Row_One_Column` 将返回多个单值数组组成的数组: `[[1,2,3],  ['a', 'b']]`
+    5. 禁止一次查询多个语句
     6. `dbName`: 默认使用service注解的`dbName`,可以在某个方法中覆盖
     7. `conn`: 仅在开启事务时需要主动传入,传入示例:
         ```
@@ -780,79 +1070,121 @@ export declare class SqlService<T extends object> {
             });
         ```
     9.  `dao`: 永远不需要传入该值
+    10. `hump`: 是否将列名改为驼峰写法？默认情况下按照全局配置
+    11. `mapper`: 列名-属性 映射工具，优先级高于hump
 
      */
     select<L = T>(option: MethodOption & {
         sync?: SyncMode.Async;
-        selectResult?: SelectResult.Many_Row_Many_Column | SelectResult.Many_Row_One_Column;
+        selectResult?: SelectResult.RS_CS | SelectResult.RS_C;
         sqlId?: string;
         sql?: string;
         params?: Record<string, any>;
         context?: any;
         isCount?: boolean;
         defValue?: L | null;
-        multiple?: boolean;
         errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
     }): Promise<L[]>;
     select<L = T>(option: MethodOption & {
         sync?: SyncMode.Async;
-        selectResult: SelectResult.One_Row_Many_Column_Assert | SelectResult.One_Row_One_Column_Assert;
+        selectResult: SelectResult.RS_CS_List | SelectResult.RS_C_List;
         sqlId?: string;
         sql?: string;
         params?: Record<string, any>;
         context?: any;
         isCount?: boolean;
         defValue?: L | null;
-        multiple?: boolean;
         errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+    }): Promise<ArrayList<L>>;
+    select<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isCount?: boolean;
+        defValue?: L | null;
+        errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
     }): Promise<L>;
     select<L = T>(option: MethodOption & {
         sync?: SyncMode.Async;
-        selectResult: SelectResult.One_Row_Many_Column_NotSure | SelectResult.One_Row_One_Column_NotSure;
+        selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure;
         sqlId?: string;
         sql?: string;
         params?: Record<string, any>;
         context?: any;
         isCount?: boolean;
         defValue?: L | null;
-        multiple?: boolean;
         errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
     }): Promise<L | null>;
     select<L = T>(option: MethodOption & {
         sync: SyncMode.Sync;
-        selectResult?: SelectResult.Many_Row_Many_Column | SelectResult.Many_Row_One_Column;
+        selectResult?: SelectResult.RS_CS | SelectResult.RS_C;
         sqlId?: string;
         sql?: string;
         params?: Record<string, any>;
         context?: any;
         isCount?: boolean;
         defValue?: L | null;
-        multiple?: boolean;
         errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
     }): L[];
     select<L = T>(option: MethodOption & {
         sync: SyncMode.Sync;
-        selectResult: SelectResult.One_Row_Many_Column_Assert | SelectResult.One_Row_One_Column_Assert;
+        selectResult: SelectResult.RS_CS_List | SelectResult.RS_C_List;
         sqlId?: string;
         sql?: string;
         params?: Record<string, any>;
         context?: any;
         isCount?: boolean;
         defValue?: L | null;
-        multiple?: boolean;
         errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+    }): ArrayList<L>;
+    select<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert;
+        sqlId?: string;
+        sql?: string;
+        params?: Record<string, any>;
+        context?: any;
+        isCount?: boolean;
+        defValue?: L | null;
+        errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
     }): L;
     select<L = T>(option: MethodOption & {
         sync: SyncMode.Sync;
-        selectResult: SelectResult.One_Row_Many_Column_NotSure | SelectResult.One_Row_One_Column_NotSure;
+        selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure;
         sqlId?: string;
         sql?: string;
         params?: Record<string, any>;
         context?: any;
         isCount?: boolean;
         defValue?: L | null;
-        multiple?: boolean;
         errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
     }): L | null;
     /**
      # 自由执行sql
@@ -867,7 +1199,7 @@ export declare class SqlService<T extends object> {
              });
          ```
      5.  `dao`: 永远不需要传入该值
- 
+     
       */
     excute<L = T>(option: MethodOption & {
         sync?: SyncMode.Async;
@@ -908,7 +1240,37 @@ export declare class SqlService<T extends object> {
         sync: SyncMode.Sync;
         fn: (conn: Connection) => L;
     }): L | null;
-    stream(option?: MethodOption): StreamQuery<T>;
+    stream<L extends object = T>(option?: MethodOption): StreamQuery<L>;
+    page<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        sqlId: string;
+        context?: any;
+        params: Record<string, any>;
+        pageSize: number;
+        pageNumber: number;
+        limitSelf?: boolean;
+        countSelf?: boolean;
+        sumSelf?: boolean;
+        orderBy?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+    }): Promise<PageQuery<L>>;
+    page<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        sqlId: string;
+        context?: any;
+        params: Record<string, any>;
+        pageSize: number;
+        pageNumber: number;
+        limitSelf?: boolean;
+        countSelf?: boolean;
+        sumSelf?: boolean;
+        orderBy?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+    }): PageQuery<L>;
     /**
     #创建表
     ** `tableName` 表名称
@@ -922,223 +1284,266 @@ export declare class SqlService<T extends object> {
     ** `index` 表的索引，设置方式同ID
      */
     private _createTable;
+    private _matchSqlid;
 }
-declare class StreamCondition<T extends object> {
-    protected _prefix: number;
-    protected _index: number;
-    protected _wheres: string[];
-    protected _andQuerys: StreamCondition<T>[];
-    protected _orQuerys: StreamCondition<T>[];
-    protected _paramKeys: Record<string, string[] | Record<string, string> | string>;
-    protected _param: Record<string, any>;
+declare class StreamQuery<T extends object> {
+    private _prefix;
+    private _index;
+    private _wheres;
+    private _andQuerys;
+    private _orQuerys;
+    private _paramKeys;
+    private _param;
     if_proceed: boolean;
     if_exec: boolean;
-    constructor();
+    private _table;
+    private _distinct;
+    private _columns;
+    private _updates?;
+    private _updateColumns;
+    private _groups;
+    private _orders;
+    private _startRow;
+    private _pageSize;
+    private _service;
+    private [_fields];
+    private [_columns];
+    constructor(table: string, service: SqlService<T>, __fields: Record<string, AField>, __columns: string[]);
     /** 将当前stream重置 */
     reset(): this;
     /** 为下次链条执行提供条件判断：非异步方法跳过，异步方法不执行并返回默认值 */
     if(condition: boolean): this;
-    eq(key: keyof T, value: string | number, { name }?: {
-        name?: string;
+    eq(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    eqT(t: Partial<T>, { name }?: {
-        name?: string;
+    eqT(t: Partial<T>, { name: paramName, breakExcuteIfSkip }?: {
+        name?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notEq(key: keyof T, value: string | number, { name }?: {
-        name?: string;
+    notEq(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
     eqWith(key1: keyof T, key2: keyof T): this;
     notEqWith(key1: keyof T, key2: keyof T): this;
-    regexp(key: keyof T, regexp: string, { name }?: {
-        name?: string;
+    regexp(key: keyof T, regexp: string, { paramName, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notRegexp(key: keyof T, regexp: string, { name }?: {
-        name?: string;
+    notRegexp(key: keyof T, regexp: string, { paramName, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
     /** (key1 << 8) + key2 = value */
-    shiftEq(key1: keyof T, key2: keyof T, value: number, { name }?: {
-        name?: string;
+    shiftEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
     /** (key1 << 8) + key2 <> value */
-    shiftNotEq(key1: keyof T, key2: keyof T, value: number, { name }?: {
-        name?: string;
+    shiftNotEq(key1: keyof T, key2: keyof T, value: number, { paramName, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    grate(key: keyof T, value: string | number, { name }?: {
-        name?: string;
+    grate(key: keyof T, value: string | number, { paramName, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    grateEq(key: keyof T, value: string | number, { name }?: {
-        name?: string;
+    grateEq(key: keyof T, value: string | number, { paramName, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
     grateWith(key1: keyof T, key2: keyof T): this;
     grateEqWith(key1: keyof T, key2: keyof T): this;
-    less(key: keyof T, value: string | number, { name }?: {
-        name?: string;
+    less(key: keyof T, value: string | number, { paramName, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    lessEq(key: keyof T, value: string | number, { name }?: {
-        name?: string;
+    lessEq(key: keyof T, value: string | number, { paramName, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
     lessWith(key1: keyof T, key2: keyof T): this;
     lessEqWith(key1: keyof T, key2: keyof T): this;
-    like(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    like(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notLike(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    notLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    leftLike(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    leftLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notLeftLike(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    notLeftLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    rightLike(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    rightLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notRightLike(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    notRightLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    PreciseLike(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    PreciseLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notPreciseLike(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    notPreciseLike(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    glob(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    glob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notGlob(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    notGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    leftGlob(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    leftGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notLeftGlob(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    notLeftGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    rightGlob(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    rightGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notRightGlob(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    notRightGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    PreciseGlob(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    PreciseGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notPreciseGlob(key: keyof T, value: string | number, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    notPreciseGlob(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    in(key: keyof T, value: Array<string | number>, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    in(key: keyof T, value: Array<string | number>, { paramName, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notIn(key: keyof T, value: Array<string | number>, { name, force }?: {
-        name?: string;
-        force?: boolean;
+    notIn(key: keyof T, value: Array<string | number>, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
     isNULL(key: keyof T): this;
     isNotNULL(key: keyof T): this;
-    between(key: keyof T, value1: string | number, value2: string | number, { name }?: {
-        name?: string;
+    between(key: keyof T, value1: string | number, value2: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notBetween(key: keyof T, value1: string | number, value2: string | number, { name }?: {
-        name?: string;
+    notBetween(key: keyof T, value1: string | number, value2: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    pow(key: keyof T, value: number, { name }?: {
-        name?: string;
+    pow(key: keyof T, value: number, { paramName, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notPow(key: keyof T, value: number, { name }?: {
-        name?: string;
+    notPow(key: keyof T, value: number, { paramName, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    powWith(key: keyof T, values: Array<number | string>, { name }?: {
-        name?: string;
+    powWith(key: keyof T, values: Array<number | string>, { paramName, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notPowWith(key: keyof T, values: Array<number | string>, { name }?: {
-        name?: string;
+    notPowWith(key: keyof T, values: Array<number | string>, { paramName, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
     /** MATCH(key1, key2, key3) AGAINST (value) */
-    match(value: string, keys: (keyof T)[], { name }?: {
-        name?: string;
+    match(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
     /** NOT MATCH(key1, key2, key3) AGAINST (value) */
-    notMatch(value: string, keys: (keyof T)[], { name }?: {
-        name?: string;
+    notMatch(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
     /** MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE*/
-    matchBoolean(value: string, keys: (keyof T)[], { name }?: {
-        name?: string;
+    matchBoolean(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
     /** NOT MATCH(key1, key2, key3) AGAINST (value) IN BOOLEAN MODE */
-    notMatchBoolean(value: string, keys: (keyof T)[], { name }?: {
-        name?: string;
+    notMatchBoolean(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
     /** MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
-    matchQuery(value: string, keys: (keyof T)[], { name }?: {
-        name?: string;
+    matchQuery(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
     /** NOT MATCH(key1, key2, key3) AGAINST (value) WITH QUERY EXPANSION*/
-    notMatchQuery(value: string, keys: (keyof T)[], { name }?: {
-        name?: string;
+    notMatchQuery(value: string, keys: (keyof T)[], { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    includes(key: keyof T, value: string | number, { name }?: {
-        name?: string;
+    includes(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    notIncludes(key: keyof T, value: string | number, { name }?: {
-        name?: string;
+    notIncludes(key: keyof T, value: string | number, { paramName, skipEmptyString, breakExcuteIfSkip }?: {
+        paramName?: string | undefined;
+        skipEmptyString?: boolean | undefined;
+        breakExcuteIfSkip?: boolean | undefined;
     }): this;
-    and(fn: (stream: StreamCondition<T>) => boolean | void): this;
-    or(fn: (stream: StreamCondition<T>) => boolean | void): this;
-    protected where(): {
-        where: string;
-        params: Record<string, any>;
-    };
-    private _;
-    private _null;
-    private _key;
-    private _between;
-    private _in;
-    private _shift;
-    private _match;
-    private _pow;
-    private _like;
-    private _includes;
-}
-declare class StreamBuild<T extends object> extends StreamCondition<T> {
-    protected _table: string;
-    protected _distinct: boolean;
-    protected _columns: string[];
-    protected _updates?: Partial<T>;
-    protected _updateColumns: string[];
-    protected _groups: (keyof T)[];
-    protected _orders: string[];
-    protected _startRow: number;
-    protected _pageSize: number;
-    constructor(table: string);
-    /** 将当前stream重置 */
-    reset(): this;
-    groupBy(key: keyof T): this;
+    and(fn: StreamQuery<T> | ((stream: StreamQuery<T>) => boolean | void)): this;
+    or(fn: StreamQuery<T> | ((stream: StreamQuery<T>) => boolean | void)): this;
+    groupBy(...keys: (keyof T)[]): this;
+    groupBy2(...keys: string[]): this;
     asc(...keys: (keyof T)[]): this;
+    asc2(...keys: string[]): this;
     desc(...keys: (keyof T)[]): this;
+    desc2(...keys: string[]): this;
     limit(startRow: number, pageSize: number): this;
     page(pageNumber: number, pageSize: number): this;
     table(_table: string): this;
     distinct(on?: boolean): this;
-    count(key: keyof T, countName?: string, distinct?: boolean): this;
+    countDistinct(key: keyof T, countName?: string): this;
+    count(countName?: string): this;
     sum(key: keyof T, legName?: string, distinct?: boolean): this;
     avg(key: keyof T, legName?: string, distinct?: boolean): this;
     max(key: keyof T, legName?: string, distinct?: boolean): this;
@@ -1150,60 +1555,111 @@ declare class StreamBuild<T extends object> extends StreamCondition<T> {
         desc?: (keyof T)[];
         groupName?: string;
     }): this;
-    selectColumn(...key: (keyof T)[]): this;
-    updateColumn(key: keyof T, value: T[keyof T]): this;
+    select(...key: (keyof T)[]): this;
+    select2(sql: string, param?: Record<string, any>): this;
+    update(key: keyof T, value: T[keyof T]): this;
+    update2(sql: string, param?: Record<string, any>): this;
     updateT(t: Partial<T>): this;
     replace(key: keyof T, valueToFind: T[keyof T], valueToReplace: T[keyof T]): this;
-}
-declare class StreamQuery<T extends object> extends StreamBuild<T> {
-    private _service;
-    constructor(table: string, service: SqlService<T>);
-    select<L = T>(option: {
+    excuteSelect<L = T>(option?: MethodOption & {
         sync?: SyncMode.Async;
-        selectResult: SelectResult.Many_Row_Many_Column | SelectResult.Many_Row_One_Column;
+        selectResult?: SelectResult.RS_CS | SelectResult.RS_C;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
     }): Promise<L[]>;
-    select<L = T>(option: {
+    excuteSelect<L = T>(option?: MethodOption & {
         sync?: SyncMode.Async;
-        selectResult: SelectResult.One_Row_Many_Column_Assert | SelectResult.One_Row_One_Column_Assert;
+        selectResult?: SelectResult.RS_CS_List | SelectResult.RS_C_List;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+    }): Promise<ArrayList<L>>;
+    excuteSelect<L = T>(option: MethodOption & {
+        sync?: SyncMode.Async;
+        selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert;
         errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
     }): Promise<L>;
-    select<L = T>(option: {
+    excuteSelect<L = T>(option: MethodOption & {
         sync?: SyncMode.Async;
-        selectResult: SelectResult.One_Row_Many_Column_NotSure | SelectResult.One_Row_One_Column_NotSure;
+        selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
     }): Promise<L | null>;
-    select<L = T>(option: {
+    excuteSelect<L = T>(option: MethodOption & {
         sync: SyncMode.Sync;
-        selectResult: SelectResult.Many_Row_Many_Column | SelectResult.Many_Row_One_Column;
+        selectResult: SelectResult.RS_CS | SelectResult.RS_C;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
     }): L[];
-    select<L = T>(option: {
+    excuteSelect<L = T>(option: MethodOption & {
+        sync: SyncMode.Sync;
+        selectResult: SelectResult.RS_CS_List | SelectResult.RS_C_List;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+    }): ArrayList<L>;
+    excuteSelect<L = T>(option: MethodOption & {
         sync: SyncMode.Sync;
-        selectResult: SelectResult.One_Row_Many_Column_Assert | SelectResult.One_Row_One_Column_Assert;
+        selectResult: SelectResult.R_CS_Assert | SelectResult.R_C_Assert;
         errorMsg?: string;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
     }): L;
-    select<L = T>(option: {
+    excuteSelect<L = T>(option: MethodOption & {
         sync: SyncMode.Sync;
-        selectResult: SelectResult.One_Row_Many_Column_NotSure | SelectResult.One_Row_One_Column_NotSure;
+        selectResult: SelectResult.R_CS_NotSure | SelectResult.R_C_NotSure;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
     }): L | null;
-    update(option: {
+    excutePage<L = T>(option?: MethodOption & {
+        sync?: SyncMode;
+        hump?: boolean;
+        mapper?: string | SqlMapper;
+        mapperIfUndefined?: MapperIfUndefined;
+    }): PageQuery<L> | Promise<PageQuery<L>>;
+    excuteUpdate(option?: MethodOption & {
         sync?: SyncMode.Async;
     }): Promise<number>;
-    update(option: {
+    excuteUpdate(option: MethodOption & {
         sync: SyncMode.Sync;
     }): number;
-    delete(option: {
+    excuteDelete(option?: MethodOption & {
         sync?: SyncMode.Async;
     }): Promise<number>;
-    delete(option: {
+    excuteDelete(option: MethodOption & {
         sync: SyncMode.Sync;
     }): number;
+    private _where;
+    private _;
+    private _null;
+    private _key;
+    private _between;
+    private _in;
+    private _shift;
+    private _match;
+    private _pow;
+    private _like;
+    private _includes;
 }
 /**
  获取REDIS客户端，
  # [查看库的API](https://github.com/redis/ioredis?tab=readme-ov-file)
  # [REDIS API](http://doc.redisfans.com/)
  REDIS 的API 可以直接用，将方法名转为小写
+ ```
+ // 设置<Redis>来获得代码提示
+ getRedisDB<Redis>('').exists(?)
+ ```
  */
-export declare function getRedisDB(db?: string): any;
+export declare function getRedisDB<T = any>(db?: string): T;
 /**
  redlock
  */
@@ -1223,7 +1679,7 @@ export declare function excuteWithLock<T>(config: {
     lockMaxActive?: number;
     /** 单个锁多少【毫秒】后自动释放?默认：60*1000MS  */
     lockMaxTime?: number;
-}, fn__: () => Promise<T>): Promise<any>;
+}, fn__: () => Promise<T>): Promise<T>;
 /** 与缓存共用时，需要在缓存之前:有缓存则返回缓存,否则加锁执行并缓存,后续队列全部返回缓存,跳过执行 */
 export declare function MethodLock<T = any>(config: {
     /** 返回缓存key,参数=方法的参数[注意：必须和主方法的参数数量、完全一致，同时会追加一个当前用户对象]+当前用户对象，可以用来清空缓存。 */
@@ -1262,5 +1718,4 @@ export declare function MethodCache<T = any>(config: {
     /** 随着当前用户sesion的清空而一起清空 */
     clearWithSession?: boolean;
 }): (target: T, _propertyKey: string, descriptor: PropertyDescriptor) => void;
-export declare const Boot: (options: GlobalSqlOption) => Promise<void>;
 export {};