FilterNode |
FilterNode.and(FilterNode node) |
|
protected FilterNode |
FilterJoinNode.any(FilterNode node0,
boolean isOr) |
|
protected FilterNode |
FilterNode.any(FilterNode node,
boolean isOr) |
|
<T> int |
AbstractDataSqlSource.clearTable(Class<T> clazz,
FilterNode node) |
|
<T> int |
DataMemorySource.clearTable(Class<T> clazz,
FilterNode node) |
|
<T> int |
DataSource.clearTable(Class<T> clazz,
FilterNode node) |
清空表
等价SQL: TRUNCATE TABLE {table}
|
<T> CompletableFuture<Integer> |
AbstractDataSqlSource.clearTableAsync(Class<T> clazz,
FilterNode node) |
|
<T> CompletableFuture<Integer> |
DataMemorySource.clearTableAsync(Class<T> clazz,
FilterNode node) |
|
<T> CompletableFuture<Integer> |
DataSource.clearTableAsync(Class<T> clazz,
FilterNode node) |
清空表
等价SQL: TRUNCATE TABLE {table}
|
protected <T> int |
AbstractDataSqlSource.clearTableCache(EntityInfo<T> info,
FilterNode node) |
|
protected <T> int |
AbstractDataSqlSource.clearTableDB(EntityInfo<T> info,
String[] tables,
FilterNode node,
String... sqls) |
|
protected <T> int |
DataJdbcSource.clearTableDB(EntityInfo<T> info,
String[] tables,
FilterNode node,
String... sqls) |
|
protected abstract <T> CompletableFuture<Integer> |
AbstractDataSqlSource.clearTableDBAsync(EntityInfo<T> info,
String[] tables,
FilterNode node,
String... sqls) |
|
protected <T> CompletableFuture<Integer> |
DataJdbcSource.clearTableDBAsync(EntityInfo<T> info,
String[] tables,
FilterNode node,
String... sqls) |
|
protected <T> String[] |
AbstractDataSqlSource.clearTableSql(EntityInfo<T> info,
String[] tables,
FilterNode node) |
|
protected FilterNode |
FilterNode.copy(FilterNode node) |
|
protected <T> AbstractDataSqlSource.PageCountSql |
AbstractDataSqlSource.createPageCountSql(EntityInfo<T> info,
boolean readCache,
boolean needTotal,
boolean distinct,
SelectColumn selects,
String[] tables,
Flipper flipper,
FilterNode node) |
|
protected <T> Predicate<T> |
AbstractDataSource.createPredicate(FilterNode node,
EntityCache<T> cache) |
生成过滤函数
|
protected <T> CharSequence |
AbstractDataSqlSource.createSQLExpress(FilterNode node,
EntityInfo<T> info,
Map<Class,String> joinTabalis) |
|
protected <T> CharSequence |
AbstractDataSqlSource.createSQLJoin(FilterNode node,
Function<Class,EntityInfo> func,
boolean update,
Map<Class,String> joinTabalis,
Set<String> haset,
EntityInfo<T> info) |
|
<T> DataBatch |
AbstractDataSource.DefaultDataBatch.delete(Class<T> clazz,
FilterNode node) |
|
<T> DataBatch |
AbstractDataSource.DefaultDataBatch.delete(Class<T> clazz,
FilterNode node,
Flipper flipper) |
|
<T> int |
AbstractDataSqlSource.delete(Class<T> clazz,
FilterNode node) |
|
<T> int |
AbstractDataSqlSource.delete(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> DataBatch |
DataBatch.delete(Class<T> clazz,
FilterNode node) |
|
<T> DataBatch |
DataBatch.delete(Class<T> clazz,
FilterNode node,
Flipper flipper) |
|
<T> int |
DataMemorySource.delete(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
default <T> int |
DataSource.delete(Class<T> clazz,
FilterNode node) |
删除符合过滤条件的记录
等价SQL: DELETE FROM {table} WHERE {filter node}
|
<T> int |
DataSource.delete(Class<T> clazz,
Flipper flipper,
FilterNode node) |
删除符合过滤条件且指定最大影响条数的记录
Flipper中offset字段将被忽略
等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
Serializable[] |
EntityCache.delete(Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<Integer> |
AbstractDataSqlSource.deleteAsync(Class<T> clazz,
FilterNode node) |
|
<T> CompletableFuture<Integer> |
AbstractDataSqlSource.deleteAsync(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<Integer> |
DataMemorySource.deleteAsync(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
default <T> CompletableFuture<Integer> |
DataSource.deleteAsync(Class<T> clazz,
FilterNode node) |
删除符合过滤条件的记录
等价SQL: DELETE FROM {table} WHERE {filter node}
|
<T> CompletableFuture<Integer> |
DataSource.deleteAsync(Class<T> clazz,
Flipper flipper,
FilterNode node) |
删除符合过滤条件且指定最大影响条数的记录
Flipper中offset字段将被忽略
等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
protected <T> int |
AbstractDataSqlSource.deleteCache(EntityInfo<T> info,
int count,
Flipper flipper,
FilterNode node) |
|
protected <T> int |
AbstractDataSqlSource.deleteDB(EntityInfo<T> info,
String[] tables,
Flipper flipper,
FilterNode node,
Map<String,List<Serializable>> pkmap,
String... sqls) |
|
protected <T> int |
DataJdbcSource.deleteDB(EntityInfo<T> info,
String[] tables,
Flipper flipper,
FilterNode node,
Map<String,List<Serializable>> pkmap,
String... sqls) |
|
protected abstract <T> CompletableFuture<Integer> |
AbstractDataSqlSource.deleteDBAsync(EntityInfo<T> info,
String[] tables,
Flipper flipper,
FilterNode node,
Map<String,List<Serializable>> pkmap,
String... sqls) |
|
protected <T> CompletableFuture<Integer> |
DataJdbcSource.deleteDBAsync(EntityInfo<T> info,
String[] tables,
Flipper flipper,
FilterNode node,
Map<String,List<Serializable>> pkmap,
String... sqls) |
|
protected <T> String[] |
AbstractDataSqlSource.deleteSql(EntityInfo<T> info,
String[] tables,
Flipper flipper,
FilterNode node) |
|
<T> int |
AbstractDataSqlSource.dropTable(Class<T> clazz,
FilterNode node) |
|
<T> int |
DataMemorySource.dropTable(Class<T> clazz,
FilterNode node) |
|
<T> int |
DataSource.dropTable(Class<T> clazz,
FilterNode node) |
删除表
等价SQL: DROP TABLE {table}
|
<T> CompletableFuture<Integer> |
AbstractDataSqlSource.dropTableAsync(Class<T> clazz,
FilterNode node) |
|
<T> CompletableFuture<Integer> |
DataMemorySource.dropTableAsync(Class<T> clazz,
FilterNode node) |
|
<T> CompletableFuture<Integer> |
DataSource.dropTableAsync(Class<T> clazz,
FilterNode node) |
删除表
等价SQL: DROP TABLE {table}
|
protected <T> int |
AbstractDataSqlSource.dropTableCache(EntityInfo<T> info,
FilterNode node) |
|
protected <T> int |
AbstractDataSqlSource.dropTableDB(EntityInfo<T> info,
String[] tables,
FilterNode node,
String... sqls) |
|
protected <T> int |
DataJdbcSource.dropTableDB(EntityInfo<T> info,
String[] tables,
FilterNode node,
String... sqls) |
|
protected abstract <T> CompletableFuture<Integer> |
AbstractDataSqlSource.dropTableDBAsync(EntityInfo<T> info,
String[] tables,
FilterNode node,
String... sqls) |
|
protected <T> CompletableFuture<Integer> |
DataJdbcSource.dropTableDBAsync(EntityInfo<T> info,
String[] tables,
FilterNode node,
String... sqls) |
|
protected <T> String[] |
AbstractDataSqlSource.dropTableSql(EntityInfo<T> info,
String[] tables,
FilterNode node) |
|
<T> boolean |
AbstractDataSqlSource.exists(Class<T> clazz,
FilterNode node) |
|
<T> boolean |
DataMemorySource.exists(Class<T> clazz,
FilterNode node) |
|
<T> boolean |
DataSource.exists(Class<T> clazz,
FilterNode node) |
判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
|
default boolean |
DataSqlMapper.exists(FilterNode node) |
判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
|
boolean |
EntityCache.exists(FilterNode node) |
|
<T> CompletableFuture<Boolean> |
AbstractDataSqlSource.existsAsync(Class<T> clazz,
FilterNode node) |
|
<T> CompletableFuture<Boolean> |
DataMemorySource.existsAsync(Class<T> clazz,
FilterNode node) |
|
<T> CompletableFuture<Boolean> |
DataSource.existsAsync(Class<T> clazz,
FilterNode node) |
判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
|
default CompletableFuture<Boolean> |
DataSqlMapper.existsAsync(FilterNode node) |
判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node}
|
protected <T> boolean |
AbstractDataSqlSource.existsDB(EntityInfo<T> info,
String[] tables,
String sql,
boolean onlypk,
Serializable pk,
FilterNode node) |
|
protected <T> boolean |
DataJdbcSource.existsDB(EntityInfo<T> info,
String[] tables,
String sql,
boolean onlypk,
Serializable pk,
FilterNode node) |
|
protected abstract <T> CompletableFuture<Boolean> |
AbstractDataSqlSource.existsDBAsync(EntityInfo<T> info,
String[] tables,
String sql,
boolean onlypk,
Serializable pk,
FilterNode node) |
|
protected <T> CompletableFuture<Boolean> |
DataJdbcSource.existsDBAsync(EntityInfo<T> info,
String[] tables,
String sql,
boolean onlypk,
Serializable pk,
FilterNode node) |
|
protected <T> String |
AbstractDataSqlSource.existsSql(EntityInfo<T> info,
String[] tables,
FilterNode node) |
|
<T> T |
AbstractDataSource.find(Class<T> clazz,
FilterNode node) |
|
<T> T |
AbstractDataSqlSource.find(Class<T> clazz,
SelectColumn selects,
FilterNode node) |
|
<T> T |
DataMemorySource.find(Class<T> clazz,
SelectColumn selects,
FilterNode node) |
|
default <T> T |
DataSource.find(Class<T> clazz,
FilterNode node) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter node}
|
<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(FilterNode node) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter node}
|
default T |
DataSqlMapper.find(SelectColumn selects,
FilterNode node) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
|
T |
EntityCache.find(SelectColumn selects,
FilterNode node) |
|
<T> CompletableFuture<T> |
AbstractDataSource.findAsync(Class<T> clazz,
FilterNode node) |
|
<T> CompletableFuture<T> |
AbstractDataSqlSource.findAsync(Class<T> clazz,
SelectColumn selects,
FilterNode node) |
|
<T> CompletableFuture<T> |
DataMemorySource.findAsync(Class<T> clazz,
SelectColumn selects,
FilterNode node) |
|
default <T> CompletableFuture<T> |
DataSource.findAsync(Class<T> clazz,
FilterNode node) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter node}
|
<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(FilterNode node) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter node}
|
default CompletableFuture<T> |
DataSqlMapper.findAsync(SelectColumn selects,
FilterNode node) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
|
<T> Serializable |
AbstractDataSource.findColumn(Class<T> clazz,
String column,
FilterNode node) |
|
<T> Serializable |
AbstractDataSqlSource.findColumn(Class<T> clazz,
String column,
Serializable defValue,
FilterNode node) |
|
<T> Serializable |
DataMemorySource.findColumn(Class<T> clazz,
String column,
Serializable defValue,
FilterNode node) |
|
<T> Serializable |
DataSource.findColumn(Class<T> clazz,
String column,
Serializable defValue,
FilterNode node) |
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter node}
|
default <T> Serializable |
DataSource.findColumn(Class<T> clazz,
String column,
FilterNode node) |
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter node}
|
default Serializable |
DataSqlMapper.findColumn(String column,
Serializable defValue,
FilterNode node) |
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter node}
|
default Serializable |
DataSqlMapper.findColumn(String column,
FilterNode node) |
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter node}
|
Serializable |
EntityCache.findColumn(String column,
Serializable defValue,
FilterNode node) |
|
<T> CompletableFuture<Serializable> |
AbstractDataSource.findColumnAsync(Class<T> clazz,
String column,
FilterNode node) |
|
<T> CompletableFuture<Serializable> |
AbstractDataSqlSource.findColumnAsync(Class<T> clazz,
String column,
Serializable defValue,
FilterNode node) |
|
<T> CompletableFuture<Serializable> |
DataMemorySource.findColumnAsync(Class<T> clazz,
String column,
Serializable defValue,
FilterNode node) |
|
<T> CompletableFuture<Serializable> |
DataSource.findColumnAsync(Class<T> clazz,
String column,
Serializable defValue,
FilterNode node) |
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter node}
|
default <T> CompletableFuture<Serializable> |
DataSource.findColumnAsync(Class<T> clazz,
String column,
FilterNode node) |
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter node}
|
default CompletableFuture<Serializable> |
DataSqlMapper.findColumnAsync(String column,
Serializable defValue,
FilterNode node) |
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter node}
|
default CompletableFuture<Serializable> |
DataSqlMapper.findColumnAsync(String column,
FilterNode node) |
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter node}
|
protected <T> Serializable |
AbstractDataSqlSource.findColumnDB(EntityInfo<T> info,
String[] tables,
String sql,
boolean onlypk,
String column,
Serializable defValue,
Serializable pk,
FilterNode node) |
|
protected <T> Serializable |
DataJdbcSource.findColumnDB(EntityInfo<T> info,
String[] tables,
String sql,
boolean onlypk,
String column,
Serializable defValue,
Serializable pk,
FilterNode node) |
|
protected abstract <T> CompletableFuture<Serializable> |
AbstractDataSqlSource.findColumnDBAsync(EntityInfo<T> info,
String[] tables,
String sql,
boolean onlypk,
String column,
Serializable defValue,
Serializable pk,
FilterNode node) |
|
protected <T> CompletableFuture<Serializable> |
DataJdbcSource.findColumnDBAsync(EntityInfo<T> info,
String[] tables,
String sql,
boolean onlypk,
String column,
Serializable defValue,
Serializable pk,
FilterNode node) |
|
protected <T> String |
AbstractDataSqlSource.findColumnSql(EntityInfo<T> info,
String[] tables,
String column,
Serializable defValue,
FilterNode 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 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) |
|
protected <T> String |
AbstractDataSqlSource.findSql(EntityInfo<T> info,
String[] tables,
SelectColumn selects,
FilterNode node) |
|
protected Map<Class,String> |
AbstractDataSource.getJoinTabalis(FilterNode node) |
根据过滤条件生成关联表与别名的映射关系
|
<N extends Number>
Map<String,N> |
AbstractDataSqlSource.getNumberMap(Class entityClass,
FilterNode node,
FilterFuncColumn... columns) |
|
<N extends Number>
Map<String,N> |
DataMemorySource.getNumberMap(Class entityClass,
FilterNode node,
FilterFuncColumn... columns) |
|
<N extends Number>
Map<String,N> |
DataSource.getNumberMap(Class entityClass,
FilterNode node,
FilterFuncColumn... columns) |
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node}
如 getNumberMapAsync(User.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT
MAX(createtime) FROM {table}
|
default <N extends Number>
Map<String,N> |
DataSqlMapper.getNumberMap(FilterNode node,
FilterFuncColumn... columns) |
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node}
如 getNumberMapAsync(User.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT
MAX(createtime) FROM {table}
|
<N extends Number>
CompletableFuture<Map<String,N>> |
AbstractDataSqlSource.getNumberMapAsync(Class entityClass,
FilterNode node,
FilterFuncColumn... columns) |
|
<N extends Number>
CompletableFuture<Map<String,N>> |
DataMemorySource.getNumberMapAsync(Class entityClass,
FilterNode node,
FilterFuncColumn... columns) |
|
<N extends Number>
CompletableFuture<Map<String,N>> |
DataSource.getNumberMapAsync(Class entityClass,
FilterNode node,
FilterFuncColumn... columns) |
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node}
如 getNumberMapAsync(User.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT
MAX(createtime) FROM {table}
|
default <N extends Number>
CompletableFuture<Map<String,N>> |
DataSqlMapper.getNumberMapAsync(FilterNode node,
FilterFuncColumn... columns) |
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node}
如 getNumberMapAsync(User.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT
MAX(createtime) FROM {table}
|
protected <T,N extends Number>
Map<String,N> |
AbstractDataSqlSource.getNumberMapDB(EntityInfo<T> info,
String[] tables,
String sql,
FilterNode node,
FilterFuncColumn... columns) |
|
protected <T,N extends Number>
Map<String,N> |
DataJdbcSource.getNumberMapDB(EntityInfo<T> info,
String[] tables,
String sql,
FilterNode node,
FilterFuncColumn... columns) |
|
protected abstract <T,N extends Number>
CompletableFuture<Map<String,N>> |
AbstractDataSqlSource.getNumberMapDBAsync(EntityInfo<T> info,
String[] tables,
String sql,
FilterNode node,
FilterFuncColumn... columns) |
|
protected <T,N extends Number>
CompletableFuture<Map<String,N>> |
DataJdbcSource.getNumberMapDBAsync(EntityInfo<T> info,
String[] tables,
String sql,
FilterNode node,
FilterFuncColumn... columns) |
|
protected <T> String |
AbstractDataSqlSource.getNumberMapSql(EntityInfo<T> info,
String[] tables,
FilterNode node,
FilterFuncColumn... columns) |
|
Number |
AbstractDataSource.getNumberResult(Class entityClass,
FilterFunc func,
String column,
FilterNode node) |
|
Number |
AbstractDataSqlSource.getNumberResult(Class entityClass,
FilterFunc func,
Number defVal,
String column,
FilterNode node) |
|
Number |
DataMemorySource.getNumberResult(Class entityClass,
FilterFunc func,
Number defVal,
String column,
FilterNode node) |
|
Number |
DataSource.getNumberResult(Class entityClass,
FilterFunc func,
Number defVal,
String column,
FilterNode node) |
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime)
FROM {table}
|
default Number |
DataSource.getNumberResult(Class entityClass,
FilterFunc func,
String column,
FilterNode node) |
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime)
FROM {table}
|
default Number |
DataSqlMapper.getNumberResult(FilterFunc func,
Number defVal,
String column,
FilterNode node) |
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime)
FROM {table}
|
default Number |
DataSqlMapper.getNumberResult(FilterFunc func,
String column,
FilterNode node) |
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime)
FROM {table}
|
Number |
EntityCache.getNumberResult(FilterFunc func,
Number defResult,
String column,
FilterNode node) |
|
CompletableFuture<Number> |
AbstractDataSource.getNumberResultAsync(Class entityClass,
FilterFunc func,
String column,
FilterNode node) |
|
CompletableFuture<Number> |
AbstractDataSqlSource.getNumberResultAsync(Class entityClass,
FilterFunc func,
Number defVal,
String column,
FilterNode node) |
|
CompletableFuture<Number> |
DataMemorySource.getNumberResultAsync(Class entityClass,
FilterFunc func,
Number defVal,
String column,
FilterNode node) |
|
CompletableFuture<Number> |
DataSource.getNumberResultAsync(Class entityClass,
FilterFunc func,
Number defVal,
String column,
FilterNode node) |
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime)
FROM {table}
|
default CompletableFuture<Number> |
DataSource.getNumberResultAsync(Class entityClass,
FilterFunc func,
String column,
FilterNode node) |
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime)
FROM {table}
|
default CompletableFuture<Number> |
DataSqlMapper.getNumberResultAsync(FilterFunc func,
Number defVal,
String column,
FilterNode node) |
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime)
FROM {table}
|
default CompletableFuture<Number> |
DataSqlMapper.getNumberResultAsync(FilterFunc func,
String column,
FilterNode node) |
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime)
FROM {table}
|
protected <T> Number |
AbstractDataSqlSource.getNumberResultDB(EntityInfo<T> info,
String[] tables,
String sql,
FilterFunc func,
Number defVal,
String column,
FilterNode node) |
|
protected <T> Number |
DataJdbcSource.getNumberResultDB(EntityInfo<T> info,
String[] tables,
String sql,
FilterFunc func,
Number defVal,
String column,
FilterNode node) |
|
protected abstract <T> CompletableFuture<Number> |
AbstractDataSqlSource.getNumberResultDBAsync(EntityInfo<T> info,
String[] tables,
String sql,
FilterFunc func,
Number defVal,
String column,
FilterNode node) |
|
protected <T> CompletableFuture<Number> |
DataJdbcSource.getNumberResultDBAsync(EntityInfo<T> info,
String[] tables,
String sql,
FilterFunc func,
Number defVal,
String column,
FilterNode node) |
|
protected <T> String |
AbstractDataSqlSource.getNumberResultSql(EntityInfo<T> info,
Class entityClass,
String[] tables,
FilterFunc func,
Number defVal,
String column,
FilterNode node) |
|
default String |
DistributeTableStrategy.getSource(FilterNode node) |
获取DataSource资源名，为null表示没有分布物理库
查询、修改、删除对象（DataSource.find、DataSource.query、DataSource.delete、DataSource.update）时调用本方法
|
String |
EntityInfo.getSource(FilterNode node) |
获取DataSource资源名，为null表示没有分布物理库
|
default String |
DistributeTableStrategy.getTable(String table,
FilterNode node) |
已过时。
|
String[] |
DistributeTableStrategy.getTables(String table,
FilterNode node) |
获取对象的表名
查询、修改、删除对象（DataSource.find、DataSource.query、DataSource.delete、DataSource.update）时调用本方法获取表名
|
String[] |
EntityInfo.getTables(FilterNode node) |
根据过滤条件获取Entity的表名
|
protected boolean |
AbstractDataSource.isCacheUseable(FilterNode node,
Function<Class,EntityInfo> entityApplyer) |
是否可以使用缓存，一般包含关联查询就不使用缓存
|
FilterNode |
FilterNode.or(FilterNode node) |
|
<T,V extends Serializable>
List<V> |
AbstractDataSource.queryColumnList(String selectedColumn,
Class<T> clazz,
FilterNode node) |
|
<T,V extends Serializable>
List<V> |
AbstractDataSqlSource.queryColumnList(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
List<V> |
DataMemorySource.queryColumnList(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
default <T,V extends Serializable>
List<V> |
DataSource.queryColumnList(String selectedColumn,
Class<T> clazz,
FilterNode node) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
|
<T,V extends Serializable>
List<V> |
DataSource.queryColumnList(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <V extends Serializable>
List<V> |
DataSqlMapper.queryColumnList(String selectedColumn,
FilterNode node) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
|
default <V extends Serializable>
List<V> |
DataSqlMapper.queryColumnList(String selectedColumn,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T,V extends Serializable>
CompletableFuture<List<V>> |
AbstractDataSource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
FilterNode node) |
|
<T,V extends Serializable>
CompletableFuture<List<V>> |
AbstractDataSqlSource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
CompletableFuture<List<V>> |
DataMemorySource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
default <T,V extends Serializable>
CompletableFuture<List<V>> |
DataSource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
FilterNode node) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
|
<T,V extends Serializable>
CompletableFuture<List<V>> |
DataSource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <V extends Serializable>
CompletableFuture<List<V>> |
DataSqlMapper.queryColumnListAsync(String selectedColumn,
FilterNode node) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node}
|
default <V extends Serializable>
CompletableFuture<List<V>> |
DataSqlMapper.queryColumnListAsync(String selectedColumn,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T,K extends Serializable,N extends Number>
Map<K,N> |
AbstractDataSqlSource.queryColumnMap(Class<T> entityClass,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
|
<T,K extends Serializable,N extends Number>
Map<K[],N[]> |
AbstractDataSqlSource.queryColumnMap(Class<T> entityClass,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
|
<T,K extends Serializable,N extends Number>
Map<K,N[]> |
AbstractDataSqlSource.queryColumnMap(Class<T> entityClass,
ColumnNode[] funcNodes,
String groupByColumn,
FilterNode node) |
|
<T,K extends Serializable,N extends Number>
Map<K,N> |
DataMemorySource.queryColumnMap(Class<T> entityClass,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
|
<T,K extends Serializable,N extends Number>
Map<K[],N[]> |
DataMemorySource.queryColumnMap(Class<T> entityClass,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
|
<T,K extends Serializable,N extends Number>
Map<K,N[]> |
DataMemorySource.queryColumnMap(Class<T> entityClass,
ColumnNode[] funcNodes,
String groupByColumn,
FilterNode node) |
|
<T,K extends Serializable,N extends Number>
Map<K,N> |
DataSource.queryColumnMap(Class<T> entityClass,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn}
如 queryColumnMapAsync(User.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name,
MAX(createtime) FROM user GROUP BY name
|
<T,K extends Serializable,N extends Number>
Map<K[],N[]> |
DataSource.queryColumnMap(Class<T> entityClass,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1},
{col2}
如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100),
ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterNode)null)
等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
|
<T,K extends Serializable,N extends Number>
Map<K,N[]> |
DataSource.queryColumnMap(Class<T> entityClass,
ColumnNode[] funcNodes,
String groupByColumn,
FilterNode node) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1}
如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100),
ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterNode)null) 等价于: SELECT targetid,
SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
|
default <K extends Serializable,N extends Number>
Map<K,N> |
DataSqlMapper.queryColumnMap(String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn}
如 queryColumnMapAsync(User.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name,
MAX(createtime) FROM user GROUP BY name
|
default <K extends Serializable,N extends Number>
Map<K[],N[]> |
DataSqlMapper.queryColumnMap(ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1},
{col2}
如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100),
ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterNode)null)
等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
|
default <K extends Serializable,N extends Number>
Map<K,N[]> |
DataSqlMapper.queryColumnMap(ColumnNode[] funcNodes,
String groupByColumn,
FilterNode node) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1}
如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100),
ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterNode)null) 等价于: SELECT targetid,
SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
|
Map<Serializable,Number> |
EntityCache.queryColumnMap(String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
|
Map<Serializable[],Number[]> |
EntityCache.queryColumnMap(ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
|
<T,K extends Serializable,N extends Number>
CompletableFuture<Map<K,N>> |
AbstractDataSqlSource.queryColumnMapAsync(Class<T> entityClass,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
|
<T,K extends Serializable,N extends Number>
CompletableFuture<Map<K[],N[]>> |
AbstractDataSqlSource.queryColumnMapAsync(Class<T> entityClass,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
|
<T,K extends Serializable,N extends Number>
CompletableFuture<Map<K,N[]>> |
AbstractDataSqlSource.queryColumnMapAsync(Class<T> entityClass,
ColumnNode[] funcNodes,
String groupByColumn,
FilterNode node) |
|
<T,K extends Serializable,N extends Number>
CompletableFuture<Map<K,N>> |
DataMemorySource.queryColumnMapAsync(Class<T> entityClass,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
|
<T,K extends Serializable,N extends Number>
CompletableFuture<Map<K[],N[]>> |
DataMemorySource.queryColumnMapAsync(Class<T> entityClass,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
|
<T,K extends Serializable,N extends Number>
CompletableFuture<Map<K,N[]>> |
DataMemorySource.queryColumnMapAsync(Class<T> entityClass,
ColumnNode[] funcNodes,
String groupByColumn,
FilterNode node) |
|
<T,K extends Serializable,N extends Number>
CompletableFuture<Map<K,N>> |
DataSource.queryColumnMapAsync(Class<T> entityClass,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn}
如 queryColumnMapAsync(User.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name,
MAX(createtime) FROM user GROUP BY name
|
<T,K extends Serializable,N extends Number>
CompletableFuture<Map<K[],N[]>> |
DataSource.queryColumnMapAsync(Class<T> entityClass,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1},
{col2}
如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100),
ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterNode)null)
等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
|
<T,K extends Serializable,N extends Number>
CompletableFuture<Map<K,N[]>> |
DataSource.queryColumnMapAsync(Class<T> entityClass,
ColumnNode[] funcNodes,
String groupByColumn,
FilterNode node) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1}
如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100),
ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterNode)null) 等价于: SELECT targetid,
SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
|
default <K extends Serializable,N extends Number>
CompletableFuture<Map<K,N>> |
DataSqlMapper.queryColumnMapAsync(String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn}
如 queryColumnMapAsync(User.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name,
MAX(createtime) FROM user GROUP BY name
|
default <K extends Serializable,N extends Number>
CompletableFuture<Map<K[],N[]>> |
DataSqlMapper.queryColumnMapAsync(ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1},
{col2}
如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100),
ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterNode)null)
等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
|
default <K extends Serializable,N extends Number>
CompletableFuture<Map<K,N[]>> |
DataSqlMapper.queryColumnMapAsync(ColumnNode[] funcNodes,
String groupByColumn,
FilterNode node) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1}
如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100),
ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterNode)null) 等价于: SELECT targetid,
SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
|
protected <T,K extends Serializable,N extends Number>
Map<K,N> |
AbstractDataSqlSource.queryColumnMapDB(EntityInfo<T> info,
String[] tables,
String sql,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
|
protected <T,K extends Serializable,N extends Number>
Map<K[],N[]> |
AbstractDataSqlSource.queryColumnMapDB(EntityInfo<T> info,
String[] tables,
String sql,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
|
protected <T,K extends Serializable,N extends Number>
Map<K,N> |
DataJdbcSource.queryColumnMapDB(EntityInfo<T> info,
String[] tables,
String sql,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
|
protected <T,K extends Serializable,N extends Number>
Map<K[],N[]> |
DataJdbcSource.queryColumnMapDB(EntityInfo<T> info,
String[] tables,
String sql,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
|
protected abstract <T,K extends Serializable,N extends Number>
CompletableFuture<Map<K,N>> |
AbstractDataSqlSource.queryColumnMapDBAsync(EntityInfo<T> info,
String[] tables,
String sql,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
|
protected abstract <T,K extends Serializable,N extends Number>
CompletableFuture<Map<K[],N[]>> |
AbstractDataSqlSource.queryColumnMapDBAsync(EntityInfo<T> info,
String[] tables,
String sql,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
|
protected <T,K extends Serializable,N extends Number>
CompletableFuture<Map<K,N>> |
DataJdbcSource.queryColumnMapDBAsync(EntityInfo<T> info,
String[] tables,
String sql,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
|
protected <T,K extends Serializable,N extends Number>
CompletableFuture<Map<K[],N[]>> |
DataJdbcSource.queryColumnMapDBAsync(EntityInfo<T> info,
String[] tables,
String sql,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
|
protected <T> String |
AbstractDataSqlSource.queryColumnMapSql(EntityInfo<T> info,
String[] tables,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterNode node) |
|
protected <T> String |
AbstractDataSqlSource.queryColumnMapSql(EntityInfo<T> info,
String[] tables,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterNode node) |
|
<T,V extends Serializable>
Set<V> |
AbstractDataSource.queryColumnSet(String selectedColumn,
Class<T> clazz,
FilterNode node) |
|
<T,V extends Serializable>
Set<V> |
AbstractDataSqlSource.queryColumnSet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
Set<V> |
DataMemorySource.queryColumnSet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
default <T,V extends Serializable>
Set<V> |
DataSource.queryColumnSet(String selectedColumn,
Class<T> clazz,
FilterNode node) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node}
|
<T,V extends Serializable>
Set<V> |
DataSource.queryColumnSet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT
{flipper.limit}
|
default <V extends Serializable>
Set<V> |
DataSqlMapper.queryColumnSet(String selectedColumn,
FilterNode node) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node}
|
default <V extends Serializable>
Set<V> |
DataSqlMapper.queryColumnSet(String selectedColumn,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT
{flipper.limit}
|
<T,V extends Serializable>
CompletableFuture<Set<V>> |
AbstractDataSource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
FilterNode node) |
|
<T,V extends Serializable>
CompletableFuture<Set<V>> |
AbstractDataSqlSource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
CompletableFuture<Set<V>> |
DataMemorySource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
default <T,V extends Serializable>
CompletableFuture<Set<V>> |
DataSource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
FilterNode node) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node}
|
<T,V extends Serializable>
CompletableFuture<Set<V>> |
DataSource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT
{flipper.limit}
|
default <V extends Serializable>
CompletableFuture<Set<V>> |
DataSqlMapper.queryColumnSetAsync(String selectedColumn,
FilterNode node) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node}
|
default <V extends Serializable>
CompletableFuture<Set<V>> |
DataSqlMapper.queryColumnSetAsync(String selectedColumn,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT
{flipper.limit}
|
<T,V extends Serializable>
Sheet<V> |
AbstractDataSqlSource.queryColumnSheet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
Sheet<V> |
DataMemorySource.queryColumnSheet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
Sheet<V> |
DataSource.queryColumnSheet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <V extends Serializable>
Sheet<V> |
DataSqlMapper.queryColumnSheet(String selectedColumn,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T,V extends Serializable>
CompletableFuture<Sheet<V>> |
AbstractDataSqlSource.queryColumnSheetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
CompletableFuture<Sheet<V>> |
DataMemorySource.queryColumnSheetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
CompletableFuture<Sheet<V>> |
DataSource.queryColumnSheetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <V extends Serializable>
CompletableFuture<Sheet<V>> |
DataSqlMapper.queryColumnSheetAsync(String selectedColumn,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T> List<T> |
AbstractDataSource.queryList(Class<T> clazz,
FilterNode node) |
|
<T> List<T> |
AbstractDataSource.queryList(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> List<T> |
AbstractDataSource.queryList(Class<T> clazz,
SelectColumn selects,
FilterNode node) |
|
<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,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node}
|
default <T> List<T> |
DataSource.queryList(Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <T> List<T> |
DataSource.queryList(Class<T> clazz,
SelectColumn selects,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
|
<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(FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node}
|
default List<T> |
DataSqlMapper.queryList(Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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,
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,
FilterNode node) |
|
<T> CompletableFuture<List<T>> |
AbstractDataSource.queryListAsync(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<List<T>> |
AbstractDataSource.queryListAsync(Class<T> clazz,
SelectColumn selects,
FilterNode node) |
|
<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,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node}
|
default <T> CompletableFuture<List<T>> |
DataSource.queryListAsync(Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <T> CompletableFuture<List<T>> |
DataSource.queryListAsync(Class<T> clazz,
SelectColumn selects,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
|
<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(FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node}
|
default CompletableFuture<List<T>> |
DataSqlMapper.queryListAsync(Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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,
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,
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> |
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,
FilterNode node) |
|
default <K extends Serializable,T>
Map<K,T> |
DataSource.queryMap(Class<T> clazz,
FilterNode node) |
查询符合过滤条件记录的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(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,
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,
FilterNode node) |
|
<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,
FilterNode node) |
|
default <K extends Serializable,T>
CompletableFuture<Map<K,T>> |
DataSource.queryMapAsync(Class<T> clazz,
FilterNode node) |
查询符合过滤条件记录的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(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,
FilterNode node) |
查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
等价SQL: SELECT * FROM {table} WHERE {filter node}
|
<T> Set<T> |
AbstractDataSource.querySet(Class<T> clazz,
FilterNode node) |
|
<T> Set<T> |
AbstractDataSource.querySet(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> Set<T> |
AbstractDataSource.querySet(Class<T> clazz,
SelectColumn selects,
FilterNode node) |
|
<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,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node}
|
default <T> Set<T> |
DataSource.querySet(Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <T> Set<T> |
DataSource.querySet(Class<T> clazz,
SelectColumn selects,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node}
|
<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(FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node}
|
default Set<T> |
DataSqlMapper.querySet(Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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,
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,
FilterNode node) |
|
<T> CompletableFuture<Set<T>> |
AbstractDataSource.querySetAsync(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<Set<T>> |
AbstractDataSource.querySetAsync(Class<T> clazz,
SelectColumn selects,
FilterNode node) |
|
<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,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node}
|
default <T> CompletableFuture<Set<T>> |
DataSource.querySetAsync(Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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}
|
<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(FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node}
|
default CompletableFuture<Set<T>> |
DataSqlMapper.querySetAsync(Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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,
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,
Flipper flipper,
FilterNode node) |
|
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,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter node} 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 Sheet<T> |
DataSqlMapper.querySheet(Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter node} 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}
|
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,
Flipper flipper,
FilterNode node) |
|
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,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter node} 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 CompletableFuture<Sheet<T>> |
DataSqlMapper.querySheetAsync(Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter node} 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}
|
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) |
|
void |
FilterNode.setNodes(FilterNode[] nodes) |
|
<V> T[] |
EntityCache.update(Attribute<T,V> attr,
V fieldValue,
FilterNode node) |
|
T[] |
EntityCache.update(T entity,
Collection<Attribute<T,Serializable>> attrs,
FilterNode node) |
|
protected <T> int |
AbstractDataSqlSource.updateCache(EntityInfo<T> info,
int count,
boolean needNode,
T entity,
FilterNode node,
SelectColumn selects) |
|
protected <T> int |
AbstractDataSqlSource.updateCache(EntityInfo<T> info,
int count,
String column,
Serializable colval,
FilterNode node) |
|
protected <T> int |
AbstractDataSqlSource.updateCache(EntityInfo<T> info,
int count,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> DataBatch |
AbstractDataSource.DefaultDataBatch.updateColumn(Class<T> clazz,
FilterNode node,
String column,
Serializable value) |
|
<T> DataBatch |
AbstractDataSource.DefaultDataBatch.updateColumn(Class<T> clazz,
FilterNode node,
ColumnValue... values) |
|
<T> DataBatch |
AbstractDataSource.DefaultDataBatch.updateColumn(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> DataBatch |
AbstractDataSource.DefaultDataBatch.updateColumn(T entity,
FilterNode node,
String... columns) |
|
<T> DataBatch |
AbstractDataSource.DefaultDataBatch.updateColumn(T entity,
FilterNode node,
SelectColumn selects) |
|
<T> int |
AbstractDataSource.updateColumn(Class<T> clazz,
FilterNode node,
ColumnValue... values) |
根据主键值更新对象的多个column对应的值， 必须是Entity Class
|
<T> int |
AbstractDataSource.updateColumn(T entity,
FilterNode node,
String... columns) |
|
<T> int |
AbstractDataSqlSource.updateColumn(Class<T> clazz,
String column,
Serializable colval,
FilterNode node) |
根据主键值更新对象的column对应的值， 必须是Entity Class
|
<T> int |
AbstractDataSqlSource.updateColumn(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> int |
AbstractDataSqlSource.updateColumn(T entity,
FilterNode node,
SelectColumn selects) |
|
<T> DataBatch |
DataBatch.updateColumn(Class<T> clazz,
FilterNode node,
String column,
Serializable value) |
|
default <T> DataBatch |
DataBatch.updateColumn(Class<T> clazz,
FilterNode node,
ColumnValue... values) |
|
<T> DataBatch |
DataBatch.updateColumn(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> DataBatch |
DataBatch.updateColumn(T entity,
FilterNode node,
String... columns) |
|
default <T> DataBatch |
DataBatch.updateColumn(T entity,
FilterNode node,
LambdaFunction<T,?>... funcs) |
|
<T> DataBatch |
DataBatch.updateColumn(T entity,
FilterNode node,
SelectColumn selects) |
|
<T> int |
DataMemorySource.updateColumn(Class<T> clazz,
String column,
Serializable value,
FilterNode node) |
|
<T> int |
DataMemorySource.updateColumn(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> int |
DataMemorySource.updateColumn(T entity,
FilterNode node,
SelectColumn selects) |
|
<T> int |
DataSource.updateColumn(Class<T> clazz,
String column,
Serializable value,
FilterNode node) |
更新符合过滤条件记录的单个字段
注意：即使字段标记为@Column(updatable=false)也会被更新
等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
|
default <T> int |
DataSource.updateColumn(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}
|
default <T> int |
DataSource.updateColumn(Class<T> clazz,
FilterNode node,
ColumnValues values) |
更新符合过滤条件记录的部分字段
字段赋值操作选项见 ColumnExpress
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node}
|
<T> int |
DataSource.updateColumn(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node} ORDER BY {flipper.sort}
|
default <T> int |
DataSource.updateColumn(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValues values) |
更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node} ORDER BY {flipper.sort}
|
default <T,V extends Serializable>
int |
DataSource.updateColumn(Class<T> clazz,
LambdaSupplier<V> func,
FilterNode node) |
更新符合过滤条件记录的单个字段
注意：即使字段标记为@Column(updatable=false)也会被更新
等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
|
<T> int |
DataSource.updateColumn(T entity,
FilterNode node,
String... columns) |
更新符合过滤条件记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ···
WHERE {filter node}
|
default <T> int |
DataSource.updateColumn(T entity,
FilterNode node,
LambdaFunction<T,?>... funcs) |
更新符合过滤条件记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ···
WHERE {filter node}
|
<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 int |
DataSqlMapper.updateColumn(String column,
Serializable value,
FilterNode node) |
更新符合过滤条件记录的单个字段
注意：即使字段标记为@Column(updatable=false)也会被更新
等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
|
default int |
DataSqlMapper.updateColumn(FilterNode node,
ColumnValue... values) |
更新符合过滤条件记录的部分字段
字段赋值操作选项见 ColumnExpress
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node}
|
default int |
DataSqlMapper.updateColumn(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}
|
default <V extends Serializable>
int |
DataSqlMapper.updateColumn(LambdaSupplier<V> func,
FilterNode node) |
更新符合过滤条件记录的单个字段
注意：即使字段标记为@Column(updatable=false)也会被更新
等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
|
default int |
DataSqlMapper.updateColumn(T entity,
FilterNode node,
String... columns) |
更新符合过滤条件记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ···
WHERE {filter node}
|
default int |
DataSqlMapper.updateColumn(T entity,
FilterNode node,
LambdaFunction<T,?>... funcs) |
更新符合过滤条件记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ···
WHERE {filter node}
|
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}
|
T[] |
EntityCache.updateColumn(FilterNode node,
Flipper flipper,
List<Attribute<T,Serializable>> attrs,
List<ColumnValue> values) |
|
<T> CompletableFuture<Integer> |
AbstractDataSource.updateColumnAsync(Class<T> clazz,
FilterNode node,
ColumnValue... values) |
|
<T> CompletableFuture<Integer> |
AbstractDataSource.updateColumnAsync(T entity,
FilterNode node,
String... columns) |
|
<T> CompletableFuture<Integer> |
AbstractDataSqlSource.updateColumnAsync(Class<T> clazz,
String column,
Serializable colval,
FilterNode node) |
|
<T> CompletableFuture<Integer> |
AbstractDataSqlSource.updateColumnAsync(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> CompletableFuture<Integer> |
AbstractDataSqlSource.updateColumnAsync(T entity,
FilterNode node,
SelectColumn selects) |
|
<T> CompletableFuture<Integer> |
DataMemorySource.updateColumnAsync(Class<T> clazz,
String column,
Serializable value,
FilterNode node) |
|
<T> CompletableFuture<Integer> |
DataMemorySource.updateColumnAsync(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> CompletableFuture<Integer> |
DataMemorySource.updateColumnAsync(T entity,
FilterNode node,
SelectColumn selects) |
|
<T> CompletableFuture<Integer> |
DataSource.updateColumnAsync(Class<T> clazz,
String column,
Serializable value,
FilterNode node) |
更新符合过滤条件记录的单个字段
注意：即使字段标记为@Column(updatable=false)也会被更新
等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
|
default <T> CompletableFuture<Integer> |
DataSource.updateColumnAsync(Class<T> clazz,
FilterNode node,
ColumnValue... values) |
更新符合过滤条件记录的部分字段
字段赋值操作选项见 ColumnExpress
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node}
|
default <T> CompletableFuture<Integer> |
DataSource.updateColumnAsync(Class<T> clazz,
FilterNode node,
ColumnValues values) |
更新符合过滤条件记录的部分字段
字段赋值操作选项见 ColumnExpress
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node}
|
<T> CompletableFuture<Integer> |
DataSource.updateColumnAsync(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node} ORDER BY {flipper.sort}
|
default <T> CompletableFuture<Integer> |
DataSource.updateColumnAsync(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValues values) |
更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node} ORDER BY {flipper.sort}
|
default <T,V extends Serializable>
CompletableFuture<Integer> |
DataSource.updateColumnAsync(Class<T> clazz,
LambdaSupplier<V> func,
FilterNode node) |
更新符合过滤条件记录的单个字段
注意：即使字段标记为@Column(updatable=false)也会被更新
等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
|
<T> CompletableFuture<Integer> |
DataSource.updateColumnAsync(T entity,
FilterNode node,
String... columns) |
更新符合过滤条件记录的指定字段
注意：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,
FilterNode node,
LambdaFunction<T,?>... funcs) |
更新符合过滤条件记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ···
WHERE {filter node}
|
<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 CompletableFuture<Integer> |
DataSqlMapper.updateColumnAsync(String column,
Serializable value,
FilterNode node) |
更新符合过滤条件记录的单个字段
注意：即使字段标记为@Column(updatable=false)也会被更新
等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
|
default CompletableFuture<Integer> |
DataSqlMapper.updateColumnAsync(FilterNode node,
ColumnValue... values) |
更新符合过滤条件记录的部分字段
字段赋值操作选项见 ColumnExpress
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node}
|
default CompletableFuture<Integer> |
DataSqlMapper.updateColumnAsync(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}
|
default <V extends Serializable>
CompletableFuture<Integer> |
DataSqlMapper.updateColumnAsync(LambdaSupplier<V> func,
FilterNode node) |
更新符合过滤条件记录的单个字段
注意：即使字段标记为@Column(updatable=false)也会被更新
等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
|
default CompletableFuture<Integer> |
DataSqlMapper.updateColumnAsync(T entity,
FilterNode node,
String... columns) |
更新符合过滤条件记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ···
WHERE {filter node}
|
default CompletableFuture<Integer> |
DataSqlMapper.updateColumnAsync(T entity,
FilterNode node,
LambdaFunction<T,?>... funcs) |
更新符合过滤条件记录的指定字段
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ···
WHERE {filter node}
|
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}
|
protected <T> AbstractDataSqlSource.UpdateSqlInfo |
AbstractDataSqlSource.updateColumnSql(EntityInfo<T> info,
boolean needNode,
T entity,
FilterNode node,
SelectColumn selects) |
|
protected <T> AbstractDataSqlSource.UpdateSqlInfo |
AbstractDataSqlSource.updateColumnSql(EntityInfo<T> info,
String column,
Serializable colval,
FilterNode node) |
|
protected <T> AbstractDataSqlSource.UpdateSqlInfo |
AbstractDataSqlSource.updateColumnSql(EntityInfo<T> info,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|