import org.apache.calcite.rel.rules.FilterJoinRule; //导入依赖的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.rel.rules.FilterJoinRule; //导入依赖的package包/类
public void registerAbstractRelationalRules() {
  addRule(FilterJoinRule.FILTER_ON_JOIN);
  addRule(FilterJoinRule.JOIN);
  addRule(AbstractConverter.ExpandConversionRule.INSTANCE);
  addRule(JoinCommuteRule.INSTANCE);
  addRule(SemiJoinRule.PROJECT);
  addRule(SemiJoinRule.JOIN);
  if (CalcitePrepareImpl.COMMUTE) {
    addRule(JoinAssociateRule.INSTANCE);
  }
  addRule(AggregateRemoveRule.INSTANCE);
  addRule(UnionToDistinctRule.INSTANCE);
  addRule(ProjectRemoveRule.INSTANCE);
  addRule(AggregateJoinTransposeRule.INSTANCE);
  addRule(AggregateProjectMergeRule.INSTANCE);
  addRule(CalcRemoveRule.INSTANCE);
  addRule(SortRemoveRule.INSTANCE);

  // todo: rule which makes Project({OrdinalRef}) disappear
}
 

import org.apache.calcite.rel.rules.FilterJoinRule; //导入依赖的package包/类
/**
 * Converts a relational expression to a form where
 * {@link org.apache.calcite.rel.logical.LogicalJoin}s are
 * as close to leaves as possible.
 */
public static RelNode toLeafJoinForm(RelNode rel) {
  final Program program = Programs.hep(
      ImmutableList.of(
          JoinProjectTransposeRule.RIGHT_PROJECT,
          JoinProjectTransposeRule.LEFT_PROJECT,
          FilterJoinRule.FilterIntoJoinRule.FILTER_ON_JOIN,
          ProjectRemoveRule.INSTANCE,
          ProjectMergeRule.INSTANCE),
      false,
      DefaultRelMetadataProvider.INSTANCE);
  if (CalcitePrepareImpl.DEBUG) {
    System.out.println(
        RelOptUtil.dumpPlan("before", rel, SqlExplainFormat.TEXT,
            SqlExplainLevel.DIGEST_ATTRIBUTES));
  }
  final RelNode rel2 = program.run(null, rel, null,
      ImmutableList.<RelOptMaterialization>of(),
      ImmutableList.<RelOptLattice>of());
  if (CalcitePrepareImpl.DEBUG) {
    System.out.println(
        RelOptUtil.dumpPlan("after", rel2, SqlExplainFormat.TEXT,
            SqlExplainLevel.DIGEST_ATTRIBUTES));
  }
  return rel2;
}
 

import org.apache.calcite.rel.rules.FilterJoinRule; //导入依赖的package包/类
@Test public void testStrengthenJoinType() {
  // The "Filter(... , right.c IS NOT NULL)" above a left join is pushed into
  // the join, makes it an inner join, and then disappears because c is NOT
  // NULL.
  final HepProgram preProgram =
      HepProgram.builder()
          .addRuleInstance(ProjectMergeRule.INSTANCE)
          .addRuleInstance(FilterProjectTransposeRule.INSTANCE)
          .build();
  final HepProgram program =
      HepProgram.builder()
          .addRuleInstance(FilterJoinRule.FILTER_ON_JOIN)
          .build();
  final String sql = "select *\n"
      + "from dept left join emp using (deptno)\n"
      + "where emp.deptno is not null and emp.sal > 100";
  sql(sql)
      .withDecorrelation(true)
      .withTrim(true)
      .withPre(preProgram)
      .with(program)
      .check();
}
 

