org.redkale.source

类 DataSqlSource<DBChannel>

java.lang.Object

org.redkale.service.AbstractService

org.redkale.source.DataSqlSource<DBChannel>

类型参数:

DBChannel - 数据库连接

所有已实现的接口:

java.lang.AutoCloseable, java.util.function.Function<java.lang.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, java.util.function.Function<java.lang.Class,EntityInfo>, java.lang.AutoCloseable, Resourcable

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

详情见: https://redkale.org

字段概要

字段

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

构造器概要

构造器

构造器和说明
DataSqlSource(java.lang.String unitName, java.net.URL persistxml, java.util.Properties readprop, java.util.Properties writeprop)

方法概要

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

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

runAsync

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

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

从接口继承的方法 org.redkale.source.DataSource

delete, delete, deleteAsync, deleteAsync, update, update, updateAsync, updateAsync

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

andThen, compose, identity

字段详细资料

FLIPPER_ONE

protected static final Flipper FLIPPER_ONE

logger

protected final java.util.logging.Logger logger

name

protected java.lang.String name

persistxml

protected java.net.URL persistxml

threads

protected int threads

bufferPool

protected ObjectPool<java.nio.ByteBuffer> bufferPool

executor

protected java.util.concurrent.ThreadPoolExecutor executor

cacheForbidden

protected boolean cacheForbidden

readPool

protected PoolSource<DBChannel> readPool

writePool

protected PoolSource<DBChannel> writePool

cacheListener

protected DataCacheListener cacheListener

futureCompleteConsumer

protected final java.util.function.BiConsumer futureCompleteConsumer

fullloader

protected final java.util.function.BiFunction<DataSource,java.lang.Class,java.util.List> fullloader

构造器详细资料

DataSqlSource

public DataSqlSource(java.lang.String unitName,
                     java.net.URL persistxml,
                     java.util.Properties readprop,
                     java.util.Properties writeprop)

方法详细资料

directExecute

@Local
public abstract int directExecute(java.lang.String sql)

directExecute

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

directQuery

@Local
public abstract <V> V directQuery(java.lang.String sql,
                                          java.util.function.Function<java.sql.ResultSet,V> handler)

isAsync

protected abstract boolean isAsync()

prepareParamSign

protected abstract java.lang.String prepareParamSign(int index)

createPoolSource

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

insertDB

protected abstract <T> java.util.concurrent.CompletableFuture<java.lang.Integer> insertDB(EntityInfo<T> info,
                                                                                          T... entitys)

deleteDB

protected abstract <T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteDB(EntityInfo<T> info,
                                                                                          Flipper flipper,
                                                                                          java.lang.String sql)

clearTableDB

protected abstract <T> java.util.concurrent.CompletableFuture<java.lang.Integer> clearTableDB(EntityInfo<T> info,
                                                                                              java.lang.String sql)

dropTableDB

protected abstract <T> java.util.concurrent.CompletableFuture<java.lang.Integer> dropTableDB(EntityInfo<T> info,
                                                                                             java.lang.String sql)

updateDB

protected abstract <T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateDB(EntityInfo<T> info,
                                                                                          T... entitys)

updateDB

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

getNumberMapDB

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

getNumberResultDB

protected abstract <T> java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultDB(EntityInfo<T> info,
                                                                                                  java.lang.String sql,
                                                                                                  java.lang.Number defVal,
                                                                                                  java.lang.String column)

queryColumnMapDB

protected abstract <T,K extends java.io.Serializable,N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<K,N>> queryColumnMapDB(EntityInfo<T> info,
                                                                                                                                                             java.lang.String sql,
                                                                                                                                                             java.lang.String keyColumn)

findDB

protected abstract <T> java.util.concurrent.CompletableFuture<T> findDB(EntityInfo<T> info,
                                                                        java.lang.String sql,
                                                                        boolean onlypk,
                                                                        SelectColumn selects)

findColumnDB

protected abstract <T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnDB(EntityInfo<T> info,
                                                                                                 java.lang.String sql,
                                                                                                 boolean onlypk,
                                                                                                 java.lang.String column,
                                                                                                 java.io.Serializable defValue)

existsDB

