org.apache.derby.impl.sql.compile
Class FromList

java.lang.Object
  extended byorg.apache.derby.impl.sql.compile.QueryTreeNode
      extended byorg.apache.derby.impl.sql.compile.QueryTreeNodeVector
          extended byorg.apache.derby.impl.sql.compile.FromList
All Implemented Interfaces:
OptimizableList, Visitable

public class FromList
extends QueryTreeNodeVector
implements OptimizableList

A FromList represents the list of tables in a FROM clause in a DML statement. It extends QueryTreeNodeVector.

Author:
Jeff Lichtman

Field Summary
(package private)  boolean fixedJoinOrder
           
(package private)  java.util.Properties properties
           
(package private)  boolean useStatistics
           
 
Fields inherited from class org.apache.derby.impl.sql.compile.QueryTreeNode
AUTOINCREMENT_INC_INDEX, AUTOINCREMENT_IS_AUTOINCREMENT_INDEX, AUTOINCREMENT_START_INDEX, beginOffset, endOffset
 
Constructor Summary
FromList()
           
 
Method Summary
 Visitable accept(Visitor v)
          Accept a visitor, and call v.visit() on child nodes as necessary.
 void addElement(QueryTreeNode qt)
           
 void addFromTable(FromTable fromTable)
          Add a table to the FROM list.
 ResultColumn bindColumnReference(ColumnReference columnReference)
          Bind a column reference to one of the tables in this FromList.
 void bindExpressions()
          Bind the expressions in this FromList.
 void bindResultColumns(FromList fromListParam)
          Bind the result columns of the ResultSetNodes in this FromList when there is no base table to bind them to.
 void bindTables(DataDictionary dataDictionary, FromList fromListParam)
          Bind the tables in this FromList.
 void bindUntypedNullsToResultColumns(ResultColumnList bindingRCL)
          Bind any untyped null nodes to the types in the given ResultColumnList.
(package private)  void decrementLevel(int decrement)
          Decrement (query block) level (0-based) for all of the tables in this from list.
 void destructiveAppend(QueryTreeNodeVector qtnv)
           
 QueryTreeNode elementAt(int index)
           
 ResultColumnList expandAll(java.lang.String allTableName)
          Expand a "*" into the appropriate ResultColumnList.
 void flattenFromTables(ResultColumnList rcl, PredicateList predicateList, SubqueryList sql, GroupByList gbl)
          Flatten all the FromTables that are flattenable.
(package private)  void genExistsBaseTables(JBitSet referencedTableMap, FromList outerFromList, boolean isNotExists)
          Mark all of the FromBaseTables in the list as EXISTS FBTs.
protected  FromTable getFromTableByName(java.lang.String name, java.lang.String schemaName, boolean exactMatch)
          Determine whether or not the specified name is an exposed name in the current query block.
 FromTable getFromTableByResultColumn(ResultColumn rc)
          Get the FromTable from this list which has the specified ResultColumn in its RCL.
 Optimizable getOptimizable(int index)
          Return the nth Optimizable in the list.
(package private)  int[] getTableNumbers()
           
(package private)  boolean hashJoinSpecified()
          Return whether or not the user specified a hash join for any of the tables in this list.
 boolean hasOuterJoins()
          Returns true if any Outer joins present.
(package private)  int indexOf(QueryTreeNode qt)
           
 void init(java.lang.Object optimizeJoinOrder)
          Initializer for a FromList
 void init(java.lang.Object optimizeJoinOrder, java.lang.Object fromTable)
          Initializer for a FromList
 void initAccessPaths(Optimizer optimizer)
          Init the access paths for these optimizables.
(package private)  void insertElementAt(QueryTreeNode qt, int index)
           
 boolean legalJoinOrder(int numTablesInQuery)
          Tell whether the join order is legal.
 boolean LOJ_reorderable(int numTables)
           
