return; RelTraitSet newTraits = call.getPlanner().emptyTraitSet();
public RelTraitSet getEmptyTraitSet() { return planner.emptyTraitSet(); }
public RelTraitSet getEmptyTraitSet() { return planner.emptyTraitSet(); }
/** Returns the default trait set for this cluster. */ public RelTraitSet traitSet() { return getPlanner().emptyTraitSet(); }
public RelTraitSet newTraitSet(RelTrait... traits) { RelTraitSet set = call.getPlanner().emptyTraitSet(); for (RelTrait t : traits) { set = set.plus(t); } return set; }
public RelTraitSet newTraitSet(RelTrait... traits) { RelTraitSet set = call.getPlanner().emptyTraitSet(); for (RelTrait t : traits) { set = set.plus(t); } return set; }
/** * Creates a cluster. * * <p>For use only from {@link #create} and {@link RelOptQuery}. */ RelOptCluster(RelOptPlanner planner, RelDataTypeFactory typeFactory, RexBuilder rexBuilder, AtomicInteger nextCorrel, Map<String, RelNode> mapCorrelToRel) { this.nextCorrel = nextCorrel; this.mapCorrelToRel = mapCorrelToRel; this.planner = Objects.requireNonNull(planner); this.typeFactory = Objects.requireNonNull(typeFactory); this.rexBuilder = rexBuilder; this.originalExpression = rexBuilder.makeLiteral("?"); // set up a default rel metadata provider, // giving the planner first crack at everything setMetadataProvider(DefaultRelMetadataProvider.INSTANCE); this.emptyTraitSet = planner.emptyTraitSet(); assert emptyTraitSet.size() == planner.getRelTraitDefs().size(); }
/** * Creates a cluster. * * <p>For use only from {@link #create} and {@link RelOptQuery}. */ RelOptCluster(RelOptPlanner planner, RelDataTypeFactory typeFactory, RexBuilder rexBuilder, AtomicInteger nextCorrel, Map<String, RelNode> mapCorrelToRel) { this.nextCorrel = nextCorrel; this.mapCorrelToRel = mapCorrelToRel; this.planner = Objects.requireNonNull(planner); this.typeFactory = Objects.requireNonNull(typeFactory); this.rexBuilder = rexBuilder; this.originalExpression = rexBuilder.makeLiteral("?"); // set up a default rel metadata provider, // giving the planner first crack at everything setMetadataProvider(DefaultRelMetadataProvider.INSTANCE); this.emptyTraitSet = planner.emptyTraitSet(); assert emptyTraitSet.size() == planner.getRelTraitDefs().size(); }
public static RelTraitSet removeCollation(RelTraitSet traitSet, RelOptRuleCall call) { RelTraitSet newTraitSet = call.getPlanner().emptyTraitSet(); for (RelTrait trait: traitSet) { if (!trait.getTraitDef().getTraitClass().equals(RelCollation.class)) { newTraitSet = newTraitSet.plus(trait); } } return newTraitSet; } }
private static RelNode toPhysicalPlan(RelNode root, RuleSet rules) { Program program = Programs.of(rules); RelOptPlanner plan = root.getCluster().getPlanner(); RelTraitSet traits = plan.emptyTraitSet().replace(EnumerableConvention.INSTANCE); return program.run(plan, root, traits, ImmutableList.<RelOptMaterialization>of(), ImmutableList.<RelOptLattice>of()); }
public RelTraitSet newTraitSet(RelTrait... traits) { RelTraitSet set = indexContext.getCall().getPlanner().emptyTraitSet(); for (RelTrait t : traits) { if(t != null) { set = set.plus(t); } } return set; }
@Override public void onMatch(RelOptRuleCall call) { final UnionRel union = (UnionRel) call.rel(0); final List<RelNode> inputs = union.getInputs(); List<RelNode> convertedInputList = Lists.newArrayList(); RelTraitSet traits = call.getPlanner().emptyTraitSet().plus(Prel.PHYSICAL); try { for (int i = 0; i < inputs.size(); i++) { RelNode convertedInput = convert(inputs.get(i), PrelUtil.fixTraits(call, traits)); convertedInputList.add(convertedInput); } traits = call.getPlanner().emptyTraitSet().plus(Prel.PHYSICAL).plus(DistributionTrait.SINGLETON); UnionDistinctPrel unionDistinct = new UnionDistinctPrel(union.getCluster(), traits, convertedInputList, false /* compatibility already checked during logical phase */); call.transformTo(unionDistinct); } catch (InvalidRelException e) { tracer.warn(e.toString()); } }
private RelNode transformToDruidPlan(RelNode root) { RelOptPlanner plan = root.getCluster().getPlanner(); final RelVisitor visitor = new RelVisitor() { @Override public void visit(RelNode node, int ordinal, RelNode parent) { if (node instanceof TableScan) { final RelOptCluster cluster = node.getCluster(); final RelOptTable.ToRelContext context = RelOptUtil.getContext(cluster); final RelNode r = node.getTable().toRel(context); plan.registerClass(r); } super.visit(node, ordinal, parent); } }; visitor.go(root); Program program = Programs.standard(); RelTraitSet traits = plan.emptyTraitSet().replace(EnumerableConvention.INSTANCE); return program.run(plan, root, traits, ImmutableList.<RelOptMaterialization>of(), ImmutableList.<RelOptLattice>of()); }
final RelDataType rowTypeWithPCComp = RexUtil.createStructType(cluster.getTypeFactory(), exprs, fieldNames); final ProjectPrel projectUnderWriter = new ProjectAllowDupPrel(cluster, cluster.getPlanner().emptyTraitSet().plus(Prel.PHYSICAL), input, exprs, rowTypeWithPCComp); return projectUnderWriter;
@Override public RelNode convert( RelOptPlanner planner, RelNode rel, DistributionTrait toDist, boolean allowInfiniteCostConverters) { switch(toDist.getType()){ // UnionExchange, HashToRandomExchange, OrderedPartitionExchange and BroadcastExchange destroy the ordering property, // therefore RelCollation is set to default, which is EMPTY. case SINGLETON: return new UnionExchangePrel(rel.getCluster(), planner.emptyTraitSet().plus(Prel.PHYSICAL).plus(toDist), rel); case HASH_DISTRIBUTED: return new HashToRandomExchangePrel(rel.getCluster(), planner.emptyTraitSet().plus(Prel.PHYSICAL).plus(toDist), rel, toDist.getFields()); case RANGE_DISTRIBUTED: return new OrderedPartitionExchangePrel(rel.getCluster(), planner.emptyTraitSet().plus(Prel.PHYSICAL).plus(toDist), rel); case BROADCAST_DISTRIBUTED: return new BroadcastExchangePrel(rel.getCluster(), planner.emptyTraitSet().plus(Prel.PHYSICAL).plus(toDist), rel); case ROUND_ROBIN_DISTRIBUTED: return new RoundRobinExchangePrel(rel.getCluster(), planner.emptyTraitSet().plus(Prel.PHYSICAL).plus(toDist), rel); case ANY: // If target is "any", any input would satisfy "any". Return input directly. return rel; default: return null; } }
@Override public void onMatch(RelOptRuleCall call) { final DrillUnionRel union = call.rel(0); final List<RelNode> inputs = union.getInputs(); List<RelNode> convertedInputList = Lists.newArrayList(); RelTraitSet traits = call.getPlanner().emptyTraitSet().plus(Prel.DRILL_PHYSICAL); try { for (RelNode input : inputs) { RelNode convertedInput = convert(input, PrelUtil.fixTraits(call, traits)); convertedInputList.add(convertedInput); } traits = call.getPlanner().emptyTraitSet().plus(Prel.DRILL_PHYSICAL).plus(DrillDistributionTrait.SINGLETON); UnionDistinctPrel unionDistinct = new UnionDistinctPrel(union.getCluster(), traits, convertedInputList, false /* compatibility already checked during logical phase */); call.transformTo(unionDistinct); } catch (InvalidRelException e) { tracer.warn(e.toString()); } }
if (aggregate.getGroupSet().isEmpty()) { DrillDistributionTrait singleDist = DrillDistributionTrait.SINGLETON; traits = call.getPlanner().emptyTraitSet().plus(Prel.DRILL_PHYSICAL).plus(singleDist); createTransformRequest(call, aggregate, input, traits); } else { ImmutableList.copyOf(getDistributionField(aggregate, true /* get all grouping keys */))); traits = call.getPlanner().emptyTraitSet().plus(Prel.DRILL_PHYSICAL).plus(distOnAllKeys); createTransformRequest(call, aggregate, input, traits); ImmutableList.copyOf(getDistributionField(aggregate, false /* get single grouping key */))); traits = call.getPlanner().emptyTraitSet().plus(Prel.DRILL_PHYSICAL).plus(distOnOneKey); createTransformRequest(call, aggregate, input, traits); traits = call.getPlanner().emptyTraitSet().plus(Prel.DRILL_PHYSICAL);
public void onMatch(RelOptRuleCall call) { RelTraitSet empty = call.getPlanner().emptyTraitSet(); LogicalAggregate rel = call.rel(0); assert rel.getGroupSet().cardinality() == 1; int aggIndex = rel.getGroupSet().iterator().next(); RelTrait collation = RelCollations.of( new RelFieldCollation(aggIndex, RelFieldCollation.Direction.ASCENDING, RelFieldCollation.NullDirection.FIRST)); RelTraitSet desiredTraits = empty.replace(PHYSICAL).replace(collation); RelNode convertedInput = convert(rel.getInput(), desiredTraits); call.transformTo( new PhysAgg(rel.getCluster(), empty.replace(PHYSICAL), convertedInput, rel.indicator, rel.getGroupSet(), rel.getGroupSets(), rel.getAggCallList())); } }
public void onMatch(RelOptRuleCall call) { RelTraitSet empty = call.getPlanner().emptyTraitSet(); LogicalAggregate rel = call.rel(0); assert rel.getGroupSet().cardinality() == 1; int aggIndex = rel.getGroupSet().iterator().next(); RelTrait collation = RelCollations.of( new RelFieldCollation(aggIndex, RelFieldCollation.Direction.ASCENDING, RelFieldCollation.NullDirection.FIRST)); RelTraitSet desiredTraits = empty.replace(PHYSICAL).replace(collation); RelNode convertedInput = convert(rel.getInput(), desiredTraits); call.transformTo( new PhysAgg(rel.getCluster(), empty.replace(PHYSICAL), convertedInput, rel.indicator, rel.getGroupSet(), rel.getGroupSets(), rel.getAggCallList())); } }
return; RelTraitSet newTraits = call.getPlanner().emptyTraitSet();