import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
/**
 * Normalizes the given query and target {@link RelNode}s and finds substitutions on canonical
 * representations.
 *
 * @param query  incoming query
 * @param materialization  materialization to apply
 * @return  list of substitutions
 */
protected List<Substitution> substitute(RelNode query,
                                                 final RelOptMaterialization materialization) {
  // First, if the materialization is in terms of a star table, rewrite
  // the query in terms of the star table.
  if (materialization.starTable != null) {
    final RelNode newRoot = RelOptMaterialization.tryUseStar(query,
      materialization.starRelOptTable);
    if (newRoot != null) {
      query = newRoot;
    }
  }

  // Push filters to the bottom, and combine projects on top.
  final HepProgram program = getProgramBuilder().build();
  final HepPlanner hepPlanner = new HepPlanner(program);

  hepPlanner.setRoot(materialization.queryRel);
  final RelNode canonicalTarget = hepPlanner.findBestExp();

  hepPlanner.setRoot(query);
  final RelNode canonicalQuery = hepPlanner.findBestExp();

  return substitute(canonicalQuery, canonicalTarget, materialization.tableRel);
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
private RelNode decorrelate(RelNode root) {
	// first adjust count() expression if any
	HepProgram program = HepProgram.builder().addRuleInstance(new AdjustProjectForCountAggregateRule(false)).addRuleInstance(new AdjustProjectForCountAggregateRule(true)).addRuleInstance(FilterJoinRule.FILTER_ON_JOIN).addRuleInstance(FilterProjectTransposeRule.INSTANCE).addRuleInstance(FilterCorrelateRule.INSTANCE).build();

	HepPlanner planner = createPlanner(program);

	planner.setRoot(root);
	root = planner.findBestExp();

	// Perform decorrelation.
	map.clear();

	final Frame frame = getInvoke(root, null);
	if (frame != null) {
		// has been rewritten; apply rules post-decorrelation
		final HepProgram program2 = HepProgram.builder().addRuleInstance(FilterJoinRule.FILTER_ON_JOIN).addRuleInstance(FilterJoinRule.JOIN).build();

		final HepPlanner planner2 = createPlanner(program2);
		final RelNode newRoot = frame.r;
		planner2.setRoot(newRoot);
		return planner2.findBestExp();
	}

	return root;
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
public static String getParsedSql(RelNode relNode, SqlDialect dialect) throws SQLException {
  if (dialect.getDatabaseProduct() == SqlDialect.DatabaseProduct.HIVE) {
    final HepProgram program = new HepProgramBuilder()
        .addRuleInstance(JoinCalcTransposeRule.LEFT_CALC)
        .addRuleInstance(JoinCalcTransposeRule.RIGHT_CALC)
        .addRuleInstance(CalcMergeRule.INSTANCE)
        .build();
    final RelOptPlanner planner = relNode.getCluster().getPlanner();
    final HepPlanner hepPlanner =
        new HepPlanner(program, planner.getContext());
    hepPlanner.setRoot(relNode);
    relNode = hepPlanner.findBestExp();
  }
  RelToSqlConverter relToSqlConverter = new RelToSqlConverter(dialect);
  RelToSqlConverter.Result res = relToSqlConverter.visitChild(0, relNode);
  SqlNode sqlNode = res.asQuery();
  String result = sqlNode.toSqlString(dialect, false).getSql();
  return result.replace("\n", " ");
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
/** Creates a program that executes a {@link HepProgram}. */
public static Program of(final HepProgram hepProgram, final boolean noDag,
                         final RelMetadataProvider metadataProvider) {
  return new Program() {
    public RelNode run(RelOptPlanner planner, RelNode rel,
                       RelTraitSet requiredOutputTraits,
                       List<RelOptMaterialization> materializations,
                       List<RelOptLattice> lattices) {
      final HepPlanner hepPlanner = new HepPlanner(hepProgram,
          null, noDag, null, RelOptCostImpl.FACTORY);

      List<RelMetadataProvider> list = Lists.newArrayList();
      if (metadataProvider != null) {
        list.add(metadataProvider);
      }
      hepPlanner.registerMetadataProviders(list);
      RelMetadataProvider plannerChain =
          ChainedRelMetadataProvider.of(list);
      rel.getCluster().setMetadataProvider(plannerChain);

      hepPlanner.setRoot(rel);
      return hepPlanner.findBestExp();
    }
  };
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
/** Creates a program that executes a {@link HepProgram}. */
public static Program of(final HepProgram hepProgram, final boolean noDag,
    final RelMetadataProvider metadataProvider) {
  return new Program() {
    public RelNode run(RelOptPlanner planner, RelNode rel,
        RelTraitSet requiredOutputTraits,
        List<RelOptMaterialization> materializations,
        List<RelOptLattice> lattices) {
      final HepPlanner hepPlanner = new HepPlanner(hepProgram,
          null, noDag, null, RelOptCostImpl.FACTORY);

      List<RelMetadataProvider> list = Lists.newArrayList();
      if (metadataProvider != null) {
        list.add(metadataProvider);
      }
      hepPlanner.registerMetadataProviders(list);
      RelMetadataProvider plannerChain =
          ChainedRelMetadataProvider.of(list);
      rel.getCluster().setMetadataProvider(plannerChain);

      hepPlanner.setRoot(rel);
      return hepPlanner.findBestExp();
    }
  };
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
/** Test case for
 * <a href="https://issues.apache.org/jira/browse/CALCITE-1586">[CALCITE-1586]
 * JDBC adapter generates wrong SQL if UNION has more than two inputs</a>. */
@Test public void testThreeQueryUnion() {
  String query = "SELECT \"product_id\" FROM \"product\" "
      + " UNION ALL "
      + "SELECT \"product_id\" FROM \"sales_fact_1997\" "
      + " UNION ALL "
      + "SELECT \"product_class_id\" AS product_id FROM \"product_class\"";
  String expected = "SELECT \"product_id\"\n"
      + "FROM \"foodmart\".\"product\"\n"
      + "UNION ALL\n"
      + "SELECT \"product_id\"\n"
      + "FROM \"foodmart\".\"sales_fact_1997\"\n"
      + "UNION ALL\n"
      + "SELECT \"product_class_id\" AS \"PRODUCT_ID\"\n"
      + "FROM \"foodmart\".\"product_class\"";

  final HepProgram program =
      new HepProgramBuilder().addRuleClass(UnionMergeRule.class).build();
  final RuleSet rules = RuleSets.ofList(UnionMergeRule.INSTANCE);
  sql(query)
      .optimize(rules, new HepPlanner(program))
      .ok(expected);
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
/** Tests that if two relational expressions are equivalent, the planner
 * notices, and only applies the rule once. */
@Test public void testCommonSubExpression() {
  // In the following,
  //   (select 1 from dept where abs(-1)=20)
  // occurs twice, but it's a common sub-expression, so the rule should only
  // apply once.
  HepProgramBuilder programBuilder = HepProgram.builder();
  programBuilder.addRuleInstance(FilterToCalcRule.INSTANCE);

  final HepTestListener listener = new HepTestListener(0);
  HepPlanner planner = new HepPlanner(programBuilder.build());
  planner.addListener(listener);

  final String sql = "(select 1 from dept where abs(-1)=20)\n"
      + "union all\n"
      + "(select 1 from dept where abs(-1)=20)";
  planner.setRoot(tester.convertSqlToRel(sql).rel);
  RelNode bestRel = planner.findBestExp();

  assertThat(bestRel.getInput(0).equals(bestRel.getInput(1)), is(true));
  assertThat(listener.getApplyTimes() == 1, is(true));
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的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.HepProgram; //导入依赖的package包/类
@Test public void testPullFilterThroughAggregateGroupingSets()
    throws Exception {
  HepProgram preProgram = HepProgram.builder()
      .addRuleInstance(ProjectMergeRule.INSTANCE)
      .addRuleInstance(ProjectFilterTransposeRule.INSTANCE)
      .build();
  HepProgram program = HepProgram.builder()
      .addRuleInstance(AggregateFilterTransposeRule.INSTANCE)
      .build();
  final String sql = "select ename, sal, deptno from ("
      + "  select ename, sal, deptno"
      + "  from emp"
      + "  where sal > 5000)"
      + "group by rollup(ename, sal, deptno)";
  checkPlanning(tester, preProgram, new HepPlanner(program), sql);
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
/** Test case for
 * <a href="https://issues.apache.org/jira/browse/CALCITE-1507">[CALCITE-1507]
 * OFFSET cannot be pushed through a JOIN if the non-preserved side of outer
 * join is not count-preserving</a>. */
@Test public void testSortJoinTranspose6() {
  final HepProgram preProgram = new HepProgramBuilder()
      .addRuleInstance(SortProjectTransposeRule.INSTANCE)
      .build();
  final HepProgram program = new HepProgramBuilder()
      .addRuleInstance(SortJoinTransposeRule.INSTANCE)
      .build();
  // This one can be pushed down even if it has an OFFSET, since the dept
  // table is count-preserving against the join condition.
  final String sql = "select d.deptno, empno from sales.dept d\n"
      + "right join sales.emp e using (deptno) limit 10 offset 2";
  sql(sql)
      .withPre(preProgram)
      .with(program)
      .check();
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
@Test public void testReduceNestedCaseWhen() {
  HepProgram preProgram = new HepProgramBuilder()
      .build();

  HepProgramBuilder builder = new HepProgramBuilder();
  builder.addRuleClass(ReduceExpressionsRule.class);
  HepPlanner hepPlanner = new HepPlanner(builder.build());
  hepPlanner.addRule(ReduceExpressionsRule.FILTER_INSTANCE);

  final String sql = "select sal\n"
          + "from emp\n"
          + "where case when (sal = 1000) then\n"
          + "(case when sal = 1000 then null else 1 end is null) else\n"
          + "(case when sal = 2000 then null else 1 end is null) end is true";
  checkPlanning(tester, preProgram, hepPlanner, sql);
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
/** Test case for
 * <a href="https://issues.apache.org/jira/browse/CALCITE-1479">[CALCITE-1479]
 * AssertionError in ReduceExpressionsRule on multi-column IN
 * sub-query</a>. */
@Test public void testReduceCompositeInSubQuery() {
  final HepProgram hepProgram = new HepProgramBuilder()
      .addRuleInstance(ReduceExpressionsRule.FILTER_INSTANCE)
      .build();
  final String sql = "select *\n"
      + "from emp\n"
      + "where (empno, deptno) in (\n"
      + "  select empno, deptno from (\n"
      + "    select empno, deptno\n"
      + "    from emp\n"
      + "    group by empno, deptno))\n"
      + "or deptno < 40 + 60";
  checkSubQuery(sql)
      .with(hepProgram)
      .check();
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
@Test public void testProjectWindowTransposeRuleWithConstants() {
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(ProjectToWindowRule.PROJECT)
      .addRuleInstance(ProjectMergeRule.INSTANCE)
      .addRuleInstance(ProjectWindowTransposeRule.INSTANCE)
      .build();

  final String sql = "select col1, col2\n"
      + "from (\n"
      + "  select empno,\n"
      + "    sum(100) over (partition by  deptno order by sal) as col1,\n"
      + "  sum(1000) over(partition by deptno order by sal) as col2\n"
      + "  from emp)";

  checkPlanning(program, sql);
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
/** Test case for
 * <a href="https://issues.apache.org/jira/browse/CALCITE-1495">[CALCITE-1495]
 * SemiJoinRule should not apply to RIGHT and FULL JOIN</a>. */
@Test public void testSemiJoinRuleRight() {
  final HepProgram preProgram =
      HepProgram.builder()
          .addRuleInstance(FilterProjectTransposeRule.INSTANCE)
          .addRuleInstance(FilterJoinRule.FILTER_ON_JOIN)
          .addRuleInstance(ProjectMergeRule.INSTANCE)
          .build();
  final HepProgram program =
      HepProgram.builder()
          .addRuleInstance(SemiJoinRule.PROJECT)
          .build();
  final String sql = "select dept.* from dept right join (\n"
      + "  select distinct deptno from emp\n"
      + "  where sal > 100) using (deptno)";
  sql(sql)
      .withPre(preProgram)
      .with(program)
      .withDecorrelation(true)
      .withTrim(true)
      .checkUnchanged();
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
/** Similar to {@link #testSemiJoinRuleRight()} but FULL. */
@Test public void testSemiJoinRuleFull() {
  final HepProgram preProgram =
      HepProgram.builder()
          .addRuleInstance(FilterProjectTransposeRule.INSTANCE)
          .addRuleInstance(FilterJoinRule.FILTER_ON_JOIN)
          .addRuleInstance(ProjectMergeRule.INSTANCE)
          .build();
  final HepProgram program =
      HepProgram.builder()
          .addRuleInstance(SemiJoinRule.PROJECT)
          .build();
  final String sql = "select dept.* from dept full join (\n"
      + "  select distinct deptno from emp\n"
      + "  where sal > 100) using (deptno)";
  sql(sql)
      .withPre(preProgram)
      .with(program)
      .withDecorrelation(true)
      .withTrim(true)
      .checkUnchanged();
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
/** Similar to {@link #testSemiJoinRule()} but LEFT. */
@Test public void testSemiJoinRuleLeft() {
  final HepProgram preProgram =
      HepProgram.builder()
          .addRuleInstance(FilterProjectTransposeRule.INSTANCE)
          .addRuleInstance(FilterJoinRule.FILTER_ON_JOIN)
          .addRuleInstance(ProjectMergeRule.INSTANCE)
          .build();
  final HepProgram program =
      HepProgram.builder()
          .addRuleInstance(SemiJoinRule.PROJECT)
          .build();
  final String sql = "select name from dept left join (\n"
      + "  select distinct deptno from emp\n"
      + "  where sal > 100) using (deptno)";
  sql(sql)
      .withPre(preProgram)
      .with(program)
      .withDecorrelation(true)
      .withTrim(true)
      .check();
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
/** Test case for
 * <a href="https://issues.apache.org/jira/browse/CALCITE-438">[CALCITE-438]
 * Push predicates through SemiJoin</a>. */
@Test public void testPushFilterThroughSemiJoin() {
  final HepProgram preProgram =
      HepProgram.builder()
          .addRuleInstance(SemiJoinRule.PROJECT)
          .build();

  final HepProgram program =
      HepProgram.builder()
          .addRuleInstance(FilterProjectTransposeRule.INSTANCE)
          .addRuleInstance(FilterJoinRule.FILTER_ON_JOIN)
          .addRuleInstance(FilterJoinRule.JOIN)
          .build();
  final String sql = "select * from (\n"
      + "  select * from dept where dept.deptno in (\n"
      + "    select emp.deptno from emp))R\n"
      + "where R.deptno <=10";
  sql(sql)
      .withDecorrelation(true)
      .withTrim(false)
      .withPre(preProgram)
      .with(program)
      .check();
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
/** Push a variety of aggregate functions. */
@Test public void testPushAggregateFunctionsThroughJoin() {
  final HepProgram preProgram = new HepProgramBuilder()
      .addRuleInstance(AggregateProjectMergeRule.INSTANCE)
      .build();
  final HepProgram program = new HepProgramBuilder()
      .addRuleInstance(AggregateJoinTransposeRule.EXTENDED)
      .build();
  final String sql = "select e.job,\n"
      + "  min(sal) as min_sal, min(e.deptno) as min_deptno,\n"
      + "  sum(sal) + 1 as sum_sal_plus, max(sal) as max_sal,\n"
      + "  sum(sal) as sum_sal_2, count(sal) as count_sal,\n"
      + "  count(mgr) as count_mgr\n"
      + "from sales.emp as e\n"
      + "join sales.dept as d on e.job = d.name\n"
      + "group by e.job,d.name";
  checkPlanning(tester, preProgram, new HepPlanner(program), sql);
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
/** Test case for
 * <a href="https://issues.apache.org/jira/browse/CALCITE-1507">[CALCITE-1507]
 * OFFSET cannot be pushed through a JOIN if the non-preserved side of outer
 * join is not count-preserving</a>. */
@Test public void testSortJoinTranspose7() {
  final HepProgram preProgram = new HepProgramBuilder()
      .addRuleInstance(SortProjectTransposeRule.INSTANCE)
      .build();
  final HepProgram program = new HepProgramBuilder()
      .addRuleInstance(SortJoinTransposeRule.INSTANCE)
      .build();
  // This one cannot be pushed down
  final String sql = "select d.deptno, empno from sales.dept d\n"
      + "left join sales.emp e using (deptno) order by d.deptno offset 1";
  sql(sql)
      .withPre(preProgram)
      .with(program)
      .checkUnchanged();
}
 

import org.apache.calcite.plan.hep.HepProgram; //导入依赖的package包/类
@Ignore // Calcite does not support INSERT yet
@Test public void testReduceCastsNullable() throws Exception {
  HepProgram program = new HepProgramBuilder()

      // Simulate the way INSERT will insert casts to the target types
      .addRuleInstance(
          new CoerceInputsRule(LogicalTableModify.class, false,
              RelFactories.LOGICAL_BUILDER))

          // Convert projects to calcs, merge two calcs, and then
          // reduce redundant casts in merged calc.
      .addRuleInstance(ProjectToCalcRule.INSTANCE)
      .addRuleInstance(CalcMergeRule.INSTANCE)
      .addRuleInstance(ReduceExpressionsRule.CALC_INSTANCE)
      .build();
  checkPlanning(program,
      "insert into sales.depts(name) "
          + "select cast(gender as varchar(128)) from sales.emps");
}