org.redkale.source

类 DataSqlSource<DBChannel>

java.lang.Object

org.redkale.service.AbstractService

org.redkale.source.DataSqlSource<DBChannel>

类型参数:

DBChannel - 数据库连接

所有已实现的接口:

AutoCloseable, Function<Class,EntityInfo>, Service, DataCacheListener, DataSource, Resourcable

直接已知子类:

DataJdbcSource, DataMemorySource

@Local
 @AutoLoad(value=false)
 @ResourceType(value=DataSource.class)
public abstract class DataSqlSource<DBChannel>
extends AbstractService
implements DataSource, DataCacheListener, Function<Class,EntityInfo>, AutoCloseable, Resourcable

DataSource的SQL抽象实现类
注意: 所有的操作只能作用在一张表上，不能同时变更多张表

详情见: https://redkale.org

作者:

zhangjx

字段概要

字段

限定符和类型	字段和说明
protected ObjectPool<ByteBuffer>	bufferPool
protected boolean	cacheForbidden
protected DataCacheListener	cacheListener
protected ThreadPoolExecutor	executor
protected static Flipper	FLIPPER_ONE
protected BiFunction<DataSource,Class,List>	fullloader
protected BiConsumer	futureCompleteConsumer
protected Logger	logger
protected String	name
protected URL	persistxml
protected PoolSource<DBChannel>	readPool
protected int	threads
protected PoolSource<DBChannel>	writePool

构造器概要

构造器

构造器和说明
DataSqlSource(String unitName, URL persistxml, Properties readprop, Properties writeprop)

方法概要

