org.redkale.source

类 DataJdbcSource

java.lang.Object

org.redkale.service.AbstractService

org.redkale.source.DataJdbcSource

所有已实现的接口:

java.lang.AutoCloseable, java.util.function.Function<java.lang.Class,EntityInfo>, Service, DataCacheListener, DataSource, Resourcable

@Local
 @AutoLoad(value=false)
 @ResourceType(value=DataSource.class)
public class DataJdbcSource
extends AbstractService
implements DataSource, Service, DataCacheListener, java.util.function.Function<java.lang.Class,EntityInfo>, java.lang.AutoCloseable, Resourcable

DataSource的JDBC实现类

详情见: https://redkale.org

作者:

zhangjx

构造器概要

构造器

构造器和说明
DataJdbcSource(java.lang.String unitName, java.util.Properties readprop, java.util.Properties writeprop)

方法概要

限定符和类型	方法和说明
EntityInfo	apply(java.lang.Class t)
void	close()
<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... ids) 删除指定主键值的记录 等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
<T> int	delete(T... values) 删除对象， 必须是Entity对象
<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... ids) 删除指定主键值的记录 等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	deleteAsync(T... values) 删除指定主键值的记录， 多对象必须是同一个Entity类 等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}
<T> int	deleteCache(java.lang.Class<T> clazz, java.io.Serializable... ids)
int[]	directExecute(java.lang.String... sqls) 直接本地执行SQL语句进行增删改操作，远程模式不可用 通常用于复杂的更新操作
void	directQuery(java.lang.String sql, java.util.function.Consumer<java.sql.ResultSet> consumer) 直接本地执行SQL语句进行查询，远程模式不可用 通常用于复杂的关联查询
<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) 根据主键获取对象
<T> T	find(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable key) 获取符合过滤条件单个记录, 返回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 key) 获取符合过滤条件单个记录, 返回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}
<T> void	insert(T... values) 新增对象， 必须是Entity对象
<T> java.util.concurrent.CompletableFuture<java.lang.Void>	insertAsync(T... values) 新增记录， 多对象必须是同一个Entity类
<T> int	insertCache(java.lang.Class<T> clazz, T... values)
<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 key) 查询符合过滤条件记录的某个字段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 key) 查询符合过滤条件记录的某个字段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 key) 查询符合过滤条件记录的某个字段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 key) 查询符合过滤条件记录的某个字段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) 根据指定参数查询对象某个字段的集合
<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}
<T> java.util.List<T>	queryList(java.lang.Class<T> clazz, FilterBean bean) 根据过滤对象FilterBean查询对象集合
<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 key) 查询符合过滤条件记录的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) 根据过滤对象FilterBean查询对象集合， 对象只填充或排除SelectField指定的字段
<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 key) 根据指定字段值查询对象集合
<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 key) 查询符合过滤条件记录的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 key) 查询符合过滤条件记录的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) 根据过滤对象FilterBean和翻页对象Flipper查询一页的数据
<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) 根据过滤对象FilterBean和翻页对象Flipper查询一页的数据， 对象只填充或排除SelectField指定的字段
<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}
<T> void	refreshCache(java.lang.Class<T> clazz) 将entity的对象全部加载到Cache中去，如果clazz没有被@javax.persistence.Cacheable注解则不做任何事
<T> int	reloadCache(java.lang.Class<T> clazz, java.io.Serializable... ids)
java.lang.String	resourceName()
<T> int	update(T... values) 更新对象， 必须是Entity对象
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	updateAsync(T... values) 更新记录， 多对象必须是同一个Entity类 等价SQL: UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1} UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2} ···
<T> int	updateCache(java.lang.Class<T> clazz, T... values)
<T> int	updateColumn(java.lang.Class<T> clazz, FilterNode node, ColumnValue... values) 根据主键值更新对象的多个column对应的值， 必须是Entity Class
<T> int	updateColumn(java.lang.Class<T> clazz, FilterNode node, Flipper flipper, ColumnValue... values) 根据主键值更新对象的多个column对应的值， 必须是Entity Class
<T> int	updateColumn(java.lang.Class<T> clazz, java.io.Serializable id, ColumnValue... values) 根据主键值更新对象的多个column对应的值， 必须是Entity Class
<T> int	updateColumn(java.lang.Class<T> clazz, java.io.Serializable id, java.lang.String column, java.io.Serializable value) 根据主键值更新对象的column对应的值， 必须是Entity Class
<T> int	updateColumn(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable value, FilterNode node) 根据主键值更新对象的column对应的值， 必须是Entity Class
<T> int	updateColumn(T bean, FilterNode node, SelectColumn selects) 更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
<T> int	updateColumn(T bean, FilterNode node, 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 bean, SelectColumn selects) 更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
<T> int	updateColumn(T bean, 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} LIMIT {flipper.limit}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	updateColumnAsync(java.lang.Class<T> clazz, java.io.Serializable id, 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.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 bean, 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 bean, 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 bean, 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 bean, 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>	updateColumnupdateColumnAsync(java.lang.Class<T> clazz, java.io.Serializable id, java.lang.String column, java.io.Serializable value) 更新单个记录的单个字段 注意：即使字段标记为@Column(updatable=false)也会被更新 等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}

