org.redkale.source

接口 DataSource

所有已知实现类:

DataJdbcSource, DataMemorySource, DataSqlSource

public interface DataSource

DataSource 为数据库或内存数据库的数据源，提供类似JPA、Hibernate的接口与功能。
返回类型为CompletableFuture的接口为异步接口

详情见: https://redkale.org

作者:

zhangjx

方法概要

限定符和类型	方法和说明
<T> int	delete(Class<T> clazz, FilterNode node) 删除符合过滤条件的记录 等价SQL: DELETE FROM {table} WHERE {filter node}
<T> int	delete(Class<T> clazz, Flipper flipper, FilterNode node) 删除符合过滤条件且指定最大影响条数的记录 Flipper中offset字段将被忽略 等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> int	delete(Class<T> clazz, Serializable... ids) 删除指定主键值的记录,多主键值必须在同一张表中 等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
<T> int	delete(T... values) 删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中 等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}
<T> CompletableFuture<Integer>	deleteAsync(Class<T> clazz, FilterNode node) 删除符合过滤条件的记录 等价SQL: DELETE FROM {table} WHERE {filter node}
<T> CompletableFuture<Integer>	deleteAsync(Class<T> clazz, Flipper flipper, FilterNode node) 删除符合过滤条件且指定最大影响条数的记录 Flipper中offset字段将被忽略 等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<Integer>	deleteAsync(Class<T> clazz, Serializable... ids) 删除指定主键值的记录,多主键值必须在同一张表中 等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
<T> CompletableFuture<Integer>	deleteAsync(T... values) 删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中 等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}
<T> boolean	exists(Class<T> clazz, FilterBean bean) 判断是否存在符合过滤条件的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
<T> boolean	exists(Class<T> clazz, FilterNode node) 判断是否存在符合过滤条件的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
<T> boolean	exists(Class<T> clazz, Serializable pk) 判断是否存在主键值的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
<T> CompletableFuture<Boolean>	existsAsync(Class<T> clazz, FilterBean bean) 判断是否存在符合过滤条件的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
<T> CompletableFuture<Boolean>	existsAsync(Class<T> clazz, FilterNode node) 判断是否存在符合过滤条件的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
<T> CompletableFuture<Boolean>	existsAsync(Class<T> clazz, Serializable pk) 判断是否存在主键值的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
<T> T	find(Class<T> clazz, FilterBean bean) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {filter bean}
<T> T	find(Class<T> clazz, FilterNode node) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {filter node}
<T> T	find(Class<T> clazz, SelectColumn selects, FilterBean bean) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
<T> T	find(Class<T> clazz, SelectColumn selects, FilterNode node) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
<T> T	find(Class<T> clazz, SelectColumn selects, Serializable pk) 获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
<T> T	find(Class<T> clazz, Serializable pk) 获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {primary} = {id}
<T> T	find(Class<T> clazz, String column, Serializable key) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {column} = {key}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, FilterBean bean) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {filter bean}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, FilterNode node) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {filter node}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, SelectColumn selects, FilterBean bean) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, SelectColumn selects, FilterNode node) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, SelectColumn selects, Serializable pk) 获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, Serializable pk) 获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {primary} = {id}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, String column, Serializable key) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {column} = {key}
<T> Serializable	findColumn(Class<T> clazz, String column, FilterBean bean) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
<T> Serializable	findColumn(Class<T> clazz, String column, FilterNode node) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
<T> Serializable	findColumn(Class<T> clazz, String column, Serializable pk) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
<T> Serializable	findColumn(Class<T> clazz, String column, Serializable defValue, FilterBean bean) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
<T> Serializable	findColumn(Class<T> clazz, String column, Serializable defValue, FilterNode node) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
<T> Serializable	findColumn(Class<T> clazz, String column, Serializable defValue, Serializable pk) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
<T> CompletableFuture<Serializable>	findColumnAsync(Class<T> clazz, String column, FilterBean bean) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
<T> CompletableFuture<Serializable>	findColumnAsync(Class<T> clazz, String column, FilterNode node) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
<T> CompletableFuture<Serializable>	findColumnAsync(Class<T> clazz, String column, Serializable pk) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
<T> CompletableFuture<Serializable>	findColumnAsync(Class<T> clazz, String column, Serializable defValue, FilterBean bean) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
<T> CompletableFuture<Serializable>	findColumnAsync(Class<T> clazz, String column, Serializable defValue, FilterNode node) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
<T> CompletableFuture<Serializable>	findColumnAsync(Class<T> clazz, String column, Serializable defValue, Serializable pk) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
<N extends Number> Map<String,N>	getNumberMap(Class entityClass, FilterBean bean, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean} 如 getNumberMapAsync(Record.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends Number> Map<String,N>	getNumberMap(Class entityClass, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} 如 getNumberMapAsync(Record.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends Number> Map<String,N>	getNumberMap(Class entityClass, FilterNode node, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node} 如 getNumberMapAsync(Record.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends Number> CompletableFuture<Map<String,N>>	getNumberMapAsync(Class entityClass, FilterBean bean, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean} 如 getNumberMapAsync(Record.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends Number> CompletableFuture<Map<String,N>>	getNumberMapAsync(Class entityClass, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} 如 getNumberMapAsync(Record.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends Number> CompletableFuture<Map<String,N>>	getNumberMapAsync(Class entityClass, FilterNode node, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node} 如 getNumberMapAsync(Record.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
Number	getNumberResult(Class entityClass, FilterFunc func, Number defVal, String column) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table}
Number	getNumberResult(Class entityClass, FilterFunc func, Number defVal, String column, FilterBean bean) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
Number	getNumberResult(Class entityClass, FilterFunc func, Number defVal, String column, FilterNode node) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
Number	getNumberResult(Class entityClass, FilterFunc func, String column) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table}
Number	getNumberResult(Class entityClass, FilterFunc func, String column, FilterBean bean) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
Number	getNumberResult(Class entityClass, FilterFunc func, String column, FilterNode node) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
CompletableFuture<Number>	getNumberResultAsync(Class entityClass, FilterFunc func, Number defVal, String column) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table}
CompletableFuture<Number>	getNumberResultAsync(Class entityClass, FilterFunc func, Number defVal, String column, FilterBean bean) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
CompletableFuture<Number>	getNumberResultAsync(Class entityClass, FilterFunc func, Number defVal, String column, FilterNode node) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
CompletableFuture<Number>	getNumberResultAsync(Class entityClass, FilterFunc func, String column) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table}
CompletableFuture<Number>	getNumberResultAsync(Class entityClass, FilterFunc func, String column, FilterBean bean) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
CompletableFuture<Number>	getNumberResultAsync(Class entityClass, FilterFunc func, String column, FilterNode node) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
String	getType() 获取数据源类型
<T> int	insert(T... values) 新增记录， 多对象必须是同一个Entity类且必须在同一张表中
<T> CompletableFuture<Integer>	insertAsync(T... values) 新增记录， 多对象必须是同一个Entity类且必须在同一张表中
<T,V extends Serializable> List<V>	queryColumnList(String selectedColumn, Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
<T,V extends Serializable> List<V>	queryColumnList(String selectedColumn, Class<T> clazz, FilterNode node) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
<T,V extends Serializable> List<V>	queryColumnList(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends Serializable> List<V>	queryColumnList(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends Serializable> List<V>	queryColumnList(String selectedColumn, Class<T> clazz, String column, Serializable key) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
<T,V extends Serializable> CompletableFuture<List<V>>	queryColumnListAsync(String selectedColumn, Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
<T,V extends Serializable> CompletableFuture<List<V>>	queryColumnListAsync(String selectedColumn, Class<T> clazz, FilterNode node) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
<T,V extends Serializable> CompletableFuture<List<V>>	queryColumnListAsync(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends Serializable> CompletableFuture<List<V>>	queryColumnListAsync(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends Serializable> CompletableFuture<List<V>>	queryColumnListAsync(String selectedColumn, Class<T> clazz, String column, Serializable key) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
<T,K extends Serializable,N extends Number> Map<K,N>	queryColumnMap(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime") 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends Serializable,N extends Number> Map<K,N>	queryColumnMap(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn, FilterBean bean) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends Serializable,N extends Number> Map<K,N>	queryColumnMap(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn, FilterNode node) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N>>	queryColumnMapAsync(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime") 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N>>	queryColumnMapAsync(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn, FilterBean bean) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N>>	queryColumnMapAsync(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn, FilterNode node) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,V extends Serializable> HashSet<V>	queryColumnSet(String selectedColumn, Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
<T,V extends Serializable> HashSet<V>	queryColumnSet(String selectedColumn, Class<T> clazz, FilterNode node) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
<T,V extends Serializable> HashSet<V>	queryColumnSet(String selectedColumn, Class<T> clazz, String column, Serializable key) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
<T,V extends Serializable> CompletableFuture<HashSet<V>>	queryColumnSetAsync(String selectedColumn, Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
<T,V extends Serializable> CompletableFuture<HashSet<V>>	queryColumnSetAsync(String selectedColumn, Class<T> clazz, FilterNode node) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
<T,V extends Serializable> CompletableFuture<HashSet<V>>	queryColumnSetAsync(String selectedColumn, Class<T> clazz, String column, Serializable key) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
<T,V extends Serializable> Sheet<V>	queryColumnSheet(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的某个字段Sheet集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends Serializable> Sheet<V>	queryColumnSheet(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的某个字段Sheet集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends Serializable> CompletableFuture<Sheet<V>>	queryColumnSheetAsync(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的某个字段Sheet集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends Serializable> CompletableFuture<Sheet<V>>	queryColumnSheetAsync(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的某个字段Sheet集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default <T> List<T>	queryList(Class<T> clazz) 查询记录的List集合 等价SQL: SELECT * FROM {table}
<T> List<T>	queryList(Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter bean}
<T> List<T>	queryList(Class<T> clazz, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter node}
<T> List<T>	queryList(Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> List<T>	queryList(Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> List<T>	queryList(Class<T> clazz, Flipper flipper, String column, Serializable key) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> List<T>	queryList(Class<T> clazz, SelectColumn selects, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
<T> List<T>	queryList(Class<T> clazz, SelectColumn selects, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
<T> List<T>	queryList(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> List<T>	queryList(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> List<T>	queryList(Class<T> clazz, String column, Serializable key) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default <T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz) 查询记录的List集合 等价SQL: SELECT * FROM {table}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter bean}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter node}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, Flipper flipper, String column, Serializable key) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, SelectColumn selects, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, SelectColumn selects, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, String column, Serializable key) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	queryMap(Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	queryMap(Class<T> clazz, FilterNode node) 查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	queryMap(Class<T> clazz, SelectColumn selects, FilterBean bean) 查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	queryMap(Class<T> clazz, SelectColumn selects, FilterNode node) 查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	queryMap(Class<T> clazz, SelectColumn selects, Stream<K> keyStream) 查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	queryMap(Class<T> clazz, Stream<K> keyStream) 查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	queryMapAsync(Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	queryMapAsync(Class<T> clazz, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	queryMapAsync(Class<T> clazz, SelectColumn selects, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	queryMapAsync(Class<T> clazz, SelectColumn selects, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	queryMapAsync(Class<T> clazz, SelectColumn selects, Stream<K> keyStream) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	queryMapAsync(Class<T> clazz, Stream<K> keyStream) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> Sheet<T>	querySheet(Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> Sheet<T>	querySheet(Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> Sheet<T>	querySheet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> Sheet<T>	querySheet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<Sheet<T>>	querySheetAsync(Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<Sheet<T>>	querySheetAsync(Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<Sheet<T>>	querySheetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<Sheet<T>>	querySheetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> int	update(T... values) 更新记录， 多对象必须是同一个Entity类且必须在同一张表中 等价SQL: UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1} UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2} ···
<T> CompletableFuture<Integer>	updateAsync(T... values) 更新记录， 多对象必须是同一个Entity类且必须在同一张表中 等价SQL: UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1} UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2} ···
<T> int	updateColumn(Class<T> clazz, FilterNode node, ColumnValue... values) 更新符合过滤条件记录的部分字段 字段赋值操作选项见 ColumnExpress 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
<T> int	updateColumn(Class<T> clazz, FilterNode node, Flipper flipper, ColumnValue... values) 更新符合过滤条件的记录的指定字段 Flipper中offset字段将被忽略 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}
<T> int	updateColumn(Class<T> clazz, Serializable id, ColumnValue... values) 更新指定主键值记录的部分字段 字段赋值操作选项见 ColumnExpress 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
<T> int	updateColumn(Class<T> clazz, Serializable id, String column, Serializable value) 更新单个记录的单个字段 注意：即使字段标记为@Column(updatable=false)也会被更新 等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
<T> int	updateColumn(Class<T> clazz, String column, Serializable value, FilterNode node) 更新符合过滤条件记录的单个字段 注意：即使字段标记为@Column(updatable=false)也会被更新 等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
<T> int	updateColumn(T bean, FilterNode node, SelectColumn selects) 更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
<T> int	updateColumn(T bean, FilterNode node, String... columns) 更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
<T> int	updateColumn(T bean, SelectColumn selects) 更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
<T> int	updateColumn(T bean, String... columns) 更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
<T> CompletableFuture<Integer>	updateColumnAsync(Class<T> clazz, FilterNode node, ColumnValue... values) 更新符合过滤条件记录的部分字段 字段赋值操作选项见 ColumnExpress 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
<T> CompletableFuture<Integer>	updateColumnAsync(Class<T> clazz, FilterNode node, Flipper flipper, ColumnValue... values) 更新符合过滤条件的记录的指定字段 Flipper中offset字段将被忽略 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}
<T> CompletableFuture<Integer>	updateColumnAsync(Class<T> clazz, Serializable id, ColumnValue... values) 更新指定主键值记录的部分字段 字段赋值操作选项见 ColumnExpress 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
<T> CompletableFuture<Integer>	updateColumnAsync(Class<T> clazz, Serializable id, String column, Serializable value) 更新单个记录的单个字段 注意：即使字段标记为@Column(updatable=false)也会被更新 等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
<T> CompletableFuture<Integer>	updateColumnAsync(Class<T> clazz, String column, Serializable value, FilterNode node) 更新符合过滤条件记录的单个字段 注意：即使字段标记为@Column(updatable=false)也会被更新 等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
<T> CompletableFuture<Integer>	updateColumnAsync(T bean, FilterNode node, SelectColumn selects) 更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
<T> CompletableFuture<Integer>	updateColumnAsync(T bean, FilterNode node, String... columns) 更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
<T> CompletableFuture<Integer>	updateColumnAsync(T bean, SelectColumn selects) 更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
<T> CompletableFuture<Integer>	updateColumnAsync(T bean, String... columns) 更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}

方法详细资料

getType

String getType()

获取数据源类型

返回:

String

insert

<T> int insert(T... values)

新增记录， 多对象必须是同一个Entity类且必须在同一张表中

类型参数:

T - 泛型

参数:

values - Entity对象

返回:

影响的记录条数

insertAsync

<T> CompletableFuture<Integer> insertAsync(T... values)

新增记录， 多对象必须是同一个Entity类且必须在同一张表中

类型参数:

T - 泛型

参数:

values - Entity对象

返回:

CompletableFuture

delete

<T> int delete(T... values)

删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}

类型参数:

T - 泛型

参数:

values - Entity对象

返回:

影响的记录条数

deleteAsync

<T> CompletableFuture<Integer> deleteAsync(T... values)

删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}

类型参数:

T - 泛型

参数:

values - Entity对象

返回:

影响的记录条数CompletableFuture

delete

<T> int delete(Class<T> clazz,
               Serializable... ids)

删除指定主键值的记录,多主键值必须在同一张表中
等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

ids - 主键值

返回:

影响的记录条数

deleteAsync

<T> CompletableFuture<Integer> deleteAsync(Class<T> clazz,
                                           Serializable... ids)

删除指定主键值的记录,多主键值必须在同一张表中
等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

ids - 主键值

返回:

影响的记录条数CompletableFuture

delete

<T> int delete(Class<T> clazz,
               FilterNode node)

删除符合过滤条件的记录
等价SQL: DELETE FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数

deleteAsync

<T> CompletableFuture<Integer> deleteAsync(Class<T> clazz,
                                           FilterNode node)

删除符合过滤条件的记录
等价SQL: DELETE FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数CompletableFuture

delete

<T> int delete(Class<T> clazz,
               Flipper flipper,
               FilterNode node)

删除符合过滤条件且指定最大影响条数的记录
Flipper中offset字段将被忽略
等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

影响的记录条数

deleteAsync

<T> CompletableFuture<Integer> deleteAsync(Class<T> clazz,
                                           Flipper flipper,
                                           FilterNode node)

删除符合过滤条件且指定最大影响条数的记录
Flipper中offset字段将被忽略
等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

影响的记录条数CompletableFuture

update

<T> int update(T... values)

更新记录， 多对象必须是同一个Entity类且必须在同一张表中
等价SQL:
UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
···

类型参数:

T - 泛型

参数:

values - Entity对象

返回:

影响的记录条数

updateAsync

<T> CompletableFuture<Integer> updateAsync(T... values)

更新记录， 多对象必须是同一个Entity类且必须在同一张表中
等价SQL:
UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
···

类型参数:

T - 泛型

参数:

values - Entity对象

返回:

影响的记录条数CompletableFuture

updateColumn

<T> int updateColumn(Class<T> clazz,
                     Serializable id,
                     String column,
                     Serializable value)

更新单个记录的单个字段
注意：即使字段标记为@Column(updatable=false)也会被更新
等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

id - 主键

column - 待更新的字段名

value - 更新值

返回:

影响的记录条数

updateColumnAsync

<T> CompletableFuture<Integer> updateColumnAsync(Class<T> clazz,
                                                 Serializable id,
                                                 String column,
                                                 Serializable value)

更新单个记录的单个字段
注意：即使字段标记为@Column(updatable=false)也会被更新
等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

id - 主键

column - 待更新的字段名

value - 更新值

返回:

影响的记录条数CompletableFuture

updateColumn

<T> int updateColumn(Class<T> clazz,
                     String column,
                     Serializable value,
                     FilterNode node)

更新符合过滤条件记录的单个字段
注意：即使字段标记为@Column(updatable=false)也会被更新
等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 待更新的字段名

value - 更新值

node - 过滤条件

返回:

影响的记录条数

updateColumnAsync

<T> CompletableFuture<Integer> updateColumnAsync(Class<T> clazz,
                                                 String column,
                                                 Serializable value,
                                                 FilterNode node)

更新符合过滤条件记录的单个字段
注意：即使字段标记为@Column(updatable=false)也会被更新
等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 待更新的字段名

value - 更新值

node - 过滤条件

返回:

影响的记录条数CompletableFuture

updateColumn

<T> int updateColumn(Class<T> clazz,
                     Serializable id,
                     ColumnValue... values)

更新指定主键值记录的部分字段
字段赋值操作选项见 ColumnExpress
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

id - 主键

values - 更新字段

返回:

影响的记录条数

updateColumnAsync

<T> CompletableFuture<Integer> updateColumnAsync(Class<T> clazz,
                                                 Serializable id,
                                                 ColumnValue... values)

更新指定主键值记录的部分字段
字段赋值操作选项见 ColumnExpress
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

id - 主键

values - 更新字段

返回:

影响的记录条数CompletableFuture

updateColumn

<T> int updateColumn(Class<T> clazz,
                     FilterNode node,
                     ColumnValue... values)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

values - 更新字段

返回:

影响的记录条数

updateColumnAsync

<T> CompletableFuture<Integer> updateColumnAsync(Class<T> clazz,
                                                 FilterNode node,
                                                 ColumnValue... values)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

values - 更新字段

返回:

影响的记录条数CompletableFuture

updateColumn

<T> int updateColumn(Class<T> clazz,
                     FilterNode node,
                     Flipper flipper,
                     ColumnValue... values)

更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

flipper - 翻页对象

values - 更新字段

返回:

影响的记录条数

updateColumnAsync

<T> CompletableFuture<Integer> updateColumnAsync(Class<T> clazz,
                                                 FilterNode node,
                                                 Flipper flipper,
                                                 ColumnValue... values)

更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

flipper - 翻页对象

values - 更新字段

返回:

影响的记录条数CompletableFuture

updateColumn

<T> int updateColumn(T bean,
                     String... columns)

更新单个记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

columns - 需更新的字段名

返回:

影响的记录条数

updateColumnAsync

<T> CompletableFuture<Integer> updateColumnAsync(T bean,
                                                 String... columns)

更新单个记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

columns - 需更新的字段名

返回:

影响的记录条数CompletableFuture

updateColumn

<T> int updateColumn(T bean,
                     FilterNode node,
                     String... columns)

更新符合过滤条件记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

node - 过滤条件

columns - 需更新的字段名

返回:

影响的记录条数

updateColumnAsync

<T> CompletableFuture<Integer> updateColumnAsync(T bean,
                                                 FilterNode node,
                                                 String... columns)

更新符合过滤条件记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

node - 过滤条件

columns - 需更新的字段名

返回:

影响的记录条数CompletableFuture

updateColumn

<T> int updateColumn(T bean,
                     SelectColumn selects)

更新单个记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

selects - 指定字段

返回:

影响的记录条数

updateColumnAsync

<T> CompletableFuture<Integer> updateColumnAsync(T bean,
                                                 SelectColumn selects)

更新单个记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

selects - 指定字段

返回:

影响的记录条数CompletableFuture

updateColumn

<T> int updateColumn(T bean,
                     FilterNode node,
                     SelectColumn selects)

更新符合过滤条件记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

node - 过滤条件

selects - 指定字段

返回:

影响的记录条数

updateColumnAsync

<T> CompletableFuture<Integer> updateColumnAsync(T bean,
                                                 FilterNode node,
                                                 SelectColumn selects)

更新符合过滤条件记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

node - 过滤条件

selects - 指定字段

返回:

影响的记录条数CompletableFuture

getNumberResult

Number getNumberResult(Class entityClass,
                       FilterFunc func,
                       String column)

获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table}
如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table}

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

返回:

聚合结果

getNumberResultAsync

CompletableFuture<Number> getNumberResultAsync(Class entityClass,
                                               FilterFunc func,
                                               String column)

获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table}
如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table}

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

返回:

聚合结果CompletableFuture

getNumberResult

Number getNumberResult(Class entityClass,
                       FilterFunc func,
                       String column,
                       FilterBean bean)

获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

bean - 过滤条件

返回:

聚合结果

getNumberResultAsync

CompletableFuture<Number> getNumberResultAsync(Class entityClass,
                                               FilterFunc func,
                                               String column,
                                               FilterBean bean)

获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

bean - 过滤条件

返回:

聚合结果CompletableFuture

getNumberResult

Number getNumberResult(Class entityClass,
                       FilterFunc func,
                       String column,
                       FilterNode node)

获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

node - 过滤条件

返回:

聚合结果

getNumberResultAsync

CompletableFuture<Number> getNumberResultAsync(Class entityClass,
                                               FilterFunc func,
                                               String column,
                                               FilterNode node)

获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

node - 过滤条件

返回:

聚合结果

getNumberResult

Number getNumberResult(Class entityClass,
                       FilterFunc func,
                       Number defVal,
                       String column)

获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table}
如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table}

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

返回:

聚合结果

getNumberResultAsync

CompletableFuture<Number> getNumberResultAsync(Class entityClass,
                                               FilterFunc func,
                                               Number defVal,
                                               String column)

获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table}
如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table}

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

返回:

聚合结果CompletableFuture

getNumberResult

Number getNumberResult(Class entityClass,
                       FilterFunc func,
                       Number defVal,
                       String column,
                       FilterBean bean)

获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

bean - 过滤条件

返回:

聚合结果

getNumberResultAsync

CompletableFuture<Number> getNumberResultAsync(Class entityClass,
                                               FilterFunc func,
                                               Number defVal,
                                               String column,
                                               FilterBean bean)

获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

bean - 过滤条件

返回:

聚合结果CompletableFuture

getNumberResult

Number getNumberResult(Class entityClass,
                       FilterFunc func,
                       Number defVal,
                       String column,
                       FilterNode node)

获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

node - 过滤条件

返回:

聚合结果

getNumberResultAsync

CompletableFuture<Number> getNumberResultAsync(Class entityClass,
                                               FilterFunc func,
                                               Number defVal,
                                               String column,
                                               FilterNode node)

获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

node - 过滤条件

返回:

聚合结果CompletableFuture

getNumberMap

<N extends Number> Map<String,N> getNumberMap(Class entityClass,
                                              FilterFuncColumn... columns)

获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table}
如 getNumberMapAsync(Record.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}

类型参数:

N - Number

参数:

entityClass - Entity类

columns - 聚合字段

返回:

聚合结果Map

getNumberMapAsync

<N extends Number> CompletableFuture<Map<String,N>> getNumberMapAsync(Class entityClass,
                                                                      FilterFuncColumn... columns)

获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table}
如 getNumberMapAsync(Record.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}

类型参数:

N - Number

参数:

entityClass - Entity类

columns - 聚合字段

返回:

聚合结果Map CompletableFuture

getNumberMap

<N extends Number> Map<String,N> getNumberMap(Class entityClass,
                                              FilterBean bean,
                                              FilterFuncColumn... columns)

获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean}
如 getNumberMapAsync(Record.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}

类型参数:

N - Number

参数:

entityClass - Entity类

bean - 过滤条件

columns - 聚合字段

返回:

聚合结果Map

getNumberMapAsync

<N extends Number> CompletableFuture<Map<String,N>> getNumberMapAsync(Class entityClass,
                                                                      FilterBean bean,
                                                                      FilterFuncColumn... columns)

获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean}
如 getNumberMapAsync(Record.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}

类型参数:

N - Number

参数:

entityClass - Entity类

bean - 过滤条件

columns - 聚合字段

返回:

聚合结果Map CompletableFuture

getNumberMap

<N extends Number> Map<String,N> getNumberMap(Class entityClass,
                                              FilterNode node,
                                              FilterFuncColumn... columns)

获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node}
如 getNumberMapAsync(Record.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}

类型参数:

N - Number

参数:

entityClass - Entity类

node - 过滤条件

columns - 聚合字段

返回:

聚合结果Map

getNumberMapAsync

<N extends Number> CompletableFuture<Map<String,N>> getNumberMapAsync(Class entityClass,
                                                                      FilterNode node,
                                                                      FilterFuncColumn... columns)

获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node}
如 getNumberMapAsync(Record.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}

类型参数:

N - Number

参数:

entityClass - Entity类

node - 过滤条件

columns - 聚合字段

返回:

聚合结果Map

queryColumnMap

<T,K extends Serializable,N extends Number> Map<K,N> queryColumnMap(Class<T> entityClass,
                                                                    String keyColumn,
                                                                    FilterFunc func,
                                                                    String funcColumn)

查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} GROUP BY {keyColumn}
如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime") 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

