import org.apache.calcite.plan.hep.HepMatchOrder; //导入依赖的package包/类
@Test public void testSubprogram() throws Exception {
  // Verify that subprogram gets re-executed until fixpoint.
  // In this case, the first time through we limit it to generate
  // only one calc; the second time through it will generate
  // a second calc, and then merge them.
  HepProgramBuilder subprogramBuilder = HepProgram.builder();
  subprogramBuilder.addMatchOrder(HepMatchOrder.TOP_DOWN);
  subprogramBuilder.addMatchLimit(1);
  subprogramBuilder.addRuleInstance(ProjectToCalcRule.INSTANCE);
  subprogramBuilder.addRuleInstance(CalcMergeRule.INSTANCE);

  HepProgramBuilder programBuilder = HepProgram.builder();
  programBuilder.addSubprogram(subprogramBuilder.build());

  checkPlanning(
      programBuilder.build(),
      "select upper(ename) from (select lower(ename) as ename from emp)");
}
 

import org.apache.calcite.plan.hep.HepMatchOrder; //导入依赖的package包/类
@Test public void testGC() throws Exception {
  HepProgramBuilder programBuilder = HepProgram.builder();
  programBuilder.addMatchOrder(HepMatchOrder.TOP_DOWN);
  programBuilder.addRuleInstance(CalcMergeRule.INSTANCE);
  programBuilder.addRuleInstance(ProjectToCalcRule.INSTANCE);
  programBuilder.addRuleInstance(FilterToCalcRule.INSTANCE);

  HepPlanner planner = new HepPlanner(programBuilder.build());
  planner.setRoot(
      tester.convertSqlToRel("select upper(name) from dept where deptno=20").rel);
  planner.findBestExp();
  // Reuse of HepPlanner (should trigger GC).
  planner.setRoot(
      tester.convertSqlToRel("select upper(name) from dept where deptno=20").rel);
  planner.findBestExp();
}
 

import org.apache.calcite.plan.hep.HepMatchOrder; //导入依赖的package包/类
/**
 * Appy Join Order Optimizations using Hep Planner.
 */
private RelNode getLoptJoinOrderTree(RelNode root,
                                    Class<? extends Join> joinClass,
                                           RelFactories.JoinFactory joinFactory,
                                           RelFactories.FilterFactory filterFactory,
                                           RelFactories.ProjectFactory projectFactory) {
  final HepProgramBuilder hepPgmBldr = new HepProgramBuilder()
      .addMatchOrder(HepMatchOrder.BOTTOM_UP)
      .addRuleInstance(new JoinToMultiJoinRule(joinClass))
      .addRuleInstance(new LoptOptimizeJoinRule(joinFactory, projectFactory, filterFactory))
      .addRuleInstance(ProjectRemoveRule.INSTANCE);
      // .addRuleInstance(new ProjectMergeRule(true, projectFactory));

      // .addRuleInstance(DrillMergeProjectRule.getInstance(true, projectFactory, this.context.getFunctionRegistry()));


  final HepProgram hepPgm = hepPgmBldr.build();
  final HepPlanner hepPlanner = new HepPlanner(hepPgm);

  final List<RelMetadataProvider> list = Lists.newArrayList();
  list.add(DrillDefaultRelMetadataProvider.INSTANCE);
  hepPlanner.registerMetadataProviders(list);
  final RelMetadataProvider cachingMetaDataProvider = new CachingRelMetadataProvider(ChainedRelMetadataProvider.of(list), hepPlanner);

  // Modify RelMetaProvider for every RelNode in the SQL operator Rel tree.
  root.accept(new MetaDataProviderModifier(cachingMetaDataProvider));

  hepPlanner.setRoot(root);

  RelNode calciteOptimizedPlan = hepPlanner.findBestExp();

  return calciteOptimizedPlan;
}
 

