org.apache.derby.iapi.sql.compile
Interface OptimizablePredicateList

All Known Implementing Classes:
PredicateList

public interface OptimizablePredicateList

OptimizablePredicateList provides services for optimizing a table in a query. RESOLVE - the methods for this interface need to get defined.


Method Summary
 void addOptPredicate(OptimizablePredicate optPredicate)
          Add the given OptimizablePredicate to the end of this list.
 void adjustForSortElimination(RequiredRowOrdering ordering)
          Walk through the predicates in this list and make any adjustments that are required to allow for proper handling of an ORDER BY clause.
 void classify(Optimizable optTable, ConglomerateDescriptor cd)
          Classify the predicates in this list according to the given table and conglomerate.
 void copyPredicatesToOtherList(OptimizablePredicateList otherList)
          Non-destructive copy of all of the predicates from this list to the other list.
 void generateQualifiers(ExpressionClassBuilderInterface acb, MethodBuilder mb, Optimizable optTable, boolean absolute)
          Generate the qualifiers for a scan.
 void generateStartKey(ExpressionClassBuilderInterface acb, MethodBuilder mb, Optimizable optTable)
          Generate the start key for a heap or index scan.
 void generateStopKey(ExpressionClassBuilderInterface acb, MethodBuilder mb, Optimizable optTable)
          Generate the stop key for a heap or index scan.
 OptimizablePredicate getOptPredicate(int n)
          Return the nth OptimizablePredicate in the list.
 int hasEqualityPredicateOnOrderedColumn(Optimizable optTable, int columnNumber, boolean isNullOkay)
          Check into the predicate list if the passed column has an equijoin predicate on it.
 boolean hasOptimizableEqualityPredicate(Optimizable optTable, int columnNumber, boolean isNullOkay)
          Is there an optimizable equality predicate on the specified column?
 boolean hasOptimizableEquijoin(Optimizable optTable, int columnNumber)
          Is there an optimizable equijoin on the specified column?
 boolean isRedundantPredicate(int predNum)
          Return whether or not the specified entry in the list is a redundant predicate.
 void markAllPredicatesQualifiers()
          Mark all of the predicates as Qualifiers and set the numberOfQualifiers to reflect this.
 void pushUsefulPredicates(Optimizable optTable)
          Determine which predicates in this list are useful for limiting the scan on the given table using its best conglomerate.
 void putOptimizableEqualityPredicateFirst(Optimizable optTable, int columnNumber)
          Find the optimizable equality predicate on the specified column and make it the first predicate in this list.
 void removeOptPredicate(int predCtr)
          Remove the OptimizablePredicate at the specified index (0-based) from the list.
 boolean sameStartStopPosition()
          Can we use the same key for both the start and stop key.
 double selectivity(Optimizable optTable)
          calculate the selectivity for a set of predicates.
 void setPredicatesAndProperties(OptimizablePredicateList otherList)
          Sets the given list to have the same elements as this one, and the same properties as this one (number of qualifiers and start and stop predicates.
 int size()
          Return the number of OptimizablePredicates in the list.
 int startOperator(Optimizable optTable)
          Get the start operator for the given Optimizable for a heap or index scan.
 int stopOperator(Optimizable optTable)
          Get the stop operator for the given Optimizable for a heap or index scan.
 void transferAllPredicates(OptimizablePredicateList otherList)
          Transfer all the predicates from this list to the given list.
 void transferPredicates(OptimizablePredicateList otherList, JBitSet referencedTableMap, Optimizable table)
          Transfer the predicates whose referenced set is contained by the specified referencedTableMap from this list to the other list.
 boolean useful(Optimizable optTable, ConglomerateDescriptor cd)
          Return true if this predicate list is useful for limiting the scan on the given table using the given conglomerate.
 

Method Detail

size

int size()
Return the number of OptimizablePredicates in the list.

Returns:
integer The number of OptimizablePredicates in the list.

getOptPredicate

OptimizablePredicate getOptPredicate(int n)
Return the nth OptimizablePredicate in the list.

Parameters:
n - "index" (0 based) into the list.
Returns:
OptimizablePredicate The nth OptimizablePredicate in the list.

removeOptPredicate

void removeOptPredicate(int predCtr)
                        throws StandardException
Remove the OptimizablePredicate at the specified index (0-based) from the list.

Parameters:
predCtr - The index.
Throws:
StandardException - Thrown on error

addOptPredicate

void addOptPredicate(OptimizablePredicate optPredicate)
Add the given OptimizablePredicate to the end of this list.

Parameters:
optPredicate - The predicate to add

useful

boolean useful(Optimizable optTable,
               ConglomerateDescriptor cd)
               throws StandardException
Return true if this predicate list is useful for limiting the scan on the given table using the given conglomerate.

Parameters:
optTable - An Optimizable for the table in question
cd - A ConglomerateDescriptor for the conglomerate in question
Returns:
true if this predicate list can limit the scan
Throws:
StandardException - Thrown on error

pushUsefulPredicates

void pushUsefulPredicates(Optimizable optTable)
                          throws StandardException
Determine which predicates in this list are useful for limiting the scan on the given table using its best conglomerate. Remove those predicates from this list and push them down to the given Optimizable table. The predicates are pushed down in the order of the index columns that they qualify. Also, the predicates are "marked" as start predicates, stop predicates, or qualifier predicates. Finally, the start and stop operators are set in the given Optimizable.

Parameters:
optTable - An Optimizable for the table in question
Throws:
StandardException - Thrown on error

classify

void classify(Optimizable optTable,
              ConglomerateDescriptor cd)
              throws StandardException
Classify the predicates in this list according to the given table and conglomerate. Each predicate can be a start key, stop key, and/or qualifier, or it can be none of the above. This method also orders the predicates to match the order of the columns in a keyed conglomerate. No ordering is done for heaps.

Parameters:
optTable - The Optimizable table for which to classify the predicates in this list.
cd - The ConglomerateDescriptor for which to classify the predicates in this list.
Throws:
StandardException - Thrown on error

markAllPredicatesQualifiers

void markAllPredicatesQualifiers()
Mark all of the predicates as Qualifiers and set the numberOfQualifiers to reflect this. This is useful for hash joins where all of the predicates in the list to be evaluated during the probe into the hash table on a next are qualifiers.


hasEqualityPredicateOnOrderedColumn

int hasEqualityPredicateOnOrderedColumn(Optimizable optTable,
                                        int columnNumber,
                                        boolean isNullOkay)
                                        throws StandardException
Check into the predicate list if the passed column has an equijoin predicate on it.

Parameters:
optTable -
columnNumber -
isNullOkay -
Returns:
the position of the predicate in the list which corresponds to the equijoin. If no quijoin predicate found, then the return value will be -1
Throws:
StandardException

hasOptimizableEqualityPredicate

boolean hasOptimizableEqualityPredicate(Optimizable optTable,
                                        int columnNumber,
                                        boolean isNullOkay)
                                        throws StandardException
Is there an optimizable equality predicate on the specified column?

Parameters:
optTable - The optimizable the column comes from.
columnNumber - The column number within the base table.
isNullOkay - boolean, whether or not the IS NULL operator satisfies the search
Returns:
Whether or not there is an optimizable equality predicate on the specified column.
Throws:
StandardException - Thrown on error

hasOptimizableEquijoin

boolean hasOptimizableEquijoin(Optimizable optTable,
                               int columnNumber)
                               throws StandardException
Is there an optimizable equijoin on the specified column?

Parameters:
optTable - The optimizable the column comes from.
columnNumber - The column number within the base table.
Returns:
Whether or not there is an optimizable equijoin on the specified column.
Throws:
StandardException - Thrown on error

putOptimizableEqualityPredicateFirst

void putOptimizableEqualityPredicateFirst(Optimizable optTable,
                                          int columnNumber)
                                          throws StandardException
Find the optimizable equality predicate on the specified column and make it the first predicate in this list. This is useful for hash joins where Qualifier[0] is assumed to be on the hash key.

Parameters:
optTable - The optimizable the column comes from.
columnNumber - The column number within the base table.
Throws:
StandardException - Thrown on error

transferPredicates

void transferPredicates(OptimizablePredicateList otherList,
                        JBitSet referencedTableMap,
                        Optimizable table)
                        throws StandardException
Transfer the predicates whose referenced set is contained by the specified referencedTableMap from this list to the other list. This is useful when splitting out a set of predicates from a larger set, like when generating a HashScanResultSet.

Parameters:
otherList - The predicateList to xfer to
referencedTableMap - The table map to check against
table - The table to order the new predicates against
Throws:
StandardException - Thrown on error

transferAllPredicates

void transferAllPredicates(OptimizablePredicateList otherList)
                           throws StandardException
Transfer all the predicates from this list to the given list.

Throws:
StandardException - Thrown on error

copyPredicatesToOtherList

void copyPredicatesToOtherList(OptimizablePredicateList otherList)
                               throws StandardException
Non-destructive copy of all of the predicates from this list to the other list. This is useful when splitting out a set of predicates from a larger set, like when generating a HashScanResultSet.

Parameters:
otherList - The predicateList to xfer to
Throws:
StandardException - Thrown on error

setPredicatesAndProperties

void setPredicatesAndProperties(OptimizablePredicateList otherList)
                                throws StandardException
Sets the given list to have the same elements as this one, and the same properties as this one (number of qualifiers and start and stop predicates.

Parameters:
otherList - The list to set the same as this one.
Throws:
StandardException - Thrown on error

isRedundantPredicate

boolean isRedundantPredicate(int predNum)
Return whether or not the specified entry in the list is a redundant predicate. This is useful for selectivity calculations because we do not want redundant predicates included in the selectivity calculation.

Parameters:
predNum - The entry in the list
Returns:
Whether or not the specified entry in the list is a redundant predicate.

startOperator

int startOperator(Optimizable optTable)
Get the start operator for the given Optimizable for a heap or index scan.


stopOperator

int stopOperator(Optimizable optTable)
Get the stop operator for the given Optimizable for a heap or index scan.


generateQualifiers

void generateQualifiers(ExpressionClassBuilderInterface acb,
                        MethodBuilder mb,
                        Optimizable optTable,
                        boolean absolute)
                        throws StandardException
Generate the qualifiers for a scan. This method generates an array of Qualifiers, and fills them in with calls to the factory method for generating Qualifiers in the constructor for the activation. It stores the array of Qualifiers in a field in the activation, and returns a reference to that field. If there are no qualifiers, it initializes the array of Qualifiers to null.

Parameters:
acb - The ExpressionClassBuilderInterface for the class we are building
mb - The method the generated code is going into
optTable - The Optimizable table the Qualifiers are on
absolute - Generate absolute column positions if true, else relative column positions (within the underlying row)
Throws:
StandardException - Thrown on error

generateStartKey

void generateStartKey(ExpressionClassBuilderInterface acb,
                      MethodBuilder mb,
                      Optimizable optTable)
                      throws StandardException
Generate the start key for a heap or index scan.

Parameters:
acb - The ExpressionClassBuilderInterface for the class we're building
mb - The method the generated code is to go into
optTable - The Optimizable table the start key is for
Throws:
StandardException - Thrown on error

generateStopKey

void generateStopKey(ExpressionClassBuilderInterface acb,
                     MethodBuilder mb,
                     Optimizable optTable)
                     throws StandardException
Generate the stop key for a heap or index scan.

Parameters:
acb - The ExpressionClassBuilderInterface for the class we're building
mb - the method the generated code is to go into
optTable - The Optimizable table the stop key is for
Throws:
StandardException - Thrown on error

sameStartStopPosition

boolean sameStartStopPosition()
                              throws StandardException
Can we use the same key for both the start and stop key. This is possible when doing an exact match on an index where there are no other sargable predicates.

Returns:
Whether or not we can use the same key for both the start and stop key.
Throws:
StandardException - Thrown on error

selectivity

double selectivity(Optimizable optTable)
                   throws StandardException
calculate the selectivity for a set of predicates. If statistics exist for the predicates this method uses the statistics. If statistics do not exist, then simply call selectivity for each of the predicates and return the result.

Parameters:
optTable - the Optimizable that the predicate list restricts.
Throws:
StandardException

adjustForSortElimination

void adjustForSortElimination(RequiredRowOrdering ordering)
                              throws StandardException
Walk through the predicates in this list and make any adjustments that are required to allow for proper handling of an ORDER BY clause.

Throws:
StandardException

Built on Thu 2012-03-29 21:53:33+0000, from revision ???

Apache Derby V10.6 Internals - Copyright © 2004,2007 The Apache Software Foundation. All Rights Reserved.