예제 #1
0
 public void testClassDecl() {
   final NewExpression newExpression =
       Expressions.new_(
           Object.class,
           Collections.<Expression>emptyList(),
           Arrays.<MemberDeclaration>asList(
               new FieldDeclaration(
                   Modifier.PUBLIC | Modifier.FINAL,
                   new ParameterExpression(String.class, "foo"),
                   Expressions.constant("bar")),
               new ClassDeclaration(
                   Modifier.PUBLIC | Modifier.STATIC,
                   "MyClass",
                   null,
                   Collections.<Type>emptyList(),
                   Arrays.<MemberDeclaration>asList(
                       new FieldDeclaration(
                           0, new ParameterExpression(int.class, "x"), Expressions.constant(0)))),
               new FieldDeclaration(0, new ParameterExpression(int.class, "i"), null)));
   assertEquals(
       "new Object(){\n"
           + "  public final String foo = \"bar\";\n"
           + "  public static class MyClass {\n"
           + "    int x = 0;\n"
           + "  }\n"
           + "  int i;\n"
           + "}",
       Expressions.toString(newExpression));
 }
예제 #2
0
  public void testLambdaCallsBinaryOp() {
    // A parameter for the lambda expression.
    ParameterExpression paramExpr = Expressions.parameter(Integer.TYPE, "arg");

    // This expression represents a lambda expression
    // that adds 1 to the parameter value.
    FunctionExpression lambdaExpr =
        Expressions.lambda(
            Expressions.add(paramExpr, Expressions.constant(2)), Arrays.asList(paramExpr));

    // Print out the expression.
    String s = Expressions.toString(lambdaExpr);
    assertEquals(
        "new net.hydromatic.linq4j.function.Function1() {\n"
            + "  public int apply(Integer arg) {\n"
            + "    return arg + 2;\n"
            + "  }\n"
            + "  public Object apply(Object arg) {\n"
            + "    return apply(\n"
            + "      (Integer) arg);\n"
            + "  }\n"
            + "}\n",
        s);

    // Compile and run the lambda expression.
    // The value of the parameter is 1.
    int n = (Integer) lambdaExpr.compile().dynamicInvoke(1);

    // This code example produces the following output:
    //
    // arg => (arg +2)
    // 3
    assertEquals(3, n);
  }
예제 #3
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);
  }
예제 #4
0
 public void testBlockBuilder2() {
   BlockBuilder statements = new BlockBuilder();
   Expression element = statements.append("element", Expressions.constant(null));
   Expression comparator =
       statements.append("comparator", Expressions.constant(null, Comparator.class));
   Expression treeSet =
       statements.append("treeSet", Expressions.new_(TreeSet.class, Arrays.asList(comparator)));
   statements.add(Expressions.return_(null, Expressions.call(treeSet, "add", element)));
   assertEquals(
       "{\n"
           + "  final java.util.Comparator comparator = null;\n"
           + "  final java.util.TreeSet treeSet = new java.util.TreeSet(\n"
           + "    comparator);\n"
           + "  return treeSet.add(null);\n"
           + "}\n",
       Expressions.toString(statements.toBlock()));
 }
