Java Convention.NONE属性代码示例

@Override
public boolean matches(RelOptRuleCall call) {
  Project topProject = call.rel(0);
  Project bottomProject = call.rel(1);

  // Make sure both projects be LogicalProject.
  if (topProject.getTraitSet().getTrait(ConventionTraitDef.INSTANCE) != Convention.NONE ||
      bottomProject.getTraitSet().getTrait(ConventionTraitDef.INSTANCE) != Convention.NONE) {
    return false;
  }

  // We have a complex output type do not fire the merge project rule
  if (checkComplexOutput(topProject) || checkComplexOutput(bottomProject)) {
    return false;
  }

  return true;
}
 

public void onMatch(RelOptRuleCall call) {
  LogicalProject rel = call.rel(0);
  RelNode rawInput = call.rel(1);
  RelNode input = convert(rawInput, PHYSICAL);

  if (subsetHack && input instanceof RelSubset) {
    RelSubset subset = (RelSubset) input;
    for (RelNode child : subset.getRels()) {
      // skip logical nodes
      if (child.getTraitSet().getTrait(ConventionTraitDef.INSTANCE)
          == Convention.NONE) {
        continue;
      } else {
        RelTraitSet outcome = child.getTraitSet().replace(PHYSICAL);
        call.transformTo(
            new PhysProj(rel.getCluster(), outcome, convert(child, outcome),
                rel.getChildExps(), rel.getRowType()));
      }
    }
  } else {
    call.transformTo(
        PhysProj.create(input, rel.getChildExps(), rel.getRowType()));
  }

}
 

/**
 * 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);
}
 

@Override
public T read(final Kryo kryo, final Input input, final Class<T> type) {
  final boolean isNone = kryo.readObject(input, Boolean.class);
  if (isNone) {
    return (T)Convention.NONE;
  }
  final T result = super.read(kryo, input, type);
  final T normalized = (T) result.getTraitDef().canonize(result);
  kryo.reference(normalized);
  return normalized;
}
 

@Override
public boolean matches(RelOptRuleCall call) {
  Project topProject = call.rel(0);
  Project bottomProject = call.rel(1);

  if (topProject.getConvention() != Convention.NONE || bottomProject.getConvention() != Convention.NONE) {
    return false;
  }

  return true;
}
 

@Override
public boolean matches(RelOptRuleCall call) {
  OldScanCrel logicalScan = call.rel(0);
  // Plugins can be null for certain group scans (I believe Direct Group Scan is one of them)
  return logicalScan.getGroupScan().getStoragePluginConvention() == null
      || logicalScan.getGroupScan().getStoragePluginConvention() == Convention.NONE;
}
 

@Override
public Convention getStoragePluginConvention() {
  // Since people seem to not like null, adding Convention.NONE, although it really should be null.
  // Not all storage plugins bring in their own conventions, so it should not be tied to a convention.
  // So for now, we will use Convention.NONE as it does not bring its own convention.
  return Convention.NONE;
}
 

private JdbcTableModificationRule(JdbcConvention out) {
    super(
            LogicalTableModify.class,
            Convention.NONE,
            out,
            "JdbcTableModificationRule");
}
 

<R extends RelNode> CassandraConverterRule(Class<R> clazz,
    Predicate<? super R> predicate,
    String description) {
  super(clazz, predicate, Convention.NONE,
      CassandraRel.CONVENTION, RelFactories.LOGICAL_BUILDER, description);
  this.out = CassandraRel.CONVENTION;
}
 

EnumerableJoinRule() {
  super(
      LogicalJoin.class,
      Convention.NONE,
      EnumerableConvention.INSTANCE,
      "EnumerableJoinRule");
}
 

public DrillJdbcProjectRule(JdbcConvention out) {
  super(LogicalProject.class, Convention.NONE, out, "JdbcProjectRule");
}
 

public DrillJdbcFilterRule(JdbcConvention out) {
  super(LogicalFilter.class, Convention.NONE, out, "DrillJdbcFilterRule");
}
 

public SourceLogicalConverter(StoragePluginType pluginType) {
  super(ScanCrel.class, Convention.NONE, Rel.LOGICAL, pluginType.generateRuleName("LogicalScanConverter"));
  this.pluginType = pluginType;
}
 

private BeamSortRule() {
  super(LogicalSort.class, Convention.NONE,
      BeamLogicalConvention.INSTANCE, "BeamSortRule");
}
 

private BeamValuesRule() {
  super(LogicalValues.class, Convention.NONE,
      BeamLogicalConvention.INSTANCE, "BeamValuesRule");
}