final VolcanoPlanner planner = new VolcanoPlanner(); planner.addRelTraitDef(ConventionTraitDef.instance); if (ENABLE_COLLATION_TRAIT) { planner.addRelTraitDef(RelCollationTraitDef.INSTANCE); planner.registerAbstractRelationalRules(); planner.addRule(JavaRules.ENUMERABLE_JOIN_RULE); planner.addRule(JavaRules.ENUMERABLE_CALC_RULE); planner.addRule(JavaRules.ENUMERABLE_AGGREGATE_RULE); planner.addRule(JavaRules.ENUMERABLE_SORT_RULE); planner.addRule(JavaRules.ENUMERABLE_LIMIT_RULE); planner.addRule(JavaRules.ENUMERABLE_UNION_RULE); planner.addRule(JavaRules.ENUMERABLE_INTERSECT_RULE); planner.addRule(JavaRules.ENUMERABLE_MINUS_RULE); planner.addRule(JavaRules.ENUMERABLE_TABLE_MODIFICATION_RULE); planner.addRule(JavaRules.ENUMERABLE_VALUES_RULE); planner.addRule(JavaRules.ENUMERABLE_WINDOW_RULE); planner.addRule(JavaRules.ENUMERABLE_ONE_ROW_RULE); planner.addRule(TableAccessRule.instance); planner.addRule(PushFilterPastProjectRule.instance); planner.addRule(PushFilterPastJoinRule.instance); planner.addRule(RemoveDistinctAggregateRule.instance); planner.addRule(ReduceAggregatesRule.instance); planner.addRule(SwapJoinRule.instance); planner.addRule(WindowedAggSplitterRule.INSTANCE); return planner;
private void dump(PrintWriter pw) { planner.dump(pw); pw.print("Importances: {"); final RelSubset[] subsets = subsetImportances.keySet().toArray( new RelSubset[subsetImportances.keySet().size()]); Arrays.sort(subsets, relImportanceComparator); for (RelSubset subset : subsets) { pw.print( " " + subset.toString() + "=" + subsetImportances.get(subset)); } pw.println("}"); }
/** * Registers a {@link RelNode}, which has already been registered, in a new * {@link RelSet}. * * @param set Set * @param rel Relational expression */ void reregister( RelSet set, RelNode rel) { // Is there an equivalent relational expression? (This might have // just occurred because the relational expression's child was just // found to be equivalent to another set.) final Pair<String, RelDataType> key = key(rel); RelNode equivRel = mapDigestToRel.get(key); if (equivRel != null && equivRel != rel) { assert equivRel.getClass() == rel.getClass(); assert equivRel.getTraitSet().equals(rel.getTraitSet()); RelSubset equivRelSubset = getSubset(equivRel); ruleQueue.recompute(equivRelSubset, true); return; } // Add the relational expression into the correct set and subset. RelSubset subset2 = asd(rel, set); }
/** * Creates a simple planner that can plan "select * from myTable" but not * much more. */ protected RelOptPlanner createTapPlanner() { final VolcanoPlanner planner = new VolcanoPlanner(); planner.addRelTraitDef( Cascading.CONVENTION.getTraitDef() ); planner.addRelTraitDef( ConventionTraitDef.instance ); planner.addRule( TableAccessRule.instance ); planner.addRule( JavaRules.ENUMERABLE_CALC_RULE ); planner.addRule( ProjectToCalcRule.instance ); planner.addRule( EnumerableTapRule.INSTANCE ); planner.setLocked( true ); // prevent further rules being added return planner; } }
void checkForSatisfiedConverters( RelSet set, RelNode rel) { int i = 0; while (i < set.abstractConverters.size()) { AbstractConverter converter = set.abstractConverters.get(i); RelNode converted = changeTraitsUsingConverters( rel, converter.getTraitSet()); if (converted == null) { i++; // couldn't convert this; move on to the next } else { if (!isRegistered(converted)) { registerImpl(converted, set); } set.abstractConverters.remove(converter); // success } } }
/** * Tests transformation of a leaf from NONE to PHYS. */ @Test public void testTransformLeaf() { VolcanoPlanner planner = new VolcanoPlanner(); planner.addRelTraitDef(ConventionTraitDef.instance); planner.addRule(new PhysLeafRule()); RelOptCluster cluster = newCluster(planner); NoneLeafRel leafRel = new NoneLeafRel( cluster, "a"); RelNode convertedRel = planner.changeTraits( leafRel, cluster.traitSetOf(PHYS_CALLING_CONVENTION)); planner.setRoot(convertedRel); RelNode result = planner.chooseDelegate().findBestExp(); assertTrue(result instanceof PhysLeafRel); }
RelNode rel, RelSet set) { assert (rel instanceof RelSubset) || !isRegistered(rel) : "pre: rel instanceof RelSubset || !isRegistered(rel)" + " : {rel=" + rel + "}"; if (rel instanceof RelSubset) { return registerSubset(set, (RelSubset) rel); Pair<String, RelDataType> key = key(rel); RelNode equivExp = mapDigestToRel.get(key); if (equivExp == null) { return getSubset(rel); } else { assert equivExp.getTraitSet().equals(traits) "right", rel.getRowType(), true); RelSet equivSet = getSet(equivExp); if (equivSet != null) { if (LOGGER.isLoggable(Level.FINER)) { return registerSubset(set, getSubset(equivExp)); final RelSet childSet = getSet(input); if ((set != null) && (set != childSet) merge(set, childSet);
useApplicableMaterializations(); int cumulativeTicks = 0; for (VolcanoPlannerPhase phase : VolcanoPlannerPhase.values()) { setInitialImportance(); firstFiniteTick = cumulativeTicks; clearImportanceBoost(); injectImportanceBoost(); root = canonize(root); StringWriter sw = new StringWriter(); final PrintWriter pw = new PrintWriter(sw); dump(pw); pw.flush(); LOGGER.finer(sw.toString()); + provenance(cheapest));
useApplicableMaterializations(); int cumulativeTicks = 0; for (VolcanoPlannerPhase phase : VolcanoPlannerPhase.values()) { setInitialImportance(); RelOptCost targetCost = makeHugeCost(); int tick = 0; int firstFiniteTick = -1; firstFiniteTick = cumulativeTicks; clearImportanceBoost(); injectImportanceBoost(); root = canonize(root); StringWriter sw = new StringWriter(); final PrintWriter pw = new PrintWriter(sw); dump(pw); pw.flush(); tracer.finer(sw.toString());
volcanoPlanner.checkCancel(); try { if (volcanoPlanner.isRuleExcluded(getRule())) { if (LOGGER.isLoggable(Level.FINE)) { LOGGER.fine( RelSubset subset = volcanoPlanner.getSubset(rel);
public void registerAbstractRelationalRules() { addRule(AbstractConverter.ExpandConversionRule.instance); addRule(SwapJoinRule.instance); addRule(RemoveDistinctRule.instance); addRule(UnionToDistinctRule.instance); addRule(RemoveTrivialProjectRule.instance); addRule(RemoveTrivialCalcRule.instance); addRule(RemoveSortRule.INSTANCE); // todo: rule which makes Project({OrdinalRef}) disappear }
/** * Registers a {@link RelNode}, which has already been registered, in a new * {@link RelSet}. * * @param set Set * @param rel Relational expression */ void reregister( RelSet set, RelNode rel) { // Is there an equivalent relational expression? (This might have // just occurred because the relational expression's child was just // found to be equivalent to another set.) RelNode equivRel = mapDigestToRel.get(rel.getDigest()); if ((equivRel != null) && (equivRel != rel)) { assert (equivRel.getClass() == rel.getClass()); assert (equivRel.getTraitSet().equals(rel.getTraitSet())); RelSubset equivRelSubset = getSubset(equivRel); ruleQueue.recompute(equivRelSubset, true); return; } // Add the relational expression into the correct set and subset. RelSubset subset2 = asd(rel, set); }
RelNode changeTraitsUsingConverters( RelNode rel, RelTraitSet toTraits) { return changeTraitsUsingConverters(rel, toTraits, false); }
private boolean fixUpInputs(RelNode rel) { List<RelNode> inputs = rel.getInputs(); int i = -1; int changeCount = 0; for (RelNode input : inputs) { ++i; if (input instanceof RelSubset) { final RelSubset subset = (RelSubset) input; RelSubset newSubset = canonize(subset); if (newSubset != subset) { rel.replaceInput(i, newSubset); if (subset.set != newSubset.set) { subset.set.parents.remove(rel); newSubset.set.parents.add(rel); } changeCount++; } } } return changeCount > 0; }
/** * Tests transformation of a leaf from NONE to PHYS. */ @Test public void testTransformLeaf() { VolcanoPlanner planner = new VolcanoPlanner(); planner.addRelTraitDef(ConventionTraitDef.INSTANCE); planner.addRule(new PhysLeafRule()); RelOptCluster cluster = newCluster(planner); NoneLeafRel leafRel = new NoneLeafRel( cluster, "a"); RelNode convertedRel = planner.changeTraits( leafRel, cluster.traitSetOf(PHYS_CALLING_CONVENTION)); planner.setRoot(convertedRel); RelNode result = planner.chooseDelegate().findBestExp(); assertTrue(result instanceof PhysLeafRel); }
assert (rel instanceof RelSubset) || !isRegistered(rel) : "pre: rel instanceof RelSubset || !isRegistered(rel)" + " : {rel=" + rel + "}"; if (rel instanceof RelSubset) { return registerSubset(set, (RelSubset) rel); return getSubset(rel); } else { assert (equivExp.getTraitSet().equals(traits) "right", rel.getRowType(), true); RelSet equivSet = getSet(equivExp); if (equivSet != null) { if (tracer.isLoggable(Level.FINER)) { return registerSubset( set, getSubset(equivExp)); final RelSet childSet = getSet(input); if ((set != null) && (set != childSet) merge(set, childSet); registerCount++; if (fixUpInputs(rel)) { digest = rel.recomputeDigest();
void checkForSatisfiedConverters( RelSet set, RelNode rel) { int i = 0; while (i < set.abstractConverters.size()) { AbstractConverter converter = set.abstractConverters.get(i); RelNode converted = changeTraitsUsingConverters( rel, converter.getTraitSet()); if (converted == null) { i++; // couldn't convert this; move on to the next } else { if (!isRegistered(converted)) { registerImpl(converted, set); } set.abstractConverters.remove(converter); // success } } }
volcanoPlanner.checkCancel(); try { if (volcanoPlanner.isRuleExcluded(getRule())) { if (tracer.isLoggable(Level.FINE)) { tracer.fine( RelSubset subset = volcanoPlanner.getSubset(rel);
public void registerAbstractRelationalRules() { addRule(PushFilterPastJoinRule.FILTER_ON_JOIN); addRule(PushFilterPastJoinRule.JOIN); addRule(AbstractConverter.ExpandConversionRule.INSTANCE); addRule(SwapJoinRule.INSTANCE); addRule(SemiJoinRule.INSTANCE); if (OptiqPrepareImpl.COMMUTE) { addRule(CommutativeJoinRule.INSTANCE); } addRule(RemoveDistinctRule.INSTANCE); addRule(UnionToDistinctRule.INSTANCE); addRule(RemoveTrivialProjectRule.INSTANCE); addRule(RemoveTrivialCalcRule.INSTANCE); addRule(RemoveSortRule.INSTANCE); // todo: rule which makes Project({OrdinalRef}) disappear }
RelNode changeTraitsUsingConverters( RelNode rel, RelTraitSet toTraits) { return changeTraitsUsingConverters(rel, toTraits, false); }