返回:

聚合结果Map

queryColumnMapAsync

<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N>> queryColumnMapAsync(Class<T> entityClass,
                                                                                            String keyColumn,
                                                                                            FilterFunc func,
                                                                                            String funcColumn)

查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} GROUP BY {keyColumn}
如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime") 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

返回:

聚合结果Map CompletableFuture

queryColumnMap

<T,K extends Serializable,N extends Number> Map<K,N> queryColumnMap(Class<T> entityClass,
                                                                    String keyColumn,
                                                                    FilterFunc func,
                                                                    String funcColumn,
                                                                    FilterBean bean)

查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn}
如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

bean - 过滤条件

返回:

聚合结果Map

queryColumnMapAsync

<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N>> queryColumnMapAsync(Class<T> entityClass,
                                                                                            String keyColumn,
                                                                                            FilterFunc func,
                                                                                            String funcColumn,
                                                                                            FilterBean bean)

查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn}
如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

bean - 过滤条件

返回:

聚合结果Map CompletableFuture

queryColumnMap

<T,K extends Serializable,N extends Number> Map<K,N> queryColumnMap(Class<T> entityClass,
                                                                    String keyColumn,
                                                                    FilterFunc func,
                                                                    String funcColumn,
                                                                    FilterNode node)

查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn}
如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

