org.apache.derby.impl.sql.execute
Class AlterTableConstantAction

java.lang.Object
  extended by org.apache.derby.impl.sql.execute.DDLConstantAction
      extended by org.apache.derby.impl.sql.execute.DDLSingleTableConstantAction
          extended by org.apache.derby.impl.sql.execute.AlterTableConstantAction
All Implemented Interfaces:
ConstantAction, RowLocationRetRowSource, RowSource

 class AlterTableConstantAction
extends DDLSingleTableConstantAction
implements RowLocationRetRowSource

This class describes actions that are ALWAYS performed for an ALTER TABLE Statement at Execution time.


Field Summary
private  Activation activation
           
private  ExecRow[] baseRow
           
private  DataValueDescriptor[][] baseRowArray
           
private  int behavior
           
private  int bulkFetchSize
           
private  int[][] collation
           
private  ColumnInfo[] columnInfo
           
private  ConglomerateController compressHeapCC
           
private  GroupFetchScanController compressHeapGSC
           
private  IndexRowGenerator[] compressIRGs
           
private  RowLocation[] compressRL
           
private  boolean compressTable
           
private  ConstraintConstantAction[] constraintActions
           
private  int currentCompressRow
           
private  ExecRow currentRow
           
private  DataDictionary dd
           
private  boolean defragment
           
private  DependencyManager dm
           
private  boolean doneScan
           
private  int droppedColumnPosition
           
private  long estimatedRowCount
           
private static int GROUP_FETCH_SIZE
           
private  long[] indexConglomerateNumbers
           
private  FormatableBitSet indexedCols
           
private  java.lang.String indexNameForUpdateStatistics
          If statistic is getting updated for just one index, then indexNameForUpdateStatistics will tell the name of the specific index whose statistics need to be updated.
private  ExecIndexRow[] indexRows
           
private  DataValueDescriptor[] lastUniqueKey
           
private  LanguageConnectionContext lcc
           
private  char lockGranularity
           
private  boolean[] needToDropSort
           
private  int numIndexes
           
private  ColumnOrdering[][] ordering
           
private  boolean purge
           
private  DataValueDescriptor[] rowBuffer
           
private  DataValueDescriptor[][] rowBufferArray
          RUNTIME state of the system is maintained in these objects.
private  int rowCount
           
private  UUID schemaId
           
private  SchemaDescriptor sd
           
private  boolean sequential
           
private  SortController[] sorters
           
private  long[] sortIds
           
private  long tableConglomerateId
           
private  java.lang.String tableName
           
private  int tableType
           
private  TransactionController tc
           
private  TableDescriptor td
           
private  boolean truncateEndOfTable
           
private  boolean truncateTable
           
private  boolean updateStatistics
          updateStatistics will indicate that we are here for updating the statistics.
private  boolean updateStatisticsAll
          The flag updateStatisticsAll will tell if we are going to update the statistics of all indexes or just one index on a table.
private  boolean[] validRow
           
 
Fields inherited from class org.apache.derby.impl.sql.execute.DDLSingleTableConstantAction
tableId
 
Constructor Summary
AlterTableConstantAction(SchemaDescriptor sd, java.lang.String tableName, UUID tableId, long tableConglomerateId, int tableType, ColumnInfo[] columnInfo, ConstraintConstantAction[] constraintActions, char lockGranularity, boolean compressTable, int behavior, boolean sequential, boolean truncateTable, boolean purge, boolean defragment, boolean truncateEndOfTable, boolean updateStatistics, boolean updateStatisticsAll, java.lang.String indexNameForUpdateStatistics)
          Make the AlterAction for an ALTER TABLE statement.
 
Method Summary
private  void addNewColumnToTable(Activation activation, LanguageConnectionContext lcc, DataDictionary dd, TransactionController tc, int ix)
          Workhorse for adding a new column to a table.
private  void cleanUp()
           
