import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr; //导入依赖的package包/类
private void parserFields(List<SQLSelectItem> mysqlSelectList){
	//显示的字段
	String key="";
	String value ="";
	for(SQLSelectItem item : mysqlSelectList) {
		if (item.getExpr() instanceof SQLAllColumnExpr) {
			//*解析
			setField(item.toString(), item.toString());
		}
		else {
			if (item.getExpr() instanceof SQLAggregateExpr) {
				SQLAggregateExpr expr =(SQLAggregateExpr)item.getExpr();
				 key = getExprFieldName(expr);
				 //value=expr.
			}
			else {					
				key=getFieldName(item);
				value=item.getAlias();
			}			
			setField(key, value);
		}
	}			
}
 

import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr; //导入依赖的package包/类
@Override
public SQLExpr toExpression() {
    SQLAggregateExpr aggregate = new SQLAggregateExpr(funcName());
    if (hasWithDistinct()) {
        aggregate.setOption(SQLAggregateOption.DISTINCT);
    }
    if (orders != null) {
        SQLOrderBy orderBy = new SQLOrderBy();
        for (Order order : orders) {
            SQLSelectOrderByItem orderItem = new SQLSelectOrderByItem(order.getItem().toExpression());
            orderItem.setType(order.getSortOrder());
            orderBy.addItem(orderItem);
        }
        aggregate.putAttribute(ItemFuncKeyWord.ORDER_BY, orderBy);
    }
    for (Item arg : args) {
        aggregate.addArgument(arg.toExpression());
    }
    if (seperator != null) {
        SQLCharExpr sep = new SQLCharExpr(seperator);
        aggregate.putAttribute(ItemFuncKeyWord.SEPARATOR, sep);
    }
    return aggregate;
}
 

import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr; //导入依赖的package包/类
private void calAggregateFunctionValue(Map<String, SQLSelectItem> columnNameFunctionMapping, RowData row,
		RowData newRowData, List<Integer> ignoreColumnList) throws SQLException {
	try {
		for (ColumnData col : row.getColumnDatas()) {
			if (ignoreColumnList != null && ignoreColumnList.contains(col.getColumnIndex())) {
				continue;
			}
			SQLSelectItem columnType = columnNameFunctionMapping.get(col.getColumnName());
			SQLAggregateExpr aggregateExpr = (SQLAggregateExpr) columnType.getExpr();
			Aggregator dataProcessor = aggregateFunctionProcessors.get(aggregateExpr.getMethodName());
			if (dataProcessor != null) {
				ColumnData oldCol = newRowData.get(col.getColumnIndex());
				Object value = dataProcessor.process(oldCol.getValue(), col.getValue());

				if (value != null) {
					oldCol.setWasNull(false);
				}
				oldCol.setValue(value);
			} else {
				throw new SQLException("Zebra unsupported groupby function exists");
			}
		}
	} catch (AggregateException e) {
		throw new SQLException("Proc aggregate merge failed.");
	}
}
 

import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr; //导入依赖的package包/类
@Override
protected BindSql toPage(PageLimit offsetLimit, SQLServerSelectQueryBlock selectBody, SQLSelect select, String raw) {
	SQLOrderBy order = select.getOrderBy();
	if (order == null) {
		order = defaultOrder;
	} else {
		select.setOrderBy(null);
	}
	
	SQLAggregateExpr arg=new SQLAggregateExpr("row_number");
	SQLOver over=new SQLOver();
	over.setOrderBy(order);
	arg.setOver(over);
	selectBody.getSelectList().add(0, new SQLSelectItem(arg, "__rn"));

	StringBuilder sb = new StringBuilder("SELECT _tmp1.* FROM (");
	SQLServerOutputVisitor visitor=new SQLServerOutputVisitor(sb);
	visitor.setPrettyFormat(false);
	select.accept(visitor);
	sb.append(") _tmp1 WHERE __rn between ");
	sb.append(offsetLimit.getOffset() + 1).append(" and ").append(offsetLimit.getEnd());
	return new BindSql(sb.toString());
}
 