node - 过滤条件

返回:

聚合结果Map

queryColumnMapAsync

<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N>> queryColumnMapAsync(Class<T> entityClass,
                                                                                            String keyColumn,
                                                                                            FilterFunc func,
                                                                                            String funcColumn,
                                                                                            FilterNode node)

查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn}
如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

node - 过滤条件

返回:

聚合结果Map CompletableFuture

find

<T> T find(Class<T> clazz,
           Serializable pk)

获取指定主键值的单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {primary} = {id}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

Entity对象

findAsync

<T> CompletableFuture<T> findAsync(Class<T> clazz,
                                   Serializable pk)

获取指定主键值的单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {primary} = {id}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

Entity对象 CompletableFuture

find

<T> T find(Class<T> clazz,
           SelectColumn selects,
           Serializable pk)

获取指定主键值的单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

pk - 主键值

返回:

Entity对象

findAsync

<T> CompletableFuture<T> findAsync(Class<T> clazz,
                                   SelectColumn selects,
                                   Serializable pk)

获取指定主键值的单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

pk - 主键值

返回:

Entity对象CompletableFuture

find

<T> T find(Class<T> clazz,
           String column,
           Serializable key)

获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {column} = {key}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity对象

findAsync

<T> CompletableFuture<T> findAsync(Class<T> clazz,
                                   String column,
                                   Serializable key)