(package private)  void markStatementResultSet()
          Move the mark for result set being the statement's outermost result set down into the first table of the from list.
 void nondestructiveAppend(QueryTreeNodeVector qtnv)
           
 boolean optimizeJoinOrder()
          Tell whether the join order should be optimized.
 void preprocess(int numTables, GroupByList gbl, ValueNode predicateTree)
          Preprocess the query tree - this currently means: o Generating a referenced table map for each ResultSetNode.
 void printSubNodes(int depth)
          Prints the sub-nodes of this object.
(package private)  void pushPredicates(PredicateList predicateList)
          Categorize and push the predicates that are pushable.
 boolean referencesSessionSchema()
          Return true if the node references SESSION schema tables (temporary or permanent)
 boolean referencesTarget(java.lang.String name, boolean baseTable)
          Search to see if a query references the specifed table name.
 void rejectParameters()
          Check for (and reject) all ?
(package private)  java.lang.Object remove(int index)
           
(package private)  void removeAllElements()
           
(package private)  void removeElement(QueryTreeNode qt)
           
(package private)  void removeElementAt(int index)
           
 void reOrder(int[] joinOrder)
          Set the join order for this list of optimizables.
(package private)  boolean returnsAtMostSingleRow(ResultColumnList rcl, ValueNode whereClause, PredicateList wherePredicates, DataDictionary dd)
          This method is used for both subquery flattening and distinct elimination based on a uniqueness condition.
(package private)  void setElementAt(QueryTreeNode qt, int index)
           
 void setLevel(int level)
          Set the (query block) level (0-based) for the FromTables in this FromList.
 void setOptimizable(int index, Optimizable optimizable)
          Set the nth Optimizable to the specified Optimizable.
 void setProperties(java.util.Properties props)
          Set the Properties list for this FromList.
 int size()
          Return the number of Optimizables in the list.
 java.lang.String toString()
          Format this list as a string We can simply iterate through the list.
 int updateTargetLockMode()
          Get the lock mode for the target of an update statement (a delete or update).
 boolean useStatistics()
          user can specify that s/he doesn't want statistics to be considered when optimizing the query.
 void verifyProperties(DataDictionary dDictionary)
          Verify that the Properties list with optimizer overrides, if specified, is valid
 
Methods inherited from class org.apache.derby.impl.sql.compile.QueryTreeNode
bind, convertDefaultNode, debugFlush, debugPrint, executeSchemaName, executeStatementName, formatNodeString, foundString, generate, generate, generateAuthorizeCheck, getBeginOffset, getClassFactory, getCompilerContext, getContextManager, getCursorInfo, getDataDictionary, getDependencyManager, getEndOffset, getExecutionFactory, getGenericConstantActionFactory, getIntProperty, getLanguageConnectionContext, getNodeFactory, getNodeType, getNullNode, getParameterTypes, getRowEstimate, getSchemaDescriptor, getSchemaDescriptor, getSPSName, getStatementType, getTableDescriptor, getTypeCompiler, init, init, init, init, init, init, init, init, init, init, init, init, isAtomic, isInstanceOf, isSessionSchema, isSessionSchema, makeConstantAction, makeResultDescription, makeTableName, needsSavepoint, nodeHeader, optimize, parseQueryText, printLabel, setBeginOffset, setContextManager, setEndOffset, setNodeType, setRefActionInfo, treePrint, treePrint, verifyClassExist
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
 
Methods inherited from interface org.apache.derby.iapi.sql.compile.OptimizableList
size
 

Field Detail

properties

java.util.Properties properties

fixedJoinOrder

boolean fixedJoinOrder

useStatistics

boolean useStatistics
Constructor Detail

FromList

public FromList()
Method Detail

init

public void init(java.lang.Object optimizeJoinOrder)
Initializer for a FromList

Overrides:
init in class QueryTreeNode

init

public void init(java.lang.Object optimizeJoinOrder,
                 java.lang.Object fromTable)
          throws StandardException
Initializer for a FromList

Overrides:
init in class QueryTreeNode
Throws:
StandardException - Thrown on error