import org.apache.calcite.plan.hep.HepMatchOrder; //导入依赖的package包/类
@Test public void testMatchLimitOneTopDown() throws Exception {
  // Verify that only the top union gets rewritten.

  HepProgramBuilder programBuilder = HepProgram.builder();
  programBuilder.addMatchOrder(HepMatchOrder.TOP_DOWN);
  programBuilder.addMatchLimit(1);
  programBuilder.addRuleInstance(UnionToDistinctRule.INSTANCE);

  checkPlanning(
      programBuilder.build(), UNION_TREE);
}
 

import org.apache.calcite.plan.hep.HepMatchOrder; //导入依赖的package包/类
@Test public void testMatchLimitOneBottomUp() throws Exception {
  // Verify that only the bottom union gets rewritten.

  HepProgramBuilder programBuilder = HepProgram.builder();
  programBuilder.addMatchLimit(1);
  programBuilder.addMatchOrder(HepMatchOrder.BOTTOM_UP);
  programBuilder.addRuleInstance(UnionToDistinctRule.INSTANCE);

  checkPlanning(
      programBuilder.build(), UNION_TREE);
}
 

import org.apache.calcite.plan.hep.HepMatchOrder; //导入依赖的package包/类
@Test public void testRuleApplyCount() {
  final long applyTimes1 = checkRuleApplyCount(HepMatchOrder.ARBITRARY);
  assertThat(applyTimes1, is(5451L));

  final long applyTimes2 = checkRuleApplyCount(HepMatchOrder.DEPTH_FIRST);
  assertThat(applyTimes2, is(403L));

  // DEPTH_FIRST has 10x fewer matches than ARBITRARY
  assertThat(applyTimes1 > applyTimes2 * 10, is(true));
}
 

import org.apache.calcite.plan.hep.HepMatchOrder; //导入依赖的package包/类
private long checkRuleApplyCount(HepMatchOrder matchOrder) {
  final HepProgramBuilder programBuilder = HepProgram.builder();
  programBuilder.addMatchOrder(matchOrder);
  programBuilder.addRuleInstance(ReduceExpressionsRule.FILTER_INSTANCE);
  programBuilder.addRuleInstance(ReduceExpressionsRule.PROJECT_INSTANCE);

  final HepTestListener listener = new HepTestListener(0);
  HepPlanner planner = new HepPlanner(programBuilder.build());
  planner.addListener(listener);
  planner.setRoot(tester.convertSqlToRel(COMPLEX_UNION_TREE).rel);
  planner.findBestExp();
  return listener.getApplyTimes();
}
 

import org.apache.calcite.plan.hep.HepMatchOrder; //导入依赖的package包/类
@Test public void testConvertMultiJoinRule() throws Exception {
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(FilterJoinRule.FILTER_ON_JOIN)
      .addMatchOrder(HepMatchOrder.BOTTOM_UP)
      .addRuleInstance(JoinToMultiJoinRule.INSTANCE)
      .build();
  checkPlanning(program,
      "select e1.ename from emp e1, dept d, emp e2 "
          + "where e1.deptno = d.deptno and d.deptno = e2.deptno");
}
 

import org.apache.calcite.plan.hep.HepMatchOrder; //导入依赖的package包/类
private void checkPlanning(String query) throws Exception {
  final Tester tester1 = tester.withCatalogReaderFactory(
      new Function<RelDataTypeFactory, Prepare.CatalogReader>() {
        public Prepare.CatalogReader apply(RelDataTypeFactory typeFactory) {
          return new MockCatalogReader(typeFactory, true) {
            @Override public MockCatalogReader init() {
              // CREATE SCHEMA abc;
              // CREATE TABLE a(a INT);
              // ...
              // CREATE TABLE j(j INT);
              MockSchema schema = new MockSchema("SALES");
              registerSchema(schema);
              final RelDataType intType =
                  typeFactory.createSqlType(SqlTypeName.INTEGER);
              for (int i = 0; i < 10; i++) {
                String t = String.valueOf((char) ('A' + i));
                MockTable table = MockTable.create(this, schema, t, false, 100);
                table.addColumn(t, intType);
                registerTable(table);
              }
              return this;
            }
            // CHECKSTYLE: IGNORE 1
          }.init();
        }
      });
  HepProgram program = new HepProgramBuilder()
      .addMatchOrder(HepMatchOrder.BOTTOM_UP)
      .addRuleInstance(ProjectRemoveRule.INSTANCE)
      .addRuleInstance(JoinToMultiJoinRule.INSTANCE)
      .build();
  checkPlanning(tester1, null,
      new HepPlanner(program), query);
}
 

