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;

    // 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

   */

  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)

  {

    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;

    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;

    /*

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

    // get an exclusive lock of the heap, to avoid deadlock on rows of

    // SYSCOLUMNS etc datadictionary tables and phantom table

    // descriptor, in which case table shape could be changed by a

    // concurrent thread doing add/drop column.

    // older version (or at target) has to get td first, potential deadlock

    if (tableConglomerateId == 0)

    {

      td = dd.getTableDescriptor(tableId);

      if (td == null)

      {

        throw StandardException.newException(

          SQLState.LANG_TABLE_NOT_FOUND_DURING_EXECUTION, tableName);

      }

      tableConglomerateId = td.getHeapConglomerateId();

    }

    lockTableForDDL(tc, tableConglomerateId, true);

    td = dd.getTableDescriptor(tableId);

    if (td == null)

    {

      throw StandardException.newException(

        SQLState.LANG_TABLE_NOT_FOUND_DURING_EXECUTION, tableName);

    }

    if (truncateTable)

      dm.invalidateFor(td, DependencyManager.TRUNCATE_TABLE, lcc);

    else

      dm.invalidateFor(td, DependencyManager.ALTER_TABLE, lcc);

    // Save the TableDescriptor off in the Activation

    activation.setDDLTableDescriptor(td);

    /*

    ** If the schema descriptor is null, then we must have just read

        ** ourselves in.  So we will get the corresponding schema descriptor

        ** from the data dictionary.

    */

    if (sd == null)

    {

      sd = getAndCheckSchemaDescriptor(dd, schemaId, "ALTER TABLE");

    }

   

    /* Prepare all dependents to invalidate.  (This is there chance

     * to say that they can't be invalidated.  For example, an open

     * cursor referencing a table/view that the user is attempting to

     * alter.) If no one objects, then invalidate any dependent objects.

     */

    if(truncateTable)

      dm.invalidateFor(td, DependencyManager.TRUNCATE_TABLE, lcc);

    else

      dm.invalidateFor(td, DependencyManager.ALTER_TABLE, lcc);

    // Are we working on columns?

    if (columnInfo != null)

    {

            boolean tableNeedsScanning = false;

      /* NOTE: We only allow a single column to be added within

       * each ALTER TABLE command at the language level.  However,

       * this may change some day, so we will try to plan for it.

       */

      /* for each new column, see if the user is adding a non-nullable

       * column.  This is only allowed on an empty table.

       */

      for (int ix = 0; ix < columnInfo.length; ix++)

      {

        /* Is this new column non-nullable? 

         * If so, it can only be added to an

         * empty table if it does not have a default value. 

         * We need to scan the table to find out how many rows

         * there are.

         */

        if ((columnInfo[ix].action == ColumnInfo.CREATE) &&

          !(columnInfo[ix].dataType.isNullable()) &&

          (columnInfo[ix].defaultInfo == null) &&

          (columnInfo[ix].autoincInc == 0)

          )

        {

          tableNeedsScanning = true;

        }

      }

      // Scan the table if necessary

      if (tableNeedsScanning)

      {

        numRows = getSemiRowCount(tc);

        // Don't allow add of non-nullable column to non-empty table

        if (numRows > 0)

        {

          throw StandardException.newException(

                        SQLState.LANG_ADDING_NON_NULL_COLUMN_TO_NON_EMPTY_TABLE,

                        td.getQualifiedName());

        }

        tableScanned = true;

      }

      // for each related column, stuff system.column

      for (int ix = 0; ix < columnInfo.length; ix++)

      {

        ColumnDescriptorList cdl = new ColumnDescriptorList();

        /* If there is a default value, use it, otherwise use null */

       

        // Are we adding a new column or modifying a default?

       

        if (columnInfo[ix].action == ColumnInfo.CREATE)

        {

          addNewColumnToTable(activation, lcc, dd, tc, ix);

        }

        else if (columnInfo[ix].action ==

             ColumnInfo.MODIFY_COLUMN_DEFAULT_RESTART ||

             columnInfo[ix].action ==

             ColumnInfo.MODIFY_COLUMN_DEFAULT_INCREMENT ||

             columnInfo[ix].action ==

             ColumnInfo.MODIFY_COLUMN_DEFAULT_VALUE)

        {

          modifyColumnDefault(activation, ix);

        }

        else if (columnInfo[ix].action ==

             ColumnInfo.MODIFY_COLUMN_TYPE)

        {

          modifyColumnType(activation, ix);

        }

        else if (columnInfo[ix].action ==

             ColumnInfo.MODIFY_COLUMN_CONSTRAINT)

        {

          modifyColumnConstraint(

                        activation, columnInfo[ix].name, true);

        }

        else if (columnInfo[ix].action ==

             ColumnInfo.MODIFY_COLUMN_CONSTRAINT_NOT_NULL)

        {

          if (!tableScanned)

          {

            tableScanned = true;

            numRows = getSemiRowCount(tc);

          }

          // check that the data in the column is not null

          String colNames[]  = new String[1];

          colNames[0]        = columnInfo[ix].name;

          boolean nullCols[] = new boolean[1];

          /* note validateNotNullConstraint returns true if the

           * column is nullable

           */

          if (validateNotNullConstraint(

                            colNames, nullCols, numRows, lcc,

                            SQLState.LANG_NULL_DATA_IN_NON_NULL_COLUMN))

          {

            /* nullable column - modify it to be not null

             * This is O.K. at this point since we would have

             * thrown an exception if any data was null

             */

            modifyColumnConstraint(

                            activation, columnInfo[ix].name, false);

          }

        }

        else if (columnInfo[ix].action == ColumnInfo.DROP)

        {

          dropColumnFromTable(activation, ix);

        }

        else if (SanityManager.DEBUG)

        {

          SanityManager.THROWASSERT(

                "Unexpected action in AlterTableConstantAction");

        }

      }

    }

    /* Create/Drop any constraints */

    if (constraintActions != null)

    {

      for (int conIndex = 0;

                 conIndex < constraintActions.length;

                 conIndex++)

      {

        ConstraintConstantAction cca = constraintActions[conIndex];

        if (cca instanceof CreateConstraintConstantAction)

        {

          int constraintType = cca.getConstraintType();

          /* Some constraint types require special checking:

           *   Check     - table must be empty, for now

           *   Primary Key - table cannot already have a primary key

           */

          switch (constraintType)

          {

            case DataDictionary.PRIMARYKEY_CONSTRAINT:

              // Check to see if a constraint of the same type

                            // already exists

              ConstraintDescriptorList cdl =

                                dd.getConstraintDescriptors(td);

              if (cdl.getPrimaryKey() != null)

              {

                throw StandardException.newException(

                                    SQLState.LANG_ADD_PRIMARY_KEY_FAILED1,

                                    td.getQualifiedName());

              }

              if (!tableScanned)

              {

                tableScanned = true;

                numRows = getSemiRowCount(tc);

              }

              break;

            case DataDictionary.CHECK_CONSTRAINT:

              if (!tableScanned)

              {

                tableScanned = true;

                numRows = getSemiRowCount(tc);

              }

              if (numRows > 0)

              {

                /*

                ** We are assuming that there will only be one

                ** check constraint that we are adding, so it

                ** is ok to do the check now rather than try

                ** to lump together several checks. 

                */

                ConstraintConstantAction.validateConstraint(

                                    cca.getConstraintName(),

                                    ((CreateConstraintConstantAction)cca).getConstraintText(),

                                    td,

                                    lcc, true);

              }

              break;

          }

        }

        else

        {

          if (SanityManager.DEBUG)

          {

            if (!(cca instanceof DropConstraintConstantAction))

            {

              SanityManager.THROWASSERT(

                                "constraintActions[" + conIndex +

                                "] expected to be instanceof " +

                                "DropConstraintConstantAction not " +

                                cca.getClass().getName());

            }

          }

        }

        constraintActions[conIndex].executeConstantAction(activation);

      }

    }

    // Are we changing the lock granularity?

    if (lockGranularity != '\0')

    {

      if (SanityManager.DEBUG)

      {

        if (lockGranularity != 'T' &&

          lockGranularity != 'R')

        {

          SanityManager.THROWASSERT(

            "lockGranularity expected to be 'T'or 'R', not " +

                        lockGranularity);

        }

      }

      // update the TableDescriptor

      td.setLockGranularity(lockGranularity);

      // update the DataDictionary

      dd.updateLockGranularity(td, sd, lockGranularity, tc);

    }

    // Are we doing a compress table?

    if (compressTable)

    {

      compressTable(activation);

    }

    // Are we doing a truncate table?

    if (truncateTable)

    {

      truncateTable(activation);

    }

  }

  /**

   * Workhorse for adding a new column to a table.

   *

   * @param   ix       the index of the column specfication in the ALTER

   *            statement-- currently we allow only one.

   * @exception StandardException   thrown on failure.

   */

  private void addNewColumnToTable(

    Activation                  activation,

    LanguageConnectionContext   lcc,

    DataDictionary              dd,

    TransactionController       tc,

    int                         ix)

          throws StandardException

  {

    ColumnDescriptor columnDescriptor   =

      td.getColumnDescriptor(columnInfo[ix].name);

    DataValueDescriptor storableDV;

    int                     colNumber   = td.getMaxColumnID() + ix;

    DataDescriptorGenerator ddg         = dd.getDataDescriptorGenerator();

    /* We need to verify that the table does not have an existing

     * column with the same name before we try to add the new

     * one as addColumnDescriptor() is a void method.

     */

    if (columnDescriptor != null)

    {

      throw

        StandardException.newException(

                   SQLState.LANG_OBJECT_ALREADY_EXISTS_IN_OBJECT,

                   columnDescriptor.getDescriptorType(),

                   columnInfo[ix].name,

                   td.getDescriptorType(),

                   td.getQualifiedName());

    }

    if (columnInfo[ix].defaultValue != null)

      storableDV = columnInfo[ix].defaultValue;

    else

      storableDV = columnInfo[ix].dataType.getNull();

    // Add the column to the conglomerate.(Column ids in store are 0-based)

    tc.addColumnToConglomerate(

            td.getHeapConglomerateId(),

            colNumber,

            storableDV,

            columnInfo[ix].dataType.getCollationType());

    UUID defaultUUID = columnInfo[ix].newDefaultUUID;

    /* Generate a UUID for the default, if one exists

     * and there is no default id yet.

     */

    if (columnInfo[ix].defaultInfo != null &&

      defaultUUID == null)

    {

      defaultUUID = dd.getUUIDFactory().createUUID();

    }

    // Add the column to syscolumns.

    // Column ids in system tables are 1-based

    columnDescriptor =

            new ColumnDescriptor(

                   columnInfo[ix].name,

                   colNumber + 1,

                   columnInfo[ix].dataType,

                   columnInfo[ix].defaultValue,

                   columnInfo[ix].defaultInfo,

                   td,

                   defaultUUID,

                   columnInfo[ix].autoincStart,

                   columnInfo[ix].autoincInc

                   );

    dd.addDescriptor(columnDescriptor, td,

             DataDictionary.SYSCOLUMNS_CATALOG_NUM, false, tc);

    // now add the column to the tables column descriptor list.

    td.getColumnDescriptorList().add(columnDescriptor);

    if (columnDescriptor.isAutoincrement())

    {

      updateNewAutoincrementColumn(activation, columnInfo[ix].name,

                     columnInfo[ix].autoincStart,

                     columnInfo[ix].autoincInc);

    }

    // Update the new column to its default, if it has a non-null default

    if (columnDescriptor.hasNonNullDefault())

    {

      updateNewColumnToDefault(activation,

                columnInfo[ix].name,

                columnInfo[ix].defaultInfo.getDefaultText(),

                lcc);

    } 

    // Update SYSCOLPERMS table which tracks the permissions granted

    // at columns level. The sytem table has a bit map of all the columns

    // in the user table to help determine which columns have the

    // permission granted on them. Since we are adding a new column,

    // that bit map needs to be expanded and initialize the bit for it

    // to 0 since at the time of ADD COLUMN, no permissions have been

    // granted on that new column.

    //

    dd.updateSYSCOLPERMSforAddColumnToUserTable(td.getUUID(), tc);

  }

  /**

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

   *

     * @param   activation  the current activation

   * @param   ix       the index of the column specfication in the ALTER

   *            statement-- currently we allow only one.

   * @exception StandardException   thrown on failure.

   */

  private void dropColumnFromTable(Activation activation,

                   int ix)

          throws StandardException

  {

    LanguageConnectionContext lcc = activation.getLanguageConnectionContext();

    DataDictionary dd = lcc.getDataDictionary();

    DependencyManager dm = dd.getDependencyManager();

    TransactionController tc = lcc.getTransactionExecute();

    ColumnDescriptor columnDescriptor =

      td.getColumnDescriptor(columnInfo[ix].name);

    // We already verified this in bind, but do it again

    if (columnDescriptor == null)

    {

      throw

        StandardException.newException(

                    SQLState.LANG_COLUMN_NOT_FOUND_IN_TABLE,

                    columnInfo[ix].name,

                    td.getQualifiedName());

    }

    DataDescriptorGenerator ddg = dd.getDataDescriptorGenerator();

    ColumnDescriptorList tab_cdl = td.getColumnDescriptorList();

    int size = tab_cdl.size();

    // can NOT drop a column if it is the only one in the table

    if (size == 1)

    {

      throw StandardException.newException(

                    SQLState.LANG_PROVIDER_HAS_DEPENDENT_OBJECT,

                    dm.getActionString(DependencyManager.DROP_COLUMN),

                    "THE *LAST* COLUMN " + columnInfo[ix].name,

                    "TABLE",

                    td.getQualifiedName() );

    }

    droppedColumnPosition = columnDescriptor.getPosition();

    boolean cascade = (behavior == StatementType.DROP_CASCADE);

    FormatableBitSet toDrop = new FormatableBitSet(size + 1);

    toDrop.set(droppedColumnPosition);

    td.setReferencedColumnMap(toDrop);

    dm.invalidateFor(td,

                        (cascade ? DependencyManager.DROP_COLUMN

                                 : DependencyManager.DROP_COLUMN_RESTRICT),

                        lcc);

         

    // If column has a default we drop the default and any dependencies

    if (columnDescriptor.getDefaultInfo() != null)

    {

      dm.clearDependencies(

                lcc, columnDescriptor.getDefaultDescriptor(dd));

    }

    // need to deal with triggers if has referencedColumns

    GenericDescriptorList tdl = dd.getTriggerDescriptors(td);

    Enumeration descs = tdl.elements();

    while (descs.hasMoreElements())

    {

      TriggerDescriptor trd = (TriggerDescriptor) descs.nextElement();

      int[] referencedCols = trd.getReferencedCols();

      if (referencedCols == null)

        continue;

      int refColLen = referencedCols.length, j;

      boolean changed = false;

      for (j = 0; j < refColLen; j++)

      {

        if (referencedCols[j] > droppedColumnPosition)

                {

          changed = true;

                }

        else if (referencedCols[j] == droppedColumnPosition)

        {

          if (cascade)

          {

                        trd.drop(lcc);

            activation.addWarning(

              StandardException.newWarning(

                                SQLState.LANG_TRIGGER_DROPPED,

                                trd.getName(), td.getName()));

          }

          else

          {  // we'd better give an error if don't drop it,

            // otherwsie there would be unexpected behaviors

            throw StandardException.newException(

                            SQLState.LANG_PROVIDER_HAS_DEPENDENT_OBJECT,

                            dm.getActionString(DependencyManager.DROP_COLUMN),

                            columnInfo[ix].name, "TRIGGER",

                            trd.getName() );

          }

          break;

        }

      }

      // change triggers to refer to columns in new positions

      if (j == refColLen && changed)

      {

        dd.dropTriggerDescriptor(trd, tc);

        for (j = 0; j < refColLen; j++)

        {

          if (referencedCols[j] > droppedColumnPosition)

            referencedCols[j]--;

        }

        dd.addDescriptor(trd, sd,

                 DataDictionary.SYSTRIGGERS_CATALOG_NUM,

                 false, tc);

      }

    }

    ConstraintDescriptorList csdl = dd.getConstraintDescriptors(td);

    int csdl_size = csdl.size();

    // we want to remove referenced primary/unique keys in the second

    // round.  This will ensure that self-referential constraints will

    // work OK.

    int tbr_size = 0;

    ConstraintDescriptor[] toBeRemoved =

            new ConstraintDescriptor[csdl_size];

    // let's go downwards, don't want to get messed up while removing

    for (int i = csdl_size - 1; i >= 0; i--)

    {

      ConstraintDescriptor cd = csdl.elementAt(i);

      int[] referencedColumns = cd.getReferencedColumns();

      int numRefCols = referencedColumns.length, j;

      boolean changed = false;

      for (j = 0; j < numRefCols; j++)

      {

        if (referencedColumns[j] > droppedColumnPosition)

          changed = true;

        if (referencedColumns[j] == droppedColumnPosition)

          break;

      }

      if (j == numRefCols)      // column not referenced

      {

        if ((cd instanceof CheckConstraintDescriptor) && changed)

        {

          dd.dropConstraintDescriptor(cd, tc);

          for (j = 0; j < numRefCols; j++)

          {

            if (referencedColumns[j] > droppedColumnPosition)

              referencedColumns[j]--;

          }

          ((CheckConstraintDescriptor) cd).setReferencedColumnsDescriptor(new ReferencedColumnsDescriptorImpl(referencedColumns));

          dd.addConstraintDescriptor(cd, tc);

        }

        continue;

      }

      if (! cascade)

      {

        // Reject the DROP COLUMN, because there exists a constraint

        // which references this column.

        //

        throw StandardException.newException(

                        SQLState.LANG_PROVIDER_HAS_DEPENDENT_OBJECT,

                        dm.getActionString(DependencyManager.DROP_COLUMN),

                        columnInfo[ix].name, "CONSTRAINT",

                        cd.getConstraintName() );

      }

      if (cd instanceof ReferencedKeyConstraintDescriptor)

      {

        // restrict will raise an error in invalidate if referenced

        toBeRemoved[tbr_size++] = cd;

        continue;

      }

      // drop now in all other cases

      dm.invalidateFor(cd, DependencyManager.DROP_CONSTRAINT,

                  lcc);

            cd.drop(lcc, true);

      activation.addWarning(

                StandardException.newWarning(SQLState.LANG_CONSTRAINT_DROPPED,

        cd.getConstraintName(), td.getName()));

    }

    for (int i = tbr_size - 1; i >= 0; i--)

    {

      ConstraintDescriptor cd = toBeRemoved[i];

      cd.drop(lcc, false);

      activation.addWarning(

                StandardException.newWarning(SQLState.LANG_CONSTRAINT_DROPPED,

                cd.getConstraintName(), td.getName()));

      if (cascade)

      {

        ConstraintDescriptorList fkcdl = dd.getForeignKeys(cd.getUUID());

        for (int j = 0; j < fkcdl.size(); j++)

        {

          ConstraintDescriptor fkcd =

                        (ConstraintDescriptor) fkcdl.elementAt(j);

          dm.invalidateFor(fkcd,

                  DependencyManager.DROP_CONSTRAINT,

                  lcc);

                    fkcd.drop(lcc, true);

          activation.addWarning(

                        StandardException.newWarning(

                            SQLState.LANG_CONSTRAINT_DROPPED,

                fkcd.getConstraintName(),

                            fkcd.getTableDescriptor().getName()));

        }

      }

      dm.invalidateFor(cd, DependencyManager.DROP_CONSTRAINT, lcc);

      dm.clearDependencies(lcc, cd);

    }

        /*

         * The work we've done above, specifically the possible

         * dropping of primary key, foreign key, and unique constraints

         * and their underlying indexes, may have affected the table

         * descriptor. By re-reading the table descriptor here, we

         * ensure that the compressTable code is working with an

         * accurate table descriptor. Without this line, we may get

         * conglomerate-not-found errors and the like due to our

         * stale table descriptor.

         */

    td = dd.getTableDescriptor(tableId);

    compressTable(activation);

    // drop the column from syscolumns

    dd.dropColumnDescriptor(td.getUUID(), columnInfo[ix].name, tc);

    ColumnDescriptor[] cdlArray =

            new ColumnDescriptor[size - columnDescriptor.getPosition()];

    // For each column in this table with a higher column position,

    // drop the entry from SYSCOLUMNS, but hold on to the column

    // descriptor and reset its position to adjust for the dropped

    // column. Then, re-add all those adjusted column descriptors

    // back to SYSCOLUMNS

    //

    for (int i = columnDescriptor.getPosition(), j = 0; i < size; i++, j++)

    {

      ColumnDescriptor cd = (ColumnDescriptor) tab_cdl.elementAt(i);

      dd.dropColumnDescriptor(td.getUUID(), cd.getColumnName(), tc);

      cd.setPosition(i);

      if (cd.isAutoincrement())

      {

        cd.setAutoinc_create_or_modify_Start_Increment(

            ColumnDefinitionNode.CREATE_AUTOINCREMENT);

      }

      cdlArray[j] = cd;

    }

    dd.addDescriptorArray(cdlArray, td,

                DataDictionary.SYSCOLUMNS_CATALOG_NUM, false, tc);

    List deps = dd.getProvidersDescriptorList(td.getObjectID().toString());

    for (Iterator depsIterator = deps.listIterator();

             depsIterator.hasNext();)

    {

      DependencyDescriptor depDesc =

                (DependencyDescriptor) depsIterator.next();