private  void closeBulkFetchScan()
           
 void closeRowSource()
          closeRowSource tells the RowSource that it will no longer need to return any rows and it can release any resource it may have.
private  int compareWithPrevKey(int index, boolean firstRow)
           
private  java.lang.Object[] compressIndexArrays(long[] indexCIDS, IndexRowGenerator[] irgs)
          Get rid of duplicates from a set of index conglomerate numbers and index descriptors.
private  void compressTable(Activation activation)
          routine to process compress table or ALTER TABLE DROP COLUMN ; Uses class level variable "compressTable" to determine if processing compress table or drop column: if (!
private  void createNewBackingCongloms(java.util.ArrayList newConglomActions, long[] ixCongNums, Activation activation, DataDictionary dd)
          Iterate through the received list of CreateIndexConstantActions and execute each one, It's possible that one or more of the constant actions in the list has been rendered "unneeded" by the time we get here (because the index that the constant action was going to create is no longer needed), so we have to check for that.
private  void defragmentRows(TransactionController tc, LanguageConnectionContext lcc)
          Defragment rows in the given table.
private  void dropAllColumnDefaults(UUID tableId, DataDictionary dd)
           
private  void dropColumnFromTable(Activation activation, java.lang.String columnName)
          Workhorse for dropping a column from a table.
 void executeConstantAction(Activation activation)
          This is the guts of the Execution-time logic for ALTER TABLE.
private static void executeUpdate(LanguageConnectionContext lcc, java.lang.String updateStmt)
           
private static void fixIndex(DataValueDescriptor[] base_row, DataValueDescriptor[] index_row, RowLocation old_row_loc, RowLocation new_row_loc, ConglomerateController index_cc, ScanController index_scan, int[] index_col_map)
          Delete old index row and insert new index row in input index.
private  void getAffectedIndexes(Activation activation)
          Get info on the indexes on the table being compressed.
private  long getColumnMax(Activation activation, TableDescriptor td, java.lang.String columnName, long increment, long initial)
          computes the minimum/maximum value in a column of a table.
 DataValueDescriptor[] getNextRowFromRowSource()
          Get the next row as an array of column objects.
private  int getSemiRowCount(TransactionController tc)
          Return the "semi" row count of a table.
 FormatableBitSet getValidColumns()
          getValidColumns describes the DataValueDescriptor[] returned by all calls to the getNextRowFromRowSource() call.
private  void initializeRowBuffers(ExecIndexRow ir)
           
private  void insertIntoSorter(int index, RowLocation rl)
           
private  void modifyColumnConstraint(Activation activation, java.lang.String colName, boolean nullability)
          Workhorse for modifying column level constraints.
private  void modifyColumnDefault(Activation activation, int ix)
          Workhorse for modifying the default value of a column.
private  void modifyColumnType(Activation activation, int ix)
           
 boolean needsRowLocation()
          needsRowLocation returns true iff this the row source expects the drainer of the row source to call rowLocation after getting a row from getNextRowFromRowSource.
 boolean needsToClone()
          Does the caller of getNextRowFromRowSource() need to clone the row in order to keep a reference to the row past the getNextRowFromRowSource() call which returned the row.
private  void objectifyStreamingColumns()
           
private  void openBulkFetchScan(long heapConglomNumber)
           
private  void purgeRows(TransactionController tc)
          Purge committed deleted rows from conglomerate.
 void rowLocation(RowLocation rl)
          rowLocation is a callback for the drainer of the row source to return the rowLocation of the current row, i.e, the row that is being returned by getNextRowFromRowSource.
private static void setup_indexes(TransactionController tc, TableDescriptor td, int[][] index_col_map, ScanController[] index_scan, ConglomerateController[] index_cc, DataValueDescriptor[][] index_row)
           
private  void setUpAllSorts(ExecRow sourceRow, RowLocation rl)
          Set up to update all of the indexes on a table when doing a bulk insert on an empty table.
 java.lang.String toString()
           
private  void truncateEnd(TransactionController tc)
          Truncate end of conglomerate.
private  void truncateTable(Activation activation)
           
private  void updateAllIndexes(long newHeapConglom, DataDictionary dd)
          Update all of the indexes on a table when doing a bulk insert on an empty table.
private  void updateIndex(long newHeapConglom, DataDictionary dd, int index, long[] newIndexCongloms)
           
private  void updateNewAutoincrementColumn(Activation activation, java.lang.String columnName, long initial, long increment)
          Update values in a new autoincrement column being added to a table.
private  void updateNewColumnToDefault(Activation activation, ColumnDescriptor columnDescriptor, LanguageConnectionContext lcc)
          Update a new column with its default.
private  void updateStatistics(Activation activation)
          Update statistics of either all the indexes on the table or only one specific index depending on what user has requested.
private  boolean validateNotNullConstraint(java.lang.String[] columnNames, boolean[] nullCols, int numRows, LanguageConnectionContext lcc, java.lang.String errorMsg)
          Make sure that the columns are non null If any column is nullable, check that the data is null.
 
Methods inherited from class org.apache.derby.impl.sql.execute.DDLSingleTableConstantAction
dropConglomerate, dropConglomerate, dropConstraint, dropConstraint, dropConstraint, executeConglomReplacement, getConglomReplacementAction, recreateUniqueConstraintBackingIndexAsUniqueWhenNotNull
 
Methods inherited from class org.apache.derby.impl.sql.execute.DDLConstantAction
addColumnDependencies, adjustUDTDependencies, adjustUDTDependencies, constructToString, getAndCheckSchemaDescriptor, getSchemaDescriptorForCreate, lockTableForDDL, storeConstraintDependenciesOnPrivileges, storeViewTriggerDependenciesOnPrivileges
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
 

Field Detail

sd

private SchemaDescriptor sd

tableName

private java.lang.String tableName

schemaId

private UUID schemaId

tableType

private int tableType

columnInfo

private ColumnInfo[] columnInfo

constraintActions

private ConstraintConstantAction[] constraintActions

lockGranularity

private char lockGranularity

tableConglomerateId

private long tableConglomerateId

compressTable

private boolean compressTable

behavior

private int behavior

sequential

private boolean sequential

truncateTable

private boolean truncateTable

purge

private boolean purge

defragment

private boolean defragment

truncateEndOfTable

private boolean truncateEndOfTable

updateStatistics

private boolean updateStatistics
updateStatistics will indicate that we are here for updating the statistics. It could be statistics of just one index or all the indexes on a given table.


updateStatisticsAll

private boolean updateStatisticsAll
The flag updateStatisticsAll will tell if we are going to update the statistics of all indexes or just one index on a table.


indexNameForUpdateStatistics

private java.lang.String indexNameForUpdateStatistics
If statistic is getting updated for just one index, then indexNameForUpdateStatistics will tell the name of the specific index whose statistics need to be updated.


rowBufferArray

private DataValueDescriptor[][] rowBufferArray
RUNTIME state of the system is maintained in these objects. rowBufferOne simply reuses the index row prepared by makeConstantAction. rowBufferTwo is a clone (an extra copy) of objects. rowBufferCurrent just switches between rowBufferOne and rowBufferTwo.


rowBuffer

private DataValueDescriptor[] rowBuffer

lastUniqueKey

private DataValueDescriptor[] lastUniqueKey

GROUP_FETCH_SIZE

private static final int GROUP_FETCH_SIZE
See Also:
Constant Field Values

doneScan

private boolean doneScan

needToDropSort

private boolean[] needToDropSort

validRow

private boolean[] validRow

bulkFetchSize

private int bulkFetchSize

currentCompressRow

private int currentCompressRow

numIndexes

private int numIndexes

rowCount

private int rowCount

estimatedRowCount

private long estimatedRowCount

indexConglomerateNumbers

private long[] indexConglomerateNumbers

sortIds

private long[] sortIds

indexedCols

private FormatableBitSet indexedCols

compressHeapCC

private ConglomerateController compressHeapCC

indexRows

private ExecIndexRow[] indexRows

baseRow

private ExecRow[] baseRow

currentRow

private ExecRow currentRow

compressHeapGSC

private GroupFetchScanController compressHeapGSC

compressIRGs

private IndexRowGenerator[] compressIRGs

baseRowArray

private DataValueDescriptor[][] baseRowArray

compressRL

private RowLocation[] compressRL

sorters

private SortController[] sorters

droppedColumnPosition

private int droppedColumnPosition

ordering

private ColumnOrdering[][] ordering

collation

private int[][] collation

td

private TableDescriptor td

lcc

private LanguageConnectionContext lcc

dd

private DataDictionary dd

dm

private DependencyManager dm

tc

private TransactionController tc

activation

private Activation activation
Constructor Detail

AlterTableConstantAction

AlterTableConstantAction(SchemaDescriptor sd,
                         java.lang.String tableName,
                         UUID tableId,
                         long tableConglomerateId,
                         int tableType,
                         ColumnInfo[] columnInfo,
                         ConstraintConstantAction[] constraintActions,
                         char lockGranularity,
                         boolean compressTable,
                         int behavior,
                         boolean sequential,
                         boolean truncateTable,
                         boolean purge,
                         boolean defragment,
                         boolean truncateEndOfTable,
                         boolean updateStatistics,
                         boolean updateStatisticsAll,
                         java.lang.String indexNameForUpdateStatistics)
Make the AlterAction for an ALTER TABLE statement.

Parameters:
sd - descriptor for the table's schema.
tableName - Name of table.
tableId - UUID of table
tableConglomerateId - heap conglomerate number of table
tableType - Type of table (e.g., BASE).
columnInfo - Information on all the columns in the table.
constraintActions - ConstraintConstantAction[] for constraints
lockGranularity - The lock granularity.
compressTable - Whether or not this is a compress table
behavior - drop behavior for dropping column
sequential - If compress table/drop column, whether or not sequential
truncateTable - Whether or not this is a truncate table
purge - PURGE during INPLACE COMPRESS?
defragment - DEFRAGMENT during INPLACE COMPRESS?
truncateEndOfTable - TRUNCATE END during INPLACE COMPRESS?
updateStatistics - TRUE means we are here to update statistics
updateStatisticsAll - TRUE means we are here to update statistics of all the indexes. False means we are here to update statistics of only one index.
indexNameForUpdateStatistics - Will name the index whose statistics will be updated
Method Detail

toString

public java.lang.String toString()
Overrides:
toString in class java.lang.Object

executeConstantAction

public void executeConstantAction(Activation activation)
                           throws StandardException
This is the guts of the Execution-time logic for ALTER TABLE.

Specified by:
executeConstantAction in interface ConstantAction
Parameters:
activation - The execution environment for this constant action.
Throws:
StandardException - Thrown on failure
See Also:
ConstantAction.executeConstantAction(org.apache.derby.iapi.sql.Activation)

updateStatistics

private void updateStatistics(Activation activation)
                       throws StandardException
Update statistics of either all the indexes on the table or only one specific index depending on what user has requested.

Parameters:
activation - the current activation
Throws:
StandardException

initializeRowBuffers

private void initializeRowBuffers(ExecIndexRow ir)

compareWithPrevKey

private int compareWithPrevKey(int index,
                               boolean firstRow)
                        throws StandardException
Throws:
StandardException

truncateEnd

private void truncateEnd(TransactionController tc)
                  throws StandardException
Truncate end of conglomerate.

Returns the contiguous free space at the end of the table back to the operating system. Takes care of space allocation bit maps, and OS call to return the actual space.

Parameters:
tc - transaction controller to use to do updates.
Throws:
StandardException

defragmentRows

private void defragmentRows(TransactionController tc,
                            LanguageConnectionContext lcc)
                     throws StandardException
Defragment rows in the given table.

Scans the rows at the end of a table and moves them to free spots towards the beginning of the table. In the same transaction all associated indexes are updated to reflect the new location of the base table row.

After a defragment pass, if was possible, there will be a set of empty pages at the end of the table which can be returned to the operating system by calling truncateEnd(). The allocation bit maps will be set so that new inserts will tend to go to empty and half filled pages starting from the front of the conglomerate.

Parameters:
tc - transaction controller to use to do updates.
lcc - the language connection context
Throws:
StandardException

setup_indexes

private static void setup_indexes(TransactionController tc,
                                  TableDescriptor td,
                                  int[][] index_col_map,
                                  ScanController[] index_scan,
                                  ConglomerateController[] index_cc,
                                  DataValueDescriptor[][] index_row)
                           throws StandardException
Throws:
StandardException

fixIndex

private static void fixIndex(DataValueDescriptor[] base_row,
                             DataValueDescriptor[] index_row,
                             RowLocation old_row_loc,
                             RowLocation new_row_loc,
                             ConglomerateController index_cc,
                             ScanController index_scan,
                             int[] index_col_map)
                      throws StandardException
Delete old index row and insert new index row in input index.

Parameters:
base_row - all columns of base row
index_row - an index row template, filled in by this routine
old_row_loc - old location of base row, used to delete index
new_row_loc - new location of base row, used to update index
index_cc - index conglomerate to insert new row
index_scan - index scan to delete old entry
index_col_map - description of mapping of index row to base row,
Throws:
StandardException - Standard exception policy.

purgeRows

private void purgeRows(TransactionController tc)
                throws StandardException
Purge committed deleted rows from conglomerate.

Scans the table and purges any committed deleted rows from the table. If all rows on a page are purged then page is also reclaimed.

Parameters:
tc - transaction controller to use to do updates.
Throws:
StandardException

addNewColumnToTable

private void addNewColumnToTable(Activation activation,
                                 LanguageConnectionContext lcc,
                                 DataDictionary dd,
                                 TransactionController tc,
                                 int ix)
                          throws StandardException
Workhorse for adding a new column to a table.

Parameters:
ix - the index of the column specfication in the ALTER statement-- currently we allow only one.
Throws:
StandardException - thrown on failure.

dropColumnFromTable

private void dropColumnFromTable(Activation activation,
                                 java.lang.String columnName)
                          throws StandardException
Workhorse for dropping a column from a table. This routine drops a column from a table, taking care to properly handle the various related schema objects. The syntax which gets you here is: ALTER TABLE tbl DROP [COLUMN] col [CASCADE|RESTRICT] The keyword COLUMN is optional, and if you don't specify CASCADE or RESTRICT, the default is CASCADE (the default is chosen in the parser, not here). If you specify RESTRICT, then the column drop should be rejected if it would cause a dependent schema object to become invalid. If you specify CASCADE, then the column drop should additionally drop other schema objects which have become invalid. You may not drop the last (only) column in a table. Schema objects of interest include: - views - triggers - constraints - check constraints - primary key constraints - foreign key constraints - unique key constraints - not null constraints - privileges - indexes - default values Dropping a column may also change the column position numbers of other columns in the table, which may require fixup of schema objects (such as triggers and column privileges) which refer to columns by column position number. Indexes are a bit interesting. The official SQL spec doesn't talk about indexes; they are considered to be an imlementation-specific performance optimization. The current Derby behavior is that: - CASCADE/RESTRICT doesn't matter for indexes - when a column is dropped, it is removed from any indexes which contain it. - if that column was the only column in the index, the entire index is dropped.

Parameters:
activation - the current activation
columnName - the name of the column specfication in the ALTER statement-- currently we allow only one.
Throws:
StandardException - thrown on failure.

modifyColumnType

private void modifyColumnType(Activation activation,
                              int ix)
                       throws StandardException
Throws:
StandardException

modifyColumnConstraint

private void modifyColumnConstraint(Activation activation,
                                    java.lang.String colName,
                                    boolean nullability)
                             throws StandardException
Workhorse for modifying column level constraints. Right now it is restricted to modifying a null constraint to a not null constraint.

Throws:
StandardException

modifyColumnDefault

private void modifyColumnDefault(Activation activation,
                                 int ix)
                          throws StandardException
Workhorse for modifying the default value of a column.

Parameters:
activation - activation
ix - the index of the column specfication in the ALTER statement-- currently we allow only one.
Throws:
StandardException, - thrown on error.
StandardException

compressTable

private void compressTable(Activation activation)
                    throws StandardException
routine to process compress table or ALTER TABLE DROP COLUMN ;

Uses class level variable "compressTable" to determine if processing compress table or drop column: if (!compressTable) must be drop column.

Handles rebuilding of base conglomerate and all necessary indexes.

Throws:
StandardException

truncateTable

private void truncateTable(Activation activation)
                    throws StandardException
Throws:
StandardException

updateAllIndexes

private void updateAllIndexes(long newHeapConglom,
                              DataDictionary dd)
                       throws StandardException
Update all of the indexes on a table when doing a bulk insert on an empty table.

Throws:
StandardException - thrown on error

updateIndex

private void updateIndex(long newHeapConglom,
                         DataDictionary dd,
                         int index,
                         long[] newIndexCongloms)
                  throws StandardException
Throws:
StandardException

getAffectedIndexes

private void getAffectedIndexes(Activation activation)
                         throws StandardException
Get info on the indexes on the table being compressed.

Throws:
StandardException - Thrown on error

createNewBackingCongloms

private void createNewBackingCongloms(java.util.ArrayList newConglomActions,
                                      long[] ixCongNums,
                                      Activation activation,
                                      DataDictionary dd)
                               throws StandardException
Iterate through the received list of CreateIndexConstantActions and execute each one, It's possible that one or more of the constant actions in the list has been rendered "unneeded" by the time we get here (because the index that the constant action was going to create is no longer needed), so we have to check for that.

Parameters:
newConglomActions - Potentially empty list of constant actions to execute, if still needed
ixCongNums - Optional array of conglomerate numbers; if non-null then any entries in the array which correspond to a dropped physical conglomerate (as determined from the list of constant actions) will be updated to have the conglomerate number of the newly-created physical conglomerate.
Throws:
StandardException

setUpAllSorts

private void setUpAllSorts(ExecRow sourceRow,
                           RowLocation rl)
                    throws StandardException
Set up to update all of the indexes on a table when doing a bulk insert on an empty table.

Throws:
StandardException - thrown on error

getValidColumns

public FormatableBitSet getValidColumns()
Description copied from interface: RowSource
getValidColumns describes the DataValueDescriptor[] returned by all calls to the getNextRowFromRowSource() call. If getValidColumns returns null, the number of columns is given by the DataValueDescriptor.length where DataValueDescriptor[] is returned by the preceeding getNextRowFromRowSource() call. Column N maps to DataValueDescriptor[N], where column numbers start at zero. If getValidColumns return a non null validColumns FormatableBitSet the number of columns is given by the number of bits set in validColumns. Column N is not in the partial row if validColumns.get(N) returns false. Column N is in the partial row if validColumns.get(N) returns true. If column N is in the partial row then it maps to DataValueDescriptor[M] where M is the count of calls to validColumns.get(i) that return true where i < N. If DataValueDescriptor.length is greater than the number of columns indicated by validColumns the extra entries are ignored.

Specified by:
getValidColumns in interface RowSource
See Also:
RowSource.getValidColumns()

getNextRowFromRowSource

public DataValueDescriptor[] getNextRowFromRowSource()
                                              throws StandardException
Description copied from interface: RowSource
Get the next row as an array of column objects. The column objects can be a JBMS Storable or any Serializable/Externalizable/Formattable/Streaming type.
A return of null indicates that the complete set of rows has been read.

A null column can be specified by leaving the object null, or indicated by returning a non-null getValidColumns. On streaming columns, it can be indicated by returning a non-null get FieldStates.

If RowSource.needToClone() is true then the returned row (the DataValueDescriptor[]) is guaranteed not to be modified by drainer of the RowSource (except that the input stream will be read, of course) and drainer will keep no reference to it before making the subsequent nextRow call. So it is safe to return the same DataValueDescriptor[] in subsequent nextRow calls if that is desirable for performance reasons.

If RowSource.needToClone() is false then the returned row (the DataValueDescriptor[]) may be be modified by drainer of the RowSource, and the drainer may keep a reference to it after making the subsequent nextRow call. In this case the client should severe all references to the row after returning it from getNextRowFromRowSource().

Specified by:
getNextRowFromRowSource in interface RowSource
Throws:
StandardException - on error
See Also:
RowSource.getNextRowFromRowSource()

needsToClone

public boolean needsToClone()
Description copied from interface: RowSource
Does the caller of getNextRowFromRowSource() need to clone the row in order to keep a reference to the row past the getNextRowFromRowSource() call which returned the row. This call must always return the same for all rows in a RowSource (ie. the caller will call this once per scan from a RowSource and assume the behavior is true for all rows in the RowSource).

Specified by:
needsToClone in interface RowSource
See Also:
RowSource.needsToClone()

closeRowSource

public void closeRowSource()
Description copied from interface: RowSource
closeRowSource tells the RowSource that it will no longer need to return any rows and it can release any resource it may have. Subsequent call to any method on the RowSource will result in undefined behavior. A closed rowSource can be closed again.

Specified by:
closeRowSource in interface RowSource
See Also:
RowSource.closeRowSource()

needsRowLocation

public boolean needsRowLocation()
Description copied from interface: RowLocationRetRowSource
needsRowLocation returns true iff this the row source expects the drainer of the row source to call rowLocation after getting a row from getNextRowFromRowSource.

Specified by:
needsRowLocation in interface RowLocationRetRowSource
Returns:
true iff this row source expects some row location to be returned
See Also:
RowLocationRetRowSource.needsRowLocation()

rowLocation

public void rowLocation(RowLocation rl)
                 throws StandardException
Description copied from interface: RowLocationRetRowSource
rowLocation is a callback for the drainer of the row source to return the rowLocation of the current row, i.e, the row that is being returned by getNextRowFromRowSource. This interface is for the purpose of loading a base table with index. In that case, the indices can be built at the same time the base table is laid down once the row location of the base row is known. This is an example pseudo code on how this call is expected to be used:
                boolean needsRL = rowSource.needsRowLocation();
                DataValueDescriptor[] row;
                while((row = rowSource.getNextRowFromRowSource()) != null)
                {
                        RowLocation rl = heapConglomerate.insertRow(row);
                        if (needsRL)
                                rowSource.rowLocation(rl);
                }
                

NeedsRowLocation and rowLocation will ONLY be called by a drainer of the row source which CAN return a row location. Drainer of row source which cannot return rowLocation will guarentee to not call either callbacks. Conversely, if NeedsRowLocation is called and it returns true, then for every row return by getNextRowFromRowSource, a rowLocation callback must also be issued with the row location of the row. Implementor of both the source and the drain of the row source must be aware of this protocol.
The RowLocation object is own by the caller of rowLocation, in other words, the drainer of the RowSource. This is so that we don't need to new a row location for every row. If the Row Source wants to keep the row location, it needs to clone it (RowLocation is a ClonableObject).

Specified by:
rowLocation in interface RowLocationRetRowSource
Throws:
StandardException - on error
See Also:
RowLocationRetRowSource.rowLocation(org.apache.derby.iapi.types.RowLocation)

objectifyStreamingColumns

private void objectifyStreamingColumns()
                                throws StandardException
Throws:
StandardException

insertIntoSorter

private void insertIntoSorter(int index,
                              RowLocation rl)
                       throws StandardException
Throws:
StandardException

cleanUp

private void cleanUp()
              throws StandardException
Throws:
StandardException - Thrown on error

getSemiRowCount

private int getSemiRowCount(TransactionController tc)
                     throws StandardException
Return the "semi" row count of a table. We are only interested in whether the table has 0, 1 or > 1 rows.

Returns:
Number of rows (0, 1 or > 1) in table.
Throws:
StandardException - Thrown on failure

updateNewColumnToDefault

private void updateNewColumnToDefault(Activation activation,
                                      ColumnDescriptor columnDescriptor,
                                      LanguageConnectionContext lcc)
                               throws StandardException
Update a new column with its default. We could do the scan ourself here, but instead we get a nested connection and issue the appropriate update statement.

Parameters:
columnDescriptor - catalog descriptor for the column
lcc - the language connection context
Throws:
StandardException - if update to default fails

executeUpdate

private static void executeUpdate(LanguageConnectionContext lcc,
                                  java.lang.String updateStmt)
                           throws StandardException
Throws:
StandardException

getColumnMax

private long getColumnMax(Activation activation,
                          TableDescriptor td,
                          java.lang.String columnName,
                          long increment,
                          long initial)
                   throws StandardException
computes the minimum/maximum value in a column of a table.

Throws:
StandardException

dropAllColumnDefaults

private void dropAllColumnDefaults(UUID tableId,
                                   DataDictionary dd)
                            throws StandardException
Throws:
StandardException

openBulkFetchScan

private void openBulkFetchScan(long heapConglomNumber)
                        throws StandardException
Throws:
StandardException

closeBulkFetchScan

private void closeBulkFetchScan()
                         throws StandardException
Throws:
StandardException

updateNewAutoincrementColumn

private void updateNewAutoincrementColumn(Activation activation,
                                          java.lang.String columnName,
                                          long initial,
                                          long increment)
                                   throws StandardException
Update values in a new autoincrement column being added to a table. This is similar to updateNewColumnToDefault whereby we issue an update statement using a nested connection. The UPDATE statement uses a static method in ConnectionInfo (which is not documented) which returns the next value to be inserted into the autoincrement column.

Parameters:
columnName - autoincrement column name that is being added.
initial - initial value of the autoincrement column.
increment - increment value of the autoincrement column.
Throws:
StandardException
See Also:
updateNewColumnToDefault(org.apache.derby.iapi.sql.Activation, org.apache.derby.iapi.sql.dictionary.ColumnDescriptor, org.apache.derby.iapi.sql.conn.LanguageConnectionContext)

validateNotNullConstraint

private boolean validateNotNullConstraint(java.lang.String[] columnNames,
                                          boolean[] nullCols,
                                          int numRows,
                                          LanguageConnectionContext lcc,
                                          java.lang.String errorMsg)
                                   throws StandardException
Make sure that the columns are non null If any column is nullable, check that the data is null.

Parameters:
columnNames - names of columns to be checked
nullCols - true if corresponding column is nullable
numRows - number of rows in the table
lcc - language context
errorMsg - error message to use for exception
Returns:
true if any nullable columns found (nullable columns must have all non null data or exception is thrown
Throws:
StandardException - on error

compressIndexArrays

private java.lang.Object[] compressIndexArrays(long[] indexCIDS,
                                               IndexRowGenerator[] irgs)
Get rid of duplicates from a set of index conglomerate numbers and index descriptors.

Parameters:
indexCIDS - array of index conglomerate numbers
irgs - array of index row generaters
Returns:
value: If no duplicates, returns NULL; otherwise, a size-3 array of objects, first element is an array of duplicates' indexes in the input arrays; second element is the compact indexCIDs; third element is the compact irgs.

Built on Thu 2011-03-10 11:54:14+0000, from revision ???

Apache Derby V10.6 Internals - Copyright © 2004,2007 The Apache Software Foundation. All Rights Reserved.