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

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.ResultColumnList
All Implemented Interfaces:
Visitable

public class ResultColumnList
extends QueryTreeNodeVector

A ResultColumnList is the target list of a SELECT, INSERT, or UPDATE.

See Also:
ResultColumn

Field Summary
protected  long conglomerateId
           
private  boolean countMismatchAllowed
           
protected  boolean forUpdate
           
protected  boolean indexRow
           
private  int initialListSize
           
(package private)  int orderBySelect
           
 
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
ResultColumnList()
           
 
Method Summary
 Visitable accept(Visitor v)
          Accept a visitor, and call v.visit() on child nodes as necessary.
 void addElement(QueryTreeNode qt)
           
 void addRCForRID()
          Add an RC to the end of the list for the RID from an index.
 void addResultColumn(ResultColumn resultColumn)
          Add a ResultColumn (at this point, ResultColumn or AllResultColumn) to the list
 void adjustVirtualColumnIds(int adjust)
          Walk the list and adjust the virtualColumnIds in the ResultColumns by the specified amount.
(package private)  boolean allExpressionsAreColumns(ResultSetNode sourceRS)
          Determine if all of the RC.expressions are columns in the source result set.
(package private)  int allTopCRsFromSameTable()
          Return whether or not all of the RCs in the list whose expressions are ColumnReferences are from the same table.
 void appendResultColumns(ResultColumnList resultColumns, boolean destructiveCopy)
          Append a given ResultColumnList to this one, resetting the virtual column ids in the appended portion.
 void bindExpressions(FromList fromList, SubqueryList subqueryList, java.util.Vector aggregateVector)
          Bind the expressions in this ResultColumnList.
 void bindResultColumnsByName(ResultColumnList fullRCL, FromVTI targetVTI, DMLStatementNode statement)
          Bind the result columns by their names.
 void bindResultColumnsByName(TableDescriptor targetTableDescriptor, DMLStatementNode statement)
          Bind the result columns by their names.
 void bindResultColumnsByPosition(TableDescriptor targetTableDescriptor)
          Bind the result columns by ordinal position.
 void bindResultColumnsToExpressions()
          Bind the result columns to the expressions that live under them.
 void bindUntypedNullsToResultColumns(ResultColumnList bindingRCL)
          Bind any untyped null nodes to the types in the given ResultColumnList.
 ExecRow buildEmptyIndexRow(TableDescriptor td, ConglomerateDescriptor cd, StoreCostController scc, DataDictionary dd)
          Build an empty index row for the given conglomerate.
 ExecRow buildEmptyRow()
          Build an empty row with the size and shape of the ResultColumnList.
 void checkAutoincrement(ResultColumnList sourceRSRCL)
          check if any autoincrement columns exist in the result column list.
 void checkAutoincrementUnion(ResultSetNode rs)
          If the resultset is a UnionNode (e.g., multi-rows in VALUES clause), we recursively call itself.
 void checkColumnUpdateability(java.lang.String[] ucl, java.lang.String cursorName)
          Verify that all of the columns in the SET clause of a positioned update appear in the cursor's FOR UPDATE OF list.
(package private)  void checkForInvalidDefaults()
          Walk the RCL and check for DEFAULTs.
(package private)  void checkStorableExpressions()
          Verify that all the result columns have expressions that are storable for them.
(package private)  void checkStorableExpressions(ResultColumnList toStore)
          Verify that all the result columns have expressions that are storable for them.
 void clearColumnReferences()
          Clear the column references from the RCL.
 void clearTableNames()
           
(package private)  boolean columnTypesAndLengthsMatch()
           
(package private)  boolean columnTypesAndLengthsMatch(ResultColumnList otherRCL)
           
private  void commonCodeForUpdatableByCursor(java.util.Vector updateColumns, boolean dealingWithSelectResultColumnList)
          dealingWithSelectResultColumnList true means we are dealing with ResultColumnList for a select sql.
(package private)  ResultColumnList compactColumns(boolean positionedUpdate, boolean always)
          Create a new, compacted RCL based on the referenced RCs in this list.
 boolean containsAllResultColumn()
          Return whether or not this RCL contains an AllResultColumn.
 void copyColumnsToNewList(ResultColumnList targetList, FormatableBitSet copyList)
          Copy the RCs from this list to the supplied target list.
 ResultColumnList copyListAndObjects()
          Create a shallow copy of a ResultColumnList and its ResultColumns.
 void copyOrderBySelect(ResultColumnList src)
           
 void copyReferencedColumnsToNewList(ResultColumnList targetList)
          Copy the referenced RCs from this list to the supplied target list.
(package private)  void copyResultColumnNames(ResultColumnList nameList)
          Copy the result column names from the given ResultColumnList to this ResultColumnList.
 void copyTypesAndLengthsToSource(ResultColumnList sourceRCL)
          Copy the types and lengths for this RCL (the target) to another RCL (the source).
 int countNumberOfSimpleColumnReferences()
          Count the number of RCs with simple ColumnReferences.
 int countReferencedColumns()
          Count the number of RCs in the list that are referenced.
 void createListFromResultSetMetaData(java.sql.ResultSetMetaData rsmd, TableName tableName, java.lang.String javaClassName)
          Generate an RCL to match the contents of a ResultSetMetaData.
 void decOrderBySelect()
           
 void destructiveAppend(QueryTreeNodeVector qtnv)
           
 void doProjection()
          Project out any unreferenced ResultColumns from the list and reset the virtual column ids in the referenced ResultColumns.
 QueryTreeNode elementAt(int index)
           
 void expandAllsAndNameColumns(FromList fromList)
          Expand any *'s in the ResultColumnList.
 ResultColumnList expandToAll(TableDescriptor td, TableName tableName)
          Expand this ResultColumnList by adding all columns from the given table that are not in this list.
 void exportNames(java.lang.String[] columnNames)
          Export the result column names to the passed in String[].
 ResultColumn findParentResultColumn(ResultColumn childRC)
          Given a ResultColumn at the next deepest level in the tree, search this RCL for its parent ResultColumn.
private  void genCreateRow(ExpressionClassBuilder acb, LocalField field, java.lang.String rowAllocatorMethod, java.lang.String rowAllocatorType, int numCols)
          Generate the code to create an empty row in the constructor.
 void generate(ActivationClassBuilder acb, MethodBuilder mb)
          Generate the code to place the columns' values into a row variable named "r".
(package private)  void generateCore(ExpressionClassBuilder acb, MethodBuilder mb, boolean genNulls)
          Generate the code to place the columns' values into a row variable named "r".
