FromList (Apache Derby V10.14 Internals)

java.lang.Object
- org.apache.derby.impl.sql.compile.QueryTreeNode
- - org.apache.derby.impl.sql.compile.QueryTreeNodeVector<ResultSetNode>
  - - org.apache.derby.impl.sql.compile.FromList

All Implemented Interfaces:

java.lang.Iterable<ResultSetNode>, OptimizableList, Visitable
```
class FromList
extends QueryTreeNodeVector<ResultSetNode>
implements OptimizableList
```
A FromList represents the list of tables in a FROM clause in a DML statement. It extends QueryTreeNodeVector.

Field Summary

Fields
Modifier and Type	Field	Description
`(package private) boolean`	`fixedJoinOrder`
`private boolean`	`isTransparent`
`(package private) java.util.Properties`	`properties`
`private boolean`	`referencesSessionSchema`
`(package private) boolean`	`useStatistics`
`private WindowList`	`windows`	Window definitions used for resolving window functions not containing in-line window specifications, but referring window definitions

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

Fields inherited from class org.apache.derby.impl.sql.compile.QueryTreeNodeVector
eltClass

Constructor Summary

Constructors
Constructor	Description
`FromList(boolean optimizeJoinOrder, ContextManager cm)`	Constructor for a FromList
`FromList(boolean optimizeJoinOrder, FromTable fromTable, ContextManager cm)`	Constructor for a FromList
`FromList(ContextManager cm)`	Does not change the default for join order optimization, i.e.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`(package private) void`	`addFromTable(FromTable fromTable)`	Add a table to the FROM list.
`(package private) ResultColumn`	`bindColumnReference(ColumnReference columnReference)`	Bind a column reference to one of the tables in this FromList.
`(package private) void`	`bindExpressions(FromList fromListParam)`	Bind the expressions in this FromList.
`(package private) void`	`bindResultColumns(FromList fromListParam)`	Bind the result columns of the ResultSetNodes in this FromList when there is no base table to bind them to.
`(package private) void`	`bindTables(DataDictionary dataDictionary, FromList fromListParam)`
`(package private) void`	`bindUntypedNullsToResultColumns(ResultColumnList bindingRCL)`	Bind any untyped null nodes to the types in the given ResultColumnList.
`private void`	`constructorMinion(boolean optimizeJoinOrder)`
`(package private) void`	`decrementLevel(int decrement)`	Decrement (query block) level (0-based) for all of the tables in this from list.
`(package private) ResultColumnList`	`expandAll(TableName allTableName)`	Expand a "*" into the appropriate ResultColumnList.
`(package private) void`	`flattenFromTables(ResultColumnList rcl, PredicateList predicateList, SubqueryList sql, GroupByList gbl, ValueNode havingClause)`	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.
`(package private) 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.
`(package private) 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) WindowList`	`getWindows()`
`(package private) boolean`	`hashJoinSpecified()`	Return whether or not the user specified a hash join for any of the tables in this list.
`void`	`initAccessPaths(Optimizer optimizer)`	Init the access paths for these optimizables.
`(package private) void`	`isJoinColumnForRightOuterJoin(ResultColumn rc)`	Go through the list of the tables and see if the passed ResultColumn is a join column for a right outer join with USING/NATURAL clause.
`boolean`	`legalJoinOrder(int numTablesInQuery)`	Tell whether the join order is legal.
`(package private) boolean`	`LOJ_reorderable(int numTables)`
`(package private) void`	`markAsTransparent()`	Indicate that this FromList is "transparent", which means that its FromTables should be bound to tables from an outer query.
`boolean`	`optimizeJoinOrder()`	Tell whether the join order should be optimized.
`(package private) void`	`preprocess(int numTables, GroupByList gbl, ValueNode predicateTree)`	Preprocess the query tree - this currently means: o Generating a referenced table map for each ResultSetNode.
`(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)
`(package private) boolean`	`referencesTarget(java.lang.String name, boolean baseTable)`	Search to see if a query references the specifed table name.
`(package private) void`	`rejectParameters()`	Check for (and reject) all ?
`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`	`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.
`(package private) void`	`setProperties(java.util.Properties props)`	Set the Properties list for this FromList.
`(package private) void`	`setWindows(WindowList windows)`	Set windows field to the supplied value.
`(package private) boolean`	`tableNumberIsNotExists(int tableNumber)`	determine whether this table is NOT EXISTS.
`(package private) 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 interface java.lang.Iterable
forEach, spliterator

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

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, resolveTableToSynonym, setBeginOffset, setEndOffset, setRefActionInfo, stackPrint, taggedWith, toString, treePrint, treePrint, verifyClassExist

