org.redkale.source

接口 DataSource

所有已知实现类:

DataJdbcSource, DataMemorySource, DataSqlSource

public interface DataSource

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

详情见: https://redkale.org

方法概要

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

方法详细资料

getType

java.lang.String getType()

获取数据源类型

返回:

String

insert

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

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数

insertAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> insertAsync(T... entitys)

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

CompletableFuture

delete

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

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数

delete

default <T> int delete(java.util.Collection<T> entitys)

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数

delete

default <T> int delete(java.util.stream.Stream<T> entitys)

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数

deleteAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteAsync(T... entitys)

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数CompletableFuture

deleteAsync

default <T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteAsync(java.util.Collection<T> entitys)

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数CompletableFuture

deleteAsync

default <T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteAsync(java.util.stream.Stream<T> entitys)

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数CompletableFuture

delete

<T> int delete(java.lang.Class<T> clazz,
               java.io.Serializable... pks)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pks - 主键值

返回:

影响的记录条数

deleteAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteAsync(java.lang.Class<T> clazz,
                                                                          java.io.Serializable... pks)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pks - 主键值

返回:

影响的记录条数CompletableFuture

delete

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

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数

deleteAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteAsync(java.lang.Class<T> clazz,
                                                                          FilterNode node)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数CompletableFuture

delete