(package private)  void generateHolder(ExpressionClassBuilder acb, MethodBuilder mb)
          Generates a row with the size and shape of the ResultColumnList.
(package private)  void generateHolder(ExpressionClassBuilder acb, MethodBuilder mb, FormatableBitSet referencedCols, FormatableBitSet propagatedCols)
          Generates a row with the size and shape of the ResultColumnList.
(package private)  MethodBuilder generateHolderMethod(ExpressionClassBuilder acb, FormatableBitSet referencedCols, FormatableBitSet propagatedCols)
           
(package private)  void generateNulls(ActivationClassBuilder acb, MethodBuilder mb)
          Generate the code to place the columns' values into a row variable named "r".
 void genVirtualColumnNodes(ResultSetNode sourceResultSet, ResultColumnList sourceResultColumnList)
          Walk the list and replace ResultColumn.expression with a new VirtualColumnNode.
 void genVirtualColumnNodes(ResultSetNode sourceResultSet, ResultColumnList sourceResultColumnList, boolean markReferenced)
          Walk the list and replace ResultColumn.expression with a new VirtualColumnNode.
 ResultColumn getAtMostOneResultColumn(ColumnReference cr, java.lang.String exposedTableName)
          Get a ResultColumn that matches the specified columnName and mark the ResultColumn as being referenced.
 java.lang.String[] getColumnNames()
          Get an array of strings for all the columns in this RCL.
 int[] getColumnPositions(TableDescriptor td)
          Get an array of column positions (1-based) for all the columns in this RCL.
 FormatableBitSet getColumnReferenceMap()
          Get a FormatableBitSet of the columns referenced in this rcl
protected  boolean getCountMismatchAllowed()
          Return whether or not a count mismatch is allowed between this RCL, as a derived column list, and an underlying RCL.
(package private)  ResultColumnList getJoinColumns(ResultColumnList joinColumns)
          Get the join columns from this list.
 ResultColumn getOrderByColumn(int position)
          Get a ResultColumn from a column position (1-based) in the list, null if out of range (for order by).
 ResultColumn getOrderByColumn(java.lang.String columnName, TableName tableName)
          For order by, get a ResultColumn that matches the specified columnName and ensure that there is only one match before the bind process.
 ResultColumn getOrderByColumn(java.lang.String columnName, TableName tableName, int tableNumber)
          For order by, get a ResultColumn that matches the specified columnName and ensure that there is only one match.
 int getOrderBySelect()
           
(package private)  FormatableBitSet getReferencedFormatableBitSet(boolean positionedUpdate, boolean always, boolean onlyBCNs)
          Generate a FormatableBitSet representing the columns that are referenced in this RCL.
 ResultColumn getResultColumn(int position)
          Get a ResultColumn from a column position (1-based) in the list
 ResultColumn getResultColumn(java.lang.String columnName)
          Get a ResultColumn that matches the specified columnName and mark the ResultColumn as being referenced.
 ResultColumn getResultColumn(java.lang.String columnsTableName, java.lang.String columnName)
          Get a ResultColumn that matches the specified columnName and mark the ResultColumn as being referenced.
(package private)  ResultColumn[] getSortedByPosition()
          Return an array that contains references to the columns in this list sorted by position.
 int[] getStreamStorableColIds(int heapColCount)
          Return an array holding the 0 based heap offsets of the StreamStorable columns in this ResultColumnList.
 int getTotalColumnSize()
          Get the size of all the columns added together.
 boolean hasConsistentTypeInfo()
          Verify that all ResultColumns and their expressions have type information and that the type information between the respective RCs and expressions matches.
 void incOrderBySelect()
           
(package private)  int indexOf(QueryTreeNode qt)
           
(package private)  void insertElementAt(QueryTreeNode qt, int index)
           
 boolean isCloneable()
          Return whether or not this RCL can be flattened out of a tree.
 boolean isExactTypeAndLengthMatch(ResultColumnList otherRCL)
          Do the 2 RCLs have the same type & length.
private  ResultColumn makeColumnFromName(java.lang.String columnName)
           
private  ResultColumn makeColumnReferenceFromName(TableName tableName, java.lang.String columnName)
           
 ResultColumnDescriptor[] makeResultDescriptors()
          Make a ResultDescription for use in a ResultSet.
(package private)  ResultColumnDescriptor[] makeResultDescriptors(ExecutionContext ec)
           
(package private)  int[] mapSourceColumns()
          Map the source columns to these columns.
 void markAllUnreferenced()
          Walk the list and mark all RCs as unreferenced.
(package private)  void markColumnsInSelectListUpdatableByCursor(java.util.Vector updateColumns)
          Mark all the columns in the select sql that this result column list represents as updatable if they match the columns in the given update column list.
protected  void markInitialSize()
           
(package private)  void markUpdatableByCursor()
          Mark all the (base) columns in this list as updatable by a positioned update statement.
(package private)  void markUpdatableByCursor(java.util.Vector updateColumns)
          Mark as updatable all the columns in this result column list that match the columns in the given update column list
(package private)  void markUpdated()
          Mark all the columns in this list as updated by an update statement.
(package private)  void markUpdated(ResultColumnList updateColumns)
          Mark as updatable all the columns in this result column list that match the columns in the given update column list.
 void nameAllResultColumns()
          Generate (unique across the entire statement) column names for those ResultColumns in this list which are not named.
 void nondestructiveAppend(QueryTreeNodeVector qtnv)
           
 boolean nopProjection(ResultColumnList childRCL)
          Determine whether this RCL is a No-Op projection of the given RCL.
 void populate(TableDescriptor table, int[] columnIDs)
          Build this ResultColumnList from a table description and an array of column IDs.
 void preprocess(int numTables, FromList outerFromList, SubqueryList outerSubqueryList, PredicateList outerPredicateList)
          Preprocess the expression trees under the RCL.
 void propagateDCLInfo(ResultColumnList derivedRCL, java.lang.String tableName)
          Validate the derived column list (DCL) and propagate the info from the list to the final ResultColumnList.
(package private)  void pullVirtualIsReferenced()
          Or in any isReferenced booleans from the virtual column chain.
 void recordColumnReferences(boolean[] colArray1, JBitSet[] tableColMap, int tableNumber)
          Record the top level ColumnReferences in the specified array and table map This is useful when checking for uniqueness conditions.
 void recordColumnReferences(int[] idArray, int basis)
          Record the column ids of the referenced columns in the specified array.
(package private)  void rejectParameters()
          Look for and reject ?
