Example #1
0
  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);
  }
Example #2
0
  private List<Expression> translate(List<Statement> list, List<RexLocalRef> rexList) {
    // First pass. Count how many times each sub-expression is used.
    this.list = null;
    for (RexNode rexExpr : rexList) {
      translate(rexExpr);
    }

    // Mark expressions as inline if they are not used more than once.
    for (Map.Entry<RexNode, Slot> entry : map.entrySet()) {
      if (entry.getValue().count < 2 || entry.getKey() instanceof RexLiteral) {
        inlineRexSet.add(entry.getKey());
      }
    }

    // Second pass. When translating each expression, if it is used more
    // than once, the first time it is encountered, add a declaration to the
    // list and set its usage count to 0.
    this.list = list;
    this.map.clear();
    List<Expression> translateds = new ArrayList<Expression>();
    for (RexNode rexExpr : rexList) {
      translateds.add(translate(rexExpr));
    }
    return translateds;
  }
Example #3
0
 private Expression translate(RexNode expr) {
   Slot slot = map.get(expr);
   if (slot == null) {
     Expression expression = translate0(expr);
     assert expression != null;
     final ParameterExpression parameter;
     if (!inlineRexSet.contains(expr) && !(expr instanceof RexLocalRef)) {
       parameter = Expressions.parameter(expression.getType(), "v" + map.size());
     } else {
       parameter = null;
     }
     slot = new Slot(parameter, expression);
     if (parameter != null && list != null) {
       list.add(Expressions.declare(Modifier.FINAL, slot.parameterExpression, slot.expression));
     }
     map.put(expr, slot);
   }
   slot.count++;
   return slot.parameterExpression != null ? slot.parameterExpression : slot.expression;
 }
Example #4
0
 static {
   for (Map.Entry<Method, SqlOperator> entry : JAVA_TO_SQL_METHOD_MAP.entrySet()) {
     SQL_OP_TO_JAVA_METHOD_MAP.put(entry.getValue(), entry.getKey());
   }
 }