pack-priv Class FromList

Add a table to the FROM list.

Parameters

fromTable:FromTable

A FromTable to add to the list

Exceptions

StandardException:

Thrown on error

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.

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:ColumnReference

The ColumnReference describing the column to bind

Returns:ResultColumn

ResultColumn The matching ResultColumn, or null if there is no matching column

Exceptions

StandardException:

Thrown on error

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.

Exceptions

StandardException:

Thrown on error

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

FromList to use/append to.

Exceptions

StandardException:

Thrown on error

Bind any untyped null nodes to the types in the given ResultColumnList.

Parameters

bindingRCL:ResultColumnList

The ResultColumnList with the types to bind to.

Exceptions

StandardException:

Thrown on error

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

Parameters

decrement:int

The amount to decrement by.

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.

Parameters

allTableName:TableName

The qualification on the "*" as a String.

Returns:ResultColumnList

ResultColumnList representing expansion

Exceptions

StandardException:

Thrown on error

Flatten all the FromTables that are flattenable. RESOLVE - right now we just flatten FromSubqueries. We should also flatten flattenable JoinNodes here.

Parameters

rcl:ResultColumnList

The RCL from the outer query

predicateList:PredicateList

The PredicateList from the outer query

sql:SubqueryList

The SubqueryList from the outer query

gbl:GroupByList

The group by list, if any

havingClause:ValueNode

The HAVING clause, if any

Exceptions

StandardException:

Thrown on error

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:JBitSet

The referenced table map.

outerFromList:FromList

FromList from outer query block

isNotExists:boolean

Whether or not for NOT EXISTS

Exceptions

StandardException:

Thrown on error

Determine whether or not the specified name is an exposed name in the current query block.

Parameters

name:String

The specified name to search for as an exposed name.

schemaName:String

Schema name, if non-null.

exactMatch:boolean

Whether or not we need an exact match on specified schema and table names or match on table id.

Returns:FromTable

The FromTable, if any, with the exposed name.

Exceptions

StandardException:

Thrown on error

Get the FromTable from this list which has the specified ResultColumn in its RCL.

Parameters

rc:ResultColumn

The ResultColumn match on.

Returns:FromTable

FromTable The matching FromTable.

Returns:WindowList

list of window definitions associated with a SELECT.

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

Returns:boolean

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

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

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.

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:int

The number of tables in the DML Statement

gbl:GroupByList

The group by list, if any

Exceptions

StandardException:

Thrown on error

Categorize and push the predicates that are pushable.

Parameters

predicateList:PredicateList

The query's PredicateList

Exceptions

StandardException:

Thrown on error

Search to see if a query references the specifed table name.

Parameters

name:String

Table name (String) to search for.

baseTable:boolean

Whether or not name is for a base table

Returns:boolean

true if found, else false

Exceptions

StandardException:

Thrown on error

Check for (and reject) all ? parameters directly under the ResultColumns. This is done for SELECT statements.

Exceptions

StandardException:

Thrown if a ? parameter found directly under a ResultColumn

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:ResultColumnList

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:ValueNode

The WHERE clause to consider.

wherePredicates:PredicateList

The predicates that have already been pulled from the WHERE clause.

dd:DataDictionary

The DataDictionary to use.

Returns:boolean

Whether or not query block will return at most 1 row for a subquery, no duplicates for a distinct.

Exceptions

StandardException:

Thrown on error

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

Parameters

level:int

The query block level for this table.

Set the Properties list for this FromList.

Exceptions

StandardException:

Thrown on error

Set windows field to the supplied value.

Parameters

windows:WindowList

list of window definitions associated with a SELECT.

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:int

which table to check

Returns:boolean

true if this table is in the from list as NOT EXISTS

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:int

The lock mode