(package private)  void rejectXMLValues()
          Check for (and reject) XML values directly under the ResultColumns.
 void remapColumnReferencesToExpressions()
          Remap all ColumnReferences in this tree to be clones of the underlying expression.
(package private)  java.lang.Object remove(int index)
           
(package private)  void removeAllElements()
           
(package private)  void removeElement(QueryTreeNode qt)
           
(package private)  void removeElementAt(int index)
           
(package private)  void removeJoinColumns(ResultColumnList joinColumns)
          Remove the columns which are join columns (in the joinColumns RCL) from this list.
(package private)  void replaceDefaults(TableDescriptor ttd, ResultColumnList tcl)
          Replace any DEFAULTs with the associated tree for the default.
(package private)  void resetVirtualColumnIds()
          Reset the virtual column ids for all of the underlying RCs.
(package private)  boolean reusableResult()
          Return whether or not the same result row can be used for all rows returned by the associated ResultSet.
 void setClause(int clause)
           
protected  void setCountMismatchAllowed(boolean allowed)
          Set the value of whether or not a count mismatch is allowed between this RCL, as a derived column list, and an underlying RCL.
(package private)  void setElementAt(QueryTreeNode qt, int index)
           
(package private)  void setIndexRow(long cid, boolean forUpdate)
           
 void setNullability(boolean nullability)
          Set the nullability of every ResultColumn in this list
 void setRedundant()
          Mark all of the ResultColumns as redundant.
 void setResultSetNumber(int resultSetNumber)
          Set the resultSetNumber in all of the ResultColumns.
 void setUnionResultExpression(ResultColumnList otherRCL, int tableNumber, int level, java.lang.String operatorName)
          Set up the result expressions for a UNION, INTERSECT, or EXCEPT: o Verify union type compatiblity o Get dominant type for result (type + max length + nullability) o Create a new ColumnReference with dominant type and name of from this RCL and make that the new expression.
 int size()
           
 int[] sortMe()
          Return an array of all my column positions, sorted in ascending order.
 java.lang.String toString()
          Format this list as a string We can simply iterate through the list.
 void treePrint(int depth)
          This class needs a treePrint method, even though it is not a descendant of QueryTreeNode, because its members contain tree nodes, and these have to be printed and indented properly.
(package private)  boolean updatableByCursor(int columnPosition)
          Returns true if the given column position is for a column that will be or could be updated by the positioned update of a cursor.
 boolean updateOverlaps(int[] columns)
          Does the column list contain any of the given column positions that are updated?
(package private)  void verifyAllOrderable()
          Verify that all of the RCs in this list are comparable.
 java.lang.String verifyCreateConstraintColumnList(TableElementList tel)
          Verify that all of the column names in this list are contained within the ColumnDefinitionNodes within the TableElementList.
 java.lang.String verifyUniqueNames(boolean errForGenCols)
          Check the uniqueness of the column names within a column list.
 
Methods inherited from class org.apache.derby.impl.sql.compile.QueryTreeNode
bind, convertDefaultNode, debugFlush, debugPrint, executeSchemaName, executeStatementName, formatNodeString, foundString, 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, init, init, isAtomic, isInstanceOf, isSessionSchema, isSessionSchema, makeConstantAction, makeResultDescription, makeTableName, needsSavepoint, nodeHeader, optimize, parseQueryText, printLabel, printSubNodes, referencesSessionSchema, resolveTableToSynonym, setBeginOffset, setContextManager, setEndOffset, setNodeType, setRefActionInfo, treePrint, verifyClassExist
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Field Detail

indexRow

protected boolean indexRow

conglomerateId

protected long conglomerateId

orderBySelect

int orderBySelect

forUpdate

protected boolean forUpdate

countMismatchAllowed

private boolean countMismatchAllowed

initialListSize

private int initialListSize
Constructor Detail

ResultColumnList

public ResultColumnList()
Method Detail

addResultColumn

public void addResultColumn(ResultColumn resultColumn)
Add a ResultColumn (at this point, ResultColumn or AllResultColumn) to the list

Parameters:
resultColumn - The ResultColumn to add to the list
Returns:
Nothing

appendResultColumns

public void appendResultColumns(ResultColumnList resultColumns,
                                boolean destructiveCopy)
Append a given ResultColumnList to this one, resetting the virtual column ids in the appended portion.

Parameters:
resultColumns - The ResultColumnList to be appended
destructiveCopy - Whether or not this is a descructive copy from resultColumns
Returns:
Nothing

getResultColumn

public ResultColumn getResultColumn(int position)
Get a ResultColumn from a column position (1-based) in the list

Parameters:
position - The ResultColumn to get from the list (1-based)
Returns:
the column at that position.

getOrderByColumn

public ResultColumn getOrderByColumn(int position)
Get a ResultColumn from a column position (1-based) in the list, null if out of range (for order by).

Parameters:
position - The ResultColumn to get from the list (1-based)
Returns:
the column at that position, null if out of range

getResultColumn

public ResultColumn getResultColumn(java.lang.String columnName)
Get a ResultColumn that matches the specified columnName and mark the ResultColumn as being referenced.

Parameters:
columnName - The ResultColumn to get from the list
Returns:
the column that matches that name.

getResultColumn

public ResultColumn getResultColumn(java.lang.String columnsTableName,
                                    java.lang.String columnName)
Get a ResultColumn that matches the specified columnName and mark the ResultColumn as being referenced.

Parameters:
columnsTableName - Qualifying name for the column
columnName - The ResultColumn to get from the list
Returns:
the column that matches that name.

getAtMostOneResultColumn

public ResultColumn getAtMostOneResultColumn(ColumnReference cr,
                                             java.lang.String exposedTableName)
                                      throws StandardException
Get a ResultColumn that matches the specified columnName and mark the ResultColumn as being referenced. NOTE - this flavor enforces no ambiguity (at most 1 match) Only FromSubquery needs to call this flavor since it can have ambiguous references in its own list.

Parameters:
cr - The ColumnReference to resolve
exposedTableName - Exposed table name for FromTable
Returns:
the column that matches that name.
Throws:
StandardException - Thrown on error

getOrderByColumn

public ResultColumn getOrderByColumn(java.lang.String columnName,
                                     TableName tableName,
                                     int tableNumber)
                              throws StandardException
For order by, get a ResultColumn that matches the specified columnName and ensure that there is only one match.

Parameters:
columnName - The ResultColumn to get from the list
tableName - The table name on the OrderByColumn, if any
tableNumber - The tableNumber corresponding to the FromTable with the exposed name of tableName, if tableName != null.
Returns:
the column that matches that name.
Throws:
StandardException - thrown on duplicate

