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

类 AbstractDataSource

    • 字段详细资料

      • sourceThreads

        protected int sourceThreads

    • 构造器详细资料

      • AbstractDataSource

        public AbstractDataSource()

    • 方法详细资料

      • init

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

      • setSourceExecutor

        protected void setSourceExecutor​(ExecutorService executor)

      • executorToString

        protected String executorToString()

      • isOnlyCache

        protected boolean isOnlyCache​(EntityInfo info)
        是否虚拟化的持久对象
        参数:
        info - EntityInfo
        返回:
        boolean

      • isCacheUseable

        protected boolean isCacheUseable​(FilterNode node,
                                 Function<Class,​EntityInfo> entityApplyer)
        是否可以使用缓存，一般包含关联查询就不使用缓存
        参数:
        node - 过滤条件
        entityApplyer - 函数
        返回:
        boolean

      • createPredicate

        protected <T> Predicate<T> createPredicate​(FilterNode node,
                                           EntityCache<T> cache)
        生成过滤函数
        类型参数:
        T - 泛型
        参数:
        node - 过滤条件
        cache - 缓存
        返回:
        Predicate

      • getEntityValue

        protected <T> T getEntityValue​(EntityInfo<T> info,
                               SelectColumn sels,
                               DataResultSetRow row)
        根据ResultSet获取对象
        类型参数:
        T - 泛型
        参数:
        info - EntityInfo
        sels - 过滤字段
        row - ResultSet
        返回:
        对象

      • getJoinTabalis

        protected Map<Class,​String> getJoinTabalis​(FilterNode node)
        根据过滤条件生成关联表与别名的映射关系
        参数:
        node - 过滤条件
        返回:
        Map

      • getEntityInfo

        protected <T> EntityInfo<T> getEntityInfo​(Class<T> clazz)
        加载指定类的EntityInfo
        类型参数:
        T - 泛型
        参数:
        clazz - 类
        返回:
        EntityInfo

      • checkEntity

        protected <T> void checkEntity​(String action,
                               T... entitys)
        检查对象是否都是同一个Entity类
        类型参数:
        T - 泛型
        参数:
        action - 操作
        entitys - 对象集合

      • batch

        public int batch​(DataBatch batch)
        从接口复制的说明: DataSource
        增删改的批量操作
        指定者:
        batch 在接口中 DataSource
        参数:
        batch - 批量对象
        返回:
        -1表示失败，正数为成功

      • insert

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

      • insert

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

      • insertAsync

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

      • insertAsync

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

      • clearTableAsync

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

      • dropTable

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

      • dropTableAsync

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

      • updateColumn

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

      • updateColumnAsync

        public <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz,
                                                        FilterNode node,
                                                        ColumnValue... values)
        从接口复制的说明: DataSource
        更新符合过滤条件记录的部分字段
        字段赋值操作选项见 ColumnExpress
        注意：Entity类中标记为@Column(updatable=false)不会被更新
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
        指定者:
        updateColumnAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        values - 更新字段
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

        public <T> int updateColumn​(T entity,
                            String... columns)
        从接口复制的说明: 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对象
        columns - 需更新的字段名
        返回:
        影响的记录条数

      • updateColumnAsync

        public <T> CompletableFuture<Integer> updateColumnAsync​(T entity,
                                                        String... columns)
        从接口复制的说明: 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对象
        columns - 需更新的字段名
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

        public <T> int updateColumn​(T entity,
                            FilterNode node,
                            String... columns)
        从接口复制的说明: 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 - 过滤条件
        columns - 需更新的字段名
        返回:
        影响的记录条数

      • updateColumnAsync

        public <T> CompletableFuture<Integer> updateColumnAsync​(T entity,
                                                        FilterNode node,
                                                        String... columns)
        从接口复制的说明: 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 - 过滤条件
        columns - 需更新的字段名
        返回:
        影响的记录条数CompletableFuture

      • getNumberMap

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

      • getNumberMapAsync

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

      • getNumberMap

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

      • getNumberMapAsync

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

      • getNumberResult

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

      • getNumberResultAsync

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

      • getNumberResult

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

      • getNumberResultAsync

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

      • getNumberResult

        public Number getNumberResult​(Class entityClass,
                              FilterFunc func,
                              String column,
                              FilterNode node)
        从接口复制的说明: DataSource
        获取符合过滤条件记录的聚合结果, 无结果返回null
        等价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 - 聚合函数
        column - 指定字段
        node - 过滤条件
        返回:
        聚合结果

      • getNumberResultAsync

        public CompletableFuture<Number> getNumberResultAsync​(Class entityClass,
                                                      FilterFunc func,
                                                      String column,
                                                      FilterNode node)
        从接口复制的说明: DataSource
        获取符合过滤条件记录的聚合结果, 无结果返回null
        等价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 - 聚合函数
        column - 指定字段
        node - 过滤条件
        返回:
        聚合结果

      • getNumberResult

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

      • getNumberResultAsync

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

      • getNumberResult

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

      • getNumberResultAsync

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

      • queryColumnMap

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

      • queryColumnMapAsync

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

      • queryColumnMap

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

      • queryColumnMapAsync

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

      • queryColumnMap

        public <T,​K extends Serializable,​N extends Number> Map<K,​N[]> queryColumnMap​(Class<T> entityClass,
                                                                                               ColumnNode[] funcNodes,
                                                                                               String groupByColumn)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE GROUP BY {col1}
        如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid") 等价于: 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字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        public <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N[]>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                       ColumnNode[] funcNodes,
                                                                                                                       String groupByColumn)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} GROUP BY {col1}
        如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid") 等价于: 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字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        public <T,​K extends Serializable,​N extends Number> Map<K,​N[]> queryColumnMap​(Class<T> entityClass,
                                                                                               ColumnNode[] funcNodes,
                                                                                               String groupByColumn,
                                                                                               FilterBean bean)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1}
        如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterBean)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字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        public <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N[]>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                       ColumnNode[] funcNodes,
                                                                                                                       String groupByColumn,
                                                                                                                       FilterBean bean)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1}
        如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterBean)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字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        public <T,​K extends Serializable,​N extends Number> Map<K[],​N[]> queryColumnMap​(Class<T> entityClass,
                                                                                                 ColumnNode[] funcNodes,
                                                                                                 String[] groupByColumns)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} 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")) 等价于: 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字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        public <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K[],​N[]>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                         ColumnNode[] funcNodes,
                                                                                                                         String[] groupByColumns)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} 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")) 等价于: 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字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        public <T,​K extends Serializable,​N extends Number> Map<K[],​N[]> queryColumnMap​(Class<T> entityClass,
                                                                                                 ColumnNode[] funcNodes,
                                                                                                 String[] groupByColumns,
                                                                                                 FilterBean bean)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} 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"), (FilterBean)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字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        public <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K[],​N[]>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                         ColumnNode[] funcNodes,
                                                                                                                         String[] groupByColumns,
                                                                                                                         FilterBean bean)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的GROUP BY聚合结果Map
        等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} 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"), (FilterBean)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字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • find

        public <T> T find​(Class<T> clazz,
                  Serializable pk)
        根据主键获取对象
        指定者:
        find 在接口中 DataSource
        类型参数:
        T - Entity类的泛型
        参数:
        clazz - Entity类
        pk - 主键值
        返回:
        Entity对象

      • findAsync

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

      • find

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

      • findAsync

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

      • find

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

      • findAsync

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

      • find

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

      • findAsync

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

      • find

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

      • findAsync

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

      • findColumn

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

      • findColumnAsync

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

      • findColumn

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

      • findColumnAsync

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

      • findColumn

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

      • findColumnAsync

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

      • findColumn

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

      • findColumnAsync

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

      • exists

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

      • existsAsync

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

      • queryColumnSet

        public <T,​V extends Serializable> Set<V> queryColumnSet​(String selectedColumn,
                                                              Class<T> clazz,
                                                              String column,
                                                              Serializable colval)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的某个字段Set集合
        等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {column} = {key}
        指定者:
        queryColumnSet 在接口中 DataSource
        类型参数:
        T - Entity泛型
        V - 字段类型
        参数:
        selectedColumn - 指定字段
        clazz - Entity类
        column - 过滤字段名
        colval - 过滤字段值
        返回:
        字段值的集合

      • queryColumnSetAsync

        public <T,​V extends Serializable> CompletableFuture<Set<V>> queryColumnSetAsync​(String selectedColumn,
                                                                                      Class<T> clazz,
                                                                                      String column,
                                                                                      Serializable colval)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的某个字段Set集合
        等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {column} = {key}
        指定者:
        queryColumnSetAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        V - 字段类型
        参数:
        selectedColumn - 指定字段
        clazz - Entity类
        column - 过滤字段名
        colval - 过滤字段值
        返回:
        字段值的集合CompletableFuture

      • queryColumnSet

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

      • queryColumnSetAsync

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

      • queryColumnSet

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

      • queryColumnSetAsync

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

      • queryColumnSet

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

      • queryColumnSetAsync

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

      • queryColumnList

        public <T,​V extends Serializable> List<V> queryColumnList​(String selectedColumn,
                                                                Class<T> clazz,
                                                                String column,
                                                                Serializable colval)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的某个字段List集合
        等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
        指定者:
        queryColumnList 在接口中 DataSource
        类型参数:
        T - Entity泛型
        V - 字段类型
        参数:
        selectedColumn - 指定字段
        clazz - Entity类
        column - 过滤字段名
        colval - 过滤字段值
        返回:
        字段值的集合

      • queryColumnListAsync

        public <T,​V extends Serializable> CompletableFuture<List<V>> queryColumnListAsync​(String selectedColumn,
                                                                                        Class<T> clazz,
                                                                                        String column,
                                                                                        Serializable colval)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的某个字段List集合
        等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
        指定者:
        queryColumnListAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        V - 字段类型
        参数:
        selectedColumn - 指定字段
        clazz - Entity类
        column - 过滤字段名
        colval - 过滤字段值
        返回:
        字段值的集合CompletableFuture

      • queryColumnList

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

      • queryColumnListAsync

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

      • queryColumnList

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

      • queryColumnListAsync

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

      • queryColumnList

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

      • queryColumnListAsync

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

      • queryColumnSheet

        public <T,​V extends Serializable> Sheet<V> queryColumnSheet​(String selectedColumn,
                                                                  Class<T> clazz,
                                                                  Flipper flipper,
                                                                  FilterBean bean)
        根据指定参数查询对象某个字段的集合
        指定者:
        queryColumnSheet 在接口中 DataSource
        类型参数:
        T - Entity类的泛型
        V - 字段值的类型
        参数:
        selectedColumn - 字段名
        clazz - Entity类
        flipper - 翻页对象
        bean - 过滤Bean
        返回:
        字段集合

      • queryColumnSheetAsync

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

      • queryMap

        public <K extends Serializable,​T> Map<K,​T> queryMap​(Class<T> clazz,
                                                                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类
        keyStream - 主键Stream
        返回:
        Entity的集合

      • queryMapAsync

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

      • queryMap

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

      • queryMapAsync

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

      • queryMap

        public <K extends Serializable,​T> Map<K,​T> queryMap​(Class<T> clazz,
                                                                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类
        node - FilterNode
        返回:
        Entity的集合

      • queryMapAsync

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

      • queryMap

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

      • queryMapAsync

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

      • querySet

        public <T> Set<T> querySet​(Class<T> clazz,
                           String column,
                           Serializable colval)
        根据指定字段值查询对象集合
        指定者:
        querySet 在接口中 DataSource
        类型参数:
        T - Entity类的泛型
        参数:
        clazz - Entity类
        column - 过滤字段名
        colval - 过滤字段值
        返回:
        Entity对象的集合

      • querySetAsync

        public <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz,
                                                   String column,
                                                   Serializable colval)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        querySetAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        column - 过滤字段名
        colval - 过滤字段值
        返回:
        Entity的集合CompletableFuture

      • querySet

        public <T> Set<T> querySet​(Class<T> clazz)
        从接口复制的说明: DataSource
        查询记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table}
        指定者:
        querySet 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        返回:
        Entity的集合

      • querySetAsync

        public <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz)
        从接口复制的说明: DataSource
        查询记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table}
        指定者:
        querySetAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        返回:
        Entity的集合CompletableFuture

      • querySet

        public <T> Set<T> querySet​(Class<T> clazz,
                           FilterBean bean)
        根据过滤对象FilterBean查询对象集合
        指定者:
        querySet 在接口中 DataSource
        类型参数:
        T - Entity类的泛型
        参数:
        clazz - Entity类
        bean - 过滤Bean
        返回:
        Entity对象集合

      • querySetAsync

        public <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz,
                                                   FilterBean bean)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean}
        指定者:
        querySetAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        bean - 过滤条件
        返回:
        Entity的集合CompletableFuture

      • querySet

        public <T> Set<T> querySet​(Class<T> clazz,
                           FilterNode node)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node}
        指定者:
        querySet 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        Entity的集合

      • querySetAsync

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

      • querySet

        public <T> Set<T> querySet​(Class<T> clazz,
                           SelectColumn selects,
                           FilterBean bean)
        根据过滤对象FilterBean查询对象集合， 对象只填充或排除SelectField指定的字段
        指定者:
        querySet 在接口中 DataSource
        类型参数:
        T - Entity类的泛型
        参数:
        clazz - Entity类
        selects - 收集的字段
        bean - 过滤Bean
        返回:
        Entity对象的集合

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • queryList

        public <T> List<T> queryList​(Class<T> clazz,
                             String column,
                             Serializable colval)
        根据指定字段值查询对象集合
        指定者:
        queryList 在接口中 DataSource
        类型参数:
        T - Entity类的泛型
        参数:
        clazz - Entity类
        column - 过滤字段名
        colval - 过滤字段值
        返回:
        Entity对象的集合

      • queryListAsync

        public <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz,
                                                     String column,
                                                     Serializable colval)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的List集合
        等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        指定者:
        queryListAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        column - 过滤字段名
        colval - 过滤字段值
        返回:
        Entity的集合CompletableFuture

      • queryList

        public <T> List<T> queryList​(Class<T> clazz)
        从接口复制的说明: DataSource
        查询记录的List集合
        等价SQL: SELECT * FROM {table}
        指定者:
        queryList 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        返回:
        Entity的集合

      • queryListAsync

        public <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz)
        从接口复制的说明: DataSource
        查询记录的List集合
        等价SQL: SELECT * FROM {table}
        指定者:
        queryListAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        返回:
        Entity的集合CompletableFuture

      • queryList

        public <T> List<T> queryList​(Class<T> clazz,
                             FilterBean bean)
        根据过滤对象FilterBean查询对象集合
        指定者:
        queryList 在接口中 DataSource
        类型参数:
        T - Entity类的泛型
        参数:
        clazz - Entity类
        bean - 过滤Bean
        返回:
        Entity对象集合

      • queryListAsync

        public <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz,
                                                     FilterBean bean)
        从接口复制的说明: DataSource
        查询符合过滤条件记录的List集合
        等价SQL: SELECT * FROM {table} WHERE {filter bean}
        指定者:
        queryListAsync 在接口中 DataSource
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        bean - 过滤条件
        返回:
        Entity的集合CompletableFuture

      • queryList

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

      • queryListAsync

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

      • queryList

        public <T> List<T> queryList​(Class<T> clazz,
                             SelectColumn selects,
                             FilterBean bean)
        根据过滤对象FilterBean查询对象集合， 对象只填充或排除SelectField指定的字段
        指定者:
        queryList 在接口中 DataSource
        类型参数:
        T - Entity类的泛型
        参数:
        clazz - Entity类
        selects - 收集的字段
        bean - 过滤Bean
        返回:
        Entity对象的集合

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • querySheet

        public <T> Sheet<T> querySheet​(Class<T> clazz,
                               Flipper flipper,
                               FilterBean bean)
        根据过滤对象FilterBean和翻页对象Flipper查询一页的数据
        指定者:
        querySheet 在接口中 DataSource
        类型参数:
        T - Entity类的泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        bean - 过滤Bean
        返回:
        Entity对象的集合

      • querySheetAsync

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

      • querySheet

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

      • querySheetAsync

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

      • querySheet

        public <T> Sheet<T> querySheet​(Class<T> clazz,
                               SelectColumn selects,
                               Flipper flipper,
                               FilterBean bean)
        根据过滤对象FilterBean和翻页对象Flipper查询一页的数据， 对象只填充或排除SelectField指定的字段
        指定者:
        querySheet 在接口中 DataSource
        类型参数:
        T - Entity类的泛型
        参数:
        clazz - Entity类
        selects - 收集的字段集合
        flipper - 翻页对象
        bean - 过滤Bean
        返回:
        Entity对象的集合

      • querySheetAsync

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