static FilterNode |
FilterNodeBean.createFilterNode(FilterBean bean) |
|
<T> boolean |
AbstractDataSource.exists(Class<T> clazz,
FilterBean bean) |
|
default <T> boolean |
DataSource.exists(Class<T> clazz,
FilterBean bean) |
判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
|
default boolean |
DataSqlMapper.exists(FilterBean bean) |
判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
|
<T> CompletableFuture<Boolean> |
AbstractDataSource.existsAsync(Class<T> clazz,
FilterBean bean) |
|
default <T> CompletableFuture<Boolean> |
DataSource.existsAsync(Class<T> clazz,
FilterBean bean) |
判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
|
default CompletableFuture<Boolean> |
DataSqlMapper.existsAsync(FilterBean bean) |
判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean}
|
<T> T |
AbstractDataSource.find(Class<T> clazz,
FilterBean bean) |
|
<T> T |
AbstractDataSource.find(Class<T> clazz,
SelectColumn selects,
FilterBean bean) |
|
default <T> T |
DataSource.find(Class<T> clazz,
FilterBean bean) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter bean}
|
default <T> T |
DataSource.find(Class<T> clazz,
SelectColumn selects,
FilterBean bean) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
|
default T |
DataSqlMapper.find(FilterBean bean) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter bean}
|
default T |
DataSqlMapper.find(SelectColumn selects,
FilterBean bean) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
|
<T> CompletableFuture<T> |
AbstractDataSource.findAsync(Class<T> clazz,
FilterBean bean) |
|
<T> CompletableFuture<T> |
AbstractDataSource.findAsync(Class<T> clazz,
SelectColumn selects,
FilterBean bean) |
|
default <T> CompletableFuture<T> |
DataSource.findAsync(Class<T> clazz,
FilterBean bean) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter bean}
|
default <T> CompletableFuture<T> |
DataSource.findAsync(Class<T> clazz,
SelectColumn selects,
FilterBean bean) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
|
default CompletableFuture<T> |
DataSqlMapper.findAsync(FilterBean bean) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter bean}
|
default CompletableFuture<T> |
DataSqlMapper.findAsync(SelectColumn selects,
FilterBean bean) |
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
|
<T> Serializable |
AbstractDataSource.findColumn(Class<T> clazz,
String column,
Serializable defValue,
FilterBean bean) |
|
<T> Serializable |
AbstractDataSource.findColumn(Class<T> clazz,
String column,
FilterBean bean) |
|
default <T> Serializable |
DataSource.findColumn(Class<T> clazz,
String column,
Serializable defValue,
FilterBean bean) |
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
|
default <T> Serializable |
DataSource.findColumn(Class<T> clazz,
String column,
FilterBean bean) |
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
|
default Serializable |
DataSqlMapper.findColumn(String column,
Serializable defValue,
FilterBean bean) |
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
|
default Serializable |
DataSqlMapper.findColumn(String column,
FilterBean bean) |
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
|
<T> CompletableFuture<Serializable> |
AbstractDataSource.findColumnAsync(Class<T> clazz,
String column,
Serializable defValue,
FilterBean bean) |
|
<T> CompletableFuture<Serializable> |
AbstractDataSource.findColumnAsync(Class<T> clazz,
String column,
FilterBean bean) |
|
default <T> CompletableFuture<Serializable> |
DataSource.findColumnAsync(Class<T> clazz,
String column,
Serializable defValue,
FilterBean bean) |
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
|
default <T> CompletableFuture<Serializable> |
DataSource.findColumnAsync(Class<T> clazz,
String column,
FilterBean bean) |
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
|
default CompletableFuture<Serializable> |
DataSqlMapper.findColumnAsync(String column,
Serializable defValue,
FilterBean bean) |
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
|
default CompletableFuture<Serializable> |
DataSqlMapper.findColumnAsync(String column,
FilterBean bean) |
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
|
<N extends Number>
Map<String,N> |
AbstractDataSource.getNumberMap(Class entityClass,
FilterBean bean,
FilterFuncColumn... columns) |
|
default <N extends Number>
Map<String,N> |
DataSource.getNumberMap(Class entityClass,
FilterBean bean,
FilterFuncColumn... columns) |
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean}
如 getNumberMapAsync(User.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT
MAX(createtime) FROM {table}
|
default <N extends Number>
Map<String,N> |
DataSqlMapper.getNumberMap(FilterBean bean,
FilterFuncColumn... columns) |
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean}
如 getNumberMapAsync(User.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT
MAX(createtime) FROM {table}
|
<N extends Number>
CompletableFuture<Map<String,N>> |
AbstractDataSource.getNumberMapAsync(Class entityClass,
FilterBean bean,
FilterFuncColumn... columns) |
|
default <N extends Number>
CompletableFuture<Map<String,N>> |
DataSource.getNumberMapAsync(Class entityClass,
FilterBean bean,
FilterFuncColumn... columns) |
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean}
如 getNumberMapAsync(User.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT
MAX(createtime) FROM {table}
|
default <N extends Number>
CompletableFuture<Map<String,N>> |
DataSqlMapper.getNumberMapAsync(FilterBean bean,
FilterFuncColumn... columns) |
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean}
如 getNumberMapAsync(User.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT
MAX(createtime) FROM {table}
|
Number |
AbstractDataSource.getNumberResult(Class entityClass,
FilterFunc func,
Number defVal,
String column,
FilterBean bean) |
|
Number |
AbstractDataSource.getNumberResult(Class entityClass,
FilterFunc func,
String column,
FilterBean bean) |
|
default Number |
DataSource.getNumberResult(Class entityClass,
FilterFunc func,
Number defVal,
String column,
FilterBean bean) |
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime)
FROM {table}
|
default Number |
DataSource.getNumberResult(Class entityClass,
FilterFunc func,
String column,
FilterBean bean) |
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
如 getNumberResultAsync(User.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
|
default Number |
DataSqlMapper.getNumberResult(FilterFunc func,
Number defVal,
String column,
FilterBean bean) |
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime)
FROM {table}
|
default Number |
DataSqlMapper.getNumberResult(FilterFunc func,
String column,
FilterBean bean) |
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
如 getNumberResultAsync(User.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
|
CompletableFuture<Number> |
AbstractDataSource.getNumberResultAsync(Class entityClass,
FilterFunc func,
Number defVal,
String column,
FilterBean bean) |
|
CompletableFuture<Number> |
AbstractDataSource.getNumberResultAsync(Class entityClass,
FilterFunc func,
String column,
FilterBean bean) |
|
default CompletableFuture<Number> |
DataSource.getNumberResultAsync(Class entityClass,
FilterFunc func,
Number defVal,
String column,
FilterBean bean) |
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime)
FROM {table}
|
default CompletableFuture<Number> |
DataSource.getNumberResultAsync(Class entityClass,
FilterFunc func,
String column,
FilterBean bean) |
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
如 getNumberResultAsync(User.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
|
default CompletableFuture<Number> |
DataSqlMapper.getNumberResultAsync(FilterFunc func,
Number defVal,
String column,
FilterBean bean) |
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
如 getNumberResultAsync(User.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime)
FROM {table}
|
default CompletableFuture<Number> |
DataSqlMapper.getNumberResultAsync(FilterFunc func,
String column,
FilterBean bean) |
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
如 getNumberResultAsync(User.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
|
<T,V extends Serializable>
List<V> |
AbstractDataSource.queryColumnList(String selectedColumn,
Class<T> clazz,
FilterBean bean) |
|
<T,V extends Serializable>
List<V> |
AbstractDataSource.queryColumnList(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
default <T,V extends Serializable>
List<V> |
DataSource.queryColumnList(String selectedColumn,
Class<T> clazz,
FilterBean bean) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
|
default <T,V extends Serializable>
List<V> |
DataSource.queryColumnList(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <V extends Serializable>
List<V> |
DataSqlMapper.queryColumnList(String selectedColumn,
FilterBean bean) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
|
default <V extends Serializable>
List<V> |
DataSqlMapper.queryColumnList(String selectedColumn,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T,V extends Serializable>
CompletableFuture<List<V>> |
AbstractDataSource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
FilterBean bean) |
|
<T,V extends Serializable>
CompletableFuture<List<V>> |
AbstractDataSource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
default <T,V extends Serializable>
CompletableFuture<List<V>> |
DataSource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
FilterBean bean) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
|
default <T,V extends Serializable>
CompletableFuture<List<V>> |
DataSource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <V extends Serializable>
CompletableFuture<List<V>> |
DataSqlMapper.queryColumnListAsync(String selectedColumn,
FilterBean bean) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean}
|
default <V extends Serializable>
CompletableFuture<List<V>> |
DataSqlMapper.queryColumnListAsync(String selectedColumn,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T,K extends Serializable,N extends Number>
Map<K,N> |
AbstractDataSource.queryColumnMap(Class<T> entityClass,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterBean bean) |
|
<T,K extends Serializable,N extends Number>
Map<K[],N[]> |
AbstractDataSource.queryColumnMap(Class<T> entityClass,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterBean bean) |
|
<T,K extends Serializable,N extends Number>
Map<K,N[]> |
AbstractDataSource.queryColumnMap(Class<T> entityClass,
ColumnNode[] funcNodes,
String groupByColumn,
FilterBean bean) |
|
default <T,K extends Serializable,N extends Number>
Map<K,N> |
DataSource.queryColumnMap(Class<T> entityClass,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterBean bean) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn}
如 queryColumnMapAsync(User.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name,
MAX(createtime) FROM user GROUP BY name
|
default <T,K extends Serializable,N extends Number>
Map<K[],N[]> |
DataSource.queryColumnMap(Class<T> entityClass,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterBean bean) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} 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"), (FilterBean)null)
等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
|
default <T,K extends Serializable,N extends Number>
Map<K,N[]> |
DataSource.queryColumnMap(Class<T> entityClass,
ColumnNode[] funcNodes,
String groupByColumn,
FilterBean bean) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1}
如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100),
ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterBean)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,
FilterBean bean) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn}
如 queryColumnMapAsync(User.class, "name", FilterFunc.MAX, "createtime", (FilterBean)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,
FilterBean bean) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} 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"), (FilterBean)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,
FilterBean bean) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1}
如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100),
ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterBean)null) 等价于: SELECT targetid,
SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
|
<T,K extends Serializable,N extends Number>
CompletableFuture<Map<K,N>> |
AbstractDataSource.queryColumnMapAsync(Class<T> entityClass,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterBean bean) |
|
<T,K extends Serializable,N extends Number>
CompletableFuture<Map<K[],N[]>> |
AbstractDataSource.queryColumnMapAsync(Class<T> entityClass,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterBean bean) |
|
<T,K extends Serializable,N extends Number>
CompletableFuture<Map<K,N[]>> |
AbstractDataSource.queryColumnMapAsync(Class<T> entityClass,
ColumnNode[] funcNodes,
String groupByColumn,
FilterBean bean) |
|
default <T,K extends Serializable,N extends Number>
CompletableFuture<Map<K,N>> |
DataSource.queryColumnMapAsync(Class<T> entityClass,
String keyColumn,
FilterFunc func,
String funcColumn,
FilterBean bean) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn}
如 queryColumnMapAsync(User.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name,
MAX(createtime) FROM user GROUP BY name
|
default <T,K extends Serializable,N extends Number>
CompletableFuture<Map<K[],N[]>> |
DataSource.queryColumnMapAsync(Class<T> entityClass,
ColumnNode[] funcNodes,
String[] groupByColumns,
FilterBean bean) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} 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"), (FilterBean)null)
等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
|
default <T,K extends Serializable,N extends Number>
CompletableFuture<Map<K,N[]>> |
DataSource.queryColumnMapAsync(Class<T> entityClass,
ColumnNode[] funcNodes,
String groupByColumn,
FilterBean bean) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1}
如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100),
ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterBean)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,
FilterBean bean) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn}
如 queryColumnMapAsync(User.class, "name", FilterFunc.MAX, "createtime", (FilterBean)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,
FilterBean bean) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} 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"), (FilterBean)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,
FilterBean bean) |
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1}
如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100),
ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterBean)null) 等价于: SELECT targetid,
SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
|
<T,V extends Serializable>
Set<V> |
AbstractDataSource.queryColumnSet(String selectedColumn,
Class<T> clazz,
FilterBean bean) |
|
<T,V extends Serializable>
Set<V> |
AbstractDataSource.queryColumnSet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
default <T,V extends Serializable>
Set<V> |
DataSource.queryColumnSet(String selectedColumn,
Class<T> clazz,
FilterBean bean) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter bean}
|
default <T,V extends Serializable>
Set<V> |
DataSource.queryColumnSet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT
{flipper.limit}
|
default <V extends Serializable>
Set<V> |
DataSqlMapper.queryColumnSet(String selectedColumn,
FilterBean bean) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter bean}
|
default <V extends Serializable>
Set<V> |
DataSqlMapper.queryColumnSet(String selectedColumn,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT
{flipper.limit}
|
<T,V extends Serializable>
CompletableFuture<Set<V>> |
AbstractDataSource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
FilterBean bean) |
|
<T,V extends Serializable>
CompletableFuture<Set<V>> |
AbstractDataSource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
default <T,V extends Serializable>
CompletableFuture<Set<V>> |
DataSource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
FilterBean bean) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter bean}
|
default <T,V extends Serializable>
CompletableFuture<Set<V>> |
DataSource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT
{flipper.limit}
|
default <V extends Serializable>
CompletableFuture<Set<V>> |
DataSqlMapper.queryColumnSetAsync(String selectedColumn,
FilterBean bean) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter bean}
|
default <V extends Serializable>
CompletableFuture<Set<V>> |
DataSqlMapper.queryColumnSetAsync(String selectedColumn,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT
{flipper.limit}
|
<T,V extends Serializable>
Sheet<V> |
AbstractDataSource.queryColumnSheet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
根据指定参数查询对象某个字段的集合
|
default <T,V extends Serializable>
Sheet<V> |
DataSource.queryColumnSheet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <V extends Serializable>
Sheet<V> |
DataSqlMapper.queryColumnSheet(String selectedColumn,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T,V extends Serializable>
CompletableFuture<Sheet<V>> |
AbstractDataSource.queryColumnSheetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
default <T,V extends Serializable>
CompletableFuture<Sheet<V>> |
DataSource.queryColumnSheetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <V extends Serializable>
CompletableFuture<Sheet<V>> |
DataSqlMapper.queryColumnSheetAsync(String selectedColumn,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T> List<T> |
AbstractDataSource.queryList(Class<T> clazz,
FilterBean bean) |
根据过滤对象FilterBean查询对象集合
|
<T> List<T> |
AbstractDataSource.queryList(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T> List<T> |
AbstractDataSource.queryList(Class<T> clazz,
SelectColumn selects,
FilterBean bean) |
根据过滤对象FilterBean查询对象集合， 对象只填充或排除SelectField指定的字段
|
<T> List<T> |
AbstractDataSource.queryList(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
|
default <T> List<T> |
DataSource.queryList(Class<T> clazz,
FilterBean bean) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean}
|
default <T> List<T> |
DataSource.queryList(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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,
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(FilterBean bean) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean}
|
default List<T> |
DataSqlMapper.queryList(Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} 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,
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>> |
AbstractDataSource.queryListAsync(Class<T> clazz,
FilterBean bean) |
|
<T> CompletableFuture<List<T>> |
AbstractDataSource.queryListAsync(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T> CompletableFuture<List<T>> |
AbstractDataSource.queryListAsync(Class<T> clazz,
SelectColumn selects,
FilterBean bean) |
|
<T> CompletableFuture<List<T>> |
AbstractDataSource.queryListAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
|
default <T> CompletableFuture<List<T>> |
DataSource.queryListAsync(Class<T> clazz,
FilterBean bean) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean}
|
default <T> CompletableFuture<List<T>> |
DataSource.queryListAsync(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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,
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(FilterBean bean) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean}
|
default CompletableFuture<List<T>> |
DataSqlMapper.queryListAsync(Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} 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,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
<K extends Serializable,T>
Map<K,T> |
AbstractDataSource.queryMap(Class<T> clazz,
FilterBean bean) |
查询符合过滤条件记录的Map集合, 主键值为key
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<K extends Serializable,T>
Map<K,T> |
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}
|
default <K extends Serializable,T>
Map<K,T> |
DataSource.queryMap(Class<T> clazz,
FilterBean bean) |
查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
等价SQL: SELECT * FROM {table} WHERE {filter node}
|
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}
|
default <K extends Serializable>
Map<K,T> |
DataSqlMapper.queryMap(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,
FilterBean bean) |
查询符合过滤条件记录的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,
FilterBean bean) |
|
<K extends Serializable,T>
CompletableFuture<Map<K,T>> |
AbstractDataSource.queryMapAsync(Class<T> clazz,
SelectColumn selects,
FilterBean bean) |
|
default <K extends Serializable,T>
CompletableFuture<Map<K,T>> |
DataSource.queryMapAsync(Class<T> clazz,
FilterBean bean) |
查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
等价SQL: SELECT * FROM {table} WHERE {filter node}
|
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}
|
default <K extends Serializable>
CompletableFuture<Map<K,T>> |
DataSqlMapper.queryMapAsync(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,
FilterBean bean) |
查询符合过滤条件记录的List转Map集合， key=主键值, value=Entity对象
等价SQL: SELECT * FROM {table} WHERE {filter node}
|
<T> Set<T> |
AbstractDataSource.querySet(Class<T> clazz,
FilterBean bean) |
根据过滤对象FilterBean查询对象集合
|
<T> Set<T> |
AbstractDataSource.querySet(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T> Set<T> |
AbstractDataSource.querySet(Class<T> clazz,
SelectColumn selects,
FilterBean bean) |
根据过滤对象FilterBean查询对象集合， 对象只填充或排除SelectField指定的字段
|
<T> Set<T> |
AbstractDataSource.querySet(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
|
default <T> Set<T> |
DataSource.querySet(Class<T> clazz,
FilterBean bean) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean}
|
default <T> Set<T> |
DataSource.querySet(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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,
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(FilterBean bean) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean}
|
default Set<T> |
DataSqlMapper.querySet(Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean} 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,
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>> |
AbstractDataSource.querySetAsync(Class<T> clazz,
FilterBean bean) |
|
<T> CompletableFuture<Set<T>> |
AbstractDataSource.querySetAsync(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T> CompletableFuture<Set<T>> |
AbstractDataSource.querySetAsync(Class<T> clazz,
SelectColumn selects,
FilterBean bean) |
|
<T> CompletableFuture<Set<T>> |
AbstractDataSource.querySetAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
|
default <T> CompletableFuture<Set<T>> |
DataSource.querySetAsync(Class<T> clazz,
FilterBean bean) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean}
|
default <T> CompletableFuture<Set<T>> |
DataSource.querySetAsync(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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,
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(FilterBean bean) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean}
|
default CompletableFuture<Set<T>> |
DataSqlMapper.querySetAsync(Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter bean} 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,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY
{flipper.sort} LIMIT {flipper.limit}
|
<T> Sheet<T> |
AbstractDataSource.querySheet(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
根据过滤对象FilterBean和翻页对象Flipper查询一页的数据
|
<T> Sheet<T> |
AbstractDataSource.querySheet(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
根据过滤对象FilterBean和翻页对象Flipper查询一页的数据， 对象只填充或排除SelectField指定的字段
|
default <T> Sheet<T> |
DataSource.querySheet(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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}
|
default Sheet<T> |
DataSqlMapper.querySheet(Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * 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}
|
<T> CompletableFuture<Sheet<T>> |
AbstractDataSource.querySheetAsync(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T> CompletableFuture<Sheet<T>> |
AbstractDataSource.querySheetAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
|
default <T> CompletableFuture<Sheet<T>> |
DataSource.querySheetAsync(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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}
|
default CompletableFuture<Sheet<T>> |
DataSqlMapper.querySheetAsync(Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * 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}
|