getOrderByColumn

public ResultColumn getOrderByColumn(java.lang.String columnName,
                                     TableName tableName)
                              throws StandardException
For order by, get a ResultColumn that matches the specified columnName and ensure that there is only one match before the bind process.

Parameters:
columnName - The ResultColumn to get from the list
tableName - The table name on the OrderByColumn, if any
Returns:
the column that matches that name.
Throws:
StandardException - thrown on duplicate

copyResultColumnNames

void copyResultColumnNames(ResultColumnList nameList)
Copy the result column names from the given ResultColumnList to this ResultColumnList. This is useful for insert-select, where the columns being inserted into may be different from the columns being selected from. The result column list for an insert is supposed to have the column names being inserted into.

Parameters:
nameList - The ResultColumnList from which to copy the column names
Returns:
Nothing

treePrint

public void treePrint(int depth)
This class needs a treePrint method, even though it is not a descendant of QueryTreeNode, because its members contain tree nodes, and these have to be printed and indented properly.

Overrides:
treePrint in class QueryTreeNode
Parameters:
depth - The depth at which to indent the sub-nodes
Returns:
Nothing

bindExpressions

public void bindExpressions(FromList fromList,
                            SubqueryList subqueryList,
                            java.util.Vector aggregateVector)
                     throws StandardException
Bind the expressions in this ResultColumnList. This means binding the expression under each ResultColumn node.

Parameters:
fromList - The FROM list for the query this expression is in, for binding columns.
subqueryList - The subquery list being built as we find SubqueryNodes
aggregateVector - The aggregate vector being built as we find AggregateNodes
Returns:
Nothing
Throws:
StandardException - Thrown on error

bindResultColumnsToExpressions

public void bindResultColumnsToExpressions()
                                    throws StandardException
Bind the result columns to the expressions that live under them. All this does is copy the datatype information to from each expression to each result column. This is useful for SELECT statements, where the result type of each column is the type of the column's expression.

Returns:
Nothing
Throws:
StandardException - Thrown on error

bindResultColumnsByName

public void bindResultColumnsByName(TableDescriptor targetTableDescriptor,
                                    DMLStatementNode statement)
                             throws StandardException
Bind the result columns by their names. This is useful for update statements, and for INSERT statements like "insert into t (a, b, c) values (1, 2, 3)" where the user specified a column list. Also, verify that the result column list does not contain any duplicates. NOTE: We pass the ResultColumns position in the ResultColumnList so that the VirtualColumnId gets set.

Parameters:
statement - DMLStatementNode containing this list
Returns:
Nothing
Throws:
StandardException - Thrown on error

bindResultColumnsByName

public void bindResultColumnsByName(ResultColumnList fullRCL,
                                    FromVTI targetVTI,
                                    DMLStatementNode statement)
                             throws StandardException
Bind the result columns by their names. This is useful for update VTI statements, and for INSERT statements like "insert into new t() (a, b, c) values (1, 2, 3)" where the user specified a column list. Also, verify that the result column list does not contain any duplicates. NOTE: We pass the ResultColumns position in the ResultColumnList so that the VirtualColumnId gets set.

Parameters:
fullRCL - The full RCL for the target table
statement - DMLStatementNode containing this list
Returns:
Nothing
Throws:
StandardException - Thrown on error

bindResultColumnsByPosition

public void bindResultColumnsByPosition(TableDescriptor targetTableDescriptor)
                                 throws StandardException
Bind the result columns by ordinal position. This is useful for INSERT statements like "insert into t values (1, 2, 3)", where the user did not specify a column list.

Returns:
Nothing
Throws:
StandardException - Thrown on error

preprocess

public void preprocess(int numTables,
                       FromList outerFromList,
                       SubqueryList outerSubqueryList,
                       PredicateList outerPredicateList)
                throws StandardException
Preprocess the expression trees under the RCL. We do a number of transformations here (including subqueries, IN lists, LIKE and BETWEEN) plus subquery flattening. NOTE: This is done before the outer ResultSetNode is preprocessed.

Parameters:
numTables - Number of tables in the DML Statement
outerFromList - FromList from outer query block
outerSubqueryList - SubqueryList from outer query block
outerPredicateList - PredicateList from outer query block
Returns:
Nothing
Throws:
StandardException - Thrown on error

checkStorableExpressions

void checkStorableExpressions(ResultColumnList toStore)
                        throws StandardException
Verify that all the result columns have expressions that are storable for them. Check versus the given ResultColumnList.

Throws:
StandardException - Thrown on error

getStreamStorableColIds

public int[] getStreamStorableColIds(int heapColCount)
                              throws StandardException
Return an array holding the 0 based heap offsets of the StreamStorable columns in this ResultColumnList. This returns null if this list does not contain any StreamStorableColumns. The list this returns does not contain duplicates. This should only be used for a resultColumnList the refers to a single heap such as the target for an Insert, Update or Delete.

Parameters:
heapColCount - the number of heap columns
Throws:
StandardException - Thrown on error

checkStorableExpressions

void checkStorableExpressions()
                        throws StandardException
Verify that all the result columns have expressions that are storable for them. Check versus the expressions under the ResultColumns.

Throws:
StandardException - Thrown on error

generate

public void generate(ActivationClassBuilder acb,
                     MethodBuilder mb)
              throws StandardException
Generate the code to place the columns' values into a row variable named "r". This wrapper is here rather than in ResultColumn, because that class does not know about the position of the columns in the list.

Overrides:
generate in class QueryTreeNode
Parameters:
acb - The ActivationClassBuilder for the class being built
mb - The method for the generated code to go into
Throws:
StandardException - Thrown on error

generateNulls

void generateNulls(ActivationClassBuilder acb,
                   MethodBuilder mb)
             throws StandardException
Generate the code to place the columns' values into a row variable named "r". This wrapper is here rather than in ResultColumn, because that class does not know about the position of the columns in the list.

Throws:
StandardException - Thrown on error

generateCore

void generateCore(ExpressionClassBuilder acb,
                  MethodBuilder mb,
                  boolean genNulls)
            throws StandardException
Generate the code to place the columns' values into a row variable named "r". This wrapper is here rather than in ResultColumn, because that class does not know about the position of the columns in the list. This is the method that does the work.

Throws:
StandardException

buildEmptyRow

public ExecRow buildEmptyRow()
                      throws StandardException
Build an empty row with the size and shape of the ResultColumnList.

Returns:
an empty row of the correct size and shape.
Throws:
StandardException - Thrown on error

