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

接口 DataSqlMapper<T>

  • 类型参数:
    T - T
    public interface DataSqlMapper<T>
    类似Mybatis的Mapper接口类, 接口系列和DataSource相似度高
    自定义的sql接口的返回结果类型只能是: void/基本数据类型/JavaBean/Map/List/Sheet
    异步接口返回的是泛型为以上类型的CompletableFuture 
     public interface ForumInfoMapper extends DataSqlMapper<ForumInfo> {

   @Sql("SELECT f.forum_groupid, s.forum_section_color "
      + "FROM forum_info f, forum_section s "
      + " WHERE f.forumid = s.forumid AND "
      + "s.forum_sectionid = #{bean.forumSectionid} AND "
      + "f.forumid = #{bean.forumid} AND s.forum_section_color = #{bean.forumSectionColor}")
   public ForumResult findForumResult(ForumBean bean);

   @Sql("SELECT f.forum_groupid, s.forum_section_color "
      + "FROM forum_info f, forum_section s "
      + " WHERE f.forumid = s.forumid AND "
      + "s.forum_sectionid = #{bean.forumSectionid} AND "
      + "f.forumid = #{bean.forumid} AND s.forum_section_color = #{bean.forumSectionColor}")
   public CompletableFuture<ForumResult> findForumResultAsync(ForumBean bean);

   @Sql("SELECT f.forum_groupid, s.forum_section_color "
      + "FROM forum_info f, forum_section s "
      + " WHERE f.forumid = s.forumid AND "
      + "s.forum_sectionid = #{bean.forumSectionid} AND "
      + "f.forumid = #{bean.forumid} AND s.forum_section_color = #{bean.forumSectionColor}")
   public List<ForumResult> queryForumResult(@Param("bean") ForumBean bean0);

   @Sql("SELECT f.forum_groupid, s.forum_section_color "
      + "FROM forum_info f, forum_section s "
      + " WHERE f.forumid = s.forumid AND "
      + "s.forum_sectionid = #{bean.forumSectionid} AND "
      + "f.forumid = #{bean.forumid} AND s.forum_section_color = #{bean.forumSectionColor}")
   public CompletableFuture<List<ForumResult>> queryForumResultAsync(ForumBean bean);
 }

    详情见: https://redkale.org

    从以下版本开始:
    2.8.0
    作者:
    zhangjx
    另请参阅:
    DataSqlMapperBuilder, Sql

    • 方法概要

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

    • 方法详细资料

      • insert

        default int insert​(T... entitys)
        新增记录
        参数:
        entitys - Entity对象
        返回:
        CompletableFuture

      • insert

        default int insert​(Collection<T> entitys)
        新增记录
        参数:
        entitys - Entity对象
        返回:
        CompletableFuture

      • insert

        default int insert​(Stream<T> entitys)
        新增记录
        参数:
        entitys - Entity对象
        返回:
        CompletableFuture

      • insertAsync

        default CompletableFuture<Integer> insertAsync​(T... entitys)
        新增记录
        参数:
        entitys - Entity对象
        返回:
        CompletableFuture

      • insertAsync

        default CompletableFuture<Integer> insertAsync​(Stream<T> entitys)
        新增记录
        参数:
        entitys - Entity对象
        返回:
        CompletableFuture

      • delete

        default int delete​(T... entitys)
        删除指定主键值的记录
        等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数CompletableFuture

      • delete

        default int delete​(Collection<T> entitys)
        删除指定主键值的记录
        等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数CompletableFuture

      • delete

        default int delete​(Stream<T> entitys)
        删除指定主键值的记录
        等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数CompletableFuture

      • deleteAsync

        default CompletableFuture<Integer> deleteAsync​(T... entitys)
        删除指定主键值的记录
        等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数CompletableFuture

      • deleteAsync

        default CompletableFuture<Integer> deleteAsync​(Collection<T> entitys)
        删除指定主键值的记录
        等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数CompletableFuture

      • deleteAsync

        default CompletableFuture<Integer> deleteAsync​(Stream<T> entitys)
        删除指定主键值的记录
        等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数CompletableFuture

      • deleteById

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

      • deleteByIdAsync

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

      • update

        default int update​(T... entitys)
        更新记录
        等价SQL:
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
        ···
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数

      • update

        default int update​(Collection<T> entitys)
        更新记录
        等价SQL:
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
        ···
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数

      • update

        default int update​(Stream<T> entitys)
        更新记录
        等价SQL:
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
        ···
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数

      • updateAsync

        default CompletableFuture<Integer> updateAsync​(T... entitys)
        更新记录
        等价SQL:
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
        ···
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数CompletableFuture

      • updateAsync

        default CompletableFuture<Integer> updateAsync​(Collection<T> entitys)
        更新记录
        等价SQL:
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
        ···
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数CompletableFuture

      • updateAsync

        default CompletableFuture<Integer> updateAsync​(Stream<T> entitys)
        更新记录
        等价SQL:
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
        UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
        ···
        参数:
        entitys - Entity对象
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

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

      • updateColumn

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

      • updateColumnAsync

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

      • updateColumnAsync

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

      • updateColumn

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

      • updateColumn

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

      • updateColumnAsync

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

      • updateColumnAsync

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

      • updateColumn

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

      • updateColumn

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

      • updateColumnAsync

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

      • updateColumnAsync

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

      • updateColumn

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

      • updateColumnAsync

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

      • updateColumn

        default int updateColumn​(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}
        参数:
        node - 过滤条件
        flipper - 翻页对象
        values - 更新字段
        返回:
        影响的记录条数

      • updateColumnAsync

        default CompletableFuture<Integer> updateColumnAsync​(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}
        参数:
        node - 过滤条件
        flipper - 翻页对象
        values - 更新字段
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

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

      • updateColumn

        default 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}
        参数:
        entity - 待更新的Entity对象
        funcs - 需更新的字段名Lambda集合
        返回:
        影响的记录条数

      • updateColumnAsync

        default 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}
        参数:
        entity - 待更新的Entity对象
        columns - 需更新的字段名
        返回:
        影响的记录条数CompletableFuture

      • updateColumnAsync

        default 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}
        参数:
        entity - 待更新的Entity对象
        funcs - 需更新的字段名Lambda集合
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

        default 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}
        参数:
        entity - 待更新的Entity对象
        node - 过滤条件
        columns - 需更新的字段名
        返回:
        影响的记录条数

      • updateColumn

        default 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}
        参数:
        entity - 待更新的Entity对象
        node - 过滤条件
        funcs - 需更新的字段名Lambda集合
        返回:
        影响的记录条数

      • updateColumnAsync

        default 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}
        参数:
        entity - 待更新的Entity对象
        node - 过滤条件
        columns - 需更新的字段名
        返回:
        影响的记录条数CompletableFuture

      • updateColumnAsync

        default 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}
        参数:
        entity - 待更新的Entity对象
        node - 过滤条件
        funcs - 需更新的字段名Lambda集合
        返回:
        影响的记录条数

      • updateColumn

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

      • updateColumnAsync

        default 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}
        参数:
        entity - 待更新的Entity对象
        selects - 指定字段
        返回:
        影响的记录条数CompletableFuture

      • updateColumn

        default 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}
        参数:
        entity - 待更新的Entity对象
        node - 过滤条件
        selects - 指定字段
        返回:
        影响的记录条数

      • updateColumnAsync

        default 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}
        参数:
        entity - 待更新的Entity对象
        node - 过滤条件
        selects - 指定字段
        返回:
        影响的记录条数CompletableFuture

      • getNumberResultAsync

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

      • getNumberResult

        default Number getNumberResult​(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}
        参数:
        func - 聚合函数
        column - 指定字段
        bean - 过滤条件
        返回:
        聚合结果

      • getNumberResultAsync

        default CompletableFuture<Number> getNumberResultAsync​(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}
        参数:
        func - 聚合函数
        column - 指定字段
        bean - 过滤条件
        返回:
        聚合结果CompletableFuture

      • getNumberResult

        default Number getNumberResult​(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}
        参数:
        func - 聚合函数
        column - 指定字段
        node - 过滤条件
        返回:
        聚合结果

      • getNumberResultAsync

        default CompletableFuture<Number> getNumberResultAsync​(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}
        参数:
        func - 聚合函数
        column - 指定字段
        node - 过滤条件
        返回:
        聚合结果

      • getNumberResult

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

      • getNumberResultAsync

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

      • getNumberResult

        default Number getNumberResult​(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}
        参数:
        func - 聚合函数
        defVal - 默认值
        column - 指定字段
        bean - 过滤条件
        返回:
        聚合结果

      • getNumberResultAsync

        default CompletableFuture<Number> getNumberResultAsync​(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}
        参数:
        func - 聚合函数
        defVal - 默认值
        column - 指定字段
        bean - 过滤条件
        返回:
        聚合结果CompletableFuture

      • getNumberResult

        default Number getNumberResult​(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}
        参数:
        func - 聚合函数
        defVal - 默认值
        column - 指定字段
        node - 过滤条件
        返回:
        聚合结果

      • getNumberResultAsync

        default CompletableFuture<Number> getNumberResultAsync​(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}
        参数:
        func - 聚合函数
        defVal - 默认值
        column - 指定字段
        node - 过滤条件
        返回:
        聚合结果CompletableFuture

      • getNumberMap

        default <N extends Number> Map<String,​N> getNumberMap​(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
        参数:
        columns - 聚合字段
        返回:
        聚合结果Map

      • getNumberMapAsync

        default <N extends Number> CompletableFuture<Map<String,​N>> getNumberMapAsync​(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
        参数:
        columns - 聚合字段
        返回:
        聚合结果Map CompletableFuture

      • getNumberMap

        default <N extends Number> Map<String,​N> getNumberMap​(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
        参数:
        bean - 过滤条件
        columns - 聚合字段
        返回:
        聚合结果Map

      • getNumberMapAsync

        default <N extends Number> CompletableFuture<Map<String,​N>> getNumberMapAsync​(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
        参数:
        bean - 过滤条件
        columns - 聚合字段
        返回:
        聚合结果Map CompletableFuture

      • getNumberMap

        default <N extends Number> Map<String,​N> getNumberMap​(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
        参数:
        node - 过滤条件
        columns - 聚合字段
        返回:
        聚合结果Map

      • getNumberMapAsync

        default <N extends Number> CompletableFuture<Map<String,​N>> getNumberMapAsync​(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
        参数:
        node - 过滤条件
        columns - 聚合字段
        返回:
        聚合结果Map

      • queryColumnMap

        default <K extends Serializable,​N extends Number> Map<K,​N> queryColumnMap​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        返回:
        聚合结果Map

      • queryColumnMapAsync

        default <K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N>> queryColumnMapAsync​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        default <K extends Serializable,​N extends Number> Map<K,​N> queryColumnMap​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        bean - 过滤条件
        返回:
        聚合结果Map

      • queryColumnMapAsync

        default <K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N>> queryColumnMapAsync​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        default <K extends Serializable,​N extends Number> Map<K,​N> queryColumnMap​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        node - 过滤条件
        返回:
        聚合结果Map

      • queryColumnMapAsync

        default <K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N>> queryColumnMapAsync​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        keyColumn - Key字段
        func - 聚合函数
        funcColumn - 聚合字段
        node - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        default <K extends Serializable,​N extends Number> Map<K,​N[]> queryColumnMap​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        default <K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N[]>> queryColumnMapAsync​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        default <K extends Serializable,​N extends Number> Map<K,​N[]> queryColumnMap​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        default <K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N[]>> queryColumnMapAsync​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        default <K extends Serializable,​N extends Number> Map<K,​N[]> queryColumnMap​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        node - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        default <K extends Serializable,​N extends Number> CompletableFuture<Map<K,​N[]>> queryColumnMapAsync​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        funcNodes - ColumnNode[]
        groupByColumn - GROUP BY字段
        node - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        default <K extends Serializable,​N extends Number> Map<K[],​N[]> queryColumnMap​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        default <K extends Serializable,​N extends Number> CompletableFuture<Map<K[],​N[]>> queryColumnMapAsync​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        default <K extends Serializable,​N extends Number> Map<K[],​N[]> queryColumnMap​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMapAsync

        default <K extends Serializable,​N extends Number> CompletableFuture<Map<K[],​N[]>> queryColumnMapAsync​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        bean - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • queryColumnMap

        default <K extends Serializable,​N extends Number> Map<K[],​N[]> queryColumnMap​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        node - 过滤条件
        返回:
        聚合结果Map

      • queryColumnMapAsync

        default <K extends Serializable,​N extends Number> CompletableFuture<Map<K[],​N[]>> queryColumnMapAsync​(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
        类型参数:
        K - Key字段的数据类型
        N - Number
        参数:
        funcNodes - ColumnNode[]
        groupByColumns - GROUP BY字段
        node - 过滤条件
        返回:
        聚合结果Map CompletableFuture

      • find

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

      • findAsync

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

      • find

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

      • findAsync

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

      • finds

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

      • finds

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

      • findsAsync

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

      • findsAsync

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

      • finds

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

      • finds

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

      • findsAsync

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

      • findsAsync

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

      • findsList

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

      • findsListAsync

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

      • find

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

      • findAsync

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

      • find

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

      • findAsync

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

      • find

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

      • findAsync

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

      • find

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

      • findAsync

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

      • find

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

      • findAsync

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

      • find

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

      • findAsync

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

      • findColumn

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

      • findColumnAsync

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

      • findColumn

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

      • findColumnAsync

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

      • findColumn

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

      • findColumnAsync

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

      • findColumn

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

      • findColumnAsync

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

      • findColumn

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

      • findColumnAsync

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

      • findColumn

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

      • findColumnAsync

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

      • exists

        default boolean exists​(Serializable pk)
        判断是否存在主键值的记录
        等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
        参数:
        pk - 主键值
        返回:
        是否存在

      • existsAsync

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

      • exists

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

      • existsAsync

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

      • exists

        default boolean exists​(FilterNode node)
        判断是否存在符合过滤条件的记录
        等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
        参数:
        node - 过滤条件
        返回:
        是否存在

      • existsAsync

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

      • queryColumnSet

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

      • queryColumnSetAsync

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

      • queryColumnSet

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

      • queryColumnSetAsync

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

      • queryColumnSet

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

      • queryColumnSetAsync

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

      • queryColumnSet

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

      • queryColumnSetAsync

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

      • queryColumnSet

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

      • queryColumnSetAsync

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

      • queryColumnList

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

      • queryColumnListAsync

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

      • queryColumnList

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

      • queryColumnListAsync

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

      • queryColumnList

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

      • queryColumnListAsync

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

      • queryColumnList

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

      • queryColumnListAsync

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

      • queryColumnList

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

      • queryColumnListAsync

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

      • queryColumnSheet

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

      • queryColumnSheetAsync

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

      • queryColumnSheet

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

      • queryColumnSheetAsync

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

      • queryMap

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

      • queryMapAsync

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

      • queryMap

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

      • queryMapAsync

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

      • queryMap

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

      • queryMapAsync

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

      • queryMap

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

      • queryMapAsync

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

      • queryMap

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

      • queryMapAsync

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

      • queryMap

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

      • queryMapAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

        default Set<T> querySet()
        查询记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table}
        返回:
        Entity的集合

      • querySet

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

      • querySetAsync

        default CompletableFuture<Set<T>> querySetAsync()
        查询记录的Set集合
        等价SQL: SELECT DISTINCT * FROM {table}
        返回:
        Entity的集合CompletableFuture

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • querySet

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

      • querySetAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

        default List<T> queryList()
        查询记录的List集合
        等价SQL: SELECT * FROM {table}
        返回:
        Entity的集合

      • queryList

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

      • queryListAsync

        default CompletableFuture<List<T>> queryListAsync()
        查询记录的List集合
        等价SQL: SELECT * FROM {table}
        返回:
        Entity的集合CompletableFuture

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • queryList

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

      • queryListAsync

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

      • querySheet

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

      • querySheet

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

      • querySheetAsync

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

      • querySheetAsync

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

      • querySheet

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

      • querySheetAsync

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

      • querySheet

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

      • querySheet

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

      • querySheetAsync

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

      • querySheetAsync

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

      • querySheet

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

      • querySheetAsync

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