import org.apache.calcite.plan.hep.HepProgramBuilder; //导入依赖的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.HepProgramBuilder; //导入依赖的package包/类
/** Push a aggregate functions into a relation that is unique on the join
 * key. */
@Test public void testPushAggregateThroughJoinDistinct() {
  final HepProgram preProgram = new HepProgramBuilder()
      .addRuleInstance(AggregateProjectMergeRule.INSTANCE)
      .build();
  final HepProgram program = new HepProgramBuilder()
      .addRuleInstance(AggregateJoinTransposeRule.EXTENDED)
      .build();
  final String sql = "select d.name,\n"
      + "  sum(sal) as sum_sal, count(*) as c\n"
      + "from sales.emp as e\n"
      + "join (select distinct name from sales.dept) as d\n"
      + "  on e.job = d.name\n"
      + "group by d.name";
  checkPlanning(tester, preProgram, new HepPlanner(program), sql);
}
 

import org.apache.calcite.plan.hep.HepProgramBuilder; //导入依赖的package包/类
@Test public void testRuleClass() throws Exception {
  // Verify that an entire class of rules can be applied.

  HepProgramBuilder programBuilder = HepProgram.builder();
  programBuilder.addRuleClass(CoerceInputsRule.class);

  HepPlanner planner =
      new HepPlanner(
          programBuilder.build());

  planner.addRule(
      new CoerceInputsRule(LogicalUnion.class, false,
          RelFactories.LOGICAL_BUILDER));
  planner.addRule(
      new CoerceInputsRule(LogicalIntersect.class, false,
          RelFactories.LOGICAL_BUILDER));

  checkPlanning(planner,
      "(select name from dept union select ename from emp)"
          + " intersect (select fname from customer.contact)");
}
 

import org.apache.calcite.plan.hep.HepProgramBuilder; //导入依赖的package包/类
@Test public void testRuleDescription() throws Exception {
  // Verify that a rule can be applied via its description.

  HepProgramBuilder programBuilder = HepProgram.builder();
  programBuilder.addRuleByDescription("FilterToCalcRule");

  HepPlanner planner =
      new HepPlanner(
          programBuilder.build());

  planner.addRule(FilterToCalcRule.INSTANCE);

  checkPlanning(
      planner,
      "select name from sales.dept where deptno=12");
}
 

import org.apache.calcite.plan.hep.HepProgramBuilder; //导入依赖的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.HepProgramBuilder; //导入依赖的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.HepProgramBuilder; //导入依赖的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.HepProgramBuilder; //导入依赖的package包/类
@Test public void testProjectToWindowRuleForMultipleWindows() {
  HepProgram preProgram = new HepProgramBuilder()
      .build();

  HepProgramBuilder builder = new HepProgramBuilder();
  builder.addRuleClass(ProjectToWindowRule.class);
  HepPlanner hepPlanner = new HepPlanner(builder.build());
  hepPlanner.addRule(ProjectToWindowRule.PROJECT);

  final String sql = "select\n"
      + " count(*) over(partition by empno order by sal) as count1,\n"
      + " count(*) over(partition by deptno order by sal) as count2,\n"
      + " sum(deptno) over(partition by empno order by sal) as sum1,\n"
      + " sum(deptno) over(partition by deptno order by sal) as sum2\n"
      + "from emp";
  checkPlanning(tester, preProgram, hepPlanner, sql);
}
 

import org.apache.calcite.plan.hep.HepProgramBuilder; //导入依赖的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.HepProgramBuilder; //导入依赖的package包/类
@Ignore("cycles")
@Test public void testMergeFilterWithJoinCondition() throws Exception {
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(TableScanRule.INSTANCE)
      .addRuleInstance(JoinExtractFilterRule.INSTANCE)
      .addRuleInstance(FilterToCalcRule.INSTANCE)
      .addRuleInstance(CalcMergeRule.INSTANCE)
      .addRuleInstance(ProjectToCalcRule.INSTANCE)
      .build();

  checkPlanning(program,
      "select d.name as dname,e.ename as ename"
          + " from emp e inner join dept d"
          + " on e.deptno=d.deptno"
          + " where d.name='Propane'");
}
 

import org.apache.calcite.plan.hep.HepProgramBuilder; //导入依赖的package包/类
/** Tests to see if the final branch of union is missed */
@Test
public void testUnionMergeRule() throws Exception {
  HepProgram program = new HepProgramBuilder()
          .addRuleInstance(ProjectSetOpTransposeRule.INSTANCE)
          .addRuleInstance(ProjectRemoveRule.INSTANCE)
          .addRuleInstance(UnionMergeRule.INSTANCE)
          .build();

  checkPlanning(program,
          "select * from (\n"
                  + "select * from (\n"
                  + "  select name, deptno from dept\n"
                  + "  union all\n"
                  + "  select name, deptno from\n"
                  + "  (\n"
                  + "    select name, deptno, count(1) from dept group by name, deptno\n"
                  + "    union all\n"
                  + "    select name, deptno, count(1) from dept group by name, deptno\n"
                  + "  ) subq\n"
                  + ") a\n"
                  + "union all\n"
                  + "select name, deptno from dept\n"
                  + ") aa\n");
}
 

import org.apache.calcite.plan.hep.HepProgramBuilder; //导入依赖的package包/类
/** Tests that a filters is combined are combined if they are identical,
 * even if one of them originates in an ON clause of a JOIN. */