buildEmptyIndexRow

public ExecRow buildEmptyIndexRow(TableDescriptor td,
                                  ConglomerateDescriptor cd,
                                  StoreCostController scc,
                                  DataDictionary dd)
                           throws StandardException
Build an empty index row for the given conglomerate.

Returns:
an empty row of the correct size and shape.
Throws:
StandardException - Thrown on error

generateHolder

void generateHolder(ExpressionClassBuilder acb,
                    MethodBuilder mb)
              throws StandardException
Generates a row with the size and shape of the ResultColumnList. Some structures, like FromBaseTable and DistinctNode, need to generate rowAllocator functions to get a row the size and shape of their ResultColumnList. We return the method pointer, which is a field access in the generated class.

Throws:
StandardException

generateHolder

void generateHolder(ExpressionClassBuilder acb,
                    MethodBuilder mb,
                    FormatableBitSet referencedCols,
                    FormatableBitSet propagatedCols)
              throws StandardException
Generates a row with the size and shape of the ResultColumnList. Some structures, like FromBaseTable and DistinctNode, need to generate rowAllocator functions to get a row the size and shape of their ResultColumnList. We return the method pointer, which is a field access in the generated class.

Throws:
StandardException

generateHolderMethod

MethodBuilder generateHolderMethod(ExpressionClassBuilder acb,
                                   FormatableBitSet referencedCols,
                                   FormatableBitSet propagatedCols)
                             throws StandardException
Throws:
StandardException

genCreateRow

private void genCreateRow(ExpressionClassBuilder acb,
                          LocalField field,
                          java.lang.String rowAllocatorMethod,
                          java.lang.String rowAllocatorType,
                          int numCols)
                   throws StandardException
Generate the code to create an empty row in the constructor.

Parameters:
acb - The ACB.
field - The field for the new row.
rowAllocatorMethod - The method to call.
rowAllocatorType - The row type.
numCols - The number of columns in the row.
Returns:
Nothing.
Throws:
StandardException - Thrown on error

makeResultDescriptors

public ResultColumnDescriptor[] makeResultDescriptors()
Make a ResultDescription for use in a ResultSet. This is useful when generating/executing a NormalizeResultSet, since it can appear anywhere in the tree.

Returns:
A ResultDescription for this ResultSetNode.

makeResultDescriptors

ResultColumnDescriptor[] makeResultDescriptors(ExecutionContext ec)

expandAllsAndNameColumns

public void expandAllsAndNameColumns(FromList fromList)
                              throws StandardException
Expand any *'s in the ResultColumnList. In addition, we will guarantee that each ResultColumn has a name. (All generated names will be unique across the entire statement.)

Returns:
None.
Throws:
StandardException - Thrown on error

nameAllResultColumns

public void nameAllResultColumns()
                          throws StandardException
Generate (unique across the entire statement) column names for those ResultColumns in this list which are not named.

Returns:
None.
Throws:
StandardException - Thrown on error

copyTypesAndLengthsToSource

public void copyTypesAndLengthsToSource(ResultColumnList sourceRCL)
Copy the types and lengths for this RCL (the target) to another RCL (the source). This is useful when adding a NormalizeResultSetNode.

Returns:
Nothing.

columnTypesAndLengthsMatch

boolean columnTypesAndLengthsMatch()
                             throws StandardException
Throws:
StandardException

columnTypesAndLengthsMatch

boolean columnTypesAndLengthsMatch(ResultColumnList otherRCL)
                             throws StandardException
Throws:
StandardException

nopProjection

public boolean nopProjection(ResultColumnList childRCL)
Determine whether this RCL is a No-Op projection of the given RCL. It only makes sense to do this if the given RCL is from the child result set of the ProjectRestrict that this RCL is from.

Parameters:
childRCL - The ResultColumnList of the child result set.
Returns:
true if this RCL is a No-Op projection of the given RCL.

copyListAndObjects

public ResultColumnList copyListAndObjects()
                                    throws StandardException
Create a shallow copy of a ResultColumnList and its ResultColumns. (All other pointers are preserved.) Useful for building new ResultSetNodes during preprocessing.

Returns:
None.
Throws:
StandardException - Thrown on error

genVirtualColumnNodes

public void genVirtualColumnNodes(ResultSetNode sourceResultSet,
                                  ResultColumnList sourceResultColumnList)
                           throws StandardException
Walk the list and replace ResultColumn.expression with a new VirtualColumnNode. This is useful when propagating a ResultColumnList up the query tree. NOTE: This flavor marks all of the underlying RCs as referenced.

Parameters:
sourceResultSet - ResultSetNode that is source of value
Returns:
None.
Throws:
StandardException - Thrown on error

genVirtualColumnNodes

public void genVirtualColumnNodes(ResultSetNode sourceResultSet,
                                  ResultColumnList sourceResultColumnList,
                                  boolean markReferenced)
                           throws StandardException
Walk the list and replace ResultColumn.expression with a new VirtualColumnNode. This is useful when propagating a ResultColumnList up the query tree.

Parameters:
sourceResultSet - ResultSetNode that is source of value
markReferenced - Whether or not to mark the underlying RCs as referenced
Returns:
None.
Throws:
StandardException - Thrown on error

adjustVirtualColumnIds

public void adjustVirtualColumnIds(int adjust)
Walk the list and adjust the virtualColumnIds in the ResultColumns by the specified amount. If ResultColumn.expression is a VirtualColumnNode, then we adjust the columnId there as well.

Returns:
None.

doProjection

public void doProjection()
                  throws StandardException
Project out any unreferenced ResultColumns from the list and reset the virtual column ids in the referenced ResultColumns. If all ResultColumns are projected out, then the list is not empty.

Returns:
None.
Throws:
StandardException - Thrown on error

verifyUniqueNames

public java.lang.String verifyUniqueNames(boolean errForGenCols)
                                   throws StandardException
Check the uniqueness of the column names within a column list.

Parameters:
errForGenCols - Raise an error for any generated column names.
Returns:
String The first duplicate column name, if any.
Throws:
StandardException

propagateDCLInfo

public void propagateDCLInfo(ResultColumnList derivedRCL,
                             java.lang.String tableName)
                      throws StandardException
Validate the derived column list (DCL) and propagate the info from the list to the final ResultColumnList.

Parameters:
derivedRCL - The derived column list
tableName - The table name for the FromTable
Returns:
None.
Throws:
StandardException - Thrown on error

rejectParameters

void rejectParameters()
                throws StandardException
Look for and reject ? parameters under ResultColumns. This is done for SELECT statements.

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

