VolcanoPlanner (Calcite Core 1.16.0 API)

java.lang.Object
- org.apache.calcite.plan.AbstractRelOptPlanner
- - org.apache.calcite.plan.volcano.VolcanoPlanner

All Implemented Interfaces:

RelOptPlanner
```
public class VolcanoPlanner
extends AbstractRelOptPlanner
```
VolcanoPlanner optimizes queries by transforming expressions selectively according to a dynamic programming algorithm.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`VolcanoPlanner.DeferringRuleCall` A rule call which defers its actions.
`(package private) static class`	`VolcanoPlanner.DirectProvenance` A RelNode that came directly from another RelNode via a copy.
`private static class`	`VolcanoPlanner.Provenance` Where a RelNode came from.
`(package private) static class`	`VolcanoPlanner.RuleProvenance` A RelNode that came via the firing of a rule.
`private static class`	`VolcanoPlanner.UnknownProvenance` We do not know where this RelNode came from.

Nested classes/interfaces inherited from interface org.apache.calcite.plan.RelOptPlanner
RelOptPlanner.CannotPlanException, RelOptPlanner.Executor

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) List<RelSet>`	`allSets` List of all sets.
`protected boolean`	`ambitious` If true, the planner keeps applying rules as long as they continue to reduce the cost.
`private com.google.common.collect.Multimap<Class<? extends RelNode>,RelOptRuleOperand>`	`classOperands` Operands that apply to a given class of `RelNode`.
`protected static double`	`COST_IMPROVEMENT`
`protected boolean`	`impatient` If true, and if `ambitious` is true, the planner waits a finite number of iterations for the cost to improve.
`private Map<List<String>,RelOptLattice>`	`latticeByName` Map of lattices by the qualified name of their star table.
`(package private) RelOptListener`	`listener` Listener for this planner, or null if none set.
`private boolean`	`locked` Whether the planner can accept new rules.
`private Map<Pair<String,RelDataType>,RelNode>`	`mapDigestToRel` Canonical map from `digest` to the unique `relational expression` with that digest.
`private IdentityHashMap<RelNode,RelSubset>`	`mapRel2Subset` Map each registered expression (`RelNode`) to its equivalence set (`RelSubset`).
`private List<RelOptMaterialization>`	`materializations`
`private int`	`nextSetId`
`private RelNode`	`originalRoot`
`private String`	`originalRootString` Dump of the root relational expression, as it was before any rules were applied.
`(package private) Map<RelNode,VolcanoPlanner.Provenance>`	`provenanceMap`
`private int`	`registerCount` Incremented every time a relational expression is registered or two sets are merged.
`private Set<RelOptSchema>`	`registeredSchemas` List of all schemas which have been registered.
`(package private) Map<RelNode,Double>`	`relImportances` The importance of relational expressions.
`protected RelSubset`	`root`
`private Deque<VolcanoRuleCall>`	`ruleCallStack`
`private com.google.common.collect.SetMultimap<String,Class>`	`ruleNames` Maps rule classes to their name, to ensure that the names are unique and conform to rules.
`(package private) RuleQueue`	`ruleQueue` Holds rule calls waiting to be fired.
`protected Set<RelOptRule>`	`ruleSet` Set of all registered rules.
`private List<RelTraitDef>`	`traitDefs` Holds the currently registered RelTraitDefs.
`private RelOptCost`	`zeroCost` Zero cost, according to `AbstractRelOptPlanner.costFactory`.

Fields inherited from class org.apache.calcite.plan.AbstractRelOptPlanner
context, costFactory

Fields inherited from interface org.apache.calcite.plan.RelOptPlanner
LOGGER

Constructor Summary

Constructors
Constructor and Description
`VolcanoPlanner()` Creates a uninitialized `VolcanoPlanner`.
`VolcanoPlanner(Context externalContext)` Creates a uninitialized `VolcanoPlanner`.
`VolcanoPlanner(RelOptCostFactory costFactory, Context externalContext)` Creates a `VolcanoPlanner` with a given cost factory.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addLattice(RelOptLattice lattice)` Defines a lattice.
`void`	`addListener(RelOptListener newListener)` Adds a listener to this planner.
`void`	`addMaterialization(RelOptMaterialization materialization)` Defines a pair of relational expressions that are equivalent.
`private RelSubset`	`addRelToSet(RelNode rel, RelSet set)`
`boolean`	`addRelTraitDef(RelTraitDef relTraitDef)` Registers a rel trait definition.
`boolean`	`addRule(RelOptRule rule)` Registers a rule.
`private RelSubset`	`canonize(RelSubset subset)` If a subset has one or more equivalent subsets (owing to a set having merged with another), returns the subset which is the leader of the equivalence class.
`RelNode`	`changeTraits(RelNode rel, RelTraitSet toTraits)` Changes a relational expression to an equivalent one with a different set of traits.
`(package private) RelNode`	`changeTraitsUsingConverters(RelNode rel, RelTraitSet toTraits)`
`private RelNode`	`changeTraitsUsingConverters(RelNode rel, RelTraitSet toTraits, boolean allowAbstractConverters)`
`(package private) void`	`checkForSatisfiedConverters(RelSet set, RelNode rel)`
`RelOptPlanner`	`chooseDelegate()` Negotiates an appropriate planner to deal with distributed queries.
`void`	`clear()` Removes all internal state, including all registered rules, materialized views, and lattices.
`private void`	`clearImportanceBoost()` Clear all importance boosts.
`void`	`clearRelTraitDefs()` Clear all the registered RelTraitDef.
`private RelNode`	`completeConversion(RelNode rel, boolean allowInfiniteCostConverters, RelTraitSet toTraits, Expressions.FluentList<RelTraitDef> usedTraits)` Converts traits using well-founded induction.
`void`	`dump(PrintWriter pw)` Dumps the internal state of this VolcanoPlanner to a writer.
`RelTraitSet`	`emptyTraitSet()` Creates an empty trait set.
`RelSubset`	`ensureRegistered(RelNode rel, RelNode equivRel)` Registers a relational expression if it is not already registered.
`void`	`ensureRegistered(RelNode rel, RelNode equivRel, VolcanoRuleCall ruleCall)`
`(package private) void`	`ensureRootConverters()` Ensures that the subset that is the root relational expression contains converters to all other subsets in its equivalence set.
`private static RelSet`	`equivRoot(RelSet s)`
`RelNode`	`findBestExp()` Finds the most efficient expression to implement the query given via `RelOptPlanner.setRoot(org.apache.calcite.rel.RelNode)`.
`(package private) void`	`fireRules(RelNode rel, boolean deferred)` Fires all rules matched by a relational expression.
`private boolean`	`fixUpInputs(RelNode rel)`
`private static RelSet`	`forward1(RelSet s, RelSet p)` Moves forward one link, checking for a cycle.
`private static RelSet`	`forward2(RelSet s, RelSet p)` Moves forward two links, checking for a cycle at each.
`RelOptCost`	`getCost(RelNode rel, RelMetadataQuery mq)` Computes the cost of a RelNode.
`RelOptLattice`	`getLattice(RelOptTable table)` Retrieves a lattice, given its star table.
`com.google.common.collect.ImmutableList<RelOptMaterialization>`	`getMaterializations()`
`protected VolcanoPlannerPhaseRuleMappingInitializer`	`getPhaseRuleMappingInitializer()`
`long`	`getRelMetadataTimestamp(RelNode rel)` Gets a timestamp for a given rel's metadata.
`List<RelTraitDef>`	`getRelTraitDefs()` Returns the list of active trait types.
`RelNode`	`getRoot()` Returns the root node of this query.
`List<RelOptRule>`	`getRules()` Returns the list of all registered rules.
`RelSet`	`getSet(RelNode rel)` Finds an expression's equivalence set.
`RelSubset`	`getSubset(RelNode rel)` Returns the subset that a relational expression belongs to.
`RelSubset`	`getSubset(RelNode rel, RelTraitSet traits)`
`RelSubset`	`getSubset(RelNode rel, RelTraitSet traits, boolean createIfMissing)`
`private void`	`injectImportanceBoost()` Finds RelSubsets in the plan that contain only rels of `Convention.NONE` and boosts their importance by 25%.
`boolean`	`isRegistered(RelNode rel)` Determines whether a relational expression has been registered.
`private static Pair<String,RelDataType>`	`key(RelNode rel)` Computes the key for `mapDigestToRel`.
`private RelSet`	`merge(RelSet set, RelSet set2)`
`static String`	`normalizePlan(String plan)` Normalizes references to subsets within the string representation of a plan.
`protected void`	`onNewClass(RelNode node)` Called when a new class of `RelNode` is seen.
`private String`	`provenance(RelNode root)` Returns a multi-line string describing the provenance of a tree of relational expressions.
`private void`	`provenanceRecurse(PrintWriter pw, RelNode node, int i, Set<RelNode> visited)` Helper for `provenance(org.apache.calcite.rel.RelNode)`.
`RelSubset`	`register(RelNode rel, RelNode equivRel)` Registers a relational expression in the expression bank.
`void`	`registerAbstractRelationalRules()`
`private RelSubset`	`registerImpl(RelNode rel, RelSet set)` Registers a new expression `exp` and queues up rule matches.
`private void`	`registerMaterializations()`
`void`	`registerMetadataProviders(List<RelMetadataProvider> list)` Gives this planner a chance to register one or more `RelMetadataProvider`s in the chain which will be used to answer metadata queries.
`private void`	`registerMetadataRels()` Informs `JaninoRelMetadataProvider` about the different kinds of `RelNode` that we will be dealing with.
`void`	`registerSchema(RelOptSchema schema)` Tells this planner that a schema exists.
`private RelSubset`	`registerSubset(RelSet set, RelSubset subset)`
`boolean`	`removeRule(RelOptRule rule)` Removes a rule.
`(package private) void`	`rename(RelNode rel)` Re-computes the digest of a `RelNode`.
`(package private) void`	`reregister(RelSet set, RelNode rel)` Registers a `RelNode`, which has already been registered, in a new `RelSet`.
`void`	`setImportance(RelNode rel, double importance)` Sets the importance of a relational expression.
`private void`	`setInitialImportance()`
`void`	`setLocked(boolean locked)` Sets whether this planner is locked.
`void`	`setRoot(RelNode rel)` Sets the root node of this query.
`protected void`	`validate()` Checks internal consistency.

