import org.eigenbase.rex.RexInputRef; //导入依赖的package包/类
private TblColRef translateRexNode(RexNode rexNode, ColumnRowType inputColumnRowType, String fieldName, Set<TblColRef> sourceCollector) {
    TblColRef column = null;
    if (rexNode instanceof RexInputRef) {
        RexInputRef inputRef = (RexInputRef) rexNode;
        column = translateRexInputRef(inputRef, inputColumnRowType, fieldName, sourceCollector);
    } else if (rexNode instanceof RexLiteral) {
        RexLiteral literal = (RexLiteral) rexNode;
        column = translateRexLiteral(literal);
    } else if (rexNode instanceof RexCall) {
        RexCall call = (RexCall) rexNode;
        column = translateRexCall(call, inputColumnRowType, fieldName, sourceCollector);
    } else {
        throw new IllegalStateException("Unsupport RexNode " + rexNode);
    }
    return column;
}
 

import org.eigenbase.rex.RexInputRef; //导入依赖的package包/类
private void translateJoinColumn(RexCall condition, Map<TblColRef, TblColRef> joinColumns) {
    SqlKind kind = condition.getOperator().getKind();
    if (kind == SqlKind.AND) {
        for (RexNode operand : condition.getOperands()) {
            RexCall subCond = (RexCall) operand;
            translateJoinColumn(subCond, joinColumns);
        }
    } else if (kind == SqlKind.EQUALS) {
        List<RexNode> operands = condition.getOperands();
        RexInputRef op0 = (RexInputRef) operands.get(0);
        TblColRef col0 = columnRowType.getColumnByIndex(op0.getIndex());
        RexInputRef op1 = (RexInputRef) operands.get(1);
        TblColRef col1 = columnRowType.getColumnByIndex(op1.getIndex());
        joinColumns.put(col0, col1);
    }
}
 

import org.eigenbase.rex.RexInputRef; //导入依赖的package包/类
public static void getExprVarsFromRexCall(RexNode cond, List<ExprVar> result) {
	if(cond instanceof RexCall) {
		RexCall call = (RexCall) cond;
		for(int i = 0; i < call.getOperands().size(); i++) {
			getExprVarsFromRexCall(call.getOperands().get(i), result);
		}
		return;
	}
	// assignable variable
	if(cond instanceof RexInputRef) {
		RexInputRef ref = (RexInputRef) cond;
		for (ExprVar expr : result) {
			if(expr.varName.equals(ref.getName())) {
				// variable already created;
				return;
			}
		}
		ExprVar e = new ExprVar();
		e.varName = ref.getName();
		e.positionInRecord = ref.getIndex();
		e.type = getTypeClass(ref.getType());
		result.add(e);
		return;
	}
}
 

import org.eigenbase.rex.RexInputRef; //导入依赖的package包/类
private int[] getProjectFields(List<RexNode> exps) {
    final int[] fields = new int[exps.size()];
    for (int i = 0; i < exps.size(); i++) {
        final RexNode exp = exps.get(i);
        if (exp instanceof RexInputRef) {
            fields[i] = ((RexInputRef) exp).getIndex();
        } else {
            return null; // not a simple projection
        }
    }
    return fields;
}
 

import org.eigenbase.rex.RexInputRef; //导入依赖的package包/类
private int[] getProjectFields(List<RexNode> exps) {
  final int[] fields = new int[exps.size()];
  for (int i = 0; i < exps.size(); i++) {
    final RexNode exp = exps.get(i);
    if (exp instanceof RexInputRef) {
      fields[i] = ((RexInputRef) exp).getIndex();
    } else {
      return null; // not a simple projection
    }
  }
  return fields;
}
 

import org.eigenbase.rex.RexInputRef; //导入依赖的package包/类
@Override
public TupleFilter visitInputRef(RexInputRef inputRef) {
    TblColRef column = inputRowType.getColumnByIndex(inputRef.getIndex());
    context.allColumns.add(column);
    ColumnTupleFilter filter = new ColumnTupleFilter(column);
    return filter;
}
 

import org.eigenbase.rex.RexInputRef; //导入依赖的package包/类
private TblColRef translateRexInputRef(RexInputRef inputRef, ColumnRowType inputColumnRowType, String fieldName, Set<TblColRef> sourceCollector) {
    int index = inputRef.getIndex();
    // check it for rewrite count
    if (index < inputColumnRowType.size()) {
        TblColRef column = inputColumnRowType.getColumnByIndex(index);
        if (!column.isInnerColumn() && !this.rewriting && !this.afterAggregate) {
            context.allColumns.add(column);
            sourceCollector.add(column);
        }
        return column;
    } else {
        throw new IllegalStateException("Can't find " + inputRef + " from child columnrowtype " + inputColumnRowType + " with fieldname " + fieldName);
    }
}
 

