Java EnumerableRelImplementor类代码示例

import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor; //导入依赖的package包/类
@Override
    public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
        final BlockBuilder list = new BlockBuilder();
        final GremlinTraversalRel.Implementor gremlinImplementor =
                new GremlinTraversalRel.Implementor();
        gremlinImplementor.visitChild(0, getInput());

        PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(),
                getRowType(), pref.preferArray());

        return implementor.result(
                physType,
                Blocks.toBlock(
                        Expressions.call(GremlinTraversalScan.class,
                                "scan")));
//        return null;
    }
 

import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor; //导入依赖的package包/类
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
  PhysType physType =
      PhysTypeImpl.of(
          implementor.getTypeFactory(),
          getRowType(),
          pref.preferArray());

  if (table instanceof JsonTable) {
    return implementor.result(
        physType,
        Blocks.toBlock(
            Expressions.call(table.getExpression(JsonTable.class),
                "enumerable")));
  }
  return implementor.result(
      physType,
      Blocks.toBlock(
          Expressions.call(table.getExpression(CsvTranslatableTable.class),
              "project", implementor.getRootExpression(),
              Expressions.constant(fields))));
}
 

import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor; //导入依赖的package包/类
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
  // Generate:
  //   RDD rdd = ...;
  //   return SparkRuntime.asEnumerable(rdd);
  final BlockBuilder list = new BlockBuilder();
  final SparkRel child = (SparkRel) getInput();
  final PhysType physType =
      PhysTypeImpl.of(implementor.getTypeFactory(),
          getRowType(),
          JavaRowFormat.CUSTOM);
  SparkRel.Implementor sparkImplementor =
      new SparkImplementorImpl(implementor);
  final SparkRel.Result result = child.implementSpark(sparkImplementor);
  final Expression rdd = list.append("rdd", result.block);
  final Expression enumerable =
      list.append(
          "enumerable",
          Expressions.call(
              SparkMethod.AS_ENUMERABLE.method,
              rdd));
  list.add(
      Expressions.return_(null, enumerable));
  return implementor.result(physType, list.toBlock());
}
 

import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor; //导入依赖的package包/类
@Override
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
    final PhysType physType =
            PhysTypeImpl.of(
                    implementor.getTypeFactory(),
                    getRowType(),
                    pref.preferArray());
    return implementor.result(
            physType,
            Blocks.toBlock(
                    Expressions.call(table.getExpression(OctopusMetaModelTable.class),
                            "project")));
}
 

import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor; //导入依赖的package包/类
private UnaryExpression getTimeZoneExpression(
        EnumerableRelImplementor implementor) {
    return Expressions.convert_(
            Expressions.call(
                    implementor.getRootExpression(),
                    "get",
                    Expressions.constant("timeZone")),
            TimeZone.class);
}
 

import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor; //导入依赖的package包/类
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
  PhysType physType =
      PhysTypeImpl.of(
          implementor.getTypeFactory(),
          getRowType(),
          pref.preferArray());

  return implementor.result(
      physType,
      Blocks.toBlock(
          Expressions.call(table.getExpression(QuarkTable.class),
              "project",
              Expressions.constant(QuarkEnumerator.identityList(
                  getRowType().getFieldCount())))));
}
 

import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor; //导入依赖的package包/类
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
  PhysType physType =
      PhysTypeImpl.of(
          implementor.getTypeFactory(),
          getRowType(),
          pref.preferArray());

  return implementor.result(
      physType,
      Blocks.toBlock(
          Expressions.call(table.getExpression(QuarkTileTable.class),
              "project", Expressions.constant(
                  QuarkEnumerator.identityList(getRowType().getFieldCount())))));
}
 

import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor; //导入依赖的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.adapter.enumerable.EnumerableRelImplementor; //导入依赖的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.adapter.enumerable.EnumerableRelImplementor; //导入依赖的package包/类
/**
 * {@inheritDoc}
 *
 * <p>This implementation does not actually execute the associated Pig Latin
 * script and return results. Instead it returns an empty
 * {@link org.apache.calcite.adapter.enumerable.EnumerableRel.Result}
 * in order to allow for testing and verification of every step of query
 * processing up to actual physical execution and result verification.
 *
 * <p>Next step is to invoke Pig from here, likely in local mode, have it
 * store results in a predefined file so they can be read here and returned as
 * a {@code Result} object.
 */
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
  final BlockBuilder list = new BlockBuilder();
  final PhysType physType =
      PhysTypeImpl.of(implementor.getTypeFactory(), rowType,
          pref.prefer(JavaRowFormat.ARRAY));
  PigRel.Implementor impl = new PigRel.Implementor();
  impl.visitChild(0, getInput());
  Hook.QUERY_PLAN.run(impl.getScript()); // for script validation in tests
  list.add(
      Expressions.return_(null,
          Expressions.call(
              BuiltInMethod.EMPTY_ENUMERABLE.method)));
  return implementor.result(physType, list.toBlock());
}
 