rejectXMLValues

void rejectXMLValues()
               throws StandardException
Check for (and reject) XML values directly under the ResultColumns. This is done for SELECT/VALUES statements. We reject values in this case because JDBC does not define an XML type/binding and thus there's no standard way to pass such a type back to a JDBC application. Note that we DO allow an XML column in a top-level RCL IF that column was added to the RCL by _us_ instead of by the user. For example, if we have a table: create table t1 (i int, x xml) and the user query is: select i from t1 order by x the "x" column will be added (internally) to the RCL as part of ORDER BY processing--and so we need to allow that XML column to be bound without throwing an error. If, as in this case, the XML column reference is invalid (we can't use ORDER BY on an XML column because XML values aren't ordered), a more appropriate error message should be returned to the user in later processing. If we didn't allow for this, the user would get an error saying that XML columns are not valid as part of the result set--but as far as s/he knows, there isn't such a column: only "i" is supposed to be returned (the RC for "x" was added to the RCL by _us_ as part of ORDER BY processing). ASSUMPTION: Any RCs that are generated internally and added to this RCL (before this RCL is bound) are added at the _end_ of the list. If that's true, then any RC with an index greater than the size of the initial (user-specified) list must have been added internally and will not be returned to the user.

Returns:
Nothing
Throws:
StandardException - Thrown if an XML value found directly under a ResultColumn

setResultSetNumber

public void setResultSetNumber(int resultSetNumber)
Set the resultSetNumber in all of the ResultColumns.

Parameters:
resultSetNumber - The resultSetNumber
Returns:
Nothing.

setRedundant

public void setRedundant()
Mark all of the ResultColumns as redundant. Useful when chopping a ResultSetNode out of a tree when there are still references to its RCL.

Returns:
Nothing.

checkColumnUpdateability

public void checkColumnUpdateability(java.lang.String[] ucl,
                                     java.lang.String cursorName)
                              throws StandardException
Verify that all of the columns in the SET clause of a positioned update appear in the cursor's FOR UPDATE OF list.

Parameters:
ucl - The cursor's FOR UPDATE OF list. (May be null.)
cursorName - The cursor's name.
Returns:
Nothing.
Throws:
StandardException - Thrown on error

setUnionResultExpression

public void setUnionResultExpression(ResultColumnList otherRCL,
                                     int tableNumber,
                                     int level,
                                     java.lang.String operatorName)
                              throws StandardException
Set up the result expressions for a UNION, INTERSECT, or EXCEPT: o Verify union type compatiblity o Get dominant type for result (type + max length + nullability) o Create a new ColumnReference with dominant type and name of from this RCL and make that the new expression. o Set the type info for in the ResultColumn to the dominant type NOTE - We are assuming that caller has generated a new RCL for the UNION with the same names as the left side's RCL and copies of the expressions.

Parameters:
otherRCL - RCL from other side of the UNION.
tableNumber - The tableNumber for the UNION.
level - The nesting level for the UNION.
operatorName - "UNION", "INTERSECT", or "EXCEPT"
Returns:
Nothing.
Throws:
StandardException - Thrown on error

checkAutoincrementUnion

public void checkAutoincrementUnion(ResultSetNode rs)
                             throws StandardException
If the resultset is a UnionNode (e.g., multi-rows in VALUES clause), we recursively call itself. checkAutoincrement() will set ColumnDescriptor for autoincrement columns. This way, all ColumnDescriptor of all rows will be set properly.

Throws:
StandardException

isExactTypeAndLengthMatch

public boolean isExactTypeAndLengthMatch(ResultColumnList otherRCL)
Do the 2 RCLs have the same type & length. This is useful for UNIONs when deciding whether a NormalizeResultSet is required.

Parameters:
otherRCL - The other RCL.
Returns:
boolean Whether or not there is an exact UNION type match on the 2 RCLs.

updateOverlaps

public boolean updateOverlaps(int[] columns)
Does the column list contain any of the given column positions that are updated? Implements same named routine in UpdateList.

Parameters:
columns - An array of column positions
Returns:
True if this column list contains any of the given columns

getSortedByPosition

ResultColumn[] getSortedByPosition()
Return an array that contains references to the columns in this list sorted by position.

Returns:
The sorted array.

sortMe

public int[] sortMe()
Return an array of all my column positions, sorted in ascending order.

Returns:
a sorted array

expandToAll

public ResultColumnList expandToAll(TableDescriptor td,
                                    TableName tableName)
                             throws StandardException
Expand this ResultColumnList by adding all columns from the given table that are not in this list. The result is sorted by column position.

Parameters:
td - The TableDescriptor for the table in question
tableName - The name of the table as given in the query
Returns:
A new ResultColumnList expanded to include all columns in the given table.
Throws:
StandardException - Thrown on error

bindUntypedNullsToResultColumns

public void bindUntypedNullsToResultColumns(ResultColumnList bindingRCL)
                                     throws StandardException
Bind any untyped null nodes to the types in the given ResultColumnList. Nodes that don't know their type may pass down nulls to children nodes. In the case of something like a union, it knows to try its right and left result sets against each other. But if a null reaches us, it means we have a null type that we don't know how to handle.

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

markUpdated

void markUpdated()
Mark all the columns in this list as updated by an update statement.

Returns:
Nothing.

markUpdatableByCursor

void markUpdatableByCursor()
Mark all the (base) columns in this list as updatable by a positioned update statement. This is necessary for positioned update statements, because we expand the column list to include all the columns in the base table, and we need to be able to tell which ones the user is really trying to update so we can determine correctly whether all the updated columns are in the "for update" list.

Returns:
Nothing.

verifyCreateConstraintColumnList

public java.lang.String verifyCreateConstraintColumnList(TableElementList tel)
Verify that all of the column names in this list are contained within the ColumnDefinitionNodes within the TableElementList.

Returns:
String The 1st column name, if any, that is not in the list.

exportNames

public void exportNames(java.lang.String[] columnNames)
Export the result column names to the passed in String[].

Parameters:
columnNames - String[] to hold the column names.
Returns:
Nothing.

countNumberOfSimpleColumnReferences

public int countNumberOfSimpleColumnReferences()
Count the number of RCs with simple ColumnReferences. (RC.expression instanceof ColumnReference) This is useful for ensuring that the number of columns in the group by list equals the number of grouping columns.

Returns:
int The number of simple ColumnReferences.

findParentResultColumn

public ResultColumn findParentResultColumn(ResultColumn childRC)
Given a ResultColumn at the next deepest level in the tree, search this RCL for its parent ResultColumn.