Methods inherited from class org.apache.calcite.plan.AbstractRelOptPlanner
checkCancel, fireRule, getContext, getCost, getCostFactory, getExecutor, getListener, getRuleByDescription, isRuleExcluded, mapRuleDescription, notifyChosen, notifyDiscard, notifyEquivalence, notifyTransformation, onCopy, registerClass, setCancelFlag, setExecutor, setRuleDescExclusionFilter, subClasses, unmapRuleDescription

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - COST_IMPROVEMENT
```
protected static final double COST_IMPROVEMENT
```
    See Also:
    
    Constant Field Values
  - root
```
protected RelSubset root
```
  - ambitious
```
protected boolean ambitious
```
    If true, the planner keeps applying rules as long as they continue to reduce the cost. If false, the planner terminates as soon as it has found any implementation, no matter how expensive.
  - impatient
```
protected boolean impatient
```
    If true, and if ambitious is true, the planner waits a finite number of iterations for the cost to improve.
    The number of iterations K is equal to the number of iterations required to get the first finite plan. After the first finite plan, it continues to fire rules to try to improve it. The planner sets a target cost of the current best cost multiplied by COST_IMPROVEMENT. If it does not meet that cost target within K steps, it quits, and uses the current best plan. If it meets the cost, it sets a new, lower target, and has another K iterations to meet it. And so forth.
    If false, the planner continues to fire rules until the rule queue is empty.
  - classOperands
