org.redkale.source

类 DataJdbcSource

java.lang.Object

org.redkale.service.AbstractService

org.redkale.source.DataJdbcSource

所有已实现的接口:

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

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

DataSource的JDBC实现类

详情见: https://redkale.org

字段概要

字段

限定符和类型	字段和说明
protected boolean	cacheForbidden
protected DataCacheListener	cacheListener
protected java.net.URL	conf
protected java.util.concurrent.ExecutorService	executor
protected static Flipper	FLIPPER_ONE
protected java.util.function.BiFunction<DataSource,java.lang.Class,java.util.List>	fullloader
protected java.util.logging.Logger	logger
protected java.lang.String	name
protected PoolJdbcSource	readPool
protected int	threads
protected PoolJdbcSource	writePool

构造器概要

构造器

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

方法概要

限定符和类型	方法和说明
EntityInfo	apply(java.lang.Class t)
void	close()
void	closeSQLConnection(java.sql.Connection sqlconn)
protected <T> java.sql.PreparedStatement	createInsertPreparedStatement(java.sql.Connection conn, java.lang.String sql, EntityInfo<T> info, T... values)
java.sql.Connection	createReadSQLConnection()
<T> java.sql.Connection	createWriteSQLConnection()
<T> int	delete(java.lang.Class<T> clazz, FilterNode node) 删除符合过滤条件的记录 等价SQL: DELETE FROM {table} WHERE {filter node}
<T> int	delete(java.lang.Class<T> clazz, Flipper flipper, FilterNode node) 删除符合过滤条件且指定最大影响条数的记录 Flipper中offset字段将被忽略 等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> int	delete(java.lang.Class<T> clazz, java.io.Serializable... ids) 删除指定主键值的记录 等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
protected <T> int	delete(java.sql.Connection conn, EntityInfo<T> info, Flipper flipper, FilterNode node)
protected <T> int	delete(java.sql.Connection conn, EntityInfo<T> info, java.io.Serializable... keys)
protected <T> int	delete(java.sql.Connection conn, EntityInfo<T> info, T... values)
<T> int	delete(T... values) 删除对象， 必须是Entity对象
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	deleteAsync(java.lang.Class<T> clazz, FilterNode node) 删除符合过滤条件的记录 等价SQL: DELETE FROM {table} WHERE {filter node}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	deleteAsync(java.lang.Class<T> clazz, Flipper flipper, FilterNode node) 删除符合过滤条件且指定最大影响条数的记录 Flipper中offset字段将被忽略 等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	deleteAsync(java.lang.Class<T> clazz, java.io.Serializable... ids) 删除指定主键值的记录 等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	deleteAsync(T... values) 删除指定主键值的记录， 多对象必须是同一个Entity类 等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}
<T> int	deleteCache(java.lang.Class<T> clazz, java.io.Serializable... ids)
void	destroy(AnyValue config) 进程退出时，调用Service销毁 远程模式下该方法会重载成空方法
protected int[]	directExecute(java.sql.Connection conn, java.lang.String... sqls)
int[]	directExecute(java.lang.String... sqls) 直接本地执行SQL语句进行增删改操作，远程模式不可用 通常用于复杂的更新操作
void	directQuery(java.lang.String sql, java.util.function.Consumer<java.sql.ResultSet> consumer) 直接本地执行SQL语句进行查询，远程模式不可用 通常用于复杂的关联查询
<T> boolean	exists(java.lang.Class<T> clazz, FilterBean bean) 判断是否存在符合过滤条件的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
<T> boolean	exists(java.lang.Class<T> clazz, FilterNode node) 判断是否存在符合过滤条件的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
<T> boolean	exists(java.lang.Class<T> clazz, java.io.Serializable pk) 判断是否存在主键值的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
<T> java.util.concurrent.CompletableFuture<java.lang.Boolean>	existsAsync(java.lang.Class<T> clazz, FilterBean bean) 判断是否存在符合过滤条件的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
<T> java.util.concurrent.CompletableFuture<java.lang.Boolean>	existsAsync(java.lang.Class<T> clazz, FilterNode node) 判断是否存在符合过滤条件的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
<T> java.util.concurrent.CompletableFuture<java.lang.Boolean>	existsAsync(java.lang.Class<T> clazz, java.io.Serializable pk) 判断是否存在主键值的记录 等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
<T> T	find(java.lang.Class<T> clazz, FilterBean bean) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {filter bean}
<T> T	find(java.lang.Class<T> clazz, FilterNode node) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {filter node}
<T> T	find(java.lang.Class<T> clazz, SelectColumn selects, FilterBean bean) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
<T> T	find(java.lang.Class<T> clazz, SelectColumn selects, FilterNode node) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
<T> T	find(java.lang.Class<T> clazz, SelectColumn selects, java.io.Serializable pk) 获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
<T> T	find(java.lang.Class<T> clazz, java.io.Serializable pk) 根据主键获取对象
<T> T	find(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable key) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {column} = {key}
<T> java.util.concurrent.CompletableFuture<T>	findAsync(java.lang.Class<T> clazz, FilterBean bean) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {filter bean}
<T> java.util.concurrent.CompletableFuture<T>	findAsync(java.lang.Class<T> clazz, FilterNode node) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {filter node}
<T> java.util.concurrent.CompletableFuture<T>	findAsync(java.lang.Class<T> clazz, SelectColumn selects, FilterBean bean) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
<T> java.util.concurrent.CompletableFuture<T>	findAsync(java.lang.Class<T> clazz, SelectColumn selects, FilterNode node) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
<T> java.util.concurrent.CompletableFuture<T>	findAsync(java.lang.Class<T> clazz, SelectColumn selects, java.io.Serializable pk) 获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
<T> java.util.concurrent.CompletableFuture<T>	findAsync(java.lang.Class<T> clazz, java.io.Serializable pk) 获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {primary} = {id}
<T> java.util.concurrent.CompletableFuture<T>	findAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable key) 获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT * FROM {table} WHERE {column} = {key}
<T> java.io.Serializable	findColumn(java.lang.Class<T> clazz, java.lang.String column, FilterBean bean) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
<T> java.io.Serializable	findColumn(java.lang.Class<T> clazz, java.lang.String column, FilterNode node) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
<T> java.io.Serializable	findColumn(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable pk) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
<T> java.io.Serializable	findColumn(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable defValue, FilterBean bean) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
<T> java.io.Serializable	findColumn(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable defValue, FilterNode node) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
<T> java.io.Serializable	findColumn(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable defValue, java.io.Serializable pk) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
<T> java.util.concurrent.CompletableFuture<java.io.Serializable>	findColumnAsync(java.lang.Class<T> clazz, java.lang.String column, FilterBean bean) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
<T> java.util.concurrent.CompletableFuture<java.io.Serializable>	findColumnAsync(java.lang.Class<T> clazz, java.lang.String column, FilterNode node) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
<T> java.util.concurrent.CompletableFuture<java.io.Serializable>	findColumnAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable pk) 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
<T> java.util.concurrent.CompletableFuture<java.io.Serializable>	findColumnAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable defValue, FilterBean bean) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
<T> java.util.concurrent.CompletableFuture<java.io.Serializable>	findColumnAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable defValue, FilterNode node) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
<T> java.util.concurrent.CompletableFuture<java.io.Serializable>	findColumnAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable defValue, java.io.Serializable pk) 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
protected java.util.concurrent.ExecutorService	getExecutor()
<N extends java.lang.Number> java.util.Map<java.lang.String,N>	getNumberMap(java.lang.Class entityClass, FilterBean bean, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean} 如 getNumberMapAsync(Record.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends java.lang.Number> java.util.Map<java.lang.String,N>	getNumberMap(java.lang.Class entityClass, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} 如 getNumberMapAsync(Record.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends java.lang.Number> java.util.Map<java.lang.String,N>	getNumberMap(java.lang.Class entityClass, FilterNode node, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node} 如 getNumberMapAsync(Record.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<java.lang.String,N>>	getNumberMapAsync(java.lang.Class entityClass, FilterBean bean, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean} 如 getNumberMapAsync(Record.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<java.lang.String,N>>	getNumberMapAsync(java.lang.Class entityClass, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} 如 getNumberMapAsync(Record.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
<N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<java.lang.String,N>>	getNumberMapAsync(java.lang.Class entityClass, FilterNode node, FilterFuncColumn... columns) 获取符合过滤条件记录的聚合结果Map 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node} 如 getNumberMapAsync(Record.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
java.lang.Number	getNumberResult(java.lang.Class entityClass, FilterFunc func, java.lang.Number defVal, java.lang.String column) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table}
java.lang.Number	getNumberResult(java.lang.Class entityClass, FilterFunc func, java.lang.Number defVal, java.lang.String column, FilterBean bean) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
java.lang.Number	getNumberResult(java.lang.Class entityClass, FilterFunc func, java.lang.Number defVal, java.lang.String column, FilterNode node) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
java.lang.Number	getNumberResult(java.lang.Class entityClass, FilterFunc func, java.lang.String column) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table}
java.lang.Number	getNumberResult(java.lang.Class entityClass, FilterFunc func, java.lang.String column, FilterBean bean) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
java.lang.Number	getNumberResult(java.lang.Class entityClass, FilterFunc func, java.lang.String column, FilterNode node) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
java.util.concurrent.CompletableFuture<java.lang.Number>	getNumberResultAsync(java.lang.Class entityClass, FilterFunc func, java.lang.Number defVal, java.lang.String column) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table}
java.util.concurrent.CompletableFuture<java.lang.Number>	getNumberResultAsync(java.lang.Class entityClass, FilterFunc func, java.lang.Number defVal, java.lang.String column, FilterBean bean) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
java.util.concurrent.CompletableFuture<java.lang.Number>	getNumberResultAsync(java.lang.Class entityClass, FilterFunc func, java.lang.Number defVal, java.lang.String column, FilterNode node) 获取符合过滤条件记录的聚合结果, 无结果返回默认值 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
java.util.concurrent.CompletableFuture<java.lang.Number>	getNumberResultAsync(java.lang.Class entityClass, FilterFunc func, java.lang.String column) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table}
java.util.concurrent.CompletableFuture<java.lang.Number>	getNumberResultAsync(java.lang.Class entityClass, FilterFunc func, java.lang.String column, FilterBean bean) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
java.util.concurrent.CompletableFuture<java.lang.Number>	getNumberResultAsync(java.lang.Class entityClass, FilterFunc func, java.lang.String column, FilterNode node) 获取符合过滤条件记录的聚合结果, 无结果返回null 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
PoolJdbcSource	getReadPoolJdbcSource()
java.lang.String	getType() 获取数据源类型
PoolJdbcSource	getWritePoolJdbcSource()
void	init(AnyValue config) 该方法必须是可以重复调用， 当reload时需要重复调用init方法 远程模式下该方法会重载成空方法
protected void	initByProperties(java.lang.String unitName, java.util.Properties readprop, java.util.Properties writeprop)
protected <T> void	insert(java.sql.Connection conn, EntityInfo<T> info, T... values)
<T> void	insert(T... values) 新增对象， 必须是Entity对象
<T> java.util.concurrent.CompletableFuture<java.lang.Void>	insertAsync(T... values) 新增记录， 多对象必须是同一个Entity类
<T> int	insertCache(java.lang.Class<T> clazz, T... values)
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 void	preConstruct(java.lang.String unitName, java.util.Properties readprop, java.util.Properties writeprop)
<T,V extends java.io.Serializable> java.util.List<V>	queryColumnList(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
<T,V extends java.io.Serializable> java.util.List<V>	queryColumnList(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterNode node) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
<T,V extends java.io.Serializable> java.util.List<V>	queryColumnList(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends java.io.Serializable> java.util.List<V>	queryColumnList(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends java.io.Serializable> java.util.List<V>	queryColumnList(java.lang.String selectedColumn, java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable key) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>>	queryColumnListAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>>	queryColumnListAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterNode node) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>>	queryColumnListAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>>	queryColumnListAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>>	queryColumnListAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable key) 查询符合过滤条件记录的某个字段List集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
<T,K extends java.io.Serializable,N extends java.lang.Number> java.util.Map<K,N>	queryColumnMap(java.lang.Class<T> entityClass, java.lang.String keyColumn, FilterFunc func, java.lang.String funcColumn) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime") 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends java.io.Serializable,N extends java.lang.Number> java.util.Map<K,N>	queryColumnMap(java.lang.Class<T> entityClass, java.lang.String keyColumn, FilterFunc func, java.lang.String funcColumn, FilterBean bean) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends java.io.Serializable,N extends java.lang.Number> java.util.Map<K,N>	queryColumnMap(java.lang.Class<T> entityClass, java.lang.String keyColumn, FilterFunc func, java.lang.String funcColumn, FilterNode node) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends java.io.Serializable,N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<K,N>>	queryColumnMapAsync(java.lang.Class<T> entityClass, java.lang.String keyColumn, FilterFunc func, java.lang.String funcColumn) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime") 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends java.io.Serializable,N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<K,N>>	queryColumnMapAsync(java.lang.Class<T> entityClass, java.lang.String keyColumn, FilterFunc func, java.lang.String funcColumn, FilterBean bean) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,K extends java.io.Serializable,N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<K,N>>	queryColumnMapAsync(java.lang.Class<T> entityClass, java.lang.String keyColumn, FilterFunc func, java.lang.String funcColumn, FilterNode node) 查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
<T,V extends java.io.Serializable> java.util.HashSet<V>	queryColumnSet(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
<T,V extends java.io.Serializable> java.util.HashSet<V>	queryColumnSet(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterNode node) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
<T,V extends java.io.Serializable> java.util.HashSet<V>	queryColumnSet(java.lang.String selectedColumn, java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable key) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.HashSet<V>>	queryColumnSetAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.HashSet<V>>	queryColumnSetAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterNode node) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.HashSet<V>>	queryColumnSetAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable key) 查询符合过滤条件记录的某个字段Set集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key}
protected <T,V extends java.io.Serializable> Sheet<V>	queryColumnSheet(boolean needtotal, java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterNode node)
<T,V extends java.io.Serializable> Sheet<V>	queryColumnSheet(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterBean bean) 根据指定参数查询对象某个字段的集合
<T,V extends java.io.Serializable> Sheet<V>	queryColumnSheet(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的某个字段Sheet集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<Sheet<V>>	queryColumnSheetAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的某个字段Sheet集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<Sheet<V>>	queryColumnSheetAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的某个字段Sheet集合 等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.List<T>	queryList(java.lang.Class<T> clazz, FilterBean bean) 根据过滤对象FilterBean查询对象集合
<T> java.util.List<T>	queryList(java.lang.Class<T> clazz, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter node}
<T> java.util.List<T>	queryList(java.lang.Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.List<T>	queryList(java.lang.Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.List<T>	queryList(java.lang.Class<T> clazz, Flipper flipper, java.lang.String column, java.io.Serializable key) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.List<T>	queryList(java.lang.Class<T> clazz, SelectColumn selects, FilterBean bean) 根据过滤对象FilterBean查询对象集合， 对象只填充或排除SelectField指定的字段
<T> java.util.List<T>	queryList(java.lang.Class<T> clazz, SelectColumn selects, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
<T> java.util.List<T>	queryList(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.List<T>	queryList(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.List<T>	queryList(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable key) 根据指定字段值查询对象集合
<T> java.util.concurrent.CompletableFuture<java.util.List<T>>	queryListAsync(java.lang.Class<T> clazz, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter bean}
<T> java.util.concurrent.CompletableFuture<java.util.List<T>>	queryListAsync(java.lang.Class<T> clazz, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter node}
<T> java.util.concurrent.CompletableFuture<java.util.List<T>>	queryListAsync(java.lang.Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.concurrent.CompletableFuture<java.util.List<T>>	queryListAsync(java.lang.Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.concurrent.CompletableFuture<java.util.List<T>>	queryListAsync(java.lang.Class<T> clazz, Flipper flipper, java.lang.String column, java.io.Serializable key) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.concurrent.CompletableFuture<java.util.List<T>>	queryListAsync(java.lang.Class<T> clazz, SelectColumn selects, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
<T> java.util.concurrent.CompletableFuture<java.util.List<T>>	queryListAsync(java.lang.Class<T> clazz, SelectColumn selects, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
<T> java.util.concurrent.CompletableFuture<java.util.List<T>>	queryListAsync(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.concurrent.CompletableFuture<java.util.List<T>>	queryListAsync(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node) 查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.concurrent.CompletableFuture<java.util.List<T>>	queryListAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable key) 查询符合过滤条件记录的List集合 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<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}
protected <T> Sheet<T>	querySheet(boolean readcache, boolean needtotal, java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
<T> Sheet<T>	querySheet(java.lang.Class<T> clazz, Flipper flipper, FilterBean bean) 根据过滤对象FilterBean和翻页对象Flipper查询一页的数据
<T> Sheet<T>	querySheet(java.lang.Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> Sheet<T>	querySheet(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean) 根据过滤对象FilterBean和翻页对象Flipper查询一页的数据， 对象只填充或排除SelectField指定的字段
<T> Sheet<T>	querySheet(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.concurrent.CompletableFuture<Sheet<T>>	querySheetAsync(java.lang.Class<T> clazz, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.concurrent.CompletableFuture<Sheet<T>>	querySheetAsync(java.lang.Class<T> clazz, Flipper flipper, FilterNode node) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.concurrent.CompletableFuture<Sheet<T>>	querySheetAsync(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> java.util.concurrent.CompletableFuture<Sheet<T>>	querySheetAsync(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node) 查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> void	refreshCache(java.lang.Class<T> clazz) 将entity的对象全部加载到Cache中去，如果clazz没有被@javax.persistence.Cacheable注解则不做任何事
<T> int	reloadCache(java.lang.Class<T> clazz, java.io.Serializable... ids)
java.lang.String	resourceName()
protected <T> int	update(java.sql.Connection conn, EntityInfo<T> info, T... values)
<T> int	update(T... values) 更新对象， 必须是Entity对象
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	updateAsync(T... values) 更新记录， 多对象必须是同一个Entity类 等价SQL: UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1} UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2} ···
<T> int	updateCache(java.lang.Class<T> clazz, T... values)
<T> int	updateColumn(java.lang.Class<T> clazz, FilterNode node, ColumnValue... values) 根据主键值更新对象的多个column对应的值， 必须是Entity Class
<T> int	updateColumn(java.lang.Class<T> clazz, FilterNode node, Flipper flipper, ColumnValue... values) 根据主键值更新对象的多个column对应的值， 必须是Entity Class
<T> int	updateColumn(java.lang.Class<T> clazz, java.io.Serializable id, ColumnValue... values) 根据主键值更新对象的多个column对应的值， 必须是Entity Class
<T> int	updateColumn(java.lang.Class<T> clazz, java.io.Serializable id, java.lang.String column, java.io.Serializable value) 根据主键值更新对象的column对应的值， 必须是Entity Class
<T> int	updateColumn(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable value, FilterNode node) 根据主键值更新对象的column对应的值， 必须是Entity Class
protected <T> int	updateColumn(java.sql.Connection conn, EntityInfo<T> info, FilterNode node, Flipper flipper, ColumnValue... values)
protected <T> int	updateColumn(java.sql.Connection conn, EntityInfo<T> info, java.io.Serializable id, ColumnValue... values)
protected <T> int	updateColumn(java.sql.Connection conn, EntityInfo<T> info, java.io.Serializable id, java.lang.String column, java.io.Serializable value)
protected <T> int	updateColumn(java.sql.Connection conn, EntityInfo<T> info, java.lang.String column, java.io.Serializable value, FilterNode node)
<T> int	updateColumn(T bean, FilterNode node, SelectColumn selects) 更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
<T> int	updateColumn(T bean, FilterNode node, java.lang.String... columns) 更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
<T> int	updateColumn(T bean, SelectColumn selects) 更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
<T> int	updateColumn(T bean, java.lang.String... columns) 更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	updateColumnAsync(java.lang.Class<T> clazz, FilterNode node, ColumnValue... values) 更新符合过滤条件记录的部分字段 字段赋值操作选项见 ColumnExpress 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	updateColumnAsync(java.lang.Class<T> clazz, FilterNode node, Flipper flipper, ColumnValue... values) 更新符合过滤条件的记录的指定字段 Flipper中offset字段将被忽略 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	updateColumnAsync(java.lang.Class<T> clazz, java.io.Serializable id, ColumnValue... values) 更新指定主键值记录的部分字段 字段赋值操作选项见 ColumnExpress 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	updateColumnAsync(java.lang.Class<T> clazz, java.io.Serializable id, java.lang.String column, java.io.Serializable value) 更新单个记录的单个字段 注意：即使字段标记为@Column(updatable=false)也会被更新 等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	updateColumnAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable value, FilterNode node) 更新符合过滤条件记录的单个字段 注意：即使字段标记为@Column(updatable=false)也会被更新 等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	updateColumnAsync(T bean, FilterNode node, SelectColumn selects) 更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	updateColumnAsync(T bean, FilterNode node, java.lang.String... columns) 更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	updateColumnAsync(T bean, SelectColumn selects) 更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
<T> java.util.concurrent.CompletableFuture<java.lang.Integer>	updateColumnAsync(T bean, java.lang.String... columns) 更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
protected <T> int	updateColumns(java.sql.Connection conn, EntityInfo<T> info, T bean, FilterNode node, SelectColumn selects)
protected <T> int	updateColumns(java.sql.Connection conn, EntityInfo<T> info, T bean, SelectColumn selects)

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

runAsync

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

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

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

queryList, queryListAsync

从接口继承的方法 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

conf

protected java.net.URL conf

threads

protected int threads

executor

protected java.util.concurrent.ExecutorService executor

cacheForbidden

protected boolean cacheForbidden

readPool

protected PoolJdbcSource readPool

writePool

protected PoolJdbcSource writePool

cacheListener

protected DataCacheListener cacheListener

fullloader

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

构造器详细资料

DataJdbcSource

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

DataJdbcSource

public DataJdbcSource()

方法详细资料

init

public void init(AnyValue config)

从接口复制的说明: Service

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

指定者:

init 在接口中 Service

参数:

config - 配置参数

getExecutor

protected java.util.concurrent.ExecutorService getExecutor()

覆盖:

getExecutor 在类中 AbstractService

destroy

public void destroy(AnyValue config)

从接口复制的说明: Service

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

指定者:

destroy 在接口中 Service

参数:

config - 配置参数

preConstruct

protected void preConstruct(java.lang.String unitName,
                            java.util.Properties readprop,
                            java.util.Properties writeprop)

initByProperties

protected void initByProperties(java.lang.String unitName,
                                java.util.Properties readprop,
                                java.util.Properties writeprop)

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

getReadPoolJdbcSource

@Local
public PoolJdbcSource getReadPoolJdbcSource()

getWritePoolJdbcSource

@Local
public PoolJdbcSource getWritePoolJdbcSource()

createReadSQLConnection

@Local
public java.sql.Connection createReadSQLConnection()

createWriteSQLConnection

@Local
public <T> java.sql.Connection createWriteSQLConnection()

closeSQLConnection

@Local
public void closeSQLConnection(java.sql.Connection sqlconn)

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)

refreshCache

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

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

类型参数:

T - Entity类泛型

参数:

clazz - Entity类

insert

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

新增对象， 必须是Entity对象

指定者:

insert 在接口中 DataSource

类型参数:

T - Entity类泛型

参数:

values - Entity对象

insertAsync

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

从接口复制的说明: DataSource

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

指定者:

insertAsync 在接口中 DataSource

类型参数:

T - 泛型

参数:

values - Entity对象

返回:

CompletableFuture

insert

protected <T> void insert(java.sql.Connection conn,
                          EntityInfo<T> info,
                          T... values)

createInsertPreparedStatement

protected <T> java.sql.PreparedStatement createInsertPreparedStatement(java.sql.Connection conn,
                                                                       java.lang.String sql,
                                                                       EntityInfo<T> info,
                                                                       T... values)
                                                                throws java.sql.SQLException

抛出:

java.sql.SQLException

insertCache

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

指定者:

insertCache 在接口中 DataCacheListener

delete

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

删除对象， 必须是Entity对象

指定者:

delete 在接口中 DataSource

类型参数:

T - Entity类泛型

参数:

values - Entity对象

返回:

删除的数据条数

deleteAsync

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

从接口复制的说明: DataSource

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

指定者:

deleteAsync 在接口中 DataSource

类型参数:

T - 泛型

参数:

values - Entity对象

返回:

影响的记录条数CompletableFuture

delete

protected <T> int delete(java.sql.Connection conn,
                         EntityInfo<T> info,
                         T... values)

delete

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

从接口复制的说明: DataSource

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

指定者:

delete 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

ids - 主键值

返回:

影响的记录条数

deleteAsync

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

从接口复制的说明: DataSource

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

指定者:

deleteAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

ids - 主键值

返回:

影响的记录条数CompletableFuture

delete

protected <T> int delete(java.sql.Connection conn,
                         EntityInfo<T> info,
                         java.io.Serializable... keys)

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

delete

protected <T> int delete(java.sql.Connection conn,
                         EntityInfo<T> info,
                         Flipper flipper,
                         FilterNode node)

deleteCache

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

指定者:

deleteCache 在接口中 DataCacheListener

update

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

更新对象， 必须是Entity对象

指定者:

update 在接口中 DataSource

类型参数:

T - Entity类泛型

参数:

values - Entity对象

返回:

更新的数据条数

updateAsync

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

从接口复制的说明: DataSource

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

指定者:

updateAsync 在接口中 DataSource

类型参数:

T - 泛型

参数:

values - Entity对象

返回:

影响的记录条数CompletableFuture

update

protected <T> int update(java.sql.Connection conn,
                         EntityInfo<T> info,
                         T... values)

updateColumn

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

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

id - 主键值

column - 过滤字段名

value - 过滤字段值

返回:

更新的数据条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

id - 主键

column - 待更新的字段名

value - 更新值

返回:

影响的记录条数CompletableFuture

updateColumn

protected <T> int updateColumn(java.sql.Connection conn,
                               EntityInfo<T> info,
                               java.io.Serializable id,
                               java.lang.String column,
                               java.io.Serializable value)

updateColumn

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

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

column - 过滤字段名

value - 过滤字段值

node - 过滤node 不能为null

返回:

更新的数据条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 待更新的字段名

value - 更新值

node - 过滤条件

返回:

影响的记录条数CompletableFuture

updateColumn

protected <T> int updateColumn(java.sql.Connection conn,
                               EntityInfo<T> info,
                               java.lang.String column,
                               java.io.Serializable value,
                               FilterNode node)

updateColumn

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

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

id - 主键值

values - 字段值

返回:

更新的数据条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

id - 主键

values - 更新字段

返回:

影响的记录条数CompletableFuture

updateColumn

protected <T> int updateColumn(java.sql.Connection conn,
                               EntityInfo<T> info,
                               java.io.Serializable id,
                               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)

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

node - 过滤条件

flipper - 翻页对象

values - 字段值

返回:

更新的数据条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

flipper - 翻页对象

values - 更新字段

返回:

影响的记录条数CompletableFuture

updateColumn

protected <T> int updateColumn(java.sql.Connection conn,
                               EntityInfo<T> info,
                               FilterNode node,
                               Flipper flipper,
                               ColumnValue... values)

updateColumn

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

从接口复制的说明: DataSource

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

columns - 需更新的字段名

返回:

影响的记录条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

columns - 需更新的字段名

返回:

影响的记录条数CompletableFuture

updateColumn

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

从接口复制的说明: DataSource

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

node - 过滤条件

columns - 需更新的字段名

返回:

影响的记录条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

node - 过滤条件

columns - 需更新的字段名

返回:

影响的记录条数CompletableFuture

updateColumn

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

从接口复制的说明: DataSource

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

selects - 指定字段

返回:

影响的记录条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

selects - 指定字段

返回:

影响的记录条数CompletableFuture

updateColumns

protected <T> int updateColumns(java.sql.Connection conn,
                                EntityInfo<T> info,
                                T bean,
                                SelectColumn selects)

updateColumn

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

从接口复制的说明: DataSource

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

指定者:

updateColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

node - 过滤条件

selects - 指定字段

返回:

影响的记录条数

updateColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

updateColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

bean - 待更新的Entity对象

node - 过滤条件

selects - 指定字段

返回:

影响的记录条数CompletableFuture

updateColumns

protected <T> int updateColumns(java.sql.Connection conn,
                                EntityInfo<T> info,
                                T bean,
                                FilterNode node,
                                SelectColumn selects)

updateCache

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

指定者:

updateCache 在接口中 DataCacheListener

reloadCache

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

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

返回:

聚合结果

getNumberResultAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

返回:

聚合结果CompletableFuture

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

bean - 过滤条件

返回:

聚合结果

getNumberResultAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

bean - 过滤条件

返回:

聚合结果CompletableFuture

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

node - 过滤条件

返回:

聚合结果

getNumberResultAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

column - 指定字段

node - 过滤条件

返回:

聚合结果

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

返回:

聚合结果

getNumberResultAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

返回:

聚合结果CompletableFuture

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

bean - 过滤条件

返回:

聚合结果

getNumberResultAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

bean - 过滤条件

返回:

聚合结果CompletableFuture

getNumberResultAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberResultAsync 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

node - 过滤条件

返回:

聚合结果CompletableFuture

getNumberMap

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

从接口复制的说明: DataSource

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

指定者:

getNumberMap 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

columns - 聚合字段

返回:

聚合结果Map

getNumberMapAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberMapAsync 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

columns - 聚合字段

返回:

聚合结果Map CompletableFuture

getNumberMap

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

从接口复制的说明: DataSource

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

指定者:

getNumberMap 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

bean - 过滤条件

columns - 聚合字段

返回:

聚合结果Map

getNumberMapAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberMapAsync 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

bean - 过滤条件

columns - 聚合字段

返回:

聚合结果Map CompletableFuture

getNumberMap

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

从接口复制的说明: DataSource

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

指定者:

getNumberMap 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

node - 过滤条件

columns - 聚合字段

返回:

聚合结果Map

getNumberMapAsync

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

从接口复制的说明: DataSource

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

指定者:

getNumberMapAsync 在接口中 DataSource

类型参数:

N - Number

参数:

entityClass - Entity类

node - 过滤条件

columns - 聚合字段

返回:

聚合结果Map

getNumberResult

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

从接口复制的说明: DataSource

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

指定者:

getNumberResult 在接口中 DataSource

参数:

entityClass - Entity类

func - 聚合函数

defVal - 默认值

column - 指定字段

node - 过滤条件

返回:

聚合结果

queryColumnMap

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

从接口复制的说明: DataSource

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

指定者:

queryColumnMap 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

返回:

聚合结果Map

queryColumnMapAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnMapAsync 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

返回:

聚合结果Map CompletableFuture

queryColumnMap

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

从接口复制的说明: DataSource

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

指定者:

queryColumnMap 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

bean - 过滤条件

返回:

聚合结果Map

queryColumnMapAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnMapAsync 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

bean - 过滤条件

返回:

聚合结果Map CompletableFuture

queryColumnMap

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

从接口复制的说明: DataSource

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

指定者:

queryColumnMap 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

node - 过滤条件

返回:

聚合结果Map

queryColumnMapAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnMapAsync 在接口中 DataSource

类型参数:

T - Entity泛型

K - Key字段的数据类型

N - Number

参数:

entityClass - Entity类

keyColumn - Key字段

func - 聚合函数

funcColumn - 聚合字段

node - 过滤条件

返回:

聚合结果Map CompletableFuture

find

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

根据主键获取对象

指定者:

find 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

pk - 主键值

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

Entity对象 CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

pk - 主键值

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

pk - 主键值

返回:

Entity对象CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity对象CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity对象CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity对象CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - 过滤条件

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - 过滤条件

返回:

Entity对象 CompletableFuture

find

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

从接口复制的说明: DataSource

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

指定者:

find 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity对象

findAsync

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

从接口复制的说明: DataSource

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

指定者:

findAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity对象 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

pk - 主键值

返回:

Entity对象

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

pk - 主键值

返回:

Entity对象 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

bean - 过滤条件

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

bean - 过滤条件

返回:

字段值 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

node - 过滤条件

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

node - 过滤条件

返回:

字段值 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

pk - 主键值

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

pk - 主键值

返回:

字段值 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

bean - 过滤条件

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

bean - 过滤条件

返回:

字段值 CompletableFuture

findColumn

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

从接口复制的说明: DataSource

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

指定者:

findColumn 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

node - 过滤条件

返回:

字段值

findColumnAsync

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

从接口复制的说明: DataSource

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

指定者:

findColumnAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 字段名

defValue - 默认值

node - 过滤条件

返回:

字段值 CompletableFuture

exists

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

从接口复制的说明: DataSource

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

指定者:

exists 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

是否存在

existsAsync

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

从接口复制的说明: DataSource

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

指定者:

existsAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

pk - 主键值

返回:

是否存在CompletableFuture

exists

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

从接口复制的说明: DataSource

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

指定者:

exists 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

是否存在

existsAsync

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

从接口复制的说明: DataSource

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

指定者:

existsAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

是否存在CompletableFuture

exists

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

从接口复制的说明: DataSource

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

指定者:

exists 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

是否存在

existsAsync

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

从接口复制的说明: DataSource

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

指定者:

existsAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

是否存在CompletableFuture

queryColumnSet

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSet 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

字段值的集合

queryColumnSetAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

字段值的集合CompletableFuture

queryColumnSet

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSet 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合

queryColumnSetAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnSet

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSet 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合

queryColumnSetAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

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

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

字段值的集合

queryColumnListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

字段值的集合CompletableFuture

queryColumnList

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

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合

queryColumnListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

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

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合

queryColumnListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

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

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

字段值的集合

queryColumnListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnList

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

从接口复制的说明: DataSource

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

指定者:

queryColumnList 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合

queryColumnListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnSheet

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

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

指定者:

queryColumnSheet 在接口中 DataSource

类型参数:

T - Entity类的泛型

V - 字段值的类型

参数:

selectedColumn - 字段名

clazz - Entity类

flipper - 翻页对象

bean - 过滤Bean

返回:

字段集合

queryColumnSheetAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnSheet

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSheet 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合

queryColumnSheetAsync

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

从接口复制的说明: DataSource

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

指定者:

queryColumnSheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

V - 字段类型

参数:

selectedColumn - 指定字段

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

字段值的集合CompletableFuture

queryColumnSheet

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

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

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity对象的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

column - 过滤字段名

key - 过滤字段值

返回:

Entity的集合CompletableFuture

queryList

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

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

bean - 过滤Bean

返回:

Entity对象集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

node - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

selects - 收集的字段

bean - 过滤Bean

返回:

Entity对象的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

node - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

column - 过滤字段名

key - 过滤字段值

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

column - 过滤字段名

key - 过滤字段值

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

queryList

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

从接口复制的说明: DataSource

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

指定者:

queryList 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

queryListAsync

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

从接口复制的说明: DataSource

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

指定者:

queryListAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

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

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

指定者:

querySheet 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤Bean

返回:

Entity对象的集合

querySheetAsync

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

从接口复制的说明: DataSource

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

指定者:

querySheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

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

从接口复制的说明: DataSource

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

指定者:

querySheet 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

querySheetAsync

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

从接口复制的说明: DataSource

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

指定者:

querySheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

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

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

指定者:

querySheet 在接口中 DataSource

类型参数:

T - Entity类的泛型

参数:

clazz - Entity类

selects - 收集的字段集合

flipper - 翻页对象

bean - 过滤Bean

返回:

Entity对象的集合

querySheetAsync

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

从接口复制的说明: DataSource

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

指定者:

querySheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

bean - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

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

从接口复制的说明: DataSource

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

指定者:

querySheet 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合

querySheetAsync

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

从接口复制的说明: DataSource

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

指定者:

querySheetAsync 在接口中 DataSource

类型参数:

T - Entity泛型

参数:

clazz - Entity类

selects - 指定字段

flipper - 翻页对象

node - 过滤条件

返回:

Entity的集合CompletableFuture

querySheet

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

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)

directExecute

protected int[] directExecute(java.sql.Connection conn,
                              java.lang.String... sqls)

directExecute

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

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

参数:

sqls - SQL语句

返回:

结果数组

directQuery

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

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

参数:

sql - SQL语句

consumer - 回调函数