获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {column} = {key}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity对象CompletableFuture

find

<T> T find(Class<T> clazz,
           FilterBean bean)

获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity对象

findAsync

<T> CompletableFuture<T> findAsync(Class<T> clazz,
                                   FilterBean bean)

获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity对象CompletableFuture

find

<T> T find(Class<T> clazz,
           FilterNode node)

获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity对象

findAsync

<T> CompletableFuture<T> findAsync(Class<T> clazz,
                                   FilterNode node)

获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity对象CompletableFuture

find

<T> T find(Class<T> clazz,
           SelectColumn selects,
           FilterBean bean)

获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - 过滤条件

返回:

Entity对象

findAsync

<T> CompletableFuture<T> findAsync(Class<T> clazz,
                                   SelectColumn selects,
                                   FilterBean bean)

获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - 过滤条件

返回:

Entity对象 CompletableFuture

find

<T> T find(Class<T> clazz,
           SelectColumn selects,
           FilterNode node)

获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity对象

findAsync

<T> CompletableFuture<T> findAsync(Class<T> clazz,
                                   SelectColumn selects,
                                   FilterNode node)

获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity对象 CompletableFuture

findColumn

<T> Serializable findColumn(Class<T> clazz,
                            String column,
                            Serializable pk)

