public interface DataSource
详情见: https://redkale.org
限定符和类型 | 方法和说明 |
---|---|
<T> int |
clearTable(java.lang.Class<T> clazz)
清空表
等价SQL: TRUNCATE TABLE {table} |
<T> int |
clearTable(java.lang.Class<T> clazz,
FilterNode node)
清空表
等价SQL: TRUNCATE TABLE {table} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
clearTableAsync(java.lang.Class<T> clazz)
清空表
等价SQL: TRUNCATE TABLE {table} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
clearTableAsync(java.lang.Class<T> clazz,
FilterNode node)
清空表
等价SQL: TRUNCATE TABLE {table} |
<T> int |
delete(java.lang.Class<T> clazz,
FilterNode node)
删除符合过滤条件的记录
等价SQL: DELETE FROM {table} WHERE {filter node} |
<T> int |
delete(java.lang.Class<T> clazz,
Flipper flipper,
FilterNode node)
删除符合过滤条件且指定最大影响条数的记录
Flipper中offset字段将被忽略 等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> int |
delete(java.lang.Class<T> clazz,
java.io.Serializable... pks)
删除指定主键值的记录,多主键值必须在同一张表中
等价SQL: DELETE FROM {table} WHERE {primary} IN {ids} |
default <T> int |
delete(java.util.Collection<T> entitys)
删除指定主键值的记录, 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id} |
default <T> int |
delete(java.util.stream.Stream<T> entitys)
删除指定主键值的记录, 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id} |
<T> int |
delete(T... entitys)
删除指定主键值的记录, 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
deleteAsync(java.lang.Class<T> clazz,
FilterNode node)
删除符合过滤条件的记录
等价SQL: DELETE FROM {table} WHERE {filter node} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
deleteAsync(java.lang.Class<T> clazz,
Flipper flipper,
FilterNode node)
删除符合过滤条件且指定最大影响条数的记录
Flipper中offset字段将被忽略 等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
deleteAsync(java.lang.Class<T> clazz,
java.io.Serializable... pks)
删除指定主键值的记录,多主键值必须在同一张表中
等价SQL: DELETE FROM {table} WHERE {primary} IN {ids} |
default <T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
deleteAsync(java.util.Collection<T> entitys)
删除指定主键值的记录, 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id} |
default <T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
deleteAsync(java.util.stream.Stream<T> entitys)
删除指定主键值的记录, 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
deleteAsync(T... entitys)
删除指定主键值的记录, 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id} |
<T> int |
dropTable(java.lang.Class<T> clazz)
删除表
等价SQL: DROP TABLE {table} |
<T> int |
dropTable(java.lang.Class<T> clazz,
FilterNode node)
删除表
等价SQL: DROP TABLE {table} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
dropTableAsync(java.lang.Class<T> clazz)
删除表
等价SQL: DROP TABLE {table} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
dropTableAsync(java.lang.Class<T> clazz,
FilterNode node)
删除表
等价SQL: DROP TABLE {table} |
<T> boolean |
exists(java.lang.Class<T> clazz,
FilterBean bean)
判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean} |
<T> boolean |
exists(java.lang.Class<T> clazz,
FilterNode node)
判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node} |
<T> boolean |
exists(java.lang.Class<T> clazz,
java.io.Serializable pk)
判断是否存在主键值的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id} |
<T> java.util.concurrent.CompletableFuture<java.lang.Boolean> |
existsAsync(java.lang.Class<T> clazz,
FilterBean bean)
判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter bean} |
<T> java.util.concurrent.CompletableFuture<java.lang.Boolean> |
existsAsync(java.lang.Class<T> clazz,
FilterNode node)
判断是否存在符合过滤条件的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {filter node} |
<T> java.util.concurrent.CompletableFuture<java.lang.Boolean> |
existsAsync(java.lang.Class<T> clazz,
java.io.Serializable pk)
判断是否存在主键值的记录
等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id} |
<T> T |
find(java.lang.Class<T> clazz,
FilterBean bean)
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter bean} |
<T> T |
find(java.lang.Class<T> clazz,
FilterNode node)
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter node} |
<T> T |
find(java.lang.Class<T> clazz,
SelectColumn selects,
FilterBean bean)
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} |
<T> T |
find(java.lang.Class<T> clazz,
SelectColumn selects,
FilterNode node)
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} |
<T> T |
find(java.lang.Class<T> clazz,
SelectColumn selects,
java.io.Serializable pk)
获取指定主键值的单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id} |
<T> T |
find(java.lang.Class<T> clazz,
java.io.Serializable pk)
获取指定主键值的单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {primary} = {id} |
<T> T |
find(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable colval)
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {column} = {key} |
<T> java.util.concurrent.CompletableFuture<T> |
findAsync(java.lang.Class<T> clazz,
FilterBean bean)
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter bean} |
<T> java.util.concurrent.CompletableFuture<T> |
findAsync(java.lang.Class<T> clazz,
FilterNode node)
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {filter node} |
<T> java.util.concurrent.CompletableFuture<T> |
findAsync(java.lang.Class<T> clazz,
SelectColumn selects,
FilterBean bean)
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} |
<T> java.util.concurrent.CompletableFuture<T> |
findAsync(java.lang.Class<T> clazz,
SelectColumn selects,
FilterNode node)
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} |
<T> java.util.concurrent.CompletableFuture<T> |
findAsync(java.lang.Class<T> clazz,
SelectColumn selects,
java.io.Serializable pk)
获取指定主键值的单个记录, 返回null表示不存在值
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id} |
<T> java.util.concurrent.CompletableFuture<T> |
findAsync(java.lang.Class<T> clazz,
java.io.Serializable pk)
获取指定主键值的单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {primary} = {id} |
<T> java.util.concurrent.CompletableFuture<T> |
findAsync(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable colval)
获取符合过滤条件单个记录, 返回null表示不存在值
等价SQL: SELECT * FROM {table} WHERE {column} = {key} |
<T> java.io.Serializable |
findColumn(java.lang.Class<T> clazz,
java.lang.String column,
FilterBean bean)
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean} |
<T> java.io.Serializable |
findColumn(java.lang.Class<T> clazz,
java.lang.String column,
FilterNode node)
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter node} |
<T> java.io.Serializable |
findColumn(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable pk)
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id} |
<T> java.io.Serializable |
findColumn(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable defValue,
FilterBean bean)
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean} |
<T> java.io.Serializable |
findColumn(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable defValue,
FilterNode node)
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter node} |
<T> java.io.Serializable |
findColumn(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable defValue,
java.io.Serializable pk)
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id} |
<T> java.util.concurrent.CompletableFuture<java.io.Serializable> |
findColumnAsync(java.lang.Class<T> clazz,
java.lang.String column,
FilterBean bean)
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean} |
<T> java.util.concurrent.CompletableFuture<java.io.Serializable> |
findColumnAsync(java.lang.Class<T> clazz,
java.lang.String column,
FilterNode node)
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {filter node} |
<T> java.util.concurrent.CompletableFuture<java.io.Serializable> |
findColumnAsync(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable pk)
获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id} |
<T> java.util.concurrent.CompletableFuture<java.io.Serializable> |
findColumnAsync(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable defValue,
FilterBean bean)
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter bean} |
<T> java.util.concurrent.CompletableFuture<java.io.Serializable> |
findColumnAsync(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable defValue,
FilterNode node)
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {filter node} |
<T> java.util.concurrent.CompletableFuture<java.io.Serializable> |
findColumnAsync(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable defValue,
java.io.Serializable pk)
获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id} |
<N extends java.lang.Number> |
getNumberMap(java.lang.Class entityClass,
FilterBean bean,
FilterFuncColumn... columns)
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean} 如 getNumberMapAsync(Record.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table} |
<N extends java.lang.Number> |
getNumberMap(java.lang.Class entityClass,
FilterFuncColumn... columns)
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} 如 getNumberMapAsync(Record.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table} |
<N extends java.lang.Number> |
getNumberMap(java.lang.Class entityClass,
FilterNode node,
FilterFuncColumn... columns)
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node} 如 getNumberMapAsync(Record.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table} |
<N extends java.lang.Number> |
getNumberMapAsync(java.lang.Class entityClass,
FilterBean bean,
FilterFuncColumn... columns)
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean} 如 getNumberMapAsync(Record.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table} |
<N extends java.lang.Number> |
getNumberMapAsync(java.lang.Class entityClass,
FilterFuncColumn... columns)
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} 如 getNumberMapAsync(Record.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table} |
<N extends java.lang.Number> |
getNumberMapAsync(java.lang.Class entityClass,
FilterNode node,
FilterFuncColumn... columns)
获取符合过滤条件记录的聚合结果Map
等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node} 如 getNumberMapAsync(Record.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table} |
java.lang.Number |
getNumberResult(java.lang.Class entityClass,
FilterFunc func,
java.lang.Number defVal,
java.lang.String column)
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table} |
java.lang.Number |
getNumberResult(java.lang.Class entityClass,
FilterFunc func,
java.lang.Number defVal,
java.lang.String column,
FilterBean bean)
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table} |
java.lang.Number |
getNumberResult(java.lang.Class entityClass,
FilterFunc func,
java.lang.Number defVal,
java.lang.String column,
FilterNode node)
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table} |
java.lang.Number |
getNumberResult(java.lang.Class entityClass,
FilterFunc func,
java.lang.String column)
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table} |
java.lang.Number |
getNumberResult(java.lang.Class entityClass,
FilterFunc func,
java.lang.String column,
FilterBean bean)
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table} |
java.lang.Number |
getNumberResult(java.lang.Class entityClass,
FilterFunc func,
java.lang.String column,
FilterNode node)
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table} |
java.util.concurrent.CompletableFuture<java.lang.Number> |
getNumberResultAsync(java.lang.Class entityClass,
FilterFunc func,
java.lang.Number defVal,
java.lang.String column)
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table} |
java.util.concurrent.CompletableFuture<java.lang.Number> |
getNumberResultAsync(java.lang.Class entityClass,
FilterFunc func,
java.lang.Number defVal,
java.lang.String column,
FilterBean bean)
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table} |
java.util.concurrent.CompletableFuture<java.lang.Number> |
getNumberResultAsync(java.lang.Class entityClass,
FilterFunc func,
java.lang.Number defVal,
java.lang.String column,
FilterNode node)
获取符合过滤条件记录的聚合结果, 无结果返回默认值
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table} |
java.util.concurrent.CompletableFuture<java.lang.Number> |
getNumberResultAsync(java.lang.Class entityClass,
FilterFunc func,
java.lang.String column)
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table} |
java.util.concurrent.CompletableFuture<java.lang.Number> |
getNumberResultAsync(java.lang.Class entityClass,
FilterFunc func,
java.lang.String column,
FilterBean bean)
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean} 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table} |
java.util.concurrent.CompletableFuture<java.lang.Number> |
getNumberResultAsync(java.lang.Class entityClass,
FilterFunc func,
java.lang.String column,
FilterNode node)
获取符合过滤条件记录的聚合结果, 无结果返回null
等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node} 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table} |
java.lang.String |
getType()
获取数据源类型
|
<T> int |
insert(T... entitys)
新增记录, 多对象必须是同一个Entity类且必须在同一张表中
|
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
insertAsync(T... entitys)
新增记录, 多对象必须是同一个Entity类且必须在同一张表中
|
<T,V extends java.io.Serializable> |
queryColumnList(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
FilterBean bean)
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} |
<T,V extends java.io.Serializable> |
queryColumnList(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
FilterNode node)
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} |
<T,V extends java.io.Serializable> |
queryColumnList(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
Flipper flipper,
FilterBean bean)
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T,V extends java.io.Serializable> |
queryColumnList(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
Flipper flipper,
FilterNode node)
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T,V extends java.io.Serializable> |
queryColumnList(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable colval)
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key} |
<T,V extends java.io.Serializable> |
queryColumnListAsync(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
FilterBean bean)
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} |
<T,V extends java.io.Serializable> |
queryColumnListAsync(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
FilterNode node)
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} |
<T,V extends java.io.Serializable> |
queryColumnListAsync(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
Flipper flipper,
FilterBean bean)
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T,V extends java.io.Serializable> |
queryColumnListAsync(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
Flipper flipper,
FilterNode node)
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T,V extends java.io.Serializable> |
queryColumnListAsync(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable colval)
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key} |
<T,K extends java.io.Serializable,N extends java.lang.Number> |
queryColumnMap(java.lang.Class<T> entityClass,
java.lang.String keyColumn,
FilterFunc func,
java.lang.String funcColumn)
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime") 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name |
<T,K extends java.io.Serializable,N extends java.lang.Number> |
queryColumnMap(java.lang.Class<T> entityClass,
java.lang.String keyColumn,
FilterFunc func,
java.lang.String funcColumn,
FilterBean bean)
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name |
<T,K extends java.io.Serializable,N extends java.lang.Number> |
queryColumnMap(java.lang.Class<T> entityClass,
java.lang.String keyColumn,
FilterFunc func,
java.lang.String funcColumn,
FilterNode node)
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name |
<T,K extends java.io.Serializable,N extends java.lang.Number> |
queryColumnMapAsync(java.lang.Class<T> entityClass,
java.lang.String keyColumn,
FilterFunc func,
java.lang.String funcColumn)
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime") 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name |
<T,K extends java.io.Serializable,N extends java.lang.Number> |
queryColumnMapAsync(java.lang.Class<T> entityClass,
java.lang.String keyColumn,
FilterFunc func,
java.lang.String funcColumn,
FilterBean bean)
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name |
<T,K extends java.io.Serializable,N extends java.lang.Number> |
queryColumnMapAsync(java.lang.Class<T> entityClass,
java.lang.String keyColumn,
FilterFunc func,
java.lang.String funcColumn,
FilterNode node)
查询符合过滤条件记录的GROUP BY聚合结果Map
等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn} 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name |
<T,V extends java.io.Serializable> |
queryColumnSet(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
FilterBean bean)
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} |
<T,V extends java.io.Serializable> |
queryColumnSet(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
FilterNode node)
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} |
<T,V extends java.io.Serializable> |
queryColumnSet(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable colval)
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key} |
<T,V extends java.io.Serializable> |
queryColumnSetAsync(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
FilterBean bean)
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} |
<T,V extends java.io.Serializable> |
queryColumnSetAsync(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
FilterNode node)
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} |
<T,V extends java.io.Serializable> |
queryColumnSetAsync(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable colval)
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {column} = {key} |
<T,V extends java.io.Serializable> |
queryColumnSheet(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
Flipper flipper,
FilterBean bean)
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T,V extends java.io.Serializable> |
queryColumnSheet(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
Flipper flipper,
FilterNode node)
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T,V extends java.io.Serializable> |
queryColumnSheetAsync(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
Flipper flipper,
FilterBean bean)
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T,V extends java.io.Serializable> |
queryColumnSheetAsync(java.lang.String selectedColumn,
java.lang.Class<T> clazz,
Flipper flipper,
FilterNode node)
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
default <T> java.util.List<T> |
queryList(java.lang.Class<T> clazz)
查询记录的List集合
等价SQL: SELECT * FROM {table} |
<T> java.util.List<T> |
queryList(java.lang.Class<T> clazz,
FilterBean bean)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} |
<T> java.util.List<T> |
queryList(java.lang.Class<T> clazz,
FilterNode node)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} |
<T> java.util.List<T> |
queryList(java.lang.Class<T> clazz,
Flipper flipper,
FilterBean bean)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.List<T> |
queryList(java.lang.Class<T> clazz,
Flipper flipper,
FilterNode node)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.List<T> |
queryList(java.lang.Class<T> clazz,
Flipper flipper,
java.lang.String column,
java.io.Serializable colval)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.List<T> |
queryList(java.lang.Class<T> clazz,
SelectColumn selects,
FilterBean bean)
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} |
<T> java.util.List<T> |
queryList(java.lang.Class<T> clazz,
SelectColumn selects,
FilterNode node)
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} |
<T> java.util.List<T> |
queryList(java.lang.Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean)
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.List<T> |
queryList(java.lang.Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node)
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.List<T> |
queryList(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable colval)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
default <T> java.util.concurrent.CompletableFuture<java.util.List<T>> |
queryListAsync(java.lang.Class<T> clazz)
查询记录的List集合
等价SQL: SELECT * FROM {table} |
<T> java.util.concurrent.CompletableFuture<java.util.List<T>> |
queryListAsync(java.lang.Class<T> clazz,
FilterBean bean)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} |
<T> java.util.concurrent.CompletableFuture<java.util.List<T>> |
queryListAsync(java.lang.Class<T> clazz,
FilterNode node)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} |
<T> java.util.concurrent.CompletableFuture<java.util.List<T>> |
queryListAsync(java.lang.Class<T> clazz,
Flipper flipper,
FilterBean bean)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.concurrent.CompletableFuture<java.util.List<T>> |
queryListAsync(java.lang.Class<T> clazz,
Flipper flipper,
FilterNode node)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.concurrent.CompletableFuture<java.util.List<T>> |
queryListAsync(java.lang.Class<T> clazz,
Flipper flipper,
java.lang.String column,
java.io.Serializable colval)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.concurrent.CompletableFuture<java.util.List<T>> |
queryListAsync(java.lang.Class<T> clazz,
SelectColumn selects,
FilterBean bean)
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} |
<T> java.util.concurrent.CompletableFuture<java.util.List<T>> |
queryListAsync(java.lang.Class<T> clazz,
SelectColumn selects,
FilterNode node)
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} |
<T> java.util.concurrent.CompletableFuture<java.util.List<T>> |
queryListAsync(java.lang.Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean)
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.concurrent.CompletableFuture<java.util.List<T>> |
queryListAsync(java.lang.Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node)
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.concurrent.CompletableFuture<java.util.List<T>> |
queryListAsync(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable colval)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<K extends java.io.Serializable,T> |
queryMap(java.lang.Class<T> clazz,
FilterBean bean)
查询符合过滤条件记录的Map集合, 主键值为key
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<K extends java.io.Serializable,T> |
queryMap(java.lang.Class<T> clazz,
FilterNode node)
查询符合过滤条件记录的Map集合, 主键值为key
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<K extends java.io.Serializable,T> |
queryMap(java.lang.Class<T> clazz,
SelectColumn selects,
FilterBean bean)
查询符合过滤条件记录的Map集合, 主键值为key
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<K extends java.io.Serializable,T> |
queryMap(java.lang.Class<T> clazz,
SelectColumn selects,
FilterNode node)
查询符合过滤条件记录的Map集合, 主键值为key
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<K extends java.io.Serializable,T> |
queryMap(java.lang.Class<T> clazz,
SelectColumn selects,
java.util.stream.Stream<K> keyStream)
查询符合过滤条件记录的Map集合, 主键值为key
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<K extends java.io.Serializable,T> |
queryMap(java.lang.Class<T> clazz,
java.util.stream.Stream<K> keyStream)
查询符合过滤条件记录的Map集合, 主键值为key
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<K extends java.io.Serializable,T> |
queryMapAsync(java.lang.Class<T> clazz,
FilterBean bean)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<K extends java.io.Serializable,T> |
queryMapAsync(java.lang.Class<T> clazz,
FilterNode node)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<K extends java.io.Serializable,T> |
queryMapAsync(java.lang.Class<T> clazz,
SelectColumn selects,
FilterBean bean)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<K extends java.io.Serializable,T> |
queryMapAsync(java.lang.Class<T> clazz,
SelectColumn selects,
FilterNode node)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<K extends java.io.Serializable,T> |
queryMapAsync(java.lang.Class<T> clazz,
SelectColumn selects,
java.util.stream.Stream<K> keyStream)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<K extends java.io.Serializable,T> |
queryMapAsync(java.lang.Class<T> clazz,
java.util.stream.Stream<K> keyStream)
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> Sheet<T> |
querySheet(java.lang.Class<T> clazz,
Flipper flipper,
FilterBean bean)
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> Sheet<T> |
querySheet(java.lang.Class<T> clazz,
Flipper flipper,
FilterNode node)
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> Sheet<T> |
querySheet(java.lang.Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean)
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> Sheet<T> |
querySheet(java.lang.Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node)
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.concurrent.CompletableFuture<Sheet<T>> |
querySheetAsync(java.lang.Class<T> clazz,
Flipper flipper,
FilterBean bean)
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.concurrent.CompletableFuture<Sheet<T>> |
querySheetAsync(java.lang.Class<T> clazz,
Flipper flipper,
FilterNode node)
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.concurrent.CompletableFuture<Sheet<T>> |
querySheetAsync(java.lang.Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean)
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
<T> java.util.concurrent.CompletableFuture<Sheet<T>> |
querySheetAsync(java.lang.Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node)
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit} |
default <T> int |
update(java.util.Collection<T> entitys)
更新记录, 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1} UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2} ··· |
default <T> int |
update(java.util.stream.Stream<T> entitys)
更新记录, 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1} UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2} ··· |
<T> int |
update(T... entitys)
更新记录, 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1} UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2} ··· |
default <T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
updateAsync(java.util.Collection<T> entitys)
更新记录, 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1} UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2} ··· |
default <T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
updateAsync(java.util.stream.Stream<T> entitys)
更新记录, 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1} UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2} ··· |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
updateAsync(T... entitys)
更新记录, 多对象必须是同一个Entity类且必须在同一张表中
等价SQL: UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1} UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2} ··· |
<T> int |
updateColumn(java.lang.Class<T> clazz,
FilterNode node,
ColumnValue... values)
更新符合过滤条件记录的部分字段
字段赋值操作选项见 ColumnExpress 注意:Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} |
<T> int |
updateColumn(java.lang.Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values)
更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略 注意:Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort} |
<T> int |
updateColumn(java.lang.Class<T> clazz,
java.io.Serializable pk,
ColumnValue... values)
更新指定主键值记录的部分字段
字段赋值操作选项见 ColumnExpress 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} |
<T> int |
updateColumn(java.lang.Class<T> clazz,
java.io.Serializable pk,
java.lang.String column,
java.io.Serializable value)
更新单个记录的单个字段
注意:即使字段标记为@Column(updatable=false)也会被更新 等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id} |
<T> int |
updateColumn(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable value,
FilterNode node)
更新符合过滤条件记录的单个字段
注意:即使字段标记为@Column(updatable=false)也会被更新 等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node} |
<T> int |
updateColumn(T entity,
FilterNode node,
SelectColumn selects)
更新符合过滤条件记录的指定字段
注意:Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node} |
<T> int |
updateColumn(T entity,
FilterNode node,
java.lang.String... columns)
更新符合过滤条件记录的指定字段
注意:Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node} |
<T> int |
updateColumn(T entity,
SelectColumn selects)
更新单个记录的指定字段
注意:Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id} |
<T> int |
updateColumn(T entity,
java.lang.String... columns)
更新单个记录的指定字段
注意:Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
updateColumnAsync(java.lang.Class<T> clazz,
FilterNode node,
ColumnValue... values)
更新符合过滤条件记录的部分字段
字段赋值操作选项见 ColumnExpress 注意:Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
updateColumnAsync(java.lang.Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values)
更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略 注意:Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
updateColumnAsync(java.lang.Class<T> clazz,
java.io.Serializable pk,
ColumnValue... values)
更新指定主键值记录的部分字段
字段赋值操作选项见 ColumnExpress 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
updateColumnAsync(java.lang.Class<T> clazz,
java.io.Serializable pk,
java.lang.String column,
java.io.Serializable value)
更新单个记录的单个字段
注意:即使字段标记为@Column(updatable=false)也会被更新 等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
updateColumnAsync(java.lang.Class<T> clazz,
java.lang.String column,
java.io.Serializable value,
FilterNode node)
更新符合过滤条件记录的单个字段
注意:即使字段标记为@Column(updatable=false)也会被更新 等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
updateColumnAsync(T entity,
FilterNode node,
SelectColumn selects)
更新符合过滤条件记录的指定字段
注意:Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
updateColumnAsync(T entity,
FilterNode node,
java.lang.String... columns)
更新符合过滤条件记录的指定字段
注意:Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
updateColumnAsync(T entity,
SelectColumn selects)
更新单个记录的指定字段
注意:Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id} |
<T> java.util.concurrent.CompletableFuture<java.lang.Integer> |
updateColumnAsync(T entity,
java.lang.String... columns)
更新单个记录的指定字段
注意:Entity类中标记为@Column(updatable=false)不会被更新 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id} |
java.lang.String getType()
<T> int insert(T... entitys)
T
- 泛型entitys
- Entity对象<T> java.util.concurrent.CompletableFuture<java.lang.Integer> insertAsync(T... entitys)
T
- 泛型entitys
- Entity对象<T> int delete(T... entitys)
T
- 泛型entitys
- Entity对象default <T> int delete(java.util.Collection<T> entitys)
T
- 泛型entitys
- Entity对象default <T> int delete(java.util.stream.Stream<T> entitys)
T
- 泛型entitys
- Entity对象<T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteAsync(T... entitys)
T
- 泛型entitys
- Entity对象default <T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteAsync(java.util.Collection<T> entitys)
T
- 泛型entitys
- Entity对象default <T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteAsync(java.util.stream.Stream<T> entitys)
T
- 泛型entitys
- Entity对象<T> int delete(java.lang.Class<T> clazz, java.io.Serializable... pks)
T
- Entity泛型clazz
- Entity类pks
- 主键值<T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteAsync(java.lang.Class<T> clazz, java.io.Serializable... pks)
T
- Entity泛型clazz
- Entity类pks
- 主键值<T> int delete(java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型clazz
- Entity类node
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteAsync(java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型clazz
- Entity类node
- 过滤条件<T> int delete(java.lang.Class<T> clazz, Flipper flipper, FilterNode node)
T
- Entity泛型clazz
- Entity类flipper
- 翻页对象node
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.lang.Integer> deleteAsync(java.lang.Class<T> clazz, Flipper flipper, FilterNode node)
T
- Entity泛型clazz
- Entity类flipper
- 翻页对象node
- 过滤条件<T> int clearTable(java.lang.Class<T> clazz)
T
- Entity泛型clazz
- Entity类<T> java.util.concurrent.CompletableFuture<java.lang.Integer> clearTableAsync(java.lang.Class<T> clazz)
T
- Entity泛型clazz
- Entity类<T> int clearTable(java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型clazz
- Entity类node
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.lang.Integer> clearTableAsync(java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型clazz
- Entity类node
- 过滤条件<T> int dropTable(java.lang.Class<T> clazz)
T
- Entity泛型clazz
- Entity类<T> java.util.concurrent.CompletableFuture<java.lang.Integer> dropTableAsync(java.lang.Class<T> clazz)
T
- Entity泛型clazz
- Entity类<T> int dropTable(java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型clazz
- Entity类node
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.lang.Integer> dropTableAsync(java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型clazz
- Entity类node
- 过滤条件<T> int update(T... entitys)
T
- 泛型entitys
- Entity对象default <T> int update(java.util.Collection<T> entitys)
T
- 泛型entitys
- Entity对象default <T> int update(java.util.stream.Stream<T> entitys)
T
- 泛型entitys
- Entity对象<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateAsync(T... entitys)
T
- 泛型entitys
- Entity对象default <T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateAsync(java.util.Collection<T> entitys)
T
- 泛型entitys
- Entity对象default <T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateAsync(java.util.stream.Stream<T> entitys)
T
- 泛型entitys
- Entity对象<T> int updateColumn(java.lang.Class<T> clazz, java.io.Serializable pk, java.lang.String column, java.io.Serializable value)
T
- Entity泛型clazz
- Entity类pk
- 主键column
- 待更新的字段名value
- 更新值<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(java.lang.Class<T> clazz, java.io.Serializable pk, java.lang.String column, java.io.Serializable value)
T
- Entity泛型clazz
- Entity类pk
- 主键column
- 待更新的字段名value
- 更新值<T> int updateColumn(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable value, FilterNode node)
T
- Entity泛型clazz
- Entity类column
- 待更新的字段名value
- 更新值node
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable value, FilterNode node)
T
- Entity泛型clazz
- Entity类column
- 待更新的字段名value
- 更新值node
- 过滤条件<T> int updateColumn(java.lang.Class<T> clazz, java.io.Serializable pk, ColumnValue... values)
T
- Entity泛型clazz
- Entity类pk
- 主键values
- 更新字段<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(java.lang.Class<T> clazz, java.io.Serializable pk, ColumnValue... values)
T
- Entity泛型clazz
- Entity类pk
- 主键values
- 更新字段<T> int updateColumn(java.lang.Class<T> clazz, FilterNode node, ColumnValue... values)
T
- Entity泛型clazz
- Entity类node
- 过滤条件values
- 更新字段<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(java.lang.Class<T> clazz, FilterNode node, ColumnValue... values)
T
- Entity泛型clazz
- Entity类node
- 过滤条件values
- 更新字段<T> int updateColumn(java.lang.Class<T> clazz, FilterNode node, Flipper flipper, ColumnValue... values)
T
- Entity泛型clazz
- Entity类node
- 过滤条件flipper
- 翻页对象values
- 更新字段<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(java.lang.Class<T> clazz, FilterNode node, Flipper flipper, ColumnValue... values)
T
- Entity泛型clazz
- Entity类node
- 过滤条件flipper
- 翻页对象values
- 更新字段<T> int updateColumn(T entity, java.lang.String... columns)
T
- Entity泛型entity
- 待更新的Entity对象columns
- 需更新的字段名<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(T entity, java.lang.String... columns)
T
- Entity泛型entity
- 待更新的Entity对象columns
- 需更新的字段名<T> int updateColumn(T entity, FilterNode node, java.lang.String... columns)
T
- Entity泛型entity
- 待更新的Entity对象node
- 过滤条件columns
- 需更新的字段名<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(T entity, FilterNode node, java.lang.String... columns)
T
- Entity泛型entity
- 待更新的Entity对象node
- 过滤条件columns
- 需更新的字段名<T> int updateColumn(T entity, SelectColumn selects)
T
- Entity泛型entity
- 待更新的Entity对象selects
- 指定字段<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(T entity, SelectColumn selects)
T
- Entity泛型entity
- 待更新的Entity对象selects
- 指定字段<T> int updateColumn(T entity, FilterNode node, SelectColumn selects)
T
- Entity泛型entity
- 待更新的Entity对象node
- 过滤条件selects
- 指定字段<T> java.util.concurrent.CompletableFuture<java.lang.Integer> updateColumnAsync(T entity, FilterNode node, SelectColumn selects)
T
- Entity泛型entity
- 待更新的Entity对象node
- 过滤条件selects
- 指定字段java.lang.Number getNumberResult(java.lang.Class entityClass, FilterFunc func, java.lang.String column)
entityClass
- Entity类func
- 聚合函数column
- 指定字段java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass, FilterFunc func, java.lang.String column)
entityClass
- Entity类func
- 聚合函数column
- 指定字段java.lang.Number getNumberResult(java.lang.Class entityClass, FilterFunc func, java.lang.String column, FilterBean bean)
entityClass
- Entity类func
- 聚合函数column
- 指定字段bean
- 过滤条件java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass, FilterFunc func, java.lang.String column, FilterBean bean)
entityClass
- Entity类func
- 聚合函数column
- 指定字段bean
- 过滤条件java.lang.Number getNumberResult(java.lang.Class entityClass, FilterFunc func, java.lang.String column, FilterNode node)
entityClass
- Entity类func
- 聚合函数column
- 指定字段node
- 过滤条件java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass, FilterFunc func, java.lang.String column, FilterNode node)
entityClass
- Entity类func
- 聚合函数column
- 指定字段node
- 过滤条件java.lang.Number getNumberResult(java.lang.Class entityClass, FilterFunc func, java.lang.Number defVal, java.lang.String column)
entityClass
- Entity类func
- 聚合函数defVal
- 默认值column
- 指定字段java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass, FilterFunc func, java.lang.Number defVal, java.lang.String column)
entityClass
- Entity类func
- 聚合函数defVal
- 默认值column
- 指定字段java.lang.Number getNumberResult(java.lang.Class entityClass, FilterFunc func, java.lang.Number defVal, java.lang.String column, FilterBean bean)
entityClass
- Entity类func
- 聚合函数defVal
- 默认值column
- 指定字段bean
- 过滤条件java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass, FilterFunc func, java.lang.Number defVal, java.lang.String column, FilterBean bean)
entityClass
- Entity类func
- 聚合函数defVal
- 默认值column
- 指定字段bean
- 过滤条件java.lang.Number getNumberResult(java.lang.Class entityClass, FilterFunc func, java.lang.Number defVal, java.lang.String column, FilterNode node)
entityClass
- Entity类func
- 聚合函数defVal
- 默认值column
- 指定字段node
- 过滤条件java.util.concurrent.CompletableFuture<java.lang.Number> getNumberResultAsync(java.lang.Class entityClass, FilterFunc func, java.lang.Number defVal, java.lang.String column, FilterNode node)
entityClass
- Entity类func
- 聚合函数defVal
- 默认值column
- 指定字段node
- 过滤条件<N extends java.lang.Number> java.util.Map<java.lang.String,N> getNumberMap(java.lang.Class entityClass, FilterFuncColumn... columns)
N
- NumberentityClass
- Entity类columns
- 聚合字段<N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<java.lang.String,N>> getNumberMapAsync(java.lang.Class entityClass, FilterFuncColumn... columns)
N
- NumberentityClass
- Entity类columns
- 聚合字段<N extends java.lang.Number> java.util.Map<java.lang.String,N> getNumberMap(java.lang.Class entityClass, FilterBean bean, FilterFuncColumn... columns)
N
- NumberentityClass
- Entity类bean
- 过滤条件columns
- 聚合字段<N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<java.lang.String,N>> getNumberMapAsync(java.lang.Class entityClass, FilterBean bean, FilterFuncColumn... columns)
N
- NumberentityClass
- Entity类bean
- 过滤条件columns
- 聚合字段<N extends java.lang.Number> java.util.Map<java.lang.String,N> getNumberMap(java.lang.Class entityClass, FilterNode node, FilterFuncColumn... columns)
N
- NumberentityClass
- Entity类node
- 过滤条件columns
- 聚合字段<N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<java.lang.String,N>> getNumberMapAsync(java.lang.Class entityClass, FilterNode node, FilterFuncColumn... columns)
N
- NumberentityClass
- Entity类node
- 过滤条件columns
- 聚合字段<T,K extends java.io.Serializable,N extends java.lang.Number> java.util.Map<K,N> queryColumnMap(java.lang.Class<T> entityClass, java.lang.String keyColumn, FilterFunc func, java.lang.String funcColumn)
T
- Entity泛型K
- Key字段的数据类型N
- NumberentityClass
- Entity类keyColumn
- Key字段func
- 聚合函数funcColumn
- 聚合字段<T,K extends java.io.Serializable,N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<K,N>> queryColumnMapAsync(java.lang.Class<T> entityClass, java.lang.String keyColumn, FilterFunc func, java.lang.String funcColumn)
T
- Entity泛型K
- Key字段的数据类型N
- NumberentityClass
- Entity类keyColumn
- Key字段func
- 聚合函数funcColumn
- 聚合字段<T,K extends java.io.Serializable,N extends java.lang.Number> java.util.Map<K,N> queryColumnMap(java.lang.Class<T> entityClass, java.lang.String keyColumn, FilterFunc func, java.lang.String funcColumn, FilterBean bean)
T
- Entity泛型K
- Key字段的数据类型N
- NumberentityClass
- Entity类keyColumn
- Key字段func
- 聚合函数funcColumn
- 聚合字段bean
- 过滤条件<T,K extends java.io.Serializable,N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<K,N>> queryColumnMapAsync(java.lang.Class<T> entityClass, java.lang.String keyColumn, FilterFunc func, java.lang.String funcColumn, FilterBean bean)
T
- Entity泛型K
- Key字段的数据类型N
- NumberentityClass
- Entity类keyColumn
- Key字段func
- 聚合函数funcColumn
- 聚合字段bean
- 过滤条件<T,K extends java.io.Serializable,N extends java.lang.Number> java.util.Map<K,N> queryColumnMap(java.lang.Class<T> entityClass, java.lang.String keyColumn, FilterFunc func, java.lang.String funcColumn, FilterNode node)
T
- Entity泛型K
- Key字段的数据类型N
- NumberentityClass
- Entity类keyColumn
- Key字段func
- 聚合函数funcColumn
- 聚合字段node
- 过滤条件<T,K extends java.io.Serializable,N extends java.lang.Number> java.util.concurrent.CompletableFuture<java.util.Map<K,N>> queryColumnMapAsync(java.lang.Class<T> entityClass, java.lang.String keyColumn, FilterFunc func, java.lang.String funcColumn, FilterNode node)
T
- Entity泛型K
- Key字段的数据类型N
- NumberentityClass
- Entity类keyColumn
- Key字段func
- 聚合函数funcColumn
- 聚合字段node
- 过滤条件<T> T find(java.lang.Class<T> clazz, java.io.Serializable pk)
T
- Entity泛型clazz
- Entity类pk
- 主键值<T> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.Class<T> clazz, java.io.Serializable pk)
T
- Entity泛型clazz
- Entity类pk
- 主键值<T> T find(java.lang.Class<T> clazz, SelectColumn selects, java.io.Serializable pk)
T
- Entity泛型clazz
- Entity类selects
- 指定字段pk
- 主键值<T> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.Class<T> clazz, SelectColumn selects, java.io.Serializable pk)
T
- Entity泛型clazz
- Entity类selects
- 指定字段pk
- 主键值<T> T find(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable colval)
T
- Entity泛型clazz
- Entity类column
- 过滤字段名colval
- 过滤字段值<T> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable colval)
T
- Entity泛型clazz
- Entity类column
- 过滤字段名colval
- 过滤字段值<T> T find(java.lang.Class<T> clazz, FilterBean bean)
T
- Entity泛型clazz
- Entity类bean
- 过滤条件<T> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.Class<T> clazz, FilterBean bean)
T
- Entity泛型clazz
- Entity类bean
- 过滤条件<T> T find(java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型clazz
- Entity类node
- 过滤条件<T> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型clazz
- Entity类node
- 过滤条件<T> T find(java.lang.Class<T> clazz, SelectColumn selects, FilterBean bean)
T
- Entity泛型clazz
- Entity类selects
- 指定字段bean
- 过滤条件<T> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.Class<T> clazz, SelectColumn selects, FilterBean bean)
T
- Entity泛型clazz
- Entity类selects
- 指定字段bean
- 过滤条件<T> T find(java.lang.Class<T> clazz, SelectColumn selects, FilterNode node)
T
- Entity泛型clazz
- Entity类selects
- 指定字段node
- 过滤条件<T> java.util.concurrent.CompletableFuture<T> findAsync(java.lang.Class<T> clazz, SelectColumn selects, FilterNode node)
T
- Entity泛型clazz
- Entity类selects
- 指定字段node
- 过滤条件<T> java.io.Serializable findColumn(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable pk)
T
- Entity泛型clazz
- Entity类column
- 字段名pk
- 主键值<T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable pk)
T
- Entity泛型clazz
- Entity类column
- 字段名pk
- 主键值<T> java.io.Serializable findColumn(java.lang.Class<T> clazz, java.lang.String column, FilterBean bean)
T
- Entity泛型clazz
- Entity类column
- 字段名bean
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnAsync(java.lang.Class<T> clazz, java.lang.String column, FilterBean bean)
T
- Entity泛型clazz
- Entity类column
- 字段名bean
- 过滤条件<T> java.io.Serializable findColumn(java.lang.Class<T> clazz, java.lang.String column, FilterNode node)
T
- Entity泛型clazz
- Entity类column
- 字段名node
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnAsync(java.lang.Class<T> clazz, java.lang.String column, FilterNode node)
T
- Entity泛型clazz
- Entity类column
- 字段名node
- 过滤条件<T> java.io.Serializable findColumn(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable defValue, java.io.Serializable pk)
T
- Entity泛型clazz
- Entity类column
- 字段名defValue
- 默认值pk
- 主键值<T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable defValue, java.io.Serializable pk)
T
- Entity泛型clazz
- Entity类column
- 字段名defValue
- 默认值pk
- 主键值<T> java.io.Serializable findColumn(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable defValue, FilterBean bean)
T
- Entity泛型clazz
- Entity类column
- 字段名defValue
- 默认值bean
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable defValue, FilterBean bean)
T
- Entity泛型clazz
- Entity类column
- 字段名defValue
- 默认值bean
- 过滤条件<T> java.io.Serializable findColumn(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable defValue, FilterNode node)
T
- Entity泛型clazz
- Entity类column
- 字段名defValue
- 默认值node
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.io.Serializable> findColumnAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable defValue, FilterNode node)
T
- Entity泛型clazz
- Entity类column
- 字段名defValue
- 默认值node
- 过滤条件<T> boolean exists(java.lang.Class<T> clazz, java.io.Serializable pk)
T
- Entity泛型clazz
- Entity类pk
- 主键值<T> java.util.concurrent.CompletableFuture<java.lang.Boolean> existsAsync(java.lang.Class<T> clazz, java.io.Serializable pk)
T
- Entity泛型clazz
- Entity类pk
- 主键值<T> boolean exists(java.lang.Class<T> clazz, FilterBean bean)
T
- Entity泛型clazz
- Entity类bean
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.lang.Boolean> existsAsync(java.lang.Class<T> clazz, FilterBean bean)
T
- Entity泛型clazz
- Entity类bean
- 过滤条件<T> boolean exists(java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型clazz
- Entity类node
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.lang.Boolean> existsAsync(java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型clazz
- Entity类node
- 过滤条件<T,V extends java.io.Serializable> java.util.HashSet<V> queryColumnSet(java.lang.String selectedColumn, java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable colval)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类column
- 过滤字段名colval
- 过滤字段值<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.HashSet<V>> queryColumnSetAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable colval)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类column
- 过滤字段名colval
- 过滤字段值<T,V extends java.io.Serializable> java.util.HashSet<V> queryColumnSet(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterBean bean)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类bean
- 过滤条件<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.HashSet<V>> queryColumnSetAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterBean bean)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类bean
- 过滤条件<T,V extends java.io.Serializable> java.util.HashSet<V> queryColumnSet(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类node
- 过滤条件<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.HashSet<V>> queryColumnSetAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类node
- 过滤条件<T,V extends java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn, java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable colval)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类column
- 过滤字段名colval
- 过滤字段值<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>> queryColumnListAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable colval)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类column
- 过滤字段名colval
- 过滤字段值<T,V extends java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterBean bean)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类bean
- 过滤条件<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>> queryColumnListAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterBean bean)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类bean
- 过滤条件<T,V extends java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类node
- 过滤条件<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>> queryColumnListAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类node
- 过滤条件<T,V extends java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterBean bean)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类flipper
- 翻页对象bean
- 过滤条件<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>> queryColumnListAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterBean bean)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类flipper
- 翻页对象bean
- 过滤条件<T,V extends java.io.Serializable> java.util.List<V> queryColumnList(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterNode node)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类flipper
- 翻页对象node
- 过滤条件<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<java.util.List<V>> queryColumnListAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterNode node)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类flipper
- 翻页对象node
- 过滤条件<T,V extends java.io.Serializable> Sheet<V> queryColumnSheet(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterBean bean)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类flipper
- 翻页对象bean
- 过滤条件<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<Sheet<V>> queryColumnSheetAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterBean bean)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类flipper
- 翻页对象bean
- 过滤条件<T,V extends java.io.Serializable> Sheet<V> queryColumnSheet(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterNode node)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类flipper
- 翻页对象node
- 过滤条件<T,V extends java.io.Serializable> java.util.concurrent.CompletableFuture<Sheet<V>> queryColumnSheetAsync(java.lang.String selectedColumn, java.lang.Class<T> clazz, Flipper flipper, FilterNode node)
T
- Entity泛型V
- 字段类型selectedColumn
- 指定字段clazz
- Entity类flipper
- 翻页对象node
- 过滤条件<K extends java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz, java.util.stream.Stream<K> keyStream)
K
- 主键泛型T
- Entity泛型clazz
- Entity类keyStream
- 主键Stream<K extends java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.Class<T> clazz, java.util.stream.Stream<K> keyStream)
K
- 主键泛型T
- Entity泛型clazz
- Entity类keyStream
- 主键Stream<K extends java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz, FilterBean bean)
K
- 主键泛型T
- Entity泛型clazz
- Entity类bean
- FilterBean<K extends java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.Class<T> clazz, FilterBean bean)
K
- 主键泛型T
- Entity泛型clazz
- Entity类bean
- FilterBean<K extends java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz, FilterNode node)
K
- 主键泛型T
- Entity泛型clazz
- Entity类node
- FilterNode<K extends java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.Class<T> clazz, FilterNode node)
K
- 主键泛型T
- Entity泛型clazz
- Entity类node
- FilterNode<K extends java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz, SelectColumn selects, java.util.stream.Stream<K> keyStream)
K
- 主键泛型T
- Entity泛型clazz
- Entity类selects
- 指定字段keyStream
- 主键Stream<K extends java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.Class<T> clazz, SelectColumn selects, java.util.stream.Stream<K> keyStream)
K
- 主键泛型T
- Entity泛型clazz
- Entity类selects
- 指定字段keyStream
- 主键Stream<K extends java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz, SelectColumn selects, FilterBean bean)
K
- 主键泛型T
- Entity泛型clazz
- Entity类selects
- 指定字段bean
- FilterBean<K extends java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.Class<T> clazz, SelectColumn selects, FilterBean bean)
K
- 主键泛型T
- Entity泛型clazz
- Entity类selects
- 指定字段bean
- FilterBean<K extends java.io.Serializable,T> java.util.Map<K,T> queryMap(java.lang.Class<T> clazz, SelectColumn selects, FilterNode node)
K
- 主键泛型T
- Entity泛型clazz
- Entity类selects
- 指定字段node
- FilterNode<K extends java.io.Serializable,T> java.util.concurrent.CompletableFuture<java.util.Map<K,T>> queryMapAsync(java.lang.Class<T> clazz, SelectColumn selects, FilterNode node)
K
- 主键泛型T
- Entity泛型clazz
- Entity类selects
- 指定字段node
- FilterNode<T> java.util.List<T> queryList(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable colval)
T
- Entity泛型clazz
- Entity类column
- 过滤字段名colval
- 过滤字段值<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz, java.lang.String column, java.io.Serializable colval)
T
- Entity泛型clazz
- Entity类column
- 过滤字段名colval
- 过滤字段值<T> java.util.List<T> queryList(java.lang.Class<T> clazz, FilterBean bean)
T
- Entity泛型clazz
- Entity类bean
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz, FilterBean bean)
T
- Entity泛型clazz
- Entity类bean
- 过滤条件default <T> java.util.List<T> queryList(java.lang.Class<T> clazz)
T
- Entity泛型clazz
- Entity类<T> java.util.List<T> queryList(java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型clazz
- Entity类node
- 过滤条件default <T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz)
T
- Entity泛型clazz
- Entity类<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz, FilterNode node)
T
- Entity泛型clazz
- Entity类node
- 过滤条件<T> java.util.List<T> queryList(java.lang.Class<T> clazz, SelectColumn selects, FilterBean bean)
T
- Entity泛型clazz
- Entity类selects
- 指定字段bean
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz, SelectColumn selects, FilterBean bean)
T
- Entity泛型clazz
- Entity类selects
- 指定字段bean
- 过滤条件<T> java.util.List<T> queryList(java.lang.Class<T> clazz, SelectColumn selects, FilterNode node)
T
- Entity泛型clazz
- Entity类selects
- 指定字段node
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz, SelectColumn selects, FilterNode node)
T
- Entity泛型clazz
- Entity类selects
- 指定字段node
- 过滤条件<T> java.util.List<T> queryList(java.lang.Class<T> clazz, Flipper flipper, java.lang.String column, java.io.Serializable colval)
T
- Entity泛型clazz
- Entity类flipper
- 翻页对象column
- 过滤字段名colval
- 过滤字段值<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz, Flipper flipper, java.lang.String column, java.io.Serializable colval)
T
- Entity泛型clazz
- Entity类flipper
- 翻页对象column
- 过滤字段名colval
- 过滤字段值<T> java.util.List<T> queryList(java.lang.Class<T> clazz, Flipper flipper, FilterBean bean)
T
- Entity泛型clazz
- Entity类flipper
- 翻页对象bean
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz, Flipper flipper, FilterBean bean)
T
- Entity泛型clazz
- Entity类flipper
- 翻页对象bean
- 过滤条件<T> java.util.List<T> queryList(java.lang.Class<T> clazz, Flipper flipper, FilterNode node)
T
- Entity泛型clazz
- Entity类flipper
- 翻页对象node
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz, Flipper flipper, FilterNode node)
T
- Entity泛型clazz
- Entity类flipper
- 翻页对象node
- 过滤条件<T> java.util.List<T> queryList(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
T
- Entity泛型clazz
- Entity类selects
- 指定字段flipper
- 翻页对象bean
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
T
- Entity泛型clazz
- Entity类selects
- 指定字段flipper
- 翻页对象bean
- 过滤条件<T> java.util.List<T> queryList(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
T
- Entity泛型clazz
- Entity类selects
- 指定字段flipper
- 翻页对象node
- 过滤条件<T> java.util.concurrent.CompletableFuture<java.util.List<T>> queryListAsync(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
T
- Entity泛型clazz
- Entity类selects
- 指定字段flipper
- 翻页对象node
- 过滤条件<T> Sheet<T> querySheet(java.lang.Class<T> clazz, Flipper flipper, FilterBean bean)
T
- Entity泛型clazz
- Entity类flipper
- 翻页对象bean
- 过滤条件<T> java.util.concurrent.CompletableFuture<Sheet<T>> querySheetAsync(java.lang.Class<T> clazz, Flipper flipper, FilterBean bean)
T
- Entity泛型clazz
- Entity类flipper
- 翻页对象bean
- 过滤条件<T> Sheet<T> querySheet(java.lang.Class<T> clazz, Flipper flipper, FilterNode node)
T
- Entity泛型clazz
- Entity类flipper
- 翻页对象node
- 过滤条件<T> java.util.concurrent.CompletableFuture<Sheet<T>> querySheetAsync(java.lang.Class<T> clazz, Flipper flipper, FilterNode node)
T
- Entity泛型clazz
- Entity类flipper
- 翻页对象node
- 过滤条件<T> Sheet<T> querySheet(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
T
- Entity泛型clazz
- Entity类selects
- 指定字段flipper
- 翻页对象bean
- 过滤条件<T> java.util.concurrent.CompletableFuture<Sheet<T>> querySheetAsync(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterBean bean)
T
- Entity泛型clazz
- Entity类selects
- 指定字段flipper
- 翻页对象bean
- 过滤条件<T> Sheet<T> querySheet(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
T
- Entity泛型clazz
- Entity类selects
- 指定字段flipper
- 翻页对象node
- 过滤条件<T> java.util.concurrent.CompletableFuture<Sheet<T>> querySheetAsync(java.lang.Class<T> clazz, SelectColumn selects, Flipper flipper, FilterNode node)
T
- Entity泛型clazz
- Entity类selects
- 指定字段flipper
- 翻页对象node
- 过滤条件