从类继承的方法 org.redkale.service.AbstractService

getExecutor, runAsync

从类继承的方法 java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从接口继承的方法 org.redkale.service.Service

destroy, init

从接口继承的方法 java.util.function.Function

andThen, compose, identity

构造器详细资料

DataJdbcSource

public DataJdbcSource(java.lang.String unitName,
                      java.util.Properties readprop,
                      java.util.Properties writeprop)

方法详细资料

resourceName

public final java.lang.String resourceName()

指定者:

resourceName 在接口中 Resourcable

close

public void close()
           throws java.lang.Exception

指定者:

close 在接口中 java.lang.AutoCloseable

抛出:

java.lang.Exception

apply

public EntityInfo apply(java.lang.Class t)

指定者:

apply 在接口中 java.util.function.Function<java.lang.Class,EntityInfo>

refreshCache

public <T> void refreshCache(java.lang.Class<T> clazz)

将entity的对象全部加载到Cache中去，如果clazz没有被@javax.persistence.Cacheable注解则不做任何事

类型参数:

T - Entity类泛型

参数:

clazz - Entity类

insert

public <T> void insert(@RpcCall(value=DataCallArrayAttribute.class)
                       T... values)

新增对象， 必须是Entity对象

指定者:

insert 在接口中 DataSource

类型参数:

T - Entity类泛型

参数:

values - Entity对象

insertAsync

public <T> java.util.concurrent.CompletableFuture<java.lang.Void> insertAsync(@RpcCall(value=DataCallArrayAttribute.class)
                                                                              T... values)

从接口复制的说明: DataSource

新增记录， 多对象必须是同一个Entity类

指定者:

insertAsync 在接口中 DataSource

类型参数:

T - 泛型

参数:

values - Entity对象

返回:

CompletableFuture

insertCache

public <T> int insertCache(java.lang.Class<T> clazz,
                           T... values)

指定者:

insertCache 在接口中 DataCacheListener

delete

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

删除对象， 必须是Entity对象

指定者:

delete 在接口中 DataSource

类型参数:

T - Entity类泛型

参数:

values - Entity对象

返回:

删除的数据条数

deleteAsync

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

从接口复制的说明: DataSource

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

指定者:

deleteAsync 在接口中 DataSource

类型参数:

T - 泛型

参数:

values - Entity对象

返回:

影响的记录条数CompletableFuture

delete

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

从接口复制的说明: DataSource

删除指定主键值的记录
等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}

指定者:

delete 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

ids - 主键值

返回:

影响的记录条数

deleteAsync

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

从接口复制的说明: DataSource

删除指定主键值的记录
等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}

指定者:

deleteAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

ids - 主键值

返回:

影响的记录条数CompletableFuture

delete

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

从接口复制的说明: DataSource

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

指定者:

delete 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数

deleteAsync

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

从接口复制的说明: DataSource

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

指定者:

deleteAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数CompletableFuture

delete

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

从接口复制的说明: DataSource

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

指定者:

delete 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

影响的记录条数

deleteAsync

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