获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

pk - 主键值

返回:

Entity对象

findColumnAsync

<T> CompletableFuture<Serializable> findColumnAsync(Class<T> clazz,
                                                    String column,
                                                    Serializable pk)

获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

pk - 主键值

返回:

Entity对象 CompletableFuture

findColumn

<T> Serializable findColumn(Class<T> clazz,
                            String column,
                            FilterBean bean)

获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

bean - 过滤条件

返回:

字段值

findColumnAsync

<T> CompletableFuture<Serializable> findColumnAsync(Class<T> clazz,
                                                    String column,
                                                    FilterBean bean)

获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

bean - 过滤条件

返回:

字段值 CompletableFuture

findColumn

<T> Serializable findColumn(Class<T> clazz,
                            String column,
                            FilterNode node)

获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

node - 过滤条件

返回:

字段值

findColumnAsync

<T> CompletableFuture<Serializable> findColumnAsync(Class<T> clazz,
                                                    String column,
                                                    FilterNode node)

获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

node - 过滤条件

返回:

字段值 CompletableFuture

findColumn

<T> Serializable findColumn(Class<T> clazz,
                            String column,
                            Serializable defValue,
                            Serializable pk)

获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

pk - 主键值

返回:

字段值

findColumnAsync

<T> CompletableFuture<Serializable> findColumnAsync(Class<T> clazz,
                                                    String column,
                                                    Serializable defValue,
                                                    Serializable pk)