import org.apache.calcite.rel.rules.FilterJoinRule; //导入依赖的package包/类
@Test public void testSemiJoinRuleExists() {
  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 * from dept where exists (\n"
      + "  select * from emp\n"
      + "  where emp.deptno = dept.deptno\n"
      + "  and emp.sal > 100)";
  sql(sql)
      .withDecorrelation(true)
      .withTrim(true)
      .withPre(preProgram)
      .with(program)
      .check();
}
 

import org.apache.calcite.rel.rules.FilterJoinRule; //导入依赖的package包/类
@Test public void testSemiJoinRule() {
  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 join (\n"
      + "  select distinct deptno from emp\n"
      + "  where sal > 100) using (deptno)";
  sql(sql)
      .withDecorrelation(true)
      .withTrim(true)
      .withPre(preProgram)
      .with(program)
      .check();
}
 

import org.apache.calcite.rel.rules.FilterJoinRule; //导入依赖的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.rel.rules.FilterJoinRule; //导入依赖的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.rel.rules.FilterJoinRule; //导入依赖的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.rel.rules.FilterJoinRule; //导入依赖的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.rel.rules.FilterJoinRule; //导入依赖的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.rel.rules.FilterJoinRule; //导入依赖的package包/类
private RelOptPlanner getVolcanoPlanner(RelNode root) {
  final RelBuilderFactory builderFactory =
      RelBuilder.proto(PigRelFactories.ALL_PIG_REL_FACTORIES);
  final RelOptPlanner planner = root.getCluster().getPlanner(); // VolcanoPlanner
  for (RelOptRule r : PigRules.ALL_PIG_OPT_RULES) {
    planner.addRule(r);
  }
  planner.removeRule(FilterAggregateTransposeRule.INSTANCE);
  planner.removeRule(FilterJoinRule.FILTER_ON_JOIN);
  planner.addRule(
      new FilterAggregateTransposeRule(PigFilter.class, builderFactory, PigAggregate.class));
  planner.addRule(new FilterIntoJoinRule(true, builderFactory, TRUE_PREDICATE));
  planner.setRoot(root);
  return planner;
}
 

import org.apache.calcite.rel.rules.FilterJoinRule; //导入依赖的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.rel.rules.FilterJoinRule; //导入依赖的package包/类
@Test public void testConvertSemiJoin() {
  final String sql = "select * from dept where exists (\n"
      + "  select * from emp\n"
      + "  where emp.deptno = dept.deptno\n"
      + "  and emp.sal > 100)";
  checkConvertMutableRel(
      "SemiJoin",
      sql,
      true,
      ImmutableList.of(
          FilterProjectTransposeRule.INSTANCE,
          FilterJoinRule.FILTER_ON_JOIN,
          ProjectMergeRule.INSTANCE,
          SemiJoinRule.PROJECT));
}
 

import org.apache.calcite.rel.rules.FilterJoinRule; //导入依赖的package包/类
@Test public void testPushSemiJoinPastJoinRuleLeft() throws Exception {
  // tests the case where the semijoin is pushed to the left
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(FilterJoinRule.FILTER_ON_JOIN)
      .addRuleInstance(JoinAddRedundantSemiJoinRule.INSTANCE)
      .addRuleInstance(SemiJoinJoinTransposeRule.INSTANCE)
      .build();
  checkPlanning(program,
      "select e1.ename from emp e1, dept d, emp e2 "
          + "where e1.deptno = d.deptno and e1.empno = e2.empno");
}
 

import org.apache.calcite.rel.rules.FilterJoinRule; //导入依赖的package包/类
@Test public void testPushSemiJoinPastJoinRuleRight() throws Exception {
  // tests the case where the semijoin is pushed to the right
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(FilterJoinRule.FILTER_ON_JOIN)
      .addRuleInstance(JoinAddRedundantSemiJoinRule.INSTANCE)
      .addRuleInstance(SemiJoinJoinTransposeRule.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.rel.rules.FilterJoinRule; //导入依赖的package包/类
@Test public void testPushSemiJoinPastFilter() throws Exception {
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(FilterJoinRule.FILTER_ON_JOIN)
      .addRuleInstance(JoinAddRedundantSemiJoinRule.INSTANCE)
      .addRuleInstance(SemiJoinFilterTransposeRule.INSTANCE)
      .build();
  checkPlanning(program,
      "select e.ename from emp e, dept d "
          + "where e.deptno = d.deptno and e.ename = 'foo'");
}
 

import org.apache.calcite.rel.rules.FilterJoinRule; //导入依赖的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.rel.rules.FilterJoinRule; //导入依赖的package包/类
@Test
public void testSkipReduceConstantsCaseEquals() throws Exception {
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(ReduceExpressionsRule.PROJECT_INSTANCE)
      .addRuleInstance(ReduceExpressionsRule.FILTER_INSTANCE)
      .addRuleInstance(FilterJoinRule.FilterIntoJoinRule.FILTER_ON_JOIN)
      .build();

  checkPlanning(program,
      "select * from emp e1, emp e2\n"
          + "where coalesce(e1.mgr, -1) = coalesce(e2.mgr, -1)");
}
 

import org.apache.calcite.rel.rules.FilterJoinRule; //导入依赖的package包/类
@Test public void testRemoveSemiJoin() throws Exception {
  HepProgram program = new HepProgramBuilder()
      .addRuleInstance(FilterJoinRule.FILTER_ON_JOIN)
      .addRuleInstance(JoinAddRedundantSemiJoinRule.INSTANCE)
      .addRuleInstance(SemiJoinRemoveRule.INSTANCE)
      .build();
  checkPlanning(program,
      "select e.ename from emp e, dept d "
          + "where e.deptno = d.deptno");
}