从接口复制的说明: DataSource

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

指定者:

deleteAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

影响的记录条数CompletableFuture

deleteCache

public <T> int deleteCache(java.lang.Class<T> clazz,
                           java.io.Serializable... ids)

指定者:

deleteCache 在接口中 DataCacheListener

update

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

更新对象， 必须是Entity对象

指定者:

update 在接口中 DataSource

类型参数:

T - Entity类泛型

参数:

values - Entity对象

返回:

更新的数据条数

updateAsync

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

从接口复制的说明: DataSource

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

指定者:

updateAsync 在接口中 DataSource

类型参数:

T - 泛型

参数:

values - Entity对象

返回:

影响的记录条数CompletableFuture

updateColumn

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

根据主键值更新对象的column对应的值， 必须是Entity Class

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

id - 主键值

column - 过滤字段名

value - 过滤字段值

返回:

更新的数据条数

updateColumnupdateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnupdateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

id - 主键

column - 待更新的字段名

value - 更新值

返回:

影响的记录条数CompletableFuture

updateColumn

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

根据主键值更新对象的column对应的值， 必须是Entity Class

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

column - 过滤字段名

value - 过滤字段值

node - 过滤node 不能为null

返回:

更新的数据条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 待更新的字段名

value - 更新值

node - 过滤条件

返回:

影响的记录条数CompletableFuture

updateColumn

public <T> int updateColumn(java.lang.Class<T> clazz,
                            java.io.Serializable id,
                            ColumnValue... values)

根据主键值更新对象的多个column对应的值， 必须是Entity Class

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

id - 主键值

values - 字段值

返回:

更新的数据条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

id - 主键

values - 更新字段

返回:

影响的记录条数CompletableFuture

updateColumn

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

根据主键值更新对象的多个column对应的值， 必须是Entity Class

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

node - 过滤条件

values - 字段值

返回:

更新的数据条数

updateColumnAsync

public <T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(java.lang.Class<T> clazz,
                                                                                       FilterNode node,
                                                                                       ColumnValue... values)

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

values - 更新字段

返回:

影响的记录条数CompletableFuture

updateColumn

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

根据主键值更新对象的多个column对应的值， 必须是Entity Class

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

node - 过滤条件

flipper - 翻页对象

values - 字段值

返回:

更新的数据条数

updateColumnAsync

public <T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(java.lang.Class<T> clazz,
                                                                                       FilterNode node,
                                                                                       Flipper flipper,
                                                                                       ColumnValue... values)

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

flipper - 翻页对象

values - 更新字段

返回:

影响的记录条数CompletableFuture

updateColumn

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

从接口复制的说明: DataSource

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

columns - 需更新的字段名

返回:

影响的记录条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

columns - 需更新的字段名

返回:

影响的记录条数CompletableFuture

updateColumn

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

从接口复制的说明: DataSource

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

node - 过滤条件

columns - 需更新的字段名

返回:

影响的记录条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

node - 过滤条件

columns - 需更新的字段名

返回:

影响的记录条数CompletableFuture

updateColumn

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

从接口复制的说明: DataSource

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

selects - 指定字段

返回:

影响的记录条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

selects - 指定字段

返回:

影响的记录条数CompletableFuture

updateColumn

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

从接口复制的说明: DataSource

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

node - 过滤条件

selects - 指定字段

返回:

影响的记录条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

node - 过滤条件

selects - 指定字段

返回:

影响的记录条数CompletableFuture

updateCache

public <T> int updateCache(java.lang.Class<T> clazz,
                           T... values)

指定者:

updateCache 在接口中 DataCacheListener

reloadCache

public <T> int reloadCache(java.lang.Class<T> clazz,
                           java.io.Serializable... ids)

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

返回:

聚合结果

getNumberResultAsync

public java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass,
                                                                                     FilterFunc func,
                                                                                     java.lang.String column)

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

返回:

聚合结果CompletableFuture

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

bean - 过滤条件

返回:

聚合结果

getNumberResultAsync

public java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass,
                                                                                     FilterFunc func,
                                                                                     java.lang.String column,
                                                                                     FilterBean bean)

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

bean - 过滤条件

返回:

聚合结果CompletableFuture

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

node - 过滤条件

返回:

聚合结果

getNumberResultAsync

public java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass,
                                                                                     FilterFunc func,
                                                                                     java.lang.String column,
                                                                                     FilterNode node)

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

node - 过滤条件

返回:

聚合结果

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

返回:

聚合结果

getNumberResultAsync

public java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass,
                                                                                     FilterFunc func,
                                                                                     java.lang.Number defVal,
                                                                                     java.lang.String column)

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

返回:

聚合结果CompletableFuture

getNumberResult

public java.lang.Number getNumberResult(java.lang.Class entityClass,
                                        FilterFunc func,
                                        java.lang.Number defVal,
                                        java.lang.String column,
                                        FilterBean bean)

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

bean - 过滤条件

返回:

聚合结果

getNumberResultAsync

public java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass,
                                                                                     FilterFunc func,
                                                                                     java.lang.Number defVal,
                                                                                     java.lang.String column,
                                                                                     FilterBean bean)

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

bean - 过滤条件

返回:

聚合结果CompletableFuture

getNumberResultAsync

public java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass,
                                                                                     FilterFunc func,
                                                                                     java.lang.Number defVal,
                                                                                     java.lang.String column,
                                                                                     FilterNode node)

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

node - 过滤条件

返回:

聚合结果CompletableFuture

getNumberMap

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

从接口复制的说明: DataSource

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

指定者:

getNumberMap 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

columns - 聚合字段

返回:

聚合结果Map

getNumberMapAsync

public <N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<java.lang.String,N>> getNumberMapAsync(java.lang.Class entityClass,
                                                                                                                                FilterFuncColumn... columns)

从接口复制的说明: DataSource

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

指定者:

getNumberMapAsync 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

columns - 聚合字段

返回:

聚合结果Map CompletableFuture

getNumberMap

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

从接口复制的说明: DataSource

获取符合过滤条件记录的聚合结果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}

指定者:

getNumberMap 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

bean - 过滤条件

columns - 聚合字段

返回:

聚合结果Map

getNumberMapAsync

public <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)

从接口复制的说明: DataSource

获取符合过滤条件记录的聚合结果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}

指定者:

getNumberMapAsync 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

bean - 过滤条件

columns - 聚合字段

返回:

聚合结果Map CompletableFuture

getNumberMap

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

从接口复制的说明: DataSource

获取符合过滤条件记录的聚合结果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}

指定者:

getNumberMap 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

node - 过滤条件

columns - 聚合字段

返回:

聚合结果Map

getNumberMapAsync

public <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)

从接口复制的说明: DataSource

获取符合过滤条件记录的聚合结果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}

指定者:

getNumberMapAsync 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

node - 过滤条件

columns - 聚合字段

返回:

聚合结果Map

getNumberResult

public java.lang.Number getNumberResult(java.lang.Class entityClass,
                                        FilterFunc func,
                                        java.lang.Number defVal,
                                        java.lang.String column,
                                        FilterNode node)

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

node - 过滤条件

返回:

聚合结果

queryColumnMap

public <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)

从接口复制的说明: DataSource

查询符合过滤条件记录的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

指定者:

queryColumnMap 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

返回:

聚合结果Map

queryColumnMapAsync

public <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)

从接口复制的说明: DataSource

查询符合过滤条件记录的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

指定者:

queryColumnMapAsync 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

返回:

聚合结果Map CompletableFuture

queryColumnMap

public <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)

从接口复制的说明: DataSource

查询符合过滤条件记录的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

指定者:

queryColumnMap 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

bean - 过滤条件

返回:

聚合结果Map

queryColumnMapAsync

public <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)

从接口复制的说明: DataSource

查询符合过滤条件记录的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

指定者:

queryColumnMapAsync 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

bean - 过滤条件

返回:

聚合结果Map CompletableFuture

queryColumnMap

public <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)

从接口复制的说明: DataSource

查询符合过滤条件记录的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

指定者:

queryColumnMap 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

node - 过滤条件

返回:

聚合结果Map

queryColumnMapAsync

public <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)

从接口复制的说明: DataSource