getOptimizable

public Optimizable getOptimizable(int index)
Description copied from interface: OptimizableList
Return the nth Optimizable in the list.

Specified by:
getOptimizable in interface OptimizableList
Parameters:
index - "index" (0 based) into the list.
Returns:
Optimizable The nth Optimizables in the list.
See Also:
OptimizableList.getOptimizable(int)

setOptimizable

public void setOptimizable(int index,
                           Optimizable optimizable)
Description copied from interface: OptimizableList
Set the nth Optimizable to the specified Optimizable.

Specified by:
setOptimizable in interface OptimizableList
Parameters:
index - "index" (0 based) into the list.
optimizable - New nth Optimizable.
Returns:
Nothing.
See Also:
OptimizableList.setOptimizable(int, org.apache.derby.iapi.sql.compile.Optimizable)

verifyProperties

public void verifyProperties(DataDictionary dDictionary)
                      throws StandardException
Description copied from interface: OptimizableList
Verify that the Properties list with optimizer overrides, if specified, is valid

Specified by:
verifyProperties in interface OptimizableList
Parameters:
dDictionary - The DataDictionary to use.
Returns:
Nothing.
Throws:
StandardException - Thrown on error
See Also:
OptimizableList.verifyProperties(org.apache.derby.iapi.sql.dictionary.DataDictionary)

addFromTable

public void addFromTable(FromTable fromTable)
                  throws StandardException
Add a table to the FROM list.

Parameters:
fromTable - A FromTable to add to the list
Returns:
Nothing
Throws:
StandardException - Thrown on error

referencesTarget

public boolean referencesTarget(java.lang.String name,
                                boolean baseTable)
                         throws StandardException
Search to see if a query references the specifed table name.

Parameters:
name - Table name (String) to search for.
baseTable - Whether or not name is for a base table
Returns:
true if found, else false
Throws:
StandardException - Thrown on error

referencesSessionSchema

public boolean referencesSessionSchema()
                                throws StandardException
Return true if the node references SESSION schema tables (temporary or permanent)

Overrides:
referencesSessionSchema in class QueryTreeNode
Returns:
true if references SESSION schema tables, else false
Throws:
StandardException - Thrown on error

getFromTableByName

protected FromTable getFromTableByName(java.lang.String name,
                                       java.lang.String schemaName,
                                       boolean exactMatch)
                                throws StandardException
Determine whether or not the specified name is an exposed name in the current query block.

Parameters:
name - The specified name to search for as an exposed name.
schemaName - Schema name, if non-null.
exactMatch - Whether or not we need an exact match on specified schema and table names or match on table id.
Returns:
The FromTable, if any, with the exposed name.
Throws:
StandardException - Thrown on error

bindTables

public void bindTables(DataDictionary dataDictionary,
                       FromList fromListParam)
                throws StandardException
Bind the tables in this FromList. This includes looking them up in the DataDictionary, getting their TableDescriptors and assigning the table numbers.

Parameters:
dataDictionary - The DataDictionary to use for binding
fromListParam - FromList to use/append to.
Returns:
Nothing.
Throws:
StandardException - Thrown on error

bindExpressions

public void bindExpressions()
                     throws StandardException
Bind the expressions in this FromList. This means binding the sub-expressions, as well as figuring out what the return type is for each expression.

Returns:
Nothing
Throws:
StandardException - Thrown on error

bindResultColumns

public void bindResultColumns(FromList fromListParam)
                       throws StandardException
Bind the result columns of the ResultSetNodes in this FromList when there is no base table to bind them to. This is useful for SELECT statements, where the result columns get their types from the expressions that live under them.

Parameters:
fromListParam - FromList to use/append to.
Returns:
Nothing
Throws:
StandardException - Thrown on error

hasOuterJoins

public boolean hasOuterJoins()
                      throws StandardException
Returns true if any Outer joins present. Used to set Nullability

