@Override
protected PreparedExecution implement(
RelDataType rowType,
RelNode rootRel,
SqlKind sqlKind,
ClassDeclaration decl,
Argument[] args) {
RelDataType resultType = rootRel.getRowType();
boolean isDml = sqlKind.belongsTo(SqlKind.DML);
javaCompiler = createCompiler();
EnumerableRelImplementor relImplementor =
getRelImplementor(rootRel.getCluster().getRexBuilder());
BlockExpression expr = relImplementor.implementRoot((EnumerableRel) rootRel);
ParameterExpression root0 = Expressions.parameter(DataContext.class, "root0");
String s =
Expressions.toString(
Blocks.create(
Expressions.declare(
Modifier.FINAL, (ParameterExpression) schema.getExpression(), root0),
expr),
false);
final Executable executable;
try {
executable =
(Executable)
ExpressionEvaluator.createFastScriptEvaluator(
s, Executable.class, new String[] {root0.name});
} catch (Exception e) {
throw Helper.INSTANCE.wrap("Error while compiling generated Java code:\n" + s, e);
}
if (timingTracer != null) {
timingTracer.traceTime("end codegen");
}
if (timingTracer != null) {
timingTracer.traceTime("end compilation");
}
return new PreparedExecution(
null, rootRel, resultType, isDml, mapTableModOp(isDml, sqlKind), null) {
public Object execute() {
return executable.execute(schema);
}
};
}
public RexNode toRex(Expression expression) {
switch (expression.getNodeType()) {
case MemberAccess:
return rexBuilder.makeFieldAccess(
toRex(((MemberExpression) expression).expression),
((MemberExpression) expression).field.getName());
case GreaterThan:
return binary(expression, SqlStdOperatorTable.greaterThanOperator);
case LessThan:
return binary(expression, SqlStdOperatorTable.lessThanOperator);
case Parameter:
return parameter((ParameterExpression) expression);
case Call:
MethodCallExpression call = (MethodCallExpression) expression;
SqlOperator operator = RexToLixTranslator.JAVA_TO_SQL_METHOD_MAP.get(call.method);
if (operator != null) {
return rexBuilder.makeCall(
operator,
toRex(
Expressions.<Expression>list()
.appendIfNotNull(call.targetExpression)
.appendAll(call.expressions)));
}
throw new RuntimeException("Could translate call to method " + call.method);
case Constant:
final ConstantExpression constant = (ConstantExpression) expression;
Object value = constant.value;
if (value instanceof Number) {
Number number = (Number) value;
if (value instanceof Double || value instanceof Float) {
return rexBuilder.makeApproxLiteral(BigDecimal.valueOf(number.doubleValue()));
} else if (value instanceof BigDecimal) {
return rexBuilder.makeExactLiteral((BigDecimal) value);
} else {
return rexBuilder.makeExactLiteral(BigDecimal.valueOf(number.longValue()));
}
} else if (value instanceof Boolean) {
return rexBuilder.makeLiteral((Boolean) value);
} else {
return rexBuilder.makeLiteral(constant.toString());
}
default:
throw new UnsupportedOperationException(
"unknown expression type " + expression.getNodeType() + " " + expression);
}
}