import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/** Creates a {@link RelBuilderFactory}, a partially-created RelBuilder.
 * Just add a {@link RelOptCluster} and a {@link RelOptSchema} */
public static RelBuilderFactory proto(final Context context) {
  return new RelBuilderFactory() {
    @Override
    public RelBuilder create(RelOptCluster cluster, RelOptSchema schema) {
      return new RelBuilder(context, cluster, schema);
    }
  };
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
public BeamAggregationRule(
    Class<? extends Aggregate> aggregateClass,
    Class<? extends Project> projectClass,
    RelBuilderFactory relBuilderFactory) {
  super(
      operand(aggregateClass,
          operand(projectClass, any())),
      relBuilderFactory, null);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
public FlinkAggregateExpandDistinctAggregatesRule(
		Class<? extends LogicalAggregate> clazz,
		boolean useGroupingSets,
		RelBuilderFactory relBuilderFactory) {
	super(operand(clazz, any()), relBuilderFactory, null);
	this.useGroupingSets = useGroupingSets;
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
public OLAPJoinPushThroughJoinRule(String description, Class<? extends Join> clazz, RelBuilderFactory relBuilderFactory) {
    super(operand(clazz,

            operand(clazz, operand(RelNode.class, any()), operand(RelNode.class, null, new Predicate<RelNode>() {
                @Override
                public boolean apply(@Nullable RelNode input) {
                    return !(input instanceof TableScan);
                }
            }, any())),

            operand(TableScan.class, any())), relBuilderFactory, description);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/**
 * Creates a FilterProjectTransposeRule with an explicit root operand and
 * factories.
 */
protected FilterJoinRule(RelOptRuleOperand operand, String id, boolean smart, RelBuilderFactory relBuilderFactory,
        Predicate predicate) {
    super(operand, relBuilderFactory, "FilterJoinRule:" + id);
    this.smart = smart;
    this.predicate = Preconditions.checkNotNull(predicate);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
private ConfigImpl(boolean convertTableAccess, boolean decorrelationEnabled,
    boolean trimUnusedFields, boolean createValuesRel, boolean explain,
    boolean expand, int inSubQueryThreshold,
    RelBuilderFactory relBuilderFactory) {
  this.convertTableAccess = convertTableAccess;
  this.decorrelationEnabled = decorrelationEnabled;
  this.trimUnusedFields = trimUnusedFields;
  this.createValuesRel = createValuesRel;
  this.explain = explain;
  this.expand = expand;
  this.inSubQueryThreshold = inSubQueryThreshold;
  this.relBuilderFactory = relBuilderFactory;
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/**
 * Creates a CassandraToEnumerableConverterRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public CassandraToEnumerableConverterRule(
    RelBuilderFactory relBuilderFactory) {
  super(RelNode.class, Predicates.<RelNode>alwaysTrue(),
      CassandraRel.CONVENTION, EnumerableConvention.INSTANCE,
      relBuilderFactory, "CassandraToEnumerableConverterRule");
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的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.tools.RelBuilderFactory; //导入依赖的package包/类
/**
 * Creates a DruidPostAggregationProjectRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public DruidPostAggregationProjectRule(
    RelBuilderFactory relBuilderFactory) {
  super(
      operand(Project.class,
          operand(DruidQuery.class, none())),
      relBuilderFactory, null);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/**
 * Creates a SemiJoinProjectTransposeRule.
 */
private SemiJoinProjectTransposeRule(RelBuilderFactory relBuilderFactory) {
  super(
      operand(SemiJoin.class,
          some(operand(LogicalProject.class, any()))),
      relBuilderFactory, null);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/**
 * Creates a DruidAggregateProjectRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public DruidAggregateProjectRule(RelBuilderFactory relBuilderFactory) {
  super(
      operand(Aggregate.class,
          operand(Project.class,
              operand(DruidQuery.class, none()))),
      relBuilderFactory, null);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/**
 * Creates a DruidSortProjectTransposeRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public DruidSortProjectTransposeRule(RelBuilderFactory relBuilderFactory) {
  super(
      operand(Sort.class,
          operand(Project.class, operand(DruidQuery.class, none()))),
      relBuilderFactory, null);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/**
 * Creates a DruidProjectSortTransposeRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public DruidProjectSortTransposeRule(RelBuilderFactory relBuilderFactory) {
  super(
      operand(Project.class,
          operand(Sort.class, operand(DruidQuery.class, none()))),
      relBuilderFactory, null);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/** Creates a JdbcToEnumerableConverterRule. */
public JdbcToEnumerableConverterRule(JdbcConvention out,
    RelBuilderFactory relBuilderFactory) {
  super(RelNode.class, Predicates.<RelNode>alwaysTrue(), out,
      EnumerableConvention.INSTANCE, relBuilderFactory,
      "JdbcToEnumerableConverterRule:" + out);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/**
 * Creates a DruidAggregateFilterTransposeRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public DruidAggregateFilterTransposeRule(
    RelBuilderFactory relBuilderFactory) {
  super(
      operand(Aggregate.class,
          operand(Filter.class,
              operand(DruidQuery.class, none()))),
      relBuilderFactory);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/**
 * Creates a DruidAggregateExtractProjectRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public DruidAggregateExtractProjectRule(
    RelBuilderFactory relBuilderFactory) {
  super(
      operand(Aggregate.class,
          operand(DruidQuery.class, none())),
      relBuilderFactory);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/**
 * Creates an AggregateProjectPullUpConstantsRule.
 *
 * @param aggregateClass Aggregate class
 * @param inputClass Input class, such as {@link LogicalProject}
 * @param relBuilderFactory Builder for relational expressions
 * @param description Description, or null to guess description
 */
public AggregateProjectPullUpConstantsRule(
    Class<? extends Aggregate> aggregateClass,
    Class<? extends RelNode> inputClass,
    RelBuilderFactory relBuilderFactory, String description) {
  super(
      operand(aggregateClass, null, Aggregate.IS_SIMPLE,
          operand(inputClass, any())),
      relBuilderFactory, description);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/**
 * Creates a DeltaAggregateTransposeRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public DeltaAggregateTransposeRule(RelBuilderFactory relBuilderFactory) {
  super(
      operand(Delta.class,
          operand(Aggregate.class, null, Aggregate.NO_INDICATOR, any())),
      relBuilderFactory, null);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/**
 * Creates a DeltaSortTransposeRule.
 *
 * @param relBuilderFactory Builder for relational expressions
 */
public DeltaSortTransposeRule(RelBuilderFactory relBuilderFactory) {
  super(
      operand(Delta.class,
          operand(Sort.class, any())),
      relBuilderFactory, null);
}
 

import org.apache.calcite.tools.RelBuilderFactory; //导入依赖的package包/类
/**
 * Creates a FilterAggregateTransposeRule.
 *
 * <p>If {@code filterFactory} is null, creates the same kind of filter as
 * matched in the rule. Similarly {@code aggregateFactory}.</p>
 */
public FilterAggregateTransposeRule(
    Class<? extends Filter> filterClass,
    RelBuilderFactory builderFactory,
    Class<? extends Aggregate> aggregateClass) {
  this(
      operand(filterClass,
          operand(aggregateClass, any())),
      builderFactory);
}