获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

pk - 主键值

返回:

字段值 CompletableFuture

findColumn

<T> Serializable findColumn(Class<T> clazz,
                            String column,
                            Serializable defValue,
                            FilterBean bean)

获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

bean - 过滤条件

返回:

字段值

findColumnAsync

<T> CompletableFuture<Serializable> findColumnAsync(Class<T> clazz,
                                                    String column,
                                                    Serializable defValue,
                                                    FilterBean bean)

获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

bean - 过滤条件

返回:

字段值 CompletableFuture

findColumn

<T> Serializable findColumn(Class<T> clazz,
                            String column,
                            Serializable defValue,
                            FilterNode node)

获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

node - 过滤条件

返回:

字段值

findColumnAsync

<T> CompletableFuture<Serializable> findColumnAsync(Class<T> clazz,
                                                    String column,
                                                    Serializable defValue,
                                                    FilterNode node)

获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

node - 过滤条件

返回:

字段值 CompletableFuture

exists

<T> boolean exists(Class<T> clazz,
                   Serializable pk)

判断是否存在主键值的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

是否存在

existsAsync

<T> CompletableFuture<Boolean> existsAsync(Class<T> clazz,
                                           Serializable pk)

判断是否存在主键值的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

是否存在CompletableFuture

exists

<T> boolean exists(Class<T> clazz,
                   FilterBean bean)

判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

是否存在

existsAsync

<T> CompletableFuture<Boolean> existsAsync(Class<T> clazz,
                                           FilterBean bean)

判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

是否存在CompletableFuture

exists

<T> boolean exists(Class<T> clazz,
                   FilterNode node)

判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

是否存在

existsAsync

<T> CompletableFuture<Boolean> existsAsync(Class<T> clazz,
                                           FilterNode node)

判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

是否存在CompletableFuture

queryColumnSet

<T,V extends Serializable> HashSet<V> queryColumnSet(String selectedColumn,
                                                     Class<T> clazz,
                                                     String column,
                                                     Serializable key)

查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

字段值的集合

queryColumnSetAsync

<T,V extends Serializable> CompletableFuture<HashSet<V>> queryColumnSetAsync(String selectedColumn,
                                                                             Class<T> clazz,
                                                                             String column,
                                                                             Serializable key)

查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

字段值的集合CompletableFuture

queryColumnSet