限定符和类型	方法和说明
EntityInfo	apply(Class t)
protected <T> CompletableFuture	checkEntity(String action, boolean async, T... values)
void	close()
protected abstract PoolSource<DBChannel>	createPoolSource(DataSource source, String rwtype, ArrayBlockingQueue queue, Semaphore semaphore, Properties prop)
protected <T> CharSequence	createSQLExpress(FilterNode node, EntityInfo<T> info, Map<Class,String> joinTabalis)
protected <T> CharSequence	createSQLJoin(FilterNode node, Function<Class,EntityInfo> func, boolean update, Map<Class,String> joinTabalis, Set<String> haset, EntityInfo<T> info)
protected <T> String	createSQLOrderby(EntityInfo<T> info, Flipper flipper)
<T> int	delete(Class<T> clazz, FilterNode node) 删除符合过滤条件的记录 等价SQL: DELETE FROM {table} WHERE {filter node}
<T> int	delete(Class<T> clazz, Flipper flipper, FilterNode node) 删除符合过滤条件且指定最大影响条数的记录 Flipper中offset字段将被忽略 等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> int	delete(Class<T> clazz, Serializable... ids) 删除指定主键值的记录,多主键值必须在同一张表中 等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
<T> int	delete(T... values) 删除对象， 必须是Entity对象
<T> CompletableFuture<Integer>	deleteAsync(Class<T> clazz, FilterNode node) 删除符合过滤条件的记录 等价SQL: DELETE FROM {table} WHERE {filter node}
<T> CompletableFuture<Integer>	deleteAsync(Class<T> clazz, Flipper flipper, FilterNode node) 删除符合过滤条件且指定最大影响条数的记录 Flipper中offset字段将被忽略 等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<Integer>	deleteAsync(Class<T> clazz, Serializable... ids) 删除指定主键值的记录,多主键值必须在同一张表中 等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
<T> CompletableFuture<Integer>	deleteAsync(T... values) 删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中 等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}
<T> int	deleteCache(Class<T> clazz, Serializable... ids)
protected <T> int	deleteCache(EntityInfo<T> info, int count, Flipper flipper, FilterNode node)
protected <T> int	deleteCache(EntityInfo<T> info, int count, Serializable... keys)
protected <T> CompletableFuture<Integer>	deleteCompose(EntityInfo<T> info, Flipper flipper, FilterNode node)
protected <T> CompletableFuture<Integer>	deleteCompose(EntityInfo<T> info, Serializable... ids)
protected abstract <T> CompletableFuture<Integer>	deleteDB(EntityInfo<T> info, Flipper flipper, String sql)
void	destroy(AnyValue config) 进程退出时，调用Service销毁 远程模式下该方法会重载成空方法
abstract int[]	directExecute(String... sqls)
abstract int	directExecute(String sql)
abstract <V> V	directQuery(String sql, Function<ResultSet,V> handler)
<T> boolean	exists(Class<T> clazz, FilterBean bean) 判断是否存在符合过滤条件的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
<T> boolean	exists(Class<T> clazz, FilterNode node) 判断是否存在符合过滤条件的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
<T> boolean	exists(Class<T> clazz, Serializable pk) 判断是否存在主键值的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
<T> CompletableFuture<Boolean>	existsAsync(Class<T> clazz, FilterBean bean) 判断是否存在符合过滤条件的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
<T> CompletableFuture<Boolean>	existsAsync(Class<T> clazz, FilterNode node) 判断是否存在符合过滤条件的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
<T> CompletableFuture<Boolean>	existsAsync(Class<T> clazz, Serializable pk) 判断是否存在主键值的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
protected <T> CompletableFuture<Boolean>	existsCompose(EntityInfo<T> info, FilterNode node)
protected <T> CompletableFuture<Boolean>	existsCompose(EntityInfo<T> info, Serializable pk)
protected abstract <T> CompletableFuture<Boolean>	existsDB(EntityInfo<T> info, String sql, boolean onlypk)
<T> T	find(Class<T> clazz, FilterBean bean) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {filter bean}
<T> T	find(Class<T> clazz, FilterNode node) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {filter node}
<T> T	find(Class<T> clazz, SelectColumn selects, FilterBean bean) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
<T> T	find(Class<T> clazz, SelectColumn selects, FilterNode node) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
<T> T	find(Class<T> clazz, SelectColumn selects, Serializable pk) 获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
<T> T	find(Class<T> clazz, Serializable pk) 根据主键获取对象
<T> T	find(Class<T> clazz, String column, Serializable key) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {column} = {key}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, FilterBean bean) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {filter bean}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, FilterNode node) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {filter node}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, SelectColumn selects, FilterBean bean) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, SelectColumn selects, FilterNode node) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, SelectColumn selects, Serializable pk) 获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, Serializable pk) 获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {primary} = {id}
<T> CompletableFuture<T>	findAsync(Class<T> clazz, String column, Serializable key) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {column} = {key}
<T> Serializable	findColumn(Class<T> clazz, String column, FilterBean bean) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
<T> Serializable	findColumn(Class<T> clazz, String column, FilterNode node) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
<T> Serializable	findColumn(Class<T> clazz, String column, Serializable pk) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
<T> Serializable	findColumn(Class<T> clazz, String column, Serializable defValue, FilterBean bean) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
<T> Serializable	findColumn(Class<T> clazz, String column, Serializable defValue, FilterNode node) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
<T> Serializable	findColumn(Class<T> clazz, String column, Serializable defValue, Serializable pk) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
<T> CompletableFuture<Serializable>	findColumnAsync(Class<T> clazz, String column, FilterBean bean) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
<T> CompletableFuture<Serializable>	findColumnAsync(Class<T> clazz, String column, FilterNode node) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
<T> CompletableFuture<Serializable>	findColumnAsync(Class<T> clazz, String column, Serializable pk) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
<T> CompletableFuture<Serializable>	findColumnAsync(Class<T> clazz, String column, Serializable defValue, FilterBean bean) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
<T> CompletableFuture<Serializable>	findColumnAsync(Class<T> clazz, String column, Serializable defValue, FilterNode node) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
<T> CompletableFuture<Serializable>	findColumnAsync(Class<T> clazz, String column, Serializable defValue, Serializable pk) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
protected <T> CompletableFuture<Serializable>	findColumnCompose(EntityInfo<T> info, String column, Serializable defValue, FilterNode node)
protected <T> CompletableFuture<Serializable>	findColumnCompose(EntityInfo<T> info, String column, Serializable defValue, Serializable pk)
protected abstract <T> CompletableFuture<Serializable>	findColumnDB(EntityInfo<T> info, String sql, boolean onlypk, String column, Serializable defValue)
protected <T> CompletableFuture<T>	findCompose(EntityInfo<T> info, SelectColumn selects, FilterNode node)
protected <T> CompletableFuture<T>	findCompose(EntityInfo<T> info, SelectColumn selects, Serializable pk)
protected abstract <T> CompletableFuture<T>	findDB(EntityInfo<T> info, String sql, boolean onlypk, SelectColumn selects)
protected ExecutorService	getExecutor()
protected Map<Class,String>	getJoinTabalis(FilterNode node)
<N extends Number> Map<String,N>	getNumberMap(Class entityClass, FilterBean bean, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean} 如 getNumberMapAsync(Record.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends Number> Map<String,N>	getNumberMap(Class entityClass, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} 如 getNumberMapAsync(Record.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends Number> Map<String,N>	getNumberMap(Class entityClass, FilterNode node, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node} 如 getNumberMapAsync(Record.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends Number> CompletableFuture<Map<String,N>>	getNumberMapAsync(Class entityClass, FilterBean bean, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean} 如 getNumberMapAsync(Record.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends Number> CompletableFuture<Map<String,N>>	getNumberMapAsync(Class entityClass, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} 如 getNumberMapAsync(Record.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends Number> CompletableFuture<Map<String,N>>	getNumberMapAsync(Class entityClass, FilterNode node, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node} 如 getNumberMapAsync(Record.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
protected <N extends Number> CompletableFuture<Map<String,N>>	getNumberMapCompose(EntityInfo info, FilterNode node, FilterFuncColumn... columns)
protected abstract <T,N extends Number> CompletableFuture<Map<String,N>>	getNumberMapDB(EntityInfo<T> info, String sql, FilterFuncColumn... columns)
Number	getNumberResult(Class entityClass, FilterFunc func, Number defVal, String column) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table}
Number	getNumberResult(Class entityClass, FilterFunc func, Number defVal, String column, FilterBean bean) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
Number	getNumberResult(Class entityClass, FilterFunc func, Number defVal, String column, FilterNode node) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
Number	getNumberResult(Class entityClass, FilterFunc func, String column) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table}
Number	getNumberResult(Class entityClass, FilterFunc func, String column, FilterBean bean) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
Number	getNumberResult(Class entityClass, FilterFunc func, String column, FilterNode node) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
CompletableFuture<Number>	getNumberResultAsync(Class entityClass, FilterFunc func, Number defVal, String column) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table}
CompletableFuture<Number>	getNumberResultAsync(Class entityClass, FilterFunc func, Number defVal, String column, FilterBean bean) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
CompletableFuture<Number>	getNumberResultAsync(Class entityClass, FilterFunc func, Number defVal, String column, FilterNode node) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
CompletableFuture<Number>	getNumberResultAsync(Class entityClass, FilterFunc func, String column) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table}
CompletableFuture<Number>	getNumberResultAsync(Class entityClass, FilterFunc func, String column, FilterBean bean) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
CompletableFuture<Number>	getNumberResultAsync(Class entityClass, FilterFunc func, String column, FilterNode node) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
protected CompletableFuture<Number>	getNumberResultCompose(EntityInfo info, Class entityClass, FilterFunc func, Number defVal, String column, FilterNode node)
protected abstract <T> CompletableFuture<Number>	getNumberResultDB(EntityInfo<T> info, String sql, Number defVal, String column)
PoolSource<DBChannel>	getReadPoolSource()
String	getType() 获取数据源类型
PoolSource<DBChannel>	getWritePoolSource()
protected <T> T	infoGetValue(EntityInfo<T> info, SelectColumn sels, ResultSet set)
void	init(AnyValue config) 该方法必须是可以重复调用， 当reload时需要重复调用init方法 远程模式下该方法会重载成空方法
<T> int	insert(T... values) 新增对象， 必须是Entity对象
<T> CompletableFuture<Integer>	insertAsync(T... values) 新增记录， 多对象必须是同一个Entity类且必须在同一张表中
<T> int	insertCache(Class<T> clazz, T... values)
protected <T> int	insertCache(EntityInfo<T> info, T... values)
protected abstract <T> CompletableFuture<Integer>	insertDB(EntityInfo<T> info, T... values)
protected abstract boolean	isAsync()
protected boolean	isOnlyCache(EntityInfo info)
protected <T> EntityInfo<T>	loadEntityInfo(Class<T> clazz)
protected static StringBuilder	multisplit(char ch1, char ch2, String split, StringBuilder sb, String str, int from)
protected abstract String	prepareParamSign(int index)
<T,V extends Serializable> List<V>	queryColumnList(String selectedColumn, Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
<T,V extends Serializable> List<V>	queryColumnList(String selectedColumn, Class<T> clazz, FilterNode node) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
<T,V extends Serializable> List<V>	queryColumnList(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends Serializable> List<V>	queryColumnList(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends Serializable> List<V>	queryColumnList(String selectedColumn, Class<T> clazz, String column, Serializable key) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
<T,V extends Serializable> CompletableFuture<List<V>>	queryColumnListAsync(String selectedColumn, Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
<T,V extends Serializable> CompletableFuture<List<V>>	queryColumnListAsync(String selectedColumn, Class<T> clazz, FilterNode node) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
<T,V extends Serializable> CompletableFuture<List<V>>	queryColumnListAsync(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends Serializable> CompletableFuture<List<V>>	queryColumnListAsync(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends Serializable> CompletableFuture<List<V>>	queryColumnListAsync(String selectedColumn, Class<T> clazz, String column, Serializable key) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
<T,K extends Serializable,N extends Number> Map<K,N>	queryColumnMap(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime") 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends Serializable,N extends Number> Map<K,N>	queryColumnMap(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn, FilterBean bean) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends Serializable,N extends Number> Map<K,N>	queryColumnMap(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn, FilterNode node) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N>>	queryColumnMapAsync(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime") 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N>>	queryColumnMapAsync(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn, FilterBean bean) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N>>	queryColumnMapAsync(Class<T> entityClass, String keyColumn, FilterFunc func, String funcColumn, FilterNode node) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
protected <T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N>>	queryColumnMapCompose(EntityInfo<T> info, String keyColumn, FilterFunc func, String funcColumn, FilterNode node)
protected abstract <T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N>>	queryColumnMapDB(EntityInfo<T> info, String sql, String keyColumn)
<T,V extends Serializable> HashSet<V>	queryColumnSet(String selectedColumn, Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
<T,V extends Serializable> HashSet<V>	queryColumnSet(String selectedColumn, Class<T> clazz, FilterNode node) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
<T,V extends Serializable> HashSet<V>	queryColumnSet(String selectedColumn, Class<T> clazz, String column, Serializable key) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
<T,V extends Serializable> CompletableFuture<HashSet<V>>	queryColumnSetAsync(String selectedColumn, Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
<T,V extends Serializable> CompletableFuture<HashSet<V>>	queryColumnSetAsync(String selectedColumn, Class<T> clazz, FilterNode node) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
<T,V extends Serializable> CompletableFuture<HashSet<V>>	queryColumnSetAsync(String selectedColumn, Class<T> clazz, String column, Serializable key) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
<T,V extends Serializable> Sheet<V>	queryColumnSheet(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean) 根据指定参数查询对象某个字段的集合
<T,V extends Serializable> Sheet<V>	queryColumnSheet(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的某个字段Sheet集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends Serializable> CompletableFuture<Sheet<V>>	queryColumnSheetAsync(String selectedColumn, Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的某个字段Sheet集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends Serializable> CompletableFuture<Sheet<V>>	queryColumnSheetAsync(String selectedColumn, Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的某个字段Sheet集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> List<T>	queryList(Class<T> clazz) 查询记录的List集合 等价SQL: SELECT * FROM {table}
<T> List<T>	queryList(Class<T> clazz, FilterBean bean) 根据过滤对象FilterBean查询对象集合
<T> List<T>	queryList(Class<T> clazz, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter node}
<T> List<T>	queryList(Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> List<T>	queryList(Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> List<T>	queryList(Class<T> clazz, Flipper flipper, String column, Serializable key) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> List<T>	queryList(Class<T> clazz, SelectColumn selects, FilterBean bean) 根据过滤对象FilterBean查询对象集合， 对象只填充或排除SelectField指定的字段
<T> List<T>	queryList(Class<T> clazz, SelectColumn selects, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
<T> List<T>	queryList(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> List<T>	queryList(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> List<T>	queryList(Class<T> clazz, String column, Serializable key) 根据指定字段值查询对象集合
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz) 查询记录的List集合 等价SQL: SELECT * FROM {table}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter bean}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter node}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, Flipper flipper, String column, Serializable key) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, SelectColumn selects, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, SelectColumn selects, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<List<T>>	queryListAsync(Class<T> clazz, String column, Serializable key) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	queryMap(Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	queryMap(Class<T> clazz, FilterNode node) 查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	queryMap(Class<T> clazz, SelectColumn selects, FilterBean bean) 查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	queryMap(Class<T> clazz, SelectColumn selects, FilterNode node) 查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	queryMap(Class<T> clazz, SelectColumn selects, Stream<K> keyStream) 查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	queryMap(Class<T> clazz, Stream<K> keyStream) 查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	queryMapAsync(Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	queryMapAsync(Class<T> clazz, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	queryMapAsync(Class<T> clazz, SelectColumn selects, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	queryMapAsync(Class<T> clazz, SelectColumn selects, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	queryMapAsync(Class<T> clazz, SelectColumn selects, Stream<K> keyStream) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	queryMapAsync(Class<T> clazz, Stream<K> keyStream) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> Sheet<T>	querySheet(Class<T> clazz, Flipper flipper, FilterBean bean) 根据过滤对象FilterBean和翻页对象Flipper查询一页的数据
<T> Sheet<T>	querySheet(Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> Sheet<T>	querySheet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean) 根据过滤对象FilterBean和翻页对象Flipper查询一页的数据， 对象只填充或排除SelectField指定的字段
<T> Sheet<T>	querySheet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<Sheet<T>>	querySheetAsync(Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<Sheet<T>>	querySheetAsync(Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<Sheet<T>>	querySheetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<Sheet<T>>	querySheetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
protected <T> CompletableFuture<Sheet<T>>	querySheetCompose(boolean readcache, boolean needtotal, Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
protected abstract <T> CompletableFuture<Sheet<T>>	querySheetDB(EntityInfo<T> info, boolean needtotal, SelectColumn selects, Flipper flipper, FilterNode node)
<T> void	refreshCache(Class<T> clazz) 将entity的对象全部加载到Cache中去，如果clazz没有被@javax.persistence.Cacheable注解则不做任何事
<T> int	reloadCache(Class<T> clazz, Serializable... ids)
String	resourceName()
<T> int	update(T... values) 更新对象， 必须是Entity对象
<T> CompletableFuture<Integer>	updateAsync(T... values) 更新记录， 多对象必须是同一个Entity类且必须在同一张表中 等价SQL: UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1} UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2} ···
<T> int	updateCache(Class<T> clazz, T... values)
protected <T> int	updateCache(EntityInfo<T> info, int count, boolean neednode, T bean, FilterNode node, SelectColumn selects)
protected <T> int	updateCache(EntityInfo<T> info, int count, FilterNode node, Flipper flipper, ColumnValue... values)
protected <T> int	updateCache(EntityInfo<T> info, int count, Serializable id, ColumnValue... values)
protected <T> int	updateCache(EntityInfo<T> info, int count, Serializable id, String column, Serializable value)
protected <T> int	updateCache(EntityInfo<T> info, int count, String column, Serializable value, FilterNode node)
protected <T> int	updateCache(EntityInfo<T> info, int count, T... values)
<T> int	updateColumn(Class<T> clazz, FilterNode node, ColumnValue... values) 根据主键值更新对象的多个column对应的值， 必须是Entity Class
<T> int	updateColumn(Class<T> clazz, FilterNode node, Flipper flipper, ColumnValue... values) 更新符合过滤条件的记录的指定字段 Flipper中offset字段将被忽略 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}
<T> int	updateColumn(Class<T> clazz, Serializable id, ColumnValue... values) 根据主键值更新对象的多个column对应的值， 必须是Entity Class
<T> int	updateColumn(Class<T> clazz, Serializable id, String column, Serializable value) 根据主键值更新对象的column对应的值， 必须是Entity Class
<T> int	updateColumn(Class<T> clazz, String column, 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, String... columns) 更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
<T> int	updateColumn(T bean, SelectColumn selects) 更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
<T> int	updateColumn(T bean, String... columns) 更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
<T> CompletableFuture<Integer>	updateColumnAsync(Class<T> clazz, FilterNode node, ColumnValue... values) 更新符合过滤条件记录的部分字段 字段赋值操作选项见 ColumnExpress 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
<T> CompletableFuture<Integer>	updateColumnAsync(Class<T> clazz, FilterNode node, Flipper flipper, ColumnValue... values) 更新符合过滤条件的记录的指定字段 Flipper中offset字段将被忽略 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}
<T> CompletableFuture<Integer>	updateColumnAsync(Class<T> clazz, Serializable id, ColumnValue... values) 更新指定主键值记录的部分字段 字段赋值操作选项见 ColumnExpress 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
<T> CompletableFuture<Integer>	updateColumnAsync(Class<T> clazz, Serializable id, String column, Serializable value) 更新单个记录的单个字段 注意：即使字段标记为@Column(updatable=false)也会被更新 等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
<T> CompletableFuture<Integer>	updateColumnAsync(Class<T> clazz, String column, Serializable value, FilterNode node) 更新符合过滤条件记录的单个字段 注意：即使字段标记为@Column(updatable=false)也会被更新 等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
<T> CompletableFuture<Integer>	updateColumnAsync(T bean, FilterNode node, SelectColumn selects) 更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
<T> CompletableFuture<Integer>	updateColumnAsync(T bean, FilterNode node, String... columns) 更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
<T> CompletableFuture<Integer>	updateColumnAsync(T bean, SelectColumn selects) 更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
<T> CompletableFuture<Integer>	updateColumnAsync(T bean, String... columns) 更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
protected <T> CompletableFuture<Integer>	updateColumnCompose(EntityInfo<T> info, boolean neednode, T bean, FilterNode node, SelectColumn selects)
protected <T> CompletableFuture<Integer>	updateColumnCompose(EntityInfo<T> info, FilterNode node, Flipper flipper, ColumnValue... values)
protected <T> CompletableFuture<Integer>	updateColumnCompose(EntityInfo<T> info, Serializable id, ColumnValue... values)
protected <T> CompletableFuture<Integer>	updateColumnCompose(EntityInfo<T> info, Serializable id, String column, Serializable value)
protected <T> CompletableFuture<Integer>	updateColumnCompose(EntityInfo<T> info, String column, Serializable value, FilterNode node)
protected abstract <T> CompletableFuture<Integer>	updateDB(EntityInfo<T> info, Flipper flipper, String sql, boolean prepared, Object... params)
protected abstract <T> CompletableFuture<Integer>	updateDB(EntityInfo<T> info, T... values)

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

runAsync

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

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

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

andThen, compose, identity

字段详细资料

FLIPPER_ONE

protected static final Flipper FLIPPER_ONE

logger

protected final Logger logger

name

protected String name

persistxml

protected URL persistxml

threads

protected int threads

bufferPool

protected ObjectPool<ByteBuffer> bufferPool

executor

protected ThreadPoolExecutor executor

cacheForbidden

protected boolean cacheForbidden

readPool

protected PoolSource<DBChannel> readPool

writePool

protected PoolSource<DBChannel> writePool

cacheListener

protected DataCacheListener cacheListener

futureCompleteConsumer

protected final BiConsumer futureCompleteConsumer

fullloader

protected final BiFunction<DataSource,Class,List> fullloader

构造器详细资料

DataSqlSource

public DataSqlSource(String unitName,
                     URL persistxml,
                     Properties readprop,
                     Properties writeprop)

方法详细资料

directExecute

@Local
public abstract int directExecute(String sql)

directExecute

@Local
public abstract int[] directExecute(String... sqls)

directQuery

@Local
public abstract <V> V directQuery(String sql,
                                         Function<ResultSet,V> handler)

isAsync

protected abstract boolean isAsync()

prepareParamSign

protected abstract String prepareParamSign(int index)

createPoolSource

protected abstract PoolSource<DBChannel> createPoolSource(DataSource source,
                                                          String rwtype,
                                                          ArrayBlockingQueue queue,
                                                          Semaphore semaphore,
                                                          Properties prop)

insertDB

protected abstract <T> CompletableFuture<Integer> insertDB(EntityInfo<T> info,
                                                           T... values)

deleteDB

protected abstract <T> CompletableFuture<Integer> deleteDB(EntityInfo<T> info,
                                                           Flipper flipper,
                                                           String sql)

updateDB

protected abstract <T> CompletableFuture<Integer> updateDB(EntityInfo<T> info,
                                                           T... values)

updateDB

protected abstract <T> CompletableFuture<Integer> updateDB(EntityInfo<T> info,
                                                           Flipper flipper,
                                                           String sql,
                                                           boolean prepared,
                                                           Object... params)

getNumberMapDB

protected abstract <T,N extends Number> CompletableFuture<Map<String,N>> getNumberMapDB(EntityInfo<T> info,
                                                                                        String sql,
                                                                                        FilterFuncColumn... columns)

getNumberResultDB

protected abstract <T> CompletableFuture<Number> getNumberResultDB(EntityInfo<T> info,
                                                                   String sql,
                                                                   Number defVal,
                                                                   String column)

queryColumnMapDB

protected abstract <T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N>> queryColumnMapDB(EntityInfo<T> info,
                                                                                                            String sql,
                                                                                                            String keyColumn)

findDB

protected abstract <T> CompletableFuture<T> findDB(EntityInfo<T> info,
                                                   String sql,
                                                   boolean onlypk,
                                                   SelectColumn selects)

findColumnDB

protected abstract <T> CompletableFuture<Serializable> findColumnDB(EntityInfo<T> info,
                                                                    String sql,
                                                                    boolean onlypk,
                                                                    String column,
                                                                    Serializable defValue)

existsDB

protected abstract <T> CompletableFuture<Boolean> existsDB(EntityInfo<T> info,
                                                           String sql,
                                                           boolean onlypk)

querySheetDB

protected abstract <T> CompletableFuture<Sheet<T>> querySheetDB(EntityInfo<T> info,
                                                                boolean needtotal,
                                                                SelectColumn selects,
                                                                Flipper flipper,
                                                                FilterNode node)

infoGetValue

protected <T> T infoGetValue(EntityInfo<T> info,
                             SelectColumn sels,
                             ResultSet set)
                      throws SQLException

抛出:

SQLException

createSQLOrderby

protected <T> String createSQLOrderby(EntityInfo<T> info,
                                      Flipper flipper)

getJoinTabalis

protected Map<Class,String> getJoinTabalis(FilterNode node)

createSQLJoin

protected <T> CharSequence createSQLJoin(FilterNode node,
                                         Function<Class,EntityInfo> func,
                                         boolean update,
                                         Map<Class,String> joinTabalis,
                                         Set<String> haset,
                                         EntityInfo<T> info)

createSQLExpress

protected <T> CharSequence createSQLExpress(FilterNode node,
                                            EntityInfo<T> info,
                                            Map<Class,String> joinTabalis)

getExecutor

protected ExecutorService getExecutor()

覆盖:

getExecutor 在类中 AbstractService

init

public void init(AnyValue config)

从接口复制的说明: Service

该方法必须是可以重复调用， 当reload时需要重复调用init方法 远程模式下该方法会重载成空方法

指定者:

init 在接口中 Service

参数:

config - 配置参数

destroy

public void destroy(AnyValue config)

从接口复制的说明: Service

进程退出时，调用Service销毁 远程模式下该方法会重载成空方法

指定者:

destroy 在接口中 Service

参数:

config - 配置参数

getType

@Local
public String getType()

从接口复制的说明: DataSource

获取数据源类型

指定者:

getType 在接口中 DataSource

返回:

String

resourceName

public final String resourceName()

指定者:

resourceName 在接口中 Resourcable

close

@Local
public void close()
                  throws Exception

指定者:

close 在接口中 AutoCloseable

抛出:

Exception

getReadPoolSource

@Local
public PoolSource<DBChannel> getReadPoolSource()

getWritePoolSource

@Local
public PoolSource<DBChannel> getWritePoolSource()

apply

@Local
public EntityInfo apply(Class t)

指定者:

apply 在接口中 Function<Class,EntityInfo>

loadEntityInfo

protected <T> EntityInfo<T> loadEntityInfo(Class<T> clazz)

isOnlyCache

protected boolean isOnlyCache(EntityInfo info)

refreshCache

public <T> void refreshCache(Class<T> clazz)

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

类型参数:

T - Entity类泛型

参数:

clazz - Entity类

checkEntity

protected <T> CompletableFuture checkEntity(String action,
                                            boolean async,
                                            T... values)

insert

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

新增对象， 必须是Entity对象

指定者:

insert 在接口中 DataSource

类型参数:

T - Entity类泛型

参数:

values - Entity对象

返回:

影响的记录条数

insertAsync

public <T> CompletableFuture<Integer> insertAsync(@RpcCall(value=DataCallArrayAttribute.class)
                                                  T... values)

从接口复制的说明: DataSource

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

指定者:

insertAsync 在接口中 DataSource

类型参数:

T - 泛型

参数:

values - Entity对象

返回:

CompletableFuture

insertCache

protected <T> int insertCache(EntityInfo<T> info,
                              T... values)

insertCache

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

指定者:

insertCache 在接口中 DataCacheListener

delete

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

删除对象， 必须是Entity对象

指定者:

delete 在接口中 DataSource

类型参数:

T - Entity类泛型

参数:

values - Entity对象

返回:

删除的数据条数

deleteAsync

public <T> CompletableFuture<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(Class<T> clazz,
                      Serializable... ids)

从接口复制的说明: DataSource

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

指定者:

delete 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

ids - 主键值

返回:

影响的记录条数

deleteAsync

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

从接口复制的说明: DataSource

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

指定者:

deleteAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

ids - 主键值

返回:

影响的记录条数CompletableFuture

delete

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

从接口复制的说明: DataSource

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

指定者:

delete 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数

deleteAsync

public <T> CompletableFuture<Integer> deleteAsync(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(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> CompletableFuture<Integer> deleteAsync(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

deleteCompose

protected <T> CompletableFuture<Integer> deleteCompose(EntityInfo<T> info,
                                                       Serializable... ids)

deleteCompose

protected <T> CompletableFuture<Integer> deleteCompose(EntityInfo<T> info,
                                                       Flipper flipper,
                                                       FilterNode node)

deleteCache

protected <T> int deleteCache(EntityInfo<T> info,
                              int count,
                              Flipper flipper,
                              FilterNode node)

deleteCache

protected <T> int deleteCache(EntityInfo<T> info,
                              int count,
                              Serializable... keys)

deleteCache

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

指定者:

deleteCache 在接口中 DataCacheListener

multisplit

protected static StringBuilder multisplit(char ch1,
                                          char ch2,
                                          String split,
                                          StringBuilder sb,
                                          String str,
                                          int from)

update

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

更新对象， 必须是Entity对象

指定者:

update 在接口中 DataSource

类型参数:

T - Entity类泛型

参数:

values - Entity对象

返回:

更新的数据条数

updateAsync

public <T> CompletableFuture<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(Class<T> clazz,
                            Serializable id,
                            String column,
                            Serializable value)

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

id - 主键值

column - 过滤字段名

value - 过滤字段值

返回:

更新的数据条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

id - 主键

column - 待更新的字段名

value - 更新值

返回:

影响的记录条数CompletableFuture

updateColumnCompose

protected <T> CompletableFuture<Integer> updateColumnCompose(EntityInfo<T> info,
                                                             Serializable id,
                                                             String column,
                                                             Serializable value)

updateColumn

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

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

column - 过滤字段名

value - 过滤字段值

node - 过滤node 不能为null

返回:

更新的数据条数

updateColumnAsync

public <T> CompletableFuture<Integer> updateColumnAsync(Class<T> clazz,
                                                        String column,
                                                        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

updateColumnCompose

protected <T> CompletableFuture<Integer> updateColumnCompose(EntityInfo<T> info,
                                                             String column,
                                                             Serializable value,
                                                             FilterNode node)

updateColumn

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

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

id - 主键值

values - 字段值

返回:

更新的数据条数

updateColumnAsync

public <T> CompletableFuture<Integer> updateColumnAsync(Class<T> clazz,
                                                        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

updateColumnCompose

protected <T> CompletableFuture<Integer> updateColumnCompose(EntityInfo<T> info,
                                                             Serializable id,
                                                             ColumnValue... values)

updateColumn

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

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

node - 过滤条件

values - 字段值

返回:

更新的数据条数

updateColumnAsync

public <T> CompletableFuture<Integer> updateColumnAsync(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(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}

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

flipper - 翻页对象

values - 更新字段

返回:

影响的记录条数

updateColumnAsync

public <T> CompletableFuture<Integer> updateColumnAsync(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}

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

flipper - 翻页对象

values - 更新字段

返回:

影响的记录条数CompletableFuture

updateColumnCompose

protected <T> CompletableFuture<Integer> updateColumnCompose(EntityInfo<T> info,
                                                             FilterNode node,
                                                             Flipper flipper,
                                                             ColumnValue... values)

updateColumn

public <T> int updateColumn(T bean,
                            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> CompletableFuture<Integer> updateColumnAsync(T bean,
                                                        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,
                            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> CompletableFuture<Integer> updateColumnAsync(T bean,
                                                        FilterNode node,
                                                        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> CompletableFuture<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> CompletableFuture<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

updateColumnCompose

protected <T> CompletableFuture<Integer> updateColumnCompose(EntityInfo<T> info,
                                                             boolean neednode,
                                                             T bean,
                                                             FilterNode node,
                                                             SelectColumn selects)

updateCache

protected <T> int updateCache(EntityInfo<T> info,
                              int count,
                              boolean neednode,
                              T bean,
                              FilterNode node,
                              SelectColumn selects)

updateCache

protected <T> int updateCache(EntityInfo<T> info,
                              int count,
                              FilterNode node,
                              Flipper flipper,
                              ColumnValue... values)

updateCache

protected <T> int updateCache(EntityInfo<T> info,
                              int count,
                              Serializable id,
                              ColumnValue... values)

updateCache

protected <T> int updateCache(EntityInfo<T> info,
                              int count,
                              String column,
                              Serializable value,
                              FilterNode node)

updateCache

protected <T> int updateCache(EntityInfo<T> info,
                              int count,
                              Serializable id,
                              String column,
                              Serializable value)

updateCache

protected <T> int updateCache(EntityInfo<T> info,
                              int count,
                              T... values)

updateCache

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

指定者:

updateCache 在接口中 DataCacheListener

reloadCache

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

getNumberMap

public <N extends Number> Map<String,N> getNumberMap(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 Number> CompletableFuture<Map<String,N>> getNumberMapAsync(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 Number> Map<String,N> getNumberMap(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 Number> CompletableFuture<Map<String,N>> getNumberMapAsync(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 Number> Map<String,N> getNumberMap(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 Number> CompletableFuture<Map<String,N>> getNumberMapAsync(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

getNumberMapCompose

protected <N extends Number> CompletableFuture<Map<String,N>> getNumberMapCompose(EntityInfo info,
                                                                                  FilterNode node,
                                                                                  FilterFuncColumn... columns)

getNumberResult

public Number getNumberResult(Class entityClass,
                              FilterFunc func,
                              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 CompletableFuture<Number> getNumberResultAsync(Class entityClass,
                                                      FilterFunc func,
                                                      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 Number getNumberResult(Class entityClass,
                              FilterFunc func,
                              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 CompletableFuture<Number> getNumberResultAsync(Class entityClass,
                                                      FilterFunc func,
                                                      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 Number getNumberResult(Class entityClass,
                              FilterFunc func,
                              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 CompletableFuture<Number> getNumberResultAsync(Class entityClass,
                                                      FilterFunc func,
                                                      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 Number getNumberResult(Class entityClass,
                              FilterFunc func,
                              Number defVal,
                              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 CompletableFuture<Number> getNumberResultAsync(Class entityClass,
                                                      FilterFunc func,
                                                      Number defVal,
                                                      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 Number getNumberResult(Class entityClass,
                              FilterFunc func,
                              Number defVal,
                              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 CompletableFuture<Number> getNumberResultAsync(Class entityClass,
                                                      FilterFunc func,
                                                      Number defVal,
                                                      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

getNumberResult

public Number getNumberResult(Class entityClass,
                              FilterFunc func,
                              Number defVal,
                              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 - 过滤条件

返回:

聚合结果

getNumberResultAsync

public CompletableFuture<Number> getNumberResultAsync(Class entityClass,
                                                      FilterFunc func,
                                                      Number defVal,
                                                      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

getNumberResultCompose

protected CompletableFuture<Number> getNumberResultCompose(EntityInfo info,
                                                           Class entityClass,
                                                           FilterFunc func,
                                                           Number defVal,
                                                           String column,
                                                           FilterNode node)

queryColumnMap

public <T,K extends Serializable,N extends Number> Map<K,N> queryColumnMap(Class<T> entityClass,
                                                                           String keyColumn,
                                                                           FilterFunc func,
                                                                           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 Serializable,N extends Number> CompletableFuture<Map<K,N>> queryColumnMapAsync(Class<T> entityClass,
                                                                                                   String keyColumn,
                                                                                                   FilterFunc func,
                                                                                                   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 Serializable,N extends Number> Map<K,N> queryColumnMap(Class<T> entityClass,
                                                                           String keyColumn,
                                                                           FilterFunc func,
                                                                           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 Serializable,N extends Number> CompletableFuture<Map<K,N>> queryColumnMapAsync(Class<T> entityClass,
                                                                                                   String keyColumn,
                                                                                                   FilterFunc func,
                                                                                                   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 Serializable,N extends Number> Map<K,N> queryColumnMap(Class<T> entityClass,
                                                                           String keyColumn,
                                                                           FilterFunc func,
                                                                           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 Serializable,N extends Number> CompletableFuture<Map<K,N>> queryColumnMapAsync(Class<T> entityClass,
                                                                                                   String keyColumn,
                                                                                                   FilterFunc func,
                                                                                                   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

queryColumnMapCompose

protected <T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N>> queryColumnMapCompose(EntityInfo<T> info,
                                                                                                        String keyColumn,
                                                                                                        FilterFunc func,
                                                                                                        String funcColumn,
                                                                                                        FilterNode node)

find

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

根据主键获取对象

指定者:

find 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

pk - 主键值

返回:

Entity对象

findAsync

public <T> CompletableFuture<T> findAsync(Class<T> clazz,
                                          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(Class<T> clazz,
                  SelectColumn selects,
                  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> CompletableFuture<T> findAsync(Class<T> clazz,
                                          SelectColumn selects,
                                          Serializable pk)

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

pk - 主键值

返回:

Entity对象CompletableFuture

findCompose

protected <T> CompletableFuture<T> findCompose(EntityInfo<T> info,
                                               SelectColumn selects,
                                               Serializable pk)

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity对象

findAsync

public <T> CompletableFuture<T> findAsync(Class<T> clazz,
                                          String column,
                                          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(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> CompletableFuture<T> findAsync(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(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> CompletableFuture<T> findAsync(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(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> CompletableFuture<T> findAsync(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(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> CompletableFuture<T> findAsync(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

findCompose

protected <T> CompletableFuture<T> findCompose(EntityInfo<T> info,
                                               SelectColumn selects,
                                               FilterNode node)

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

pk - 主键值

返回:

Entity对象

findColumnAsync

public <T> CompletableFuture<Serializable> findColumnAsync(Class<T> clazz,
                                                           String column,
                                                           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> Serializable findColumn(Class<T> clazz,
                                   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> CompletableFuture<Serializable> findColumnAsync(Class<T> clazz,
                                                           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> Serializable findColumn(Class<T> clazz,
                                   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> CompletableFuture<Serializable> findColumnAsync(Class<T> clazz,
                                                           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> Serializable findColumn(Class<T> clazz,
                                   String column,
                                   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> CompletableFuture<Serializable> findColumnAsync(Class<T> clazz,
                                                           String column,
                                                           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> Serializable findColumn(Class<T> clazz,
                                   String column,
                                   Serializable defValue,
                                   Serializable pk)

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

pk - 主键值

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

pk - 主键值

返回:

字段值 CompletableFuture

findColumnCompose

protected <T> CompletableFuture<Serializable> findColumnCompose(EntityInfo<T> info,
                                                                String column,
                                                                Serializable defValue,
                                                                Serializable pk)

findColumn

public <T> Serializable findColumn(Class<T> clazz,
                                   String column,
                                   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> CompletableFuture<Serializable> findColumnAsync(Class<T> clazz,
                                                           String column,
                                                           Serializable defValue,
                                                           FilterNode node)

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

node - 过滤条件

返回:

字段值 CompletableFuture

findColumnCompose

protected <T> CompletableFuture<Serializable> findColumnCompose(EntityInfo<T> info,
                                                                String column,
                                                                Serializable defValue,
                                                                FilterNode node)

exists

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

从接口复制的说明: DataSource

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

指定者:

exists 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

是否存在

existsAsync

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

从接口复制的说明: DataSource

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

指定者:

existsAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

是否存在CompletableFuture

existsCompose

protected <T> CompletableFuture<Boolean> existsCompose(EntityInfo<T> info,
                                                       Serializable pk)

exists

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

从接口复制的说明: DataSource

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

指定者:

exists 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

是否存在

existsAsync

public <T> CompletableFuture<Boolean> existsAsync(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(Class<T> clazz,
                          FilterNode node)

从接口复制的说明: DataSource

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

指定者:

exists 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

是否存在

existsAsync

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

从接口复制的说明: DataSource

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

指定者:

existsAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

是否存在CompletableFuture

existsCompose

protected <T> CompletableFuture<Boolean> existsCompose(EntityInfo<T> info,
                                                       FilterNode node)

queryColumnSet

public <T,V extends Serializable> HashSet<V> queryColumnSet(String selectedColumn,
                                                            Class<T> clazz,
                                                            String column,
                                                            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 Serializable> CompletableFuture<HashSet<V>> queryColumnSetAsync(String selectedColumn,
                                                                                    Class<T> clazz,
                                                                                    String column,
                                                                                    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 Serializable> HashSet<V> queryColumnSet(String selectedColumn,
                                                            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 Serializable> CompletableFuture<HashSet<V>> queryColumnSetAsync(String selectedColumn,
                                                                                    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 Serializable> HashSet<V> queryColumnSet(String selectedColumn,
                                                            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 Serializable> CompletableFuture<HashSet<V>> queryColumnSetAsync(String selectedColumn,
                                                                                    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 Serializable> List<V> queryColumnList(String selectedColumn,
                                                          Class<T> clazz,
                                                          String column,
                                                          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 Serializable> CompletableFuture<List<V>> queryColumnListAsync(String selectedColumn,
                                                                                  Class<T> clazz,
                                                                                  String column,
                                                                                  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 Serializable> List<V> queryColumnList(String selectedColumn,
                                                          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 Serializable> CompletableFuture<List<V>> queryColumnListAsync(String selectedColumn,
                                                                                  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 Serializable> List<V> queryColumnList(String selectedColumn,
                                                          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 Serializable> CompletableFuture<List<V>> queryColumnListAsync(String selectedColumn,
                                                                                  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 Serializable> List<V> queryColumnList(String selectedColumn,
                                                          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 Serializable> CompletableFuture<List<V>> queryColumnListAsync(String selectedColumn,
                                                                                  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 Serializable> List<V> queryColumnList(String selectedColumn,
                                                          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 Serializable> CompletableFuture<List<V>> queryColumnListAsync(String selectedColumn,
                                                                                  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 Serializable> Sheet<V> queryColumnSheet(String selectedColumn,
                                                            Class<T> clazz,
                                                            Flipper flipper,
                                                            FilterBean bean)

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

指定者:

queryColumnSheet 在接口中 DataSource

类型参数:

T - Entity类的泛型

V - 字段值的类型

参数:

selectedColumn - 字段名

clazz - Entity类

flipper - 翻页对象

bean - 过滤Bean

返回:

字段集合

queryColumnSheetAsync

public <T,V extends Serializable> CompletableFuture<Sheet<V>> queryColumnSheetAsync(String selectedColumn,
                                                                                    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 Serializable> Sheet<V> queryColumnSheet(String selectedColumn,
                                                            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 Serializable> CompletableFuture<Sheet<V>> queryColumnSheetAsync(String selectedColumn,
                                                                                    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

queryMap

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

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

指定者:

queryMap 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

keyStream - 主键Stream

返回:

Entity的集合

queryMapAsync

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

从接口复制的说明: DataSource

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

指定者:

queryMapAsync 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

keyStream - 主键Stream

返回:

Entity的集合CompletableFuture

queryMap

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

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

指定者:

queryMap 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

bean - FilterBean

返回:

Entity的集合

queryMapAsync

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

从接口复制的说明: DataSource

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

指定者:

queryMapAsync 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

bean - FilterBean

返回:

Entity的集合CompletableFuture

queryMap

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

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

指定者:

queryMap 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

node - FilterNode

返回:

Entity的集合

queryMapAsync

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

从接口复制的说明: DataSource

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

指定者:

queryMapAsync 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

node - FilterNode

返回:

Entity的集合CompletableFuture

queryMap

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

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

指定者:

queryMap 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

keyStream - 主键Stream

返回:

Entity的集合

queryMapAsync

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

从接口复制的说明: DataSource

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

指定者:

queryMapAsync 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

keyStream - 主键Stream

返回:

Entity的集合CompletableFuture

queryMap

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

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

指定者:

queryMap 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - FilterBean

返回:

Entity的集合

queryMapAsync

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

从接口复制的说明: DataSource

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

指定者:

queryMapAsync 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - FilterBean

返回:

Entity的集合CompletableFuture

queryMap

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

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

指定者:

queryMap 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - FilterNode

返回:

Entity的集合

queryMapAsync

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

从接口复制的说明: DataSource

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

指定者:

queryMapAsync 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - FilterNode

返回:

Entity的集合CompletableFuture

queryList

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

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity对象的集合

queryListAsync

public <T> CompletableFuture<List<T>> queryListAsync(Class<T> clazz,
                                                     String column,
                                                     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> List<T> queryList(Class<T> clazz)

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

Entity的集合CompletableFuture

queryList

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

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

bean - 过滤Bean

返回:

Entity对象集合

queryListAsync

public <T> CompletableFuture<List<T>> queryListAsync(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> List<T> queryList(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> CompletableFuture<List<T>> queryListAsync(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> List<T> queryList(Class<T> clazz,
                             SelectColumn selects,
                             FilterBean bean)

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

selects - 收集的字段

bean - 过滤Bean

返回:

Entity对象的集合

queryListAsync

public <T> CompletableFuture<List<T>> queryListAsync(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> List<T> queryList(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> CompletableFuture<List<T>> queryListAsync(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> List<T> queryList(Class<T> clazz,
                             Flipper flipper,
                             String column,
                             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> CompletableFuture<List<T>> queryListAsync(Class<T> clazz,
                                                     Flipper flipper,
                                                     String column,
                                                     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> List<T> queryList(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> CompletableFuture<List<T>> queryListAsync(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> List<T> queryList(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> CompletableFuture<List<T>> queryListAsync(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> List<T> queryList(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> CompletableFuture<List<T>> queryListAsync(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> List<T> queryList(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> CompletableFuture<List<T>> queryListAsync(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(Class<T> clazz,
                               Flipper flipper,
                               FilterBean bean)

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

指定者:

querySheet 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤Bean

返回:

Entity对象的集合

querySheetAsync

public <T> CompletableFuture<Sheet<T>> querySheetAsync(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(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> CompletableFuture<Sheet<T>> querySheetAsync(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(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> CompletableFuture<Sheet<T>> querySheetAsync(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(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> CompletableFuture<Sheet<T>> querySheetAsync(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

querySheetCompose

protected <T> CompletableFuture<Sheet<T>> querySheetCompose(boolean readcache,
                                                            boolean needtotal,
                                                            Class<T> clazz,
                                                            SelectColumn selects,
                                                            Flipper flipper,
                                                            FilterNode node)