org.apache.calcite.plan.Convention Java Examples

/**
 * Finds RelSubsets in the plan that contain only rels of
 * {@link Convention#NONE} and boosts their importance by 25%.
 */
private void injectImportanceBoost() {
  final Set<RelSubset> requireBoost = new HashSet<>();

SUBSET_LOOP:
  for (RelSubset subset : ruleQueue.subsetImportances.keySet()) {
    for (RelNode rel : subset.getRels()) {
      if (rel.getConvention() != Convention.NONE) {
        continue SUBSET_LOOP;
      }
    }

    requireBoost.add(subset);
  }

  ruleQueue.boostImportance(requireBoost, 1.25);
}
 

/**
 * Creates a LogicalMatch.
 */
public static LogicalMatch create(RelNode input, RelDataType rowType,
    RexNode pattern, boolean strictStart, boolean strictEnd,
    Map<String, RexNode> patternDefinitions, Map<String, RexNode> measures,
    RexNode after, Map<String, ? extends SortedSet<String>> subsets, boolean allRows,
    List<RexNode> partitionKeys, RelCollation orderKeys, RexNode interval) {
  final RelOptCluster cluster = input.getCluster();
  final RelTraitSet traitSet = cluster.traitSetOf(Convention.NONE);
  return new LogicalMatch(cluster, traitSet, input, rowType, pattern,
      strictStart, strictEnd, patternDefinitions, measures, after, subsets,
      allRows, partitionKeys, orderKeys, interval);
}
 

/** Creates a SemiJoin. */
public static SemiJoin create(RelNode left, RelNode right, RexNode condition,
    ImmutableIntList leftKeys, ImmutableIntList rightKeys) {
  final RelOptCluster cluster = left.getCluster();
  return new SemiJoin(cluster, cluster.traitSetOf(Convention.NONE), left,
      right, condition, leftKeys, rightKeys);
}
 

/** Creates a LogicalProject, specifying row type rather than field names. */
public static LogicalProject create(final RelNode input,
    final List<? extends RexNode> projects, RelDataType rowType) {
  final RelOptCluster cluster = input.getCluster();
  final RelMetadataQuery mq = cluster.getMetadataQuery();
  final RelTraitSet traitSet =
      cluster.traitSet().replace(Convention.NONE)
          .replaceIfs(RelCollationTraitDef.INSTANCE,
              () -> RelMdCollation.project(mq, input, projects));
  return new LogicalProject(cluster, traitSet, input, projects, rowType);
}
 

@Deprecated // to be removed before 2.0
public LogicalAggregate(
    RelOptCluster cluster,
    RelNode child,
    boolean indicator,
    ImmutableBitSet groupSet,
    List<ImmutableBitSet> groupSets,
    List<AggregateCall> aggCalls) {
  this(cluster, cluster.traitSetOf(Convention.NONE), child, indicator,
      groupSet, groupSets, aggCalls);
}
 

private static LogicalAggregate create_(final RelNode input,
    boolean indicator,
    ImmutableBitSet groupSet,
    List<ImmutableBitSet> groupSets,
    List<AggregateCall> aggCalls) {
  final RelOptCluster cluster = input.getCluster();
  final RelTraitSet traitSet = cluster.traitSetOf(Convention.NONE);
  return new LogicalAggregate(cluster, traitSet, input, indicator, groupSet,
      groupSets, aggCalls);
}
 

/** Creates a LogicalTableScan.
 *
 * @param cluster Cluster
 * @param relOptTable Table
 */
public static LogicalTableScan create(RelOptCluster cluster,
    final RelOptTable relOptTable) {
  final Table table = relOptTable.unwrap(Table.class);
  final RelTraitSet traitSet =
      cluster.traitSetOf(Convention.NONE)
          .replaceIfs(RelCollationTraitDef.INSTANCE, () -> {
            if (table != null) {
              return table.getStatistic().getCollations();
            }
            return ImmutableList.of();
          });
  return new LogicalTableScan(cluster, traitSet, relOptTable);
}
 

/** Creates a LogicalTableModify. */
public static LogicalTableModify create(RelOptTable table,
    CatalogReader schema, RelNode input,
    Operation operation, List<String> updateColumnList,
    List<RexNode> sourceExpressionList, boolean flattened) {
  final RelOptCluster cluster = input.getCluster();
  final RelTraitSet traitSet = cluster.traitSetOf(Convention.NONE);
  return new LogicalTableModify(cluster, traitSet, table, schema, input,
      operation, updateColumnList, sourceExpressionList, flattened);
}
 

/**
 * Creates a LogicalExchange.
 *
 * @param input     Input relational expression
 * @param distribution Distribution specification
 */
public static LogicalExchange create(RelNode input,
    RelDistribution distribution) {
  RelOptCluster cluster = input.getCluster();
  distribution = RelDistributionTraitDef.INSTANCE.canonize(distribution);
  RelTraitSet traitSet =
      input.getTraitSet().replace(Convention.NONE).replace(distribution);
  return new LogicalExchange(cluster, traitSet, input, distribution);
}
 