查询符合过滤条件记录的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

指定者:

queryColumnMapAsync 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

node - 过滤条件

返回:

聚合结果Map CompletableFuture

find

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

根据主键获取对象

指定者:

find 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

pk - 主键值

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

Entity对象 CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

pk - 主键值

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

pk - 主键值

返回:

Entity对象CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity对象CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity对象CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity对象CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - 过滤条件

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - 过滤条件

返回:

Entity对象 CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity对象 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

pk - 主键值

返回:

Entity对象

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

pk - 主键值

返回:

Entity对象 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

bean - 过滤条件

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

bean - 过滤条件

返回:

字段值 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

node - 过滤条件

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

node - 过滤条件

返回:

字段值 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

pk - 主键值

返回:

字段值

findColumnAsync

public <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)

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

pk - 主键值

返回:

字段值 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

bean - 过滤条件

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

bean - 过滤条件

返回:

字段值 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

node - 过滤条件

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

node - 过滤条件

返回:

字段值 CompletableFuture

exists

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

从接口复制的说明: DataSource

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

指定者:

exists 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

是否存在

existsAsync

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

从接口复制的说明: DataSource

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

指定者:

existsAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

是否存在CompletableFuture

exists

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

从接口复制的说明: DataSource

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

指定者:

exists 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

是否存在

existsAsync

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

从接口复制的说明: DataSource

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

指定者:

existsAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

是否存在CompletableFuture

exists

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

从接口复制的说明: DataSource

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

指定者:

exists 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

是否存在

existsAsync

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

从接口复制的说明: DataSource

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

指定者:

existsAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

是否存在CompletableFuture

queryColumnSet

public <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 key)

从接口复制的说明: DataSource

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

指定者:

queryColumnSet 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

字段值的集合

queryColumnSetAsync

public <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 key)

从接口复制的说明: DataSource

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

指定者:

queryColumnSetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

字段值的集合CompletableFuture

queryColumnSet

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSet 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合

queryColumnSetAsync

public <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)

从接口复制的说明: DataSource

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

指定者:

queryColumnSetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnSet

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSet 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合

queryColumnSetAsync

public <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)

从接口复制的说明: DataSource

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

指定者:

queryColumnSetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

public <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 key)

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

字段值的集合

queryColumnListAsync

public <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 key)

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

字段值的集合CompletableFuture

queryColumnList

public <T,V extends java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn,
                                                                            java.lang.Class<T> clazz,
                                                                            FilterBean bean)

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合

queryColumnListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

public <T,V extends java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn,
                                                                            java.lang.Class<T> clazz,
                                                                            FilterNode node)

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合

queryColumnListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

public <T,V extends java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn,
                                                                            java.lang.Class<T> clazz,
                                                                            Flipper flipper,
                                                                            FilterBean bean)

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

字段值的集合

queryColumnListAsync

public <T,V extends 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)

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

public <T,V extends java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn,
                                                                            java.lang.Class<T> clazz,
                                                                            Flipper flipper,
                                                                            FilterNode node)

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合

queryColumnListAsync

public <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)

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnSheet

public <T,V extends java.io.Serializable> Sheet<V> queryColumnSheet(java.lang.String selectedColumn,
                                                                    java.lang.Class<T> clazz,
                                                                    Flipper flipper,
                                                                    FilterBean bean)

根据指定参数查询对象某个字段的集合

指定者:

queryColumnSheet 在接口中 DataSource

类型参数:

T - Entity类的泛型

V - 字段值的类型

参数:

selectedColumn - 字段名

clazz - Entity类

flipper - 翻页对象

bean - 过滤Bean

返回:

字段集合

queryColumnSheetAsync

public <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)

从接口复制的说明: DataSource

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

指定者:

queryColumnSheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnSheet

public <T,V extends java.io.Serializable> Sheet<V> queryColumnSheet(java.lang.String selectedColumn,
                                                                    java.lang.Class<T> clazz,
                                                                    Flipper flipper,
                                                                    FilterNode node)

从接口复制的说明: DataSource

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

指定者:

queryColumnSheet 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合

queryColumnSheetAsync

public <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)

从接口复制的说明: DataSource

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