예제 #5
0
  public void testWrite() {
    assertEquals(
        "1 + 2.0F + 3L + Long.valueOf(4L)",
        Expressions.toString(
            Expressions.add(
                Expressions.add(
                    Expressions.add(Expressions.constant(1), Expressions.constant(2F, Float.TYPE)),
                    Expressions.constant(3L, Long.TYPE)),
                Expressions.constant(4L, Long.class))));

    assertEquals(
        "new java.math.BigDecimal(31415926L, 7)",
        Expressions.toString(Expressions.constant(BigDecimal.valueOf(314159260, 8))));

    // Parentheses needed, to override the left-associativity of +.
    assertEquals(
        "1 + (2 + 3)",
        Expressions.toString(
            Expressions.add(
                Expressions.constant(1),
                Expressions.add(Expressions.constant(2), Expressions.constant(3)))));

    // No parentheses needed; higher precedence of * achieves the desired
    // effect.
    assertEquals(
        "1 + 2 * 3",
        Expressions.toString(
            Expressions.add(
                Expressions.constant(1),
                Expressions.multiply(Expressions.constant(2), Expressions.constant(3)))));

    assertEquals(
        "1 * (2 + 3)",
        Expressions.toString(
            Expressions.multiply(
                Expressions.constant(1),
                Expressions.add(Expressions.constant(2), Expressions.constant(3)))));

    // Parentheses needed, to overcome right-associativity of =.
    assertEquals(
        "(1 = 2) = 3",
        Expressions.toString(
            Expressions.assign(
                Expressions.assign(Expressions.constant(1), Expressions.constant(2)),
                Expressions.constant(3))));

    // Ternary operator.
    assertEquals(
        "1 < 2 ? (3 < 4 ? 5 : 6) : 7 < 8 ? 9 : 10",
        Expressions.toString(
            Expressions.condition(
                Expressions.lessThan(Expressions.constant(1), Expressions.constant(2)),
                Expressions.condition(
                    Expressions.lessThan(Expressions.constant(3), Expressions.constant(4)),
                    Expressions.constant(5),
                    Expressions.constant(6)),
                Expressions.condition(
                    Expressions.lessThan(Expressions.constant(7), Expressions.constant(8)),
                    Expressions.constant(9),
                    Expressions.constant(10)))));

    assertEquals(
        "0 + (double) (2 + 3)",
        Expressions.toString(
            Expressions.add(
                Expressions.constant(0),
                Expressions.convert_(
                    Expressions.add(Expressions.constant(2), Expressions.constant(3)),
                    Double.TYPE))));

    assertEquals(
        "a.empno",
        Expressions.toString(
            Expressions.field(Expressions.parameter(Linq4jTest.Employee.class, "a"), "empno")));

    assertEquals(
        "java.util.Collections.EMPTY_LIST",
        Expressions.toString(Expressions.field(null, Collections.class, "EMPTY_LIST")));

    final ParameterExpression paramX = Expressions.parameter(String.class, "x");
    assertEquals(
        "new net.hydromatic.linq4j.function.Function1() {\n"
            + "  public int apply(String x) {\n"
            + "    return x.length();\n"
            + "  }\n"
            + "  public Object apply(Object x) {\n"
            + "    return apply(\n"
            + "      (String) x);\n"
            + "  }\n"
            + "}\n",
        Expressions.toString(
            Expressions.lambda(
                Function1.class,
                Expressions.call(paramX, "length", Collections.<Expression>emptyList()),
                Arrays.asList(paramX))));

    assertEquals(
        "new String[] {\n" + "  \"foo\",\n" + "  null,\n" + "  \"bar\\\"baz\"}",
        Expressions.toString(
            Expressions.newArrayInit(
                String.class,
                Arrays.<Expression>asList(
                    Expressions.constant("foo"),
                    Expressions.constant(null),
                    Expressions.constant("bar\"baz")))));

    assertEquals(
        "(int) ((String) (Object) \"foo\").length()",
        Expressions.toString(
            Expressions.convert_(
                Expressions.call(
                    Expressions.convert_(
                        Expressions.convert_(Expressions.constant("foo"), Object.class),
                        String.class),
                    "length",
                    Collections.<Expression>emptyList()),
                Integer.TYPE)));

    // resolving a static method
    assertEquals(
        "Integer.valueOf(\"0123\")",
        Expressions.toString(
            Expressions.call(
                Integer.class,
                "valueOf",
                Collections.<Expression>singletonList(Expressions.constant("0123")))));

    // precedence of not and instanceof
    assertEquals(
        "!(o instanceof String)",
        Expressions.toString(
            Expressions.not(
                Expressions.typeIs(Expressions.parameter(Object.class, "o"), String.class))));

    // not not
    assertEquals(
        "!!(o instanceof String)",
        Expressions.toString(
            Expressions.not(
                Expressions.not(
                    Expressions.typeIs(Expressions.parameter(Object.class, "o"), String.class)))));
  }