Parameters:
childRC - The child ResultColumn
Returns:
ResultColumn The parent ResultColumn

setClause

public void setClause(int clause)

markUpdated

void markUpdated(ResultColumnList updateColumns)
Mark as updatable all the columns in this result column list that match the columns in the given update column list.

Parameters:
updateColumns - A ResultColumnList representing the columns to be updated.

markColumnsInSelectListUpdatableByCursor

void markColumnsInSelectListUpdatableByCursor(java.util.Vector updateColumns)
Mark all the columns in the select sql that this result column list represents as updatable if they match the columns in the given update column list.

Parameters:
updateColumns - A Vector representing the columns to be updated.

commonCodeForUpdatableByCursor

private void commonCodeForUpdatableByCursor(java.util.Vector updateColumns,
                                            boolean dealingWithSelectResultColumnList)
dealingWithSelectResultColumnList true means we are dealing with ResultColumnList for a select sql. When dealing with ResultColumnList for select sql, it is possible that not all the updatable columns are projected in the select column list and hence it is possible that we may not find the column to be updated in the ResultColumnList and that is why special handling is required when dealingWithSelectResultColumnList is true. eg select c11, c13 from t1 for update of c11, c12 In the eg above, we will find updatable column c11 in the select column list but we will not find updatable column c12 in the select column list


markUpdatableByCursor

void markUpdatableByCursor(java.util.Vector updateColumns)
Mark as updatable all the columns in this result column list that match the columns in the given update column list

Parameters:
updateColumns - A Vector representing the columns to be updated.

updatableByCursor

boolean updatableByCursor(int columnPosition)
Returns true if the given column position is for a column that will be or could be updated by the positioned update of a cursor.

Parameters:
columnPosition - The position of the column in question
Returns:
true if the column is updatable

isCloneable

public boolean isCloneable()
Return whether or not this RCL can be flattened out of a tree. It can only be flattened if the expressions are all cloneable.

Returns:
boolean Whether or not this RCL can be flattened out of a tree.

remapColumnReferencesToExpressions

public void remapColumnReferencesToExpressions()
                                        throws StandardException
Remap all ColumnReferences in this tree to be clones of the underlying expression.

Returns:
Nothing.
Throws:
StandardException - Thrown on error

setIndexRow

void setIndexRow(long cid,
                 boolean forUpdate)

hasConsistentTypeInfo

public boolean hasConsistentTypeInfo()
Verify that all ResultColumns and their expressions have type information and that the type information between the respective RCs and expressions matches.

Returns:
boolean Whether or not the type information is consistent

containsAllResultColumn

public boolean containsAllResultColumn()
Return whether or not this RCL contains an AllResultColumn. This is useful when dealing with SELECT * views which reference tables that may have had columns added to them via ALTER TABLE since the view was created.

Returns:
Whether or not this RCL contains an AllResultColumn.

countReferencedColumns

public int countReferencedColumns()
Count the number of RCs in the list that are referenced.

Returns:
The number of RCs in the list that are referenced.

recordColumnReferences

public void recordColumnReferences(int[] idArray,
                                   int basis)
Record the column ids of the referenced columns in the specified array.

Parameters:
idArray - int[] for column ids
basis - 0 (for 0-based ids) or 1 (for 1-based ids)
Returns:
Nothing.

recordColumnReferences

public void recordColumnReferences(boolean[] colArray1,
                                   JBitSet[] tableColMap,
                                   int tableNumber)
Record the top level ColumnReferences in the specified array and table map This is useful when checking for uniqueness conditions. NOTE: All top level CRs assumed to be from the same table. The size of the array is expected to be the # of columns in the table of interest + 1, so we use 1-base column #s.

Parameters:
colArray1 - boolean[] for columns
tableColMap - JBitSet[] for tables
tableNumber - Table number of column references
Returns:
Nothing.

allTopCRsFromSameTable

int allTopCRsFromSameTable()
Return whether or not all of the RCs in the list whose expressions are ColumnReferences are from the same table. One place this is useful for distinct elimination based on the existence of a uniqueness condition.

Returns:
-1 if all of the top level CRs in the RCL are not ColumnReferences from the same table, else the tableNumber

clearColumnReferences

public void clearColumnReferences()
Clear the column references from the RCL. (Restore RCL back to a state where none of the RCs are marked as referenced.)

Returns:
Nothing.

copyReferencedColumnsToNewList

public void copyReferencedColumnsToNewList(ResultColumnList targetList)
Copy the referenced RCs from this list to the supplied target list.

Parameters:
targetList - The list to copy to
Returns:
Nothing.

copyColumnsToNewList

public void copyColumnsToNewList(ResultColumnList targetList,
                                 FormatableBitSet copyList)
Copy the RCs from this list to the supplied target list.

Parameters:
targetList - The list to copy to,
copyList - 1 based bitMap we copy columns associated with set bits.
Returns:
Nothing.

getColumnReferenceMap

public FormatableBitSet getColumnReferenceMap()
Get a FormatableBitSet of the columns referenced in this rcl

Returns:
the FormatableBitSet

pullVirtualIsReferenced

void pullVirtualIsReferenced()
Or in any isReferenced booleans from the virtual column chain. That is the isReferenced bits on each ResultColumn on the list will be set if the ResultColumn is referenced or if any VirtualColumnNode in its expression chain refers to a referenced column.


clearTableNames

public void clearTableNames()

setCountMismatchAllowed

protected void setCountMismatchAllowed(boolean allowed)
Set the value of whether or not a count mismatch is allowed between this RCL, as a derived column list, and an underlying RCL. This is allowed for SELECT * views when an underlying table has had columns added to it via ALTER TABLE.

Parameters:
allowed - Whether or not a mismatch is allowed.
Returns:
Nothing.

getCountMismatchAllowed

protected boolean getCountMismatchAllowed()
Return whether or not a count mismatch is allowed between this RCL, as a derived column list, and an underlying RCL. This is allowed for SELECT * views when an underlying table has had columns added to it via ALTER TABLE. return Whether or not a mismatch is allowed.


getTotalColumnSize

public int getTotalColumnSize()
Get the size of all the columns added together. Does NOT include the column overhead that the store requires. Also, will be a very rough estimate for user types.

Returns:
the size

createListFromResultSetMetaData

public void createListFromResultSetMetaData(java.sql.ResultSetMetaData rsmd,
                                            TableName tableName,
                                            java.lang.String javaClassName)
                                     throws StandardException
Generate an RCL to match the contents of a ResultSetMetaData. This is useful when dealing with VTIs.

