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包/类
private RelNode copyOf(LogicalTableScan rel) {
  return new LogicalTableScan(
    cluster,
    copyOf(rel.getTraitSet()),
    rel.getTable()
  );
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入依赖的package包/类
@Override
public RelNode visit(TableScan scan) {
  if (scan instanceof CopyToCluster) {
    return ((CopyToCluster) scan).copyWith(this);
  } else if (scan instanceof LogicalTableScan) {
    return copyOf((LogicalTableScan) scan);
  }
  notSupported(scan);
  return super.visit(scan);
}
 

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 void onMatch(RelOptRuleCall call) {
  final LogicalTableScan oldRel = call.rel(0);
  RelNode newRel =
      oldRel.getTable().toRel(
          RelOptUtil.getContext(oldRel.getCluster()));
  call.transformTo(newRel);
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入依赖的package包/类
@Override public RelNode convert(RelNode rel) {
  LogicalTableScan scan = (LogicalTableScan) rel;
  final RelOptTable relOptTable = scan.getTable();
  final Table table = relOptTable.unwrap(Table.class);
  if (!EnumerableTableScan.canHandle(table)) {
    return null;
  }
  final Expression expression = relOptTable.getExpression(Object.class);
  if (expression == null) {
    return null;
  }
  return EnumerableTableScan.create(scan.getCluster(), relOptTable);
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入依赖的package包/类
@Override public void onMatch(RelOptRuleCall call) {
  final LogicalTableScan scan = call.rel(0);
  final RelOptTable table = scan.getTable();
  if (BindableTableScan.canHandle(table)) {
    call.transformTo(
        BindableTableScan.create(scan.getCluster(), table));
  }
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入依赖的package包/类
@Test public void testAggregateExtractProjectRule() {
  final String sql = "select sum(sal)\n"
      + "from emp";
  HepProgram pre = new HepProgramBuilder()
      .addRuleInstance(AggregateProjectMergeRule.INSTANCE)
      .build();
  final AggregateExtractProjectRule rule =
      new AggregateExtractProjectRule(Aggregate.class, LogicalTableScan.class,
          RelFactories.LOGICAL_BUILDER);
  sql(sql).withPre(pre).withRule(rule).check();
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入依赖的package包/类
@Test public void testAggregateExtractProjectRuleWithGroupingSets() {
  final String sql = "select empno, deptno, sum(sal)\n"
      + "from emp\n"
      + "group by grouping sets ((empno, deptno),(deptno),(empno))";
  HepProgram pre = new HepProgramBuilder()
      .addRuleInstance(AggregateProjectMergeRule.INSTANCE)
      .build();
  final AggregateExtractProjectRule rule =
      new AggregateExtractProjectRule(Aggregate.class, LogicalTableScan.class,
          RelFactories.LOGICAL_BUILDER);
  sql(sql).withPre(pre).withRule(rule).check();
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入依赖的package包/类
/** Test with column used in both grouping set and argument to aggregate
 * function. */
@Test public void testAggregateExtractProjectRuleWithGroupingSets2() {
  final String sql = "select empno, deptno, sum(empno)\n"
      + "from emp\n"
      + "group by grouping sets ((empno, deptno),(deptno),(empno))";
  HepProgram pre = new HepProgramBuilder()
      .addRuleInstance(AggregateProjectMergeRule.INSTANCE)
      .build();
  final AggregateExtractProjectRule rule =
      new AggregateExtractProjectRule(Aggregate.class, LogicalTableScan.class,
          RelFactories.LOGICAL_BUILDER);
  sql(sql).withPre(pre).withRule(rule).check();
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入依赖的package包/类
/**
 * Unit test for {@link org.apache.calcite.rel.externalize.RelJsonWriter} on
 * a simple tree of relational expressions, consisting of a table, a filter
 * and an aggregate node.
 */
@Test public void testWriter() {
  String s =
      Frameworks.withPlanner(
          new Frameworks.PlannerAction<String>() {
            public String apply(RelOptCluster cluster,
                RelOptSchema relOptSchema, SchemaPlus rootSchema) {
              rootSchema.add("hr",
                  new ReflectiveSchema(new JdbcTest.HrSchema()));
              LogicalTableScan scan =
                  LogicalTableScan.create(cluster,
                      relOptSchema.getTableForMember(
                          Arrays.asList("hr", "emps")));
              final RexBuilder rexBuilder = cluster.getRexBuilder();
              LogicalFilter filter =
                  LogicalFilter.create(scan,
                      rexBuilder.makeCall(
                          SqlStdOperatorTable.EQUALS,
                          rexBuilder.makeFieldAccess(
                              rexBuilder.makeRangeReference(scan),
                              "deptno", true),
                          rexBuilder.makeExactLiteral(BigDecimal.TEN)));
              final RelJsonWriter writer = new RelJsonWriter();
              final RelDataType bigIntType =
                  cluster.getTypeFactory().createSqlType(SqlTypeName.BIGINT);
              LogicalAggregate aggregate =
                  LogicalAggregate.create(filter, ImmutableBitSet.of(0), null,
                      ImmutableList.of(
                          AggregateCall.create(SqlStdOperatorTable.COUNT,
                              true, false, ImmutableList.of(1), -1,
                              bigIntType, "c"),
                          AggregateCall.create(SqlStdOperatorTable.COUNT,
                              false, false, ImmutableList.<Integer>of(), -1,
                              bigIntType, "d")));
              aggregate.explain(writer);
              return writer.asString();
            }
          });
  assertThat(s, is(XX));
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入依赖的package包/类
private BeamIOSourceRule() {
  super(LogicalTableScan.class, Convention.NONE, BeamLogicalConvention.INSTANCE,
      "BeamIOSourceRule");
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入依赖的package包/类
private PigTableScanRule() {
  super(LogicalTableScan.class, Convention.NONE, PigRel.CONVENTION, "PigTableScanRule");
}
 

import org.apache.calcite.rel.logical.LogicalTableScan; //导入依赖的package包/类
public RelNode convert(RelNode rel) {
  final LogicalTableScan scan = (LogicalTableScan) rel;
  final RelTraitSet traitSet = scan.getTraitSet().replace(PigRel.CONVENTION);
  return new PigTableScan(rel.getCluster(), traitSet, scan.getTable());
}
 

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包/类
/**
 * Creates an EnumerableTableScanRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public EnumerableTableScanRule(RelBuilderFactory relBuilderFactory) {
  super(LogicalTableScan.class, Predicates.<RelNode>alwaysTrue(),
      Convention.NONE, EnumerableConvention.INSTANCE, relBuilderFactory,
      "EnumerableTableScanRule");
}