import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr; //导入依赖的package包/类
private String getExprFieldName(SQLAggregateExpr expr){
	StringBuilder field = new StringBuilder();
	for (SQLExpr item :expr.getArguments()){
		field.append(item.toString());
	}		
	return expr.getMethodName()+"("+field.toString()+")";
}
 

import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr; //导入依赖的package包/类
@Override
public SQLExpr toExpression() {
    Item arg0 = getArg(0);
    SQLAggregateExpr aggregate = new SQLAggregateExpr(funcName());
    aggregate.addArgument(arg0.toExpression());
    if (hasWithDistinct()) {
        aggregate.setOption(SQLAggregateOption.DISTINCT);
    }
    return aggregate;
}
 

import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr; //导入依赖的package包/类
@Override
public SQLExpr toExpression() {
    Item arg0 = args.get(0);
    SQLAggregateExpr aggregate = new SQLAggregateExpr(funcName());
    aggregate.addArgument(arg0.toExpression());
    return aggregate;
}
 

import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr; //导入依赖的package包/类
@Override
public SQLExpr toExpression() {
    Item arg0 = args.get(0);
    SQLAggregateExpr aggregate = new SQLAggregateExpr(funcName());
    aggregate.addArgument(arg0.toExpression());
    if (hasWithDistinct()) {
        aggregate.setOption(SQLAggregateOption.DISTINCT);
    }
    return aggregate;
}
 

import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr; //导入依赖的package包/类
@Override
public SQLExpr toExpression() {
    SQLAggregateExpr aggregate = new SQLAggregateExpr(funcName());
    if (hasWithDistinct()) {
        for (Item arg : args)
            aggregate.addArgument(arg.toExpression());
        aggregate.setOption(SQLAggregateOption.DISTINCT);
    } else {
        Item arg0 = getArg(0);
        aggregate.addArgument(arg0.toExpression());
    }
    return aggregate;
}
 

import com.alibaba.druid.sql.ast.expr.SQLAggregateExpr; //导入依赖的package包/类
@Override
public boolean visit(MySqlSelectQueryBlock x) {
	Map<String, SQLSelectItem> selectItemMap = result.getMergeContext().getSelectItemMap();
	Map<String, String> columnNameAliasMapping = result.getMergeContext().getColumnNameAliasMapping();

	for (SQLSelectItem column : x.getSelectList()) {
		String name = null;
		if (column.getExpr() instanceof SQLAggregateExpr) {
			SQLAggregateExpr expr = (SQLAggregateExpr) column.getExpr();
			SQLExpr argument = expr.getArguments().get(0);
			if (argument instanceof SQLAllColumnExpr) {
				name = expr.getMethodName() + "(*)";
			} else if(argument instanceof SQLIntegerExpr){
				name = expr.getMethodName() + "(1)";
			}else {
				name = expr.getMethodName() + "(" + ((SQLName) argument).getSimpleName() + ")";
				columnNameAliasMapping.put(((SQLName) argument).getSimpleName(), column.getAlias());
			}

			result.getMergeContext().setAggregate(true);
		} else if (column.getExpr() instanceof SQLIdentifierExpr || column.getExpr() instanceof SQLPropertyExpr) {
			name = ((SQLName) column.getExpr()).getSimpleName();

			if (column.getAlias() != null) {
				SQLName identifier = (SQLName) column.getExpr();
				columnNameAliasMapping.put(identifier.getSimpleName(), column.getAlias());
			}
		} else {
			// ignore SQLAllColumnExpr,SQLMethodInvokeExpr and etc.
		}

		selectItemMap.put(column.getAlias() == null ? name : column.getAlias(), column);
	}

	if (x.getDistionOption() == 2) {
		result.getMergeContext().setDistinct(true);
	}

	return true;
}