Flipper |
Flipper.copyFrom(Flipper copy) |
|
Flipper |
Flipper.copyTo(Flipper copy) |
|
protected Comparator<T> |
EntityCache.createComparator(Flipper flipper) |
|
protected String |
AbstractDataSqlSource.createOrderbySql(EntityInfo info,
Flipper flipper) |
根据Flipper获取ORDER BY的SQL语句，不存在Flipper或sort字段返回空字符串
|
protected <T> AbstractDataSqlSource.PageCountSql |
AbstractDataSqlSource.createPageCountSql(EntityInfo<T> info,
boolean readCache,
boolean needTotal,
boolean distinct,
SelectColumn selects,
String[] tables,
Flipper flipper,
FilterNode node) |
|
<T> DataBatch |
AbstractDataSource.DefaultDataBatch.delete(Class<T> clazz,
FilterNode node,
Flipper flipper) |
|
<T> int |
AbstractDataSqlSource.delete(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> DataBatch |
DataBatch.delete(Class<T> clazz,
FilterNode node,
Flipper flipper) |
|
<T> int |
DataMemorySource.delete(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> int |
DataSource.delete(Class<T> clazz,
Flipper flipper,
FilterNode node) |
删除符合过滤条件且指定最大影响条数的记录
Flipper中offset字段将被忽略
等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
Serializable[] |
EntityCache.delete(Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<Integer> |
AbstractDataSqlSource.deleteAsync(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<Integer> |
DataMemorySource.deleteAsync(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<Integer> |
DataSource.deleteAsync(Class<T> clazz,
Flipper flipper,
FilterNode node) |
删除符合过滤条件且指定最大影响条数的记录
Flipper中offset字段将被忽略
等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
protected <T> int |
AbstractDataSqlSource.deleteCache(EntityInfo<T> info,
int count,
Flipper flipper,
FilterNode node) |
|
protected <T> int |
AbstractDataSqlSource.deleteDB(EntityInfo<T> info,
String[] tables,
Flipper flipper,
FilterNode node,
Map<String,List<Serializable>> pkmap,
String... sqls) |
|
protected <T> int |
DataJdbcSource.deleteDB(EntityInfo<T> info,
String[] tables,
Flipper flipper,
FilterNode node,
Map<String,List<Serializable>> pkmap,
String... sqls) |
|
protected abstract <T> CompletableFuture<Integer> |
AbstractDataSqlSource.deleteDBAsync(EntityInfo<T> info,
String[] tables,
Flipper flipper,
FilterNode node,
Map<String,List<Serializable>> pkmap,
String... sqls) |
|
protected <T> CompletableFuture<Integer> |
DataJdbcSource.deleteDBAsync(EntityInfo<T> info,
String[] tables,
Flipper flipper,
FilterNode node,
Map<String,List<Serializable>> pkmap,
String... sqls) |
|
protected <T> String[] |
AbstractDataSqlSource.deleteSql(EntityInfo<T> info,
String[] tables,
Flipper flipper,
FilterNode node) |
|
PageBean<T> |
PageBean.flipper(Flipper flipper) |
|
static boolean |
Flipper.hasLimit(Flipper flipper) |
|
<V> Sheet<V> |
DataJdbcSource.nativeQuerySheet(Class<V> type,
String sql,
Flipper flipper,
Map<String,Object> params) |
|
<T,V extends Serializable>
List<V> |
AbstractDataSource.queryColumnList(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T,V extends Serializable>
List<V> |
AbstractDataSqlSource.queryColumnList(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
List<V> |
DataMemorySource.queryColumnList(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
default <T,V extends Serializable>
List<V> |
DataSource.queryColumnList(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T,V extends Serializable>
List<V> |
DataSource.queryColumnList(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <V extends Serializable>
List<V> |
DataSqlMapper.queryColumnList(String selectedColumn,
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,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T,V extends Serializable>
CompletableFuture<List<V>> |
AbstractDataSource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T,V extends Serializable>
CompletableFuture<List<V>> |
AbstractDataSqlSource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
CompletableFuture<List<V>> |
DataMemorySource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
default <T,V extends Serializable>
CompletableFuture<List<V>> |
DataSource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
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>> |
DataSource.queryColumnListAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <V extends Serializable>
CompletableFuture<List<V>> |
DataSqlMapper.queryColumnListAsync(String selectedColumn,
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,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段List集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T,V extends Serializable>
Set<V> |
AbstractDataSource.queryColumnSet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T,V extends Serializable>
Set<V> |
AbstractDataSqlSource.queryColumnSet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
Set<V> |
DataMemorySource.queryColumnSet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
default <T,V extends Serializable>
Set<V> |
DataSource.queryColumnSet(String selectedColumn,
Class<T> clazz,
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>
Set<V> |
DataSource.queryColumnSet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT
{flipper.limit}
|
default <V extends Serializable>
Set<V> |
DataSqlMapper.queryColumnSet(String selectedColumn,
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,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT
{flipper.limit}
|
<T,V extends Serializable>
CompletableFuture<Set<V>> |
AbstractDataSource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T,V extends Serializable>
CompletableFuture<Set<V>> |
AbstractDataSqlSource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
CompletableFuture<Set<V>> |
DataMemorySource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
default <T,V extends Serializable>
CompletableFuture<Set<V>> |
DataSource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
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>> |
DataSource.queryColumnSetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT
{flipper.limit}
|
default <V extends Serializable>
CompletableFuture<Set<V>> |
DataSqlMapper.queryColumnSetAsync(String selectedColumn,
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,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Set集合
等价SQL: SELECT DISTINCT {selectedColumn} FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT
{flipper.limit}
|
<T,V extends Serializable>
Sheet<V> |
AbstractDataSource.queryColumnSheet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
根据指定参数查询对象某个字段的集合
|
<T,V extends Serializable>
Sheet<V> |
AbstractDataSqlSource.queryColumnSheet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
Sheet<V> |
DataMemorySource.queryColumnSheet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
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}
|
<T,V extends Serializable>
Sheet<V> |
DataSource.queryColumnSheet(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <V extends Serializable>
Sheet<V> |
DataSqlMapper.queryColumnSheet(String selectedColumn,
Flipper flipper,
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,
FilterNode node) |
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T,V extends Serializable>
CompletableFuture<Sheet<V>> |
AbstractDataSource.queryColumnSheetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T,V extends Serializable>
CompletableFuture<Sheet<V>> |
AbstractDataSqlSource.queryColumnSheetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T,V extends Serializable>
CompletableFuture<Sheet<V>> |
DataMemorySource.queryColumnSheetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
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}
|
<T,V extends Serializable>
CompletableFuture<Sheet<V>> |
DataSource.queryColumnSheetAsync(String selectedColumn,
Class<T> clazz,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <V extends Serializable>
CompletableFuture<Sheet<V>> |
DataSqlMapper.queryColumnSheetAsync(String selectedColumn,
Flipper flipper,
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,
FilterNode node) |
查询符合过滤条件记录的某个字段Sheet集合
等价SQL: SELECT {selectedColumn} FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T> List<T> |
AbstractDataSource.queryList(Class<T> clazz,
Flipper flipper,
String column,
Serializable colval) |
|
<T> List<T> |
AbstractDataSource.queryList(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T> List<T> |
AbstractDataSource.queryList(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> List<T> |
AbstractDataSource.queryList(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
|
<T> List<T> |
AbstractDataSqlSource.queryList(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
<T> List<T> |
DataMemorySource.queryList(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
default <T> List<T> |
DataSource.queryList(Class<T> clazz,
Flipper flipper) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T> List<T> |
DataSource.queryList(Class<T> clazz,
Flipper flipper,
String column,
Serializable colval) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <T> List<T> |
DataSource.queryList(Class<T> clazz,
SelectColumn selects,
Flipper flipper) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <T> List<T> |
DataSource.queryList(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
<T> List<T> |
DataSource.queryList(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
default List<T> |
DataSqlMapper.queryList(Flipper flipper) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default List<T> |
DataSqlMapper.queryList(Flipper flipper,
String column,
Serializable colval) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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(Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default List<T> |
DataSqlMapper.queryList(SelectColumn selects,
Flipper flipper) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default List<T> |
DataSqlMapper.queryList(SelectColumn selects,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
default List<T> |
DataSqlMapper.queryList(SelectColumn selects,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
<T> CompletableFuture<List<T>> |
AbstractDataSource.queryListAsync(Class<T> clazz,
Flipper flipper,
String column,
Serializable colval) |
|
<T> CompletableFuture<List<T>> |
AbstractDataSource.queryListAsync(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T> CompletableFuture<List<T>> |
AbstractDataSource.queryListAsync(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<List<T>> |
AbstractDataSource.queryListAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
|
<T> CompletableFuture<List<T>> |
AbstractDataSqlSource.queryListAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<List<T>> |
DataMemorySource.queryListAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
default <T> CompletableFuture<List<T>> |
DataSource.queryListAsync(Class<T> clazz,
Flipper flipper) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
<T> CompletableFuture<List<T>> |
DataSource.queryListAsync(Class<T> clazz,
Flipper flipper,
String column,
Serializable colval) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <T> CompletableFuture<List<T>> |
DataSource.queryListAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <T> CompletableFuture<List<T>> |
DataSource.queryListAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
<T> CompletableFuture<List<T>> |
DataSource.queryListAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
default CompletableFuture<List<T>> |
DataSqlMapper.queryListAsync(Flipper flipper) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default CompletableFuture<List<T>> |
DataSqlMapper.queryListAsync(Flipper flipper,
String column,
Serializable colval) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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(Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default CompletableFuture<List<T>> |
DataSqlMapper.queryListAsync(SelectColumn selects,
Flipper flipper) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default CompletableFuture<List<T>> |
DataSqlMapper.queryListAsync(SelectColumn selects,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
default CompletableFuture<List<T>> |
DataSqlMapper.queryListAsync(SelectColumn selects,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的List集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
<T> Set<T> |
AbstractDataSource.querySet(Class<T> clazz,
Flipper flipper,
String column,
Serializable colval) |
|
<T> Set<T> |
AbstractDataSource.querySet(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T> Set<T> |
AbstractDataSource.querySet(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> Set<T> |
AbstractDataSource.querySet(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
|
<T> Set<T> |
AbstractDataSqlSource.querySet(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
<T> Set<T> |
DataMemorySource.querySet(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
<T> Set<T> |
DataSource.querySet(Class<T> clazz,
Flipper flipper,
String column,
Serializable colval) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <T> Set<T> |
DataSource.querySet(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY
{flipper.sort} LIMIT {flipper.limit}
|
<T> Set<T> |
DataSource.querySet(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY
{flipper.sort} LIMIT {flipper.limit}
|
default Set<T> |
DataSqlMapper.querySet(Flipper flipper,
String column,
Serializable colval) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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(Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default Set<T> |
DataSqlMapper.querySet(SelectColumn selects,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY
{flipper.sort} LIMIT {flipper.limit}
|
default Set<T> |
DataSqlMapper.querySet(SelectColumn selects,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY
{flipper.sort} LIMIT {flipper.limit}
|
<T> CompletableFuture<Set<T>> |
AbstractDataSource.querySetAsync(Class<T> clazz,
Flipper flipper,
String column,
Serializable colval) |
|
<T> CompletableFuture<Set<T>> |
AbstractDataSource.querySetAsync(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T> CompletableFuture<Set<T>> |
AbstractDataSource.querySetAsync(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<Set<T>> |
AbstractDataSource.querySetAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
|
<T> CompletableFuture<Set<T>> |
AbstractDataSqlSource.querySetAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<Set<T>> |
DataMemorySource.querySetAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<Set<T>> |
DataSource.querySetAsync(Class<T> clazz,
Flipper flipper,
String column,
Serializable colval) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default <T> CompletableFuture<Set<T>> |
DataSource.querySetAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY
{flipper.sort} LIMIT {flipper.limit}
|
<T> CompletableFuture<Set<T>> |
DataSource.querySetAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY
{flipper.sort} LIMIT {flipper.limit}
|
default CompletableFuture<Set<T>> |
DataSqlMapper.querySetAsync(Flipper flipper,
String column,
Serializable colval) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
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(Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default CompletableFuture<Set<T>> |
DataSqlMapper.querySetAsync(SelectColumn selects,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY
{flipper.sort} LIMIT {flipper.limit}
|
default CompletableFuture<Set<T>> |
DataSqlMapper.querySetAsync(SelectColumn selects,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Set集合
等价SQL: SELECT DISTINCT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY
{flipper.sort} LIMIT {flipper.limit}
|
<T> Sheet<T> |
AbstractDataSource.querySheet(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
根据过滤对象FilterBean和翻页对象Flipper查询一页的数据
|
<T> Sheet<T> |
AbstractDataSource.querySheet(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> Sheet<T> |
AbstractDataSource.querySheet(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
根据过滤对象FilterBean和翻页对象Flipper查询一页的数据， 对象只填充或排除SelectField指定的字段
|
protected <T> Sheet<T> |
AbstractDataSqlSource.querySheet(boolean readCache,
boolean needTotal,
boolean distinct,
Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
<T> Sheet<T> |
AbstractDataSqlSource.querySheet(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
<T> Sheet<T> |
DataMemorySource.querySheet(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
default <T> Sheet<T> |
DataSource.querySheet(Class<T> clazz,
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,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter node} 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}
|
<T> Sheet<T> |
DataSource.querySheet(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
default Sheet<T> |
DataSqlMapper.querySheet(Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default Sheet<T> |
DataSqlMapper.querySheet(Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default Sheet<T> |
DataSqlMapper.querySheet(SelectColumn selects,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
default Sheet<T> |
DataSqlMapper.querySheet(SelectColumn selects,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
Sheet<T> |
EntityCache.querySheet(boolean needTotal,
boolean distinct,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
Sheet<T> |
EntityCache.querySheet(SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<Sheet<T>> |
AbstractDataSource.querySheetAsync(Class<T> clazz,
Flipper flipper,
FilterBean bean) |
|
<T> CompletableFuture<Sheet<T>> |
AbstractDataSource.querySheetAsync(Class<T> clazz,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<Sheet<T>> |
AbstractDataSource.querySheetAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterBean bean) |
|
protected <T> CompletableFuture<Sheet<T>> |
AbstractDataSqlSource.querySheetAsync(boolean readCache,
boolean needTotal,
boolean distinct,
Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<Sheet<T>> |
AbstractDataSqlSource.querySheetAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
<T> CompletableFuture<Sheet<T>> |
DataMemorySource.querySheetAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
default <T> CompletableFuture<Sheet<T>> |
DataSource.querySheetAsync(Class<T> clazz,
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,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter node} 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}
|
<T> CompletableFuture<Sheet<T>> |
DataSource.querySheetAsync(Class<T> clazz,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
default CompletableFuture<Sheet<T>> |
DataSqlMapper.querySheetAsync(Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter bean} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default CompletableFuture<Sheet<T>> |
DataSqlMapper.querySheetAsync(Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT * FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
|
default CompletableFuture<Sheet<T>> |
DataSqlMapper.querySheetAsync(SelectColumn selects,
Flipper flipper,
FilterBean bean) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
default CompletableFuture<Sheet<T>> |
DataSqlMapper.querySheetAsync(SelectColumn selects,
Flipper flipper,
FilterNode node) |
查询符合过滤条件记录的Sheet集合
等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node} ORDER BY {flipper.sort}
LIMIT {flipper.limit}
|
protected <T> Sheet<T> |
AbstractDataSqlSource.querySheetDB(EntityInfo<T> info,
boolean readcache,
boolean needtotal,
boolean distinct,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
protected <T> Sheet<T> |
DataJdbcSource.querySheetDB(EntityInfo<T> info,
boolean readCache,
boolean needTotal,
boolean distinct,
SelectColumn selects,
Flipper flipper,
FilterNode node) |
|
protected abstract <T> CompletableFuture<Sheet<T>> |
AbstractDataSqlSource.querySheetDBAsync(EntityInfo<T> info,
boolean readcache,
boolean needtotal,
boolean distinct,
SelectColumn selects,
Flipper flipper,
FilterNode node,
boolean inCacheLoad) |
|
protected <T> CompletableFuture<Sheet<T>> |
DataJdbcSource.querySheetDBAsync(EntityInfo<T> info,
boolean readCache,
boolean needTotal,
boolean distinct,
SelectColumn selects,
Flipper flipper,
FilterNode node,
boolean inCacheLoad) |
|
void |
PageBean.setFlipper(Flipper flipper) |
|
static Flipper |
Flipper.sortIfAbsent(Flipper flipper,
String sort) |
|
protected <T> int |
AbstractDataSqlSource.updateCache(EntityInfo<T> info,
int count,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> DataBatch |
AbstractDataSource.DefaultDataBatch.updateColumn(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> int |
AbstractDataSqlSource.updateColumn(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> DataBatch |
DataBatch.updateColumn(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> int |
DataMemorySource.updateColumn(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> int |
DataSource.updateColumn(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node} ORDER BY {flipper.sort}
|
default <T> int |
DataSource.updateColumn(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValues values) |
更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node} ORDER BY {flipper.sort}
|
default int |
DataSqlMapper.updateColumn(FilterNode node,
Flipper flipper,
ColumnValue... values) |
更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node} ORDER BY {flipper.sort}
|
T[] |
EntityCache.updateColumn(FilterNode node,
Flipper flipper,
List<Attribute<T,Serializable>> attrs,
List<ColumnValue> values) |
|
<T> CompletableFuture<Integer> |
AbstractDataSqlSource.updateColumnAsync(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> CompletableFuture<Integer> |
DataMemorySource.updateColumnAsync(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|
<T> CompletableFuture<Integer> |
DataSource.updateColumnAsync(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node} ORDER BY {flipper.sort}
|
default <T> CompletableFuture<Integer> |
DataSource.updateColumnAsync(Class<T> clazz,
FilterNode node,
Flipper flipper,
ColumnValues values) |
更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node} ORDER BY {flipper.sort}
|
default CompletableFuture<Integer> |
DataSqlMapper.updateColumnAsync(FilterNode node,
Flipper flipper,
ColumnValue... values) |
更新符合过滤条件的记录的指定字段
Flipper中offset字段将被忽略
注意：Entity类中标记为@Column(updatable=false)不会被更新
等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ···
WHERE {filter node} ORDER BY {flipper.sort}
|
protected <T> int |
AbstractDataSqlSource.updateColumnDB(EntityInfo<T> info,
Flipper flipper,
AbstractDataSqlSource.UpdateSqlInfo sql) |
|
protected <T> int |
DataJdbcSource.updateColumnDB(EntityInfo<T> info,
Flipper flipper,
AbstractDataSqlSource.UpdateSqlInfo sql) |
|
protected abstract <T> CompletableFuture<Integer> |
AbstractDataSqlSource.updateColumnDBAsync(EntityInfo<T> info,
Flipper flipper,
AbstractDataSqlSource.UpdateSqlInfo sql) |
|
protected <T> CompletableFuture<Integer> |
DataJdbcSource.updateColumnDBAsync(EntityInfo<T> info,
Flipper flipper,
AbstractDataSqlSource.UpdateSqlInfo sql) |
|
protected <T> AbstractDataSqlSource.UpdateSqlInfo |
AbstractDataSqlSource.updateColumnSql(EntityInfo<T> info,
FilterNode node,
Flipper flipper,
ColumnValue... values) |
|