Methods inherited from class org.apache.derby.impl.sql.compile.QueryTreeNodeVector
acceptChildren, addElement, destructiveAppend, elementAt, indexOf, insertElementAt, iterator, nondestructiveAppend, printSubNodes, removeAllElements, removeElement, removeElementAt, setElementAt, size

- Field Detail
  - properties
```
java.util.Properties properties
```
  - fixedJoinOrder
```
boolean fixedJoinOrder
```
  - useStatistics
```
boolean useStatistics
```
  - referencesSessionSchema
```
private boolean referencesSessionSchema
```
  - isTransparent
```
private boolean isTransparent
```
  - windows
```
private WindowList windows
```
    Window definitions used for resolving window functions not containing in-line window specifications, but referring window definitions
- Constructor Detail
  - FromList
```
FromList(ContextManager cm)
```
    Does not change the default for join order optimization, i.e. false.
    
    Parameters:
    
    cm - context manager
  - FromList
```
FromList(boolean optimizeJoinOrder,
         ContextManager cm)
```
    Constructor for a FromList
    
    Parameters:
    
    optimizeJoinOrder - true if join order optimization is to be performed
    
    cm - context manager
  - FromList
```
FromList(boolean optimizeJoinOrder,
         FromTable fromTable,
         ContextManager cm)
  throws StandardException
```
    Constructor for a FromList
    
    Parameters:
    
    optimizeJoinOrder - true if join order optimization is to be performed
    
    fromTable - initialize list with this table
    
    cm - context manager
    
    Throws:
    
    StandardException - Thrown on error
- Method Detail
  - constructorMinion
```
private void constructorMinion(boolean optimizeJoinOrder)
```
  - 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.
    
    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.
    
    Throws:
    
    StandardException - Thrown on error
    
    See Also:
    
    OptimizableList.verifyProperties(org.apache.derby.iapi.sql.dictionary.DataDictionary)
  - addFromTable
```
final void addFromTable(FromTable fromTable)
                 throws StandardException
```
    Add a table to the FROM list.
    
    Parameters:
    
    fromTable - A FromTable to add to the list
    
    Throws:
    
    StandardException - Thrown on error
  - referencesTarget
```
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
```
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
  - isJoinColumnForRightOuterJoin
```
void isJoinColumnForRightOuterJoin(ResultColumn rc)
```
    Go through the list of the tables and see if the passed ResultColumn is a join column for a right outer join with USING/NATURAL clause.
    
    See Also:
    
    HalfOuterJoinNode.isJoinColumnForRightOuterJoin(org.apache.derby.impl.sql.compile.ResultColumn)
  - bindTables
```
void bindTables(DataDictionary dataDictionary,
                FromList fromListParam)
         throws StandardException
```
    Throws:
    
    StandardException
  - bindExpressions
```
void bindExpressions(FromList fromListParam)
              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.
    
    Throws:
    
    StandardException - Thrown on error
  - bindResultColumns
```
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.
    
    Throws:
    
    StandardException - Thrown on error
  - expandAll
```
ResultColumnList expandAll(TableName 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 at the current nesting level; otherwise it will expand into a list of all of the columns in the base table that matches the qualification. NOTE: Callers are responsible for ordering the FromList by nesting level, with tables at the deepest (current) nesting level first. We will expand the "*" into a list of all columns from all tables having the same nesting level as the first FromTable in this list. The check for nesting level exists because it's possible that this FromList includes FromTables from an outer query, which can happen if there is a "transparent" FromList above this one in the query tree. Ex: select j from onerow where exists (select 1 from somerow union select * from diffrow where onerow.j < diffrow.k) If "this" is the FromList for the right child of the UNION then it will contain both "diffrow" and "onerow", the latter of which was passed down via a transparent FromList (to allow binding of the WHERE clause). In that case the "*" should only expand the result columns of "diffrow"; it should not expand the result columns of "onerow" because that table is from an outer query. We can achieve this selective expansion by looking at nesting levels.
    
    Parameters:
    
    allTableName - The qualification on the "*" as a String.
    
    Returns:
    
    ResultColumnList representing expansion
    
    Throws:
    
    StandardException - Thrown on error
  - bindColumnReference
```
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. This method fills in various fields in the column reference.
    
    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, or null if there is no matching column
    
    Throws:
    
    StandardException - Thrown on error
  - rejectParameters