Returns:
True if has any outer joins. False otherwise.
Throws:
StandardException

expandAll

public ResultColumnList expandAll(java.lang.String allTableName)
                           throws StandardException
Expand a "*" into the appropriate ResultColumnList. If the "*" is unqualified it will expand into a list of all columns in all of the base tables in the from list, otherwise it will expand into a list of all of the columns in the base table that matches the qualification.

Parameters:
allTableName - The qualification on the "*" as a String.
Returns:
ResultColumnList representing expansion
Throws:
StandardException - Thrown on error

bindColumnReference

public ResultColumn bindColumnReference(ColumnReference columnReference)
                                 throws StandardException
Bind a column reference to one of the tables in this FromList. The column name must be unique within the tables in the FromList. An exception is thrown if a column name is not unique. NOTE: Callers are responsible for ordering the FromList by nesting level, with tables at the deepest (current) nesting level first. We will try to match against all FromTables at a given nesting level. If no match is found at a nesting level, then we proceed to the next level. We stop walking the list when the nesting level changes and we have found a match. NOTE: If the ColumnReference is qualified, then we will stop the search at the first nesting level where there is a match on the exposed table name. For example, s (a, b, c), t (d, e, f) select * from s where exists (select * from t s where s.c = a) will not find a match for s.c, which is the expected ANSI behavior. bindTables() must have already been called on this FromList before calling this method.

Parameters:
columnReference - The ColumnReference describing the column to bind
Returns:
ResultColumn The matching ResultColumn
Throws:
StandardException - Thrown on error

rejectParameters

public void rejectParameters()
                      throws StandardException
Check for (and reject) all ? parameters directly under the ResultColumns. This is done for SELECT statements.

Returns:
Nothing
Throws:
StandardException - Thrown if a ? parameter found directly under a ResultColumn

LOJ_reorderable

public boolean LOJ_reorderable(int numTables)
                        throws StandardException
Throws:
StandardException

preprocess

public void preprocess(int numTables,
                       GroupByList gbl,
                       ValueNode predicateTree)
                throws StandardException
Preprocess the query tree - this currently means: o Generating a referenced table map for each ResultSetNode. o Putting the WHERE and HAVING clauses in conjunctive normal form (CNF). o Converting the WHERE and HAVING clauses into PredicateLists and classifying them. o Flatten those FromSubqueries which can be flattened. o Ensuring that a ProjectRestrictNode is generated on top of every FromBaseTable and generated in place of every FromSubquery which could not be flattened. o Pushing single table predicates down to the new ProjectRestrictNodes.

Parameters:
numTables - The number of tables in the DML Statement
gbl - The group by list, if any
Returns:
Nothing.
Throws:
StandardException - Thrown on error

flattenFromTables

public void flattenFromTables(ResultColumnList rcl,
                              PredicateList predicateList,
                              SubqueryList sql,
                              GroupByList gbl)
                       throws StandardException
Flatten all the FromTables that are flattenable. RESOLVE - right now we just flatten FromSubqueries. We should also flatten flattenable JoinNodes here.

Parameters:
rcl - The RCL from the outer query
predicateList - The PredicateList from the outer query
sql - The SubqueryList from the outer query
gbl - The group by list, if any
Throws:
StandardException - Thrown on error

pushPredicates

void pushPredicates(PredicateList predicateList)
              throws StandardException
Categorize and push the predicates that are pushable.

Parameters:
predicateList - The query's PredicateList
Throws:
StandardException - Thrown on error

printSubNodes

public 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 class QueryTreeNode
Parameters:
depth - The depth of this node in the tree
Returns:
Nothing

setLevel

public void setLevel(int level)
Set the (query block) level (0-based) for the FromTables in this FromList.

Parameters:
level - The query block level for this table.
Returns:
Nothing

markStatementResultSet

void markStatementResultSet()
Move the mark for result set being the statement's outermost result set down into the first table of the from list. Generally expect there is only one table at this point.


getFromTableByResultColumn

