模块 org.redkale
程序包 org.redkale.source

类 AbstractDataSqlSource

    • 构造器详细资料

      • AbstractDataSqlSource

        public AbstractDataSqlSource()

    • 方法详细资料

      • init

        public void init​(AnyValue conf)
        从接口复制的说明: Service
        该方法必须是可以重复调用， 当reload时需要重复调用init方法 远程模式下该方法会重载成空方法
        指定者:
        init 在接口中 Service
        覆盖:
        init 在类中 AbstractDataSource
        参数:
        conf - 配置参数

      • afterResourceChange

        protected void afterResourceChange()

      • createOrderbySql

        protected String createOrderbySql​(EntityInfo info,
                                  Flipper flipper)
        根据Flipper获取ORDER BY的SQL语句，不存在Flipper或sort字段返回空字符串
        参数:
        info - EntityInfo
        flipper - 翻页对象
        返回:
        String

      • updateOneResourceChange

        protected void updateOneResourceChange​(Properties newProps,
                                       ResourceEvent[] events)

      • updateReadResourceChange

        protected void updateReadResourceChange​(Properties newReadProps,
                                        ResourceEvent[] events)

      • updateWriteResourceChange

        protected void updateWriteResourceChange​(Properties newWriteProps,
                                         ResourceEvent[] events)

      • slowLog

        protected void slowLog​(long startTime,
                       String... sqls)

      • initProperties

        protected void initProperties​(Properties props)

      • readMaxConns

        protected abstract int readMaxConns()

      • writeMaxConns

        protected abstract int writeMaxConns()

      • createTableSqls

        protected <T> String[] createTableSqls​(EntityInfo<T> info)

      • destroy

        public void destroy​(AnyValue config)
        从接口复制的说明: Service
        进程退出时，调用Service销毁 远程模式下该方法会重载成空方法 注意： 在此方法内不能调用MessageClient.sendMessage 方法，因为Application关闭时会先destroy掉MessageClient
        指定者:
        destroy 在接口中 Service
        参数:
        config - 配置参数

      • compile

        public <T> void compile​(Class<T> clazz)
        从接口复制的说明: DataSource
        提取预编译Entity类，主要用于native-image使用
        指定者:
        compile 在接口中 DataSource
        类型参数:
        T - 泛型
        参数:
        clazz - Entity实体类

      • dbtype

        public final String dbtype()

      • autoddl

        public final boolean autoddl()

      • isAsync

        protected abstract boolean isAsync()

      • prepareParamSign

        protected abstract String prepareParamSign​(int index)

      • insertDB

        protected <T> int insertDB​(EntityInfo<T> info,
                           T... entitys)

      • updateEntityDB

        protected <T> int updateEntityDB​(EntityInfo<T> info,
                                 T... entitys)

      • loadEntityInfo

        protected <T> EntityInfo<T> loadEntityInfo​(Class<T> clazz)

      • refreshCache

        public <T> void refreshCache​(Class<T> clazz)
        将entity的对象全部加载到Cache中去，如果clazz没有被@org.redkale.persistence.Cacheable注解则不做任何事
        类型参数:
        T - Entity类泛型
        参数:
        clazz - Entity类

      • insert

        public <T> int insert​(T... entitys)
        新增对象， 必须是Entity对象
        指定者:
        insert 在接口中 DataSource
        类型参数:
        T - Entity类泛型
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数

      • insertAsync

        public <T> CompletableFuture<Integer> insertAsync​(T... entitys)
        从接口复制的说明: DataSource
        新增记录， 多对象必须是同一个Entity类且必须在同一张表中
        指定者:
        insertAsync 在接口中 DataSource
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        CompletableFuture

      • insertCache

        protected <T> int insertCache​(EntityInfo<T> info,
                              T... entitys)

      • delete

        public <T> int delete​(T... entitys)
        删除对象， 必须是Entity对象
        指定者:
        delete 在接口中 DataSource
        类型参数:
        T - Entity类泛型
        参数:
        entitys - Entity对象
        返回:
        删除的数据条数

      • deleteAsync

        public <T> CompletableFuture<Integer> deleteAsync​(T... entitys)
        从接口复制的说明: DataSource
        删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
        等价SQL: DELETE FROM {table} WHERE {primary} IN {getValues.id}
        指定者:
        deleteAsync 在接口中 DataSource
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数CompletableFuture

      • delete

        public <T> int delete​(Class<T> clazz,
                      Serializable... pks)
        从接口复制的说明: DataSource
        删除指定主键值的记录,多主键值必须在同一张表中
        等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
        指定者:
        delete 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pks - 主键值
        返回:
        影响的记录条数

      • deleteAsync

        public <T> CompletableFuture<Integer> deleteAsync​(Class<T> clazz,
                                                  Serializable... pks)
        从接口复制的说明: DataSource
        删除指定主键值的记录,多主键值必须在同一张表中
        等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
        指定者:
        deleteAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pks - 主键值
        返回:
        影响的记录条数CompletableFuture

      • delete

        public <T> int delete​(Class<T> clazz,
                      FilterNode node)
        从接口复制的说明: DataSource
        删除符合过滤条件的记录
        等价SQL: DELETE FROM {table} WHERE {filter node}
        指定者:
        delete 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        影响的记录条数

      • deleteAsync

        public <T> CompletableFuture<Integer> deleteAsync​(Class<T> clazz,
                                                  FilterNode node)
        从接口复制的说明: DataSource
        删除符合过滤条件的记录
        等价SQL: DELETE FROM {table} WHERE {filter node}
        指定者:
        deleteAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        影响的记录条数CompletableFuture

      • delete

        public <T> int delete​(Class<T> clazz,
                      Flipper flipper,
                      FilterNode node)
        从接口复制的说明: DataSource
        删除符合过滤条件且指定最大影响条数的记录
        Flipper中offset字段将被忽略
        等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        delete 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        node - 过滤条件
        返回:
        影响的记录条数

      • deleteAsync

        public <T> CompletableFuture<Integer> deleteAsync​(Class<T> clazz,
                                                  Flipper flipper,
                                                  FilterNode node)
        从接口复制的说明: DataSource
        删除符合过滤条件且指定最大影响条数的记录
        Flipper中offset字段将被忽略
        等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        deleteAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        node - 过滤条件
        返回:
        影响的记录条数CompletableFuture

      • clearTable

        public <T> int clearTable​(Class<T> clazz)
        从接口复制的说明: DataSource
        清空表
        等价SQL: TRUNCATE TABLE {table}
        指定者:
        clearTable 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        返回:
        影响的记录条数 -1表示表不存在

      • clearTable

        public <T> int clearTable​(Class<T> clazz,
                          FilterNode node)
        从接口复制的说明: DataSource
        清空表
        等价SQL: TRUNCATE TABLE {table}
        指定者:
        clearTable 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 分库分表的过滤条件
        返回:
        影响的记录条数 -1表示表不存在

      • clearTableAsync

        public <T> CompletableFuture<Integer> clearTableAsync​(Class<T> clazz,
                                                      FilterNode node)
        从接口复制的说明: DataSource
        清空表
        等价SQL: TRUNCATE TABLE {table}
        指定者:
        clearTableAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 分库分表的过滤条件
        返回:
        影响的记录条数CompletableFuture -1表示表不存在

      • createTable

        public <T> int createTable​(Class<T> clazz,
                           Serializable pk)
        从接口复制的说明: DataSource
        删除表
        等价SQL: DROP TABLE {table}
        指定者:
        createTable 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键
        返回:
        建表结果

      • dropTable

        public <T> int dropTable​(Class<T> clazz,
                         FilterNode node)
        从接口复制的说明: DataSource
        删除表
        等价SQL: DROP TABLE {table}
        指定者:
        dropTable 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        影响的记录条数 -1表示表不存在

      • dropTableAsync

        public <T> CompletableFuture<Integer> dropTableAsync​(Class<T> clazz,
                                                     FilterNode node)
        从接口复制的说明: DataSource
        删除表
        等价SQL: DROP TABLE {table}
        指定者:
        dropTableAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 分库分表的过滤条件
        返回:
        影响的记录条数CompletableFuture -1表示表不存在

      • update

        public <T> int update​(T... entitys)
        更新对象， 必须是Entity对象
        指定者:
        update 在接口中 DataSource
        类型参数:
        T - Entity类泛型
        参数:
        entitys - Entity对象
        返回:
        更新的数据条数

      • updateAsync

        public <T> CompletableFuture<Integer> updateAsync​(T... entitys)
        从接口复制的说明: DataSource
        更新记录， 多对象必须是同一个Entity类且必须在同一张表中
        等价SQL:
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
        ···
        指定者:
        updateAsync 在接口中 DataSource
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

        public <T> int updateColumn​(Class<T> clazz,
                            Serializable pk,
                            String column,
                            Serializable colval)
        根据主键值更新对象的column对应的值， 必须是Entity Class
        指定者:
        updateColumn 在接口中 DataSource
        类型参数:
        T - Entity类的泛型
        参数:
        clazz - Entity类
        pk - 主键值
        column - 过滤字段名
        colval - 过滤字段值
        返回:
        更新的数据条数

      • updateColumnAsync

        public <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz,
                                                        Serializable pk,
                                                        String column,
                                                        Serializable colval)
        从接口复制的说明: DataSource
        更新单个记录的单个字段
        注意：即使字段标记为@Column(updatable=false)也会被更新
        等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
        指定者:
        updateColumnAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键
        column - 待更新的字段名
        colval - 更新值
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

        public <T> int updateColumn​(Class<T> clazz,
                            String column,
                            Serializable colval,
                            FilterNode node)
        根据主键值更新对象的column对应的值， 必须是Entity Class
        指定者:
        updateColumn 在接口中 DataSource
        类型参数:
        T - Entity类的泛型
        参数:
        clazz - Entity类
        column - 过滤字段名
        colval - 过滤字段值
        node - 过滤node 不能为null
        返回:
        更新的数据条数

      • updateColumnAsync

        public <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz,
                                                        String column,
                                                        Serializable colval,
                                                        FilterNode node)
        从接口复制的说明: DataSource
        更新符合过滤条件记录的单个字段
        注意：即使字段标记为@Column(updatable=false)也会被更新
        等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
        指定者:
        updateColumnAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        column - 待更新的字段名
        colval - 更新值
        node - 过滤条件
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

        public <T> int updateColumn​(Class<T> clazz,
                            Serializable pk,
                            ColumnValue... values)
        根据主键值更新对象的多个column对应的值， 必须是Entity Class
        指定者:
        updateColumn 在接口中 DataSource
        类型参数:
        T - Entity类的泛型
        参数:
        clazz - Entity类
        pk - 主键值
        values - 字段值
        返回:
        更新的数据条数

      • updateColumnAsync

        public <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz,
                                                        Serializable pk,
                                                        ColumnValue... values)
        从接口复制的说明: DataSource
        更新指定主键值记录的部分字段
        字段赋值操作选项见 ColumnExpress
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
        指定者:
        updateColumnAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键
        values - 更新字段
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

        public <T> int updateColumn​(Class<T> clazz,
                            FilterNode node,
                            Flipper flipper,
                            ColumnValue... values)
        从接口复制的说明: DataSource
        更新符合过滤条件的记录的指定字段
        Flipper中offset字段将被忽略
        注意：Entity类中标记为@Column(updatable=false)不会被更新
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}
        指定者:
        updateColumn 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        flipper - 翻页对象
        values - 更新字段
        返回:
        影响的记录条数

      • updateColumnAsync

        public <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz,
                                                        FilterNode node,
                                                        Flipper flipper,
                                                        ColumnValue... values)
        从接口复制的说明: DataSource
        更新符合过滤条件的记录的指定字段
        Flipper中offset字段将被忽略
        注意：Entity类中标记为@Column(updatable=false)不会被更新
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}
        指定者:
        updateColumnAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        flipper - 翻页对象
        values - 更新字段
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

        public <T> int updateColumn​(T entity,
                            SelectColumn selects)
        从接口复制的说明: DataSource
        更新单个记录的指定字段
        注意：Entity类中标记为@Column(updatable=false)不会被更新
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
        指定者:
        updateColumn 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        entity - 待更新的Entity对象
        selects - 指定字段
        返回:
        影响的记录条数

      • updateColumnAsync

        public <T> CompletableFuture<Integer> updateColumnAsync​(T entity,
                                                        SelectColumn selects)
        从接口复制的说明: DataSource
        更新单个记录的指定字段
        注意：Entity类中标记为@Column(updatable=false)不会被更新
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
        指定者:
        updateColumnAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        entity - 待更新的Entity对象
        selects - 指定字段
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

        public <T> int updateColumn​(T entity,
                            FilterNode node,
                            SelectColumn selects)
        从接口复制的说明: DataSource
        更新符合过滤条件记录的指定字段
        注意：Entity类中标记为@Column(updatable=false)不会被更新
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
        指定者:
        updateColumn 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        entity - 待更新的Entity对象
        node - 过滤条件
        selects - 指定字段
        返回:
        影响的记录条数

      • updateColumnAsync

        public <T> CompletableFuture<Integer> updateColumnAsync​(T entity,
                                                        FilterNode node,
                                                        SelectColumn selects)
        从接口复制的说明: DataSource
        更新符合过滤条件记录的指定字段
        注意：Entity类中标记为@Column(updatable=false)不会被更新
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
        指定者:
        updateColumnAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        entity - 待更新的Entity对象
        node - 过滤条件
        selects - 指定字段
        返回:
        影响的记录条数CompletableFuture

      • updateCache

        protected <T> int updateCache​(EntityInfo<T> info,
                              int count,
                              T... entitys)

      • reloadCache

        public <T> int reloadCache​(Class<T> clazz,
                           Serializable... pks)

      • getNumberMap

        public <N extends Number> Map<String,​N> getNumberMap​(Class entityClass,
                                                           FilterNode node,
                                                           FilterFuncColumn... columns)
        从接口复制的说明: DataSource
        获取符合过滤条件记录的聚合结果Map
        等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node}
        如 getNumberMapAsync(User.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
        指定者:
        getNumberMap 在接口中 DataSource
        类型参数:
        N - Number
        参数:
        entityClass - Entity类
        node - 过滤条件
        columns - 聚合字段
        返回:
        聚合结果Map

      • getNumberMapAsync

        public <N extends Number> CompletableFuture<Map<String,​N>> getNumberMapAsync​(Class entityClass,
                                                                                   FilterNode node,
                                                                                   FilterFuncColumn... columns)
        从接口复制的说明: DataSource
        获取符合过滤条件记录的聚合结果Map
        等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node}
        如 getNumberMapAsync(User.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
        指定者:
        getNumberMapAsync 在接口中 DataSource
        类型参数:
        N - Number
        参数:
        entityClass - Entity类
        node - 过滤条件
        columns - 聚合字段
        返回:
        聚合结果Map

      • getNumberResult

        public Number getNumberResult​(Class entityClass,
                              FilterFunc func,
                              Number defVal,
                              String column,
                              FilterNode node)
        从接口复制的说明: DataSource
        获取符合过滤条件记录的聚合结果, 无结果返回默认值
        等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
        如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
        指定者:
        getNumberResult 在接口中 DataSource
        参数:
        entityClass - Entity类
        func - 聚合函数
        defVal - 默认值
        column - 指定字段
        node - 过滤条件
        返回:
        聚合结果

      • getNumberResultAsync

        public CompletableFuture<Number> getNumberResultAsync​(Class entityClass,
                                                      FilterFunc func,
                                                      Number defVal,
                                                      String column,
                                                      FilterNode node)
        从接口复制的说明: DataSource
        获取符合过滤条件记录的聚合结果, 无结果返回默认值
        等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
        如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
        指定者:
        getNumberResultAsync 在接口中 DataSource
        参数:
        entityClass - Entity类
        func - 聚合函数
        defVal - 默认值
        column - 指定字段
        node - 过滤条件
        返回:
        聚合结果CompletableFuture

      • queryColumnMap

        public <T,​K extends Serializable,​N extends Number> Map<K,​N> queryColumnMap​(Class<T> entityClass,
                                                                                             String keyColumn,
                                                                                             FilterFunc func,
                                                                                             String funcColumn,
                                                                                             FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn}
        如 queryColumnMapAsync(User.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM user GROUP BY name
        指定者:
        queryColumnMap 在接口中 DataSource
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        node - 过滤条件
        返回:
        聚合结果Map

      • queryColumnMapAsync

        public <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                     String keyColumn,
                                                                                                                     FilterFunc func,
                                                                                                                     String funcColumn,
                                                                                                                     FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn}
        如 queryColumnMapAsync(User.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM user GROUP BY name
        指定者:
        queryColumnMapAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        node - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        public <T,​K extends Serializable,​N extends Number> Map<K,​N[]> queryColumnMap​(Class<T> entityClass,
                                                                                               ColumnNode[] funcNodes,
                                                                                               String groupByColumn,
                                                                                               FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1}
        如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterNode)null) 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
        指定者:
        queryColumnMap 在接口中 DataSource
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        node - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        public <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N[]>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                       ColumnNode[] funcNodes,
                                                                                                                       String groupByColumn,
                                                                                                                       FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1}
        如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterNode)null) 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
        指定者:
        queryColumnMapAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        node - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        public <T,​K extends Serializable,​N extends Number> Map<K[],​N[]> queryColumnMap​(Class<T> entityClass,
                                                                                                 ColumnNode[] funcNodes,
                                                                                                 String[] groupByColumns,
                                                                                                 FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1}, {col2}
        如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterNode)null) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
        指定者:
        queryColumnMap 在接口中 DataSource
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        node - 过滤条件
        返回:
        聚合结果Map

      • queryColumnMapAsync

        public <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K[],​N[]>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                         ColumnNode[] funcNodes,
                                                                                                                         String[] groupByColumns,
                                                                                                                         FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1}, {col2}
        如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterNode)null) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
        指定者:
        queryColumnMapAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        node - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • finds

        public <T> T[] finds​(Class<T> clazz,
                     SelectColumn selects,
                     Serializable... pks)
        从接口复制的说明: DataSource
        获取指定主键值的多个记录, 返回数组，数组长度与pks一样
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
        指定者:
        finds 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        pks - 主键值集合
        返回:
        Entity对象

      • findsAsync

        public <T> CompletableFuture<T[]> findsAsync​(Class<T> clazz,
                                             SelectColumn selects,
                                             Serializable... pks)
        从接口复制的说明: DataSource
        获取指定主键值的多个记录, 返回数组，数组长度与pks一样
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
        指定者:
        findsAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        pks - 主键值集合
        返回:
        Entity对象CompletableFuture

      • findsList

        public <D extends Serializable,​T> List<T> findsList​(Class<T> clazz,
                                                          Stream<D> pks)
        从接口复制的说明: DataSource
        获取指定主键值的多个记录, 返回列表
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
        指定者:
        findsList 在接口中 DataSource
        类型参数:
        D - 主键泛型
        T - Entity泛型
        参数:
        clazz - Entity类
        pks - 主键值集合
        返回:
        Entity对象

      • findsListAsync

        public <D extends Serializable,​T> CompletableFuture<List<T>> findsListAsync​(Class<T> clazz,
                                                                                  Stream<D> pks)
        从接口复制的说明: DataSource
        获取指定主键值的多个记录, 返回列表
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
        指定者:
        findsListAsync 在接口中 DataSource
        类型参数:
        D - 主键泛型
        T - Entity泛型
        参数:
        clazz - Entity类
        pks - 主键值集合
        返回:
        Entity对象

      • find

        public <T> T find​(Class<T> clazz,
                  SelectColumn selects,
                  Serializable pk)
        从接口复制的说明: DataSource
        获取指定主键值的单个记录, 返回null表示不存在值
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
        指定者:
        find 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        pk - 主键值
        返回:
        Entity对象

      • findAsync

        public <T> CompletableFuture<T> findAsync​(Class<T> clazz,
                                          SelectColumn selects,
                                          Serializable pk)
        从接口复制的说明: DataSource
        获取指定主键值的单个记录, 返回null表示不存在值
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
        指定者:
        findAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        pk - 主键值
        返回:
        Entity对象CompletableFuture

      • find

        public <T> T find​(Class<T> clazz,
                  SelectColumn selects,
                  FilterNode node)
        从接口复制的说明: DataSource
        获取符合过滤条件单个记录, 返回null表示不存在值
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
        指定者:
        find 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        node - 过滤条件
        返回:
        Entity对象

      • findAsync

        public <T> CompletableFuture<T> findAsync​(Class<T> clazz,
                                          SelectColumn selects,
                                          FilterNode node)
        从接口复制的说明: DataSource
        获取符合过滤条件单个记录, 返回null表示不存在值
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
        指定者:
        findAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        node - 过滤条件
        返回:
        Entity对象 CompletableFuture

      • findColumn

        public <T> Serializable findColumn​(Class<T> clazz,
                                   String column,
                                   Serializable defValue,
                                   Serializable pk)
        从接口复制的说明: DataSource
        获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
        等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
        指定者:
        findColumn 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        column - 字段名
        defValue - 默认值
        pk - 主键值
        返回:
        字段值

      • findColumnAsync

        public <T> CompletableFuture<Serializable> findColumnAsync​(Class<T> clazz,
                                                           String column,
                                                           Serializable defValue,
                                                           Serializable pk)
        从接口复制的说明: DataSource
        获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
        等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
        指定者:
        findColumnAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        column - 字段名
        defValue - 默认值
        pk - 主键值
        返回:
        字段值 CompletableFuture

      • findColumn

        public <T> Serializable findColumn​(Class<T> clazz,
                                   String column,
                                   Serializable defValue,
                                   FilterNode node)
        从接口复制的说明: DataSource
        获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
        等价SQL: SELECT {column} FROM {table} WHERE {filter node}
        指定者:
        findColumn 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        column - 字段名
        defValue - 默认值
        node - 过滤条件
        返回:
        字段值

      • findColumnAsync

        public <T> CompletableFuture<Serializable> findColumnAsync​(Class<T> clazz,
                                                           String column,
                                                           Serializable defValue,
                                                           FilterNode node)
        从接口复制的说明: DataSource
        获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
        等价SQL: SELECT {column} FROM {table} WHERE {filter node}
        指定者:
        findColumnAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        column - 字段名
        defValue - 默认值
        node - 过滤条件
        返回:
        字段值 CompletableFuture

      • exists

        public <T> boolean exists​(Class<T> clazz,
                          Serializable pk)
        从接口复制的说明: DataSource
        判断是否存在主键值的记录
        等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
        指定者:
        exists 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键值
        返回:
        是否存在

      • existsAsync

        public <T> CompletableFuture<Boolean> existsAsync​(Class<T> clazz,
                                                  Serializable pk)
        从接口复制的说明: DataSource
        判断是否存在主键值的记录
        等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
        指定者:
        existsAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键值
        返回:
        是否存在CompletableFuture

      • exists

        public <T> boolean exists​(Class<T> clazz,
                          FilterNode node)
        从接口复制的说明: DataSource
        判断是否存在符合过滤条件的记录
        等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
        指定者:
        exists 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        是否存在

      • existsAsync

        public <T> CompletableFuture<Boolean> existsAsync​(Class<T> clazz,
                                                  FilterNode node)
        从接口复制的说明: DataSource
        判断是否存在符合过滤条件的记录
        等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
        指定者:
        existsAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        是否存在CompletableFuture

      • queryColumnSet

        public <T,​V extends Serializable> Set<V> queryColumnSet​(String selectedColumn,
                                                              Class<T> clazz,
                                                              Flipper flipper,
                                                              FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的某个字段Set集合
        等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        queryColumnSet 在接口中 DataSource
        类型参数:
        T - Entity泛型
        V - 字段类型
        参数:
        selectedColumn - 指定字段
        clazz - Entity类
        flipper - 翻页对象
        node - 过滤条件
        返回:
        字段值的集合

      • queryColumnSetAsync

        public <T,​V extends Serializable> CompletableFuture<Set<V>> queryColumnSetAsync​(String selectedColumn,
                                                                                      Class<T> clazz,
                                                                                      Flipper flipper,
                                                                                      FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的某个字段Set集合
        等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        queryColumnSetAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        V - 字段类型
        参数:
        selectedColumn - 指定字段
        clazz - Entity类
        flipper - 翻页对象
        node - 过滤条件
        返回:
        字段值的集合CompletableFuture

      • queryColumnList

        public <T,​V extends Serializable> List<V> queryColumnList​(String selectedColumn,
                                                                Class<T> clazz,
                                                                Flipper flipper,
                                                                FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的某个字段List集合
        等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        queryColumnList 在接口中 DataSource
        类型参数:
        T - Entity泛型
        V - 字段类型
        参数:
        selectedColumn - 指定字段
        clazz - Entity类
        flipper - 翻页对象
        node - 过滤条件
        返回:
        字段值的集合

      • queryColumnListAsync

        public <T,​V extends Serializable> CompletableFuture<List<V>> queryColumnListAsync​(String selectedColumn,
                                                                                        Class<T> clazz,
                                                                                        Flipper flipper,
                                                                                        FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的某个字段List集合
        等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        queryColumnListAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        V - 字段类型
        参数:
        selectedColumn - 指定字段
        clazz - Entity类
        flipper - 翻页对象
        node - 过滤条件
        返回:
        字段值的集合CompletableFuture

      • queryColumnSheet

        public <T,​V extends Serializable> Sheet<V> queryColumnSheet​(String selectedColumn,
                                                                  Class<T> clazz,
                                                                  Flipper flipper,
                                                                  FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的某个字段Sheet集合
        等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        queryColumnSheet 在接口中 DataSource
        类型参数:
        T - Entity泛型
        V - 字段类型
        参数:
        selectedColumn - 指定字段
        clazz - Entity类
        flipper - 翻页对象
        node - 过滤条件
        返回:
        字段值的集合

      • queryColumnSheetAsync

        public <T,​V extends Serializable> CompletableFuture<Sheet<V>> queryColumnSheetAsync​(String selectedColumn,
                                                                                          Class<T> clazz,
                                                                                          Flipper flipper,
                                                                                          FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的某个字段Sheet集合
        等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        queryColumnSheetAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        V - 字段类型
        参数:
        selectedColumn - 指定字段
        clazz - Entity类
        flipper - 翻页对象
        node - 过滤条件
        返回:
        字段值的集合CompletableFuture

      • queryMap

        public <K extends Serializable,​T> Map<K,​T> queryMap​(Class<T> clazz,
                                                                SelectColumn selects,
                                                                Stream<K> keyStream)
        查询符合过滤条件记录的Map集合, 主键值为key
        等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        queryMap 在接口中 DataSource
        类型参数:
        K - 主键泛型
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        keyStream - 主键Stream
        返回:
        Entity的集合

      • queryMapAsync

        public <K extends Serializable,​T> CompletableFuture<Map<K,​T>> queryMapAsync​(Class<T> clazz,
                                                                                        SelectColumn selects,
                                                                                        Stream<K> keyStream)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
        等价SQL: SELECT * FROM {table} WHERE id IN {ids}
        指定者:
        queryMapAsync 在接口中 DataSource
        类型参数:
        K - 主键泛型
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        keyStream - 主键Stream
        返回:
        Entity的集合CompletableFuture

      • queryMap

        public <K extends Serializable,​T> Map<K,​T> queryMap​(Class<T> clazz,
                                                                SelectColumn selects,
                                                                FilterNode node)
        查询符合过滤条件记录的Map集合, 主键值为key
        等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        queryMap 在接口中 DataSource
        类型参数:
        K - 主键泛型
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        node - FilterNode
        返回:
        Entity的集合

      • queryMapAsync

        public <K extends Serializable,​T> CompletableFuture<Map<K,​T>> queryMapAsync​(Class<T> clazz,
                                                                                        SelectColumn selects,
                                                                                        FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
        等价SQL: SELECT * FROM {table} WHERE {filter node}
        指定者:
        queryMapAsync 在接口中 DataSource
        类型参数:
        K - 主键泛型
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        node - FilterNode
        返回:
        Entity的集合CompletableFuture

      • querySet

        public <T> Set<T> querySet​(Class<T> clazz,
                           SelectColumn selects,
                           Flipper flipper,
                           FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的Set集合
        等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        querySet 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        flipper - 翻页对象
        node - 过滤条件
        返回:
        Entity的集合

      • querySetAsync

        public <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz,
                                                   SelectColumn selects,
                                                   Flipper flipper,
                                                   FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的Set集合
        等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        querySetAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        flipper - 翻页对象
        node - 过滤条件
        返回:
        Entity的集合CompletableFuture

      • queryList

        public <T> List<T> queryList​(Class<T> clazz,
                             SelectColumn selects,
                             Flipper flipper,
                             FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的List集合
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        queryList 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        flipper - 翻页对象
        node - 过滤条件
        返回:
        Entity的集合

      • queryListAsync

        public <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz,
                                                     SelectColumn selects,
                                                     Flipper flipper,
                                                     FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的List集合
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        queryListAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        flipper - 翻页对象
        node - 过滤条件
        返回:
        Entity的集合CompletableFuture

      • querySheet

        public <T> Sheet<T> querySheet​(Class<T> clazz,
                               SelectColumn selects,
                               Flipper flipper,
                               FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的Sheet集合
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        querySheet 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        flipper - 翻页对象
        node - 过滤条件
        返回:
        Entity的集合

      • querySheetAsync

        public <T> CompletableFuture<Sheet<T>> querySheetAsync​(Class<T> clazz,
                                                       SelectColumn selects,
                                                       Flipper flipper,
                                                       FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的Sheet集合
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        querySheetAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        flipper - 翻页对象
        node - 过滤条件
        返回:
        Entity的集合CompletableFuture

      • nativeQuery

        public <V> V nativeQuery​(String sql,
                         BiConsumer<Object,​Object> consumer,
                         Function<DataResultSet,​V> handler,
                         Map<String,​Object> params)
        从接口复制的说明: DataSqlSource
        通过原生带参数的sql查询结果
        指定者:
        nativeQuery 在接口中 DataSqlSource
        类型参数:
        V - 泛型
        参数:
        sql - 带参数的sql语句
        consumer - BiConsumer 参数1: connection, 参数2: statement
        handler - DataResultSet的回调函数
        params - 参数值集合
        返回:
        结果对象

      • nativeQuery

        public <V> V nativeQuery​(String sql,
                         BiConsumer<Object,​Object> consumer,
                         Function<DataResultSet,​V> handler)
        从接口复制的说明: DataSqlSource
        通过原生的sql查询结果
        指定者:
        nativeQuery 在接口中 DataSqlSource
        类型参数:
        V - 泛型
        参数:
        sql - 无参数的sql语句
        consumer - BiConsumer 参数1: connection, 参数2: statement
        handler - DataResultSet的回调函数
        返回:
        结果对象

      • nativeUpdate

        public int nativeUpdate​(String sql)
        从接口复制的说明: DataSqlSource
        执行原生无参数的sql
        指定者:
        nativeUpdate 在接口中 DataSqlSource
        参数:
        sql - 无参数的sql语句
        返回:
        执行条数

      • nativeUpdates

        public int[] nativeUpdates​(String... sqls)
        从接口复制的说明: DataSqlSource
        执行多条原生无参数的sql
        指定者:
        nativeUpdates 在接口中 DataSqlSource
        参数:
        sqls - 无参数的sql语句
        返回:
        执行条数