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

接口 DataSource

  • 所有超级接口:
    Resourcable
    所有已知子接口:
    DataSqlSource, SearchSource
    所有已知实现类:
    AbstractDataSource, AbstractDataSqlSource, DataJdbcSource, DataMemorySource
    @Component
public interface DataSource
extends Resourcable
    DataSource 为数据库或内存数据库的数据源，提供类似JPA、Hibernate的接口与功能。
    返回类型为CompletableFuture的接口为异步接口

    字段类型支持：
    1、boolean/Boolean
    2、byte/Byte
    3、short/Short
    4、char/Character
    5、int/Integer/AtomicInteger
    6、long/Long/AtomicLong/LongAdder
    7、float/Float
    8、double/Double
    9、java.math.BigInteger
    10、java.math.BigDecimal
    11、String
    12、byte[]
    13、java.time.LocalDate/java.sql.Date/java.util.Date
    14、java.time.LocalTime/java.sql.Time
    15、java.time.LocalDateTime/java.sql.Timestamp
    16、JavaBean/其他可JSON化类型

    详情见: https://redkale.org

    作者:
    zhangjx

    • 方法概要

      所有方法 实例方法 抽象方法 默认方法 
      修饰符和类型 方法 说明
      int batch​(DataBatch batch)
      增删改的批量操作
      CompletableFuture<Integer> batchAsync​(DataBatch batch)
      增删改的批量操作
      default <T> int clearTable​(Class<T> clazz)
      清空表
      等价SQL: TRUNCATE TABLE {table}
      <T> int clearTable​(Class<T> clazz, FilterNode node)
      清空表
      等价SQL: TRUNCATE TABLE {table}
      default <T> CompletableFuture<Integer> clearTableAsync​(Class<T> clazz)
      清空表
      等价SQL: TRUNCATE TABLE {table}
      <T> CompletableFuture<Integer> clearTableAsync​(Class<T> clazz, FilterNode node)
      清空表
      等价SQL: TRUNCATE TABLE {table}
      <T> void compile​(Class<T> clazz)
      提取预编译Entity类，主要用于native-image使用
      <T> int createTable​(Class<T> clazz, Serializable pk)
      删除表
      等价SQL: DROP TABLE {table}
      <T> CompletableFuture<Integer> createTableAsync​(Class<T> clazz, Serializable pk)
      删除表
      等价SQL: DROP TABLE {table}
      <T> int delete​(Class<T> clazz, Serializable... pks)
      删除指定主键值的记录,多主键值必须在同一张表中
      等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
      default <T> int delete​(Class<T> clazz, FilterNode node)
      删除符合过滤条件的记录
      等价SQL: DELETE FROM {table} WHERE {filter node}
      <T> int delete​(Class<T> clazz, Flipper flipper, FilterNode node)
      删除符合过滤条件且指定最大影响条数的记录
      Flipper中offset字段将被忽略
      等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> int delete​(Collection<T> entitys)
      删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
      等价SQL: DELETE FROM {table} WHERE {primary} IN {getValues.id}
      default <T> int delete​(Stream<T> entitys)
      删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
      等价SQL: DELETE FROM {table} WHERE {primary} IN {getValues.id}
      <T> int delete​(T... entitys)
      删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
      等价SQL: DELETE FROM {table} WHERE {primary} IN {getValues.id}
      <T> CompletableFuture<Integer> deleteAsync​(Class<T> clazz, Serializable... pks)
      删除指定主键值的记录,多主键值必须在同一张表中
      等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
      default <T> CompletableFuture<Integer> deleteAsync​(Class<T> clazz, FilterNode node)
      删除符合过滤条件的记录
      等价SQL: DELETE FROM {table} WHERE {filter node}
      <T> CompletableFuture<Integer> deleteAsync​(Class<T> clazz, Flipper flipper, FilterNode node)
      删除符合过滤条件且指定最大影响条数的记录
      Flipper中offset字段将被忽略
      等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<Integer> deleteAsync​(Collection<T> entitys)
      删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
      等价SQL: DELETE FROM {table} WHERE {primary} IN {getValues.id}
      default <T> CompletableFuture<Integer> deleteAsync​(Stream<T> entitys)
      删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
      等价SQL: DELETE FROM {table} WHERE {primary} IN {getValues.id}
      <T> CompletableFuture<Integer> deleteAsync​(T... entitys)
      删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
      等价SQL: DELETE FROM {table} WHERE {primary} IN {getValues.id}
      default <T> int dropTable​(Class<T> clazz)
      删除表
      等价SQL: DROP TABLE {table}
      <T> int dropTable​(Class<T> clazz, FilterNode node)
      删除表
      等价SQL: DROP TABLE {table}
      default <T> CompletableFuture<Integer> dropTableAsync​(Class<T> clazz)
      删除表
      等价SQL: DROP TABLE {table}
      <T> CompletableFuture<Integer> dropTableAsync​(Class<T> clazz, FilterNode node)
      删除表
      等价SQL: DROP TABLE {table}
      <T> boolean exists​(Class<T> clazz, Serializable pk)
      判断是否存在主键值的记录
      等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
      default <T> boolean exists​(Class<T> clazz, FilterBean bean)
      判断是否存在符合过滤条件的记录
      等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
      <T> boolean exists​(Class<T> clazz, FilterNode node)
      判断是否存在符合过滤条件的记录
      等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
      <T> CompletableFuture<Boolean> existsAsync​(Class<T> clazz, Serializable pk)
      判断是否存在主键值的记录
      等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
      default <T> CompletableFuture<Boolean> existsAsync​(Class<T> clazz, FilterBean bean)
      判断是否存在符合过滤条件的记录
      等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
      <T> CompletableFuture<Boolean> existsAsync​(Class<T> clazz, FilterNode node)
      判断是否存在符合过滤条件的记录
      等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
      default <T> T find​(Class<T> clazz, Serializable pk)
      获取指定主键值的单个记录, 返回null表示不存在值
      等价SQL: SELECT * FROM {table} WHERE {primary} = {id}
      <T> T find​(Class<T> clazz, String column, Serializable colval)
      获取符合过滤条件单个记录, 返回null表示不存在值
      等价SQL: SELECT * FROM {table} WHERE {column} = {key}
      default <T> T find​(Class<T> clazz, FilterBean bean)
      获取符合过滤条件单个记录, 返回null表示不存在值
      等价SQL: SELECT * FROM {table} WHERE {filter bean}
      default <T> T find​(Class<T> clazz, FilterNode node)
      获取符合过滤条件单个记录, 返回null表示不存在值
      等价SQL: SELECT * FROM {table} WHERE {filter node}
      default <T> T find​(Class<T> clazz, LambdaSupplier<Serializable> func)
      获取符合过滤条件单个记录, 返回null表示不存在值
      等价SQL: SELECT * FROM {table} WHERE {column} = {key}
      <T> T find​(Class<T> clazz, SelectColumn selects, Serializable pk)
      获取指定主键值的单个记录, 返回null表示不存在值
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
      default <T> T find​(Class<T> clazz, SelectColumn selects, FilterBean bean)
      获取符合过滤条件单个记录, 返回null表示不存在值
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
      <T> T find​(Class<T> clazz, SelectColumn selects, FilterNode node)
      获取符合过滤条件单个记录, 返回null表示不存在值
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
      <T> CompletableFuture<T> findAsync​(Class<T> clazz, Serializable pk)
      获取指定主键值的单个记录, 返回null表示不存在值
      等价SQL: SELECT * FROM {table} WHERE {primary} = {id}
      <T> CompletableFuture<T> findAsync​(Class<T> clazz, String column, Serializable colval)
      获取符合过滤条件单个记录, 返回null表示不存在值
      等价SQL: SELECT * FROM {table} WHERE {column} = {key}
      default <T> CompletableFuture<T> findAsync​(Class<T> clazz, FilterBean bean)
      获取符合过滤条件单个记录, 返回null表示不存在值
      等价SQL: SELECT * FROM {table} WHERE {filter bean}
      default <T> CompletableFuture<T> findAsync​(Class<T> clazz, FilterNode node)
      获取符合过滤条件单个记录, 返回null表示不存在值
      等价SQL: SELECT * FROM {table} WHERE {filter node}
      default <T> CompletableFuture<T> findAsync​(Class<T> clazz, LambdaSupplier<Serializable> func)
      获取符合过滤条件单个记录, 返回null表示不存在值
      等价SQL: SELECT * FROM {table} WHERE {column} = {key}
      <T> CompletableFuture<T> findAsync​(Class<T> clazz, SelectColumn selects, Serializable pk)
      获取指定主键值的单个记录, 返回null表示不存在值
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
      default <T> CompletableFuture<T> findAsync​(Class<T> clazz, SelectColumn selects, FilterBean bean)
      获取符合过滤条件单个记录, 返回null表示不存在值
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
      <T> CompletableFuture<T> findAsync​(Class<T> clazz, SelectColumn selects, FilterNode node)
      获取符合过滤条件单个记录, 返回null表示不存在值
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
      <T> Serializable findColumn​(Class<T> clazz, String column, Serializable pk)
      获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
      等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
      <T> Serializable findColumn​(Class<T> clazz, String column, Serializable defValue, Serializable pk)
      获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
      等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
      default <T> Serializable findColumn​(Class<T> clazz, String column, Serializable defValue, FilterBean bean)
      获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
      等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
      <T> Serializable findColumn​(Class<T> clazz, String column, Serializable defValue, FilterNode node)
      获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
      等价SQL: SELECT {column} FROM {table} WHERE {filter node}
      default <T> Serializable findColumn​(Class<T> clazz, String column, FilterBean bean)
      获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
      等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
      default <T> Serializable findColumn​(Class<T> clazz, String column, FilterNode node)
      获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
      等价SQL: SELECT {column} FROM {table} WHERE {filter node}
      <T> CompletableFuture<Serializable> findColumnAsync​(Class<T> clazz, String column, Serializable pk)
      获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
      等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
      <T> CompletableFuture<Serializable> findColumnAsync​(Class<T> clazz, String column, Serializable defValue, Serializable pk)
      获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
      等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
      default <T> CompletableFuture<Serializable> findColumnAsync​(Class<T> clazz, String column, Serializable defValue, FilterBean bean)
      获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
      等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
      <T> CompletableFuture<Serializable> findColumnAsync​(Class<T> clazz, String column, Serializable defValue, FilterNode node)
      获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
      等价SQL: SELECT {column} FROM {table} WHERE {filter node}
      default <T> CompletableFuture<Serializable> findColumnAsync​(Class<T> clazz, String column, FilterBean bean)
      获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
      等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
      default <T> CompletableFuture<Serializable> findColumnAsync​(Class<T> clazz, String column, FilterNode node)
      获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
      等价SQL: SELECT {column} FROM {table} WHERE {filter node}
      default <T> T[] finds​(Class<T> clazz, Serializable... pks)
      获取指定主键值的多个记录, 返回数组，数组长度与pks一样
      等价SQL: SELECT * FROM {table} WHERE {primary} = {id1,id2, ···}
      default <D extends Serializable,​T>
      T[]      		 finds​(Class<T> clazz, Stream<D> pks)
      获取指定主键值的多个记录, 返回数组，数组长度与pks一样
      等价SQL: SELECT * FROM {table} WHERE {primary} = {id1,id2, ···}
      <T> T[] finds​(Class<T> clazz, SelectColumn selects, Serializable... pks)
      获取指定主键值的多个记录, 返回数组，数组长度与pks一样
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
      default <D extends Serializable,​T>
      T[]      		 finds​(Class<T> clazz, SelectColumn selects, Stream<D> pks)
      获取指定主键值的多个记录, 返回数组，数组长度与pks一样
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
      default <T> CompletableFuture<T[]> findsAsync​(Class<T> clazz, Serializable... pks)
      获取指定主键值的多个记录, 返回数组，数组长度与pks一样
      等价SQL: SELECT * FROM {table} WHERE {primary} = {id1,id2, ···}
      default <D extends Serializable,​T>
      CompletableFuture<T[]>      		 findsAsync​(Class<T> clazz, Stream<D> pks)
      获取指定主键值的多个记录, 返回数组，数组长度与pks一样
      等价SQL: SELECT * FROM {table} WHERE {primary} = {id1,id2, ···}
      <T> CompletableFuture<T[]> findsAsync​(Class<T> clazz, SelectColumn selects, Serializable... pks)
      获取指定主键值的多个记录, 返回数组，数组长度与pks一样
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
      default <D extends Serializable,​T>
      CompletableFuture<T[]>      		 findsAsync​(Class<T> clazz, SelectColumn selects, Stream<D> pks)
      获取指定主键值的多个记录, 返回数组，数组长度与pks一样
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
      <D extends Serializable,​T>
      List<T>      		 findsList​(Class<T> clazz, Stream<D> pks)
      获取指定主键值的多个记录, 返回列表
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
      <D extends Serializable,​T>
      CompletableFuture<List<T>>      		 findsListAsync​(Class<T> clazz, Stream<D> pks)
      获取指定主键值的多个记录, 返回列表
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
      default <N extends Number>
      Map<String,​N>      		 getNumberMap​(Class entityClass, FilterBean bean, FilterFuncColumn... columns)
      获取符合过滤条件记录的聚合结果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}
      default <N extends Number>
      Map<String,​N>      		 getNumberMap​(Class entityClass, FilterFuncColumn... columns)
      获取符合过滤条件记录的聚合结果Map
      等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table}
      如 getNumberMapAsync(User.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
      <N extends Number>
      Map<String,​N>      		 getNumberMap​(Class entityClass, FilterNode node, FilterFuncColumn... columns)
      获取符合过滤条件记录的聚合结果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}
      default <N extends Number>
      CompletableFuture<Map<String,​N>>      		 getNumberMapAsync​(Class entityClass, FilterBean bean, FilterFuncColumn... columns)
      获取符合过滤条件记录的聚合结果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}
      default <N extends Number>
      CompletableFuture<Map<String,​N>>      		 getNumberMapAsync​(Class entityClass, FilterFuncColumn... columns)
      获取符合过滤条件记录的聚合结果Map
      等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table}
      如 getNumberMapAsync(User.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
      <N extends Number>
      CompletableFuture<Map<String,​N>>      		 getNumberMapAsync​(Class entityClass, FilterNode node, FilterFuncColumn... columns)
      获取符合过滤条件记录的聚合结果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}
      default Number getNumberResult​(Class entityClass, FilterFunc func, Number defVal, String column)
      获取符合过滤条件记录的聚合结果, 无结果返回默认值
      等价SQL: SELECT FUNC{column} FROM {table}
      如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table}
      default Number getNumberResult​(Class entityClass, FilterFunc func, Number defVal, String column, FilterBean bean)
      获取符合过滤条件记录的聚合结果, 无结果返回默认值
      等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
      如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
      Number getNumberResult​(Class entityClass, FilterFunc func, Number defVal, String column, FilterNode node)
      获取符合过滤条件记录的聚合结果, 无结果返回默认值
      等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
      如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
      default Number getNumberResult​(Class entityClass, FilterFunc func, String column)
      获取符合过滤条件记录的聚合结果, 无结果返回null
      等价SQL: SELECT FUNC{column} FROM {table}
      如 getNumberResultAsync(User.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table}
      default Number getNumberResult​(Class entityClass, FilterFunc func, String column, FilterBean bean)
      获取符合过滤条件记录的聚合结果, 无结果返回null
      等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
      如 getNumberResultAsync(User.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
      default Number getNumberResult​(Class entityClass, FilterFunc func, String column, FilterNode node)
      获取符合过滤条件记录的聚合结果, 无结果返回null
      等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
      如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
      default CompletableFuture<Number> getNumberResultAsync​(Class entityClass, FilterFunc func, Number defVal, String column)
      获取符合过滤条件记录的聚合结果, 无结果返回默认值
      等价SQL: SELECT FUNC{column} FROM {table}
      如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table}
      default CompletableFuture<Number> getNumberResultAsync​(Class entityClass, FilterFunc func, Number defVal, String column, FilterBean bean)
      获取符合过滤条件记录的聚合结果, 无结果返回默认值
      等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
      如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
      CompletableFuture<Number> getNumberResultAsync​(Class entityClass, FilterFunc func, Number defVal, String column, FilterNode node)
      获取符合过滤条件记录的聚合结果, 无结果返回默认值
      等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
      如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
      default CompletableFuture<Number> getNumberResultAsync​(Class entityClass, FilterFunc func, String column)
      获取符合过滤条件记录的聚合结果, 无结果返回null
      等价SQL: SELECT FUNC{column} FROM {table}
      如 getNumberResultAsync(User.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table}
      default CompletableFuture<Number> getNumberResultAsync​(Class entityClass, FilterFunc func, String column, FilterBean bean)
      获取符合过滤条件记录的聚合结果, 无结果返回null
      等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
      如 getNumberResultAsync(User.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
      default CompletableFuture<Number> getNumberResultAsync​(Class entityClass, FilterFunc func, String column, FilterNode node)
      获取符合过滤条件记录的聚合结果, 无结果返回null
      等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
      如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
      String getType()
      获取数据源类型
      default <T> int insert​(Collection<T> entitys)
      新增记录， 多对象必须是同一个Entity类且必须在同一张表中
      default <T> int insert​(Stream<T> entitys)
      新增记录， 多对象必须是同一个Entity类且必须在同一张表中
      <T> int insert​(T... entitys)
      新增记录， 多对象必须是同一个Entity类且必须在同一张表中
      default <T> CompletableFuture<Integer> insertAsync​(Collection<T> entitys)
      新增记录， 多对象必须是同一个Entity类且必须在同一张表中
      default <T> CompletableFuture<Integer> insertAsync​(Stream<T> entitys)
      新增记录， 多对象必须是同一个Entity类且必须在同一张表中
      <T> CompletableFuture<Integer> insertAsync​(T... entitys)
      新增记录， 多对象必须是同一个Entity类且必须在同一张表中
      <T,​V extends Serializable>
      List<V>      		 queryColumnList​(String selectedColumn, Class<T> clazz, String column, Serializable colval)
      查询符合过滤条件记录的某个字段List集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
      default <T,​V extends Serializable>
      List<V>      		 queryColumnList​(String selectedColumn, Class<T> clazz, FilterBean bean)
      查询符合过滤条件记录的某个字段List集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
      default <T,​V extends Serializable>
      List<V>      		 queryColumnList​(String selectedColumn, Class<T> clazz, FilterNode node)
      查询符合过滤条件记录的某个字段List集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
      default <T,​V extends Serializable>
      List<V>      		 queryColumnList​(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的某个字段List集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T,​V extends Serializable>
      List<V>      		 queryColumnList​(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的某个字段List集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T,​V extends Serializable>
      CompletableFuture<List<V>>      		 queryColumnListAsync​(String selectedColumn, Class<T> clazz, String column, Serializable colval)
      查询符合过滤条件记录的某个字段List集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
      default <T,​V extends Serializable>
      CompletableFuture<List<V>>      		 queryColumnListAsync​(String selectedColumn, Class<T> clazz, FilterBean bean)
      查询符合过滤条件记录的某个字段List集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
      default <T,​V extends Serializable>
      CompletableFuture<List<V>>      		 queryColumnListAsync​(String selectedColumn, Class<T> clazz, FilterNode node)
      查询符合过滤条件记录的某个字段List集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
      default <T,​V extends Serializable>
      CompletableFuture<List<V>>      		 queryColumnListAsync​(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的某个字段List集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T,​V extends Serializable>
      CompletableFuture<List<V>>      		 queryColumnListAsync​(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的某个字段List集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T,​K extends Serializable,​N extends Number>
      Map<K,​N>      		 queryColumnMap​(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn)
      查询符合过滤条件记录的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
      default <T,​K extends Serializable,​N extends Number>
      Map<K,​N>      		 queryColumnMap​(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn, FilterBean bean)
      查询符合过滤条件记录的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
      <T,​K extends Serializable,​N extends Number>
      Map<K,​N>      		 queryColumnMap​(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn, FilterNode node)
      查询符合过滤条件记录的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
      default <T,​K extends Serializable,​N extends Number>
      Map<K,​N[]>      		 queryColumnMap​(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn)
      查询符合过滤条件记录的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
      default <T,​K extends Serializable,​N extends Number>
      Map<K[],​N[]>      		 queryColumnMap​(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns)
      查询符合过滤条件记录的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
      default <T,​K extends Serializable,​N extends Number>
      Map<K[],​N[]>      		 queryColumnMap​(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterBean bean)
      查询符合过滤条件记录的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
      <T,​K extends Serializable,​N extends Number>
      Map<K[],​N[]>      		 queryColumnMap​(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)
      查询符合过滤条件记录的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
      default <T,​K extends Serializable,​N extends Number>
      Map<K,​N[]>      		 queryColumnMap​(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterBean bean)
      查询符合过滤条件记录的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
      <T,​K extends Serializable,​N extends Number>
      Map<K,​N[]>      		 queryColumnMap​(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterNode node)
      查询符合过滤条件记录的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
      default <T,​K extends Serializable,​N extends Number>
      CompletableFuture<Map<K,​N>>      		 queryColumnMapAsync​(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn)
      查询符合过滤条件记录的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
      default <T,​K extends Serializable,​N extends Number>
      CompletableFuture<Map<K,​N>>      		 queryColumnMapAsync​(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn, FilterBean bean)
      查询符合过滤条件记录的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
      <T,​K extends Serializable,​N extends Number>
      CompletableFuture<Map<K,​N>>      		 queryColumnMapAsync​(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn, FilterNode node)
      查询符合过滤条件记录的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
      default <T,​K extends Serializable,​N extends Number>
      CompletableFuture<Map<K,​N[]>>      		 queryColumnMapAsync​(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn)
      查询符合过滤条件记录的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
      default <T,​K extends Serializable,​N extends Number>
      CompletableFuture<Map<K[],​N[]>>      		 queryColumnMapAsync​(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns)
      查询符合过滤条件记录的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
      default <T,​K extends Serializable,​N extends Number>
      CompletableFuture<Map<K[],​N[]>>      		 queryColumnMapAsync​(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterBean bean)
      查询符合过滤条件记录的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
      <T,​K extends Serializable,​N extends Number>
      CompletableFuture<Map<K[],​N[]>>      		 queryColumnMapAsync​(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)
      查询符合过滤条件记录的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
      default <T,​K extends Serializable,​N extends Number>
      CompletableFuture<Map<K,​N[]>>      		 queryColumnMapAsync​(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterBean bean)
      查询符合过滤条件记录的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
      <T,​K extends Serializable,​N extends Number>
      CompletableFuture<Map<K,​N[]>>      		 queryColumnMapAsync​(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterNode node)
      查询符合过滤条件记录的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
      <T,​V extends Serializable>
      Set<V>      		 queryColumnSet​(String selectedColumn, Class<T> clazz, String column, Serializable colval)
      查询符合过滤条件记录的某个字段Set集合
      等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {column} = {key}
      default <T,​V extends Serializable>
      Set<V>      		 queryColumnSet​(String selectedColumn, Class<T> clazz, FilterBean bean)
      查询符合过滤条件记录的某个字段Set集合
      等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter bean}
      default <T,​V extends Serializable>
      Set<V>      		 queryColumnSet​(String selectedColumn, Class<T> clazz, FilterNode node)
      查询符合过滤条件记录的某个字段Set集合
      等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node}
      default <T,​V extends Serializable>
      Set<V>      		 queryColumnSet​(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的某个字段Set集合
      等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T,​V extends Serializable>
      Set<V>      		 queryColumnSet​(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的某个字段Set集合
      等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T,​V extends Serializable>
      CompletableFuture<Set<V>>      		 queryColumnSetAsync​(String selectedColumn, Class<T> clazz, String column, Serializable colval)
      查询符合过滤条件记录的某个字段Set集合
      等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {column} = {key}
      default <T,​V extends Serializable>
      CompletableFuture<Set<V>>      		 queryColumnSetAsync​(String selectedColumn, Class<T> clazz, FilterBean bean)
      查询符合过滤条件记录的某个字段Set集合
      等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter bean}
      default <T,​V extends Serializable>
      CompletableFuture<Set<V>>      		 queryColumnSetAsync​(String selectedColumn, Class<T> clazz, FilterNode node)
      查询符合过滤条件记录的某个字段Set集合
      等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node}
      default <T,​V extends Serializable>
      CompletableFuture<Set<V>>      		 queryColumnSetAsync​(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的某个字段Set集合
      等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T,​V extends Serializable>
      CompletableFuture<Set<V>>      		 queryColumnSetAsync​(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的某个字段Set集合
      等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T,​V extends Serializable>
      Sheet<V>      		 queryColumnSheet​(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的某个字段Sheet集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T,​V extends Serializable>
      Sheet<V>      		 queryColumnSheet​(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的某个字段Sheet集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T,​V extends Serializable,​F extends FilterBean>
      Sheet<V>      		 queryColumnSheet​(String selectedColumn, Class<T> clazz, PageBean<F> pageBean)
      查询符合过滤条件记录的某个字段Sheet集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T,​V extends Serializable>
      CompletableFuture<Sheet<V>>      		 queryColumnSheetAsync​(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的某个字段Sheet集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T,​V extends Serializable>
      CompletableFuture<Sheet<V>>      		 queryColumnSheetAsync​(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的某个字段Sheet集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T,​V extends Serializable,​F extends FilterBean>
      CompletableFuture<Sheet<V>>      		 queryColumnSheetAsync​(String selectedColumn, Class<T> clazz, PageBean<F> pageBean)
      查询符合过滤条件记录的某个字段Sheet集合
      等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> List<T> queryList​(Class<T> clazz)
      查询记录的List集合
      等价SQL: SELECT * FROM {table}
      default <T> List<T> queryList​(Class<T> clazz, String column, Serializable colval)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> List<T> queryList​(Class<T> clazz, FilterBean bean)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} WHERE {filter bean}
      default <T> List<T> queryList​(Class<T> clazz, FilterNode node)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} WHERE {filter node}
      default <T> List<T> queryList​(Class<T> clazz, Flipper flipper)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T> List<T> queryList​(Class<T> clazz, Flipper flipper, String column, Serializable colval)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> List<T> queryList​(Class<T> clazz, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> List<T> queryList​(Class<T> clazz, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> List<T> queryList​(Class<T> clazz, SelectColumn selects, FilterBean bean)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
      default <T> List<T> queryList​(Class<T> clazz, SelectColumn selects, FilterNode node)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
      default <T> List<T> queryList​(Class<T> clazz, SelectColumn selects, Flipper flipper)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> List<T> queryList​(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T> List<T> queryList​(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz)
      查询记录的List集合
      等价SQL: SELECT * FROM {table}
      default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz, String column, Serializable colval)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz, FilterBean bean)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} WHERE {filter bean}
      default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz, FilterNode node)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} WHERE {filter node}
      default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz, Flipper flipper)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz, Flipper flipper, String column, Serializable colval)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz, SelectColumn selects, FilterBean bean)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
      default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz, SelectColumn selects, FilterNode node)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
      default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz, SelectColumn selects, Flipper flipper)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的List集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <K extends Serializable,​T>
      Map<K,​T>      		 queryMap​(Class<T> clazz, Stream<K> keyStream)
      查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
      等价SQL: SELECT * FROM {table} WHERE id IN {ids}
      default <K extends Serializable,​T>
      Map<K,​T>      		 queryMap​(Class<T> clazz, FilterBean bean)
      查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
      等价SQL: SELECT * FROM {table} WHERE {filter node}
      default <K extends Serializable,​T>
      Map<K,​T>      		 queryMap​(Class<T> clazz, FilterNode node)
      查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
      等价SQL: SELECT * FROM {table} WHERE {filter node}
      <K extends Serializable,​T>
      Map<K,​T>      		 queryMap​(Class<T> clazz, SelectColumn selects, Stream<K> keyStream)
      查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
      等价SQL: SELECT * FROM {table} WHERE id IN {ids}
      default <K extends Serializable,​T>
      Map<K,​T>      		 queryMap​(Class<T> clazz, SelectColumn selects, FilterBean bean)
      查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
      等价SQL: SELECT * FROM {table} WHERE {filter node}
      <K extends Serializable,​T>
      Map<K,​T>      		 queryMap​(Class<T> clazz, SelectColumn selects, FilterNode node)
      查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
      等价SQL: SELECT * FROM {table} WHERE {filter node}
      default <K extends Serializable,​T>
      CompletableFuture<Map<K,​T>>      		 queryMapAsync​(Class<T> clazz, Stream<K> keyStream)
      查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
      等价SQL: SELECT * FROM {table} WHERE id IN {ids}
      default <K extends Serializable,​T>
      CompletableFuture<Map<K,​T>>      		 queryMapAsync​(Class<T> clazz, FilterBean bean)
      查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
      等价SQL: SELECT * FROM {table} WHERE {filter node}
      default <K extends Serializable,​T>
      CompletableFuture<Map<K,​T>>      		 queryMapAsync​(Class<T> clazz, FilterNode node)
      查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
      等价SQL: SELECT * FROM {table} WHERE {filter node}
      <K extends Serializable,​T>
      CompletableFuture<Map<K,​T>>      		 queryMapAsync​(Class<T> clazz, SelectColumn selects, Stream<K> keyStream)
      查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
      等价SQL: SELECT * FROM {table} WHERE id IN {ids}
      default <K extends Serializable,​T>
      CompletableFuture<Map<K,​T>>      		 queryMapAsync​(Class<T> clazz, SelectColumn selects, FilterBean bean)
      查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
      等价SQL: SELECT * FROM {table} WHERE {filter node}
      <K extends Serializable,​T>
      CompletableFuture<Map<K,​T>>      		 queryMapAsync​(Class<T> clazz, SelectColumn selects, FilterNode node)
      查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
      等价SQL: SELECT * FROM {table} WHERE {filter node}
      default <T> Set<T> querySet​(Class<T> clazz)
      查询记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table}
      default <T> Set<T> querySet​(Class<T> clazz, String column, Serializable colval)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> Set<T> querySet​(Class<T> clazz, FilterBean bean)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean}
      default <T> Set<T> querySet​(Class<T> clazz, FilterNode node)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node}
      <T> Set<T> querySet​(Class<T> clazz, Flipper flipper, String column, Serializable colval)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> Set<T> querySet​(Class<T> clazz, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> Set<T> querySet​(Class<T> clazz, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> Set<T> querySet​(Class<T> clazz, SelectColumn selects, FilterBean bean)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
      default <T> Set<T> querySet​(Class<T> clazz, SelectColumn selects, FilterNode node)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node}
      default <T> Set<T> querySet​(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T> Set<T> querySet​(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz)
      查询记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table}
      default <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz, String column, Serializable colval)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz, FilterBean bean)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean}
      default <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz, FilterNode node)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node}
      <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz, Flipper flipper, String column, Serializable colval)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz, SelectColumn selects, FilterBean bean)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
      default <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz, SelectColumn selects, FilterNode node)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node}
      default <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的Set集合
      等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> Sheet<T> querySheet​(Class<T> clazz, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的Sheet集合
      等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> Sheet<T> querySheet​(Class<T> clazz, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的Sheet集合
      等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T,​F extends FilterBean>
      Sheet<T>      		 querySheet​(Class<T> clazz, PageBean<F> pageBean)
      查询符合过滤条件记录的Sheet集合
      等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> Sheet<T> querySheet​(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的Sheet集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T> Sheet<T> querySheet​(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的Sheet集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T,​F extends FilterBean>
      Sheet<T>      		 querySheet​(Class<T> clazz, SelectColumn selects, PageBean<F> pageBean)
      查询符合过滤条件记录的Sheet集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<Sheet<T>> querySheetAsync​(Class<T> clazz, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的Sheet集合
      等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<Sheet<T>> querySheetAsync​(Class<T> clazz, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的Sheet集合
      等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T,​F extends FilterBean>
      CompletableFuture<Sheet<T>>      		 querySheetAsync​(Class<T> clazz, PageBean<F> pageBean)
      查询符合过滤条件记录的Sheet集合
      等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> CompletableFuture<Sheet<T>> querySheetAsync​(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
      查询符合过滤条件记录的Sheet集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      <T> CompletableFuture<Sheet<T>> querySheetAsync​(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
      查询符合过滤条件记录的Sheet集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T,​F extends FilterBean>
      CompletableFuture<Sheet<T>>      		 querySheetAsync​(Class<T> clazz, SelectColumn selects, PageBean<F> pageBean)
      查询符合过滤条件记录的Sheet集合
      等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
      default <T> int update​(Collection<T> entitys)
      更新记录， 多对象必须是同一个Entity类且必须在同一张表中
      等价SQL:
      UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
      UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
      ···
      default <T> int update​(Stream<T> entitys)
      更新记录， 多对象必须是同一个Entity类且必须在同一张表中
      等价SQL:
      UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
      UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
      ···
      <T> int update​(T... entitys)
      更新记录， 多对象必须是同一个Entity类且必须在同一张表中
      等价SQL:
      UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
      UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
      ···
      default <T> CompletableFuture<Integer> updateAsync​(Collection<T> entitys)
      更新记录， 多对象必须是同一个Entity类且必须在同一张表中
      等价SQL:
      UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
      UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
      ···
      default <T> CompletableFuture<Integer> updateAsync​(Stream<T> entitys)
      更新记录， 多对象必须是同一个Entity类且必须在同一张表中
      等价SQL:
      UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
      UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
      ···
      <T> CompletableFuture<Integer> updateAsync​(T... entitys)
      更新记录， 多对象必须是同一个Entity类且必须在同一张表中
      等价SQL:
      UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
      UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
      ···
      <T> int updateColumn​(Class<T> clazz, Serializable pk, String column, Serializable value)
      更新单个记录的单个字段
      注意：即使字段标记为@Column(updatable=false)也会被更新
      等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
      <T> int updateColumn​(Class<T> clazz, Serializable pk, ColumnValue... values)
      更新指定主键值记录的部分字段
      字段赋值操作选项见 ColumnExpress
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
      default <T> int updateColumn​(Class<T> clazz, Serializable pk, ColumnValues values)
      更新指定主键值记录的部分字段
      字段赋值操作选项见 ColumnExpress
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
      default <T> int updateColumn​(Class<T> clazz, Serializable pk, LambdaFunction<T,​?> func, Serializable value)
      更新指定主键值记录的部分字段
      字段赋值操作选项见 ColumnExpress
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
      default <T,​V extends Serializable>
      int      		 updateColumn​(Class<T> clazz, Serializable pk, LambdaSupplier<V> func)
      更新单个记录的单个字段
      注意：即使字段标记为@Column(updatable=false)也会被更新
      等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
      <T> int updateColumn​(Class<T> clazz, String column, Serializable value, FilterNode node)
      更新符合过滤条件记录的单个字段
      注意：即使字段标记为@Column(updatable=false)也会被更新
      等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
      default <T> int updateColumn​(Class<T> clazz, FilterNode node, ColumnValue... values)
      更新符合过滤条件记录的部分字段
      字段赋值操作选项见 ColumnExpress
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
      default <T> int updateColumn​(Class<T> clazz, FilterNode node, ColumnValues values)
      更新符合过滤条件记录的部分字段
      字段赋值操作选项见 ColumnExpress
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
      <T> int updateColumn​(Class<T> clazz, FilterNode node, Flipper flipper, ColumnValue... values)
      更新符合过滤条件的记录的指定字段
      Flipper中offset字段将被忽略
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}
      default <T> int updateColumn​(Class<T> clazz, FilterNode node, Flipper flipper, ColumnValues values)
      更新符合过滤条件的记录的指定字段
      Flipper中offset字段将被忽略
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}
      default <T,​V extends Serializable>
      int      		 updateColumn​(Class<T> clazz, LambdaSupplier<V> func, FilterNode node)
      更新符合过滤条件记录的单个字段
      注意：即使字段标记为@Column(updatable=false)也会被更新
      等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
      default <T> int updateColumn​(T entity, String... columns)
      更新单个记录的指定字段
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
      <T> int updateColumn​(T entity, FilterNode node, String... columns)
      更新符合过滤条件记录的指定字段
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
      default <T> int updateColumn​(T entity, FilterNode node, LambdaFunction<T,​?>... funcs)
      更新符合过滤条件记录的指定字段
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
      <T> int updateColumn​(T entity, FilterNode node, SelectColumn selects)
      更新符合过滤条件记录的指定字段
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
      default <T> int updateColumn​(T entity, LambdaFunction<T,​?>... funcs)
      更新单个记录的指定字段
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
      default <T> int updateColumn​(T entity, SelectColumn selects)
      更新单个记录的指定字段
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
      <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz, Serializable pk, String column, Serializable value)
      更新单个记录的单个字段
      注意：即使字段标记为@Column(updatable=false)也会被更新
      等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
      <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz, Serializable pk, ColumnValue... values)
      更新指定主键值记录的部分字段
      字段赋值操作选项见 ColumnExpress
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
      default <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz, Serializable pk, ColumnValues values)
      更新指定主键值记录的部分字段
      字段赋值操作选项见 ColumnExpress
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
      default <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz, Serializable pk, LambdaFunction<T,​?> func, Serializable value)
      更新指定主键值记录的部分字段
      字段赋值操作选项见 ColumnExpress
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
      default <T,​V extends Serializable>
      CompletableFuture<Integer>      		 updateColumnAsync​(Class<T> clazz, Serializable pk, LambdaSupplier<V> func)
      更新单个记录的单个字段
      注意：即使字段标记为@Column(updatable=false)也会被更新
      等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
      <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz, String column, Serializable value, FilterNode node)
      更新符合过滤条件记录的单个字段
      注意：即使字段标记为@Column(updatable=false)也会被更新
      等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
      default <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz, FilterNode node, ColumnValue... values)
      更新符合过滤条件记录的部分字段
      字段赋值操作选项见 ColumnExpress
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
      default <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz, FilterNode node, ColumnValues values)
      更新符合过滤条件记录的部分字段
      字段赋值操作选项见 ColumnExpress
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
      <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz, FilterNode node, Flipper flipper, ColumnValue... values)
      更新符合过滤条件的记录的指定字段
      Flipper中offset字段将被忽略
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}
      default <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz, FilterNode node, Flipper flipper, ColumnValues values)
      更新符合过滤条件的记录的指定字段
      Flipper中offset字段将被忽略
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}
      default <T,​V extends Serializable>
      CompletableFuture<Integer>      		 updateColumnAsync​(Class<T> clazz, LambdaSupplier<V> func, FilterNode node)
      更新符合过滤条件记录的单个字段
      注意：即使字段标记为@Column(updatable=false)也会被更新
      等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
      default <T> CompletableFuture<Integer> updateColumnAsync​(T entity, String... columns)
      更新单个记录的指定字段
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
      <T> CompletableFuture<Integer> updateColumnAsync​(T entity, FilterNode node, String... columns)
      更新符合过滤条件记录的指定字段
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
      default <T> CompletableFuture<Integer> updateColumnAsync​(T entity, FilterNode node, LambdaFunction<T,​?>... funcs)
      更新符合过滤条件记录的指定字段
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
      <T> CompletableFuture<Integer> updateColumnAsync​(T entity, FilterNode node, SelectColumn selects)
      更新符合过滤条件记录的指定字段
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
      default <T> CompletableFuture<Integer> updateColumnAsync​(T entity, LambdaFunction<T,​?>... funcs)
      更新单个记录的指定字段
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
      default <T> CompletableFuture<Integer> updateColumnAsync​(T entity, SelectColumn selects)
      更新单个记录的指定字段
      注意：Entity类中标记为@Column(updatable=false)不会被更新
      等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}

    • 方法详细资料

      • getType

        String getType()
        获取数据源类型
        返回:
        String

      • compile

        <T> void compile​(Class<T> clazz)
        提取预编译Entity类，主要用于native-image使用
        类型参数:
        T - 泛型
        参数:
        clazz - Entity实体类

      • batch

        int batch​(DataBatch batch)
        增删改的批量操作
        参数:
        batch - 批量对象
        返回:
        -1表示失败，正数为成功

      • batchAsync

        CompletableFuture<Integer> batchAsync​(DataBatch batch)
        增删改的批量操作
        参数:
        batch - 批量对象
        返回:
        -1表示失败，正数为成功

      • insert

        <T> int insert​(T... entitys)
        新增记录， 多对象必须是同一个Entity类且必须在同一张表中
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数

      • insert

        default <T> int insert​(Collection<T> entitys)
        新增记录， 多对象必须是同一个Entity类且必须在同一张表中
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数

      • insert

        default <T> int insert​(Stream<T> entitys)
        新增记录， 多对象必须是同一个Entity类且必须在同一张表中
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数

      • insertAsync

        <T> CompletableFuture<Integer> insertAsync​(T... entitys)
        新增记录， 多对象必须是同一个Entity类且必须在同一张表中
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        CompletableFuture

      • insertAsync

        default <T> CompletableFuture<Integer> insertAsync​(Collection<T> entitys)
        新增记录， 多对象必须是同一个Entity类且必须在同一张表中
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        CompletableFuture

      • insertAsync

        default <T> CompletableFuture<Integer> insertAsync​(Stream<T> entitys)
        新增记录， 多对象必须是同一个Entity类且必须在同一张表中
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        CompletableFuture

      • delete

        <T> int delete​(T... entitys)
        删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
        等价SQL: DELETE FROM {table} WHERE {primary} IN {getValues.id}
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数

      • delete

        default <T> int delete​(Collection<T> entitys)
        删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
        等价SQL: DELETE FROM {table} WHERE {primary} IN {getValues.id}
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数

      • delete

        default <T> int delete​(Stream<T> entitys)
        删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
        等价SQL: DELETE FROM {table} WHERE {primary} IN {getValues.id}
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数

      • deleteAsync

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

      • deleteAsync

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

      • deleteAsync

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

      • delete

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

      • deleteAsync

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

      • delete

        default <T> int delete​(Class<T> clazz,
                       FilterNode node)
        删除符合过滤条件的记录
        等价SQL: DELETE FROM {table} WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        影响的记录条数

      • deleteAsync

        default <T> CompletableFuture<Integer> deleteAsync​(Class<T> clazz,
                                                   FilterNode node)
        删除符合过滤条件的记录
        等价SQL: DELETE FROM {table} WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        影响的记录条数CompletableFuture

      • delete

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

      • deleteAsync

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

      • clearTable

        default <T> int clearTable​(Class<T> clazz)
        清空表
        等价SQL: TRUNCATE TABLE {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        返回:
        影响的记录条数 -1表示表不存在

      • clearTableAsync

        default <T> CompletableFuture<Integer> clearTableAsync​(Class<T> clazz)
        清空表
        等价SQL: TRUNCATE TABLE {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        返回:
        影响的记录条数CompletableFuture -1表示表不存在

      • clearTable

        <T> int clearTable​(Class<T> clazz,
                   FilterNode node)
        清空表
        等价SQL: TRUNCATE TABLE {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 分库分表的过滤条件
        返回:
        影响的记录条数 -1表示表不存在

      • clearTableAsync

        <T> CompletableFuture<Integer> clearTableAsync​(Class<T> clazz,
                                               FilterNode node)
        清空表
        等价SQL: TRUNCATE TABLE {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 分库分表的过滤条件
        返回:
        影响的记录条数CompletableFuture -1表示表不存在

      • createTable

        <T> int createTable​(Class<T> clazz,
                    Serializable pk)
        删除表
        等价SQL: DROP TABLE {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键
        返回:
        建表结果

      • createTableAsync

        <T> CompletableFuture<Integer> createTableAsync​(Class<T> clazz,
                                                Serializable pk)
        删除表
        等价SQL: DROP TABLE {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键
        返回:
        建表结果

      • dropTable

        default <T> int dropTable​(Class<T> clazz)
        删除表
        等价SQL: DROP TABLE {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        返回:
        影响的记录条数 -1表示表不存在

      • dropTableAsync

        default <T> CompletableFuture<Integer> dropTableAsync​(Class<T> clazz)
        删除表
        等价SQL: DROP TABLE {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        返回:
        影响的记录条数CompletableFuture -1表示表不存在

      • dropTable

        <T> int dropTable​(Class<T> clazz,
                  FilterNode node)
        删除表
        等价SQL: DROP TABLE {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        影响的记录条数 -1表示表不存在

      • dropTableAsync

        <T> CompletableFuture<Integer> dropTableAsync​(Class<T> clazz,
                                              FilterNode node)
        删除表
        等价SQL: DROP TABLE {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 分库分表的过滤条件
        返回:
        影响的记录条数CompletableFuture -1表示表不存在

      • update

        <T> int update​(T... entitys)
        更新记录， 多对象必须是同一个Entity类且必须在同一张表中
        等价SQL:
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
        ···
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数

      • update

        default <T> int update​(Collection<T> entitys)
        更新记录， 多对象必须是同一个Entity类且必须在同一张表中
        等价SQL:
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
        ···
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数

      • update

        default <T> int update​(Stream<T> entitys)
        更新记录， 多对象必须是同一个Entity类且必须在同一张表中
        等价SQL:
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
        ···
        类型参数:
        T - 泛型
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数

      • updateAsync

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

      • updateAsync

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

      • updateAsync

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

      • updateColumn

        <T> int updateColumn​(Class<T> clazz,
                     Serializable pk,
                     String column,
                     Serializable value)
        更新单个记录的单个字段
        注意：即使字段标记为@Column(updatable=false)也会被更新
        等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键
        column - 待更新的字段名
        value - 更新值
        返回:
        影响的记录条数

      • updateColumn

        default <T,​V extends Serializable> int updateColumn​(Class<T> clazz,
                                                          Serializable pk,
                                                          LambdaSupplier<V> func)
        更新单个记录的单个字段
        注意：即使字段标记为@Column(updatable=false)也会被更新
        等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
        类型参数:
        T - Entity泛型
        V - 更新值泛型
        参数:
        clazz - Entity类
        pk - 主键
        func - 更新值Lambda
        返回:
        影响的记录条数

      • updateColumnAsync

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

      • updateColumnAsync

        default <T,​V extends Serializable> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz,
                                                                                      Serializable pk,
                                                                                      LambdaSupplier<V> func)
        更新单个记录的单个字段
        注意：即使字段标记为@Column(updatable=false)也会被更新
        等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
        类型参数:
        T - Entity泛型
        V - 更新值泛型
        参数:
        clazz - Entity类
        pk - 主键
        func - 更新值Lambda
        返回:
        影响的记录条数

      • updateColumn

        <T> int updateColumn​(Class<T> clazz,
                     String column,
                     Serializable value,
                     FilterNode node)
        更新符合过滤条件记录的单个字段
        注意：即使字段标记为@Column(updatable=false)也会被更新
        等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        column - 待更新的字段名
        value - 更新值
        node - 过滤条件
        返回:
        影响的记录条数

      • updateColumn

        default <T,​V extends Serializable> int updateColumn​(Class<T> clazz,
                                                          LambdaSupplier<V> func,
                                                          FilterNode node)
        更新符合过滤条件记录的单个字段
        注意：即使字段标记为@Column(updatable=false)也会被更新
        等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
        类型参数:
        T - Entity泛型
        V - 更新值泛型
        参数:
        clazz - Entity类
        func - 更新值Lambda
        node - 过滤条件
        返回:
        影响的记录条数

      • updateColumnAsync

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

      • updateColumnAsync

        default <T,​V extends Serializable> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz,
                                                                                      LambdaSupplier<V> func,
                                                                                      FilterNode node)
        更新符合过滤条件记录的单个字段
        注意：即使字段标记为@Column(updatable=false)也会被更新
        等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
        类型参数:
        T - Entity泛型
        V - 更新值泛型
        参数:
        clazz - Entity类
        func - 更新值Lambda
        node - 过滤条件
        返回:
        影响的记录条数

      • updateColumn

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

      • updateColumn

        default <T> int updateColumn​(Class<T> clazz,
                             Serializable pk,
                             ColumnValues values)
        更新指定主键值记录的部分字段
        字段赋值操作选项见 ColumnExpress
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键
        values - 更新字段
        返回:
        影响的记录条数

      • updateColumn

        default <T> int updateColumn​(Class<T> clazz,
                             Serializable pk,
                             LambdaFunction<T,​?> func,
                             Serializable value)
        更新指定主键值记录的部分字段
        字段赋值操作选项见 ColumnExpress
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键
        func - 更新字段
        value - 更新字段值
        返回:
        影响的记录条数

      • updateColumnAsync

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

      • updateColumnAsync

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

      • updateColumnAsync

        default <T> CompletableFuture<Integer> updateColumnAsync​(Class<T> clazz,
                                                         Serializable pk,
                                                         LambdaFunction<T,​?> func,
                                                         Serializable value)
        更新指定主键值记录的部分字段
        字段赋值操作选项见 ColumnExpress
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键
        func - 更新字段
        value - 更新字段值
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

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

      • updateColumn

        default <T> int updateColumn​(Class<T> clazz,
                             FilterNode node,
                             ColumnValues values)
        更新符合过滤条件记录的部分字段
        字段赋值操作选项见 ColumnExpress
        注意：Entity类中标记为@Column(updatable=false)不会被更新
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        values - 更新字段
        返回:
        影响的记录条数

      • updateColumnAsync

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

      • updateColumnAsync

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

      • updateColumn

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

      • updateColumn

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

      • updateColumnAsync

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

      • updateColumnAsync

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

      • updateColumn

        default <T> int updateColumn​(T entity,
                             String... columns)
        更新单个记录的指定字段
        注意：Entity类中标记为@Column(updatable=false)不会被更新
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
        类型参数:
        T - Entity泛型
        参数:
        entity - 待更新的Entity对象
        columns - 需更新的字段名
        返回:
        影响的记录条数

      • updateColumn

        default <T> int updateColumn​(T entity,
                             LambdaFunction<T,​?>... funcs)
        更新单个记录的指定字段
        注意：Entity类中标记为@Column(updatable=false)不会被更新
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
        类型参数:
        T - Entity泛型
        参数:
        entity - 待更新的Entity对象
        funcs - 需更新的字段名Lambda集合
        返回:
        影响的记录条数

      • updateColumnAsync

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

      • updateColumnAsync

        default <T> CompletableFuture<Integer> updateColumnAsync​(T entity,
                                                         LambdaFunction<T,​?>... funcs)
        更新单个记录的指定字段
        注意：Entity类中标记为@Column(updatable=false)不会被更新
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
        类型参数:
        T - Entity泛型
        参数:
        entity - 待更新的Entity对象
        funcs - 需更新的字段名Lambda集合
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

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

      • updateColumn

        default <T> int updateColumn​(T entity,
                             FilterNode node,
                             LambdaFunction<T,​?>... funcs)
        更新符合过滤条件记录的指定字段
        注意：Entity类中标记为@Column(updatable=false)不会被更新
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        entity - 待更新的Entity对象
        node - 过滤条件
        funcs - 需更新的字段名Lambda集合
        返回:
        影响的记录条数

      • updateColumnAsync

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

      • updateColumnAsync

        default <T> CompletableFuture<Integer> updateColumnAsync​(T entity,
                                                         FilterNode node,
                                                         LambdaFunction<T,​?>... funcs)
        更新符合过滤条件记录的指定字段
        注意：Entity类中标记为@Column(updatable=false)不会被更新
        等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        entity - 待更新的Entity对象
        node - 过滤条件
        funcs - 需更新的字段名Lambda集合
        返回:
        影响的记录条数

      • updateColumn

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

      • updateColumnAsync

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

      • updateColumn

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

      • updateColumnAsync

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

      • getNumberResult

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

      • getNumberResultAsync

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

      • getNumberResult

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

      • getNumberResultAsync

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

      • getNumberResult

        default Number getNumberResult​(Class entityClass,
                               FilterFunc func,
                               String column,
                               FilterNode node)
        获取符合过滤条件记录的聚合结果, 无结果返回null
        等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
        如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
        参数:
        entityClass - Entity类
        func - 聚合函数
        column - 指定字段
        node - 过滤条件
        返回:
        聚合结果

      • getNumberResultAsync

        default CompletableFuture<Number> getNumberResultAsync​(Class entityClass,
                                                       FilterFunc func,
                                                       String column,
                                                       FilterNode node)
        获取符合过滤条件记录的聚合结果, 无结果返回null
        等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
        如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
        参数:
        entityClass - Entity类
        func - 聚合函数
        column - 指定字段
        node - 过滤条件
        返回:
        聚合结果

      • getNumberResult

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

      • getNumberResultAsync

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

      • getNumberResult

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

      • getNumberResultAsync

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

      • getNumberResult

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

      • getNumberResultAsync

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

      • getNumberMap

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

      • getNumberMapAsync

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

      • getNumberMap

        default <N extends Number> Map<String,​N> getNumberMap​(Class entityClass,
                                                            FilterBean bean,
                                                            FilterFuncColumn... columns)
        获取符合过滤条件记录的聚合结果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}
        类型参数:
        N - Number
        参数:
        entityClass - Entity类
        bean - 过滤条件
        columns - 聚合字段
        返回:
        聚合结果Map

      • getNumberMapAsync

        default <N extends Number> CompletableFuture<Map<String,​N>> getNumberMapAsync​(Class entityClass,
                                                                                    FilterBean bean,
                                                                                    FilterFuncColumn... columns)
        获取符合过滤条件记录的聚合结果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}
        类型参数:
        N - Number
        参数:
        entityClass - Entity类
        bean - 过滤条件
        columns - 聚合字段
        返回:
        聚合结果Map CompletableFuture

      • getNumberMap

        <N extends Number> Map<String,​N> getNumberMap​(Class entityClass,
                                                    FilterNode node,
                                                    FilterFuncColumn... columns)
        获取符合过滤条件记录的聚合结果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}
        类型参数:
        N - Number
        参数:
        entityClass - Entity类
        node - 过滤条件
        columns - 聚合字段
        返回:
        聚合结果Map

      • getNumberMapAsync

        <N extends Number> CompletableFuture<Map<String,​N>> getNumberMapAsync​(Class entityClass,
                                                                            FilterNode node,
                                                                            FilterFuncColumn... columns)
        获取符合过滤条件记录的聚合结果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}
        类型参数:
        N - Number
        参数:
        entityClass - Entity类
        node - 过滤条件
        columns - 聚合字段
        返回:
        聚合结果Map

      • queryColumnMap

        default <T,​K extends Serializable,​N extends Number> Map<K,​N> queryColumnMap​(Class<T> entityClass,
                                                                                              String keyColumn,
                                                                                              FilterFunc func,
                                                                                              String funcColumn)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        返回:
        聚合结果Map

      • queryColumnMapAsync

        default <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                      String keyColumn,
                                                                                                                      FilterFunc func,
                                                                                                                      String funcColumn)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        default <T,​K extends Serializable,​N extends Number> Map<K,​N> queryColumnMap​(Class<T> entityClass,
                                                                                              String keyColumn,
                                                                                              FilterFunc func,
                                                                                              String funcColumn,
                                                                                              FilterBean bean)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        bean - 过滤条件
        返回:
        聚合结果Map

      • queryColumnMapAsync

        default <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                      String keyColumn,
                                                                                                                      FilterFunc func,
                                                                                                                      String funcColumn,
                                                                                                                      FilterBean bean)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        <T,​K extends Serializable,​N extends Number> Map<K,​N> queryColumnMap​(Class<T> entityClass,
                                                                                      String keyColumn,
                                                                                      FilterFunc func,
                                                                                      String funcColumn,
                                                                                      FilterNode node)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        node - 过滤条件
        返回:
        聚合结果Map

      • queryColumnMapAsync

        <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                              String keyColumn,
                                                                                                              FilterFunc func,
                                                                                                              String funcColumn,
                                                                                                              FilterNode node)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        node - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        default <T,​K extends Serializable,​N extends Number> Map<K,​N[]> queryColumnMap​(Class<T> entityClass,
                                                                                                ColumnNode[] funcNodes,
                                                                                                String groupByColumn)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        default <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N[]>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                        ColumnNode[] funcNodes,
                                                                                                                        String groupByColumn)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        default <T,​K extends Serializable,​N extends Number> Map<K,​N[]> queryColumnMap​(Class<T> entityClass,
                                                                                                ColumnNode[] funcNodes,
                                                                                                String groupByColumn,
                                                                                                FilterBean bean)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        default <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N[]>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                        ColumnNode[] funcNodes,
                                                                                                                        String groupByColumn,
                                                                                                                        FilterBean bean)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        <T,​K extends Serializable,​N extends Number> Map<K,​N[]> queryColumnMap​(Class<T> entityClass,
                                                                                        ColumnNode[] funcNodes,
                                                                                        String groupByColumn,
                                                                                        FilterNode node)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        node - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N[]>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                ColumnNode[] funcNodes,
                                                                                                                String groupByColumn,
                                                                                                                FilterNode node)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        node - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        default <T,​K extends Serializable,​N extends Number> Map<K[],​N[]> queryColumnMap​(Class<T> entityClass,
                                                                                                  ColumnNode[] funcNodes,
                                                                                                  String[] groupByColumns)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        default <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K[],​N[]>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                          ColumnNode[] funcNodes,
                                                                                                                          String[] groupByColumns)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        default <T,​K extends Serializable,​N extends Number> Map<K[],​N[]> queryColumnMap​(Class<T> entityClass,
                                                                                                  ColumnNode[] funcNodes,
                                                                                                  String[] groupByColumns,
                                                                                                  FilterBean bean)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        default <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K[],​N[]>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                          ColumnNode[] funcNodes,
                                                                                                                          String[] groupByColumns,
                                                                                                                          FilterBean bean)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        <T,​K extends Serializable,​N extends Number> Map<K[],​N[]> queryColumnMap​(Class<T> entityClass,
                                                                                          ColumnNode[] funcNodes,
                                                                                          String[] groupByColumns,
                                                                                          FilterNode node)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        node - 过滤条件
        返回:
        聚合结果Map

      • queryColumnMapAsync

        <T,​K extends Serializable,​N extends Number> CompletableFuture<Map<K[],​N[]>> queryColumnMapAsync​(Class<T> entityClass,
                                                                                                                  ColumnNode[] funcNodes,
                                                                                                                  String[] groupByColumns,
                                                                                                                  FilterNode node)
        查询符合过滤条件记录的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
        类型参数:
        T - Entity泛型
        K - Key字段的数据类型
        N - Number
        参数:
        entityClass - Entity类
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        node - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • find

        default <T> T find​(Class<T> clazz,
                   Serializable pk)
        获取指定主键值的单个记录, 返回null表示不存在值
        等价SQL: SELECT * FROM {table} WHERE {primary} = {id}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键值
        返回:
        Entity对象

      • findAsync

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

      • find

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

      • findAsync

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

      • finds

        default <T> T[] finds​(Class<T> clazz,
                      Serializable... pks)
        获取指定主键值的多个记录, 返回数组，数组长度与pks一样
        等价SQL: SELECT * FROM {table} WHERE {primary} = {id1,id2, ···}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pks - 主键值集合
        返回:
        Entity对象

      • finds

        default <D extends Serializable,​T> T[] finds​(Class<T> clazz,
                                                   Stream<D> pks)
        获取指定主键值的多个记录, 返回数组，数组长度与pks一样
        等价SQL: SELECT * FROM {table} WHERE {primary} = {id1,id2, ···}
        类型参数:
        D - 主键泛型
        T - Entity泛型
        参数:
        clazz - Entity类
        pks - 主键值集合
        返回:
        Entity对象

      • findsAsync

        default <T> CompletableFuture<T[]> findsAsync​(Class<T> clazz,
                                              Serializable... pks)
        获取指定主键值的多个记录, 返回数组，数组长度与pks一样
        等价SQL: SELECT * FROM {table} WHERE {primary} = {id1,id2, ···}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pks - 主键值集合
        返回:
        Entity对象 CompletableFuture

      • findsAsync

        default <D extends Serializable,​T> CompletableFuture<T[]> findsAsync​(Class<T> clazz,
                                                                           Stream<D> pks)
        获取指定主键值的多个记录, 返回数组，数组长度与pks一样
        等价SQL: SELECT * FROM {table} WHERE {primary} = {id1,id2, ···}
        类型参数:
        D - 主键泛型
        T - Entity泛型
        参数:
        clazz - Entity类
        pks - 主键值集合
        返回:
        Entity对象 CompletableFuture

      • finds

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

      • finds

        default <D extends Serializable,​T> T[] finds​(Class<T> clazz,
                                                   SelectColumn selects,
                                                   Stream<D> pks)
        获取指定主键值的多个记录, 返回数组，数组长度与pks一样
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
        类型参数:
        D - 主键泛型
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        pks - 主键值集合
        返回:
        Entity对象

      • findsAsync

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

      • findsAsync

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

      • findsList

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

      • findsListAsync

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

      • find

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

      • findAsync

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

      • find

        default <T> T find​(Class<T> clazz,
                   LambdaSupplier<Serializable> func)
        获取符合过滤条件单个记录, 返回null表示不存在值
        等价SQL: SELECT * FROM {table} WHERE {column} = {key}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        func - 更新值Lambda
        返回:
        Entity对象

      • findAsync

        default <T> CompletableFuture<T> findAsync​(Class<T> clazz,
                                           LambdaSupplier<Serializable> func)
        获取符合过滤条件单个记录, 返回null表示不存在值
        等价SQL: SELECT * FROM {table} WHERE {column} = {key}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        func - 更新值Lambda
        返回:
        Entity对象

      • find

        default <T> T find​(Class<T> clazz,
                   FilterBean bean)
        获取符合过滤条件单个记录, 返回null表示不存在值
        等价SQL: SELECT * FROM {table} WHERE {filter bean}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        bean - 过滤条件
        返回:
        Entity对象

      • findAsync

        default <T> CompletableFuture<T> findAsync​(Class<T> clazz,
                                           FilterBean bean)
        获取符合过滤条件单个记录, 返回null表示不存在值
        等价SQL: SELECT * FROM {table} WHERE {filter bean}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        bean - 过滤条件
        返回:
        Entity对象CompletableFuture

      • find

        default <T> T find​(Class<T> clazz,
                   FilterNode node)
        获取符合过滤条件单个记录, 返回null表示不存在值
        等价SQL: SELECT * FROM {table} WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        Entity对象

      • findAsync

        default <T> CompletableFuture<T> findAsync​(Class<T> clazz,
                                           FilterNode node)
        获取符合过滤条件单个记录, 返回null表示不存在值
        等价SQL: SELECT * FROM {table} WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        Entity对象CompletableFuture

      • find

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

      • findAsync

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

      • find

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

      • findAsync

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

      • findColumn

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

      • findColumnAsync

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

      • findColumn

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

      • findColumnAsync

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

      • findColumn

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

      • findColumnAsync

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

      • findColumn

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

      • findColumnAsync

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

      • findColumn

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

      • findColumnAsync

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

      • findColumn

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

      • findColumnAsync

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

      • exists

        <T> boolean exists​(Class<T> clazz,
                   Serializable pk)
        判断是否存在主键值的记录
        等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键值
        返回:
        是否存在

      • existsAsync

        <T> CompletableFuture<Boolean> existsAsync​(Class<T> clazz,
                                           Serializable pk)
        判断是否存在主键值的记录
        等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        pk - 主键值
        返回:
        是否存在CompletableFuture

      • exists

        default <T> boolean exists​(Class<T> clazz,
                           FilterBean bean)
        判断是否存在符合过滤条件的记录
        等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        bean - 过滤条件
        返回:
        是否存在

      • existsAsync

        default <T> CompletableFuture<Boolean> existsAsync​(Class<T> clazz,
                                                   FilterBean bean)
        判断是否存在符合过滤条件的记录
        等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        bean - 过滤条件
        返回:
        是否存在CompletableFuture

      • exists

        <T> boolean exists​(Class<T> clazz,
                   FilterNode node)
        判断是否存在符合过滤条件的记录
        等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        是否存在

      • existsAsync

        <T> CompletableFuture<Boolean> existsAsync​(Class<T> clazz,
                                           FilterNode node)
        判断是否存在符合过滤条件的记录
        等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        是否存在CompletableFuture

      • queryColumnSet

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

      • queryColumnSetAsync

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

      • queryColumnSet

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

      • queryColumnSetAsync

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

      • queryColumnSet

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

      • queryColumnSetAsync

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

      • queryColumnSet

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

      • queryColumnSetAsync

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

      • queryColumnSet

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

      • queryColumnSetAsync

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

      • queryColumnList

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

      • queryColumnListAsync

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

      • queryColumnList

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

      • queryColumnListAsync

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

      • queryColumnList

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

      • queryColumnListAsync

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

      • queryColumnList

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

      • queryColumnListAsync

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

      • queryColumnList

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

      • queryColumnListAsync

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

      • queryColumnSheet

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

      • queryColumnSheet

        default <T,​V extends Serializable,​F extends FilterBean> Sheet<V> queryColumnSheet​(String selectedColumn,
                                                                                              Class<T> clazz,
                                                                                              PageBean<F> pageBean)
        查询符合过滤条件记录的某个字段Sheet集合
        等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        V - 字段类型
        F - 过滤类型
        参数:
        selectedColumn - 指定字段
        clazz - Entity类
        pageBean - 过滤翻页条件
        返回:
        字段值的集合

      • queryColumnSheetAsync

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

      • queryColumnSheetAsync

        default <T,​V extends Serializable,​F extends FilterBean> CompletableFuture<Sheet<V>> queryColumnSheetAsync​(String selectedColumn,
                                                                                                                      Class<T> clazz,
                                                                                                                      PageBean<F> pageBean)
        查询符合过滤条件记录的某个字段Sheet集合
        等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        V - 字段类型
        F - 过滤类型
        参数:
        selectedColumn - 指定字段
        clazz - Entity类
        pageBean - 过滤翻页条件
        返回:
        字段值的集合CompletableFuture

      • queryColumnSheet

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

      • queryColumnSheetAsync

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

      • queryMap

        default <K extends Serializable,​T> Map<K,​T> queryMap​(Class<T> clazz,
                                                                 Stream<K> keyStream)
        查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
        等价SQL: SELECT * FROM {table} WHERE id IN {ids}
        类型参数:
        K - 主键泛型
        T - Entity泛型
        参数:
        clazz - Entity类
        keyStream - 主键Stream
        返回:
        Entity的集合

      • queryMapAsync

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

      • queryMap

        default <K extends Serializable,​T> Map<K,​T> queryMap​(Class<T> clazz,
                                                                 FilterBean bean)
        查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
        等价SQL: SELECT * FROM {table} WHERE {filter node}
        类型参数:
        K - 主键泛型
        T - Entity泛型
        参数:
        clazz - Entity类
        bean - FilterBean
        返回:
        Entity的集合

      • queryMapAsync

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

      • queryMap

        default <K extends Serializable,​T> Map<K,​T> queryMap​(Class<T> clazz,
                                                                 FilterNode node)
        查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
        等价SQL: SELECT * FROM {table} WHERE {filter node}
        类型参数:
        K - 主键泛型
        T - Entity泛型
        参数:
        clazz - Entity类
        node - FilterNode
        返回:
        Entity的集合

      • queryMapAsync

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

      • queryMap

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

      • queryMapAsync

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

      • queryMap

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

      • queryMapAsync

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

      • queryMap

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

      • queryMapAsync

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

      • querySet

        default <T> Set<T> querySet​(Class<T> clazz,
                            String column,
                            Serializable colval)
        查询符合过滤条件记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        column - 过滤字段名
        colval - 过滤字段值
        返回:
        Entity的集合

      • querySetAsync

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

      • querySet

        default <T> Set<T> querySet​(Class<T> clazz,
                            FilterBean bean)
        查询符合过滤条件记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        bean - 过滤条件
        返回:
        Entity的集合

      • querySetAsync

        default <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz,
                                                    FilterBean bean)
        查询符合过滤条件记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        bean - 过滤条件
        返回:
        Entity的集合CompletableFuture

      • querySet

        default <T> Set<T> querySet​(Class<T> clazz)
        查询记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        返回:
        Entity的集合

      • querySet

        default <T> Set<T> querySet​(Class<T> clazz,
                            FilterNode node)
        查询符合过滤条件记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        Entity的集合

      • querySetAsync

        default <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz)
        查询记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        返回:
        Entity的集合CompletableFuture

      • querySetAsync

        default <T> CompletableFuture<Set<T>> querySetAsync​(Class<T> clazz,
                                                    FilterNode node)
        查询符合过滤条件记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        Entity的集合CompletableFuture

      • querySet

        default <T> Set<T> querySet​(Class<T> clazz,
                            SelectColumn selects,
                            FilterBean bean)
        查询符合过滤条件记录的Set集合
        等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        bean - 过滤条件
        返回:
        Entity的集合

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

        default <T> Set<T> querySet​(Class<T> clazz,
                            Flipper flipper,
                            FilterBean bean)
        查询符合过滤条件记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        bean - 过滤条件
        返回:
        Entity的集合

      • querySetAsync

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

      • querySet

        default <T> Set<T> querySet​(Class<T> clazz,
                            Flipper flipper,
                            FilterNode node)
        查询符合过滤条件记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        node - 过滤条件
        返回:
        Entity的集合

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • queryList

        default <T> List<T> queryList​(Class<T> clazz,
                              String column,
                              Serializable colval)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        column - 过滤字段名
        colval - 过滤字段值
        返回:
        Entity的集合

      • queryListAsync

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

      • queryList

        default <T> List<T> queryList​(Class<T> clazz,
                              FilterBean bean)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT * FROM {table} WHERE {filter bean}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        bean - 过滤条件
        返回:
        Entity的集合

      • queryListAsync

        default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz,
                                                      FilterBean bean)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT * FROM {table} WHERE {filter bean}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        bean - 过滤条件
        返回:
        Entity的集合CompletableFuture

      • queryList

        default <T> List<T> queryList​(Class<T> clazz)
        查询记录的List集合
        等价SQL: SELECT * FROM {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        返回:
        Entity的集合

      • queryList

        default <T> List<T> queryList​(Class<T> clazz,
                              FilterNode node)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT * FROM {table} WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        Entity的集合

      • queryListAsync

        default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz)
        查询记录的List集合
        等价SQL: SELECT * FROM {table}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        返回:
        Entity的集合CompletableFuture

      • queryListAsync

        default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz,
                                                      FilterNode node)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT * FROM {table} WHERE {filter node}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        node - 过滤条件
        返回:
        Entity的集合CompletableFuture

      • queryList

        default <T> List<T> queryList​(Class<T> clazz,
                              SelectColumn selects,
                              FilterBean bean)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        bean - 过滤条件
        返回:
        Entity的集合

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

        default <T> List<T> queryList​(Class<T> clazz,
                              Flipper flipper)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT * FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        返回:
        Entity的集合

      • queryListAsync

        default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz,
                                                      Flipper flipper)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT * FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        返回:
        Entity的集合CompletableFuture

      • queryList

        default <T> List<T> queryList​(Class<T> clazz,
                              Flipper flipper,
                              FilterBean bean)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        bean - 过滤条件
        返回:
        Entity的集合

      • queryListAsync

        default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz,
                                                      Flipper flipper,
                                                      FilterBean bean)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        bean - 过滤条件
        返回:
        Entity的集合CompletableFuture

      • queryList

        default <T> List<T> queryList​(Class<T> clazz,
                              Flipper flipper,
                              FilterNode node)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        node - 过滤条件
        返回:
        Entity的集合

      • queryListAsync

        default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz,
                                                      Flipper flipper,
                                                      FilterNode node)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        node - 过滤条件
        返回:
        Entity的集合

      • queryList

        default <T> List<T> queryList​(Class<T> clazz,
                              SelectColumn selects,
                              Flipper flipper)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        flipper - 翻页对象
        返回:
        Entity的集合

      • queryListAsync

        default <T> CompletableFuture<List<T>> queryListAsync​(Class<T> clazz,
                                                      SelectColumn selects,
                                                      Flipper flipper)
        查询符合过滤条件记录的List集合
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        selects - 指定字段
        flipper - 翻页对象
        返回:
        Entity的集合CompletableFuture

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • querySheet

        default <T> Sheet<T> querySheet​(Class<T> clazz,
                                Flipper flipper,
                                FilterBean bean)
        查询符合过滤条件记录的Sheet集合
        等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        bean - 过滤条件
        返回:
        Entity的集合

      • querySheet

        default <T,​F extends FilterBean> Sheet<T> querySheet​(Class<T> clazz,
                                                           PageBean<F> pageBean)
        查询符合过滤条件记录的Sheet集合
        等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        F - 过滤类型
        参数:
        clazz - Entity类
        pageBean - 过滤翻页条件
        返回:
        Entity的集合

      • querySheetAsync

        default <T> CompletableFuture<Sheet<T>> querySheetAsync​(Class<T> clazz,
                                                        Flipper flipper,
                                                        FilterBean bean)
        查询符合过滤条件记录的Sheet集合
        等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        bean - 过滤条件
        返回:
        Entity的集合CompletableFuture

      • querySheetAsync

        default <T,​F extends FilterBean> CompletableFuture<Sheet<T>> querySheetAsync​(Class<T> clazz,
                                                                                   PageBean<F> pageBean)
        查询符合过滤条件记录的Sheet集合
        等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        F - 过滤类型
        参数:
        clazz - Entity类
        pageBean - 过滤翻页条件
        返回:
        Entity的集合CompletableFuture

      • querySheet

        default <T> Sheet<T> querySheet​(Class<T> clazz,
                                Flipper flipper,
                                FilterNode node)
        查询符合过滤条件记录的Sheet集合
        等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        node - 过滤条件
        返回:
        Entity的集合

      • querySheetAsync

        default <T> CompletableFuture<Sheet<T>> querySheetAsync​(Class<T> clazz,
                                                        Flipper flipper,
                                                        FilterNode node)
        查询符合过滤条件记录的Sheet集合
        等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        参数:
        clazz - Entity类
        flipper - 翻页对象
        node - 过滤条件
        返回:
        Entity的集合CompletableFuture

      • querySheet

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

      • querySheet

        default <T,​F extends FilterBean> Sheet<T> querySheet​(Class<T> clazz,
                                                           SelectColumn selects,
                                                           PageBean<F> pageBean)
        查询符合过滤条件记录的Sheet集合
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        F - 过滤类型
        参数:
        clazz - Entity类
        selects - 指定字段
        pageBean - 过滤翻页条件
        返回:
        Entity的集合

      • querySheetAsync

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

      • querySheetAsync

        default <T,​F extends FilterBean> CompletableFuture<Sheet<T>> querySheetAsync​(Class<T> clazz,
                                                                                   SelectColumn selects,
                                                                                   PageBean<F> pageBean)
        查询符合过滤条件记录的Sheet集合
        等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
        类型参数:
        T - Entity泛型
        F - 过滤类型
        参数:
        clazz - Entity类
        selects - 指定字段
        pageBean - 过滤翻页条件
        返回:
        Entity的集合CompletableFuture

      • querySheet

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

      • querySheetAsync

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