<T,V extends Serializable> HashSet<V> queryColumnSet(String selectedColumn,
                                                     Class<T> clazz,
                                                     FilterBean bean)

查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合

queryColumnSetAsync

<T,V extends Serializable> CompletableFuture<HashSet<V>> queryColumnSetAsync(String selectedColumn,
                                                                             Class<T> clazz,
                                                                             FilterBean bean)

查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnSet

<T,V extends Serializable> HashSet<V> queryColumnSet(String selectedColumn,
                                                     Class<T> clazz,
                                                     FilterNode node)

查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合

queryColumnSetAsync

<T,V extends Serializable> CompletableFuture<HashSet<V>> queryColumnSetAsync(String selectedColumn,
                                                                             Class<T> clazz,
                                                                             FilterNode node)

查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

<T,V extends Serializable> List<V> queryColumnList(String selectedColumn,
                                                   Class<T> clazz,
                                                   String column,
                                                   Serializable key)

查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

字段值的集合

queryColumnListAsync

<T,V extends Serializable> CompletableFuture<List<V>> queryColumnListAsync(String selectedColumn,
                                                                           Class<T> clazz,
                                                                           String column,
                                                                           Serializable key)

查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

字段值的集合CompletableFuture

queryColumnList

<T,V extends Serializable> List<V> queryColumnList(String selectedColumn,
                                                   Class<T> clazz,
                                                   FilterBean bean)

查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合

queryColumnListAsync

<T,V extends Serializable> CompletableFuture<List<V>> queryColumnListAsync(String selectedColumn,
                                                                           Class<T> clazz,
                                                                           FilterBean bean)

查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

<T,V extends Serializable> List<V> queryColumnList(String selectedColumn,
                                                   Class<T> clazz,
                                                   FilterNode node)

查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合

queryColumnListAsync

<T,V extends Serializable> CompletableFuture<List<V>> queryColumnListAsync(String selectedColumn,
                                                                           Class<T> clazz,
                                                                           FilterNode node)

查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

<T,V extends Serializable> List<V> queryColumnList(String selectedColumn,
                                                   Class<T> clazz,
                                                   Flipper flipper,
                                                   FilterBean bean)

查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

字段值的集合

queryColumnListAsync

<T,V extends Serializable> CompletableFuture<List<V>> queryColumnListAsync(String selectedColumn,
                                                                           Class<T> clazz,
                                                                           Flipper flipper,
                                                                           FilterBean bean)

查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

<T,V extends Serializable> List<V> queryColumnList(String selectedColumn,
                                                   Class<T> clazz,
                                                   Flipper flipper,
                                                   FilterNode node)

查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合

queryColumnListAsync

<T,V extends Serializable> CompletableFuture<List<V>> queryColumnListAsync(String selectedColumn,
                                                                           Class<T> clazz,
                                                                           Flipper flipper,
                                                                           FilterNode node)

查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnSheet

<T,V extends Serializable> Sheet<V> queryColumnSheet(String selectedColumn,
                                                     Class<T> clazz,
                                                     Flipper flipper,
                                                     FilterBean bean)

查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

字段值的集合

queryColumnSheetAsync

<T,V extends Serializable> CompletableFuture<Sheet<V>> queryColumnSheetAsync(String selectedColumn,
                                                                             Class<T> clazz,
                                                                             Flipper flipper,
                                                                             FilterBean bean)

查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnSheet

<T,V extends Serializable> Sheet<V> queryColumnSheet(String selectedColumn,
                                                     Class<T> clazz,
                                                     Flipper flipper,
                                                     FilterNode node)

查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合

queryColumnSheetAsync

<T,V extends Serializable> CompletableFuture<Sheet<V>> queryColumnSheetAsync(String selectedColumn,
                                                                             Class<T> clazz,
                                                                             Flipper flipper,
                                                                             FilterNode node)

查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryMap

<K extends Serializable,T> Map<K,T> queryMap(Class<T> clazz,
                                             Stream<K> keyStream)

查询符合过滤条件记录的Map集合, 主键值为key
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

keyStream - 主键Stream

返回:

Entity的集合

queryMapAsync

<K extends Serializable,T> CompletableFuture<Map<K,T>> queryMapAsync(Class<T> clazz,
                                                                     Stream<K> keyStream)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

keyStream - 主键Stream

返回:

Entity的集合CompletableFuture

queryMap

<K extends Serializable,T> Map<K,T> queryMap(Class<T> clazz,
                                             FilterBean bean)

查询符合过滤条件记录的Map集合, 主键值为key
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

bean - FilterBean

返回:

Entity的集合

queryMapAsync

<K extends Serializable,T> CompletableFuture<Map<K,T>> queryMapAsync(Class<T> clazz,
                                                                     FilterBean bean)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

bean - FilterBean

返回:

Entity的集合CompletableFuture

queryMap

<K extends Serializable,T> Map<K,T> queryMap(Class<T> clazz,
                                             FilterNode node)

查询符合过滤条件记录的Map集合, 主键值为key
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

node - FilterNode

返回:

Entity的集合

queryMapAsync

<K extends Serializable,T> CompletableFuture<Map<K,T>> queryMapAsync(Class<T> clazz,
                                                                     FilterNode node)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

node - FilterNode

返回:

Entity的集合CompletableFuture

queryMap

<K extends Serializable,T> Map<K,T> queryMap(Class<T> clazz,
                                             SelectColumn selects,
                                             Stream<K> keyStream)

查询符合过滤条件记录的Map集合, 主键值为key
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

keyStream - 主键Stream

返回:

Entity的集合

queryMapAsync

<K extends Serializable,T> CompletableFuture<Map<K,T>> queryMapAsync(Class<T> clazz,
                                                                     SelectColumn selects,
                                                                     Stream<K> keyStream)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

keyStream - 主键Stream

返回:

Entity的集合CompletableFuture

queryMap