public FromTable getFromTableByResultColumn(ResultColumn rc)
Get the FromTable from this list which has the specified ResultColumn in its RCL.

Parameters:
rc - The ResultColumn match on.
Returns:
FromTable The matching FromTable.

setProperties

public void setProperties(java.util.Properties props)
                   throws StandardException
Set the Properties list for this FromList.

Throws:
StandardException - Thrown on error

reOrder

public void reOrder(int[] joinOrder)
Description copied from interface: OptimizableList
Set the join order for this list of optimizables. The join order is represented as an array of integers - each entry in the array stands for the order of the corresponding element in the list. For example, a joinOrder of {2, 0, 1} means that the 3rd Optimizable in the list (element 2, since we are zero-based) is the first one in the join order, followed by the 1st element in the list, and finally by the 2nd element in the list. This method shuffles this OptimizableList to match the join order. Obviously, the size of the array must equal the number of elements in the array, and the values in the array must be between 0 and the number of elements in the array minus 1, and the values in the array must be unique.

Specified by:
reOrder in interface OptimizableList
See Also:
OptimizableList.reOrder(int[])

useStatistics

public boolean useStatistics()
Description copied from interface: OptimizableList
user can specify that s/he doesn't want statistics to be considered when optimizing the query.

Specified by:
useStatistics in interface OptimizableList
See Also:
OptimizableList.useStatistics()

optimizeJoinOrder

public boolean optimizeJoinOrder()
Description copied from interface: OptimizableList
Tell whether the join order should be optimized.

Specified by:
optimizeJoinOrder in interface OptimizableList
See Also:
OptimizableList.optimizeJoinOrder()

legalJoinOrder

public boolean legalJoinOrder(int numTablesInQuery)
Description copied from interface: OptimizableList
Tell whether the join order is legal.

Specified by:
legalJoinOrder in interface OptimizableList
See Also:
OptimizableList.legalJoinOrder(int)

initAccessPaths

public void initAccessPaths(Optimizer optimizer)
Description copied from interface: OptimizableList
Init the access paths for these optimizables.

Specified by:
initAccessPaths in interface OptimizableList
Parameters:
optimizer - The optimizer being used.
Returns:
Nothing.
See Also:
OptimizableList.initAccessPaths(org.apache.derby.iapi.sql.compile.Optimizer)

bindUntypedNullsToResultColumns

public void bindUntypedNullsToResultColumns(ResultColumnList bindingRCL)
                                     throws StandardException
Bind any untyped null nodes to the types in the given ResultColumnList.

Parameters:
bindingRCL - The ResultColumnList with the types to bind to.
Throws:
StandardException - Thrown on error

decrementLevel

void decrementLevel(int decrement)
Decrement (query block) level (0-based) for all of the tables in this from list. This is useful when flattening a subquery.

Parameters:
decrement - The amount to decrement by.
Returns:
Nothing;

returnsAtMostSingleRow

boolean returnsAtMostSingleRow(ResultColumnList rcl,
                               ValueNode whereClause,
                               PredicateList wherePredicates,
                               DataDictionary dd)
                         throws StandardException