```
void rejectParameters()
               throws StandardException
```
    Check for (and reject) all ? parameters directly under the ResultColumns. This is done for SELECT statements.
    
    Throws:
    
    StandardException - Thrown if a ? parameter found directly under a ResultColumn
  - LOJ_reorderable
```
boolean LOJ_reorderable(int numTables)
                 throws StandardException
```
    Throws:
    
    StandardException
  - preprocess
```
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
    
    Throws:
    
    StandardException - Thrown on error
  - flattenFromTables
```
void flattenFromTables(ResultColumnList rcl,
                       PredicateList predicateList,
                       SubqueryList sql,
                       GroupByList gbl,
                       ValueNode havingClause)
                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
    
    havingClause - The HAVING clause, 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
  - setLevel
```
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.
  - getFromTableByResultColumn
```
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
```
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.
    
    See Also:
    
    OptimizableList.initAccessPaths(org.apache.derby.iapi.sql.compile.Optimizer)
  - bindUntypedNullsToResultColumns
```
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.
  - 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
    
    Throws:
    
    StandardException - Thrown on error
  - tableNumberIsNotExists
```
boolean tableNumberIsNotExists(int tableNumber)
                        throws StandardException
```
    determine whether this table is NOT EXISTS. This routine searches for the indicated table number in the fromlist and returns TRUE if the table is present in the from list and is marked NOT EXISTS, false otherwise. A table may be present in the from list for NOT EXISTS if it is used as a correlated NOT EXISTS subquery. In such a situation, when the subquery is flattened, it is important that we remember that this is a NOT EXISTS subquery, because the join semantics are different (we're looking for rows that do NOT match, rather than rows that do). And since the join semantics are different, we cannot include this table into a transitive closure of equijoins (See DERBY-3033 for a situation where this occurs).
    
    Parameters:
    
    tableNumber - which table to check
    
    Returns:
    
    true if this table is in the from list as NOT EXISTS
    
    Throws:
    
    StandardException
  - updateTargetLockMode
```
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.
  - markAsTransparent
```
void markAsTransparent()
```
    Indicate that this FromList is "transparent", which means that its FromTables should be bound to tables from an outer query. Generally this is not allowed, but there are exceptions. See SetOperatorNode.setResultToBooleanTrueNode() for more.
  - setWindows
```
void setWindows(WindowList windows)
```
    Set windows field to the supplied value.
    
    Parameters:
    
    windows - list of window definitions associated with a SELECT.
  - getWindows
```
WindowList getWindows()
```
    Returns:
    
    list of window definitions associated with a SELECT.

Class FromList

Field Summary

Fields inherited from class org.apache.derby.impl.sql.compile.QueryTreeNode

Fields inherited from class org.apache.derby.impl.sql.compile.QueryTreeNodeVector

Constructor Summary

Method Summary

Methods inherited from interface java.lang.Iterable

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.derby.iapi.sql.compile.OptimizableList

Methods inherited from class org.apache.derby.impl.sql.compile.QueryTreeNode

Methods inherited from class org.apache.derby.impl.sql.compile.QueryTreeNodeVector

Field Detail

properties

fixedJoinOrder

useStatistics

referencesSessionSchema

isTransparent

windows

Constructor Detail

FromList

FromList

FromList

Method Detail

constructorMinion

getOptimizable

setOptimizable

verifyProperties

addFromTable

referencesTarget

referencesSessionSchema

getFromTableByName

isJoinColumnForRightOuterJoin

bindTables

bindExpressions

bindResultColumns

expandAll

bindColumnReference

rejectParameters

LOJ_reorderable

preprocess

flattenFromTables

pushPredicates

setLevel

getFromTableByResultColumn

setProperties

reOrder

useStatistics

optimizeJoinOrder

legalJoinOrder

initAccessPaths

bindUntypedNullsToResultColumns

decrementLevel

returnsAtMostSingleRow

getTableNumbers

genExistsBaseTables

tableNumberIsNotExists

updateTargetLockMode

hashJoinSpecified

markAsTransparent

setWindows

getWindows