Java HepPlanner.findBestExp方法代码示例

import org.apache.calcite.plan.hep.HepPlanner; //导入方法依赖的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.HepPlanner; //导入方法依赖的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.HepPlanner; //导入方法依赖的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.HepPlanner; //导入方法依赖的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.HepPlanner; //导入方法依赖的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.HepPlanner; //导入方法依赖的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.HepPlanner; //导入方法依赖的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.HepPlanner; //导入方法依赖的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.HepPlanner; //导入方法依赖的package包/类
public RelNode removeCorrelationViaRule(RelNode root) {
	HepProgram program = HepProgram.builder().addRuleInstance(new RemoveSingleAggregateRule()).addRuleInstance(new RemoveCorrelationForScalarProjectRule()).addRuleInstance(new RemoveCorrelationForScalarAggregateRule()).build();

	HepPlanner planner = createPlanner(program);

	planner.setRoot(root);
	return planner.findBestExp();
}
 

import org.apache.calcite.plan.hep.HepPlanner; //导入方法依赖的package包/类
protected void apply(RelOptRuleCall call, Filter filter, TableScan scan) {
  //Avoid optimizing already optimized scan
  if (scan instanceof QuarkViewScan || scan instanceof QuarkTileScan) {
    return;
  }
  RelNode root = filter.copy(filter.getTraitSet(),
      Collections.singletonList((RelNode) scan));
  RelOptPlanner planner = call.getPlanner();
  if (planner instanceof VolcanoPlanner) {
    List<RelOptMaterialization> materializations
        = ((VolcanoPlanner) planner).getMaterializations();
    for (RelOptMaterialization materialization : materializations) {
      if (scan.getRowType().equals(materialization.queryRel.getRowType())) {
        RelNode target = materialization.queryRel;
        final HepPlanner hepPlanner =
            new HepPlanner(program, planner.getContext());
        hepPlanner.setRoot(target);
        target = hepPlanner.findBestExp();
        List<RelNode> subs = new MaterializedViewSubstitutionVisitor(target, root)
            .go(materialization.tableRel);
        for (RelNode s : subs) {
          call.transformTo(s);
        }
      }
    }
  }
}
 

import org.apache.calcite.plan.hep.HepPlanner; //导入方法依赖的package包/类
protected void apply(RelOptRuleCall call, Filter filter, TableScan scan) {
  RelOptPlanner planner = call.getPlanner();
  List<RelOptMaterialization> materializations =
      (planner instanceof VolcanoPlanner)
          ? ((VolcanoPlanner) planner).getMaterializations()
          : ImmutableList.<RelOptMaterialization>of();
  if (!materializations.isEmpty()) {
    RelNode root = filter.copy(filter.getTraitSet(),
        Collections.singletonList((RelNode) scan));
    List<RelOptMaterialization> applicableMaterializations =
        RelOptMaterializations.getApplicableMaterializations(root, materializations);
    for (RelOptMaterialization materialization : applicableMaterializations) {
      if (RelOptUtil.areRowTypesEqual(scan.getRowType(),
          materialization.queryRel.getRowType(), false)) {
        RelNode target = materialization.queryRel;
        final HepPlanner hepPlanner =
            new HepPlanner(program, planner.getContext());
        hepPlanner.setRoot(target);
        target = hepPlanner.findBestExp();
        List<RelNode> subs = new MaterializedViewSubstitutionVisitor(target, root)
            .go(materialization.tableRel);
        for (RelNode s : subs) {
          call.transformTo(s);
        }
      }
    }
  }
}
 

import org.apache.calcite.plan.hep.HepPlanner; //导入方法依赖的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.HepPlanner; //导入方法依赖的package包/类
public RelNode removeCorrelationViaRule(RelNode root) {
  HepProgram program = HepProgram.builder()
      .addRuleInstance(new RemoveSingleAggregateRule())
      .addRuleInstance(new RemoveCorrelationForScalarProjectRule())
      .addRuleInstance(new RemoveCorrelationForScalarAggregateRule())
      .build();

  HepPlanner planner = createPlanner(program);

  planner.setRoot(root);
  return planner.findBestExp();
}
 

import org.apache.calcite.plan.hep.HepPlanner; //导入方法依赖的package包/类
private static List<RelNode> substitute(
    RelNode root, 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) {
    RelNode newRoot = RelOptMaterialization.tryUseStar(root,
        materialization.starRelOptTable);
    if (newRoot != null) {
      root = newRoot;
    }
  }

  // Push filters to the bottom, and combine projects on top.
  RelNode target = materialization.queryRel;
  HepProgram program =
      new HepProgramBuilder()
          .addRuleInstance(FilterProjectTransposeRule.INSTANCE)
          .addRuleInstance(ProjectMergeRule.INSTANCE)
          .addRuleInstance(ProjectRemoveRule.INSTANCE)
          .build();

  final HepPlanner hepPlanner = new HepPlanner(program);
  hepPlanner.setRoot(target);
  target = hepPlanner.findBestExp();

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

  return new MaterializedViewSubstitutionVisitor(target, root)
          .go(materialization.tableRel);
}
 

import org.apache.calcite.plan.hep.HepPlanner; //导入方法依赖的package包/类
private RelNode optimize(RelNode rootRel) {
  final HepProgram hepProgram = new HepProgramBuilder()
      .addRuleInstance(CalcSplitRule.INSTANCE)
      .addRuleInstance(FilterTableScanRule.INSTANCE)
      .addRuleInstance(FilterTableScanRule.INTERPRETER)
      .addRuleInstance(ProjectTableScanRule.INSTANCE)
      .addRuleInstance(ProjectTableScanRule.INTERPRETER).build();
  final HepPlanner planner = new HepPlanner(hepProgram);
  planner.setRoot(rootRel);
  rootRel = planner.findBestExp();
  return rootRel;
}