private Expression translate0(RexNode expr) {
if (expr instanceof RexInputRef) {
// TODO: multiple inputs, e.g. joins
final Expression input = getInput(0);
final int index = ((RexInputRef) expr).getIndex();
final List<RelDataTypeField> fields = program.getInputRowType().getFieldList();
final RelDataTypeField field = fields.get(index);
if (fields.size() == 1) {
return input;
} else if (input.getType() == Object[].class) {
return Expressions.convert_(
Expressions.arrayIndex(input, Expressions.constant(field.getIndex())),
Types.box(JavaRules.EnumUtil.javaClass(typeFactory, field.getType())));
} else {
return Expressions.field(input, field.getName());
}
}
if (expr instanceof RexLocalRef) {
return translate(program.getExprList().get(((RexLocalRef) expr).getIndex()));
}
if (expr instanceof RexLiteral) {
return Expressions.constant(
((RexLiteral) expr).getValue(), typeFactory.getJavaClass(expr.getType()));
}
if (expr instanceof RexCall) {
final RexCall call = (RexCall) expr;
final SqlOperator operator = call.getOperator();
final ExpressionType expressionType = SQL_TO_LINQ_OPERATOR_MAP.get(operator);
if (expressionType != null) {
switch (operator.getSyntax()) {
case Binary:
return Expressions.makeBinary(
expressionType, translate(call.getOperands()[0]), translate(call.getOperands()[1]));
case Postfix:
case Prefix:
return Expressions.makeUnary(expressionType, translate(call.getOperands()[0]));
default:
throw new RuntimeException("unknown syntax " + operator.getSyntax());
}
}
Method method = SQL_OP_TO_JAVA_METHOD_MAP.get(operator);
if (method != null) {
List<Expression> exprs = translateList(Arrays.asList(call.operands));
return !Modifier.isStatic(method.getModifiers())
? Expressions.call(exprs.get(0), method, exprs.subList(1, exprs.size()))
: Expressions.call(method, exprs);
}
switch (expr.getKind()) {
default:
throw new RuntimeException("cannot translate expression " + expr);
}
}
throw new RuntimeException("cannot translate expression " + expr);
}
public static Expression translateCondition(
List<Expression> inputs,
RexProgram program,
JavaTypeFactory typeFactory,
List<Statement> list) {
List<Expression> x =
new RexToLixTranslator(program, typeFactory, inputs)
.translate(list, Collections.singletonList(program.getCondition()));
assert x.size() == 1;
return x.get(0);
}
/**
* Gets the expression for an input and counts it.
*
* @param index Input ordinal
* @return Expression to which an input should be translated
*/
private Expression getInput(int index) {
Slot slot = inputSlots.get(index);
if (list == null) {
slot.count++;
} else {
if (slot.count > 1 && slot.parameterExpression == null) {
slot.parameterExpression = Expressions.parameter(slot.expression.type, "current" + index);
list.add(Expressions.declare(Modifier.FINAL, slot.parameterExpression, slot.expression));
}
}
return slot.parameterExpression != null ? slot.parameterExpression : slot.expression;
}
