Package org.apache.derby.iapi.sql.dictionary

Examples of org.apache.derby.iapi.sql.dictionary.ColumnDescriptor


            oldReferencingName,
            newReferencingName,
            triggerEventMask);
        String colName = ref.getColumnName();

        ColumnDescriptor triggerColDesc;
        //Following will catch the case where an invalid column is
        //used in trigger action through the REFERENCING clause. The
        //following tigger is trying to use oldt.c13 but there is no
        //column c13 in trigger table table1
        //CREATE TRIGGER tr1 AFTER UPDATE OF c12 ON table1
        //    REFERENCING OLD AS oldt NEW AS newt
        //    FOR EACH ROW UPDATE table2 SET c24=oldt.c14567;
        if ((triggerColDesc = triggerTableDescriptor.getColumnDescriptor(colName)) ==
                  null) {
          throw StandardException.newException(
                      SQLState.LANG_COLUMN_NOT_FOUND, tableName+"."+colName);
          }

        if (in10_7_orHigherVersion) {
          int triggerColDescPosition = triggerColDesc.getPosition();
          triggerColsAndTriggerActionCols[triggerColDescPosition-1]=triggerColDescPosition;
          triggerActionColsOnly[triggerColDescPosition-1]=triggerColDescPosition;
          referencedColsInTriggerAction[triggerColDescPosition-1] = triggerColDescPosition;
        }
      }
    } else {
      //We are here because we have come across an invalidated trigger
      //which is being fired. This code gets called for such a trigger
      //only if it is a row level trigger with REFERENCEs clause
      //
      // referencedColsInTriggerAction can be null if trigger action
      // does not use any columns through REFERENCING clause. This can
      // happen when we are coming here through ALTER TABLE DROP COLUMN
      // and the trigger being rebuilt does not use any columns through
      // REFERENCING clause. DERBY-4887
      if (referencedCols != null && referencedColsInTriggerAction != null){
        for (int i = 0; i < referencedColsInTriggerAction.length; i++)
        {
          triggerColsAndTriggerActionCols[referencedColsInTriggerAction[i]-1] = referencedColsInTriggerAction[i];
        }
      }
    }
         
    //Now that we know what columns we need for trigger columns and
    //trigger action columns, we can get rid of remaining -1 entries
    //for the remaining columns from trigger table.
    //eg
    //CREATE TRIGGER tr1 AFTER UPDATE OF c12 ON table1
    //    REFERENCING OLD AS oldt NEW AS newt
    //    FOR EACH ROW UPDATE table2 SET c24=oldt.c14;
    //For the above trigger, before the justTheRequiredColumns() call,
    //the content of triggerColsAndTriggerActionCols array were as
    //follows [-1, 2, -1, 4, -1]
    //After the justTheRequiredColumns() call below,
    //triggerColsAndTriggerActionCols will have [2,4]. What this means
    //that, at run time, during trigger execution, these are the only
    //2 column positions that will be read into memory from the
    //trigger table. The columns in other column positions are not
    //needed for trigger execution.
    triggerColsAndTriggerActionCols = justTheRequiredColumns(
        triggerColsAndTriggerActionCols, triggerTableDescriptor);

    //This is where we do the actual transformation of trigger action
    //sql. An eg of that is
    //  DELETE FROM t WHERE c = old.c
    // turns into
    //  DELETE FROM t WHERE c = org.apache.derby.iapi.db.Factory::
    //    getTriggerExecutionContext().getOldRow().
    //    getInt(columnNumberFor'C'inRuntimeResultset)
    // or
    //  DELETE FROM t WHERE c in (SELECT c FROM OLD)
    // turns into
    //  DELETE FROM t WHERE c in
    //    (SELECT c FROM new TriggerOldTransitionTable OLD)
    for (int i = 0; i < cols.length; i++)
    {
      ColumnReference ref = (ColumnReference) cols[i];       
      /*
      ** Only occurrences of those OLD/NEW transition tables/variables
      ** are of interest here.  There may be intermediate nodes in the
      ** parse tree that have its own RCL which contains copy of
      ** column references(CR) from other nodes. e.g.: 
      **
      ** CREATE TRIGGER tt
      ** AFTER INSERT ON x
      ** REFERENCING NEW AS n
      ** FOR EACH ROW
      **    INSERT INTO y VALUES (n.i), (999), (333);
      **
      ** The above trigger action will result in InsertNode that
      ** contains a UnionNode of RowResultSetNodes.  The UnionNode
      ** will have a copy of the CRs from its left child and those CRs
      ** will not have its beginOffset set which indicates they are
      ** not relevant for the conversion processing here, so we can
      ** safely skip them.
      */
      if (ref.getBeginOffset() == -1)
      {
        continue;
      }
     
      TableName tableName = ref.getTableNameNode();
      if ((tableName == null) ||
        ((oldReferencingName == null || !oldReferencingName.equals(tableName.getTableName())) &&
        (newReferencingName == null || !newReferencingName.equals(tableName.getTableName()))))
      {
        continue;
      }
       
      int tokBeginOffset = tableName.getBeginOffset();
      int tokEndOffset = tableName.getEndOffset();
      if (tokBeginOffset == -1)
      {
        continue;
      }

      String colName = ref.getColumnName();
      int columnLength = ref.getEndOffset() - ref.getBeginOffset() + 1;

      newText.append(triggerDefinition.substring(start, tokBeginOffset-actionOffset));
      int colPositionInRuntimeResultSet = -1;
      ColumnDescriptor triggerColDesc = triggerTableDescriptor.getColumnDescriptor(colName);
      //DERBY-5121 We can come here if the column being used in trigger
      // action is getting dropped and we have come here through that
      // ALTER TABLE DROP COLUMN. In that case, we will not find the
      // column in the trigger table.
      if (triggerColDesc == null) {
        throw StandardException.newException(
                    SQLState.LANG_COLUMN_NOT_FOUND, tableName+"."+colName);
      }
      int colPositionInTriggerTable = triggerColDesc.getPosition();

      //This part of code is little tricky and following will help
      //understand what mapping is happening here.
      //eg
      //CREATE TRIGGER tr1 AFTER UPDATE OF c12 ON table1
View Full Code Here


      ColumnDescriptorList cdl = td.getColumnDescriptorList();
      int           cdlSize = cdl.size();

      for (int index = 0; index < cdlSize; index++)
      {
        ColumnDescriptor cd = (ColumnDescriptor) cdl.elementAt(index);
        baseRow.setColumn(cd.getPosition(), cd.getType().getNull());
      }

            DataValueDescriptor[][] row_array = new DataValueDescriptor[100][];
            row_array[0] = baseRow.getRowArray();
            RowLocation[] old_row_location_array = new RowLocation[100];
View Full Code Here

   * @exception StandardException   thrown on failure.
   */
    private void addNewColumnToTable(int ix)
          throws StandardException
  {
    ColumnDescriptor columnDescriptor   =
      td.getColumnDescriptor(columnInfo[ix].name);
    DataValueDescriptor storableDV;
    int                     colNumber   = td.getMaxColumnID() + ix;

    /* 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(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(columnDescriptor);
   

        //
View Full Code Here

        ColumnDescriptorList    generatedColumnList = td.getGeneratedColumns();
        int                                 generatedColumnCount = generatedColumnList.size();
        ArrayList                   cascadedDroppedColumns = new ArrayList();
        for ( int i = 0; i < generatedColumnCount; i++ )
        {
            ColumnDescriptor    generatedColumn = generatedColumnList.elementAt( i );
            String[]                       referencedColumnNames = generatedColumn.getDefaultInfo().getReferencedColumnNames();
            int                         referencedColumnCount = referencedColumnNames.length;
            for ( int j = 0; j < referencedColumnCount; j++ )
            {
                if ( columnName.equals( referencedColumnNames[ j ] ) )
                {
                    String      generatedColumnName = generatedColumn.getColumnName();
                   
                    // ok, the current generated column references the column
                    // we're trying to drop
                    if (! cascade)
                    {
                        // Reject the DROP COLUMN, because there exists a
                        // generated column which references this column.
                        //
                        throw StandardException.newException
                            (
                             SQLState.LANG_PROVIDER_HAS_DEPENDENT_OBJECT,
                             dm.getActionString(DependencyManager.DROP_COLUMN),
                             columnName, "GENERATED COLUMN",
                             generatedColumnName
                             );
                    }
                    else
                    {
                        cascadedDroppedColumns.add( generatedColumnName );
                    }
                }
            }
        }

    DataDescriptorGenerator ddg = dd.getDataDescriptorGenerator();
        int                             cascadedDrops = cascadedDroppedColumns.size();
    int sizeAfterCascadedDrops = td.getColumnDescriptorList().size() - cascadedDrops;

    // can NOT drop a column if it is the only one in the table
    if (sizeAfterCascadedDrops == 1)
    {
      throw StandardException.newException(
                    SQLState.LANG_PROVIDER_HAS_DEPENDENT_OBJECT,
                    dm.getActionString(DependencyManager.DROP_COLUMN),
                    "THE *LAST* COLUMN " + columnName,
                    "TABLE",
                    td.getQualifiedName() );
    }

        // now drop dependent generated columns
        for ( int i = 0; i < cascadedDrops; i++ )
        {
            String      generatedColumnName = (String) cascadedDroppedColumns.get( i );
           
            activation.addWarning
                ( StandardException.newWarning( SQLState.LANG_GEN_COL_DROPPED, generatedColumnName, td.getName() ) );

            //
            // We can only recurse 2 levels since a generation clause cannot
            // refer to other generated columns.
            //
            dropColumnFromTable(generatedColumnName);
        }

        /*
         * Cascaded drops of dependent generated columns may require us to
         * rebuild the table descriptor.
         */
    td = dd.getTableDescriptor(tableId);

    ColumnDescriptor columnDescriptor = td.getColumnDescriptor( columnName );

    // We already verified this in bind, but do it again
    if (columnDescriptor == null)
    {
      throw
        StandardException.newException(
                    SQLState.LANG_COLUMN_NOT_FOUND_IN_TABLE,
                    columnName,
                    td.getQualifiedName());
    }

    int size = td.getColumnDescriptorList().size();
    droppedColumnPosition = columnDescriptor.getPosition();

    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));
    }

    //Now go through each trigger on this table and see if the column
    //being dropped is part of it's trigger columns or trigger action
    //columns which are used through REFERENCING clause
    GenericDescriptorList tdl = dd.getTriggerDescriptors(td);
    Enumeration descs = tdl.elements();
    while (descs.hasMoreElements())
    {
      TriggerDescriptor trd = (TriggerDescriptor) descs.nextElement();
      //If we find that the trigger is dependent on the column being
      //dropped because column is part of trigger columns list, then
      //we will give a warning or drop the trigger based on whether
      //ALTER TABLE DROP COLUMN is RESTRICT or CASCADE. In such a
      //case, no need to check if the trigger action columns referenced
      //through REFERENCING clause also used the column being dropped.
      boolean triggerDroppedAlready = false;

      int[] referencedCols = trd.getReferencedCols();
      if (referencedCols != null) {
        int refColLen = referencedCols.length, j;
        boolean changed = false;
        for (j = 0; j < refColLen; j++)
        {
          if (referencedCols[j] > droppedColumnPosition)
                  {
            //Trigger is not defined on the column being dropped
            //but the column position of trigger column is changing
            //because the position of the column being dropped is
            //before the the trigger column
            changed = true;
                  }
          else if (referencedCols[j] == droppedColumnPosition)
          {
            //the trigger is defined on the column being dropped
            if (cascade)
            {
                          trd.drop(lcc);
                          triggerDroppedAlready = true;
              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),
                              columnName, "TRIGGER",
                              trd.getName() );
            }
            break;
          }
        }

        // The following if condition will be true if the column
        // getting dropped is not a trigger column, but one or more
        // of the trigge column's position has changed because of
        // drop column.
        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);
        }
      }

      // If the trigger under consideration got dropped through the
      // loop above, then move to next trigger
      if (triggerDroppedAlready) continue;
     
      // Column being dropped is not one of trigger columns. Check if
      // that column is getting used inside the trigger action through
      // REFERENCING clause. This can be tracked only for triggers
      // created in 10.7 and higher releases. Derby releases prior to
      // that did not keep track of trigger action columns used
      // through the REFERENCING clause.
      int[] referencedColsInTriggerAction = trd.getReferencedColsInTriggerAction();
      if (referencedColsInTriggerAction != null) {
        int refColInTriggerActionLen = referencedColsInTriggerAction.length, j;
        boolean changedColPositionInTriggerAction = false;
        for (j = 0; j < refColInTriggerActionLen; j++)
        {
          if (referencedColsInTriggerAction[j] > droppedColumnPosition)
          {
            changedColPositionInTriggerAction = true;
          }
          else if (referencedColsInTriggerAction[j] == droppedColumnPosition)
          {
            if (cascade)
            {
                          trd.drop(lcc);
                          triggerDroppedAlready = true;
              activation.addWarning(
                StandardException.newWarning(
                                  SQLState.LANG_TRIGGER_DROPPED,
                                  trd.getName(), td.getName()));
            }
            else
            // we'd better give an error if don't drop it,
              throw StandardException.newException(
                              SQLState.LANG_PROVIDER_HAS_DEPENDENT_OBJECT,
                              dm.getActionString(DependencyManager.DROP_COLUMN),
                              columnName, "TRIGGER",
                              trd.getName() );
            }
            break;
          }
        }

        // change trigger to refer to columns in new positions
        // The following if condition will be true if the column
        // getting dropped is not getting used in the trigger action
        // sql through the REFERENCING clause but one or more of those
        // column's position has changed because of drop column.
        // This applies only to triggers created with 10.7 and higher.
        // Prior to that, Derby did not keep track of the trigger
        // action column used through the REFERENCING clause. Such
        // triggers will be caught later on in this method after the
        // column has been actually dropped from the table descriptor.
        if (j == refColInTriggerActionLen && changedColPositionInTriggerAction)
        {
          dd.dropTriggerDescriptor(trd, tc);
          for (j = 0; j < refColInTriggerActionLen; j++)
          {
            if (referencedColsInTriggerAction[j] > droppedColumnPosition)
              referencedColsInTriggerAction[j]--;
          }
          dd.addDescriptor(trd, sd,
               DataDictionary.SYSTRIGGERS_CATALOG_NUM,
               false, tc);
        }
      }
    }

    ConstraintDescriptorList csdl = dd.getConstraintDescriptors(td);
    int csdl_size = csdl.size();

    ArrayList newCongloms = new ArrayList();

    // 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),
                        columnName, "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);

      dropConstraint(cd, td, newCongloms, activation, 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];
      dropConstraint(cd, td, newCongloms, activation, 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);

          dropConstraint(fkcd, td,
            newCongloms, activation, 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);
    }

    /* If there are new backing conglomerates which must be
     * created to replace a dropped shared conglomerate
     * (where the shared conglomerate was dropped as part
     * of a "drop constraint" call above), then create them
     * now.  We do this *after* dropping all dependent
     * constraints because we don't want to waste time
     * creating a new conglomerate if it's just going to be
     * dropped again as part of another "drop constraint".
     */
    createNewBackingCongloms(newCongloms, (long[])null);

        /*
         * 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();

    ColumnDescriptorList tab_cdl = td.getColumnDescriptorList();

    // drop the column from syscolumns
    dd.dropColumnDescriptor(td.getUUID(), columnName, 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;
    }
View Full Code Here

   
  }

    private void modifyColumnType(int ix)
            throws StandardException {
    ColumnDescriptor columnDescriptor =
      td.getColumnDescriptor(columnInfo[ix].name),
      newColumnDescriptor = null;

    newColumnDescriptor =
      new ColumnDescriptor(columnInfo[ix].name,
                  columnDescriptor.getPosition(),
                  columnInfo[ix].dataType,
                  columnDescriptor.getDefaultValue(),
                  columnDescriptor.getDefaultInfo(),
                  td,
                  columnDescriptor.getDefaultUUID(),
                    columnInfo[ix].autoincStart,
                    columnInfo[ix].autoincInc
                  );
   
View Full Code Here

   * Right now it is restricted to modifying a null constraint to a not null
   * constraint.
   */
    private void modifyColumnConstraint(String colName, boolean nullability)
            throws StandardException {
    ColumnDescriptor columnDescriptor =
      td.getColumnDescriptor(colName),
      newColumnDescriptor = null;
       
        // Get the type and change the nullability
    DataTypeDescriptor dataType =
            columnDescriptor.getType().getNullabilityType(nullability);

        //check if there are any unique constraints to update
        ConstraintDescriptorList cdl = dd.getConstraintDescriptors(td);
        int columnPostion = columnDescriptor.getPosition();
        for (int i = 0; i < cdl.size(); i++)
        {
            ConstraintDescriptor cd = cdl.elementAt(i);
            if (cd.getConstraintType() == DataDictionary.UNIQUE_CONSTRAINT)
            {
                ColumnDescriptorList columns = cd.getColumnDescriptors();
                for (int count = 0; count < columns.size(); count++)
                {
                    if (columns.elementAt(count).getPosition() != columnPostion)
                        break;

                    //get backing index
                    ConglomerateDescriptor desc =
                        td.getConglomerateDescriptor(cd.getConglomerateId());

                    //check if the backing index was created when the column
                    //not null ie is backed by unique index
                    if (!desc.getIndexDescriptor().isUnique())
                        break;

                    // replace backing index with a unique when not null index.
                    recreateUniqueConstraintBackingIndexAsUniqueWhenNotNull(
                        desc, td, activation, lcc);
                }
            }
        }

    newColumnDescriptor =
       new ColumnDescriptor(colName,
                  columnDescriptor.getPosition(),
                  dataType,
                  columnDescriptor.getDefaultValue(),
                  columnDescriptor.getDefaultInfo(),
                  td,
                  columnDescriptor.getDefaultUUID(),
                  columnDescriptor.getAutoincStart(),
                  columnDescriptor.getAutoincInc());
       
    // Update the ColumnDescriptor with new default info
    dd.dropColumnDescriptor(td.getUUID(), colName, tc);
    dd.addDescriptor(newColumnDescriptor, td,
             DataDictionary.SYSCOLUMNS_CATALOG_NUM, false, tc);   
View Full Code Here

      String      tabName,
      boolean      isOldTable,
      int        colPositionInRuntimeResultSet
      ) throws StandardException
  {
    ColumnDescriptor colDesc = null;
    if ((colDesc = td.getColumnDescriptor(colName)) ==
              null)
    {
      throw StandardException.newException(
              SQLState.LANG_COLUMN_NOT_FOUND, tabName+"."+colName);
    }

    /*
    ** Generate something like this:
    **
    **     CAST (org.apache.derby.iapi.db.Factory::
    **      getTriggerExecutionContext().getNewRow().
    **        getObject(<colPosition>) AS DECIMAL(6,2))
      **
      ** Column position is used to avoid the wrong column being
      ** selected problem (DERBY-1258) caused by the case insensitive
      ** JDBC rules for fetching a column by name.
    **
    ** The cast back to the SQL Domain may seem redundant
    ** but we need it to make the column reference appear
    ** EXACTLY like a regular column reference, so we need
    ** the object in the SQL Domain and we need to have the
    ** type information.  Thus a user should be able to do
    ** something like
    **
    **    CREATE TRIGGER ... INSERT INTO T length(Column), ...
      **
      */

    DataTypeDescriptor  dts     = colDesc.getType();
    TypeId              typeId  = dts.getTypeId();

      if (!typeId.isXMLTypeId())
      {

View Full Code Here

    SchemaDescriptor  sd = getSystemSchemaDescriptor();

    TableDescriptor td = getTableDescriptor(rowFactory.getCatalogName(), sd, tc);

    theColumn = columns[columnNumber - 1]// from 1 to 0 based
    ColumnDescriptor cd = makeColumnDescriptor(theColumn, columnNumber, td );
    String columnName = cd.getColumnName();
    int[] columnNameColArray = new int[1];
    columnNameColArray[0] = SYSCOLUMNSRowFactory.SYSCOLUMNS_COLUMNDATATYPE ;
    updateColumnDescriptor(cd,
                td.getUUID(),
                columnName,
View Full Code Here

                    TransactionController  tc )
          throws StandardException
  {
    int          columnID;
    SystemColumn    currentColumn;
    ColumnDescriptor  cd;

    SystemColumn[]    columns = rowFactory.buildColumnList();
    ExecRow        templateRow = rowFactory.makeEmptyRow();
    int          columnCount = newColumnIDs.length;
    SchemaDescriptor  sd = getSystemSchemaDescriptor();
View Full Code Here

    size = td.getNumberOfColumns();
    RowLocation[] rla = new RowLocation[size];

    for (int i = 0; i < size; i++)
    {
      ColumnDescriptor cd = td.getColumnDescriptor(i + 1);
      if (cd.isAutoincrement())
        rla[i] = computeRowLocation(tc, td, cd.getColumnName());
    }
    return rla;
  }
View Full Code Here

TOP

Related Classes of org.apache.derby.iapi.sql.dictionary.ColumnDescriptor

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.