类的使用
org.redkale.util.SelectColumn

使用SelectColumn的程序包

程序包	说明
org.redkale.source	数据源(数据库、缓存)操作包
org.redkale.util	Redkale工具包

org.redkale.source中SelectColumn的使用

声明为SelectColumn的org.redkale.source中的字段

修饰符和类型	字段	说明
SelectColumn	AbstractDataSource.UpdateBatchAction4.selects

参数类型为SelectColumn的org.redkale.source中的方法

修饰符和类型	方法	说明
protected <T> String	AbstractDataSqlSource.checkIllegalColumn(EntityInfo<T> info, SelectColumn selects)
protected <T> AbstractDataSqlSource.PageCountSql	AbstractDataSqlSource.createPageCountSql(EntityInfo<T> info, boolean readCache, boolean needTotal, boolean distinct, SelectColumn selects, String[] tables, Flipper flipper, FilterNode node)
<T> T	AbstractDataSource.find(Class<T> clazz, SelectColumn selects, FilterBean bean)
<T> T	AbstractDataSqlSource.find(Class<T> clazz, SelectColumn selects, Serializable pk)
<T> T	AbstractDataSqlSource.find(Class<T> clazz, SelectColumn selects, FilterNode node)
<T> T	DataMemorySource.find(Class<T> clazz, SelectColumn selects, Serializable pk)
<T> T	DataMemorySource.find(Class<T> clazz, SelectColumn selects, FilterNode node)
<T> T	DataSource.find(Class<T> clazz, SelectColumn selects, Serializable pk)	获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
default <T> T	DataSource.find(Class<T> clazz, SelectColumn selects, FilterBean bean)	获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
<T> T	DataSource.find(Class<T> clazz, SelectColumn selects, FilterNode node)	获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
default T	DataSqlMapper.find(SelectColumn selects, Serializable pk)	获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
default T	DataSqlMapper.find(SelectColumn selects, FilterBean bean)	获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
default T	DataSqlMapper.find(SelectColumn selects, FilterNode node)	获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
T	EntityCache.find(SelectColumn selects, Serializable pk)
T	EntityCache.find(SelectColumn selects, FilterNode node)
<T> CompletableFuture<T>	AbstractDataSource.findAsync(Class<T> clazz, SelectColumn selects, FilterBean bean)
<T> CompletableFuture<T>	AbstractDataSqlSource.findAsync(Class<T> clazz, SelectColumn selects, Serializable pk)
<T> CompletableFuture<T>	AbstractDataSqlSource.findAsync(Class<T> clazz, SelectColumn selects, FilterNode node)
<T> CompletableFuture<T>	DataMemorySource.findAsync(Class<T> clazz, SelectColumn selects, Serializable pk)
<T> CompletableFuture<T>	DataMemorySource.findAsync(Class<T> clazz, SelectColumn selects, FilterNode node)
<T> CompletableFuture<T>	DataSource.findAsync(Class<T> clazz, SelectColumn selects, Serializable pk)	获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
default <T> CompletableFuture<T>	DataSource.findAsync(Class<T> clazz, SelectColumn selects, FilterBean bean)	获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
<T> CompletableFuture<T>	DataSource.findAsync(Class<T> clazz, SelectColumn selects, FilterNode node)	获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
default CompletableFuture<T>	DataSqlMapper.findAsync(SelectColumn selects, Serializable pk)	获取指定主键值的单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
default CompletableFuture<T>	DataSqlMapper.findAsync(SelectColumn selects, FilterBean bean)	获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
default CompletableFuture<T>	DataSqlMapper.findAsync(SelectColumn selects, FilterNode node)	获取符合过滤条件单个记录, 返回null表示不存在值 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
protected <T> T	AbstractDataSqlSource.findDB(EntityInfo<T> info, String[] tables, String sql, boolean onlypk, SelectColumn selects, Serializable pk, FilterNode node)
protected <T> T	DataJdbcSource.findDB(EntityInfo<T> info, String[] tables, String sql, boolean onlypk, SelectColumn selects, Serializable pk, FilterNode node)
protected <T> CompletableFuture<T>	AbstractDataSqlSource.findDBApply(EntityInfo<T> info, CompletableFuture<? extends DataResultSet> future, boolean onlypk, SelectColumn selects)
protected abstract <T> CompletableFuture<T>	AbstractDataSqlSource.findDBAsync(EntityInfo<T> info, String[] tables, String sql, boolean onlypk, SelectColumn selects, Serializable pk, FilterNode node)
protected <T> CompletableFuture<T>	DataJdbcSource.findDBAsync(EntityInfo<T> info, String[] tables, String sql, boolean onlypk, SelectColumn selects, Serializable pk, FilterNode node)
<T> T[]	AbstractDataSqlSource.finds(Class<T> clazz, SelectColumn selects, Serializable... pks)
<T> T[]	DataMemorySource.finds(Class<T> clazz, SelectColumn selects, Serializable... pks)
<T> T[]	DataSource.finds(Class<T> clazz, SelectColumn selects, Serializable... pks)	获取指定主键值的多个记录, 返回数组，数组长度与pks一样 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
default <D extends Serializable,T> T[]	DataSource.finds(Class<T> clazz, SelectColumn selects, Stream<D> pks)	获取指定主键值的多个记录, 返回数组，数组长度与pks一样 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
default T[]	DataSqlMapper.finds(SelectColumn selects, Serializable... pks)	获取指定主键值的多个记录, 返回数组，数组长度与pks一样 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
default <D extends Serializable> T[]	DataSqlMapper.finds(SelectColumn selects, Stream<D> pks)	获取指定主键值的多个记录, 返回数组，数组长度与pks一样 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
T[]	EntityCache.finds(SelectColumn selects, Serializable... pks)
<T> CompletableFuture<T[]>	AbstractDataSqlSource.findsAsync(Class<T> clazz, SelectColumn selects, Serializable... pks)
<T> CompletableFuture<T[]>	DataMemorySource.findsAsync(Class<T> clazz, SelectColumn selects, Serializable... pks)
<T> CompletableFuture<T[]>	DataSource.findsAsync(Class<T> clazz, SelectColumn selects, Serializable... pks)	获取指定主键值的多个记录, 返回数组，数组长度与pks一样 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
default <D extends Serializable,T> CompletableFuture<T[]>	DataSource.findsAsync(Class<T> clazz, SelectColumn selects, Stream<D> pks)	获取指定主键值的多个记录, 返回数组，数组长度与pks一样 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
default CompletableFuture<T[]>	DataSqlMapper.findsAsync(SelectColumn selects, Serializable... pks)	获取指定主键值的多个记录, 返回数组，数组长度与pks一样 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
default <D extends Serializable> CompletableFuture<T[]>	DataSqlMapper.findsAsync(SelectColumn selects, Stream<D> pks)	获取指定主键值的多个记录, 返回数组，数组长度与pks一样 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id1,id2, ···}
protected <T> CompletableFuture<T[]>	AbstractDataSqlSource.findsDBAsync(EntityInfo<T> info, SelectColumn selects, Serializable... pks)
protected <T> String	AbstractDataSqlSource.findSql(EntityInfo<T> info, String[] tables, SelectColumn selects, FilterNode node)
protected <T> String	AbstractDataSqlSource.findSql(EntityInfo<T> info, SelectColumn selects, Serializable pk)
protected <T> T	AbstractDataSqlSource.findUnCache(EntityInfo<T> info, SelectColumn selects, Serializable pk)
protected <T> T	DataJdbcSource.findUnCache(EntityInfo<T> info, SelectColumn selects, Serializable pk)
protected <T> CompletableFuture<T>	AbstractDataSqlSource.findUnCacheAsync(EntityInfo<T> info, SelectColumn selects, Serializable pk)
protected <T> CompletableFuture<T>	DataJdbcSource.findUnCacheAsync(EntityInfo<T> info, SelectColumn selects, Serializable pk)
List<T>	EntityBuilder.getEntityList(SelectColumn sels, DataResultSet rset)
protected <T> T	AbstractDataSource.getEntityValue(EntityInfo<T> info, SelectColumn sels, DataResultSetRow row)	根据ResultSet获取对象
T	EntityBuilder.getEntityValue(SelectColumn sels, DataResultSetRow row)	将一行的ResultSet组装成一个Entity对象
CharSequence	EntityInfo.getQueryColumns(String tabalis, SelectColumn selects)	获取查询字段列表
<T> List<T>	AbstractDataSource.queryList(Class<T> clazz, SelectColumn selects, FilterBean bean)	根据过滤对象FilterBean查询对象集合， 对象只填充或排除SelectField指定的字段
<T> List<T>	AbstractDataSource.queryList(Class<T> clazz, SelectColumn selects, FilterNode node)
<T> List<T>	AbstractDataSource.queryList(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
<T> List<T>	AbstractDataSqlSource.queryList(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
<T> List<T>	DataMemorySource.queryList(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
default <T> List<T>	DataSource.queryList(Class<T> clazz, SelectColumn selects, FilterBean bean)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
default <T> List<T>	DataSource.queryList(Class<T> clazz, SelectColumn selects, FilterNode node)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
default <T> List<T>	DataSource.queryList(Class<T> clazz, SelectColumn selects, Flipper flipper)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default <T> List<T>	DataSource.queryList(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> List<T>	DataSource.queryList(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default List<T>	DataSqlMapper.queryList(SelectColumn selects, FilterBean bean)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
default List<T>	DataSqlMapper.queryList(SelectColumn selects, FilterNode node)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
default List<T>	DataSqlMapper.queryList(SelectColumn selects, Flipper flipper)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default List<T>	DataSqlMapper.queryList(SelectColumn selects, Flipper flipper, FilterBean bean)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default List<T>	DataSqlMapper.queryList(SelectColumn selects, Flipper flipper, FilterNode node)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<List<T>>	AbstractDataSource.queryListAsync(Class<T> clazz, SelectColumn selects, FilterBean bean)
<T> CompletableFuture<List<T>>	AbstractDataSource.queryListAsync(Class<T> clazz, SelectColumn selects, FilterNode node)
<T> CompletableFuture<List<T>>	AbstractDataSource.queryListAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
<T> CompletableFuture<List<T>>	AbstractDataSqlSource.queryListAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
<T> CompletableFuture<List<T>>	DataMemorySource.queryListAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
default <T> CompletableFuture<List<T>>	DataSource.queryListAsync(Class<T> clazz, SelectColumn selects, FilterBean bean)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
default <T> CompletableFuture<List<T>>	DataSource.queryListAsync(Class<T> clazz, SelectColumn selects, FilterNode node)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
default <T> CompletableFuture<List<T>>	DataSource.queryListAsync(Class<T> clazz, SelectColumn selects, Flipper flipper)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default <T> CompletableFuture<List<T>>	DataSource.queryListAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<List<T>>	DataSource.queryListAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default CompletableFuture<List<T>>	DataSqlMapper.queryListAsync(SelectColumn selects, FilterBean bean)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
default CompletableFuture<List<T>>	DataSqlMapper.queryListAsync(SelectColumn selects, FilterNode node)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
default CompletableFuture<List<T>>	DataSqlMapper.queryListAsync(SelectColumn selects, Flipper flipper)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default CompletableFuture<List<T>>	DataSqlMapper.queryListAsync(SelectColumn selects, Flipper flipper, FilterBean bean)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default CompletableFuture<List<T>>	DataSqlMapper.queryListAsync(SelectColumn selects, Flipper flipper, FilterNode node)	查询符合过滤条件记录的List集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	AbstractDataSource.queryMap(Class<T> clazz, SelectColumn selects, FilterBean bean)	查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	AbstractDataSqlSource.queryMap(Class<T> clazz, SelectColumn selects, Stream<K> keyStream)	查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	AbstractDataSqlSource.queryMap(Class<T> clazz, SelectColumn selects, FilterNode node)	查询符合过滤条件记录的Map集合, 主键值为key 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<K extends Serializable,T> Map<K,T>	DataMemorySource.queryMap(Class<T> clazz, SelectColumn selects, Stream<K> keyStream)
<K extends Serializable,T> Map<K,T>	DataMemorySource.queryMap(Class<T> clazz, SelectColumn selects, FilterNode node)
<K extends Serializable,T> Map<K,T>	DataSource.queryMap(Class<T> clazz, SelectColumn selects, Stream<K> keyStream)	查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象 等价SQL: SELECT * FROM {table} WHERE id IN {ids}
default <K extends Serializable,T> Map<K,T>	DataSource.queryMap(Class<T> clazz, SelectColumn selects, FilterBean bean)	查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象 等价SQL: SELECT * FROM {table} WHERE {filter node}
<K extends Serializable,T> Map<K,T>	DataSource.queryMap(Class<T> clazz, SelectColumn selects, FilterNode node)	查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象 等价SQL: SELECT * FROM {table} WHERE {filter node}
default <K extends Serializable> Map<K,T>	DataSqlMapper.queryMap(SelectColumn selects, Stream<K> keyStream)	查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象 等价SQL: SELECT * FROM {table} WHERE id IN {ids}
default <K extends Serializable> Map<K,T>	DataSqlMapper.queryMap(SelectColumn selects, FilterBean bean)	查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象 等价SQL: SELECT * FROM {table} WHERE {filter node}
default <K extends Serializable> Map<K,T>	DataSqlMapper.queryMap(SelectColumn selects, FilterNode node)	查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象 等价SQL: SELECT * FROM {table} WHERE {filter node}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	AbstractDataSource.queryMapAsync(Class<T> clazz, SelectColumn selects, FilterBean bean)
<K extends Serializable,T> CompletableFuture<Map<K,T>>	AbstractDataSqlSource.queryMapAsync(Class<T> clazz, SelectColumn selects, Stream<K> keyStream)
<K extends Serializable,T> CompletableFuture<Map<K,T>>	AbstractDataSqlSource.queryMapAsync(Class<T> clazz, SelectColumn selects, FilterNode node)
<K extends Serializable,T> CompletableFuture<Map<K,T>>	DataMemorySource.queryMapAsync(Class<T> clazz, SelectColumn selects, Stream<K> keyStream)
<K extends Serializable,T> CompletableFuture<Map<K,T>>	DataMemorySource.queryMapAsync(Class<T> clazz, SelectColumn selects, FilterNode node)
<K extends Serializable,T> CompletableFuture<Map<K,T>>	DataSource.queryMapAsync(Class<T> clazz, SelectColumn selects, Stream<K> keyStream)	查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象 等价SQL: SELECT * FROM {table} WHERE id IN {ids}
default <K extends Serializable,T> CompletableFuture<Map<K,T>>	DataSource.queryMapAsync(Class<T> clazz, SelectColumn selects, FilterBean bean)	查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象 等价SQL: SELECT * FROM {table} WHERE {filter node}
<K extends Serializable,T> CompletableFuture<Map<K,T>>	DataSource.queryMapAsync(Class<T> clazz, SelectColumn selects, FilterNode node)	查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象 等价SQL: SELECT * FROM {table} WHERE {filter node}
default <K extends Serializable> CompletableFuture<Map<K,T>>	DataSqlMapper.queryMapAsync(SelectColumn selects, Stream<K> keyStream)	查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象 等价SQL: SELECT * FROM {table} WHERE id IN {ids}
default <K extends Serializable> CompletableFuture<Map<K,T>>	DataSqlMapper.queryMapAsync(SelectColumn selects, FilterBean bean)	查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象 等价SQL: SELECT * FROM {table} WHERE {filter node}
default <K extends Serializable> CompletableFuture<Map<K,T>>	DataSqlMapper.queryMapAsync(SelectColumn selects, FilterNode node)	查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象 等价SQL: SELECT * FROM {table} WHERE {filter node}
<T> Set<T>	AbstractDataSource.querySet(Class<T> clazz, SelectColumn selects, FilterBean bean)	根据过滤对象FilterBean查询对象集合， 对象只填充或排除SelectField指定的字段
<T> Set<T>	AbstractDataSource.querySet(Class<T> clazz, SelectColumn selects, FilterNode node)
<T> Set<T>	AbstractDataSource.querySet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
<T> Set<T>	AbstractDataSqlSource.querySet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
<T> Set<T>	DataMemorySource.querySet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
default <T> Set<T>	DataSource.querySet(Class<T> clazz, SelectColumn selects, FilterBean bean)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
default <T> Set<T>	DataSource.querySet(Class<T> clazz, SelectColumn selects, FilterNode node)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node}
default <T> Set<T>	DataSource.querySet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> Set<T>	DataSource.querySet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default Set<T>	DataSqlMapper.querySet(SelectColumn selects, FilterBean bean)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
default Set<T>	DataSqlMapper.querySet(SelectColumn selects, FilterNode node)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node}
default Set<T>	DataSqlMapper.querySet(SelectColumn selects, Flipper flipper, FilterBean bean)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default Set<T>	DataSqlMapper.querySet(SelectColumn selects, Flipper flipper, FilterNode node)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<Set<T>>	AbstractDataSource.querySetAsync(Class<T> clazz, SelectColumn selects, FilterBean bean)
<T> CompletableFuture<Set<T>>	AbstractDataSource.querySetAsync(Class<T> clazz, SelectColumn selects, FilterNode node)
<T> CompletableFuture<Set<T>>	AbstractDataSource.querySetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
<T> CompletableFuture<Set<T>>	AbstractDataSqlSource.querySetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
<T> CompletableFuture<Set<T>>	DataMemorySource.querySetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
default <T> CompletableFuture<Set<T>>	DataSource.querySetAsync(Class<T> clazz, SelectColumn selects, FilterBean bean)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
default <T> CompletableFuture<Set<T>>	DataSource.querySetAsync(Class<T> clazz, SelectColumn selects, FilterNode node)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node}
default <T> CompletableFuture<Set<T>>	DataSource.querySetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<Set<T>>	DataSource.querySetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default CompletableFuture<Set<T>>	DataSqlMapper.querySetAsync(SelectColumn selects, FilterBean bean)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
default CompletableFuture<Set<T>>	DataSqlMapper.querySetAsync(SelectColumn selects, FilterNode node)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node}
default CompletableFuture<Set<T>>	DataSqlMapper.querySetAsync(SelectColumn selects, Flipper flipper, FilterBean bean)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default CompletableFuture<Set<T>>	DataSqlMapper.querySetAsync(SelectColumn selects, Flipper flipper, FilterNode node)	查询符合过滤条件记录的Set集合 等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> Sheet<T>	AbstractDataSource.querySheet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)	根据过滤对象FilterBean和翻页对象Flipper查询一页的数据， 对象只填充或排除SelectField指定的字段
protected <T> Sheet<T>	AbstractDataSqlSource.querySheet(boolean readCache, boolean needTotal, boolean distinct, Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
<T> Sheet<T>	AbstractDataSqlSource.querySheet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
<T> Sheet<T>	DataMemorySource.querySheet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
default <T> Sheet<T>	DataSource.querySheet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)	查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> Sheet<T>	DataSource.querySheet(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)	查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default <T,F extends FilterBean> Sheet<T>	DataSource.querySheet(Class<T> clazz, SelectColumn selects, PageBean<F> pageBean)	查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default Sheet<T>	DataSqlMapper.querySheet(SelectColumn selects, Flipper flipper, FilterBean bean)	查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default Sheet<T>	DataSqlMapper.querySheet(SelectColumn selects, Flipper flipper, FilterNode node)	查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default <F extends FilterBean> Sheet<T>	DataSqlMapper.querySheet(SelectColumn selects, PageBean<F> pageBean)	查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
Sheet<T>	EntityCache.querySheet(boolean needTotal, boolean distinct, SelectColumn selects, Flipper flipper, FilterNode node)
Sheet<T>	EntityCache.querySheet(SelectColumn selects, Flipper flipper, FilterNode node)
<T> CompletableFuture<Sheet<T>>	AbstractDataSource.querySheetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
protected <T> CompletableFuture<Sheet<T>>	AbstractDataSqlSource.querySheetAsync(boolean readCache, boolean needTotal, boolean distinct, Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
<T> CompletableFuture<Sheet<T>>	AbstractDataSqlSource.querySheetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
<T> CompletableFuture<Sheet<T>>	DataMemorySource.querySheetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
default <T> CompletableFuture<Sheet<T>>	DataSource.querySheetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)	查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
<T> CompletableFuture<Sheet<T>>	DataSource.querySheetAsync(Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)	查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default <T,F extends FilterBean> CompletableFuture<Sheet<T>>	DataSource.querySheetAsync(Class<T> clazz, SelectColumn selects, PageBean<F> pageBean)	查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default CompletableFuture<Sheet<T>>	DataSqlMapper.querySheetAsync(SelectColumn selects, Flipper flipper, FilterBean bean)	查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default CompletableFuture<Sheet<T>>	DataSqlMapper.querySheetAsync(SelectColumn selects, Flipper flipper, FilterNode node)	查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
default <F extends FilterBean> CompletableFuture<Sheet<T>>	DataSqlMapper.querySheetAsync(SelectColumn selects, PageBean<F> pageBean)	查询符合过滤条件记录的Sheet集合 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
protected <T> Sheet<T>	AbstractDataSqlSource.querySheetDB(EntityInfo<T> info, boolean readcache, boolean needtotal, boolean distinct, SelectColumn selects, Flipper flipper, FilterNode node)
protected <T> Sheet<T>	DataJdbcSource.querySheetDB(EntityInfo<T> info, boolean readCache, boolean needTotal, boolean distinct, SelectColumn selects, Flipper flipper, FilterNode node)
protected abstract <T> CompletableFuture<Sheet<T>>	AbstractDataSqlSource.querySheetDBAsync(EntityInfo<T> info, boolean readcache, boolean needtotal, boolean distinct, SelectColumn selects, Flipper flipper, FilterNode node, boolean inCacheLoad)
protected <T> CompletableFuture<Sheet<T>>	DataJdbcSource.querySheetDBAsync(EntityInfo<T> info, boolean readCache, boolean needTotal, boolean distinct, SelectColumn selects, Flipper flipper, FilterNode node, boolean inCacheLoad)
protected <T> int	AbstractDataSqlSource.updateCache(EntityInfo<T> info, int count, boolean needNode, T entity, FilterNode node, SelectColumn selects)
<T> DataBatch	AbstractDataSource.DefaultDataBatch.updateColumn(T entity, FilterNode node, SelectColumn selects)
<T> DataBatch	AbstractDataSource.DefaultDataBatch.updateColumn(T entity, SelectColumn selects)
<T> int	AbstractDataSqlSource.updateColumn(T entity, FilterNode node, SelectColumn selects)
<T> int	AbstractDataSqlSource.updateColumn(T entity, SelectColumn selects)
<T> DataBatch	DataBatch.updateColumn(T entity, FilterNode node, SelectColumn selects)
<T> DataBatch	DataBatch.updateColumn(T entity, SelectColumn selects)
<T> int	DataMemorySource.updateColumn(T entity, FilterNode node, SelectColumn selects)
<T> int	DataSource.updateColumn(T entity, FilterNode node, SelectColumn selects)	更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
default <T> int	DataSource.updateColumn(T entity, SelectColumn selects)	更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
default int	DataSqlMapper.updateColumn(T entity, FilterNode node, SelectColumn selects)	更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
default int	DataSqlMapper.updateColumn(T entity, SelectColumn selects)	更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
<T> CompletableFuture<Integer>	AbstractDataSqlSource.updateColumnAsync(T entity, FilterNode node, SelectColumn selects)
<T> CompletableFuture<Integer>	AbstractDataSqlSource.updateColumnAsync(T entity, SelectColumn selects)
<T> CompletableFuture<Integer>	DataMemorySource.updateColumnAsync(T entity, FilterNode node, SelectColumn selects)
<T> CompletableFuture<Integer>	DataSource.updateColumnAsync(T entity, FilterNode node, SelectColumn selects)	更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
default <T> CompletableFuture<Integer>	DataSource.updateColumnAsync(T entity, SelectColumn selects)	更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
default CompletableFuture<Integer>	DataSqlMapper.updateColumnAsync(T entity, FilterNode node, SelectColumn selects)	更新符合过滤条件记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
default CompletableFuture<Integer>	DataSqlMapper.updateColumnAsync(T entity, SelectColumn selects)	更新单个记录的指定字段 注意：Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
protected <T> AbstractDataSqlSource.UpdateSqlInfo	AbstractDataSqlSource.updateColumnSql(EntityInfo<T> info, boolean needNode, T entity, FilterNode node, SelectColumn selects)

参数类型为SelectColumn的org.redkale.source中的构造器

构造器	说明
UpdateBatchAction4(Object entity, FilterNode node, SelectColumn selects)
UpdateBatchAction4(Object entity, SelectColumn selects)

org.redkale.util中SelectColumn的使用

返回SelectColumn的org.redkale.util中的方法

修饰符和类型	方法	说明
static SelectColumn	SelectColumn.excludes(String... columns)	class中的字段名
static SelectColumn	SelectColumn.excludes(String[] cols, String... columns)	class中的字段名
static <T> SelectColumn	SelectColumn.excludes(LambdaFunction<T,?>... funcs)	class中的字段名
static SelectColumn	SelectColumn.includes(String... columns)	class中的字段名
static SelectColumn	SelectColumn.includes(String[] cols, String... columns)	class中的字段名
static <T> SelectColumn	SelectColumn.includes(LambdaFunction<T,?>... funcs)	class中的字段名