import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor; //导入依赖的package包/类
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
  PhysType physType =
      PhysTypeImpl.of(
          implementor.getTypeFactory(),
          getRowType(),
          pref.preferArray());

  return implementor.result(
      physType,
      Blocks.toBlock(
          Expressions.call(table.getExpression(FileTable.class), "project",
              Expressions.constant(fields))));
}
 

import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor; //导入依赖的package包/类
private UnaryExpression getTimeZoneExpression(
    EnumerableRelImplementor implementor) {
  return Expressions.convert_(
      Expressions.call(
          implementor.getRootExpression(),
          "get",
          Expressions.constant("timeZone")),
      TimeZone.class);
}
 

import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor; //导入依赖的package包/类
@Override public Result implement(EnumerableRelImplementor implementor, Prefer prefer) {
  final BlockBuilder list = new BlockBuilder();
  final ElasticsearchRel.Implementor elasticsearchImplementor =
      new ElasticsearchRel.Implementor();
  elasticsearchImplementor.visitChild(0, getInput());
  final RelDataType rowType = getRowType();
  final PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), rowType,
      prefer.prefer(JavaRowFormat.ARRAY));
  final Expression fields = list.append("fields",
      constantArrayList(
          Pair.zip(ElasticsearchRules.elasticsearchFieldNames(rowType),
              new AbstractList<Class>() {
                @Override public Class get(int index) {
                  return physType.fieldClass(index);
                }

                @Override public int size() {
                  return rowType.getFieldCount();
                }
              }),
          Pair.class));
  final Expression table = list.append("table",
      elasticsearchImplementor.table
          .getExpression(AbstractElasticsearchTable.ElasticsearchQueryable.class));
  List<String> opList = elasticsearchImplementor.list;
  final Expression ops = list.append("ops", constantArrayList(opList, String.class));
  Expression enumerable = list.append("enumerable",
      Expressions.call(table, ElasticsearchMethod.ELASTICSEARCH_QUERYABLE_FIND.method, ops,
          fields));
  if (CalcitePrepareImpl.DEBUG) {
    System.out.println("Elasticsearch: " + opList);
  }
  Hook.QUERY_PLAN.run(opList);
  list.add(Expressions.return_(null, enumerable));
  return implementor.result(physType, list.toBlock());
}
 

import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor; //导入依赖的package包/类
private void generateGet(EnumerableRelImplementor implementor,
                         PhysType physType, BlockBuilder builder, ParameterExpression resultSet,
                         int i, Expression target, Expression calendar,
                         CalendarPolicy calendarPolicy) {
    final Primitive primitive = Primitive.ofBoxOr(physType.fieldClass(i));
    final RelDataType fieldType =
            physType.getRowType().getFieldList().get(i).getType();
    final List<Expression> dateTimeArgs = new ArrayList<Expression>();
    dateTimeArgs.add(Expressions.constant(i + 1));
    SqlTypeName sqlTypeName = fieldType.getSqlTypeName();
    boolean offset = false;
    switch (calendarPolicy) {
    case LOCAL:
        dateTimeArgs.add(calendar);
        break;
    case NULL:
        // We don't specify a calendar at all, so we don't add an argument and
        // instead use the version of the getXXX that doesn't take a Calendar
        break;
    case DIRECT:
        sqlTypeName = SqlTypeName.ANY;
        break;
    case SHIFT:
        switch (sqlTypeName) {
        case TIMESTAMP:
        case DATE:
            offset = true;
            break;
        default:
        }
        break;
    default:
    }
    final Expression source;
    switch (sqlTypeName) {
    case DATE:
    case TIME:
    case TIMESTAMP:
        source = Expressions.call(
                getMethod(sqlTypeName, fieldType.isNullable(), offset),
                Expressions.<Expression>list()
                        .append(
                                Expressions.call(resultSet,
                                        getMethod2(sqlTypeName), dateTimeArgs))
                        .appendIf(offset, getTimeZoneExpression(implementor)));
        break;
    case ARRAY:
        final Expression x = Expressions.convert_(
                Expressions.call(resultSet, jdbcGetMethod(primitive),
                        Expressions.constant(i + 1)),
                java.sql.Array.class);
        source = Expressions.call(BuiltInMethod.JDBC_ARRAY_TO_LIST.method, x);
        break;
    default:
        source = Expressions.call(
                resultSet, jdbcGetMethod(primitive), Expressions.constant(i + 1));
    }
    builder.add(
            Expressions.statement(
                    Expressions.assign(
                            target, source)));

    // [CALCITE-596] If primitive type columns contain null value, returns null
    // object
    if (primitive != null) {
        builder.add(
                Expressions.ifThen(
                        Expressions.call(resultSet, "wasNull"),
                        Expressions.statement(
                                Expressions.assign(target,
                                        Expressions.constant(null)))));
    }
}
 

import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor; //导入依赖的package包/类
public JavaImplementor(EnumerableRelImplementor enumImplementor) {
    super(enumImplementor.getRexBuilder(), new LinkedHashMap<String, Object>());
}