import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
/**
 * Get a list of logical rules that can be turned on or off by session/system options.
 *
 * If a rule is intended to always be included with the logical set, it should be added
 * to the immutable list created in the getDrillBasicRules() method below.
 *
 * @param optimizerRulesContext - used to get the list of planner settings, other rules may
 *                                also in the future need to get other query state from this,
 *                                such as the available list of UDFs (as is used by the
 *                                DrillMergeProjectRule created in getDrillBasicRules())
 * @return - a list of rules that have been filtered to leave out
 *         rules that have been turned off by system or session settings
 */
public static RuleSet getDrillUserConfigurableLogicalRules(OptimizerRulesContext optimizerRulesContext) {
  final PlannerSettings ps = optimizerRulesContext.getPlannerSettings();

  // This list is used to store rules that can be turned on an off
  // by user facing planning options
  final Builder<RelOptRule> userConfigurableRules = ImmutableSet.<RelOptRule>builder();

  if (ps.isConstantFoldingEnabled()) {
    // TODO - DRILL-2218
    userConfigurableRules.add(ReduceExpressionsRule.PROJECT_INSTANCE);

    userConfigurableRules.add(DrillReduceExpressionsRule.FILTER_INSTANCE_DRILL);
    userConfigurableRules.add(DrillReduceExpressionsRule.CALC_INSTANCE_DRILL);
  }

  return new DrillRuleSet(userConfigurableRules.build());
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
/**
 * Get an immutable list of rules that will always be used when running
 * logical planning.
 *
 * This cannot be a static singleton because some of the rules need to
 * reference state owned by the current query (including its allocator).
 *
 * If a logical rule needs to be user configurable, such as turning
 * it on and off with a system/session option, add it in the
 * getDrillUserConfigurableLogicalRules() method instead of here.
 *
 * @param optimizerRulesContext - shared state used during planning, currently used here
 *                                to gain access to the function registry described above.
 * @return - a RuleSet containing the logical rules that will always
 *           be used, either by VolcanoPlanner directly, or
 *           used VolcanoPlanner as pre-processing for LOPTPlanner.
 *
 * Note : Join permutation rule is excluded here.
 */
public static RuleSet getDrillBasicRules(OptimizerRulesContext optimizerRulesContext) {
  /*
   * We have to create another copy of the ruleset with the context dependent elements;
   * this cannot be reused across queries.
   */
  final ImmutableSet<RelOptRule> basicRules = ImmutableSet.<RelOptRule>builder()
      .addAll(staticRuleSet)
      .add(
          DrillMergeProjectRule.getInstance(true, RelFactories.DEFAULT_PROJECT_FACTORY,
              optimizerRulesContext.getFunctionRegistry()),

          PruneScanRule.getFilterOnProject(optimizerRulesContext),
          PruneScanRule.getFilterOnScan(optimizerRulesContext),
          ParquetPruneScanRule.getFilterOnProjectParquet(optimizerRulesContext),
          ParquetPruneScanRule.getFilterOnScanParquet(optimizerRulesContext)
          )
      .build();

  return new DrillRuleSet(basicRules);
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
private RuleSet[] getRules(QueryContext context) {
  StoragePluginRegistry storagePluginRegistry = context.getStorage();
  RuleSet drillLogicalRules = DrillRuleSets.mergedRuleSets(
      DrillRuleSets.getDrillBasicRules(context),
      DrillRuleSets.getJoinPermRules(context),
      DrillRuleSets.getDrillUserConfigurableLogicalRules(context));
  RuleSet drillPhysicalMem = DrillRuleSets.mergedRuleSets(
      DrillRuleSets.getPhysicalRules(context),
      storagePluginRegistry.getStoragePluginRuleSet(context));

  // Following is used in LOPT join OPT.
  RuleSet logicalConvertRules = DrillRuleSets.mergedRuleSets(
      DrillRuleSets.getDrillBasicRules(context),
      DrillRuleSets.getDrillUserConfigurableLogicalRules(context));

  RuleSet[] allRules = new RuleSet[] {drillLogicalRules, drillPhysicalMem, logicalConvertRules};

  return allRules;
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的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.tools.RuleSet; //导入依赖的package包/类
/** Checks that a given query can use a materialized view with a given
 * definition. */
private CalciteAssert.AssertQuery checkThatMaterialize(String materialize,
    String query, String name, boolean existing, String model,
    Function<ResultSet, Void> explainChecker, final RuleSet rules) {
  try (final TryThreadLocal.Memo ignored = Prepare.THREAD_TRIM.push(true)) {
    MaterializationService.setThreadLocal();
    CalciteAssert.AssertQuery that = CalciteAssert.that()
        .withMaterializations(model, existing, name, materialize)
        .query(query)
        .enableMaterializations(true);

    // Add any additional rules required for the test
    if (rules.iterator().hasNext()) {
      that.withHook(Hook.PLANNER, new Function<RelOptPlanner, Void>() {
        public Void apply(RelOptPlanner planner) {
          for (RelOptRule rule : rules) {
            planner.addRule(rule);
          }
          return null;
        }
      });
    }

    return that.explainMatches("", explainChecker);
  }
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
public static RuleSet mergedRuleSets(RuleSet...ruleSets) {
  final Builder<RelOptRule> relOptRuleSetBuilder = ImmutableSet.builder();
  for (final RuleSet ruleSet : ruleSets) {
    for (final RelOptRule relOptRule : ruleSet) {
      relOptRuleSetBuilder.add(relOptRule);
    }
  }
  return new DrillRuleSet(relOptRuleSetBuilder.build());
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
public RuleSet getStoragePluginRuleSet(OptimizerRulesContext optimizerRulesContext) {
  // query registered engines for optimizer rules and build the storage plugin RuleSet
  Builder<RelOptRule> setBuilder = ImmutableSet.builder();
  for (StoragePlugin plugin : this.plugins.values()) {
    Set<? extends RelOptRule> rules = plugin.getOptimizerRules(optimizerRulesContext);
    if (rules != null && rules.size() > 0) {
      setBuilder.addAll(rules);
    }
  }

  return DrillRuleSets.create(setBuilder.build());
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
public RuleSet getRules(PlannerPhase phase) {
  Collection<StoragePlugin> plugins = Lists.newArrayList();
  for (Entry<String, StoragePlugin> k : context.getStorage()) {
    plugins.add(k.getValue());
  }
  return phase.getRules(context, plugins);
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
/**
 * Gets the default set of rules for planning process
 */
public static RuleSet getDefaultRuleSet() {
  ImmutableList.Builder<RelOptRule> builder
      = ImmutableList.builder();
  builder.addAll(DEFAULT_RULES).addAll(ENUMERABLE_RULES);
  return new QuarkRuleSet(builder.build());
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
private List<Program> getPrograms() {
  ImmutableList.Builder<Program> builder
      = ImmutableList.builder();
  for (RuleSet ruleSet: getRules()) {
    builder.add(Programs.sequence(
        new EnumerableProgram(ruleSet, this.context, this.plannerHolder),
        Programs.CALC_PROGRAM));
  }
  return builder.build();
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
Sql optimize(final RuleSet ruleSet, final RelOptPlanner relOptPlanner) {
  return new Sql(schemaSpec, sql, dialect, config,
      FlatLists.append(transforms, new Function<RelNode, RelNode>() {
        public RelNode apply(RelNode r) {
          Program program = Programs.of(ruleSet);
          return program.run(relOptPlanner, r, r.getTraitSet(),
              ImmutableList.<RelOptMaterialization>of(),
              ImmutableList.<RelOptLattice>of());
        }
      }));
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
private static RelNode run(PropAction action, RuleSet rules)
    throws Exception {

  FrameworkConfig config = Frameworks.newConfigBuilder()
      .ruleSets(rules).build();

  final Properties info = new Properties();
  final Connection connection = DriverManager
      .getConnection("jdbc:calcite:", info);
  final CalciteServerStatement statement = connection
      .createStatement().unwrap(CalciteServerStatement.class);
  final CalcitePrepare.Context prepareContext =
        statement.createPrepareContext();
  final JavaTypeFactory typeFactory = prepareContext.getTypeFactory();
  CalciteCatalogReader catalogReader =
        new CalciteCatalogReader(prepareContext.getRootSchema(),
            prepareContext.getDefaultSchemaPath(),
            typeFactory,
            prepareContext.config());
  final RexBuilder rexBuilder = new RexBuilder(typeFactory);
  final RelOptPlanner planner = new VolcanoPlanner(config.getCostFactory(),
      config.getContext());

  // set up rules before we generate cluster
  planner.clearRelTraitDefs();
  planner.addRelTraitDef(RelCollationTraitDef.INSTANCE);
  planner.addRelTraitDef(ConventionTraitDef.INSTANCE);

  planner.clear();
  for (RelOptRule r : rules) {
    planner.addRule(r);
  }

  final RelOptCluster cluster = RelOptCluster.create(planner, rexBuilder);
  return action.apply(cluster, catalogReader,
      prepareContext.getRootSchema().plus());
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
public static RuleSet getJoinPermRules(OptimizerRulesContext optimizerRulesContext) {
  return new DrillRuleSet(ImmutableSet.<RelOptRule> builder().add( //
      JoinPushThroughJoinRule.RIGHT,
      JoinPushThroughJoinRule.LEFT
      ).build());
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
public static final RuleSet getPhysicalRules(OptimizerRulesContext optimizerRulesContext) {
  final List<RelOptRule> ruleList = new ArrayList<RelOptRule>();
  final PlannerSettings ps = optimizerRulesContext.getPlannerSettings();

  ruleList.add(ConvertCountToDirectScan.AGG_ON_PROJ_ON_SCAN);
  ruleList.add(ConvertCountToDirectScan.AGG_ON_SCAN);
  ruleList.add(SortConvertPrule.INSTANCE);
  ruleList.add(SortPrule.INSTANCE);
  ruleList.add(ProjectPrule.INSTANCE);
  ruleList.add(ScanPrule.INSTANCE);
  ruleList.add(ScreenPrule.INSTANCE);
  ruleList.add(ExpandConversionRule.INSTANCE);
  ruleList.add(FilterPrule.INSTANCE);
  ruleList.add(LimitPrule.INSTANCE);
  ruleList.add(WriterPrule.INSTANCE);
  ruleList.add(WindowPrule.INSTANCE);
  ruleList.add(PushLimitToTopN.INSTANCE);
  ruleList.add(LimitUnionExchangeTransposeRule.INSTANCE);
  ruleList.add(UnionAllPrule.INSTANCE);
  ruleList.add(ValuesPrule.INSTANCE);

  if (ps.isHashAggEnabled()) {
    ruleList.add(HashAggPrule.INSTANCE);
  }

  if (ps.isStreamAggEnabled()) {
    ruleList.add(StreamAggPrule.INSTANCE);
  }

  if (ps.isHashJoinEnabled()) {
    ruleList.add(HashJoinPrule.DIST_INSTANCE);

    if(ps.isBroadcastJoinEnabled()){
      ruleList.add(HashJoinPrule.BROADCAST_INSTANCE);
    }
  }

  if (ps.isMergeJoinEnabled()) {
    ruleList.add(MergeJoinPrule.DIST_INSTANCE);

    if(ps.isBroadcastJoinEnabled()){
      ruleList.add(MergeJoinPrule.BROADCAST_INSTANCE);
    }

  }

  // NLJ plans consist of broadcasting the right child, hence we need
  // broadcast join enabled.
  if (ps.isNestedLoopJoinEnabled() && ps.isBroadcastJoinEnabled()) {
    ruleList.add(NestedLoopJoinPrule.INSTANCE);
  }

  return new DrillRuleSet(ImmutableSet.copyOf(ruleList));
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
public static RuleSet create(ImmutableSet<RelOptRule> rules) {
  return new DrillRuleSet(rules);
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
public RuleSet getRules(PlannerPhase phase) {
  return phase.getRules(context, getPlugins());
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
public static RuleSet[] getRuleSets() {
  return new RuleSet[] { new BeamRuleSet(
      ImmutableSet.<RelOptRule>builder().addAll(calciteToBeamConversionRules).build()) };
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
private RuleSet[] getRules() {
  RuleSet defaultRule = RuleSets.getDefaultRuleSet();
  RuleSet[] allRules = new RuleSet[] {defaultRule};
  return allRules;
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
private EnumerableProgram(RuleSet ruleSet, QueryContext context,
                          QuarkMaterializeCluster.RelOptPlannerHolder holder) {
  this.ruleSet = ruleSet;
  this.context = context;
  this.plannerHolder = holder;
}
 

import org.apache.calcite.tools.RuleSet; //导入依赖的package包/类
/** Checks that a given query can use a materialized view with a given
 * definition. */
private void checkMaterializeWithRules(String materialize, String query, RuleSet rules) {
  checkMaterialize(materialize, query, HR_FKUK_MODEL, CONTAINS_M0, rules);
}