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 void onMatch(RelOptRuleCall call) {
JoinRel join = (JoinRel) call.rels[0];
List<RexNode> expList = new ArrayList<RexNode>(Arrays.asList(join.getChildExps()));
if (reduceExpressions(join, expList)) {
call.transformTo(
new JoinRel(
join.getCluster(),
join.getLeft(),
join.getRight(),
expList.get(0),
join.getJoinType(),
join.getVariablesStopped()));
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(join, 0.0);
}
}
public void onMatch(RelOptRuleCall call) {
ProjectRel project = (ProjectRel) call.rels[0];
List<RexNode> expList = new ArrayList<RexNode>(Arrays.asList(project.getChildExps()));
if (reduceExpressions(project, expList)) {
call.transformTo(
new ProjectRel(
project.getCluster(),
project.getChild(),
expList.toArray(new RexNode[expList.size()]),
project.getRowType(),
ProjectRel.Flags.Boxed,
Collections.<RelCollation>emptyList()));
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(project, 0.0);
}
}
public void onMatch(RelOptRuleCall call) {
FilterRel filter = (FilterRel) call.rels[0];
List<RexNode> expList = new ArrayList<RexNode>(Arrays.asList(filter.getChildExps()));
RexNode newConditionExp;
boolean reduced;
if (reduceExpressions(filter, expList)) {
assert (expList.size() == 1);
newConditionExp = expList.get(0);
reduced = true;
} else {
// No reduction, but let's still test the original
// predicate to see if it was already a constant,
// in which case we don't need any runtime decision
// about filtering.
newConditionExp = filter.getChildExps()[0];
reduced = false;
}
if (newConditionExp.isAlwaysTrue()) {
call.transformTo(filter.getChild());
} else if ((newConditionExp instanceof RexLiteral)
|| RexUtil.isNullLiteral(newConditionExp, true)) {
call.transformTo(new EmptyRel(filter.getCluster(), filter.getRowType()));
} else if (reduced) {
call.transformTo(CalcRel.createFilter(filter.getChild(), expList.get(0)));
} else {
if (newConditionExp instanceof RexCall) {
RexCall rexCall = (RexCall) newConditionExp;
boolean reverse = (rexCall.getOperator() == SqlStdOperatorTable.notOperator);
if (reverse) {
rexCall = (RexCall) rexCall.getOperands()[0];
}
reduceNotNullableFilter(call, filter, rexCall, reverse);
}
return;
}
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(filter, 0.0);
}
/**
* Once you have a Result of implementing a child relational expression, call this method to
* create a Builder to implement the current relational expression by adding additional clauses
* to the SQL query.
*
* <p>You need to declare which clauses you intend to add. If the clauses are "later", you can
* add to the same query. For example, "GROUP BY" comes after "WHERE". But if they are the same
* or earlier, this method will start a new SELECT that wraps the previous result.
*
* <p>When you have called {@link Builder#setSelect(org.eigenbase.sql.SqlNodeList)}, {@link
* Builder#setWhere(org.eigenbase.sql.SqlNode)} etc. call {@link
* Builder#result(org.eigenbase.sql.SqlNode, java.util.Collection, org.eigenbase.rel.RelNode)}
* to fix the new query.
*
* @param rel Relational expression being implemented
* @param clauses Clauses that will be generated to implement current relational expression
* @return A builder
*/
public Builder builder(JdbcRel rel, Clause... clauses) {
final Clause maxClause = maxClause();
boolean needNew = false;
for (Clause clause : clauses) {
if (maxClause.ordinal() >= clause.ordinal()) {
needNew = true;
}
}
SqlSelect select;
Expressions.FluentList<Clause> clauseList = Expressions.list();
if (needNew) {
select = subSelect();
} else {
select = asSelect();
clauseList.addAll(this.clauses);
}
clauseList.addAll(Arrays.asList(clauses));
Context newContext;
final SqlNodeList selectList = select.getSelectList();
if (selectList != null) {
newContext =
new Context(selectList.size()) {
@Override
public SqlNode field(int ordinal) {
final SqlNode selectItem = selectList.get(ordinal);
switch (selectItem.getKind()) {
case AS:
return ((SqlCall) selectItem).operand(0);
}
return selectItem;
}
};
} else {
newContext = new AliasContext(aliases, aliases.size() > 1);
}
return new Builder(rel, clauseList, select, newContext);
}