protected DrillFilterRelBase(Convention convention, RelOptCluster cluster, RelTraitSet traits, RelNode child, RexNode condition) {
  super(cluster, traits, child, condition);
  assert getConvention() == convention;

  // save the number of conjuncts that make up the filter condition such
  // that repeated calls to the costing function can use the saved copy
  conjunctions = RelOptUtil.conjunctions(condition);
  numConjuncts = conjunctions.size();
  // assert numConjuncts >= 1;

  filterMinSelectivityEstimateFactor = PrelUtil.
          getPlannerSettings(cluster.getPlanner()).getFilterMinSelectivityEstimateFactor();
  filterMaxSelectivityEstimateFactor = PrelUtil.
          getPlannerSettings(cluster.getPlanner()).getFilterMaxSelectivityEstimateFactor();
}
 

@Deprecated // to be removed before 2.0
public LogicalTableModify(RelOptCluster cluster, RelOptTable table,
    CatalogReader schema, RelNode input, Operation operation,
    List<String> updateColumnList, boolean flattened) {
  this(cluster,
      cluster.traitSetOf(Convention.NONE),
      table,
      schema,
      input,
      operation,
      updateColumnList,
      null,
      flattened);
}
 

@Deprecated // to be removed before 2.0
public LogicalTableFunctionScan(
    RelOptCluster cluster,
    List<RelNode> inputs,
    RexNode rexCall,
    Type elementType, RelDataType rowType,
    Set<RelColumnMapping> columnMappings) {
  this(cluster, cluster.traitSetOf(Convention.NONE), inputs, rexCall,
      elementType, rowType, columnMappings);
}
 

/** Creates a LogicalTableFunctionScan. */
public static LogicalTableFunctionScan create(
    RelOptCluster cluster,
    List<RelNode> inputs,
    RexNode rexCall,
    Type elementType, RelDataType rowType,
    Set<RelColumnMapping> columnMappings) {
  final RelTraitSet traitSet = cluster.traitSetOf(Convention.NONE);
  return new LogicalTableFunctionScan(cluster, traitSet, inputs, rexCall,
      elementType, rowType, columnMappings);
}
 

/** Creates a LogicalCorrelate. */
public static LogicalCorrelate create(RelNode left, RelNode right,
    CorrelationId correlationId, ImmutableBitSet requiredColumns,
    SemiJoinType joinType) {
  final RelOptCluster cluster = left.getCluster();
  final RelTraitSet traitSet = cluster.traitSetOf(Convention.NONE);
  return new LogicalCorrelate(cluster, traitSet, left, right, correlationId,
      requiredColumns, joinType);
}
 

@Override public Match copy(RelNode input, RelDataType rowType,
    RexNode pattern, boolean strictStart, boolean strictEnd,
    Map<String, RexNode> patternDefinitions, Map<String, RexNode> measures,
    RexNode after, Map<String, ? extends SortedSet<String>> subsets,
    boolean allRows, List<RexNode> partitionKeys, RelCollation orderKeys,
    RexNode interval) {
  final RelTraitSet traitSet = getCluster().traitSetOf(Convention.NONE);
  return new LogicalMatch(getCluster(), traitSet,
      input,
      rowType,
      pattern, strictStart, strictEnd, patternDefinitions, measures,
      after, subsets, allRows, partitionKeys, orderKeys,
      interval);
}
 

private DrillAggregateRule() {
  super(
      RelOptHelper.some(LogicalAggregate.class,
          Convention.NONE, RelOptHelper.any(RelNode.class)),
      DrillRelFactories.LOGICAL_BUILDER,
      "DrillAggregateRule");
}
 

/**
 * Creates a LogicalSortExchange.
 *
 * @param input     Input relational expression
 * @param distribution Distribution specification
 * @param collation array of sort specifications
 */
public static LogicalSortExchange create(
    RelNode input,
    RelDistribution distribution,
    RelCollation collation) {
  RelOptCluster cluster = input.getCluster();
  collation = RelCollationTraitDef.INSTANCE.canonize(collation);
  distribution = RelDistributionTraitDef.INSTANCE.canonize(distribution);
  RelTraitSet traitSet =
      input.getTraitSet().replace(Convention.NONE).replace(distribution).replace(collation);
  return new LogicalSortExchange(cluster, traitSet, input, distribution,
      collation);
}
 

public static LogicalCalc create(final RelNode input,
    final RexProgram program) {
  final RelOptCluster cluster = input.getCluster();
  final RelMetadataQuery mq = cluster.getMetadataQuery();
  final RelTraitSet traitSet = cluster.traitSet()
      .replace(Convention.NONE)
      .replaceIfs(RelCollationTraitDef.INSTANCE,
          () -> RelMdCollation.calc(mq, input, program))
      .replaceIf(RelDistributionTraitDef.INSTANCE,
          () -> RelMdDistribution.calc(mq, input, program));
  return new LogicalCalc(cluster, traitSet, input, program);
}
 