protected abstract <T> java.util.concurrent.CompletableFuture<java.lang.Boolean> existsDB(EntityInfo<T> info,
                                                                                          java.lang.String sql,
                                                                                          boolean onlypk)

querySheetDB

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

getEntityValue

protected <T> T getEntityValue(EntityInfo<T> info,
                               SelectColumn sels,
                               java.sql.ResultSet set)
                        throws java.sql.SQLException

抛出:

java.sql.SQLException

getFieldValue

protected <T> java.io.Serializable getFieldValue(EntityInfo<T> info,
                                                 Attribute<T,java.io.Serializable> attr,
                                                 java.sql.ResultSet set,
                                                 int index)
                                          throws java.sql.SQLException

抛出:

java.sql.SQLException

getFieldValue

protected <T> java.io.Serializable getFieldValue(EntityInfo<T> info,
                                                 Attribute<T,java.io.Serializable> attr,
                                                 java.sql.ResultSet set)
                                          throws java.sql.SQLException

抛出:

java.sql.SQLException

createSQLOrderby

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

getJoinTabalis

protected java.util.Map<java.lang.Class,java.lang.String> getJoinTabalis(FilterNode node)

createSQLJoin

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

createSQLExpress

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

getExecutor

protected java.util.concurrent.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 java.lang.String getType()

从接口复制的说明: DataSource

获取数据源类型

指定者:

getType 在接口中 DataSource

返回:

String

resourceName

public final java.lang.String resourceName()

指定者:

resourceName 在接口中 Resourcable

close

@Local
public void close()
                   throws java.lang.Exception

指定者:

close 在接口中 java.lang.AutoCloseable

抛出:

java.lang.Exception

getReadPoolSource

@Local
public PoolSource<DBChannel> getReadPoolSource()

getWritePoolSource

@Local
public PoolSource<DBChannel> getWritePoolSource()

apply

@Local
public EntityInfo apply(java.lang.Class t)

指定者:

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

loadEntityInfo

protected <T> EntityInfo<T> loadEntityInfo(java.lang.Class<T> clazz)

isOnlyCache

protected boolean isOnlyCache(EntityInfo info)

refreshCache

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

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

类型参数:

T - Entity类泛型

参数:

clazz - Entity类

checkEntity

protected <T> java.util.concurrent.CompletableFuture checkEntity(java.lang.String action,
                                                                 boolean async,
                                                                 T... entitys)

insert

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

新增对象， 必须是Entity对象

指定者:

insert 在接口中 DataSource

类型参数:

T - Entity类泛型

参数:

entitys - Entity对象

返回:

影响的记录条数

insertAsync

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

从接口复制的说明: DataSource

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

指定者:

insertAsync 在接口中 DataSource

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

CompletableFuture

insertCache

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

insertCache

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

指定者:

insertCache 在接口中 DataCacheListener

delete

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

删除对象， 必须是Entity对象

指定者:

delete 在接口中 DataSource

类型参数:

T - Entity类泛型

参数:

entitys - Entity对象

返回:

删除的数据条数

deleteAsync

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

从接口复制的说明: DataSource

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

指定者:

deleteAsync 在接口中 DataSource

类型参数:

T - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数CompletableFuture

delete

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

从接口复制的说明: DataSource

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

指定者:

delete 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pks - 主键值

返回:

影响的记录条数

deleteAsync

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

从接口复制的说明: DataSource

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

指定者:

deleteAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pks - 主键值

返回:

影响的记录条数CompletableFuture

delete

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

从接口复制的说明: DataSource

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

指定者:

delete 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数

deleteAsync

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

从接口复制的说明: DataSource

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

指定者:

deleteAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数CompletableFuture

delete

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

从接口复制的说明: DataSource

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

指定者:

delete 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

影响的记录条数

deleteAsync

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

从接口复制的说明: DataSource

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

指定者:

deleteAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

影响的记录条数CompletableFuture

deleteCompose

protected <T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteCompose(EntityInfo<T> info,
                                                                                      java.io.Serializable... pks)

deleteCompose

protected <T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteCompose(EntityInfo<T> info,
                                                                                      Flipper flipper,
                                                                                      FilterNode node)

clearTable

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

从接口复制的说明: DataSource

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

指定者:

clearTable 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

影响的记录条数

clearTable

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

从接口复制的说明: DataSource

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

指定者:

clearTable 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数

clearTableAsync

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

从接口复制的说明: DataSource

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

指定者:

clearTableAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

影响的记录条数CompletableFuture

clearTableAsync

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

从接口复制的说明: DataSource

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

指定者:

clearTableAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数CompletableFuture

clearTableCompose

protected <T> java.util.concurrent.CompletableFuture<java.lang.Integer> clearTableCompose(EntityInfo<T> info,
                                                                                          FilterNode node)

dropTable

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

从接口复制的说明: DataSource

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

指定者:

dropTable 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

影响的记录条数

dropTable

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

从接口复制的说明: DataSource

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

指定者:

dropTable 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数

dropTableAsync

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

从接口复制的说明: DataSource

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

指定者:

dropTableAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

影响的记录条数CompletableFuture

dropTableAsync

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

从接口复制的说明: DataSource

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

指定者:

dropTableAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

影响的记录条数CompletableFuture

dropTableCompose

protected <T> java.util.concurrent.CompletableFuture<java.lang.Integer> dropTableCompose(EntityInfo<T> info,
                                                                                         FilterNode node)

clearTableCache

protected <T> int clearTableCache(EntityInfo<T> info,
                                  FilterNode node)

dropTableCache

protected <T> int dropTableCache(EntityInfo<T> info,
                                 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,
                              java.io.Serializable... pks)

deleteCache

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

指定者:

deleteCache 在接口中 DataCacheListener

multisplit

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

update

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

更新对象， 必须是Entity对象

指定者:

update 在接口中 DataSource

类型参数:

T - Entity类泛型

参数:

entitys - Entity对象

返回:

更新的数据条数

updateAsync

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

从接口复制的说明: 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 - 泛型

参数:

entitys - Entity对象

返回:

影响的记录条数CompletableFuture

updateColumn

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

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

pk - 主键值

column - 过滤字段名

colval - 过滤字段值

返回:

更新的数据条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键

column - 待更新的字段名

colval - 更新值

返回:

影响的记录条数CompletableFuture

updateColumnCompose

protected <T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnCompose(EntityInfo<T> info,
                                                                                            java.io.Serializable pk,
                                                                                            java.lang.String column,
                                                                                            java.io.Serializable colval)

updateColumn

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

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

node - 过滤node 不能为null

返回:

更新的数据条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 待更新的字段名

colval - 更新值

node - 过滤条件

返回:

影响的记录条数CompletableFuture

updateColumnCompose

protected <T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnCompose(EntityInfo<T> info,
                                                                                            java.lang.String column,
                                                                                            java.io.Serializable colval,
                                                                                            FilterNode node)

updateColumn

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

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

pk - 主键值

values - 字段值

返回:

更新的数据条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键

values - 更新字段

返回:

影响的记录条数CompletableFuture

updateColumnCompose

protected <T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnCompose(EntityInfo<T> info,
                                                                                            java.io.Serializable pk,
                                                                                            ColumnValue... values)

updateColumn

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

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

node - 过滤条件

values - 字段值

返回:

更新的数据条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

values - 更新字段

返回:

影响的记录条数CompletableFuture

updateColumn

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

从接口复制的说明: 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> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(java.lang.Class<T> clazz,
                                                                                       FilterNode node,
                                                                                       Flipper flipper,
                                                                                       ColumnValue... values)

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

flipper - 翻页对象

values - 更新字段

返回:

影响的记录条数CompletableFuture

updateColumnCompose

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

updateColumn

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

从接口复制的说明: DataSource

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

entity - 待更新的Entity对象

columns - 需更新的字段名

返回:

影响的记录条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

entity - 待更新的Entity对象

columns - 需更新的字段名

返回:

影响的记录条数CompletableFuture

updateColumn

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

从接口复制的说明: DataSource

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

entity - 待更新的Entity对象

node - 过滤条件

columns - 需更新的字段名

返回:

影响的记录条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

entity - 待更新的Entity对象

node - 过滤条件

columns - 需更新的字段名

返回:

影响的记录条数CompletableFuture

updateColumn

