| Modifier and Type | Field and Description |
|---|---|
| private JBitSet | |
| private CostEstimateImpl | |
| private int[] | |
| private boolean | |
| private RowOrdering | |
| private CostEstimateImpl | |
| private OptimizerPlan | |
| private RowOrdering | |
| private CostEstimateImpl | |
| private long | |
| private DataDictionary | |
| private boolean | |
| private CostEstimate | |
| private int[] | |
| private boolean | |
| private int | |
| private JoinStrategy[] | |
| private static final int | |
| private LanguageConnectionContext | |
| private int | |
| private static final int | |
| private JBitSet | |
| private boolean | |
| private int | |
| private int | |
| private OptimizableList | |
| private CostEstimateImpl | |
| private OptimizerPlan | |
| private int | |
| private OptimizablePredicateList | |
| private int[] | |
| private static final int | |
| private boolean | |
| private RequiredRowOrdering | |
| private boolean | |
| private HashMap | |
| private CostEstimate | |
| private int | |
| private boolean | |
| private double | |
| private long | |
| private boolean | |
| private boolean | |
| private static final int | |
| private static final int |
| Access | Constructor and Description |
|---|---|
| pack-priv | OptimizerImpl(OptimizableList optimizableList, OptimizablePredicateList predicateList, DataDictionary dDictionary, boolean ruleBasedOptimization, boolean noTimeout, boolean useStatistics, int maxMemoryPerTable, JoinStrategy[] joinStrategies, int tableLockThreshold, RequiredRowOrdering requiredRowOrdering, int numTablesInQuery, OptimizerPlan overridingPlan, LanguageConnectionContext lcc)
|
| Modifier and Type | Method and Description |
|---|---|
| pack-priv void | addScopedPredicatesToList(PredicateList
List of predicates to add to this OptimizerImpl's
own list for pushing. pList, ContextManager cm)Add scoped predicates to this optimizer's predicateList. |
| public void | considerCost(Optimizable
The Optimizable optimizable, OptimizablePredicateList The OptimizablePredicateList to apply predList, CostEstimate The estimated cost of the given optimizable estimatedCost, CostEstimate The cost of the tables outer to the one being
optimizer - tells how many outer rows there are. outerCost)Implements org. This is the version of costOptimizable for non-base-tables. |
| private void | costBasedCostOptimizable(Optimizable optimizable, TableDescriptor td, ConglomerateDescriptor cd, OptimizablePredicateList predList, CostEstimate outerCost)
This method decides whether the given conglomerate descriptor is cheapest based on cost, rather than based on rules. |
| public void | costOptimizable(Optimizable
The Optimizable optimizable, TableDescriptor TableDescriptor of the Optimizable td, ConglomerateDescriptor The ConglomerateDescriptor for the conglom to cost
(This should change to an object to represent
access paths, but for now this is OK). cd, OptimizablePredicateList The OptimizablePredicateList to apply predList, CostEstimate The cost of the tables outer to the one being
optimizer - tells how many outer rows there are. outerCost)Implements org. Cost the current Optimizable with the specified OPL. |
| public void | costPermutation()
Implements org. Cost the current permutation. |
| private void | endOfRoundCleanup()
Do any work that needs to be done after the current round of optimization has completed. |
| private CostEstimate | estimateTotalCost(OptimizablePredicateList predList, ConglomerateDescriptor cd, CostEstimate outerCost, Optimizable optimizable)
Estimate the total cost of doing a join with the given optimizable. |
| public DataDictionary | getDataDictionary()
Implements org. Return the DataDictionary that the Optimizer is using. |
| public CostEstimate | getFinalCost()
Implements org. Get the final estimated cost of the optimized query. |
| public JoinStrategy | getJoinStrategy(int whichStrategy)
Implements org. Gets a join strategy by number (zero-based). |
| public JoinStrategy | getJoinStrategy(String whichStrategy)
Implements org. Gets a join strategy by name. |
| public int | getLevel()
Implements org. Get the level of this optimizer. |
| public int | |
| pack-priv CostEstimateImpl | |
| public boolean | getNextDecoratedPermutation()
Implements org. Iterate through the "decorated permutations", returning false when they are exhausted. |
| public boolean | getNextPermutation()
Implements org. Iterate through the permutations, returning false when the permutations are exhausted. |
| public int | getNumberOfJoinStrategies()
Implements org. Get the number of join strategies supported by this optimizer. |
| public Optimizable | getOptimizable(int idx)
Implements org. Get the ith (0-based) Optimizable being considered by this Optimizer. |
| public int | getOptimizableCount()
Implements org. Get the number of optimizables being considered by this Optimizer. |
| public CostEstimate | getOptimizedCost()
Implements org. Get the estimated cost of the optimized query |
| private UniqueTupleDescriptor | getTupleDescriptor(Optimizable optimizable)
Get the unique tuple descriptor of the current access path for an Optimizable. |
| private int | initJumpState()
Determine if we want to try "jumping" permutations with this OptimizerImpl, and (re-)initialize the permuteState field accordingly. |
| private boolean | |
| pack-priv static boolean | |
| private boolean | joinOrderMeetsDependencies(int optNumber)
Check to see if the optimizable corresponding to the received optNumber can legally be placed within the current join order. |
| public void | modifyAccessPaths()
Implements org. Modify the access path for each Optimizable, as necessary. |
| private CostEstimate | |
| public void | prepForNextRound()
Implements org. This method is called before every "round" of optimization, where we define a "round" to be the period between the last time a call to getOptimizer() (on either a ResultSetNode or an OptimizerFactory) returned _this_ OptimizerImpl and the time a call to this OptimizerImpl's getNextPermutation() method returns FALSE. |
| private void | pullOptimizableFromJoinOrder()
Pull whatever optimizable is at joinPosition in the proposed join order from the join order, and update all corresponding state accordingly. |
| pack-priv void | |
| private double | recoverCostFromProposedJoinOrder(boolean sortAvoidance)
Iterate through all optimizables in the current proposedJoinOrder and find the accumulated sum of their estimated costs. |
| private void | rememberBestCost(CostEstimate currentCost, int planType)
Is the cost of this join order lower than the best one we've found so far? |
| private void | |
| private void | ruleBasedCostOptimizable(Optimizable optimizable, TableDescriptor td, ConglomerateDescriptor cd, OptimizablePredicateList predList, CostEstimate outerCost)
This method decides whether the given conglomerate descriptor is cheapest based on rules, rather than based on cost estimates. |
| public void | setOuterRows(double outerRows)
Implements org. Set the estimated number of outer rows - good for optimizing nested optimizables like subqueries and join nodes. |
| public int | tableLockThreshold()
Implements org. Get the maximum number of estimated rows touched in a table before we decide to open the table with table locking (as opposed to row locking. |
| private OptTrace | |
| private boolean | |
| public double | uniqueJoinWithOuterTable(OptimizablePredicateList
The predicate list to check predList)Implements org. Tells whether any of the tables outer to the current one has a uniqueness condition on the given predicate list, and if so, how many times each unique key can be seen by the current table. |
| public void | updateBestPlanMaps(short
Indicates whether to add, load, or remove the plan action, Object Object to use as the map key when adding/looking up
a plan. If this is an instance of OptimizerImpl then it corresponds
to an outer query; otherwise it's some Optimizable above this
OptimizerImpl that could potentially reject plans chosen by this
OptimizerImpl. planKey)Implements org. Process (i.e. add, load, or remove) current best join order as the best one for some outer query or ancestor node, represented by another OptimizerImpl or an instance of FromTable, respectively. |
| public boolean | useStatistics()
Implements org. If statistics should be considered by the optimizer while optimizing a query. |
| assignedTableMap | back to summary |
|---|---|
| private JBitSet assignedTableMap | |
| bestCost | back to summary |
|---|---|
| private CostEstimateImpl bestCost | |
| bestJoinOrder | back to summary |
|---|---|
| private int[] bestJoinOrder | |
| bestJoinOrderUsedPredsFromAbove | back to summary |
|---|---|
| private boolean bestJoinOrderUsedPredsFromAbove | |
| bestRowOrdering | back to summary |
|---|---|
| private RowOrdering bestRowOrdering | |
| currentCost | back to summary |
|---|---|
| private CostEstimateImpl currentCost | |
| currentPlan | back to summary |
|---|---|
| private OptimizerPlan currentPlan | |
| currentRowOrdering | back to summary |
|---|---|
| private RowOrdering currentRowOrdering | |
| currentSortAvoidanceCost | back to summary |
|---|---|
| private CostEstimateImpl currentSortAvoidanceCost | |
| currentTime | back to summary |
|---|---|
| private long currentTime | |
| dDictionary | back to summary |
|---|---|
| private DataDictionary dDictionary | |
| desiredJoinOrderFound | back to summary |
|---|---|
| private boolean desiredJoinOrderFound | |
| finalCostEstimate | back to summary |
|---|---|
| private CostEstimate finalCostEstimate | |
| firstLookOrder | back to summary |
|---|---|
| private int[] firstLookOrder | |
| foundABestPlan | back to summary |
|---|---|
| private boolean foundABestPlan | |
| joinPosition | back to summary |
|---|---|
| private int joinPosition | |
| joinStrategies | back to summary |
|---|---|
| private JoinStrategy[] joinStrategies | |
| JUMPING | back to summary |
|---|---|
| private static final int JUMPING | |
| lcc | back to summary |
|---|---|
| private LanguageConnectionContext lcc | |
| maxMemoryPerTable | back to summary |
|---|---|
| private int maxMemoryPerTable | |
| NO_JUMP | back to summary |
|---|---|
| private static final int NO_JUMP | |
| nonCorrelatedTableMap | back to summary |
|---|---|
| private JBitSet nonCorrelatedTableMap | |
| noTimeout | back to summary |
|---|---|
| private boolean noTimeout | |
| numOptimizables | back to summary |
|---|---|
| private int numOptimizables | |
| numTablesInQuery | back to summary |
|---|---|
| private int numTablesInQuery | |
| optimizableList | back to summary |
|---|---|
| private OptimizableList optimizableList | |
| outermostCostEstimate | back to summary |
|---|---|
| private CostEstimateImpl outermostCostEstimate | |
| overridingPlan | back to summary |
|---|---|
| private OptimizerPlan overridingPlan | |
| permuteState | back to summary |
|---|---|
| private int permuteState | |
| predicateList | back to summary |
|---|---|
| private OptimizablePredicateList predicateList | |
| proposedJoinOrder | back to summary |
|---|---|
| private int[] proposedJoinOrder | |
| READY_TO_JUMP | back to summary |
|---|---|
| private static final int READY_TO_JUMP | |
| reloadBestPlan | back to summary |
|---|---|
| private boolean reloadBestPlan | |
| requiredRowOrdering | back to summary |
|---|---|
| private RequiredRowOrdering requiredRowOrdering | |
| ruleBasedOptimization | back to summary |
|---|---|
| private boolean ruleBasedOptimization | |
| savedJoinOrders | back to summary |
|---|---|
| private HashMap<Object, int[]> savedJoinOrders | |
| sortCost | back to summary |
|---|---|
| private CostEstimate sortCost | |
| tableLockThreshold | back to summary |
|---|---|
| private int tableLockThreshold | |
| timeExceeded | back to summary |
|---|---|
| private boolean timeExceeded | |
| timeLimit | back to summary |
|---|---|
| private double timeLimit | |
| timeOptimizationStarted | back to summary |
|---|---|
| private long timeOptimizationStarted | |
| useStatistics | back to summary |
|---|---|
| private boolean useStatistics | |
| usingPredsPushedFromAbove | back to summary |
|---|---|
| private boolean usingPredsPushedFromAbove | |
| WALK_HIGH | back to summary |
|---|---|
| private static final int WALK_HIGH | |
| WALK_LOW | back to summary |
|---|---|
| private static final int WALK_LOW | |
| OptimizerImpl | back to summary |
|---|---|
| pack-priv OptimizerImpl(OptimizableList optimizableList, OptimizablePredicateList predicateList, DataDictionary dDictionary, boolean ruleBasedOptimization, boolean noTimeout, boolean useStatistics, int maxMemoryPerTable, JoinStrategy[] joinStrategies, int tableLockThreshold, RequiredRowOrdering requiredRowOrdering, int numTablesInQuery, OptimizerPlan overridingPlan, LanguageConnectionContext lcc) throws StandardException | |
| addScopedPredicatesToList | back to summary |
|---|---|
| pack-priv void addScopedPredicatesToList(PredicateList pList, ContextManager cm) throws StandardException Add scoped predicates to this optimizer's predicateList. This method is intended for use during the modifyAccessPath() phase of compilation, as it allows nodes (esp. SelectNodes) to add to the list of predicates available for the final "push" before code generation. Just as the constructor for this class allows a caller to specify a predicate list to use during the optimization phase, this method allows a caller to specify a predicate list to use during the modify-access-paths phase. Before adding the received predicates, this method also clears out any scoped predicates that might be sitting in OptimizerImpl's list from the last round of optimizing. This method should be in the Optimizer interface, but it relies on an argument type (PredicateList) which lives in an impl package.
| |
| considerCost | back to summary |
|---|---|
| public void considerCost(Optimizable optimizable, OptimizablePredicateList predList, CostEstimate estimatedCost, CostEstimate outerCost) throws StandardException Implements org. This is the version of costOptimizable for non-base-tables.
| |
| costBasedCostOptimizable | back to summary |
|---|---|
| private void costBasedCostOptimizable(Optimizable optimizable, TableDescriptor td, ConglomerateDescriptor cd, OptimizablePredicateList predList, CostEstimate outerCost) throws StandardException This method decides whether the given conglomerate descriptor is cheapest based on cost, rather than based on rules. It compares the cost of using the given ConglomerateDescriptor with the cost of using the best ConglomerateDescriptor so far. | |
| costOptimizable | back to summary |
|---|---|
| public void costOptimizable(Optimizable optimizable, TableDescriptor td, ConglomerateDescriptor cd, OptimizablePredicateList predList, CostEstimate outerCost) throws StandardException Implements org. Doc from org. Cost the current Optimizable with the specified OPL. Caller is responsible for pushing all predicates which can be evaluated prior to costing.
| |
| costPermutation | back to summary |
|---|---|
| public void costPermutation() throws StandardException Implements org. Doc from org. Cost the current permutation. Caller is responsible for pushing all predicates which can be evaluated prior to costing.
| |
| endOfRoundCleanup | back to summary |
|---|---|
| private void endOfRoundCleanup() throws StandardException Do any work that needs to be done after the current round of optimization has completed. For now this just means walking the subtrees for each optimizable and removing the "bestPlan" that we saved (w.r.t to this OptimizerImpl) from all of the nodes. If we don't do this post-optimization cleanup we can end up consuming a huge amount of memory for deeply- nested queries, which can lead to OOM errors. DERBY-1315. | |
| estimateTotalCost | back to summary |
|---|---|
| private CostEstimate estimateTotalCost(OptimizablePredicateList predList, ConglomerateDescriptor cd, CostEstimate outerCost, Optimizable optimizable) throws StandardException Estimate the total cost of doing a join with the given optimizable.
| |
| getDataDictionary | back to summary |
|---|---|
| public DataDictionary getDataDictionary() Implements org. Doc from org. Return the DataDictionary that the Optimizer is using. This is useful when an Optimizable needs to call optimize() on a child ResultSetNode.
| |
| getFinalCost | back to summary |
|---|---|
| public CostEstimate getFinalCost() Implements org. Doc from org. Get the final estimated cost of the optimized query. This should be the cost that corresponds to the best overall join order chosen by the optimizer, and thus this method should only be called after optimization is complete (i.e. when modifying access paths). | |
| getJoinStrategy | back to summary |
|---|---|
| public JoinStrategy getJoinStrategy(int whichStrategy) Implements org. Doc from org. Gets a join strategy by number (zero-based).
| |
| getJoinStrategy | back to summary |
|---|---|
| public JoinStrategy getJoinStrategy(String whichStrategy) Implements org. Doc from org. Gets a join strategy by name. Returns null if not found. The look-up is case-insensitive.
| |
| getLevel | back to summary |
|---|---|
| public int getLevel() Implements org. Doc from org. Get the level of this optimizer.
| |
| getMaxMemoryPerTable | back to summary |
|---|---|
| public int getMaxMemoryPerTable() Implements org.
| |
| getNewCostEstimate | back to summary |
|---|---|
| pack-priv CostEstimateImpl getNewCostEstimate(double theCost, double theRowCount, double theSingleScanRowCount) | |
| getNextDecoratedPermutation | back to summary |
|---|---|
| public boolean getNextDecoratedPermutation() throws StandardException Implements org. Doc from org. Iterate through the "decorated permutations", returning false when they are exhausted. NOTE - Implementers are responsible for hiding tree pruning of access methods behind this method call.
| |
| getNextPermutation | back to summary |
|---|---|
| public boolean getNextPermutation() throws StandardException Implements org. Doc from org. Iterate through the permutations, returning false when the permutations are exhausted. NOTE - Implementers are responsible for hiding tree pruning of permutations behind this method call.
| |
| getNumberOfJoinStrategies | back to summary |
|---|---|
| public int getNumberOfJoinStrategies() Implements org. Get the number of join strategies supported by this optimizer. | |
| getOptimizable | back to summary |
|---|---|
| public Optimizable getOptimizable(int idx) Implements org. Doc from org. Get the ith (0-based) Optimizable being considered by this Optimizer. | |
| getOptimizableCount | back to summary |
|---|---|
| public int getOptimizableCount() Implements org. Doc from org. Get the number of optimizables being considered by this Optimizer. | |
| getOptimizedCost | back to summary |
|---|---|
| public CostEstimate getOptimizedCost() Implements org. Doc from org. Get the estimated cost of the optimized query
| |
| getTupleDescriptor | back to summary |
|---|---|
| private UniqueTupleDescriptor getTupleDescriptor(Optimizable optimizable) throws StandardException Get the unique tuple descriptor of the current access path for an Optimizable. | |
| initJumpState | back to summary |
|---|---|
| private int initJumpState() Determine if we want to try "jumping" permutations with this OptimizerImpl, and (re-)initialize the permuteState field accordingly. | |
| isPushable | back to summary |
|---|---|
| private boolean isPushable(OptimizablePredicate pred) | |
| isTableFunction | back to summary |
|---|---|
| pack-priv static boolean isTableFunction(Optimizable optimizable) Return true if the optimizable is a table function | |
| joinOrderMeetsDependencies | back to summary |
|---|---|
| private boolean joinOrderMeetsDependencies(int optNumber) throws StandardException Check to see if the optimizable corresponding to the received optNumber can legally be placed within the current join order. More specifically, if the optimizable has any dependencies, check to see if those dependencies are satisified by the table map representing the current join order. | |
| modifyAccessPaths | back to summary |
|---|---|
| public void modifyAccessPaths() throws StandardException Implements org. Doc from org. Modify the access path for each Optimizable, as necessary. This includes things like adding result sets to translate from index rows to base rows.
| |
| newCostEstimate | back to summary |
|---|---|
| private CostEstimate newCostEstimate() | |
| prepForNextRound | back to summary |
|---|---|
| public void prepForNextRound() Implements org. This method is called before every "round" of optimization, where we define a "round" to be the period between the last time a call to getOptimizer() (on either a ResultSetNode or an OptimizerFactory) returned _this_ OptimizerImpl and the time a call to this OptimizerImpl's getNextPermutation() method returns FALSE. Any re-initialization of state that is required before each round should be done in this method. | |
| pullOptimizableFromJoinOrder | back to summary |
|---|---|
| private void pullOptimizableFromJoinOrder() throws StandardException Pull whatever optimizable is at joinPosition in the proposed join order from the join order, and update all corresponding state accordingly. | |
| pushPredicates | back to summary |
|---|---|
| pack-priv void pushPredicates(Optimizable curTable, JBitSet outerTables) throws StandardException | |
| recoverCostFromProposedJoinOrder | back to summary |
|---|---|
| private double recoverCostFromProposedJoinOrder(boolean sortAvoidance) throws StandardException Iterate through all optimizables in the current proposedJoinOrder and find the accumulated sum of their estimated costs. This method is used to 'recover' cost estimate sums that have been lost due to the addition/subtraction of the cost estimate for the Optimizable at position "joinPosition". Ex. If the total cost for Optimizables at positions < joinPosition is 1500, and then the Optimizable at joinPosition has an estimated cost of 3.14E40, adding those two numbers effectively "loses" the 1500. When we later subtract 3.14E40 from the total cost estimate (as part of "pull" processing), we'll end up with 0 as the result--which is wrong. This method allows us to recover the "1500" that we lost in the process of adding and subtracting 3.14E40. | |
| rememberBestCost | back to summary |
|---|---|
| private void rememberBestCost(CostEstimate currentCost, int planType) throws StandardException Is the cost of this join order lower than the best one we've found so far? If so, remember it. Note If the user has specified a join order, it will be the only join order the optimizer considers, so it is OK to use costing to decide that it is the "best" join order.
| |
| rewindJoinOrder | back to summary |
|---|---|
| private void rewindJoinOrder() throws StandardException | |
| ruleBasedCostOptimizable | back to summary |
|---|---|
| private void ruleBasedCostOptimizable(Optimizable optimizable, TableDescriptor td, ConglomerateDescriptor cd, OptimizablePredicateList predList, CostEstimate outerCost) throws StandardException This method decides whether the given conglomerate descriptor is cheapest based on rules, rather than based on cost estimates. The rules are: Covering matching indexes are preferred above all Non-covering matching indexes are next in order of preference Covering non-matching indexes are next in order of preference Heap scans are next in order of preference Non-covering, non-matching indexes are last in order of preference. In the current language architecture, there will always be a heap, so a non-covering, non-matching index scan will never be chosen. However, the optimizer may see a non-covering, non-matching index first, in which case it will choose it temporarily as the best conglomerate seen so far. Note This method sets the cost in the optimizable, even though it doesn't use the cost to determine which access path to choose. There are two reasons for this: the cost might be needed to determine join order, and the cost information is copied to the query plan. | |
| setOuterRows | back to summary |
|---|---|
| public void setOuterRows(double outerRows) Implements org. Doc from org. Set the estimated number of outer rows - good for optimizing nested optimizables like subqueries and join nodes.
| |
| tableLockThreshold | back to summary |
|---|---|
| public int tableLockThreshold() Implements org. Doc from org. Get the maximum number of estimated rows touched in a table before we decide to open the table with table locking (as opposed to row locking.
| |
| tracer | back to summary |
|---|---|
| private OptTrace tracer() Get the trace machinery | |
| tracingIsOn | back to summary |
|---|---|
| private boolean tracingIsOn() | |
| uniqueJoinWithOuterTable | back to summary |
|---|---|
| public double uniqueJoinWithOuterTable(OptimizablePredicateList predList) throws StandardException Implements org. Doc from org. Tells whether any of the tables outer to the current one has a uniqueness condition on the given predicate list, and if so, how many times each unique key can be seen by the current table.
| |
| updateBestPlanMaps | back to summary |
|---|---|
| public void updateBestPlanMaps(short action, Object planKey) throws StandardException Implements org. Process (i.e. add, load, or remove) current best join order as the best one for some outer query or ancestor node, represented by another OptimizerImpl or an instance of FromTable, respectively. Then iterate through our optimizableList and tell each Optimizable to do the same. See Optimizable.updateBestPlan() for more on why this is necessary.
| |
| useStatistics | back to summary |
|---|---|
| public boolean useStatistics() Implements org. Doc from org. If statistics should be considered by the optimizer while optimizing a query. The user may disable the use of statistics by setting the property derby.optimizer.useStatistics or by using the property useStatistics in a query.
| |