import org.apache.calcite.plan.hep.HepMatchOrder; //导入依赖的package包/类
/** Creates a program that invokes heuristic join-order optimization
 * (via {@link org.apache.calcite.rel.rules.JoinToMultiJoinRule},
 * {@link org.apache.calcite.rel.rules.MultiJoin} and
 * {@link org.apache.calcite.rel.rules.LoptOptimizeJoinRule})
 * if there are 6 or more joins (7 or more relations). */
public static Program heuristicJoinOrder(
    final Iterable<? extends RelOptRule> rules,
    final boolean bushy, final int minJoinCount) {
  return new Program() {
    public RelNode run(RelOptPlanner planner, RelNode rel,
                       RelTraitSet requiredOutputTraits,
                       List<RelOptMaterialization> materializations,
                       List<RelOptLattice> lattices) {
      final int joinCount = RelOptUtil.countJoins(rel);
      final Program program;
      if (joinCount < minJoinCount) {
        program = ofRules(rules);
      } else {
        // Create a program that gathers together joins as a MultiJoin.
        final HepProgram hep = new HepProgramBuilder()
            .addRuleInstance(FilterJoinRule.FILTER_ON_JOIN)
            .addMatchOrder(HepMatchOrder.BOTTOM_UP)
            .addRuleInstance(JoinToMultiJoinRule.INSTANCE)
            .build();
        final Program program1 =
            of(hep, false, DefaultRelMetadataProvider.INSTANCE);

        // Create a program that contains a rule to expand a MultiJoin
        // into heuristically ordered joins.
        // We use the rule set passed in, but remove JoinCommuteRule and
        // JoinPushThroughJoinRule, because they cause exhaustive search.
        final List<RelOptRule> list = Lists.newArrayList(rules);
        list.removeAll(
            ImmutableList.of(JoinCommuteRule.INSTANCE,
                JoinAssociateRule.INSTANCE,
                JoinPushThroughJoinRule.LEFT,
                JoinPushThroughJoinRule.RIGHT));
        list.add(bushy
            ? MultiJoinOptimizeBushyRule.INSTANCE
            : LoptOptimizeJoinRule.INSTANCE);
        final Program program2 = ofRules(list);

        program = sequence(program1, program2);
      }
      return program.run(
          planner, rel, requiredOutputTraits, materializations, lattices);
    }
  };
}
 

import org.apache.calcite.plan.hep.HepMatchOrder; //导入依赖的package包/类
/** Creates a program that invokes heuristic join-order optimization
 * (via {@link org.apache.calcite.rel.rules.JoinToMultiJoinRule},
 * {@link org.apache.calcite.rel.rules.MultiJoin} and
 * {@link org.apache.calcite.rel.rules.LoptOptimizeJoinRule})
 * if there are 6 or more joins (7 or more relations). */
