Class Predicate
- java.lang.Object
-
- org.apache.derby.impl.sql.compile.QueryTreeNode
-
- org.apache.derby.impl.sql.compile.Predicate
-
- All Implemented Interfaces:
java.lang.Comparable<Predicate>
,OptimizablePredicate
,Visitable
public final class Predicate extends QueryTreeNode implements OptimizablePredicate, java.lang.Comparable<Predicate>
A Predicate represents a top level predicate.
-
-
Field Summary
Fields Modifier and Type Field Description (package private) AndNode
andNode
(package private) int
equivalenceClass
(package private) int
indexPosition
protected boolean
isQualifier
(package private) boolean
pushable
(package private) JBitSet
referencedSet
private boolean
scoped
private java.util.Set<java.lang.Integer>
searchClauses
protected boolean
startKey
protected boolean
stopKey
-
Fields inherited from class org.apache.derby.impl.sql.compile.QueryTreeNode
AUTOINCREMENT_CREATE_MODIFY, AUTOINCREMENT_CYCLE, AUTOINCREMENT_INC_INDEX, AUTOINCREMENT_IS_AUTOINCREMENT_INDEX, AUTOINCREMENT_START_INDEX
-
-
Constructor Summary
Constructors Constructor Description Predicate(AndNode andNode, JBitSet referencedSet, ContextManager cm)
Constructor.
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description (package private) void
acceptChildren(Visitor v)
Accept the visitor for all visitable children of this node.(package private) java.lang.String
binaryRelOpColRefsToString()
Get a string version of the column references for this predicate IF it's a binary relational operator.(package private) void
categorize()
Categorize this predicate.(package private) void
clearScanFlags()
Clear the start/stop position and qualifier flagsint
compareTo(Predicate other)
boolean
compareWithKnownConstant(Optimizable optTable, boolean considerParameters)
Is this predicate a comparison with a known constant value?(package private) void
copyFields(Predicate otherPred)
Copy all fields of this Predicate (except the two that are set from 'init').boolean
equalsComparisonWithConstantExpression(Optimizable optTable)
Is this predicate an equality comparison with a constant expression?(package private) void
generateExpressionOperand(Optimizable optTable, int columnPosition, ExpressionClassBuilder acb, MethodBuilder mb)
(package private) AndNode
getAndNode()
Return the andNode.DataValueDescriptor
getCompareValue(Optimizable optTable)
Get an Object representing the known constant value that the given Optimizable is being compared to.(package private) int
getEquivalenceClass()
Get the equivalenceClass for this predicate.int
getIndexPosition()
Get the position of the index column that this predicate restricts.protected Predicate
getPredScopedForResultSet(JBitSet parentRSNsTables, ResultSetNode childRSN, int[] whichRC)
If this predicate's operator is a BinaryRelationalOperatorNode, then look at the operands and return a new, equivalent predicate that is "scoped" to the received ResultSetNode.(package private) boolean
getPushable()
Return the pushable.JBitSet
getReferencedMap()
Get the map of referenced tables for this OptimizablePredicate.(package private) JBitSet
getReferencedSet()
Return the referencedSet.(package private) RelationalOperator
getRelop()
Get the RelationalOperator on the left side of the AND node, if there is one.protected InListOperatorNode
getSourceInList()
If this predicate corresponds to an IN-list, return the underlying InListOperatorNode from which it was built.protected InListOperatorNode
getSourceInList(boolean probePredOnly)
Does the work of getSourceInList() above, but can also be called directly with an argument to indicate whether or not we should limit ourselves to probe predicates.(package private) int
getStartOperator(Optimizable optTable)
Get the start operator for this predicate for a scan.(package private) int
getStopOperator(Optimizable optTable)
int
hasEqualOnColumnList(int[] baseColumnPositions, Optimizable optTable)
Returns if the predicate involves an equal operator on one of the columns specified in the baseColumnPositions.boolean
hasMethodCall()
Return whether or not an OptimizablePredicate contains a method call.boolean
hasSubquery()
Return whether or not an OptimizablePredicate contains a subquery.protected boolean
isInListProbePredicate()
Return whether or not this predicate is an IN-list probe predicate.protected boolean
isJoinPredicate()
Is this predicate a join predicate?(package private) boolean
isOrList()
(package private) boolean
isPushableOrClause(Optimizable optTable)
Is this predicate an pushable OR list?boolean
isQualifier()
Is this predicate a qualifier?protected boolean
isRelationalOpPredicate()
Return whether or not this predicate corresponds to a legitimate relational operator.protected boolean
isScopedForPush()
Return whether or not this predicate is a scoped copy of another predicate.protected boolean
isScopedToSourceResultSet()
Return true if this predicate is scoped AND the scoped operand is a ColumnReference that points to a source result set.boolean
isStartKey()
Is this predicate a start key?boolean
isStopKey()
Is this predicate a stop key?(package private) boolean
isStoreQualifier()
Is this predicate a possible Qualifier for store?protected void
markAsScopedForPush()
Indicate that this predicate is a scoped copy of some other predicate (i.e. it was created as the result of a call to getPredScopedForResultSet() on some other predicate).void
markQualifier()
Tell the predicate that it is to be used as a qualifier in an index scan.void
markStartKey()
Tell the predicate that it is to be used as a column in the start key value for an index scan.void
markStopKey()
Tell the predicate that it is to be used as a column in the stop key value for an index scan.(package private) void
printSubNodes(int depth)
Prints the sub-nodes of this object.protected boolean
pushableToSubqueries()
Determine whether or not this predicate is eligible for push-down into subqueries.protected boolean
remapScopedPred()
When remapping a "normal" (i.e. non-scoped) predicate both of the predicate's operands are remapped and that's it.double
selectivity(Optimizable optTable)
Get a (crude) estimate of the selectivity of this predicate.(package private) void
setAndNode(AndNode andNode)
Set the andNode.(package private) void
setEquivalenceClass(int equivalenceClass)
Set the equivalence class, if any, for this predicate.(package private) void
setIndexPosition(int indexPosition)
Set the position of the index column that this predicate restricts(package private) void
setPushable(boolean pushable)
Set whether or not this predicate is pushable.(package private) void
setTransitiveSearchClauseAdded(RelationalOperator ro)
Mark this predicate as having been used to add a new predicate of the specified type via transitive closure on search clauses.java.lang.String
toString()
Convert this object to a String.(package private) boolean
transitiveSearchClauseAdded(RelationalOperator ro)
Return whether or not this predicate has been used to add a new search clause of the specified type via transitive closure.-
Methods inherited from class org.apache.derby.impl.sql.compile.QueryTreeNode
accept, addTag, addUDTUsagePriv, addUDTUsagePriv, bindOffsetFetch, bindRowMultiSet, bindUserCatalogType, bindUserType, checkReliability, checkReliability, convertDefaultNode, copyTagsFrom, createTypeDependency, debugFlush, debugPrint, disablePrivilegeCollection, formatNodeString, generate, generateAuthorizeCheck, getBeginOffset, getClassFactory, getCompilerContext, getContext, getContextManager, getDataDictionary, getDependencyManager, getEndOffset, getExecutionFactory, getGenericConstantActionFactory, getIntProperty, getLanguageConnectionContext, getLongProperty, getNullNode, getOffsetOrderedNodes, getOptimizerFactory, getOptimizerTracer, getParameterTypes, getSchemaDescriptor, getSchemaDescriptor, getStatementType, getTableDescriptor, getTypeCompiler, getUDTDesc, isAtomic, isPrivilegeCollectionRequired, isSessionSchema, isSessionSchema, makeConstantAction, makeTableName, makeTableName, nodeHeader, optimizerTracingIsOn, orReliability, parseSearchCondition, parseStatement, printLabel, referencesSessionSchema, resolveTableToSynonym, setBeginOffset, setEndOffset, setRefActionInfo, stackPrint, taggedWith, treePrint, treePrint, verifyClassExist
-
-
-
-
Field Detail
-
andNode
AndNode andNode
-
pushable
boolean pushable
-
referencedSet
JBitSet referencedSet
-
equivalenceClass
int equivalenceClass
-
indexPosition
int indexPosition
-
startKey
protected boolean startKey
-
stopKey
protected boolean stopKey
-
isQualifier
protected boolean isQualifier
-
searchClauses
private java.util.Set<java.lang.Integer> searchClauses
-
scoped
private boolean scoped
-
-
Constructor Detail
-
Predicate
Predicate(AndNode andNode, JBitSet referencedSet, ContextManager cm)
Constructor.- Parameters:
andNode
- The top of the predicatereferencedSet
- Bit map of referenced tablescm
- The context manager
-
-
Method Detail
-
getReferencedMap
public JBitSet getReferencedMap()
Description copied from interface:OptimizablePredicate
Get the map of referenced tables for this OptimizablePredicate.- Specified by:
getReferencedMap
in interfaceOptimizablePredicate
- Returns:
- JBitSet Referenced table map.
- See Also:
OptimizablePredicate.getReferencedMap()
-
hasSubquery
public boolean hasSubquery()
Description copied from interface:OptimizablePredicate
Return whether or not an OptimizablePredicate contains a subquery.- Specified by:
hasSubquery
in interfaceOptimizablePredicate
- Returns:
- boolean Whether or not an OptimizablePredicate includes a subquery.
- See Also:
OptimizablePredicate.hasSubquery()
-
hasMethodCall
public boolean hasMethodCall()
Description copied from interface:OptimizablePredicate
Return whether or not an OptimizablePredicate contains a method call.- Specified by:
hasMethodCall
in interfaceOptimizablePredicate
- Returns:
- boolean Whether or not an OptimizablePredicate includes a method call.
- See Also:
OptimizablePredicate.hasMethodCall()
-
markStartKey
public void markStartKey()
Description copied from interface:OptimizablePredicate
Tell the predicate that it is to be used as a column in the start key value for an index scan.- Specified by:
markStartKey
in interfaceOptimizablePredicate
- See Also:
OptimizablePredicate.markStartKey()
-
isStartKey
public boolean isStartKey()
Description copied from interface:OptimizablePredicate
Is this predicate a start key?- Specified by:
isStartKey
in interfaceOptimizablePredicate
- See Also:
OptimizablePredicate.isStartKey()
-
markStopKey
public void markStopKey()
Description copied from interface:OptimizablePredicate
Tell the predicate that it is to be used as a column in the stop key value for an index scan.- Specified by:
markStopKey
in interfaceOptimizablePredicate
- See Also:
OptimizablePredicate.markStopKey()
-
isStopKey
public boolean isStopKey()
Description copied from interface:OptimizablePredicate
Is this predicate a stop key?- Specified by:
isStopKey
in interfaceOptimizablePredicate
- See Also:
OptimizablePredicate.isStopKey()
-
markQualifier
public void markQualifier()
Description copied from interface:OptimizablePredicate
Tell the predicate that it is to be used as a qualifier in an index scan.- Specified by:
markQualifier
in interfaceOptimizablePredicate
- See Also:
OptimizablePredicate.markQualifier()
-
isQualifier
public boolean isQualifier()
Description copied from interface:OptimizablePredicate
Is this predicate a qualifier?- Specified by:
isQualifier
in interfaceOptimizablePredicate
- See Also:
OptimizablePredicate.isQualifier()
-
compareWithKnownConstant
public boolean compareWithKnownConstant(Optimizable optTable, boolean considerParameters)
Description copied from interface:OptimizablePredicate
Is this predicate a comparison with a known constant value?- Specified by:
compareWithKnownConstant
in interfaceOptimizablePredicate
- Parameters:
optTable
- The Optimizable that we want to know whether we are comparing to a known constant.considerParameters
- Whether or not to consider parameters with defaults as known constants.- See Also:
OptimizablePredicate.compareWithKnownConstant(org.apache.derby.iapi.sql.compile.Optimizable, boolean)
-
hasEqualOnColumnList
public int hasEqualOnColumnList(int[] baseColumnPositions, Optimizable optTable) throws StandardException
Description copied from interface:OptimizablePredicate
Returns if the predicate involves an equal operator on one of the columns specified in the baseColumnPositions.- Specified by:
hasEqualOnColumnList
in interfaceOptimizablePredicate
- Parameters:
baseColumnPositions
- the column numbers on which the user wants to check if the equality condition exists.optTable
- the table for which baseColumnPositions are given.- Returns:
- returns the index into baseColumnPositions of the column that has the equality operator.
- Throws:
StandardException
-
getCompareValue
public DataValueDescriptor getCompareValue(Optimizable optTable) throws StandardException
Description copied from interface:OptimizablePredicate
Get an Object representing the known constant value that the given Optimizable is being compared to.- Specified by:
getCompareValue
in interfaceOptimizablePredicate
- Throws:
StandardException
- Thrown on error- See Also:
OptimizablePredicate.getCompareValue(org.apache.derby.iapi.sql.compile.Optimizable)
-
equalsComparisonWithConstantExpression
public boolean equalsComparisonWithConstantExpression(Optimizable optTable)
Description copied from interface:OptimizablePredicate
Is this predicate an equality comparison with a constant expression? (IS NULL is considered to be an = comparison with a constant expression).- Specified by:
equalsComparisonWithConstantExpression
in interfaceOptimizablePredicate
- Parameters:
optTable
- The Optimizable for which we want to know whether it is being equality-compared to a constant expression.- See Also:
OptimizablePredicate.equalsComparisonWithConstantExpression(org.apache.derby.iapi.sql.compile.Optimizable)
-
selectivity
public double selectivity(Optimizable optTable) throws StandardException
Description copied from interface:OptimizablePredicate
Get a (crude) estimate of the selectivity of this predicate. This is to be used when no better technique is available for estimating the selectivity - this method's estimate is a hard- wired number based on the type of predicate and the datatype (the selectivity of boolean is always 50%).- Specified by:
selectivity
in interfaceOptimizablePredicate
- Parameters:
optTable
- The Optimizable that this predicate restricts- Throws:
StandardException
- See Also:
OptimizablePredicate.selectivity(org.apache.derby.iapi.sql.compile.Optimizable)
-
getIndexPosition
public int getIndexPosition()
Description copied from interface:OptimizablePredicate
Get the position of the index column that this predicate restricts. NOTE: This assumes that this predicate is part of an OptimizablePredicateList, and that classify() has been called on the OptimizablePredicateList.- Specified by:
getIndexPosition
in interfaceOptimizablePredicate
- Returns:
- The index position that this predicate restricts (zero-based)
- See Also:
OptimizablePredicate.getIndexPosition()
-
compareTo
public int compareTo(Predicate other)
- Specified by:
compareTo
in interfacejava.lang.Comparable<Predicate>
-
getAndNode
AndNode getAndNode()
Return the andNode.- Returns:
- AndNode The andNode.
-
setAndNode
void setAndNode(AndNode andNode)
Set the andNode.- Parameters:
andNode
- The new andNode.
-
getPushable
boolean getPushable()
Return the pushable.- Returns:
- boolean Whether or not the predicate is pushable.
-
setPushable
void setPushable(boolean pushable)
Set whether or not this predicate is pushable. This method is intended for use when creating a copy of the predicate, ex for predicate pushdown. We choose not to add this assignment to copyFields() because the comments for that method say that it should copy all fields _except_ the two specified at init time; "pushable" is one of the two specified at init time.- Parameters:
pushable
- Whether or not the predicate is pushable.
-
getReferencedSet
JBitSet getReferencedSet()
Return the referencedSet.- Returns:
- JBitSet The referencedSet.
-
setEquivalenceClass
void setEquivalenceClass(int equivalenceClass)
Set the equivalence class, if any, for this predicate.- Parameters:
equivalenceClass
- The equivalence class for this predicate.
-
getEquivalenceClass
int getEquivalenceClass()
Get the equivalenceClass for this predicate.- Returns:
- The equivalenceClass for this predicate.
-
categorize
void categorize() throws StandardException
Categorize this predicate. Initially, this means building a bit map of the referenced tables for each predicate.- Throws:
StandardException
- Thrown on error
-
getRelop
RelationalOperator getRelop()
Get the RelationalOperator on the left side of the AND node, if there is one. If the left side is not a RelationalOperator, return null.- Returns:
- The RelationalOperator on the left side of the AND node, if any.
-
isOrList
final boolean isOrList()
-
isStoreQualifier
final boolean isStoreQualifier()
Is this predicate a possible Qualifier for store?Current 2 types of predicates can be pushed to store: 1) RelationalOperator - represented with by left operand as instance of RelationalOperator. 2) A single And'd term of a list of OR terms represented by left operand as instance of OrNode. More checking specific operator's terms to see if they are finally pushable to store. In the final push at execution each term of the AND or OR must be a Relational operator with a column reference on one side and a constant on the other.
- Returns:
- true if term is wither a AND of a RelationalOperator, or an OR of one or more Relational Operators.
- Throws:
StandardException
- Standard exception policy.
-
isPushableOrClause
final boolean isPushableOrClause(Optimizable optTable) throws StandardException
Is this predicate an pushable OR list?Does the predicate represent a AND'd list of OR term's, all of which are pushable. To be pushable each of OR terms must be a legal qualifier, which is a column reference on one side of a Relational operator and a constant on the other.
- Returns:
- true if the predicate is a pushable set of OR clauses.
- Throws:
StandardException
- Standard exception policy.
-
transitiveSearchClauseAdded
boolean transitiveSearchClauseAdded(RelationalOperator ro)
Return whether or not this predicate has been used to add a new search clause of the specified type via transitive closure. NOTE: This can only be true if this is an equijoin between 2 column references.- Parameters:
ro
- The search clause that we are currently considering as the source for transitive closure- Returns:
- Whether or not this predicate has been used to add a new search clause of the specified type via transitive closure.
-
setTransitiveSearchClauseAdded
void setTransitiveSearchClauseAdded(RelationalOperator ro)
Mark this predicate as having been used to add a new predicate of the specified type via transitive closure on search clauses.- Parameters:
ro
- The search clause that we are currently considering as the source for transitive closure
-
getStartOperator
int getStartOperator(Optimizable optTable)
Get the start operator for this predicate for a scan.- Parameters:
optTable
- The optimizable table, so we can tell which side of the operator the search column is on.- Returns:
- The start operator for a start key on this column.
-
getStopOperator
int getStopOperator(Optimizable optTable)
-
setIndexPosition
void setIndexPosition(int indexPosition)
Set the position of the index column that this predicate restricts- Parameters:
indexPosition
- The position of the index column that this predicate restricts.
-
clearScanFlags
void clearScanFlags()
Clear the start/stop position and qualifier flags
-
generateExpressionOperand
void generateExpressionOperand(Optimizable optTable, int columnPosition, ExpressionClassBuilder acb, MethodBuilder mb) throws StandardException
- Throws:
StandardException
-
toString
public java.lang.String toString()
Convert this object to a String. See comments in QueryTreeNode.java for how this should be done for tree printing.- Overrides:
toString
in classQueryTreeNode
- Returns:
- This object as a String
-
binaryRelOpColRefsToString
java.lang.String binaryRelOpColRefsToString()
Get a string version of the column references for this predicate IF it's a binary relational operator. We only print out the names of the operands if they are column references; otherwise we just print a dummy value. This is for debugging purposes only--it's a convenient way to see what columns the predicate is referencing, especially when tracing through code and printing assert failure.
-
printSubNodes
void printSubNodes(int depth)
Prints the sub-nodes of this object. See QueryTreeNode.java for how tree printing is supposed to work.- Overrides:
printSubNodes
in classQueryTreeNode
- Parameters:
depth
- The depth of this node in the tree
-
acceptChildren
void acceptChildren(Visitor v) throws StandardException
Accept the visitor for all visitable children of this node.- Overrides:
acceptChildren
in classQueryTreeNode
- Parameters:
v
- the visitor- Throws:
StandardException
- on error
-
copyFields
void copyFields(Predicate otherPred)
Copy all fields of this Predicate (except the two that are set from 'init').
-
pushableToSubqueries
protected boolean pushableToSubqueries() throws StandardException
Determine whether or not this predicate is eligible for push-down into subqueries. Right now the only predicates we consider to be eligible are those which 1) are Binary Relational operator nodes and 2) have a column reference on BOTH sides, each of which has a reference to a base table somewhere beneath it.- Returns:
- Whether or not this predicate is eligible to be pushed into subqueries.
- Throws:
StandardException
-
isJoinPredicate
protected boolean isJoinPredicate()
Is this predicate a join predicate? In order to be so, it must be a binary relational operator node that has a column reference on both sides.- Returns:
- Whether or not this is a join predicate.
-
getPredScopedForResultSet
protected Predicate getPredScopedForResultSet(JBitSet parentRSNsTables, ResultSetNode childRSN, int[] whichRC) throws StandardException
If this predicate's operator is a BinaryRelationalOperatorNode, then look at the operands and return a new, equivalent predicate that is "scoped" to the received ResultSetNode. By "scoped" we mean that the operands, which shold be column references, have been mapped to the appropriate result columns in the received RSN. This is useful for pushing predicates from outer queries down into inner queries, in which case the column references need to be remapped. For example, let V1 represent select i,j from t1 UNION select i,j from t2 and V2 represent select a,b from t3 UNION select a,b from t4 Then assume we have the following query: select * from V1, V2 where V1.j = V2.b Let's further assume that this Predicate object represents the "V1.j = V2.b" operator and that the childRSN we received as a parameter represents one of the subqueries to which we want to push the predicate; let's say it's: select i,j from t1 Then this method will return a new predicate whose binary operator represents the expression "T1.j = V2.b" (that is, V1.j will be mapped to the corresponding column in T1). For more on how that mapping is made, see the "getScopedOperand()" method in BinaryRelationalOperatorNode.java. ASSUMPTION: We should only get to this method if we know that at least one operand in this predicate can and should be mapped to the received childRSN. For an example of where that check is made, see the pushOptPredicate() method in SetOperatorNode.java.- Parameters:
parentRSNsTables
- Set of all table numbers referenced by the ResultSetNode that is _parent_ to the received childRSN. We need this to make sure we don't scope the operands to a ResultSetNode to which they don't apply.childRSN
- The result set node for which we want to create a scoped predicate.whichRC
- If not -1 then this tells us which ResultColumn in the received childRSN we need to use for the scoped predicate; if -1 then the column position of the scoped column reference will be stored in this array and passed back to the caller.- Returns:
- A new predicate whose operands have been scoped to the received childRSN.
- Throws:
StandardException
-
markAsScopedForPush
protected void markAsScopedForPush()
Indicate that this predicate is a scoped copy of some other predicate (i.e. it was created as the result of a call to getPredScopedForResultSet() on some other predicate).
-
isScopedForPush
protected boolean isScopedForPush()
Return whether or not this predicate is a scoped copy of another predicate.
-
remapScopedPred
protected boolean remapScopedPred()
When remapping a "normal" (i.e. non-scoped) predicate both of the predicate's operands are remapped and that's it. But when remapping a scoped predicate, things are slightly different. This method handles remapping of scoped predicates. We know that, for a scoped predicate, exactly one operand has been scoped for a specific target result set; the other operand is pointing to some other instance of FromTable with which the target result set is to be joined (see getScopedOperand() in BinaryRelationalOperatorNode.java). For every level of the query through which the scoped predicate is pushed, we have to perform a remap operation of the scoped operand. We do *not*, however, remap the non-scoped operand. The reason is that the non-scoped operand is already pointing to the result set against which it must be evaluated. As the scoped predicate is pushed down the query tree, the non-scoped operand should not change where it's pointing and thus should not be remapped. For example, assume we have a query whose tree has the following form: SELECT[0] / \ PRN PRN | | SELECT[4] UNION | / \ PRN SELECT[1] SELECT[2] | | | [FBT:T1] PRN PRN | | SELECT[3] [FromBaseTable:T2] | PRN | [FromBaseTable:T3] Assume also that we have some predicate "SELECT[4].i =.j". If the optimizer decides to push the predicate to the UNION node, it (the predicate) will be scoped to the UNION's children, yielding something like "SELECT[4].i = SELECT[1].j" for the left child and "SELECT[4].i = SELECT[2].j" for the right child. These scoped predicates will then be pushed to the PRNs above SELECT[3] and T2, respectively. As part of that pushing process a call to PRN.pushOptPredicate() will occur, which brings us to this method. So let's assume we're here for the scoped predicate "SELECT[4].i = SELECT[1].j". Then we want to remap the scoped operand, "SELECT[1].j", so that it will point to the correct column in "SELECT[3]". We do NOT, however, want to remap the non-scoped operand "SELECT[4].i" because that operand is already pointing to the correct result set--namely, to a column in SELECT[4]. That non-scoped operand should not change regardless of how far down the UNION subtree the scoped predicate is pushed. If we did try to remap the non-scoped operand, it would end up pointing to result sets too low in the tree, which could lead to execution-time errors. So when we remap a scoped predicate, we have to make sure we only remap the scoped operand. That's what this method does. - Returns:
- True if this predicate is a scoped predicate, in which case we performed a one-sided remap. False if the predicate is not scoped; the caller can then make the calls to perform a "normal" remap on this predicate.
-
isScopedToSourceResultSet
protected boolean isScopedToSourceResultSet() throws StandardException
Return true if this predicate is scoped AND the scoped operand is a ColumnReference that points to a source result set. If the scoped operand is not a ColumnReference that points to a source result set then it must be pointing to some kind of expression, such as a literal (ex. 'strlit'), an aggregate value (ex. "count(*)"), or the result of a function (ex. "sin(i)") or operator (ex. "i+1"). This method is used when pushing predicates to determine how far down the query tree a scoped predicate needs to be pushed to allow for successful evaluation of the scoped operand. If the scoped operand is not pointing to a source result set then it should not be pushed any further down tree. The reason is that evaluation of the expression to which the operand is pointing may depend on other values from the current level in the tree (ex. "sin(i)" depends on the value of "i", which could be a column at the predicate's current level). If we pushed the predicate further down, those values could become inaccessible, leading to execution-time errors. If, on the other hand, the scoped operand *is* pointing to a source result set, then we want to push it further down the tree until it reaches that result set, which allows evaluation of this predicate to occur as close to store as possible. This method doesn't actually do the push, it just returns "true" and then the caller can push as appropriate.- Throws:
StandardException
-
isRelationalOpPredicate
protected boolean isRelationalOpPredicate()
Return whether or not this predicate corresponds to a legitimate relational operator.- Returns:
- False if there is no relational operator for this predicate OR if this predicate is an internal "probe predicate" (in which case it "looks" like we have a relational operator but in truth it's a disguised IN-list operator). True otherwise.
-
isInListProbePredicate
protected boolean isInListProbePredicate()
Return whether or not this predicate is an IN-list probe predicate.
-
getSourceInList
protected InListOperatorNode getSourceInList()
If this predicate corresponds to an IN-list, return the underlying InListOperatorNode from which it was built. There are two forms to check for: 1. This predicate is an IN-list "probe predicate", in which case the underlying InListOpNode is stored within the binary relational operator that is the left operand of this predicate's AND node. 2. This predicate corresponds to an IN-list that could _not_ be transformed into a "probe predicate" (i.e. the IN-list contains one or more non-parameter, non-constant values). In that case the underlying InListOpNode is simply the left operand of this predicate's AND node. If this predicate does not correspond to an IN-list in any way, this method will return null.
-
getSourceInList
protected InListOperatorNode getSourceInList(boolean probePredOnly)
Does the work of getSourceInList() above, but can also be called directly with an argument to indicate whether or not we should limit ourselves to probe predicates.- Parameters:
probePredOnly
- If true, only get the source IN list for this predicate *if* it is an IN-list probe predicate. If false, return the underlying InListOperatorNode (if it exists) regardless of whether this is a probe predicate or an un-transformed IN-list pred.- Returns:
- Underlying InListOp for this predicate (depending on the value of probePredOnly), or null if this predicate does not correspond to an IN-list in any way.
-
-