接口的使用
org.redkale.source.ColumnNode

使用ColumnNode的程序包

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

org.redkale.source中ColumnNode的使用

实现ColumnNode的org.redkale.source中的类

修饰符和类型	类	说明
class	ColumnBytesNode	byte[]的ColumnNode
class	ColumnExpNode	作为ColumnValue的value字段值，用于复杂的字段表达式 。
class	ColumnFuncNode	与ColumnNameNode、ColumnExpNode组合，用于复杂的字段表达式 。
class	ColumnNameNode	字段名的ColumnNode
class	ColumnNumberNode	数值的ColumnNode
class	ColumnStringNode	字符串的ColumnNode

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

修饰符和类型	字段	说明
protected ColumnNode	ColumnExpNode.left
protected ColumnNode	ColumnExpNode.right
protected ColumnNode	ColumnFuncNode.value

返回ColumnNode的org.redkale.source中的方法

修饰符和类型	方法	说明
protected ColumnNode	ColumnFuncNode.createColumnNode(Serializable value)
ColumnNode	ColumnExpNode.getLeft()
ColumnNode	ColumnExpNode.getRight()
ColumnNode	ColumnFuncNode.getValue()
ColumnNode	ColumnValue.getValue()

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

修饰符和类型	方法	说明
static ColumnExpNode	ColumnNodes.and(ColumnNode left, Number rightValue)
static ColumnExpNode	ColumnNodes.and(ColumnNode left, String rightColumn)
static ColumnExpNode	ColumnNodes.and(ColumnNode left, ColumnNode right)
static ColumnFuncNode	ColumnNodes.avg(ColumnNode node)
static ColumnFuncNode	ColumnNodes.count(ColumnNode node)
static ColumnExpNode	ColumnNodes.dec(ColumnNode left, Number rightValue)
static ColumnExpNode	ColumnNodes.dec(ColumnNode left, String rightColumn)
static ColumnExpNode	ColumnNodes.dec(ColumnNode left, ColumnNode right)
static ColumnFuncNode	ColumnNodes.distinctCount(ColumnNode node)
static ColumnExpNode	ColumnNodes.div(ColumnNode left, Number rightValue)
static ColumnExpNode	ColumnNodes.div(ColumnNode left, String rightColumn)
static ColumnExpNode	ColumnNodes.div(ColumnNode left, ColumnNode right)
static ColumnExpNode	ColumnNodes.exp(ColumnNode left, ColumnExpress express, ColumnNode right)
static ColumnFuncNode	ColumnNodes.func(FilterFunc func, ColumnNode node)
static ColumnExpNode	ColumnNodes.inc(ColumnNode left, Number rightValue)
static ColumnExpNode	ColumnNodes.inc(ColumnNode left, String rightColumn)
static ColumnExpNode	ColumnNodes.inc(ColumnNode left, ColumnNode right)
static ColumnFuncNode	ColumnNodes.max(ColumnNode node)
static ColumnFuncNode	ColumnNodes.min(ColumnNode node)
static ColumnExpNode	ColumnNodes.mod(ColumnNode left, Number rightValue)
static ColumnExpNode	ColumnNodes.mod(ColumnNode left, String rightColumn)
static ColumnExpNode	ColumnNodes.mod(ColumnNode left, ColumnNode right)
static ColumnExpNode	ColumnNodes.mul(ColumnNode left, Number rightValue)
static ColumnExpNode	ColumnNodes.mul(ColumnNode left, String rightColumn)
static ColumnExpNode	ColumnNodes.mul(ColumnNode left, ColumnNode right)
static ColumnExpNode	ColumnNodes.orr(ColumnNode left, Number rightValue)
static ColumnExpNode	ColumnNodes.orr(ColumnNode left, String rightColumn)
static ColumnExpNode	ColumnNodes.orr(ColumnNode left, ColumnNode right)
<T,K extends Serializable,N extends Number> Map<K,N[]>	AbstractDataSource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn)
<T,K extends Serializable,N extends Number> Map<K[],N[]>	AbstractDataSource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns)
<T,K extends Serializable,N extends Number> Map<K[],N[]>	AbstractDataSource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterBean bean)
<T,K extends Serializable,N extends Number> Map<K,N[]>	AbstractDataSource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterBean bean)
<T,K extends Serializable,N extends Number> Map<K[],N[]>	AbstractDataSqlSource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)
<T,K extends Serializable,N extends Number> Map<K,N[]>	AbstractDataSqlSource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterNode node)
<T,K extends Serializable,N extends Number> Map<K[],N[]>	DataMemorySource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)
<T,K extends Serializable,N extends Number> Map<K,N[]>	DataMemorySource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterNode node)
default <T,K extends Serializable,N extends Number> Map<K,N[]>	DataSource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE GROUP BY {col1} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid") 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
default <T,K extends Serializable,N extends Number> Map<K[],N[]>	DataSource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} GROUP BY {col1}, {col2} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid")) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
default <T,K extends Serializable,N extends Number> Map<K[],N[]>	DataSource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterBean bean)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1}, {col2} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterBean)null) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
<T,K extends Serializable,N extends Number> Map<K[],N[]>	DataSource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1}, {col2} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterNode)null) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
default <T,K extends Serializable,N extends Number> Map<K,N[]>	DataSource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterBean bean)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterBean)null) 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
<T,K extends Serializable,N extends Number> Map<K,N[]>	DataSource.queryColumnMap(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterNode node)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterNode)null) 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
default <K extends Serializable,N extends Number> Map<K,N[]>	DataSqlMapper.queryColumnMap(ColumnNode[] funcNodes, String groupByColumn)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE GROUP BY {col1} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid") 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
default <K extends Serializable,N extends Number> Map<K[],N[]>	DataSqlMapper.queryColumnMap(ColumnNode[] funcNodes, String[] groupByColumns)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} GROUP BY {col1}, {col2} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid")) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
default <K extends Serializable,N extends Number> Map<K[],N[]>	DataSqlMapper.queryColumnMap(ColumnNode[] funcNodes, String[] groupByColumns, FilterBean bean)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1}, {col2} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterBean)null) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
default <K extends Serializable,N extends Number> Map<K[],N[]>	DataSqlMapper.queryColumnMap(ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1}, {col2} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterNode)null) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
default <K extends Serializable,N extends Number> Map<K,N[]>	DataSqlMapper.queryColumnMap(ColumnNode[] funcNodes, String groupByColumn, FilterBean bean)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterBean)null) 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
default <K extends Serializable,N extends Number> Map<K,N[]>	DataSqlMapper.queryColumnMap(ColumnNode[] funcNodes, String groupByColumn, FilterNode node)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterNode)null) 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
Map<Serializable[],Number[]>	EntityCache.queryColumnMap(ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N[]>>	AbstractDataSource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn)
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K[],N[]>>	AbstractDataSource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns)
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K[],N[]>>	AbstractDataSource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterBean bean)
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N[]>>	AbstractDataSource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterBean bean)
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K[],N[]>>	AbstractDataSqlSource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N[]>>	AbstractDataSqlSource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterNode node)
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K[],N[]>>	DataMemorySource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N[]>>	DataMemorySource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterNode node)
default <T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N[]>>	DataSource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} GROUP BY {col1} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid") 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
default <T,K extends Serializable,N extends Number> CompletableFuture<Map<K[],N[]>>	DataSource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} GROUP BY {col1}, {col2} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid")) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
default <T,K extends Serializable,N extends Number> CompletableFuture<Map<K[],N[]>>	DataSource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterBean bean)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1}, {col2} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterBean)null) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K[],N[]>>	DataSource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1}, {col2} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterNode)null) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
default <T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N[]>>	DataSource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterBean bean)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterBean)null) 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
<T,K extends Serializable,N extends Number> CompletableFuture<Map<K,N[]>>	DataSource.queryColumnMapAsync(Class<T> entityClass, ColumnNode[] funcNodes, String groupByColumn, FilterNode node)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterNode)null) 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
default <K extends Serializable,N extends Number> CompletableFuture<Map<K,N[]>>	DataSqlMapper.queryColumnMapAsync(ColumnNode[] funcNodes, String groupByColumn)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} GROUP BY {col1} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid") 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
default <K extends Serializable,N extends Number> CompletableFuture<Map<K[],N[]>>	DataSqlMapper.queryColumnMapAsync(ColumnNode[] funcNodes, String[] groupByColumns)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} GROUP BY {col1}, {col2} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid")) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
default <K extends Serializable,N extends Number> CompletableFuture<Map<K[],N[]>>	DataSqlMapper.queryColumnMapAsync(ColumnNode[] funcNodes, String[] groupByColumns, FilterBean bean)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1}, {col2} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterBean)null) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
default <K extends Serializable,N extends Number> CompletableFuture<Map<K[],N[]>>	DataSqlMapper.queryColumnMapAsync(ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, col2, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1}, {col2} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), Utility.ofArray("fromid", "targetid"), (FilterNode)null) 等价于: SELECT fromid, targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY fromid, targetid
default <K extends Serializable,N extends Number> CompletableFuture<Map<K,N[]>>	DataSqlMapper.queryColumnMapAsync(ColumnNode[] funcNodes, String groupByColumn, FilterBean bean)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter bean} GROUP BY {col1} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterBean)null) 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
default <K extends Serializable,N extends Number> CompletableFuture<Map<K,N[]>>	DataSqlMapper.queryColumnMapAsync(ColumnNode[] funcNodes, String groupByColumn, FilterNode node)	查询符合过滤条件记录的GROUP BY聚合结果Map 等价SQL: SELECT col1, FUNC{funcColumn1}, FUNC{funcColumn2} FROM {table} WHERE {filter node} GROUP BY {col1} 如 queryColumnMapAsync(OrderRecord.class, Utility.ofArray(ColumnExpNode.div(ColumnFuncNode.sum("money"), 100), ColumnFuncNode.avg(ColumnExpNode.dec("money", 20)))), "targetid", (FilterNode)null) 等价于: SELECT targetid, SUM(money) / 100, AVG(money - 20) FROM orderrecord GROUP BY targetid
protected <T,K extends Serializable,N extends Number> Map<K[],N[]>	AbstractDataSqlSource.queryColumnMapDB(EntityInfo<T> info, String[] tables, String sql, ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)
protected <T,K extends Serializable,N extends Number> Map<K[],N[]>	DataJdbcSource.queryColumnMapDB(EntityInfo<T> info, String[] tables, String sql, ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)
protected <T,K extends Serializable,N extends Number> CompletableFuture<Map<K[],N[]>>	AbstractDataSqlSource.queryColumnMapDBApply(EntityInfo<T> info, CompletableFuture<? extends DataResultSet> future, ColumnNode[] funcNodes, String[] groupByColumns)
protected abstract <T,K extends Serializable,N extends Number> CompletableFuture<Map<K[],N[]>>	AbstractDataSqlSource.queryColumnMapDBAsync(EntityInfo<T> info, String[] tables, String sql, ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)
protected <T,K extends Serializable,N extends Number> CompletableFuture<Map<K[],N[]>>	DataJdbcSource.queryColumnMapDBAsync(EntityInfo<T> info, String[] tables, String sql, ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)
protected <T> String	AbstractDataSqlSource.queryColumnMapSql(EntityInfo<T> info, String[] tables, ColumnNode[] funcNodes, String[] groupByColumns, FilterNode node)
void	ColumnExpNode.setLeft(ColumnNode left)
void	ColumnExpNode.setRight(ColumnNode right)
void	ColumnFuncNode.setValue(ColumnNode value)
void	ColumnValue.setValue(ColumnNode value)
static ColumnFuncNode	ColumnNodes.sum(ColumnNode node)