Parameters:
rsmd - The ResultSetMetaData.
tableName - The TableName for the BCNs.
javaClassName - The name of the VTI
Returns:
Nothing.
Throws:
StandardException - Thrown on error

addRCForRID

public void addRCForRID()
                 throws StandardException
Add an RC to the end of the list for the RID from an index. NOTE: RC.expression is a CurrentRowLocationNode. This was previously only used for non-select DML. We test for this node when generating the holder above and generate the expected code. (We really should create yet another new node type with its own code generation.)

Returns:
Nothing.
Throws:
StandardException - Thrown on error

markAllUnreferenced

public void markAllUnreferenced()
                         throws StandardException
Walk the list and mark all RCs as unreferenced. This is useful when recalculating which RCs are referenced at what level like when deciding which columns need to be returned from a non-matching index scan (as opposed to those returned from the base table).

Returns:
None.
Throws:
StandardException - Thrown on error

allExpressionsAreColumns

boolean allExpressionsAreColumns(ResultSetNode sourceRS)
Determine if all of the RC.expressions are columns in the source result set. This is useful for determining if we need to do reflection at execution time.

Parameters:
sourceRS - The source ResultSet.
Returns:
Whether or not all of the RC.expressions are columns in the source result set.

mapSourceColumns

int[] mapSourceColumns()
Map the source columns to these columns. Build an array to represent the mapping. For each RC, if the expression is simply a VCN or a CR then set the array element to be the virtual column number of the source RC. Otherwise, set the array element to -1. This is useful for determining if we need to do reflection at execution time.

Returns:
Array representiong mapping of RCs to source RCs.

setNullability

public void setNullability(boolean nullability)
Set the nullability of every ResultColumn in this list


getReferencedFormatableBitSet

FormatableBitSet getReferencedFormatableBitSet(boolean positionedUpdate,
                                               boolean always,
                                               boolean onlyBCNs)
Generate a FormatableBitSet representing the columns that are referenced in this RCL. The caller decides if they want this FormatableBitSet if every RC is referenced.

Parameters:
positionedUpdate - Whether or not the scan that the RCL belongs to is for update w/o a column list
always - Whether or not caller always wants a non-null FormatableBitSet if all RCs are referenced.
Returns:
The FormatableBitSet representing the referenced RCs.

compactColumns

ResultColumnList compactColumns(boolean positionedUpdate,
                                boolean always)
                          throws StandardException
Create a new, compacted RCL based on the referenced RCs in this list. If the RCL being compacted is for an updatable scan, then we simply return this. The caller tells us whether or not they want a new list if there is no compaction because all RCs are referenced. This is useful in the case where the caller needs a new RCL for existing RCs so that it can augment the new list.

Parameters:
positionedUpdate - Whether or not the scan that the RCL belongs to is for update w/o a column list
always - Whether or not caller always wants a new RCL
Returns:
The compacted RCL if compaction occurred, otherwise return this RCL.
Throws:
StandardException - Thrown on error

removeJoinColumns

void removeJoinColumns(ResultColumnList joinColumns)
Remove the columns which are join columns (in the joinColumns RCL) from this list. This is useful for a JOIN with a USING clause.

Parameters:
joinColumns - The list of join columns
Returns:
Nothing.

getJoinColumns

ResultColumnList getJoinColumns(ResultColumnList joinColumns)
Get the join columns from this list. This is useful for a join with a USING clause. (ANSI specifies that the join columns appear 1st.)

Parameters:
joinColumns - A list of the join columns.
Returns:
A list of the join columns from this list

resetVirtualColumnIds

void resetVirtualColumnIds()
Reset the virtual column ids for all of the underlying RCs. (Virtual column ids are 1-based.)

Returns:
Nothing.

reusableResult

boolean reusableResult()
Return whether or not the same result row can be used for all rows returned by the associated ResultSet. This is possible if all entries in the list are constants or AggregateNodes.

Returns:
Whether or not the same result row can be used for all rows returned by the associated ResultSet.

getColumnPositions

public int[] getColumnPositions(TableDescriptor td)
                         throws StandardException
Get an array of column positions (1-based) for all the columns in this RCL. Assumes that all the columns are in the passed-in table

Returns:
the array of strings
Throws:
throws - StandardException on error
StandardException

getColumnNames

public java.lang.String[] getColumnNames()
Get an array of strings for all the columns in this RCL.

Returns:
the array of strings

replaceDefaults

void replaceDefaults(TableDescriptor ttd,
                     ResultColumnList tcl)
               throws StandardException
Replace any DEFAULTs with the associated tree for the default.

Parameters:
ttd - The TableDescriptor for the target table.
tcl - The RCL for the target table.
Throws:
StandardException - Thrown on error

checkForInvalidDefaults

void checkForInvalidDefaults()
                       throws StandardException
Walk the RCL and check for DEFAULTs. DEFAULTs are invalid at the time that this method is called, so we throw an exception if found. NOTE: The grammar allows: VALUES DEFAULT;

Returns:
Nothing.
Throws:
StandardException - Thrown on error

verifyAllOrderable

void verifyAllOrderable()
                  throws StandardException
Verify that all of the RCs in this list are comparable.

Returns:
Nothing.
Throws:
StandardException - Thrown on error

populate

public void populate(TableDescriptor table,
                     int[] columnIDs)
              throws StandardException
Build this ResultColumnList from a table description and an array of column IDs.

Parameters:
table - describes the table
columnIDs - column positions in that table (1-based)
Throws:
StandardException - Thrown on error

makeColumnFromName

private ResultColumn makeColumnFromName(java.lang.String columnName)
                                 throws StandardException
Throws:
StandardException

makeColumnReferenceFromName

private ResultColumn makeColumnReferenceFromName(TableName tableName,
                                                 java.lang.String columnName)
                                          throws StandardException
Throws:
StandardException

checkAutoincrement

public void checkAutoincrement(ResultColumnList sourceRSRCL)
                        throws StandardException
check if any autoincrement columns exist in the result column list. called from insert or update where you cannot insert/update the value of an autoincrement column.

Throws:
StandardException - If the column is an ai column

incOrderBySelect

public void incOrderBySelect()

decOrderBySelect

public void decOrderBySelect()

getOrderBySelect

public int getOrderBySelect()

copyOrderBySelect

public void copyOrderBySelect(ResultColumnList src)

markInitialSize

protected void markInitialSize()

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

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 QueryTreeNode
Parameters:
v - the visitor
Throws:
StandardException - on error

Built on Mon 2007-06-04 09:58:47+0400, from revision ???

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