```
private final com.google.common.collect.Multimap<Class<? extends RelNode>,RelOptRuleOperand> classOperands
```
    Operands that apply to a given class of RelNode.
    Any operand can be an 'entry point' to a rule call, when a RelNode is registered which matches the operand. This map allows us to narrow down operands based on the class of the RelNode.
  - allSets
```
final List<RelSet> allSets
```
    List of all sets. Used only for debugging.
  - mapDigestToRel
```
private final Map<Pair<String,RelDataType>,RelNode> mapDigestToRel
```
    Canonical map from digest to the unique relational expression with that digest.
    Row type is part of the key for the rare occasion that similar expressions have different types, e.g. variants of Project(child=rel#1, a=null) where a is a null INTEGER or a null VARCHAR(10).
  - mapRel2Subset
```
private final IdentityHashMap<RelNode,RelSubset> mapRel2Subset
```
    Map each registered expression (RelNode) to its equivalence set (RelSubset).
    We use an IdentityHashMap to simplify the process of merging RelSet objects. Most RelNode objects are identified by their digest, which involves the set that their child relational expressions belong to. If those children belong to the same set, we have to be careful, otherwise it gets incestuous.
  - relImportances
```
final Map<RelNode,Double> relImportances
```
    The importance of relational expressions.
    The map contains only RelNodes whose importance has been overridden using RelOptPlanner.setImportance(RelNode, double). Other RelNodes are presumed to have 'normal' importance.
    If a RelNode has 0 importance, all RelOptRuleCalls using it are ignored, and future RelOptRuleCalls are not queued up.
  - registeredSchemas
```
private final Set<RelOptSchema> registeredSchemas
```
    List of all schemas which have been registered.
  - ruleQueue
```
final RuleQueue ruleQueue
```
    Holds rule calls waiting to be fired.
  - traitDefs
```
private final List<RelTraitDef> traitDefs
```
    Holds the currently registered RelTraitDefs.
  - ruleSet
```
protected final Set<RelOptRule> ruleSet
```
    Set of all registered rules.
  - nextSetId
```
private int nextSetId
```
  - registerCount
```
private int registerCount
```
    Incremented every time a relational expression is registered or two sets are merged. Tells us whether anything is going on.
  - listener
```
RelOptListener listener
```
    Listener for this planner, or null if none set.
  - originalRootString
```
private String originalRootString
```
    Dump of the root relational expression, as it was before any rules were applied. For debugging.
  - originalRoot
```
private RelNode originalRoot
```
  - locked
```
private boolean locked
```
    Whether the planner can accept new rules.
  - materializations
```
private final List<RelOptMaterialization> materializations
```
  - latticeByName
```
private final Map<List<String>,RelOptLattice> latticeByName
```
    Map of lattices by the qualified name of their star table.
  - provenanceMap
```
final Map<RelNode,VolcanoPlanner.Provenance> provenanceMap
```
  - ruleCallStack
```
private final Deque<VolcanoRuleCall> ruleCallStack
```
  - zeroCost
```
private final RelOptCost zeroCost
```
    Zero cost, according to AbstractRelOptPlanner.costFactory. Not necessarily a VolcanoCost.
  - ruleNames
```
private final com.google.common.collect.SetMultimap<String,Class> ruleNames
```
    Maps rule classes to their name, to ensure that the names are unique and conform to rules.
- Constructor Detail
  - VolcanoPlanner
```
public VolcanoPlanner()
```
    Creates a uninitialized VolcanoPlanner. To fully initialize it, the caller must register the desired set of relations, rules, and calling conventions.
  - VolcanoPlanner
```
public VolcanoPlanner(Context externalContext)
```
    Creates a uninitialized VolcanoPlanner. To fully initialize it, the caller must register the desired set of relations, rules, and calling conventions.
  - VolcanoPlanner
```
public VolcanoPlanner(RelOptCostFactory costFactory,
                      Context externalContext)
```
    Creates a VolcanoPlanner with a given cost factory.
- Method Detail
  - getPhaseRuleMappingInitializer
```
protected VolcanoPlannerPhaseRuleMappingInitializer getPhaseRuleMappingInitializer()
```
  - isRegistered
```
public boolean isRegistered(RelNode rel)
```
    Description copied from interface: RelOptPlanner
    
    Determines whether a relational expression has been registered.
    
    Parameters:
    
    rel - expression to test
    
    Returns:
    
    whether rel has been registered
  - setRoot
```
public void setRoot(RelNode rel)
```
    Description copied from interface: RelOptPlanner
    
    Sets the root node of this query.
    
    Parameters:
    
    rel - Relational expression
  - getRoot
```
public RelNode getRoot()
```
    Description copied from interface: RelOptPlanner
    
    Returns the root node of this query.
    
    Returns:
    
    Root node
  - getMaterializations
```
public com.google.common.collect.ImmutableList<RelOptMaterialization> getMaterializations()
```
  - addMaterialization
```
public void addMaterialization(RelOptMaterialization materialization)
```
    Description copied from interface: RelOptPlanner
    
    Defines a pair of relational expressions that are equivalent.
    Typically tableRel is a LogicalTableScan representing a table that is a materialized view and queryRel is the SQL expression that populates that view. The intention is that tableRel is cheaper to evaluate and therefore if the query being optimized uses (or can be rewritten to use) queryRel as a sub-expression then it can be optimized by using tableRel instead.
    
    Specified by:
    
    addMaterialization in interface RelOptPlanner
    
    Overrides:
    
    addMaterialization in class AbstractRelOptPlanner
  - addLattice
```
public void addLattice(RelOptLattice lattice)
```
    Description copied from interface: RelOptPlanner
    
    Defines a lattice.
    The lattice may have materializations; it is not necessary to call RelOptPlanner.addMaterialization(org.apache.calcite.plan.RelOptMaterialization) for these; they are registered implicitly.
    
    Specified by:
    
    addLattice in interface RelOptPlanner
    
    Overrides:
    
    addLattice in class AbstractRelOptPlanner
  - getLattice
```
public RelOptLattice getLattice(RelOptTable table)
```
    Description copied from interface: RelOptPlanner
    
    Retrieves a lattice, given its star table.
    
    Specified by:
    
    getLattice in interface RelOptPlanner
    
    Overrides:
    
    getLattice in class AbstractRelOptPlanner
  - registerMaterializations
```
private void registerMaterializations()
```
  - getSet
```
public RelSet getSet(RelNode rel)
```
    Finds an expression's equivalence set. If the expression is not registered, returns null.
    
    Parameters:
    
    rel - Relational expression
    
    Returns:
    
    Equivalence set that expression belongs to, or null if it is not registered
  - addRelTraitDef
```
public boolean addRelTraitDef(RelTraitDef relTraitDef)
```
    Description copied from interface: RelOptPlanner
    
    Registers a rel trait definition. If the RelTraitDef has already been registered, does nothing.
    
    Specified by:
    
    addRelTraitDef in interface RelOptPlanner
    
    Overrides:
    
    addRelTraitDef in class AbstractRelOptPlanner
    
    Returns:
    
    whether the RelTraitDef was added, as per Collection.add(E)
  - clearRelTraitDefs
```
public void clearRelTraitDefs()
```
    Description copied from interface: RelOptPlanner
    
    Clear all the registered RelTraitDef.
    
    Specified by:
    
    clearRelTraitDefs in interface RelOptPlanner
    
    Overrides:
    
    clearRelTraitDefs in class AbstractRelOptPlanner
  - getRelTraitDefs
```
public List<RelTraitDef> getRelTraitDefs()
```
    Description copied from interface: RelOptPlanner
    
    Returns the list of active trait types.
    
    Specified by:
    
    getRelTraitDefs in interface RelOptPlanner
    
    Overrides:
    
    getRelTraitDefs in class AbstractRelOptPlanner
  - emptyTraitSet
```
public RelTraitSet emptyTraitSet()
```
    Description copied from interface: RelOptPlanner
    
    Creates an empty trait set. It contains all registered traits, and the default values of any traits that have them.
    The empty trait set acts as the prototype (a kind of factory) for all subsequently created trait sets.
    
    Specified by:
    
    emptyTraitSet in interface RelOptPlanner
    
    Overrides:
    
    emptyTraitSet in class AbstractRelOptPlanner
    
    Returns:
    
    Empty trait set
  - clear
```
public void clear()
```
    Description copied from interface: RelOptPlanner
    
    Removes all internal state, including all registered rules, materialized views, and lattices.
    
    Specified by:
    
    clear in interface RelOptPlanner
    
    Overrides:
    
    clear in class AbstractRelOptPlanner
  - getRules
```
public List<RelOptRule> getRules()
```
    Description copied from interface: RelOptPlanner
    
    Returns the list of all registered rules.
  - addRule
```
public boolean addRule(RelOptRule rule)
```
    Description copied from interface: RelOptPlanner
    
    Registers a rule.
    If the rule has already been registered, does nothing. This method determines if the given rule is a ConverterRule and pass the ConverterRule to all registered RelTraitDef instances.
    
    Returns:
    
    whether the rule was added, as per Collection.add(E)
  - removeRule
```
public boolean removeRule(RelOptRule rule)
```
    Description copied from interface: RelOptPlanner
    
    Removes a rule.
    
    Returns:
    
    true if the rule was present, as per Collection.remove(Object)
  - onNewClass
```
protected void onNewClass(RelNode node)
```
    Description copied from class: AbstractRelOptPlanner
    
    Called when a new class of RelNode is seen.
    
    Overrides:
    
    onNewClass in class AbstractRelOptPlanner
  - changeTraits
```
public RelNode changeTraits(RelNode rel,
                            RelTraitSet toTraits)
```
    Description copied from interface: RelOptPlanner
    
    Changes a relational expression to an equivalent one with a different set of traits.
    
    Parameters:
    
    rel - Relational expression (may or may not have been registered; must not have the desired traits)
    
    toTraits - Trait set to convert the relational expression to
    
    Returns:
    
    Relational expression with desired traits. Never null, but may be abstract
  - chooseDelegate
```
public RelOptPlanner chooseDelegate()
```
    Description copied from interface: RelOptPlanner
    
    Negotiates an appropriate planner to deal with distributed queries. The idea is that the schemas decide among themselves which has the most knowledge. Right now, the local planner retains control.
    
    Specified by:
    
    chooseDelegate in interface RelOptPlanner
    
    Overrides:
    
    chooseDelegate in class AbstractRelOptPlanner
  - findBestExp
```
public RelNode findBestExp()
```
    Finds the most efficient expression to implement the query given via RelOptPlanner.setRoot(org.apache.calcite.rel.RelNode).
    The algorithm executes repeatedly in a series of phases. In each phase the exact rules that may be fired varies. The mapping of phases to rule sets is maintained in the ruleQueue.
    In each phase, the planner sets the initial importance of the existing RelSubSets (setInitialImportance()). The planner then iterates over the rule matches presented by the rule queue until:
    1. The rule queue becomes empty.
    2. For ambitious planners: No improvements to the plan have been made recently (specifically within a number of iterations that is 10% of the number of iterations necessary to first reach an implementable plan or 25 iterations whichever is larger).
    3. For non-ambitious planners: When an implementable plan is found.
    Furthermore, after every 10 iterations without an implementable plan, RelSubSets that contain only logical RelNodes are given an importance boost via injectImportanceBoost(). Once an implementable plan is found, the artificially raised importance values are cleared (see clearImportanceBoost()).
    Returns:
    
    the most efficient RelNode tree found for implementing the given query
  - registerMetadataRels
```
private void registerMetadataRels()
```
    Informs JaninoRelMetadataProvider about the different kinds of RelNode that we will be dealing with. It will reduce the number of times that we need to re-generate the provider.
  - ensureRootConverters
```
void ensureRootConverters()
```
    Ensures that the subset that is the root relational expression contains converters to all other subsets in its equivalence set.
    Thus the planner tries to find cheap implementations of those other subsets, which can then be converted to the root. This is the only place in the plan where explicit converters are required; elsewhere, a consumer will be asking for the result in a particular convention, but the root has no consumers.
  - provenance
```
private String provenance(RelNode root)
```
    Returns a multi-line string describing the provenance of a tree of relational expressions. For each node in the tree, prints the rule that created the node, if any. Recursively describes the provenance of the relational expressions that are the arguments to that rule.
    Thus, every relational expression and rule invocation that affected the final outcome is described in the provenance. This can be useful when finding the root cause of "mistakes" in a query plan.
    
    Parameters:
    
    root - Root relational expression in a tree
    
    Returns:
    
    Multi-line string describing the rules that created the tree
  - provenanceRecurse
```
private void provenanceRecurse(PrintWriter pw,
                               RelNode node,
                               int i,
                               Set<RelNode> visited)
```
    Helper for provenance(org.apache.calcite.rel.RelNode).
  - setInitialImportance
```
private void setInitialImportance()
```
  - injectImportanceBoost
```
private void injectImportanceBoost()
```
    Finds RelSubsets in the plan that contain only rels of Convention.NONE and boosts their importance by 25%.
  - clearImportanceBoost
```
private void clearImportanceBoost()
```
    Clear all importance boosts.
  - register
```
public RelSubset register(RelNode rel,
                          RelNode equivRel)
```
    Description copied from interface: RelOptPlanner
    
    Registers a relational expression in the expression bank.
    After it has been registered, you may not modify it.
    The expression must not already have been registered. If you are not sure whether it has been registered, call RelOptPlanner.ensureRegistered(RelNode, RelNode).
    
    Parameters:
    
    rel - Relational expression to register (must not already be registered)
    
    equivRel - Relational expression it is equivalent to (may be null)
    
    Returns:
    
    the same expression, or an equivalent existing expression
  - ensureRegistered
```
public RelSubset ensureRegistered(RelNode rel,
                                  RelNode equivRel)
```
    Description copied from interface: RelOptPlanner
    
    Registers a relational expression if it is not already registered.
    If equivRel is specified, rel is placed in the same equivalence set. It is OK if equivRel has different traits; rel will end up in a different subset of the same set.
    It is OK if rel is a subset.
    
    Parameters:
    
    rel - Relational expression to register
    
    equivRel - Relational expression it is equivalent to (may be null)
    
    Returns:
    
    Registered relational expression
  - validate
```
protected void validate()
```
    Checks internal consistency.
  - registerAbstractRelationalRules
```
public void registerAbstractRelationalRules()
```
  - registerSchema
```
public void registerSchema(RelOptSchema schema)
```
    Description copied from interface: RelOptPlanner
    
    Tells this planner that a schema exists. This is the schema's chance to tell the planner about all of the special transformation rules.
    
    Specified by:
    
    registerSchema in interface RelOptPlanner
    
    Overrides:
    
    registerSchema in class AbstractRelOptPlanner
  - getCost
```
public RelOptCost getCost(RelNode rel,
                          RelMetadataQuery mq)
```
    Description copied from interface: RelOptPlanner
    
    Computes the cost of a RelNode. In most cases, this just dispatches to RelMetadataQuery.getCumulativeCost(org.apache.calcite.rel.RelNode).
    
    Specified by:
    
    getCost in interface RelOptPlanner
    
    Overrides:
    
    getCost in class AbstractRelOptPlanner
    
    Parameters:
    
    rel - Relational expression of interest
    
    mq - Metadata query
    
    Returns:
    
    estimated cost
  - getSubset
```
public RelSubset getSubset(RelNode rel)
```
    Returns the subset that a relational expression belongs to.
    
    Parameters:
    
    rel - Relational expression
    
    Returns:
    
    Subset it belongs to, or null if it is not registered
  - getSubset
```
public RelSubset getSubset(RelNode rel,
                           RelTraitSet traits)
```
  - getSubset
```
public RelSubset getSubset(RelNode rel,
                           RelTraitSet traits,
                           boolean createIfMissing)
```
  - changeTraitsUsingConverters
```
private RelNode changeTraitsUsingConverters(RelNode rel,
                                            RelTraitSet toTraits,
                                            boolean allowAbstractConverters)
```
  - completeConversion
```
private RelNode completeConversion(RelNode rel,
                                   boolean allowInfiniteCostConverters,
                                   RelTraitSet toTraits,
                                   Expressions.FluentList<RelTraitDef> usedTraits)
```
    Converts traits using well-founded induction. We don't require that each conversion preserves all traits that have previously been converted, but if it changes "locked in" traits we'll try some other conversion.
    
    Parameters:
    
    rel - Relational expression
    
    allowInfiniteCostConverters - Whether to allow infinite converters
    
    toTraits - Target trait set
    
    usedTraits - Traits that have been locked in
    
    Returns:
    
    Converted relational expression
  - changeTraitsUsingConverters
```
RelNode changeTraitsUsingConverters(RelNode rel,
                                    RelTraitSet toTraits)
```
  - checkForSatisfiedConverters
```
void checkForSatisfiedConverters(RelSet set,
                                 RelNode rel)
```
  - setImportance
```
public void setImportance(RelNode rel,
                          double importance)
```
    Description copied from interface: RelOptPlanner
    
    Sets the importance of a relational expression.
    An important use of this method is when a RelOptRule has created a relational expression which is indisputably better than the original relational expression. The rule set the original relational expression's importance to zero, to reduce the search space. Pending rule calls are cancelled, and future rules will not fire.
    
    Specified by:
    
    setImportance in interface RelOptPlanner
    
    Overrides:
    
    setImportance in class AbstractRelOptPlanner
    
    Parameters:
    
    rel - Relational expression
    
    importance - Importance
  - dump
```
public void dump(PrintWriter pw)
```
    Dumps the internal state of this VolcanoPlanner to a writer.
    
    Parameters:
    
    pw - Print writer
    
    See Also:
    
    normalizePlan(String)
  - key
```
private static Pair<String,RelDataType> key(RelNode rel)
```
    Computes the key for mapDigestToRel.
  - rename
```
void rename(RelNode rel)
```
    Re-computes the digest of a RelNode.
    Since a relational expression's digest contains the identifiers of its children, this method needs to be called when the child has been renamed, for example if the child's set merges with another.
    
    Parameters:
    
    rel - Relational expression
  - reregister
```
void reregister(RelSet set,
                RelNode rel)
```
    Registers a RelNode, which has already been registered, in a new RelSet.
    
    Parameters:
    
    set - Set
    
    rel - Relational expression
  - canonize
```
private RelSubset canonize(RelSubset subset)
```
    If a subset has one or more equivalent subsets (owing to a set having merged with another), returns the subset which is the leader of the equivalence class.
    
    Parameters:
    
    subset - Subset
    
    Returns:
    
    Leader of subset's equivalence class
  - fireRules
```
void fireRules(RelNode rel,
               boolean deferred)
```
    Fires all rules matched by a relational expression.
    
    Parameters:
    
    rel - Relational expression which has just been created (or maybe from the queue)
    
    deferred - If true, each time a rule matches, just add an entry to the queue.
  - fixUpInputs
```
private boolean fixUpInputs(RelNode rel)
```
  - merge
```
private RelSet merge(RelSet set,
                     RelSet set2)
```
  - equivRoot
```
private static RelSet equivRoot(RelSet s)
```
  - forward2
```
private static RelSet forward2(RelSet s,
                               RelSet p)
```
    Moves forward two links, checking for a cycle at each.
  - forward1
```
private static RelSet forward1(RelSet s,
                               RelSet p)
```
    Moves forward one link, checking for a cycle.
  - registerImpl
```
private RelSubset registerImpl(RelNode rel,
                               RelSet set)
```
    Registers a new expression exp and queues up rule matches. If set is not null, makes the expression part of that equivalence set. If an identical expression is already registered, we don't need to register this one and nor should we queue up rule matches.
    
    Parameters:
    
    rel - relational expression to register. Must be either a RelSubset, or an unregistered RelNode
    
    set - set that rel belongs to, or null
    
    Returns:
    
    the equivalence-set
  - addRelToSet
```
private RelSubset addRelToSet(RelNode rel,
                              RelSet set)
```
  - registerSubset
```
private RelSubset registerSubset(RelSet set,
                                 RelSubset subset)
```
  - addListener
```
public void addListener(RelOptListener newListener)
```
    Description copied from interface: RelOptPlanner
    
    Adds a listener to this planner.
    
    Specified by:
    
    addListener in interface RelOptPlanner
    
    Overrides:
    
    addListener in class AbstractRelOptPlanner
    
    Parameters:
    
    newListener - new listener to be notified of events
  - registerMetadataProviders
```
public void registerMetadataProviders(List<RelMetadataProvider> list)
```
    Description copied from interface: RelOptPlanner
    
    Gives this planner a chance to register one or more RelMetadataProviders in the chain which will be used to answer metadata queries.
    Planners which use their own relational expressions internally to represent concepts such as equivalence classes will generally need to supply corresponding metadata providers.
    
    Specified by:
    
    registerMetadataProviders in interface RelOptPlanner
    
    Overrides:
    
    registerMetadataProviders in class AbstractRelOptPlanner
    
    Parameters:
    
    list - receives planner's custom providers, if any
  - getRelMetadataTimestamp
```
public long getRelMetadataTimestamp(RelNode rel)
```
    Description copied from interface: RelOptPlanner
    
    Gets a timestamp for a given rel's metadata. This timestamp is used by CachingRelMetadataProvider to decide whether cached metadata has gone stale.
    
    Specified by:
    
    getRelMetadataTimestamp in interface RelOptPlanner
    
    Overrides:
    
    getRelMetadataTimestamp in class AbstractRelOptPlanner
    
    Parameters:
    
    rel - rel of interest
    
    Returns:
    
    timestamp of last change which might affect metadata derivation
  - normalizePlan
```
public static String normalizePlan(String plan)
```
    Normalizes references to subsets within the string representation of a plan.
    This is useful when writing tests: it helps to ensure that tests don't break when an extra rule is introduced that generates a new subset and causes subsequent subset numbers to be off by one.
    For example,
    FennelAggRel.FENNEL_EXEC(child=Subset#17.FENNEL_EXEC,groupCount=1, EXPR$1=COUNT())
      FennelSortRel.FENNEL_EXEC(child=Subset#2.FENNEL_EXEC, key=[0], discardDuplicates=false)
        FennelCalcRel.FENNEL_EXEC( child=Subset#4.FENNEL_EXEC, expr#0..8={inputs}, expr#9=3456, DEPTNO=$t7, $f0=$t9)
          MockTableImplRel.FENNEL_EXEC( table=[CATALOG, SALES, EMP])
    
    becomes
    FennelAggRel.FENNEL_EXEC(child=Subset#{0}.FENNEL_EXEC, groupCount=1, EXPR$1=COUNT())
      FennelSortRel.FENNEL_EXEC(child=Subset#{1}.FENNEL_EXEC, key=[0], discardDuplicates=false)
        FennelCalcRel.FENNEL_EXEC( child=Subset#{2}.FENNEL_EXEC,expr#0..8={inputs},expr#9=3456,DEPTNO=$t7, $f0=$t9)
          MockTableImplRel.FENNEL_EXEC( table=[CATALOG, SALES, EMP])
    
    Parameters:
    
    plan - Plan
    
    Returns:
    
    Normalized plan
  - setLocked
```
public void setLocked(boolean locked)
```
    Sets whether this planner is locked. A locked planner does not accept new rules. addRule(org.apache.calcite.plan.RelOptRule) will do nothing and return false.
    
    Parameters:
    
    locked - Whether planner is locked
  - ensureRegistered
```
public void ensureRegistered(RelNode rel,
                             RelNode equivRel,
                             VolcanoRuleCall ruleCall)
```

Class VolcanoPlanner

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.calcite.plan.RelOptPlanner

Field Summary

Fields inherited from class org.apache.calcite.plan.AbstractRelOptPlanner

Fields inherited from interface org.apache.calcite.plan.RelOptPlanner

Constructor Summary

Method Summary

Methods inherited from class org.apache.calcite.plan.AbstractRelOptPlanner

Methods inherited from class java.lang.Object

Field Detail

COST_IMPROVEMENT

root

ambitious

impatient

classOperands

allSets

mapDigestToRel

mapRel2Subset

relImportances

registeredSchemas

ruleQueue

traitDefs

ruleSet

nextSetId

registerCount

listener

originalRootString

originalRoot

locked

materializations

latticeByName

provenanceMap

ruleCallStack

zeroCost

ruleNames

Constructor Detail

VolcanoPlanner

VolcanoPlanner

VolcanoPlanner

Method Detail

getPhaseRuleMappingInitializer

isRegistered

setRoot

getRoot

getMaterializations

addMaterialization

addLattice

getLattice

registerMaterializations

getSet

addRelTraitDef

clearRelTraitDefs

getRelTraitDefs

emptyTraitSet

clear

getRules

addRule

removeRule

onNewClass

changeTraits

chooseDelegate

findBestExp

registerMetadataRels

ensureRootConverters

provenance

provenanceRecurse

setInitialImportance

injectImportanceBoost

clearImportanceBoost

register

ensureRegistered

validate

registerAbstractRelationalRules

registerSchema

getCost

getSubset

getSubset

getSubset

changeTraitsUsingConverters