public <T> int updateColumn(T entity,
                            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泛型

参数:

entity - 待更新的Entity对象

selects - 指定字段

返回:

影响的记录条数

updateColumnAsync

public <T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(T entity,
                                                                                       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泛型

参数:

entity - 待更新的Entity对象

selects - 指定字段

返回:

影响的记录条数CompletableFuture

updateColumn

public <T> int updateColumn(T entity,
                            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泛型

参数:

entity - 待更新的Entity对象

node - 过滤条件

selects - 指定字段

返回:

影响的记录条数

updateColumnAsync

public <T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(T entity,
                                                                                       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泛型

参数:

entity - 待更新的Entity对象

node - 过滤条件

selects - 指定字段

返回:

影响的记录条数CompletableFuture

updateColumnCompose

protected <T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnCompose(EntityInfo<T> info,
                                                                                            boolean neednode,
                                                                                            T entity,
                                                                                            FilterNode node,
                                                                                            SelectColumn selects)

updateCache

protected <T> int updateCache(EntityInfo<T> info,
                              int count,
                              boolean neednode,
                              T entity,
                              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,
                              java.io.Serializable pk,
                              ColumnValue... values)

updateCache

protected <T> int updateCache(EntityInfo<T> info,
                              int count,
                              java.lang.String column,
                              java.io.Serializable colval,
                              FilterNode node)

updateCache

protected <T> int updateCache(EntityInfo<T> info,
                              int count,
                              java.io.Serializable pk,
                              java.lang.String column,
                              java.io.Serializable colval)

updateCache

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

updateCache

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

指定者:

updateCache 在接口中 DataCacheListener

reloadCache

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

getNumberMap

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

从接口复制的说明: DataSource

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

指定者:

getNumberMap 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

columns - 聚合字段

返回:

聚合结果Map

getNumberMapAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberMapAsync 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

columns - 聚合字段

返回:

聚合结果Map CompletableFuture

getNumberMap

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

从接口复制的说明: DataSource

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

指定者:

getNumberMap 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

bean - 过滤条件

columns - 聚合字段

返回:

聚合结果Map

getNumberMapAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberMapAsync 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

bean - 过滤条件

columns - 聚合字段

返回:

聚合结果Map CompletableFuture

getNumberMap

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

从接口复制的说明: DataSource

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

指定者:

getNumberMap 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

node - 过滤条件

columns - 聚合字段

返回:

聚合结果Map

getNumberMapAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberMapAsync 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

node - 过滤条件

columns - 聚合字段

返回:

聚合结果Map

getNumberMapCompose

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

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

返回:

聚合结果

getNumberResultAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

返回:

聚合结果CompletableFuture

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

bean - 过滤条件

返回:

聚合结果

getNumberResultAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

bean - 过滤条件

返回:

聚合结果CompletableFuture

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

node - 过滤条件

返回:

聚合结果

getNumberResultAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

node - 过滤条件

返回:

聚合结果

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

返回:

聚合结果

getNumberResultAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

返回:

聚合结果CompletableFuture

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

bean - 过滤条件

返回:

聚合结果

getNumberResultAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

bean - 过滤条件

返回:

聚合结果CompletableFuture

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

node - 过滤条件

返回:

聚合结果

getNumberResultAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

node - 过滤条件

返回:

聚合结果CompletableFuture

getNumberResultCompose

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

queryColumnMap

public <T,K extends java.io.Serializable,N extends java.lang.Number> java.util.Map<K,N> queryColumnMap(java.lang.Class<T> entityClass,
                                                                                                       java.lang.String keyColumn,
                                                                                                       FilterFunc func,
                                                                                                       java.lang.String funcColumn)

从接口复制的说明: DataSource

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

指定者:

queryColumnMap 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

返回:

聚合结果Map

queryColumnMapAsync

public <T,K extends java.io.Serializable,N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<K,N>> queryColumnMapAsync(java.lang.Class<T> entityClass,
                                                                                                                                                    java.lang.String keyColumn,
                                                                                                                                                    FilterFunc func,
                                                                                                                                                    java.lang.String funcColumn)

从接口复制的说明: DataSource

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

指定者:

queryColumnMapAsync 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

返回:

聚合结果Map CompletableFuture

queryColumnMap

public <T,K extends java.io.Serializable,N extends java.lang.Number> java.util.Map<K,N> queryColumnMap(java.lang.Class<T> entityClass,
                                                                                                       java.lang.String keyColumn,
                                                                                                       FilterFunc func,
                                                                                                       java.lang.String funcColumn,
                                                                                                       FilterBean bean)

从接口复制的说明: DataSource

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

指定者:

queryColumnMap 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

bean - 过滤条件

返回:

聚合结果Map

queryColumnMapAsync

public <T,K extends java.io.Serializable,N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<K,N>> queryColumnMapAsync(java.lang.Class<T> entityClass,
                                                                                                                                                    java.lang.String keyColumn,
                                                                                                                                                    FilterFunc func,
                                                                                                                                                    java.lang.String funcColumn,
                                                                                                                                                    FilterBean bean)

从接口复制的说明: DataSource

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

指定者:

queryColumnMapAsync 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

bean - 过滤条件

返回:

聚合结果Map CompletableFuture

queryColumnMap

public <T,K extends java.io.Serializable,N extends java.lang.Number> java.util.Map<K,N> queryColumnMap(java.lang.Class<T> entityClass,
                                                                                                       java.lang.String keyColumn,
                                                                                                       FilterFunc func,
                                                                                                       java.lang.String funcColumn,
                                                                                                       FilterNode node)

从接口复制的说明: DataSource

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

指定者:

queryColumnMap 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

node - 过滤条件

返回:

聚合结果Map

queryColumnMapAsync

public <T,K extends java.io.Serializable,N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<K,N>> queryColumnMapAsync(java.lang.Class<T> entityClass,
                                                                                                                                                    java.lang.String keyColumn,
                                                                                                                                                    FilterFunc func,
                                                                                                                                                    java.lang.String funcColumn,
                                                                                                                                                    FilterNode node)

从接口复制的说明: DataSource

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

指定者:

queryColumnMapAsync 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

node - 过滤条件

返回:

聚合结果Map CompletableFuture

queryColumnMapCompose

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

find

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

根据主键获取对象

指定者:

find 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

pk - 主键值

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

Entity对象 CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

pk - 主键值

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

pk - 主键值

返回:

Entity对象CompletableFuture

findCompose

protected <T> java.util.concurrent.CompletableFuture<T> findCompose(EntityInfo<T> info,
                                                                    SelectColumn selects,
                                                                    java.io.Serializable pk)

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

Entity对象CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity对象CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity对象CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - 过滤条件

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - 过滤条件

返回:

Entity对象 CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity对象 CompletableFuture

findCompose

protected <T> java.util.concurrent.CompletableFuture<T> findCompose(EntityInfo<T> info,
                                                                    SelectColumn selects,
                                                                    FilterNode node)

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

pk - 主键值

返回:

Entity对象

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

pk - 主键值

返回:

Entity对象 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

bean - 过滤条件

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

bean - 过滤条件

返回:

字段值 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

node - 过滤条件

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

node - 过滤条件

返回:

字段值 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

bean - 过滤条件

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

bean - 过滤条件

返回:

字段值 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

pk - 主键值

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

pk - 主键值

返回:

字段值 CompletableFuture

findColumnCompose

protected <T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnCompose(EntityInfo<T> info,
                                                                                             java.lang.String column,
                                                                                             java.io.Serializable defValue,
                                                                                             java.io.Serializable pk)

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

node - 过滤条件

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

node - 过滤条件

返回:

字段值 CompletableFuture

findColumnCompose

protected <T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnCompose(EntityInfo<T> info,
                                                                                             java.lang.String column,
                                                                                             java.io.Serializable defValue,
                                                                                             FilterNode node)

exists

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

从接口复制的说明: DataSource

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

指定者:

exists 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

是否存在

existsAsync

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

从接口复制的说明: DataSource

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

指定者:

existsAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

是否存在CompletableFuture

existsCompose

protected <T> java.util.concurrent.CompletableFuture<java.lang.Boolean> existsCompose(EntityInfo<T> info,
                                                                                      java.io.Serializable pk)

exists

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

从接口复制的说明: DataSource

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

指定者:

exists 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

是否存在

existsAsync

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

从接口复制的说明: DataSource

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

指定者:

existsAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

是否存在CompletableFuture

exists

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

从接口复制的说明: DataSource

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

指定者:

exists 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

是否存在

existsAsync

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

从接口复制的说明: DataSource

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

指定者:

existsAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

是否存在CompletableFuture

existsCompose

protected <T> java.util.concurrent.CompletableFuture<java.lang.Boolean> existsCompose(EntityInfo<T> info,
                                                                                      FilterNode node)

queryColumnSet

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSet 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

字段值的集合

queryColumnSetAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

字段值的集合CompletableFuture

queryColumnSet

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSet 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合

queryColumnSetAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnSet

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSet 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合

queryColumnSetAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

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

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

字段值的集合

queryColumnListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

字段值的集合CompletableFuture

queryColumnList

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

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合

queryColumnListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

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

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合

queryColumnListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

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

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

字段值的集合

queryColumnListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

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

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合

queryColumnListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnSheet

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

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

指定者:

queryColumnSheet 在接口中 DataSource

类型参数:

T - Entity类的泛型

V - 字段值的类型

参数:

selectedColumn - 字段名

clazz - Entity类

flipper - 翻页对象

bean - 过滤Bean

返回:

字段集合

queryColumnSheetAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnSheet

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSheet 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合

queryColumnSheetAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryMap

public <K extends java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz,
                                                                      java.util.stream.Stream<K> keyStream)

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

指定者:

queryMap 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

keyStream - 主键Stream

返回:

Entity的集合

queryMapAsync

public <K extends java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.Class<T> clazz,
                                                                                                                   java.util.stream.Stream<K> keyStream)

从接口复制的说明: 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 java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz,
                                                                      FilterBean bean)

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

指定者:

queryMap 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

bean - FilterBean

返回:

Entity的集合

queryMapAsync

public <K extends java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.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 java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz,
                                                                      FilterNode node)

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