@Test public void testMergeJoinFilter() throws Exception {
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(FilterProjectTransposeRule.INSTANCE)
      .addRuleInstance(FilterMergeRule.INSTANCE)
      .addRuleInstance(FilterJoinRule.FILTER_ON_JOIN)
      .build();

  checkPlanning(program,
      "select * from (\n"
          + "  select d.deptno, e.ename\n"
          + "  from emp as e\n"
          + "  join dept as d\n"
          + "  on e.deptno = d.deptno\n"
          + "  and d.deptno = 10)\n"
          + "where deptno = 10\n");
}
 

import org.apache.calcite.plan.hep.HepProgramBuilder; //导入依赖的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.HepProgramBuilder; //导入依赖的package包/类
@Test public void testCustomColumnResolvingInCorrelatedSubQuery() {
  final String sql = "select *\n"
      + "from struct.t t1\n"
      + "where c0 = (\n"
      + "  select max(f1.c0) from struct.t t2 where t1.k0 = t2.k0)";
  final HepProgram program = new HepProgramBuilder()
      .addRuleInstance(SubQueryRemoveRule.PROJECT)
      .addRuleInstance(SubQueryRemoveRule.FILTER)
      .addRuleInstance(SubQueryRemoveRule.JOIN)
      .build();
  sql(sql)
      .withTrim(true)
      .expand(false)
      .with(program)
      .check();
}
 

import org.apache.calcite.plan.hep.HepProgramBuilder; //导入依赖的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.HepProgramBuilder; //导入依赖的package包/类
@Test public void testCustomColumnResolvingInCorrelatedSubQuery2() {
  final String sql = "select *\n"
      + "from struct.t t1\n"
      + "where c0 in (\n"
      + "  select f1.c0 from struct.t t2 where t1.c2 = t2.c2)";
  final HepProgram program = new HepProgramBuilder()
      .addRuleInstance(SubQueryRemoveRule.PROJECT)
      .addRuleInstance(SubQueryRemoveRule.FILTER)
      .addRuleInstance(SubQueryRemoveRule.JOIN)
      .build();
  sql(sql)
      .withTrim(true)
      .expand(false)
      .with(program)
      .check();
}
 

import org.apache.calcite.plan.hep.HepProgramBuilder; //导入依赖的package包/类
@Test public void testReduceConstantsCaseEquals2() throws Exception {
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(ReduceExpressionsRule.PROJECT_INSTANCE)
      .addRuleInstance(ReduceExpressionsRule.FILTER_INSTANCE)
      .addRuleInstance(ReduceExpressionsRule.JOIN_INSTANCE)
      .build();

  // Equivalent to 'case when deptno = 20 then false
  //                     when deptno = 10 then true
  //                     else null end'
  checkPlanning(program,
      "select count(1) from emp\n"
          + "where case deptno\n"
          + "  when 20 then 2\n"
          + "  when 10 then 1\n"
          + "  else cast(null as integer) end = 1");
}
 

import org.apache.calcite.plan.hep.HepProgramBuilder; //导入依赖的package包/类
@Test public void testReduceConstantsCaseEquals3() throws Exception {
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(ReduceExpressionsRule.PROJECT_INSTANCE)
      .addRuleInstance(ReduceExpressionsRule.FILTER_INSTANCE)
      .addRuleInstance(ReduceExpressionsRule.JOIN_INSTANCE)
      .build();

  // Equivalent to 'deptno = 30 or deptno = 10'
  checkPlanning(program,
      "select count(1) from emp\n"
          + "where case deptno\n"
          + "  when 30 then 1\n"
          + "  when 20 then 2\n"
          + "  when 10 then 1\n"
          + "  when 30 then 111\n"
          + "  else 0 end = 1");
}
 

import org.apache.calcite.plan.hep.HepProgramBuilder; //导入依赖的package包/类
/** Test case for
 * <a href="https://issues.apache.org/jira/browse/CALCITE-2110">[CALCITE-2110]
 * ArrayIndexOutOfBoundsException in RexSimplify when using
 * ReduceExpressionsRule.JOIN_INSTANCE</a>. */
@Test public void testCorrelationScalarAggAndFilter() {
  final String sql = "SELECT e1.empno\n"
      + "FROM emp e1, dept d1 where e1.deptno = d1.deptno\n"
      + "and e1.deptno < 10 and d1.deptno < 15\n"
      + "and e1.sal > (select avg(sal) from emp e2 where e1.empno = e2.empno)";
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(ReduceExpressionsRule.PROJECT_INSTANCE)
      .addRuleInstance(ReduceExpressionsRule.FILTER_INSTANCE)
      .addRuleInstance(ReduceExpressionsRule.JOIN_INSTANCE)
      .build();
  sql(sql)
      .withDecorrelation(true)
      .withTrim(true)
      .expand(true)
      .withPre(program)
      .with(program)
      .checkUnchanged();
}
 

import org.apache.calcite.plan.hep.HepProgramBuilder; //导入依赖的package包/类
@Test public void testEmptyFilterProjectUnion() throws Exception {
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(FilterSetOpTransposeRule.INSTANCE)
      .addRuleInstance(FilterProjectTransposeRule.INSTANCE)
      .addRuleInstance(ProjectMergeRule.INSTANCE)
      .addRuleInstance(ValuesReduceRule.PROJECT_FILTER_INSTANCE)
      .addRuleInstance(PruneEmptyRules.PROJECT_INSTANCE)
      .addRuleInstance(PruneEmptyRules.UNION_INSTANCE)
      .build();

  // Plan should be same as for
  // select * from (values (30, 3)) as t(x, y)");
  checkPlanning(program,
      "select * from (\n"
          + "select * from (values (10, 1), (30, 3)) as t (x, y)\n"
          + "union all\n"
          + "select * from (values (20, 2))\n"
          + ")\n"
          + "where x + y > 30");
}