예제 #6
0
 public void testWriteAnonymousClass() {
   // final List<String> baz = Arrays.asList("foo", "bar");
   // new AbstractList<String>() {
   //     public int size() {
   //         return baz.size();
   //     }
   //     public String get(int index) {
   //         return ((String) baz.get(index)).toUpperCase();
   //     }
   // }
   final ParameterExpression bazParameter =
       Expressions.parameter(Types.of(List.class, String.class), "baz");
   final ParameterExpression indexParameter = Expressions.parameter(Integer.TYPE, "index");
   BlockExpression e =
       Expressions.block(
           Expressions.declare(
               Modifier.FINAL,
               bazParameter,
               Expressions.call(
                   Arrays.class,
                   "asList",
                   Arrays.<Expression>asList(
                       Expressions.constant("foo"), Expressions.constant("bar")))),
           Expressions.statement(
               Expressions.new_(
                   Types.of(AbstractList.class, String.class),
                   Collections.<Expression>emptyList(),
                   Arrays.<MemberDeclaration>asList(
                       Expressions.fieldDecl(
                           Modifier.PUBLIC | Modifier.FINAL,
                           Expressions.parameter(String.class, "qux"),
                           Expressions.constant("xyzzy")),
                       Expressions.methodDecl(
                           Modifier.PUBLIC,
                           Integer.TYPE,
                           "size",
                           Collections.<ParameterExpression>emptyList(),
                           Blocks.toFunctionBlock(
                               Expressions.call(
                                   bazParameter, "size", Collections.<Expression>emptyList()))),
                       Expressions.methodDecl(
                           Modifier.PUBLIC,
                           String.class,
                           "get",
                           Arrays.asList(indexParameter),
                           Blocks.toFunctionBlock(
                               Expressions.call(
                                   Expressions.convert_(
                                       Expressions.call(
                                           bazParameter,
                                           "get",
                                           Arrays.<Expression>asList(indexParameter)),
                                       String.class),
                                   "toUpperCase",
                                   Collections.<Expression>emptyList())))))));
   assertEquals(
       "{\n"
           + "  final java.util.List<String> baz = java.util.Arrays.asList(\"foo\", \"bar\");\n"
           + "  new java.util.AbstractList<String>(){\n"
           + "    public final String qux = \"xyzzy\";\n"
           + "    public int size() {\n"
           + "      return baz.size();\n"
           + "    }\n"
           + "\n"
           + "    public String get(int index) {\n"
           + "      return ((String) baz.get(index)).toUpperCase();\n"
           + "    }\n"
           + "\n"
           + "  };\n"
           + "}\n",
       Expressions.toString(e));
 }
예제 #7
0
  <T> PrepareResult<T> prepare_(
      Context context, String sql, Queryable<T> queryable, Type elementType) {
    final JavaTypeFactory typeFactory = context.getTypeFactory();
    OptiqCatalogReader catalogReader = new OptiqCatalogReader(context.getRootSchema(), typeFactory);
    final OptiqPreparingStmt preparingStmt =
        new OptiqPreparingStmt(catalogReader, typeFactory, context.getRootSchema());
    preparingStmt.setResultCallingConvention(CallingConvention.ENUMERABLE);

    final RelDataType x;
    final PreparedResult preparedResult;
    if (sql != null) {
      assert queryable == null;
      SqlParser parser = new SqlParser(sql);
      SqlNode sqlNode;
      try {
        sqlNode = parser.parseQuery();
      } catch (SqlParseException e) {
        throw new RuntimeException("parse failed", e);
      }
      final Schema rootSchema = context.getRootSchema();
      SqlValidator validator =
          new SqlValidatorImpl(
              new ChainedSqlOperatorTable(
                  Arrays.<SqlOperatorTable>asList(
                      SqlStdOperatorTable.instance(),
                      new MySqlOperatorTable(rootSchema, typeFactory))),
              catalogReader,
              typeFactory,
              SqlConformance.Default) {};
      preparedResult = preparingStmt.prepareSql(sqlNode, Object.class, validator, true);
      x = validator.getValidatedNodeType(sqlNode);
    } else {
      assert queryable != null;
      x = context.getTypeFactory().createType(elementType);
      preparedResult = preparingStmt.prepareQueryable(queryable, x);
    }

    // TODO: parameters
    final List<Parameter> parameters = Collections.emptyList();
    // TODO: column meta data
    final List<ColumnMetaData> columns = new ArrayList<ColumnMetaData>();
    RelDataType jdbcType = makeStruct(typeFactory, x);
    for (RelDataTypeField field : jdbcType.getFields()) {
      RelDataType type = field.getType();
      SqlTypeName sqlTypeName = type.getSqlTypeName();
      columns.add(
          new ColumnMetaData(
              columns.size(),
              false,
              true,
              false,
              false,
              type.isNullable() ? 1 : 0,
              true,
              0,
              field.getName(),
              field.getName(),
              null,
              sqlTypeName.allowsPrec() && false ? type.getPrecision() : -1,
              sqlTypeName.allowsScale() ? type.getScale() : -1,
              null,
              null,
              sqlTypeName.getJdbcOrdinal(),
              sqlTypeName.getName(),
              true,
              false,
              false,
              null));
    }
    return new PrepareResult<T>(sql, parameters, columns, (Enumerable<T>) preparedResult.execute());
  }
예제 #8
0
 private RexNode binary(Expression expression, SqlBinaryOperator op) {
   BinaryExpression call = (BinaryExpression) expression;
   return rexBuilder.makeCall(op, toRex(Arrays.asList(call.expression0, call.expression1)));
 }