<T> int delete(java.lang.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> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteAsync(java.lang.Class<T> clazz,
                                                                          Flipper flipper,
                                                                          FilterNode node)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

影响的记录条数CompletableFuture

clearTable

<T> int clearTable(java.lang.Class<T> clazz)

清空表
等价SQL: TRUNCATE TABLE {table}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

影响的记录条数

clearTableAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> clearTableAsync(java.lang.Class<T> clazz)

清空表
等价SQL: TRUNCATE TABLE {table}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

影响的记录条数CompletableFuture

clearTable

<T> int clearTable(java.lang.Class<T> clazz,
                   FilterNode node)

清空表
等价SQL: TRUNCATE TABLE {table}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数

clearTableAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> clearTableAsync(java.lang.Class<T> clazz,
                                                                              FilterNode node)

清空表
等价SQL: TRUNCATE TABLE {table}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数CompletableFuture

dropTable

<T> int dropTable(java.lang.Class<T> clazz)

删除表
等价SQL: DROP TABLE {table}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

影响的记录条数

dropTableAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> dropTableAsync(java.lang.Class<T> clazz)

删除表
等价SQL: DROP TABLE {table}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

影响的记录条数CompletableFuture

dropTable

<T> int dropTable(java.lang.Class<T> clazz,
                  FilterNode node)

删除表
等价SQL: DROP TABLE {table}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数

dropTableAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> dropTableAsync(java.lang.Class<T> clazz,
                                                                             FilterNode node)

删除表
等价SQL: DROP TABLE {table}

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数CompletableFuture

update

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

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数

update

default <T> int update(java.util.Collection<T> entitys)

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数

update

default <T> int update(java.util.stream.Stream<T> entitys)

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数

updateAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateAsync(T... entitys)

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数CompletableFuture

updateAsync

default <T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateAsync(java.util.Collection<T> entitys)

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数CompletableFuture

updateAsync

default <T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateAsync(java.util.stream.Stream<T> entitys)

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

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数CompletableFuture

updateColumn

<T> int updateColumn(java.lang.Class<T> clazz,
                     java.io.Serializable pk,
                     java.lang.String column,
                     java.io.Serializable value)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键

column - 待更新的字段名

value - 更新值

返回:

影响的记录条数

updateColumnAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(java.lang.Class<T> clazz,
                                                                                java.io.Serializable pk,
                                                                                java.lang.String column,
                                                                                java.io.Serializable value)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键

column - 待更新的字段名

value - 更新值

返回:

影响的记录条数CompletableFuture

updateColumn

<T> int updateColumn(java.lang.Class<T> clazz,
                     java.lang.String column,
                     java.io.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> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(java.lang.Class<T> clazz,
                                                                                java.lang.String column,
                                                                                java.io.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(java.lang.Class<T> clazz,
                     java.io.Serializable pk,
                     ColumnValue... values)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键

values - 更新字段

返回:

影响的记录条数

updateColumnAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(java.lang.Class<T> clazz,
                                                                                java.io.Serializable pk,
                                                                                ColumnValue... values)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键

values - 更新字段

返回:

影响的记录条数CompletableFuture

updateColumn

<T> int updateColumn(java.lang.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> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(java.lang.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(java.lang.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> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(java.lang.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 entity,
                     java.lang.String... columns)

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

类型参数:

T - Entity泛型

参数:

entity - 待更新的Entity对象

columns - 需更新的字段名

返回:

影响的记录条数

updateColumnAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(T entity,
                                                                                java.lang.String... columns)

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

类型参数:

T - Entity泛型

参数:

entity - 待更新的Entity对象

columns - 需更新的字段名

返回:

影响的记录条数CompletableFuture

updateColumn

<T> int updateColumn(T entity,
                     FilterNode node,
                     java.lang.String... columns)

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

类型参数:

T - Entity泛型

参数:

entity - 待更新的Entity对象

node - 过滤条件

columns - 需更新的字段名

返回:

影响的记录条数

updateColumnAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(T entity,
                                                                                FilterNode node,
                                                                                java.lang.String... columns)

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

类型参数:

T - Entity泛型

参数:

entity - 待更新的Entity对象

node - 过滤条件

columns - 需更新的字段名

返回:

影响的记录条数CompletableFuture

updateColumn

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

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

类型参数:

T - Entity泛型

参数:

entity - 待更新的Entity对象

selects - 指定字段

返回:

影响的记录条数

updateColumnAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(T entity,
                                                                                SelectColumn selects)

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

类型参数:

T - Entity泛型

参数:

entity - 待更新的Entity对象

selects - 指定字段

返回:

影响的记录条数CompletableFuture

updateColumn

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

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

类型参数:

T - Entity泛型

参数:

entity - 待更新的Entity对象

node - 过滤条件

selects - 指定字段

返回:

影响的记录条数

updateColumnAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(T entity,
                                                                                FilterNode node,
                                                                                SelectColumn selects)

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

类型参数:

T - Entity泛型

参数:

entity - 待更新的Entity对象

node - 过滤条件

selects - 指定字段

返回:

影响的记录条数CompletableFuture

getNumberResult

java.lang.Number getNumberResult(java.lang.Class entityClass,
                                 FilterFunc func,
                                 java.lang.String column)

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

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

返回:

聚合结果

getNumberResultAsync

java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass,
                                                                              FilterFunc func,
                                                                              java.lang.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

java.lang.Number getNumberResult(java.lang.Class entityClass,
                                 FilterFunc func,
                                 java.lang.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

java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass,
                                                                              FilterFunc func,
                                                                              java.lang.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

java.lang.Number getNumberResult(java.lang.Class entityClass,
                                 FilterFunc func,
                                 java.lang.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

java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass,
                                                                              FilterFunc func,
                                                                              java.lang.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

java.lang.Number getNumberResult(java.lang.Class entityClass,
                                 FilterFunc func,
                                 java.lang.Number defVal,
                                 java.lang.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

java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass,
                                                                              FilterFunc func,
                                                                              java.lang.Number defVal,
                                                                              java.lang.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

java.lang.Number getNumberResult(java.lang.Class entityClass,
                                 FilterFunc func,
                                 java.lang.Number defVal,
                                 java.lang.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

java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass,
                                                                              FilterFunc func,
                                                                              java.lang.Number defVal,
                                                                              java.lang.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

java.lang.Number getNumberResult(java.lang.Class entityClass,
                                 FilterFunc func,
                                 java.lang.Number defVal,
                                 java.lang.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

java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass,
                                                                              FilterFunc func,
                                                                              java.lang.Number defVal,
                                                                              java.lang.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 java.lang.Number> java.util.Map<java.lang.String,N> getNumberMap(java.lang.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 java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<java.lang.String,N>> getNumberMapAsync(java.lang.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 java.lang.Number> java.util.Map<java.lang.String,N> getNumberMap(java.lang.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 java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<java.lang.String,N>> getNumberMapAsync(java.lang.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 java.lang.Number> java.util.Map<java.lang.String,N> getNumberMap(java.lang.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 java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<java.lang.String,N>> getNumberMapAsync(java.lang.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 java.io.Serializable,N extends java.lang.Number> java.util.Map<K,N> queryColumnMap(java.lang.Class<T> entityClass,
                                                                                                java.lang.String keyColumn,
                                                                                                FilterFunc func,
                                                                                                java.lang.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 java.io.Serializable,N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<K,N>> queryColumnMapAsync(java.lang.Class<T> entityClass,
                                                                                                                                             java.lang.String keyColumn,
                                                                                                                                             FilterFunc func,
                                                                                                                                             java.lang.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 java.io.Serializable,N extends java.lang.Number> java.util.Map<K,N> queryColumnMap(java.lang.Class<T> entityClass,
                                                                                                java.lang.String keyColumn,
                                                                                                FilterFunc func,
                                                                                                java.lang.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 java.io.Serializable,N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<K,N>> queryColumnMapAsync(java.lang.Class<T> entityClass,
                                                                                                                                             java.lang.String keyColumn,
                                                                                                                                             FilterFunc func,
                                                                                                                                             java.lang.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 java.io.Serializable,N extends java.lang.Number> java.util.Map<K,N> queryColumnMap(java.lang.Class<T> entityClass,
                                                                                                java.lang.String keyColumn,
                                                                                                FilterFunc func,
                                                                                                java.lang.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 java.io.Serializable,N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<K,N>> queryColumnMapAsync(java.lang.Class<T> entityClass,
                                                                                                                                             java.lang.String keyColumn,
                                                                                                                                             FilterFunc func,
                                                                                                                                             java.lang.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(java.lang.Class<T> clazz,
           java.io.Serializable pk)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

Entity对象

findAsync

<T> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.Class<T> clazz,
                                                        java.io.Serializable pk)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

Entity对象 CompletableFuture

find

<T> T find(java.lang.Class<T> clazz,
           SelectColumn selects,
           java.io.Serializable pk)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

pk - 主键值

返回:

Entity对象

findAsync

<T> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.Class<T> clazz,
                                                        SelectColumn selects,
                                                        java.io.Serializable pk)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

pk - 主键值

返回:

Entity对象CompletableFuture

find

<T> T find(java.lang.Class<T> clazz,
           java.lang.String column,
           java.io.Serializable colval)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

Entity对象

findAsync

<T> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.Class<T> clazz,
                                                        java.lang.String column,
                                                        java.io.Serializable colval)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

Entity对象CompletableFuture

find

<T> T find(java.lang.Class<T> clazz,
           FilterBean bean)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity对象

findAsync

<T> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.Class<T> clazz,
                                                        FilterBean bean)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity对象CompletableFuture

find

<T> T find(java.lang.Class<T> clazz,
           FilterNode node)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity对象

findAsync

<T> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.Class<T> clazz,
                                                        FilterNode node)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity对象CompletableFuture

find

<T> T find(java.lang.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> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.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(java.lang.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> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.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> java.io.Serializable findColumn(java.lang.Class<T> clazz,
                                    java.lang.String column,
                                    java.io.Serializable pk)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

pk - 主键值

返回:

Entity对象

findColumnAsync

<T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnAsync(java.lang.Class<T> clazz,
                                                                                 java.lang.String column,
                                                                                 java.io.Serializable pk)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

pk - 主键值

返回:

Entity对象 CompletableFuture

findColumn

<T> java.io.Serializable findColumn(java.lang.Class<T> clazz,
                                    java.lang.String column,
                                    FilterBean bean)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

bean - 过滤条件

返回:

字段值

findColumnAsync

<T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnAsync(java.lang.Class<T> clazz,
                                                                                 java.lang.String column,
                                                                                 FilterBean bean)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

bean - 过滤条件

返回:

字段值 CompletableFuture

findColumn

<T> java.io.Serializable findColumn(java.lang.Class<T> clazz,
                                    java.lang.String column,
                                    FilterNode node)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

node - 过滤条件

返回:

字段值

findColumnAsync

<T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnAsync(java.lang.Class<T> clazz,
                                                                                 java.lang.String column,
                                                                                 FilterNode node)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

node - 过滤条件

返回:

字段值 CompletableFuture

findColumn

<T> java.io.Serializable findColumn(java.lang.Class<T> clazz,
                                    java.lang.String column,
                                    java.io.Serializable defValue,
                                    java.io.Serializable pk)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

pk - 主键值

返回:

字段值

findColumnAsync

<T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnAsync(java.lang.Class<T> clazz,
                                                                                 java.lang.String column,
                                                                                 java.io.Serializable defValue,
                                                                                 java.io.Serializable pk)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

pk - 主键值

返回:

字段值 CompletableFuture

findColumn

<T> java.io.Serializable findColumn(java.lang.Class<T> clazz,
                                    java.lang.String column,
                                    java.io.Serializable defValue,
                                    FilterBean bean)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

bean - 过滤条件

返回:

字段值

findColumnAsync

<T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnAsync(java.lang.Class<T> clazz,
                                                                                 java.lang.String column,
                                                                                 java.io.Serializable defValue,
                                                                                 FilterBean bean)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

bean - 过滤条件

返回:

字段值 CompletableFuture

findColumn

<T> java.io.Serializable findColumn(java.lang.Class<T> clazz,
                                    java.lang.String column,
                                    java.io.Serializable defValue,
                                    FilterNode node)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

node - 过滤条件

返回:

字段值

findColumnAsync

<T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnAsync(java.lang.Class<T> clazz,
                                                                                 java.lang.String column,
                                                                                 java.io.Serializable defValue,
                                                                                 FilterNode node)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

node - 过滤条件

返回:

字段值 CompletableFuture

exists

<T> boolean exists(java.lang.Class<T> clazz,
                   java.io.Serializable pk)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

是否存在

existsAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Boolean> existsAsync(java.lang.Class<T> clazz,
                                                                          java.io.Serializable pk)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

是否存在CompletableFuture

exists

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

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

是否存在

existsAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Boolean> existsAsync(java.lang.Class<T> clazz,
                                                                          FilterBean bean)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

是否存在CompletableFuture

exists

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

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

是否存在

existsAsync

<T> java.util.concurrent.CompletableFuture<java.lang.Boolean> existsAsync(java.lang.Class<T> clazz,
                                                                          FilterNode node)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

是否存在CompletableFuture

queryColumnSet

<T,V extends java.io.Serializable> java.util.HashSet<V> queryColumnSet(java.lang.String selectedColumn,
                                                                       java.lang.Class<T> clazz,
                                                                       java.lang.String column,
                                                                       java.io.Serializable colval)

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

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

字段值的集合

queryColumnSetAsync

<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.HashSet<V>> queryColumnSetAsync(java.lang.String selectedColumn,
                                                                                                                    java.lang.Class<T> clazz,
                                                                                                                    java.lang.String column,
                                                                                                                    java.io.Serializable colval)

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

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

字段值的集合CompletableFuture

queryColumnSet

<T,V extends java.io.Serializable> java.util.HashSet<V> queryColumnSet(java.lang.String selectedColumn,
                                                                       java.lang.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 java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.HashSet<V>> queryColumnSetAsync(java.lang.String selectedColumn,
                                                                                                                    java.lang.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 java.io.Serializable> java.util.HashSet<V> queryColumnSet(java.lang.String selectedColumn,
                                                                       java.lang.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 java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.HashSet<V>> queryColumnSetAsync(java.lang.String selectedColumn,
                                                                                                                    java.lang.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 java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn,
                                                                     java.lang.Class<T> clazz,
                                                                     java.lang.String column,
                                                                     java.io.Serializable colval)

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

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

字段值的集合

queryColumnListAsync

<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>> queryColumnListAsync(java.lang.String selectedColumn,
                                                                                                                  java.lang.Class<T> clazz,
                                                                                                                  java.lang.String column,
                                                                                                                  java.io.Serializable colval)

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

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

字段值的集合CompletableFuture

queryColumnList

<T,V extends java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn,
                                                                     java.lang.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 java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>> queryColumnListAsync(java.lang.String selectedColumn,
                                                                                                                  java.lang.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 java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn,
                                                                     java.lang.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 java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>> queryColumnListAsync(java.lang.String selectedColumn,
                                                                                                                  java.lang.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 java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn,
                                                                     java.lang.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 java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>> queryColumnListAsync(java.lang.String selectedColumn,
                                                                                                                  java.lang.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 java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn,
                                                                     java.lang.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 java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>> queryColumnListAsync(java.lang.String selectedColumn,
                                                                                                                  java.lang.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 java.io.Serializable> Sheet<V> queryColumnSheet(java.lang.String selectedColumn,
                                                             java.lang.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 java.io.Serializable> java.util.concurrent.CompletableFuture<Sheet<V>> queryColumnSheetAsync(java.lang.String selectedColumn,
                                                                                                          java.lang.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 java.io.Serializable> Sheet<V> queryColumnSheet(java.lang.String selectedColumn,
                                                             java.lang.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 java.io.Serializable> java.util.concurrent.CompletableFuture<Sheet<V>> queryColumnSheetAsync(java.lang.String selectedColumn,
                                                                                                          java.lang.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 java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz,
                                                               java.util.stream.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 java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.Class<T> clazz,
                                                                                                            java.util.stream.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 java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.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 java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.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 java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.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 java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.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 java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz,
                                                               SelectColumn selects,
                                                               java.util.stream.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 java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.Class<T> clazz,
                                                                                                            SelectColumn selects,
                                                                                                            java.util.stream.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 java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.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 java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.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 java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.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 java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.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> java.util.List<T> queryList(java.lang.Class<T> clazz,
                                java.lang.String column,
                                java.io.Serializable colval)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

Entity的集合

queryListAsync

<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz,
                                                                             java.lang.String column,
                                                                             java.io.Serializable colval)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

Entity的集合CompletableFuture

queryList

<T> java.util.List<T> queryList(java.lang.Class<T> clazz,
                                FilterBean bean)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity的集合

queryListAsync

<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz,
                                                                             FilterBean bean)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

default <T> java.util.List<T> queryList(java.lang.Class<T> clazz)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

Entity的集合

queryList

<T> java.util.List<T> queryList(java.lang.Class<T> clazz,
                                FilterNode node)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity的集合

queryListAsync

default <T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

Entity的集合CompletableFuture

queryListAsync

<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz,
                                                                             FilterNode node)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

<T> java.util.List<T> queryList(java.lang.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> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.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> java.util.List<T> queryList(java.lang.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> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.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> java.util.List<T> queryList(java.lang.Class<T> clazz,
                                Flipper flipper,
                                java.lang.String column,
                                java.io.Serializable colval)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

column - 过滤字段名

colval - 过滤字段值

返回:

Entity的集合

queryListAsync

<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz,
                                                                             Flipper flipper,
                                                                             java.lang.String column,
                                                                             java.io.Serializable colval)

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

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

column - 过滤字段名

colval - 过滤字段值

返回:

Entity的集合CompletableFuture

queryList

<T> java.util.List<T> queryList(java.lang.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> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.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> java.util.List<T> queryList(java.lang.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> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.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> java.util.List<T> queryList(java.lang.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> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.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> java.util.List<T> queryList(java.lang.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> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.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(java.lang.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> java.util.concurrent.CompletableFuture<Sheet<T>> querySheetAsync(java.lang.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(java.lang.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> java.util.concurrent.CompletableFuture<Sheet<T>> querySheetAsync(java.lang.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(java.lang.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> java.util.concurrent.CompletableFuture<Sheet<T>> querySheetAsync(java.lang.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(java.lang.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> java.util.concurrent.CompletableFuture<Sheet<T>> querySheetAsync(java.lang.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