Java Expressions类代码示例

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
  final JavaTypeFactory typeFactory = implementor.getTypeFactory();
  final BlockBuilder builder = new BlockBuilder();
  final PhysType physType =
      PhysTypeImpl.of(typeFactory, getRowType(), JavaRowFormat.ARRAY);
  final Expression interpreter_ = builder.append("interpreter",
      Expressions.new_(Interpreter.class,
          implementor.getRootExpression(),
          implementor.stash(getInput(), RelNode.class)));
  final Expression sliced_ =
      getRowType().getFieldCount() == 1
          ? Expressions.call(BuiltInMethod.SLICE0.method, interpreter_)
          : interpreter_;
  builder.add(sliced_);
  return implementor.result(physType, builder.toBlock());
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
public Result implementSpark(Implementor implementor) {
  // Generate:
  //   Enumerable source = ...;
  //   return SparkRuntime.createRdd(sparkContext, source);
  final BlockBuilder list = new BlockBuilder();
  final EnumerableRel child = (EnumerableRel) getInput();
  final PhysType physType =
      PhysTypeImpl.of(
          implementor.getTypeFactory(), getRowType(),
          JavaRowFormat.CUSTOM);
  final Expression source = null; // TODO:
  final Expression sparkContext =
      Expressions.call(
          SparkMethod.GET_SPARK_CONTEXT.method,
          implementor.getRootExpression());
  final Expression rdd =
      list.append(
          "rdd",
          Expressions.call(
              SparkMethod.CREATE_RDD.method,
              sparkContext,
              source));
  list.add(
      Expressions.return_(null, rdd));
  return implementor.result(physType, list.toBlock());
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
@Test public void testWriteTryCatch() {
  final ParameterExpression cce_ =
      Expressions.parameter(Modifier.FINAL, ClassCastException.class, "cce");
  final ParameterExpression re_ =
      Expressions.parameter(0, RuntimeException.class, "re");
  Node node =
      Expressions.tryCatch(
          Expressions.block(
              Expressions.return_(null,
                  Expressions.call(Expressions.constant("foo"), "length"))),
          Expressions.catch_(cce_,
              Expressions.return_(null, Expressions.constant(null))),
          Expressions.catch_(re_,
              Expressions.return_(null,
                  Expressions.call(re_, "toString"))));
  assertEquals(
      "try {\n"
          + "  return \"foo\".length();\n"
          + "} catch (final ClassCastException cce) {\n"
          + "  return null;\n"
          + "} catch (RuntimeException re) {\n"
          + "  return re.toString();\n"
          + "}\n",
      Expressions.toString(node));
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
public Expression field(BlockBuilder list, int index, Type storageType) {
  MethodCallExpression recFromCtx = Expressions.call(
      DataContext.ROOT,
      BuiltInMethod.DATA_CONTEXT_GET.method,
      Expressions.constant("inputRecord"));
  Expression recFromCtxCasted =
      RexToLixTranslator.convert(recFromCtx, Object[].class);
  IndexExpression recordAccess = Expressions.arrayIndex(recFromCtxCasted,
      Expressions.constant(index));
  if (storageType == null) {
    final RelDataType fieldType =
        rowType.getFieldList().get(index).getType();
    storageType = ((JavaTypeFactory) typeFactory).getJavaClass(fieldType);
  }
  return RexToLixTranslator.convert(recordAccess, storageType);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
@Test public void testTestCustomOptimizer() {
  BlockBuilder b = new BlockBuilder() {
    @Override protected Shuttle createOptimizeShuttle() {
      return new OptimizeShuttle() {
        @Override public Expression visit(BinaryExpression binary,
            Expression expression0, Expression expression1) {
          if (binary.getNodeType() == ExpressionType.Add
              && ONE.equals(expression0) && TWO.equals(expression1)) {
            return FOUR;
          }
          return super.visit(binary, expression0, expression1);
        }
      };
    }
  };
  b.add(Expressions.return_(null, Expressions.add(ONE, TWO)));
  assertEquals("{\n  return 4;\n}\n", b.toBlock().toString());
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
@Test public void testNonDeterministicMethodCall() {
  assertThat(
      optimize(
          Expressions.new_(
              Runnable.class,
              Collections.<Expression>emptyList(),
              Expressions.methodDecl(
                  0,
                  int.class,
                  "test",
                  Collections.<ParameterExpression>emptyList(),
                  Blocks.toFunctionBlock(
                      Expressions.call(null,
                          Types.lookupMethod(TestClass.class,
                              "nonDeterministic", int.class),
                          ONE))))),
      equalTo("{\n"
          + "  return new Runnable(){\n"
          + "      int test() {\n"
          + "        return org.apache.calcite.linq4j.test.DeterministicTest.TestClass.nonDeterministic(1);\n"
          + "      }\n"
          + "\n"
          + "    };\n"
          + "}\n"));
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
@Test public void testAssignInConditionMultipleUsage() {
  // int t;
  // return (t = 1) != a ? t : c
  final BlockBuilder builder = new BlockBuilder(true);
  final ParameterExpression t = Expressions.parameter(int.class, "t");

  builder.add(Expressions.declare(0, t, null));

  Expression v = builder.append("v",
      Expressions.makeTernary(ExpressionType.Conditional,
          Expressions.makeBinary(ExpressionType.NotEqual,
              Expressions.assign(t, Expressions.constant(1)),
              Expressions.parameter(int.class, "a")),
          t,
          Expressions.parameter(int.class, "c")));
  builder.add(Expressions.return_(null, v));
  assertEquals(
      "{\n"
          + "  int t;\n"
          + "  return (t = 1) != a ? t : c;\n"
          + "}\n",
      Expressions.toString(builder.toBlock()));
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
@Test public void testFactorOutBinaryAddMul() {
  assertThat(
      optimize(
          Expressions.new_(
              Runnable.class,
              Collections.<Expression>emptyList(),
              Expressions.methodDecl(
                  0,
                  int.class,
                  "test",
                  Collections.<ParameterExpression>emptyList(),
                  Blocks.toFunctionBlock(
                      Expressions.multiply(Expressions.add(ONE, TWO),
                          THREE))))),
      equalTo("{\n"
          + "  return new Runnable(){\n"
          + "      int test() {\n"
          + "        return $L4J$C$1_2_3;\n"
          + "      }\n"
          + "\n"
          + "      static final int $L4J$C$1_2 = 1 + 2;\n"
          + "      static final int $L4J$C$1_2_3 = $L4J$C$1_2 * 3;\n"
          + "    };\n"
          + "}\n"));
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
@Test public void testFor() throws NoSuchFieldException {
  final BlockBuilder builder = new BlockBuilder();
  final ParameterExpression i_ = Expressions.parameter(int.class, "i");
  builder.add(
      Expressions.for_(
          Expressions.declare(
              0, i_, Expressions.constant(0)),
          Expressions.lessThan(i_, Expressions.constant(10)),
          Expressions.postIncrementAssign(i_),
          Expressions.block(
              Expressions.statement(
                  Expressions.call(
                      Expressions.field(
                          null, System.class.getField("out")),
                      "println",
                      i_)))));
  assertEquals(
      "{\n"
          + "  for (int i = 0; i < 10; i++) {\n"
          + "    System.out.println(i);\n"
          + "  }\n"
          + "}\n",
      Expressions.toString(builder.toBlock()));
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
/** Returns the expression for a sub-schema. */
public static Expression subSchemaExpression(SchemaPlus schema, String name,
    Class type) {
  // (Type) schemaExpression.getSubSchema("name")
  final Expression schemaExpression = expression(schema);
  Expression call =
      Expressions.call(
          schemaExpression,
          BuiltInMethod.SCHEMA_GET_SUB_SCHEMA.method,
          Expressions.constant(name));
  //CHECKSTYLE: IGNORE 2
  //noinspection unchecked
  if (false && type != null && !type.isAssignableFrom(Schema.class)) {
    return unwrap(call, type);
  }
  return call;
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
public Expression implement(
    RexToLixTranslator translator,
    RexCall call,
    List<Expression> translatedOperands) {
  final Expression expression;
  if (Modifier.isStatic(method.getModifiers())) {
    expression = Expressions.call(method, translatedOperands);
  } else {
    expression = Expressions.call(translatedOperands.get(0), method,
        Util.skip(translatedOperands, 1));
  }

  final Type returnType =
      translator.typeFactory.getJavaClass(call.getType());
  return Types.castIfNecessary(returnType, expression);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
@Test public void testIfElseIfElse() {
  assertEquals(
      "if (true) {\n"
          + "  return;\n"
          + "} else if (false) {\n"
          + "  return;\n"
          + "} else {\n"
          + "  return 1;\n"
          + "}\n",
      Expressions.toString(
          Expressions.ifThenElse(
              Expressions.constant(true),
              Expressions.return_(null),
              Expressions.constant(false),
              Expressions.return_(null),
              Expressions.return_(null, Expressions.constant(1)))));
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
@Test public void testFactorOutBinaryAddNameCollision() {
  assertThat(
      optimize(
          Expressions.new_(
              Runnable.class,
              Collections.<Expression>emptyList(),
              Expressions.methodDecl(
                  0,
                  int.class,
                  "test",
                  Collections.<ParameterExpression>emptyList(),
                  Blocks.toFunctionBlock(
                      Expressions.multiply(Expressions.add(ONE, TWO),
                          Expressions.subtract(ONE, TWO)))))),
      equalTo("{\n"
          + "  return new Runnable(){\n"
          + "      int test() {\n"
          + "        return $L4J$C$1_2_1_20;\n"
          + "      }\n"
          + "\n"
          + "      static final int $L4J$C$1_2 = 1 + 2;\n"
          + "      static final int $L4J$C$1_20 = 1 - 2;\n"
          + "      static final int $L4J$C$1_2_1_20 = $L4J$C$1_2 * $L4J$C$1_20;\n"
          + "    };\n"
          + "}\n"));
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
@Test public void testNoInlineMultipleUsage() {
  ParameterExpression p1 = Expressions.parameter(int.class, "p1");
  ParameterExpression p2 = Expressions.parameter(int.class, "p2");
  DeclarationStatement decl = Expressions.declare(16, "x",
      Expressions.subtract(p1, p2));
  b.add(decl);
  b.add(
      Expressions.return_(null,
          Expressions.add(decl.parameter, decl.parameter)));
  assertEquals(
      "{\n"
          + "  final int x = p1 - p2;\n"
          + "  return x + x;\n"
          + "}\n",
      b.toBlock().toString());
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入依赖的package包/类
public Expression implementResult(AggContext info,
    AggResultContext result) {
  WinAggResultContext winResult = (WinAggResultContext) result;

  List<RexNode> rexArgs = winResult.rexArguments();

  Expression tiles =
      winResult.rowTranslator(winResult.index()).translate(
          rexArgs.get(0), int.class);

  Expression ntile =
      Expressions.add(Expressions.constant(1),
          Expressions.divide(
              Expressions.multiply(
                  tiles,
                  Expressions.subtract(
                      winResult.index(), winResult.startIndex())),
              winResult.getPartitionRowCount()));

  return ntile;
}