Java Expressions.call方法代码示例

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
private static Expression constantStringList(final List<String> strings) {
  return Expressions.call(
      Arrays.class,
      "asList",
      Expressions.newArrayInit(
          Object.class,
          new AbstractList<Expression>() {
            @Override public Expression get(int index) {
              return Expressions.constant(strings.get(index));
            }

            @Override public int size() {
              return strings.size();
            }
          }));
}
 

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 testCompile() throws NoSuchMethodException {
  // Creating a parameter for the expression tree.
  ParameterExpression param = Expressions.parameter(String.class);

  // Creating an expression for the method call and specifying its
  // parameter.
  MethodCallExpression methodCall =
      Expressions.call(
          Integer.class,
          "valueOf",
          Collections.<Expression>singletonList(param));

  // The following statement first creates an expression tree,
  // then compiles it, and then runs it.
  int x =
      Expressions.<Function1<String, Integer>>lambda(
          methodCall,
          new ParameterExpression[] { param })
          .getFunction()
          .apply("1234");
  assertEquals(1234, x);
}
 

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包/类
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包/类
@Override
public Expression getExpression(SchemaPlus parentSchema,
                                String name) {
    return Expressions.call(
            DataContext.ROOT,
            BuiltInMethod.DATA_CONTEXT_GET_ROOT_SCHEMA.method);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
@Override
public Expression getExpression(SchemaPlus parentSchema,
                                String name) {
  return Expressions.call(
      DataContext.ROOT,
      BuiltInMethod.DATA_CONTEXT_GET_ROOT_SCHEMA.method);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
@Override
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {

    context.setReturnTupleInfo(rowType, columnRowType);

    PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), getRowType(), pref.preferArray());
    RelOptTable factTable = context.firstTableScan.getTable();
    MethodCallExpression exprCall = Expressions.call(factTable.getExpression(OLAPTable.class), "executeOLAPQuery",
            implementor.getRootExpression(), Expressions.constant(context.id));
    return implementor.result(physType, Blocks.toBlock(exprCall));
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
@Override
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {

    context.setReturnTupleInfo(rowType, columnRowType);
    String execFunction = genExecFunc();

    PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), getRowType(), JavaRowFormat.ARRAY);
    MethodCallExpression exprCall = Expressions.call(table.getExpression(OLAPTable.class), execFunction,
            implementor.getRootExpression(), Expressions.constant(context.id));
    return implementor.result(physType, Blocks.toBlock(exprCall));
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
@Override
public Expression implement(RexToLixTranslator rexToLixTranslator, RexCall rexCall, List<Expression> operands) {
    int snapshotId = SnapshotHolder.put(snapshot);

    return Expressions.call(
            Expressions.new_(getConstructor(SnapshotFunctions.class, Integer.TYPE), Expressions.constant(snapshotId, Integer.TYPE)),
            functionMethod, operands);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
/** E.g. {@code constantArrayList("x", "y")} returns
 * "Arrays.asList('x', 'y')". */
private static <T> MethodCallExpression constantArrayList(List<T> values,
    Class clazz) {
  return Expressions.call(
      BuiltInMethod.ARRAYS_AS_LIST.method,
      Expressions.newArrayInit(clazz, constantList(values)));
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
@Override public CallImplementor getImplementor() {
  return new CallImplementor() {
    public Expression implement(RexToLixTranslator translator, RexCall call, NullAs nullAs) {
      Method lookupMethod =
          Types.lookupMethod(Smalls.AllTypesFunction.class,
              "arrayAppendFun", List.class, Integer.class);
      return Expressions.call(lookupMethod,
          translator.translateList(call.getOperands(), nullAs));
    }
  };
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
private Expression callBackupMethodAnyType(RexToLixTranslator translator,
    RexCall call, List<Expression> expressions) {
  final String backupMethodNameForAnyType =
      backupMethodName + METHOD_POSTFIX_FOR_ANY_TYPE;

  // one or both of parameter(s) is(are) ANY type
  final Expression expression0 = maybeBox(expressions.get(0));
  final Expression expression1 = maybeBox(expressions.get(1));
  return Expressions.call(SqlFunctions.class, backupMethodNameForAnyType,
      expression0, expression1);
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
public Expression implement(
    RexToLixTranslator translator,
    RexCall call,
    NullAs nullAs) {
  switch (nullAs) {
  case IS_NULL:
    return Expressions.constant(false);
  case IS_NOT_NULL:
    return Expressions.constant(true);
  }
  final SqlOperator op = call.getOperator();
  final Expression root = translator.getRoot();
  if (op == CURRENT_USER
      || op == SESSION_USER
      || op == USER) {
    return Expressions.constant("sa");
  } else if (op == SYSTEM_USER) {
    return Expressions.constant(System.getProperty("user.name"));
  } else if (op == CURRENT_PATH
      || op == CURRENT_ROLE
      || op == CURRENT_CATALOG) {
    // By default, the CURRENT_ROLE and CURRENT_CATALOG functions return the
    // empty string because a role or a catalog has to be set explicitly.
    return Expressions.constant("");
  } else if (op == CURRENT_TIMESTAMP) {
    return Expressions.call(BuiltInMethod.CURRENT_TIMESTAMP.method, root);
  } else if (op == CURRENT_TIME) {
    return Expressions.call(BuiltInMethod.CURRENT_TIME.method, root);
  } else if (op == CURRENT_DATE) {
    return Expressions.call(BuiltInMethod.CURRENT_DATE.method, root);
  } else if (op == LOCALTIMESTAMP) {
    return Expressions.call(BuiltInMethod.LOCAL_TIMESTAMP.method, root);
  } else if (op == LOCALTIME) {
    return Expressions.call(BuiltInMethod.LOCAL_TIME.method, root);
  } else {
    throw new AssertionError("unknown function " + op);
  }
}
 

import org.apache.calcite.linq4j.tree.Expressions; //导入方法依赖的package包/类
public Expression implement(RexToLixTranslator translator,
    RexCall call, List<Expression> translatedOperands) {
  translatedOperands =
      EnumUtils.fromInternal(method.getParameterTypes(), translatedOperands);
  if ((method.getModifiers() & Modifier.STATIC) != 0) {
    return Expressions.call(method, translatedOperands);
  } else {
    // The UDF class must have a public zero-args constructor.
    // Assume that the validator checked already.
    final Expression target =
        Expressions.new_(method.getDeclaringClass());
    return Expressions.call(target, method, translatedOperands);
  }
}