指定者:

queryMap 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

node - FilterNode

返回:

Entity的集合

queryMapAsync

public <K extends java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.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 java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz,
                                                                      SelectColumn selects,
                                                                      java.util.stream.Stream<K> keyStream)

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

指定者:

queryMap 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

keyStream - 主键Stream

返回:

Entity的集合

queryMapAsync

public <K extends java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.Class<T> clazz,
                                                                                                                   SelectColumn selects,
                                                                                                                   java.util.stream.Stream<K> keyStream)

从接口复制的说明: 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 java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz,
                                                                      SelectColumn selects,
                                                                      FilterBean bean)

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

指定者:

queryMap 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - FilterBean

返回:

Entity的集合

queryMapAsync

public <K extends java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.Class<T> clazz,
                                                                                                                   SelectColumn selects,
                                                                                                                   FilterBean bean)

从接口复制的说明: 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 java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz,
                                                                      SelectColumn selects,
                                                                      FilterNode node)

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

指定者:

queryMap 在接口中 DataSource

类型参数:

K - 主键泛型

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - FilterNode

返回:

Entity的集合

queryMapAsync

public <K extends java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.Class<T> clazz,
                                                                                                                   SelectColumn selects,
                                                                                                                   FilterNode node)

从接口复制的说明: 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> java.util.List<T> queryList(java.lang.Class<T> clazz,
                                       java.lang.String column,
                                       java.io.Serializable colval)

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

Entity对象的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

colval - 过滤字段值

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

返回:

Entity的集合CompletableFuture

queryList

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

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

bean - 过滤Bean

返回:

Entity对象集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

selects - 收集的字段

bean - 过滤Bean

返回:

Entity对象的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

column - 过滤字段名

colval - 过滤字段值

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

column - 过滤字段名

colval - 过滤字段值

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

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

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

指定者:

querySheet 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤Bean

返回:

Entity对象的集合

querySheetAsync

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

从接口复制的说明: DataSource

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

指定者:

querySheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

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

从接口复制的说明: DataSource

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

指定者:

querySheet 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

querySheetAsync

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

从接口复制的说明: DataSource

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

指定者:

querySheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

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

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

指定者:

querySheet 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

selects - 收集的字段集合

flipper - 翻页对象

bean - 过滤Bean

返回:

Entity对象的集合

querySheetAsync

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

从接口复制的说明: DataSource

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

指定者:

querySheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

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

从接口复制的说明: DataSource

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

指定者:

querySheet 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

querySheetAsync

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

从接口复制的说明: DataSource

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

指定者:

querySheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合CompletableFuture

querySheetCompose

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