<K extends Serializable,T> Map<K,T> queryMap(Class<T> clazz,
                                             SelectColumn selects,
                                             FilterBean bean)

查询符合过滤条件记录的Map集合, 主键值为key
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - FilterBean

返回:

Entity的集合

queryMapAsync

<K extends Serializable,T> CompletableFuture<Map<K,T>> queryMapAsync(Class<T> clazz,
                                                                     SelectColumn selects,
                                                                     FilterBean bean)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - FilterBean

返回:

Entity的集合CompletableFuture

queryMap

<K extends Serializable,T> Map<K,T> queryMap(Class<T> clazz,
                                             SelectColumn selects,
                                             FilterNode node)

查询符合过滤条件记录的Map集合, 主键值为key
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - FilterNode

返回:

Entity的集合

queryMapAsync

<K extends Serializable,T> CompletableFuture<Map<K,T>> queryMapAsync(Class<T> clazz,
                                                                     SelectColumn selects,
                                                                     FilterNode node)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - FilterNode

返回:

Entity的集合CompletableFuture

queryList

<T> List<T> queryList(Class<T> clazz,
                      String column,
                      Serializable key)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity的集合

queryListAsync

<T> CompletableFuture<List<T>> queryListAsync(Class<T> clazz,
                                              String column,
                                              Serializable key)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity的集合CompletableFuture

queryList

<T> List<T> queryList(Class<T> clazz,
                      FilterBean bean)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity的集合

queryListAsync

<T> CompletableFuture<List<T>> queryListAsync(Class<T> clazz,
                                              FilterBean bean)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

default <T> List<T> queryList(Class<T> clazz)

查询记录的List集合
等价SQL: SELECT * FROM {table}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

Entity的集合

queryList

<T> List<T> queryList(Class<T> clazz,
                      FilterNode node)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity的集合

queryListAsync

default <T> CompletableFuture<List<T>> queryListAsync(Class<T> clazz)

查询记录的List集合
等价SQL: SELECT * FROM {table}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

Entity的集合CompletableFuture

queryListAsync

<T> CompletableFuture<List<T>> queryListAsync(Class<T> clazz,
                                              FilterNode node)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

<T> List<T> queryList(Class<T> clazz,
                      SelectColumn selects,
                      FilterBean bean)

查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - 过滤条件

返回:

Entity的集合

queryListAsync

<T> CompletableFuture<List<T>> queryListAsync(Class<T> clazz,
                                              SelectColumn selects,
                                              FilterBean bean)

查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

<T> List<T> queryList(Class<T> clazz,
                      SelectColumn selects,
                      FilterNode node)

查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity的集合

queryListAsync

<T> CompletableFuture<List<T>> queryListAsync(Class<T> clazz,
                                              SelectColumn selects,
                                              FilterNode node)

查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

<T> List<T> queryList(Class<T> clazz,
                      Flipper flipper,
                      String column,
                      Serializable key)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

column - 过滤字段名

key - 过滤字段值

返回:

Entity的集合

queryListAsync

<T> CompletableFuture<List<T>> queryListAsync(Class<T> clazz,
                                              Flipper flipper,
                                              String column,
                                              Serializable key)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

column - 过滤字段名

key - 过滤字段值

返回:

Entity的集合CompletableFuture

queryList

<T> List<T> queryList(Class<T> clazz,
                      Flipper flipper,
                      FilterBean bean)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合

queryListAsync

<T> CompletableFuture<List<T>> queryListAsync(Class<T> clazz,
                                              Flipper flipper,
                                              FilterBean bean)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

<T> List<T> queryList(Class<T> clazz,
                      Flipper flipper,
                      FilterNode node)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

queryListAsync

<T> CompletableFuture<List<T>> queryListAsync(Class<T> clazz,
                                              Flipper flipper,
                                              FilterNode node)

查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

queryList

<T> List<T> queryList(Class<T> clazz,
                      SelectColumn selects,
                      Flipper flipper,
                      FilterBean bean)

查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合

queryListAsync

<T> CompletableFuture<List<T>> queryListAsync(Class<T> clazz,
                                              SelectColumn selects,
                                              Flipper flipper,
                                              FilterBean bean)

查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

<T> List<T> queryList(Class<T> clazz,
                      SelectColumn selects,
                      Flipper flipper,
                      FilterNode node)

查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

queryListAsync

<T> CompletableFuture<List<T>> queryListAsync(Class<T> clazz,
                                              SelectColumn selects,
                                              Flipper flipper,
                                              FilterNode node)

查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

<T> Sheet<T> querySheet(Class<T> clazz,
                        Flipper flipper,
                        FilterBean bean)

查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合

querySheetAsync

<T> CompletableFuture<Sheet<T>> querySheetAsync(Class<T> clazz,
                                                Flipper flipper,
                                                FilterBean bean)

查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

<T> Sheet<T> querySheet(Class<T> clazz,
                        Flipper flipper,
                        FilterNode node)

查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

querySheetAsync

<T> CompletableFuture<Sheet<T>> querySheetAsync(Class<T> clazz,
                                                Flipper flipper,
                                                FilterNode node)

查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

<T> Sheet<T> querySheet(Class<T> clazz,
                        SelectColumn selects,
                        Flipper flipper,
                        FilterBean bean)

查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合

querySheetAsync

<T> CompletableFuture<Sheet<T>> querySheetAsync(Class<T> clazz,
                                                SelectColumn selects,
                                                Flipper flipper,
                                                FilterBean bean)

查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

<T> Sheet<T> querySheet(Class<T> clazz,
                        SelectColumn selects,
                        Flipper flipper,
                        FilterNode node)

查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

querySheetAsync

<T> CompletableFuture<Sheet<T>> querySheetAsync(Class<T> clazz,
                                                SelectColumn selects,
                                                Flipper flipper,
                                                FilterNode node)

查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合CompletableFuture