Java LogicalTableScan.create方法代码示例

import org.apache.calcite.rel.logical.LogicalTableScan; //导入方法依赖的package包/类
@Override
public void onMatch(RelOptRuleCall call) {
    InstanceByClassTableScan scan = call.rel(0);
    RelOptTable table = scan.getTable();
    RelOptSchema schema = table.getRelOptSchema();
    List<String> indexName = new ArrayList<String>(table.getQualifiedName());
    indexName.set(indexName.size() - 1, "$ids$:" + indexName.get(indexName.size() - 1));
    LogicalTableScan ids = LogicalTableScan.create(scan.getCluster(), schema.getTableForMember(indexName));

    InstanceByClassTable instanceByClassTable = table.unwrap(InstanceByClassTable.class);
    int snapshotId = SnapshotHolder.put(instanceByClassTable.snapshot);

    RelOptCluster cluster = scan.getCluster();
    RexInputRef objectId = cluster.getRexBuilder().makeInputRef(ids, 0);
    RexBuilderContext rexContext = new ExecutionRexBuilderContext(cluster, snapshotId, objectId);

    List<Function<RexBuilderContext, RexNode>> resolvers = instanceByClassTable.getResolvers();
    List<RexNode> exprs = new ArrayList<RexNode>(resolvers.size());
    for (Function<RexBuilderContext, RexNode> resolver : resolvers) {
        exprs.add(resolver.apply(rexContext));
    }
    call.transformTo(RelOptUtil.createProject(ids, exprs, table.getRowType().getFieldNames(), true));
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入方法依赖的package包/类
@Override public void onMatch(RelOptRuleCall call) {
  final Delta delta = call.rel(0);
  final TableScan scan = call.rel(1);
  final RelOptCluster cluster = delta.getCluster();
  final RelOptTable relOptTable = scan.getTable();
  final StreamableTable streamableTable =
      relOptTable.unwrap(StreamableTable.class);
  if (streamableTable != null) {
    final Table table1 = streamableTable.stream();
    final RelOptTable relOptTable2 =
        RelOptTableImpl.create(relOptTable.getRelOptSchema(),
            relOptTable.getRowType(), table1,
            ImmutableList.<String>builder()
                .addAll(relOptTable.getQualifiedName())
                .add("(STREAM)").build());
    final LogicalTableScan newScan =
        LogicalTableScan.create(cluster, relOptTable2);
    call.transformTo(newScan);
  }
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入方法依赖的package包/类
RelNode toRel(Queryable<T> queryable) {
  if (queryable instanceof QueryableDefaults.Replayable) {
    //noinspection unchecked
    ((QueryableDefaults.Replayable) queryable).replay(this);
    return rel;
  }
  if (queryable instanceof AbstractTableQueryable) {
    final AbstractTableQueryable tableQueryable =
        (AbstractTableQueryable) queryable;
    final QueryableTable table = tableQueryable.table;
    final CalciteSchema.TableEntry tableEntry =
        CalciteSchema.from(tableQueryable.schema)
            .add(tableQueryable.tableName, tableQueryable.table);
    final RelOptTableImpl relOptTable =
        RelOptTableImpl.create(null, table.getRowType(translator.typeFactory),
            tableEntry, null);
    if (table instanceof TranslatableTable) {
      return ((TranslatableTable) table).toRel(translator, relOptTable);
    } else {
      return LogicalTableScan.create(translator.cluster, relOptTable);
    }
  }
  return translator.translate(queryable.getExpression());
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入方法依赖的package包/类
@Override public RelNode toRel(ToRelContext context) {
  RelNode rel = LogicalTableScan.create(context.getCluster(), fromTable);
  final RexBuilder rexBuilder = context.getCluster().getRexBuilder();
  rel = LogicalFilter.create(
      rel, getConstraint(rexBuilder, rel.getRowType()));
  final List<RelDataTypeField> fieldList =
      rel.getRowType().getFieldList();
  final List<Pair<RexNode, String>> projects =
      new AbstractList<Pair<RexNode, String>>() {
        @Override public Pair<RexNode, String> get(int index) {
          return RexInputRef.of2(mapping.get(index), fieldList);
        }

        @Override public int size() {
          return mapping.size();
        }
      };
  return LogicalProject.create(rel, Pair.left(projects),
      Pair.right(projects));
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入方法依赖的package包/类
public RelNode toRel(RelOptTable.ToRelContext context,
    RelOptTable relOptTable) {
  final RelOptCluster cluster = context.getCluster();
  final TableScan scan = LogicalTableScan.create(cluster, relOptTable);
  return DruidQuery.create(cluster,
      cluster.traitSetOf(BindableConvention.INSTANCE), relOptTable, this,
      ImmutableList.<RelNode>of(scan));
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入方法依赖的package包/类
public RelNode createScan(RelOptCluster cluster, RelOptTable table) {
  return LogicalTableScan.create(cluster, table);
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入方法依赖的package包/类
public RelNode translate(Expression expression) {
  if (expression instanceof MethodCallExpression) {
    final MethodCallExpression call = (MethodCallExpression) expression;
    BuiltInMethod method = BuiltInMethod.MAP.get(call.method);
    if (method == null) {
      throw new UnsupportedOperationException(
          "unknown method " + call.method);
    }
    RelNode input;
    switch (method) {
    case SELECT:
      input = translate(call.targetExpression);
      return LogicalProject.create(input,
          toRex(input, (FunctionExpression) call.expressions.get(0)),
          (List<String>) null);

    case WHERE:
      input = translate(call.targetExpression);
      return LogicalFilter.create(input,
          toRex((FunctionExpression) call.expressions.get(0), input));

    case AS_QUERYABLE:
      return LogicalTableScan.create(cluster,
          RelOptTableImpl.create(null,
              typeFactory.createJavaType(
                  Types.toClass(
                      Types.getElementType(call.targetExpression.getType()))),
              ImmutableList.<String>of(),
              call.targetExpression));

    case SCHEMA_GET_TABLE:
      return LogicalTableScan.create(cluster,
          RelOptTableImpl.create(null,
              typeFactory.createJavaType((Class)
                  ((ConstantExpression) call.expressions.get(1)).value),
              ImmutableList.<String>of(),
              call.targetExpression));

    default:
      throw new UnsupportedOperationException(
          "unknown method " + call.method);
    }
  }
  throw new UnsupportedOperationException(
      "unknown expression type " + expression.getNodeType());
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入方法依赖的package包/类
public RelNode toRel(ToRelContext context) {
  return LogicalTableScan.create(context.getCluster(), this);
}