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

   Licensed to the Apache Software Foundation (ASF) under one or more

   contributor license agreements.  See the NOTICE file distributed with

   this work for additional information regarding copyright ownership.

   The ASF licenses this file to you under the Apache License, Version 2.0

   (the "License"); you may not use this file except in compliance with

   the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software

   distributed under the License is distributed on an "AS IS" BASIS,

   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

   See the License for the specific language governing permissions and

   limitations under the License.

*/

*  This class  describes actions that are ALWAYS performed for an

*  ALTER TABLE Statement at Execution time.

*

*/

implements RowLocationRetRowSource

    // copied from constructor args and stored locally.

    private      SchemaDescriptor      sd;

    private      String            tableName;

    private      UUID            schemaId;

    private      int              tableType;

    private      ColumnInfo[]        columnInfo;

    private      ConstraintConstantAction[]  constraintActions;

    private      char            lockGranularity;

    private      long            tableConglomerateId;

    private      boolean              compressTable;

    private     int                behavior;

    private      boolean              sequential;

    private     boolean                     truncateTable;

  //The following three (purge, defragment and truncateEndOfTable) apply for

  //inplace compress

    private      boolean              purge;

    private      boolean              defragment;

    private      boolean              truncateEndOfTable;

  /**

   * 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.

   */

    private      boolean              updateStatistics;

  /**

   * 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              updateStatisticsAll;

  /**

   * 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      String            indexNameForUpdateStatistics;

    /**

     * 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.

     */

    private DataValueDescriptor[][] rowBufferArray;

    private DataValueDescriptor[] rowBuffer;

    private DataValueDescriptor[] lastUniqueKey;

    private static final int GROUP_FETCH_SIZE = 16;

   

    // Alter table compress and Drop column

    private     boolean              doneScan;

    private     boolean[]            needToDropSort;

    private     boolean[]            validRow;

    private      int                bulkFetchSize = 16;

    private      int                currentCompressRow;

    private     int                numIndexes;

    private     int                rowCount;

    private     long              estimatedRowCount;

    private     long[]              indexConglomerateNumbers;

    private      long[]              sortIds;

    private     FormatableBitSet      indexedCols;

    private     ConglomerateController      compressHeapCC;

    private     ExecIndexRow[]          indexRows;

    private     ExecRow[]            baseRow;

    private     ExecRow              currentRow;

    private      GroupFetchScanController    compressHeapGSC;

    private     IndexRowGenerator[]        compressIRGs;

    private      DataValueDescriptor[][]    baseRowArray;

    private     RowLocation[]          compressRL;

    private     SortController[]        sorters;

    private     int                droppedColumnPosition;

    private     ColumnOrdering[][]        ordering;

    private     int[][]                    collation;

    private  TableDescriptor             td;

    // CONSTRUCTORS

    private LanguageConnectionContext lcc;

    private DataDictionary dd;

    private DependencyManager dm;

    private TransactionController tc;

    private Activation activation;

  /**

   *  Make the AlterAction for an ALTER TABLE statement.

   *

   *  @param sd              descriptor for the table's schema.

   *  @param tableName          Name of table.

   *  @param tableId            UUID of table

   *  @param tableConglomerateId  heap conglomerate number of table

   *  @param tableType          Type of table (e.g., BASE).

   *  @param columnInfo          Information on all the columns in the table.

   *  @param constraintActions  ConstraintConstantAction[] for constraints

   *  @param lockGranularity      The lock granularity.

   *  @param compressTable      Whether or not this is a compress table

   *  @param behavior            drop behavior for dropping column

   *  @param sequential          If compress table/drop column,

     *                              whether or not sequential

   *  @param truncateTable      Whether or not this is a truncate table

   *  @param purge        PURGE during INPLACE COMPRESS?

   *  @param defragment      DEFRAGMENT during INPLACE COMPRESS?

   *  @param truncateEndOfTable  TRUNCATE END during INPLACE COMPRESS?

   *  @param updateStatistics    TRUE means we are here to update statistics

   *  @param 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.

   *  @param indexNameForUpdateStatistics  Will name the index whose statistics

   *    will be updated

   */

  AlterTableConstantAction(

    SchemaDescriptor            sd,

    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,

    String                      indexNameForUpdateStatistics)

  {

    super(tableId);

    this.sd                     = sd;

    this.tableName              = tableName;

    this.tableConglomerateId    = tableConglomerateId;

    this.tableType              = tableType;

    this.columnInfo             = columnInfo;

    this.constraintActions      = constraintActions;

    this.lockGranularity        = lockGranularity;

    this.compressTable          = compressTable;

    this.behavior               = behavior;

    this.sequential             = sequential;

    this.truncateTable          = truncateTable;

    this.purge              = purge;

    this.defragment            = defragment;

    this.truncateEndOfTable     = truncateEndOfTable;

    this.updateStatistics       = updateStatistics;

    this.updateStatisticsAll    = updateStatisticsAll;

    this.indexNameForUpdateStatistics = indexNameForUpdateStatistics;

    if (SanityManager.DEBUG)

    {

      SanityManager.ASSERT(sd != null, "schema descriptor is null");

    }

  }

  // OBJECT METHODS

  public  String  toString()

  {

    // Do not put this under SanityManager.DEBUG - it is needed for

    // error reporting.

    // we don't bother trying to print out the

    // schema because we don't have it until execution

    if(truncateTable)

      return "TRUNCATE TABLE " + tableName;

    else

      return "ALTER TABLE " + tableName;

  }

  // INTERFACE METHODS

  /**

   *  This is the guts of the Execution-time logic for ALTER TABLE.

   *

   *  @see ConstantAction#executeConstantAction

   *

   * @exception StandardException    Thrown on failure

   */

  public void  executeConstantAction(

    Activation activation)

        throws StandardException

  {

    LanguageConnectionContext   lcc =

            activation.getLanguageConnectionContext();

    DataDictionary              dd = lcc.getDataDictionary();

    DependencyManager           dm = dd.getDependencyManager();

    TransactionController       tc = lcc.getTransactionExecute();

    int              numRows = 0;

        boolean            tableScanned = false;

        //Following if is for inplace compress. Compress using temporary

        //tables to do the compression is done later in this method.

    if (compressTable)

    {

      if (purge || defragment || truncateEndOfTable)

      {

        td = dd.getTableDescriptor(tableId);

        if (td == null)

        {

          throw StandardException.newException(

            SQLState.LANG_TABLE_NOT_FOUND_DURING_EXECUTION, tableName);

        }

              // Each of the following may give up locks allowing ddl on the

              // table, so each phase needs to do the data dictionary lookup.

              // The order is important as it makes sense to first purge

              // deleted rows, then defragment existing non-deleted rows, and

              // finally to truncate the end of the file which may have been

              // made larger by the previous purge/defragment pass.

              if (purge)

                  purgeRows(tc);

              if (defragment)

                  defragmentRows(tc, lcc);

              if (truncateEndOfTable)

                  truncateEnd(tc);           

              return;       

      }

    }

    if (updateStatistics)

    {

      updateStatistics(activation);

            return;

    }

    /*

    ** Inform the data dictionary that we are about to write to it.

    ** There are several calls to data dictionary "get" methods here

    ** that might be done in "read" mode in the data dictionary, but

    ** it seemed safer to do this whole operation in "write" mode.

    **

    ** We tell the data dictionary we're done writing at the end of

    ** the transaction.

    */

    dd.startWriting(lcc);

    // now do the real work