import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
protected LinkedHashMap<String, Integer> buildOrderByCols(List<SQLSelectOrderByItem> orderByItems,Map<String, String> aliaColumns) {
	LinkedHashMap<String, Integer> map = new LinkedHashMap<String, Integer>();
	for(int i= 0; i < orderByItems.size(); i++) {
		SQLOrderingSpecification type = orderByItems.get(i).getType();
           //orderColumn只记录字段名称,因为返回的结果集是不带表名的。
		SQLExpr expr =  orderByItems.get(i).getExpr();
		String col;
		if (expr instanceof SQLName) {
		   col = ((SQLName)expr).getSimpleName();
		}
		else {
			col =expr.toString();
		}
		if(type == null) {
			type = SQLOrderingSpecification.ASC;
		}
		col=getAliaColumn(aliaColumns,col);//此步骤得到的col必须是不带.的，有别名的用别名，无别名的用字段名
		map.put(col, type == SQLOrderingSpecification.ASC ? OrderCol.COL_ORDER_TYPE_ASC : OrderCol.COL_ORDER_TYPE_DESC);
	}
	return map;
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
public TwoTableComparator(List<FieldPacket> fps1, List<FieldPacket> fps2, List<Order> leftOrders,
                          List<Order> rightOrders, boolean isAllPushDown, DMLResponseHandler.HandlerType type) {
    this.leftFields = HandlerTool.createFields(fps1);
    this.rightFields = HandlerTool.createFields(fps2);
    ascList = new ArrayList<>();
    for (Order order : leftOrders) {
        ascList.add(order.getSortOrder() == SQLOrderingSpecification.ASC);
    }
    comparators = new ArrayList<>();
    for (int index = 0; index < ascList.size(); index++) {
        Order leftOrder = leftOrders.get(index);
        Order rightOrder = rightOrders.get(index);
        Item leftCmpItem = HandlerTool.createItem(leftOrder.getItem(), leftFields, 0, isAllPushDown, type);
        Item rightCmpItem = HandlerTool.createItem(rightOrder.getItem(), rightFields, 0, isAllPushDown,
                type);
        ArgComparator comparator = new ArgComparator(leftCmpItem, rightCmpItem);
        comparator.setCmpFunc(null, leftCmpItem, rightCmpItem, false);
        comparators.add(comparator);
    }
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
public RowDataComparator(List<FieldPacket> fps, List<Order> orders, boolean allPushDown, DMLResponseHandler.HandlerType type) {
    sourceFields = HandlerTool.createFields(fps);
    if (orders != null && orders.size() > 0) {
        ascList = new ArrayList<>();
        cmpFields = new ArrayList<>();
        cmpItems = new ArrayList<>();
        for (Order order : orders) {
            Item cmpItem = HandlerTool.createItem(order.getItem(), sourceFields, 0, allPushDown, type);
            cmpItems.add(cmpItem);
            FieldPacket tmpFp = new FieldPacket();
            cmpItem.makeField(tmpFp);
            Field cmpField = HandlerTool.createField(tmpFp);
            cmpFields.add(cmpField);
            ascList.add(order.getSortOrder() == SQLOrderingSpecification.ASC);
        }
    }
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
private void reverseAppendTo(SQLSelectOrderByItem order, SQLServerOutputVisitor visitor, String tmpTableAlias, List<SQLSelectItem> items) {
	SQLExpr expression=order.getExpr();
	
	if(expression instanceof SQLPropertyExpr){
		SQLPropertyExpr c=(SQLPropertyExpr)expression;
		if(items!=null){
			fixWithSelects(c,items);
		}
		if(c.getOwner()!=null){
			c.setOwner(new SQLIdentifierExpr(tmpTableAlias));
		}
	}
	expression.accept(visitor);
	if(order.getType()==SQLOrderingSpecification.ASC || order.getType()==null){
		try {
			visitor.getAppender().append(" DESC");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
private String getSQLExprToAsc(SQLOrderingSpecification ASC){
	if (ASC==null ) {
		return " ASC ";
	}
	if (ASC==SQLOrderingSpecification.DESC){
		return " DESC ";
	}
	else {
		return " ASC ";		
	}
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
private int getSQLExprToAsc(SQLOrderingSpecification ASC){
	if (ASC==null ) {
		return 1;
	}
	if (ASC==SQLOrderingSpecification.DESC){
		return -1;
	}
	else {
		return 1;		
	}
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
public PlanNode orderBy(Item c, SQLOrderingSpecification sortOrder) {
    if (sortOrder == null) {
        sortOrder = SQLOrderingSpecification.ASC;
    }
    Order order = new Order(c, sortOrder);
    if (!this.orderBys.contains(order)) {
        this.orderBys.add(order);
    }
    return this;
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
/**
 * make order by from distinct
 *
 * @param selects
 * @return
 */
public static List<Order> makeOrder(List<Item> selects) {
    List<Order> orders = new ArrayList<>();
    for (Item sel : selects) {
        Order order = new Order(sel, SQLOrderingSpecification.ASC);
        orders.add(order);
    }
    return orders;
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
public static OrderbyType buildOrderbyType(SQLOrderingSpecification type){
    if (SQLOrderingSpecification.ASC == type){
        return OrderbyType.ASC;
    }
    if (SQLOrderingSpecification.DESC == type){
        return OrderbyType.DESC;
    }
    return OrderbyType.ASC;
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
public SQLOrderingSpecification getType() {
    return this.type;
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
public void setType(SQLOrderingSpecification type) {
    this.type = type;
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
public MySqlOrderingExpr(SQLExpr expr, SQLOrderingSpecification type){
    super();
    setExpr(expr);
    this.type = type;
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
public SQLOrderingSpecification getType() {
    return type;
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
public Order(Item item) {
    this(item, SQLOrderingSpecification.ASC);
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
public SQLOrderingSpecification getSortOrder() {
    return sortOrder;
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
public void setSortOrder(SQLOrderingSpecification sortOrder) {
    this.sortOrder = sortOrder;
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
public PlanNode groupBy(Item c, SQLOrderingSpecification sortOrder) {
    Order order = new Order(c, sortOrder);
    this.groups.add(order);
    return this;
}
 

import com.alibaba.druid.sql.ast.SQLOrderingSpecification; //导入依赖的package包/类
public List<RowData> process(List<RowData> sourceData, MergeContext mergeContext) throws SQLException {
	if (mergeContext.getOrderBy() != null) {
		SQLOrderBy orderBy = mergeContext.getOrderBy();
		final List<SQLSelectOrderByItem> items = orderBy.getItems();
		Collections.sort(sourceData, new Comparator<RowData>() {
			@Override
			public int compare(RowData o1, RowData o2) {
				try {
					for (SQLSelectOrderByItem orderByEle : items) {
						SQLName identifier = (SQLName) orderByEle.getExpr();

						Object value1 = o1.get(identifier.getSimpleName()).getValue();
						Class<?> type1 = o1.get(identifier.getSimpleName()).getType();
						Object value2 = o2.get(identifier.getSimpleName()).getValue();
						Class<?> type2 = o2.get(identifier.getSimpleName()).getType();

						if (!type1.equals(type2)) {
							throw new SQLException("Invalid data");
						}

						if (!Comparable.class.isAssignableFrom(type1)) {
							throw new SQLException(
									"Can not orderBy column : " + identifier + " which isn't comparable.");
						}

						@SuppressWarnings({ "unchecked", "rawtypes" })
						int compareRes = ((Comparable) value1).compareTo((Comparable) value2);

						if (orderByEle.getType() == null
								|| ((SQLOrderingSpecification) orderByEle.getType()).name().equals("ASC")) {
							if (compareRes != 0) {
								return compareRes;
							}
						} else {
							if (compareRes != 0) {
								return compareRes < 0 ? 1 : -1;
							}
						}
					}

					return 0;

				} catch (SQLException e) {
					throw new RuntimeException(e);
				}
			}

		});
	}

	return sourceData;
}