指定者:

queryColumnSheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryList

public <T> java.util.List<T> queryList(java.lang.Class<T> clazz,
                                       java.lang.String column,
                                       java.io.Serializable key)

根据指定字段值查询对象集合

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity对象的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity的集合CompletableFuture

queryList

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

根据过滤对象FilterBean查询对象集合

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

bean - 过滤Bean

返回:

Entity对象集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

根据过滤对象FilterBean查询对象集合， 对象只填充或排除SelectField指定的字段

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

selects - 收集的字段

bean - 过滤Bean

返回:

Entity对象的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

public <T> java.util.List<T> queryList(java.lang.Class<T> clazz,
                                       Flipper flipper,
                                       java.lang.String column,
                                       java.io.Serializable key)

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

column - 过滤字段名

key - 过滤字段值

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

column - 过滤字段名

key - 过滤字段值

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

queryList

public <T> java.util.List<T> queryList(java.lang.Class<T> clazz,
                                       SelectColumn selects,
                                       Flipper flipper,
                                       FilterBean bean)

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合

queryListAsync

public <T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz,
                                                                                    SelectColumn selects,
                                                                                    Flipper flipper,
                                                                                    FilterBean bean)

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

public <T> java.util.List<T> queryList(java.lang.Class<T> clazz,
                                       SelectColumn selects,
                                       Flipper flipper,
                                       FilterNode node)

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

queryListAsync

public <T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz,
                                                                                    SelectColumn selects,
                                                                                    Flipper flipper,
                                                                                    FilterNode node)

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

public <T> Sheet<T> querySheet(java.lang.Class<T> clazz,
                               Flipper flipper,
                               FilterBean bean)

根据过滤对象FilterBean和翻页对象Flipper查询一页的数据

指定者:

querySheet 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤Bean

返回:

Entity对象的集合

querySheetAsync

public <T> java.util.concurrent.CompletableFuture<Sheet<T>> querySheetAsync(java.lang.Class<T> clazz,
                                                                            Flipper flipper,
                                                                            FilterBean bean)

从接口复制的说明: DataSource

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

指定者:

querySheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

public <T> Sheet<T> querySheet(java.lang.Class<T> clazz,
                               Flipper flipper,
                               FilterNode node)

从接口复制的说明: DataSource

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

指定者:

querySheet 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

querySheetAsync

public <T> java.util.concurrent.CompletableFuture<Sheet<T>> querySheetAsync(java.lang.Class<T> clazz,
                                                                            Flipper flipper,
                                                                            FilterNode node)

从接口复制的说明: DataSource

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

指定者:

querySheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

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

根据过滤对象FilterBean和翻页对象Flipper查询一页的数据， 对象只填充或排除SelectField指定的字段

指定者:

querySheet 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

selects - 收集的字段集合

flipper - 翻页对象

bean - 过滤Bean

返回:

Entity对象的集合

querySheetAsync

public <T> java.util.concurrent.CompletableFuture<Sheet<T>> querySheetAsync(java.lang.Class<T> clazz,
                                                                            SelectColumn selects,
                                                                            Flipper flipper,
                                                                            FilterBean bean)

从接口复制的说明: DataSource

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

指定者:

querySheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

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

从接口复制的说明: DataSource

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

指定者:

querySheet 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

querySheetAsync

public <T> java.util.concurrent.CompletableFuture<Sheet<T>> querySheetAsync(java.lang.Class<T> clazz,
                                                                            SelectColumn selects,
                                                                            Flipper flipper,
                                                                            FilterNode node)

从接口复制的说明: DataSource

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

指定者:

querySheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合CompletableFuture

directExecute

public final int[] directExecute(java.lang.String... sqls)

直接本地执行SQL语句进行增删改操作，远程模式不可用
通常用于复杂的更新操作

参数:

sqls - SQL语句

返回:

结果数组

directQuery

public final void directQuery(java.lang.String sql,
                              java.util.function.Consumer<java.sql.ResultSet> consumer)

直接本地执行SQL语句进行查询，远程模式不可用
通常用于复杂的关联查询

参数:

sql - SQL语句

consumer - 回调函数