import org.eigenbase.rex.RexInputRef; //导入依赖的package包/类
public Void visitInputRef(RexInputRef inputRef) {
//			if (true) { // do I need a condition here?
//				inputRef.setExternalRef(true);
//			}
//			System.err.println("Setting input ref " + inputRef + " index "
//					+ inputRef.getIndex());
			inputPosAndType
					.add(Pair.of(inputRef.getIndex(), inputRef.getType()));
			return null;
		}
 

import org.eigenbase.rex.RexInputRef; //导入依赖的package包/类
public Class<? extends Value>[] getFields() {
	Class<? extends Value>[] fields = new Class[this.exps.size()];
	Iterator<RexNode> it = exps.iterator();
	int i = 0;
	while(it.hasNext()) {
		RexInputRef inputRef = (RexInputRef) it.next();
		fields[i++] = StratosphereRelUtils.getTypeClass(inputRef.getType());
	}
	return fields;
}
 

import org.eigenbase.rex.RexInputRef; //导入依赖的package包/类
public static String convertRexCallToJexlExpr(RexNode c) {
	StringBuffer sb = new StringBuffer();
	if(c instanceof RexCall) {
		RexCall call = (RexCall) c;
		sb.append("(");
		for(int i = 0; i < call.getOperands().size(); i++) {
			sb.append( convertRexCallToJexlExpr(call.getOperands().get(i)));
			if(i+1 <call.getOperands().size()) {
				switch(c.getKind()) {
					case AND:
						sb.append(" && ");
						break;
					case OR:
						sb.append(" || ");
						break;
					case EQUALS:
						sb.append(" == ");
						break;
					case LESS_THAN:
						sb.append(" < ");
						break;
					default:
						throw new RuntimeException("Unknown kind "+c.getKind());
				}
			}
		}
		sb.append(")");
	}
	// assignable variable
	if(c instanceof RexInputRef) {
		RexInputRef ref = (RexInputRef) c;
		return ref.getName();
	}
	if(c instanceof RexLiteral) {
		RexLiteral lit = (RexLiteral) c;
		return lit.getValue().toString();
	}
	return sb.toString();
}
 

import org.eigenbase.rex.RexInputRef; //导入依赖的package包/类
@Override
public String apply(RexNode exp) {

  if (exp instanceof RexInputRef) {
    return ((RexInputRef) exp).getName();
  } else
    return exp.toString();
}
 

import org.eigenbase.rex.RexInputRef; //导入依赖的package包/类
@Override
public ChildVisitor visitInputRef(RexInputRef inputRef) {

  final int index = inputRef.getIndex();
  final RelDataTypeField field = input.getRowType().getFieldList().get(index);
  return new Field(field.getName());
}
 

import org.eigenbase.rex.RexInputRef; //导入依赖的package包/类
@Override
public void implementRewrite(RewriteImplementor implementor) {
    implementor.visitChild(this, getChild());

    this.rewriting = true;

    // project before join or is just after OLAPToEnumerableConverter
    if (!RewriteImplementor.needRewrite(this.context) || (this.hasJoin && !this.afterJoin) || this.afterAggregate) {
        this.columnRowType = this.buildColumnRowType();
        return;
    }

    // find missed rewrite fields
    int paramIndex = this.rowType.getFieldList().size();
    List<RelDataTypeField> newFieldList = new LinkedList<RelDataTypeField>();
    List<RexNode> newExpList = new LinkedList<RexNode>();
    ColumnRowType inputColumnRowType = ((OLAPRel) getChild()).getColumnRowType();

    for (Map.Entry<String, RelDataType> rewriteField : this.context.rewriteFields.entrySet()) {
        String rewriteFieldName = rewriteField.getKey();
        int rowIndex = this.columnRowType.getIndexByName(rewriteFieldName);
        if (rowIndex < 0) {
            int inputIndex = inputColumnRowType.getIndexByName(rewriteFieldName);
            if (inputIndex >= 0) {
                // new field
                RelDataType fieldType = rewriteField.getValue();
                RelDataTypeField newField = new RelDataTypeFieldImpl(rewriteFieldName, paramIndex++, fieldType);
                newFieldList.add(newField);
                // new project
                RelDataTypeField inputField = getChild().getRowType().getFieldList().get(inputIndex);
                RexInputRef newFieldRef = new RexInputRef(inputField.getIndex(), inputField.getType());
                newExpList.add(newFieldRef);
            }
        }
    }

    if (!newFieldList.isEmpty()) {
        // rebuild projects
        List<RexNode> newProjects = new ArrayList<RexNode>(this.rewriteProjects);
        newProjects.addAll(newExpList);
        this.rewriteProjects = newProjects;

        // rebuild row type
        FieldInfoBuilder fieldInfo = getCluster().getTypeFactory().builder();
        fieldInfo.addAll(this.rowType.getFieldList());
        fieldInfo.addAll(newFieldList);
        this.rowType = getCluster().getTypeFactory().createStructType(fieldInfo);
    }

    // rebuild columns
    this.columnRowType = this.buildColumnRowType();

    this.rewriting = false;
}