@Deprecated // to be removed before 2.0
public LogicalFilter(
    RelOptCluster cluster,
    RelNode child,
    RexNode condition) {
  this(cluster, cluster.traitSetOf(Convention.NONE), child, condition,
      ImmutableSet.of());
}
 

/** Creates a LogicalFilter. */
public static LogicalFilter create(final RelNode input, RexNode condition,
    ImmutableSet<CorrelationId> variablesSet) {
  final RelOptCluster cluster = input.getCluster();
  final RelMetadataQuery mq = cluster.getMetadataQuery();
  final RelTraitSet traitSet = cluster.traitSetOf(Convention.NONE)
      .replaceIfs(RelCollationTraitDef.INSTANCE,
          () -> RelMdCollation.filter(mq, input))
      .replaceIf(RelDistributionTraitDef.INSTANCE,
          () -> RelMdDistribution.filter(mq, input));
  return new LogicalFilter(cluster, traitSet, input, condition, variablesSet);
}
 

@Deprecated // to be removed before 2.0
public LogicalJoin(RelOptCluster cluster, RelNode left, RelNode right,
    RexNode condition, JoinRelType joinType, Set<String> variablesStopped) {
  this(cluster, cluster.traitSetOf(Convention.NONE), left, right, condition,
      CorrelationId.setOf(variablesStopped), joinType, false,
      ImmutableList.of());
}
 

@Deprecated // to be removed before 2.0
public LogicalJoin(RelOptCluster cluster, RelNode left, RelNode right,
    RexNode condition, JoinRelType joinType, Set<String> variablesStopped,
    boolean semiJoinDone, ImmutableList<RelDataTypeField> systemFieldList) {
  this(cluster, cluster.traitSetOf(Convention.NONE), left, right, condition,
      CorrelationId.setOf(variablesStopped), joinType, semiJoinDone,
      systemFieldList);
}
 

/**
 * Creates a LogicalJoin by parsing serialized output.
 */
public LogicalJoin(RelInput input) {
  this(input.getCluster(), input.getCluster().traitSetOf(Convention.NONE),
      input.getInputs().get(0), input.getInputs().get(1),
      input.getExpression("condition"), ImmutableSet.of(),
      input.getEnum("joinType", JoinRelType.class), false,
      ImmutableList.of());
}
 

/** Creates a LogicalJoin, flagged with whether it has been translated to a
 * semi-join. */
public static LogicalJoin create(RelNode left, RelNode right,
    RexNode condition, Set<CorrelationId> variablesSet, JoinRelType joinType,
    boolean semiJoinDone, ImmutableList<RelDataTypeField> systemFieldList) {
  final RelOptCluster cluster = left.getCluster();
  final RelTraitSet traitSet = cluster.traitSetOf(Convention.NONE);
  return new LogicalJoin(cluster, traitSet, left, right, condition,
      variablesSet, joinType, semiJoinDone, systemFieldList);
}
 

/** Creates a LogicalSnapshot. */
public static LogicalSnapshot create(RelNode input, RexNode period) {
  final RelOptCluster cluster = input.getCluster();
  final RelMetadataQuery mq = cluster.getMetadataQuery();
  final RelTraitSet traitSet = cluster.traitSet()
      .replace(Convention.NONE)
      .replaceIfs(RelCollationTraitDef.INSTANCE,
          () -> RelMdCollation.snapshot(mq, input))
      .replaceIf(RelDistributionTraitDef.INSTANCE,
          () -> RelMdDistribution.snapshot(mq, input));
  return new LogicalSnapshot(cluster, traitSet, input, period);
}
 

@Deprecated // to be removed before 2.0
public LogicalValues(
    RelOptCluster cluster,
    RelDataType rowType,
    ImmutableList<ImmutableList<RexLiteral>> tuples) {
  this(cluster, cluster.traitSetOf(Convention.NONE), rowType, tuples);
}
 

/** Creates a LogicalValues. */
public static LogicalValues create(RelOptCluster cluster,
    final RelDataType rowType,
    final ImmutableList<ImmutableList<RexLiteral>> tuples) {
  final RelMetadataQuery mq = cluster.getMetadataQuery();
  final RelTraitSet traitSet = cluster.traitSetOf(Convention.NONE)
      .replaceIfs(RelCollationTraitDef.INSTANCE,
          () -> RelMdCollation.values(mq, rowType, tuples));
  return new LogicalValues(cluster, traitSet, rowType, tuples);
}
 

@Deprecated // to be removed before 2.0
public LogicalCorrelate(RelOptCluster cluster, RelNode left, RelNode right,
    CorrelationId correlationId,
    ImmutableBitSet requiredColumns, SemiJoinType joinType) {
  this(cluster, cluster.traitSetOf(Convention.NONE), left, right,
      correlationId, requiredColumns, joinType);
}
 

private DrillValuesRule() {
  super(RelOptHelper.any(LogicalValues.class, Convention.NONE),
      DrillRelFactories.LOGICAL_BUILDER, "DrillValuesRule");
}
 

public OLAPJoinRule() {
    super(LogicalJoin.class, Convention.NONE, OLAPRel.CONVENTION, "OLAPJoinRule");
}