This method is used for both subquery flattening and distinct elimination based on a uniqueness condition. For subquery flattening we want to make sure that the query block will return at most 1 row. For distinct elimination we want to make sure that the query block will not return any duplicates. This is true if every table in the from list is (a base table and the set of columns from the table that are in equality comparisons with expressions that do not include columns from the same table is a superset of any unique index on the table) or an EXISTS FBT. In addition, at least 1 of the tables in the list has a set of columns in equality comparisons with expressions that do not include column references from the same query block is a superset of a unique index on that table. (This ensures that the query block will onlyr return a single row.) This method is expected to be called after normalization and after the from list has been preprocessed. It can be called both before and after the predicates have been pulled from the where clause. The algorithm for this is as follows If any table in the query block is not a base table, give up. For each table in the query Ignore exists table since they can only produce one row create a matrix of tables and columns from the table (tableColMap) (this is used to keep track of the join columns and constants that can be used to figure out whether the rows from a join or in a select list are distinct based on unique indexes) create an array of columns from the table(eqOuterCol) (this is used to determine that only one row will be returned from a join) if the current table is the table for the result columns set the result columns in the eqOuterCol and tableColMap (if these columns are a superset of a unique index and all joining tables result in only one row, the results will be distinct) go through all the predicates and update tableColMap and eqOuterCol with join columns and correlation variables, parameters and constants since setting constants, correlation variables and parameters, reduces the number of columns required for uniqueness in a multi-column index, they are set for all the tables (if the table is not the result table, in this case only the column of the result table is set) join columns are just updated for the column in the row of the joining table. check if the marked columns in tableColMap are a superset of a unique index (This means that the join will only produce 1 row when joined with 1 row of another table) check that there is a least one table for which the columns in eqOuterCol(i.e. constant values) are a superset of a unique index (This quarantees that there will be only one row selected from this table). Once all tables have been evaluated, check that all the tables can be joined by unique index or will have only one row

Parameters:
rcl - If non-null, the RCL from the query block. If non-null for subqueries, then entry can be considered as part of an = comparison.
whereClause - The WHERE clause to consider.
wherePredicates - The predicates that have already been pulled from the WHERE clause.
dd - The DataDictionary to use.
Returns:
Whether or not query block will return at most 1 row for a subquery, no duplicates for a distinct.
Throws:
StandardException - Thrown on error

getTableNumbers

int[] getTableNumbers()

genExistsBaseTables

void genExistsBaseTables(JBitSet referencedTableMap,
                         FromList outerFromList,
                         boolean isNotExists)
                   throws StandardException
Mark all of the FromBaseTables in the list as EXISTS FBTs. Each EBT has the same dependency list - those tables that are referenced minus the tables in the from list.

Parameters:
referencedTableMap - The referenced table map.
outerFromList - FromList from outer query block
isNotExists - Whether or not for NOT EXISTS
Returns:
Nothing.
Throws:
StandardException - Thrown on error

updateTargetLockMode

public int updateTargetLockMode()
Get the lock mode for the target of an update statement (a delete or update). The update mode will always be row for CurrentOfNodes. It will be table if there is no where clause.

Returns:
The lock mode

hashJoinSpecified

boolean hashJoinSpecified()
Return whether or not the user specified a hash join for any of the tables in this list.

Returns:
Whether or not the user specified a hash join for any of the tables in this list.

accept

public Visitable accept(Visitor v)
                 throws StandardException
Accept a visitor, and call v.visit() on child nodes as necessary.

Specified by:
accept in interface Visitable
Overrides:
accept in class QueryTreeNodeVector
Parameters:
v - the visitor
Throws:
StandardException - on error

size

public final int size()

elementAt

public QueryTreeNode elementAt(int index)

addElement

public final void addElement(QueryTreeNode qt)

removeElementAt

final void removeElementAt(int index)

removeElement

final void removeElement(QueryTreeNode qt)

remove

final java.lang.Object remove(int index)

indexOf

final int indexOf(QueryTreeNode qt)

setElementAt

final void setElementAt(QueryTreeNode qt,
                        int index)

destructiveAppend

public void destructiveAppend(QueryTreeNodeVector qtnv)

nondestructiveAppend

public void nondestructiveAppend(QueryTreeNodeVector qtnv)

removeAllElements

final void removeAllElements()

insertElementAt

final void insertElementAt(QueryTreeNode qt,
                           int index)

toString

public java.lang.String toString()
Format this list as a string We can simply iterate through the list. Note each list member is a QueryTreeNode, and so should have its specialization of toString defined.

Overrides:
toString in class QueryTreeNode
Returns:
This list formatted as a String


Apache Derby V10.0 Engine Documentation - Copyright © 1997,2004 The Apache Software Foundation or its licensors, as applicable.