Java Expressions.lambda方法代码示例

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
@Test public void testLambdaCallsTwoArgMethod() throws NoSuchMethodException {
  // A parameter for the lambda expression.
  ParameterExpression paramS =
      Expressions.parameter(String.class, "s");
  ParameterExpression paramBegin =
      Expressions.parameter(Integer.TYPE, "begin");
  ParameterExpression paramEnd =
      Expressions.parameter(Integer.TYPE, "end");

  // This expression represents a lambda expression
  // that adds 1 to the parameter value.
  FunctionExpression lambdaExpr =
      Expressions.lambda(
          Expressions.call(
              paramS,
              String.class.getMethod(
                  "substring", Integer.TYPE, Integer.TYPE),
              paramBegin,
              paramEnd), paramS, paramBegin, paramEnd);

  // Compile and run the lambda expression.
  String s =
      (String) lambdaExpr.compile().dynamicInvoke("hello world", 3, 7);

  assertEquals("lo w", s);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
public Expression generateSelector(
    ParameterExpression parameter,
    List<Integer> fields,
    JavaRowFormat targetFormat) {
  // Optimize target format
  switch (fields.size()) {
  case 0:
    targetFormat = JavaRowFormat.LIST;
    break;
  case 1:
    targetFormat = JavaRowFormat.SCALAR;
    break;
  }
  final PhysType targetPhysType =
      project(fields, targetFormat);
  switch (format) {
  case SCALAR:
    return Expressions.call(BuiltInMethod.IDENTITY_SELECTOR.method);
  default:
    return Expressions.lambda(Function1.class,
        targetPhysType.record(fieldReferences(parameter, fields)), parameter);
  }
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
@Test public void testLambdaPrimitiveTwoArgs() {
  // Parameters for the lambda expression.
  ParameterExpression paramExpr =
      Expressions.parameter(int.class, "key");
  ParameterExpression param2Expr =
      Expressions.parameter(int.class, "key2");

  FunctionExpression lambdaExpr = Expressions.lambda(
      Expressions.block(
          (Type) null,
          Expressions.return_(
              null, paramExpr)),
      Arrays.asList(paramExpr, param2Expr));

  // Print out the expression.
  String s = Expressions.toString(lambdaExpr);
  assertEquals("new org.apache.calcite.linq4j.function.Function2() {\n"
          + "  public int apply(int key, int key2) {\n"
          + "    return key;\n"
          + "  }\n"
          + "  public Integer apply(Integer key, Integer key2) {\n"
          + "    return apply(\n"
          + "      key.intValue(),\n"
          + "      key2.intValue());\n"
          + "  }\n"
          + "  public Integer apply(Object key, Object key2) {\n"
          + "    return apply(\n"
          + "      (Integer) key,\n"
          + "      (Integer) key2);\n"
          + "  }\n"
          + "}\n",
      s);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
Expression predicate(EnumerableRelImplementor implementor,
    BlockBuilder builder, PhysType leftPhysType, PhysType rightPhysType,
    RexNode condition) {
  final ParameterExpression left_ =
      Expressions.parameter(leftPhysType.getJavaRowType(), "left");
  final ParameterExpression right_ =
      Expressions.parameter(rightPhysType.getJavaRowType(), "right");
  final RexProgramBuilder program =
      new RexProgramBuilder(
          implementor.getTypeFactory().builder()
              .addAll(left.getRowType().getFieldList())
              .addAll(right.getRowType().getFieldList())
              .build(),
          getCluster().getRexBuilder());
  program.addCondition(condition);
  builder.add(
      Expressions.return_(null,
          RexToLixTranslator.translateCondition(program.getProgram(),
              implementor.getTypeFactory(),
              builder,
              new RexToLixTranslator.InputGetterImpl(
                  ImmutableList.of(Pair.of((Expression) left_, leftPhysType),
                      Pair.of((Expression) right_, rightPhysType))),
              implementor.allCorrelateVariables)));
  return Expressions.lambda(Predicate2.class, builder.toBlock(), left_,
      right_);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
@Test public void testLambdaCallsBinaryOp() {
  // A parameter for the lambda expression.
  ParameterExpression paramExpr =
      Expressions.parameter(Double.TYPE, "arg");

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

  // Print out the expression.
  String s = Expressions.toString(lambdaExpr);
  assertEquals(
      "new org.apache.calcite.linq4j.function.Function1() {\n"
          + "  public double apply(double arg) {\n"
          + "    return arg + 2.0D;\n"
          + "  }\n"
          + "  public Object apply(Double arg) {\n"
          + "    return apply(\n"
          + "      arg.doubleValue());\n"
          + "  }\n"
          + "  public Object apply(Object arg) {\n"
          + "    return apply(\n"
          + "      (Double) arg);\n"
          + "  }\n"
          + "}\n",
      s);

  // Compile and run the lambda expression.
  // The value of the parameter is 1.5.
  double n = (Double) lambdaExpr.compile().dynamicInvoke(1.5d);

  // This code example produces the following output:
  //
  // arg => (arg +2)
  // 3
  assertEquals(3.5D, n, 0d);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
static Expression joinSelector(JoinRelType joinType, PhysType physType,
    List<PhysType> inputPhysTypes) {
  // A parameter for each input.
  final List<ParameterExpression> parameters = new ArrayList<>();

  // Generate all fields.
  final List<Expression> expressions = new ArrayList<>();
  final int outputFieldCount = physType.getRowType().getFieldCount();
  for (Ord<PhysType> ord : Ord.zip(inputPhysTypes)) {
    final PhysType inputPhysType =
        ord.e.makeNullable(joinType.generatesNullsOn(ord.i));
    // If input item is just a primitive, we do not generate specialized
    // primitive apply override since it won't be called anyway
    // Function<T> always operates on boxed arguments
    final ParameterExpression parameter =
        Expressions.parameter(Primitive.box(inputPhysType.getJavaRowType()),
            EnumUtils.LEFT_RIGHT.get(ord.i));
    parameters.add(parameter);
    if (expressions.size() == outputFieldCount) {
      // For instance, if semi-join needs to return just the left inputs
      break;
    }
    final int fieldCount = inputPhysType.getRowType().getFieldCount();
    for (int i = 0; i < fieldCount; i++) {
      Expression expression =
          inputPhysType.fieldReference(parameter, i,
              physType.getJavaFieldType(expressions.size()));
      if (joinType.generatesNullsOn(ord.i)) {
        expression =
            Expressions.condition(
                Expressions.equal(parameter, Expressions.constant(null)),
                Expressions.constant(null),
                expression);
      }
      expressions.add(expression);
    }
  }
  return Expressions.lambda(
      Function2.class,
      physType.record(expressions),
      parameters);
}