public static Program heuristicJoinOrder(
    final Iterable<? extends RelOptRule> rules,
    final boolean bushy, final int minJoinCount) {
  return new Program() {
    public RelNode run(RelOptPlanner planner, RelNode rel,
        RelTraitSet requiredOutputTraits,
        List<RelOptMaterialization> materializations,
        List<RelOptLattice> lattices) {
      final int joinCount = RelOptUtil.countJoins(rel);
      final Program program;
      if (joinCount < minJoinCount) {
        program = ofRules(rules);
      } else {
        // Create a program that gathers together joins as a MultiJoin.
        final HepProgram hep = new HepProgramBuilder()
            .addRuleInstance(FilterJoinRule.FILTER_ON_JOIN)
            .addMatchOrder(HepMatchOrder.BOTTOM_UP)
            .addRuleInstance(JoinToMultiJoinRule.INSTANCE)
            .build();
        final Program program1 =
            of(hep, false, DefaultRelMetadataProvider.INSTANCE);

        // Create a program that contains a rule to expand a MultiJoin
        // into heuristically ordered joins.
        // We use the rule set passed in, but remove JoinCommuteRule and
        // JoinPushThroughJoinRule, because they cause exhaustive search.
        final List<RelOptRule> list = Lists.newArrayList(rules);
        list.removeAll(
            ImmutableList.of(JoinCommuteRule.INSTANCE,
                JoinAssociateRule.INSTANCE,
                JoinPushThroughJoinRule.LEFT,
                JoinPushThroughJoinRule.RIGHT));
        list.add(bushy
            ? MultiJoinOptimizeBushyRule.INSTANCE
            : LoptOptimizeJoinRule.INSTANCE);
        final Program program2 = ofRules(list);

        program = sequence(program1, program2);
      }
      return program.run(
          planner, rel, requiredOutputTraits, materializations, lattices);
    }
  };
}
 

import org.apache.calcite.plan.hep.HepMatchOrder; //导入依赖的package包/类
private void transitiveInference(RelOptRule... extraRules) throws Exception {
  final DiffRepository diffRepos = getDiffRepos();
  final String sql = diffRepos.expand(null, "${sql}");

  final HepProgram program = new HepProgramBuilder()
      .addRuleInstance(FilterJoinRule.DUMB_FILTER_ON_JOIN)
      .addRuleInstance(FilterJoinRule.JOIN)
      .addRuleInstance(FilterProjectTransposeRule.INSTANCE)
      .addRuleInstance(FilterSetOpTransposeRule.INSTANCE)
      .build();
  final HepPlanner planner = new HepPlanner(program);

  final RelRoot root = tester.convertSqlToRel(sql);
  final RelNode relInitial = root.rel;

  assertTrue(relInitial != null);

  List<RelMetadataProvider> list = Lists.newArrayList();
  list.add(DefaultRelMetadataProvider.INSTANCE);
  planner.registerMetadataProviders(list);
  RelMetadataProvider plannerChain = ChainedRelMetadataProvider.of(list);
  relInitial.getCluster().setMetadataProvider(
      new CachingRelMetadataProvider(plannerChain, planner));

  planner.setRoot(relInitial);
  RelNode relBefore = planner.findBestExp();

  String planBefore = NL + RelOptUtil.toString(relBefore);
  diffRepos.assertEquals("planBefore", "${planBefore}", planBefore);

  HepProgram program2 = new HepProgramBuilder()
      .addMatchOrder(HepMatchOrder.BOTTOM_UP)
      .addRuleInstance(FilterJoinRule.DUMB_FILTER_ON_JOIN)
      .addRuleInstance(FilterJoinRule.JOIN)
      .addRuleInstance(FilterProjectTransposeRule.INSTANCE)
      .addRuleInstance(FilterSetOpTransposeRule.INSTANCE)
      .addRuleInstance(JoinPushTransitivePredicatesRule.INSTANCE)
      .addRuleCollection(Arrays.asList(extraRules))
      .build();
  final HepPlanner planner2 = new HepPlanner(program2);
  planner.registerMetadataProviders(list);
  planner2.setRoot(relBefore);
  RelNode relAfter = planner2.findBestExp();

  String planAfter = NL + RelOptUtil.toString(relAfter);
  diffRepos.assertEquals("planAfter", "${planAfter}", planAfter);
}