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

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


  {
    int size = columnNames.length;
    int columnPositions[] = new int[size];

     TableDescriptor td = dd.getTableDescriptor(constants.targetUUID);
    ColumnDescriptor cd;

    for (int i = 0; i < size; i++)
    {
      if (columnNames[i] == null)
      {
        throw StandardException.newException(
          SQLState.LANG_INVALID_AUTOGEN_COLUMN_NAME,
          columnNames[i], td.getName());
      }

      cd = td.getColumnDescriptor(columnNames[i]);
      if (!verifyAutoGenColumn(cd))
      {
        throw StandardException.newException(
          SQLState.LANG_INVALID_AUTOGEN_COLUMN_NAME,
          columnNames[i], td.getName());
      }

      columnPositions[i] = cd.getPosition();
    }
    activation.setAutoGeneratedKeysResultsetInfo(columnPositions, null);
  }
View Full Code Here


    setIdentity = (! autoincrementGenerated) && isSourceRowResultSet();
    autoincrementGenerated = true;

      if (bulkInsert)
      {
      ColumnDescriptor cd = td.getColumnDescriptor(columnPosition);
      long ret;

      // for bulk insert we have the table descriptor
      //      System.out.println("in bulk insert");
      if (aiCache[index].isNull())
      {
        if (bulkInsertReplace)
        {
          startValue = cd.getAutoincStart();
        }
        else
        {
          dvd = dd.getSetAutoincrementValue(
                constants.autoincRowLocation[index],
              tc, false, aiCache[index], true);
          startValue = dvd.getLong();
        }
        lcc.autoincrementCreateCounter(td.getSchemaName(),
                         td.getName(),
                         cd.getColumnName(),
                         new Long(startValue),
                         increment,
                         columnPosition);
     
      }     
      ret = lcc.nextAutoincrementValue(td.getSchemaName(),
                       td.getName(),
                       cd.getColumnName());
      aiCache[columnPosition - 1].setValue(ret);
   

    else
    {
View Full Code Here

                        int maxColumns = td.getMaxColumnID();
                        int col;
                       
                        for(col=1;col<=maxColumns;col++)
                        {
                            ColumnDescriptor cd = td.getColumnDescriptor(col);
                            if(cd.isAutoincrement())
                            {
                                break;
                            }
                        }
                       
View Full Code Here

    valueNode =  (ValueNode) nodeFactory.getNode(C_NodeTypes.UNTYPED_NULL_CONSTANT_NODE,
                               getContextManager());
    for(int index =0 ; index < cdl.size() ; index++)
    {
      ColumnDescriptor cd = (ColumnDescriptor) cdl.elementAt(index);
      //only columns that are nullable need to be set to 'null' for ON
      //DELETE SET NULL
      if((cd.getType()).isNullable())
      {
        resultColumn = (ResultColumn) nodeFactory.getNode(
                         C_NodeTypes.RESULT_COLUMN,
                    cd,
                    valueNode,
View Full Code Here

    valueNode =  (ValueNode) nodeFactory.getNode(C_NodeTypes.UNTYPED_NULL_CONSTANT_NODE,
                               getContextManager());
    for(int index =0 ; index < cdl.size() ; index++)
    {
      ColumnDescriptor cd = (ColumnDescriptor) cdl.elementAt(index);
      //only columns that are nullable need to be set to 'null' for ON
      //DELETE SET NULL
      if((cd.getType()).isNullable())
      {
        resultColumn = (ResultColumn) nodeFactory.getNode(
                         C_NodeTypes.RESULT_COLUMN,
                    cd,
                    valueNode,
View Full Code Here

    TableDescriptor td = dd.getTableDescriptor(constants.targetUUID);

    // all 1-based column ids.
    for (int i = 0; i < size; i++)
    {
      ColumnDescriptor cd = td.getColumnDescriptor(columnIndexes[i]);
      if (!verifyAutoGenColumn(cd))
      {
        throw StandardException.newException(
          SQLState.LANG_INVALID_AUTOGEN_COLUMN_POSITION,
          new Integer(columnIndexes[i]), td.getName());
View Full Code Here

   */
  private int[] generatedColumnPositionsArray()
    throws StandardException
  {
    TableDescriptor td = dd.getTableDescriptor(constants.targetUUID);
    ColumnDescriptor cd;
    int size = td.getMaxColumnID();

    int[] generatedColumnPositionsArray = new int[size];
    int generatedColumnNumbers = 0;
    for (int i=0; i<size; i++) {
      generatedColumnPositionsArray[i] = -1;
    }

    for (int i=0; i<size; i++) {
      cd = td.getColumnDescriptor(i+1);
      if (cd.isAutoincrement()) { //if the column has auto-increment value
        generatedColumnNumbers++;
        generatedColumnPositionsArray[i] = i+1;
      } else if (cd.getDefaultValue() != null || cd.getDefaultInfo() != null) {//default value
        generatedColumnNumbers++;
        generatedColumnPositionsArray[i] = i+1;
      }
    }
    int[] returnGeneratedColumnPositionsArray = new int[generatedColumnNumbers];
View Full Code Here

            throws StandardException
  {
    boolean            forCreateTable;
    TableDescriptor       td;
    UUID             toid;
    ColumnDescriptor      columnDescriptor;
    int[]            baseColumnPositions;
    IndexRowGenerator      indexRowGenerator = null;
    ExecRow[]          baseRows;
    ExecIndexRow[]        indexRows;
    ExecRow[]          compactBaseRows;
    GroupFetchScanController    scan;
    RowLocationRetRowSource      rowSource;
    long            sortId;
    int              maxBaseColumnPosition = -1;

    LanguageConnectionContext lcc = activation.getLanguageConnectionContext();
    DataDictionary dd = lcc.getDataDictionary();
    DependencyManager dm = dd.getDependencyManager();
    TransactionController tc = lcc.getTransactionExecute();

    /* Remember whether or not we are doing a create table */
    forCreateTable = activation.getForCreateTable();

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

    /*
    ** 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.
    */
    SchemaDescriptor sd = dd.getSchemaDescriptor(schemaName, tc, true) ;


    /* Get the table descriptor. */
    /* See if we can get the TableDescriptor
     * from the Activation.  (Will be there
     * for backing indexes.)
     */
    td = activation.getDDLTableDescriptor();

    if (td == null)
    {
      /* tableId will be non-null if adding an index to
       * an existing table (as opposed to creating a
       * table with a constraint with a backing index).
       */
      if (tableId != null)
      {
        td = dd.getTableDescriptor(tableId);
      }
      else
      {
        td = dd.getTableDescriptor(tableName, sd);
      }
    }

    if (td == null)
    {
      throw StandardException.newException(SQLState.LANG_CREATE_INDEX_NO_TABLE,
            indexName, tableName);
    }

    if (td.getTableType() == TableDescriptor.SYSTEM_TABLE_TYPE)
    {
      throw StandardException.newException(SQLState.LANG_CREATE_SYSTEM_INDEX_ATTEMPTED,
            indexName, tableName);
    }

    /* Get a shared table lock on the table. We need to lock table before
     * invalidate dependents, otherwise, we may interfere with the
     * compilation/re-compilation of DML/DDL.  See beetle 4325 and $WS/
     * docs/language/SolutionsToConcurrencyIssues.txt (point f).
     */
    lockTableForDDL(tc, td.getHeapConglomerateId(), false);

    // invalidate any prepared statements that
    // depended on this table (including this one)
    if (! forCreateTable)
    {
      dm.invalidateFor(td, DependencyManager.CREATE_INDEX, lcc);
    }

    // Translate the base column names to column positions
    baseColumnPositions = new int[columnNames.length];
    for (int i = 0; i < columnNames.length; i++)
    {
      // Look up the column in the data dictionary
      columnDescriptor = td.getColumnDescriptor(columnNames[i]);
      if (columnDescriptor == null)
      {
        throw StandardException.newException(SQLState.LANG_COLUMN_NOT_FOUND_IN_TABLE,
                              columnNames[i],
                              tableName);
      }

      TypeId typeId = columnDescriptor.getType().getTypeId();

      // Don't allow a column to be created on a non-orderable type
      ClassFactory cf = lcc.getLanguageConnectionFactory().getClassFactory();
      boolean isIndexable = typeId.orderable(cf);

      if (isIndexable && typeId.userType()) {
        String userClass = typeId.getCorrespondingJavaTypeName();

        // Don't allow indexes to be created on classes that
        // are loaded from the database. This is because recovery
        // won't be able to see the class and it will need it to
        // run the compare method.
        try {
          if (cf.isApplicationClass(cf.loadApplicationClass(userClass)))
            isIndexable = false;
        } catch (ClassNotFoundException cnfe) {
          // shouldn't happen as we just check the class is orderable
          isIndexable = false;
        }
      }

      if (!isIndexable) {
        throw StandardException.newException(SQLState.LANG_COLUMN_NOT_ORDERABLE_DURING_EXECUTION,
          typeId.getSQLTypeName());
      }

      // Remember the position in the base table of each column
      baseColumnPositions[i] = columnDescriptor.getPosition();

      if (maxBaseColumnPosition < baseColumnPositions[i])
        maxBaseColumnPosition = baseColumnPositions[i];
    }

    // check if we have similar indices already for this table
    ConglomerateDescriptor[] congDescs = td.getConglomerateDescriptors();
    boolean duplicate = false;
        long conglomId = 0;

    for (int i = 0; i < congDescs.length; i++)
    {
      ConglomerateDescriptor cd = congDescs[i];
      if ( ! cd.isIndex())
        continue;
      IndexRowGenerator irg = cd.getIndexDescriptor();
      int[] bcps = irg.baseColumnPositions();
      boolean[] ia = irg.isAscending();
      int j = 0;

      /* For an index to be considered a duplicate of already existing index, the
       * following conditions have to be satisfied:
       * 1. the set of columns (both key and include columns) and their
       *  order in the index is the same as that of an existing index AND
       * 2. the ordering attributes are the same AND
       * 3. both the previously existing index and the one being created
       *  are non-unique OR the previously existing index is unique
       */

      if ((bcps.length == baseColumnPositions.length) &&
          (irg.isUnique() || !unique) &&
        indexType.equals(irg.indexType()))
      {
        for (; j < bcps.length; j++)
        {
          if ((bcps[j] != baseColumnPositions[j]) || (ia[j] != isAscending[j]))
            break;
        }
      }

      if (j == baseColumnPositions.length// duplicate
      {
        /*
         * Don't allow users to create a duplicate index. Allow if being done internally
         * for a constraint
         */
        if (!isConstraint)
        {
          activation.addWarning(
              StandardException.newWarning(
                SQLState.LANG_INDEX_DUPLICATE,
                cd.getConglomerateName()));

          return;
        }

        //Duplicate indexes share the physical conglomerate underneath
        conglomId = cd.getConglomerateNumber();
        indexRowGenerator = cd.getIndexDescriptor();
        //DERBY-655 and DERBY-1343 
        //Duplicate indexes will have unqiue logical conglomerate UUIDs. 
        conglomerateUUID = dd.getUUIDFactory().createUUID();
        duplicate = true;
        break;
      }
    }

    /* If this index already has an essentially same one, we share the
     * conglomerate with the old one, and just simply add a descriptor
     * entry into SYSCONGLOMERATES.
     */
    DataDescriptorGenerator ddg = dd.getDataDescriptorGenerator();
    if (duplicate)
    {
      ConglomerateDescriptor cgd =
        ddg.newConglomerateDescriptor(conglomId, indexName, true,
                      indexRowGenerator, isConstraint,
                      conglomerateUUID, td.getUUID(), sd.getUUID() );
      dd.addDescriptor(cgd, sd, DataDictionary.SYSCONGLOMERATES_CATALOG_NUM, false, tc);
      // add newly added conglomerate to the list of conglomerate
      // descriptors in the td.
      ConglomerateDescriptorList cdl =
        td.getConglomerateDescriptorList();
      cdl.add(cgd);

      // can't just return yet, need to get member "indexTemplateRow"
      // because create constraint may use it
    }

    // Describe the properties of the index to the store using Properties
    // RESOLVE: The following properties assume a BTREE index.
    Properties  indexProperties;
   
    if (properties != null)
    {
      indexProperties = properties;
    }
    else
    {
      indexProperties = new Properties();
    }

    // Tell it the conglomerate id of the base table
    indexProperties.put("baseConglomerateId",
              Long.toString(td.getHeapConglomerateId()));

    // All indexes are unique because they contain the RowLocation.
    // The number of uniqueness columns must include the RowLocation
    // if the user did not specify a unique index.
    indexProperties.put("nUniqueColumns",
          Integer.toString(unique ? baseColumnPositions.length :
                        baseColumnPositions.length + 1)
              );

    // By convention, the row location column is the last column
    indexProperties.put("rowLocationColumn",
              Integer.toString(baseColumnPositions.length));

    // For now, all columns are key fields, including the RowLocation
    indexProperties.put("nKeyFields",
              Integer.toString(baseColumnPositions.length + 1));

    // For now, assume that all index columns are ordered columns
    if (! duplicate)
    {
      indexRowGenerator = new IndexRowGenerator(indexType, unique,
                          baseColumnPositions,
                          isAscending,
                          baseColumnPositions.length);
    }

    /* Now add the rows from the base table to the conglomerate.
     * We do this by scanning the base table and inserting the
     * rows into a sorter before inserting from the sorter
     * into the index.  This gives us better performance
     * and a more compact index.
     */

    rowSource = null;
    sortId = 0;
    boolean needToDropSort = false// set to true once the sorter is created

    /* bulkFetchSIze will be 16 (for now) unless
     * we are creating the table in which case it
     * will be 1.  Too hard to remove scan when
     * creating index on new table, so minimize
     * work where we can.
     */
    int bulkFetchSize = (forCreateTable) ? 1 : 16
    int numColumns = td.getNumberOfColumns();
    int approximateRowSize = 0;

    // Create the FormatableBitSet for mapping the partial to full base row
    FormatableBitSet bitSet = new FormatableBitSet(numColumns+1);
    for (int index = 0; index < baseColumnPositions.length; index++)
    {
      bitSet.set(baseColumnPositions[index]);
    }
    FormatableBitSet zeroBasedBitSet = RowUtil.shift(bitSet, 1);

    // Start by opening a full scan on the base table.
    scan = tc.openGroupFetchScan(
                            td.getHeapConglomerateId(),
              false,  // hold
              0// open base table read only
                            TransactionController.MODE_TABLE,
                            TransactionController.ISOLATION_SERIALIZABLE,
              zeroBasedBitSet,    // all fields as objects
              (DataValueDescriptor[]) null,  // startKeyValue
              0,    // not used when giving null start posn.
              null,  // qualifier
              (DataValueDescriptor[]) null,  // stopKeyValue
              0);    // not used when giving null stop posn.

    // Create an array to put base row template
    baseRows = new ExecRow[bulkFetchSize];
    indexRows = new ExecIndexRow[bulkFetchSize];
    compactBaseRows = new ExecRow[bulkFetchSize];

    try
    {
      // Create the array of base row template
      for (int i = 0; i < bulkFetchSize; i++)
      {
        // create a base row template
        baseRows[i] = activation.getExecutionFactory().getValueRow(maxBaseColumnPosition);

        // create an index row template
        indexRows[i] = indexRowGenerator.getIndexRowTemplate();

        // create a compact base row template
        compactBaseRows[i] = activation.getExecutionFactory().getValueRow(
                          baseColumnPositions.length);
      }

      indexTemplateRow = indexRows[0];

      // Fill the partial row with nulls of the correct type
      ColumnDescriptorList cdl = td.getColumnDescriptorList();
      int           cdlSize = cdl.size();
      for (int index = 0, numSet = 0; index < cdlSize; index++)
      {
        if (! zeroBasedBitSet.get(index))
        {
          continue;
        }
        numSet++;
        ColumnDescriptor cd = (ColumnDescriptor) cdl.elementAt(index);
        DataTypeDescriptor dts = cd.getType();


        for (int i = 0; i < bulkFetchSize; i++)
        {
          // Put the column in both the compact and sparse base rows
          baseRows[i].setColumn(index + 1,
                  dts.getNull());
          compactBaseRows[i].setColumn(numSet,
                  baseRows[i].getColumn(index + 1));
        }

        // Calculate the approximate row size for the index row
        approximateRowSize += dts.getTypeId().getApproximateLengthInBytes(dts);
      }

      // Get an array of RowLocation template
      RowLocation rl[] = new RowLocation[bulkFetchSize];
      for (int i = 0; i < bulkFetchSize; i++)
      {
        rl[i] = scan.newRowLocationTemplate();

        // Get an index row based on the base row
        indexRowGenerator.getIndexRow(compactBaseRows[i], rl[i], indexRows[i], bitSet);
      }

      /* now that we got indexTemplateRow, done for duplicate index
       */
      if (duplicate)
        return;

      /* For non-unique indexes, we order by all columns + the RID.
       * For unique indexes, we just order by the columns.
       * We create a unique index observer for unique indexes
       * so that we can catch duplicate key.
       * We create a basic sort observer for non-unique indexes
       * so that we can reuse the wrappers during an external
       * sort.
       */
      int numColumnOrderings;
      SortObserver sortObserver = null;
      if (unique)
      {
        numColumnOrderings = baseColumnPositions.length;
        // if the index is a constraint, use constraintname in possible error messagge
        String indexOrConstraintName = indexName;
        if  (conglomerateUUID != null)
        {
          ConglomerateDescriptor cd = dd.getConglomerateDescriptor(conglomerateUUID);
          if ((isConstraint) && (cd != null && cd.getUUID() != null && td != null))
          {
            ConstraintDescriptor conDesc = dd.getConstraintDescriptor(td,
                                                                      cd.getUUID());
            indexOrConstraintName = conDesc.getConstraintName();
          }
        }
        sortObserver = new UniqueIndexSortObserver(true, isConstraint,
                               indexOrConstraintName,
View Full Code Here

  private void execGutsRenameColumn
  (
           TableDescriptor td, Activation activation)
    throws StandardException
  {
    ColumnDescriptor columnDescriptor = null;
    int columnPosition = 0;
    ConstraintDescriptorList constraintDescriptorList;
    ConstraintDescriptor constraintDescriptor;
    LanguageConnectionContext lcc = activation.getLanguageConnectionContext();
    DataDictionary dd = lcc.getDataDictionary();
    DependencyManager dm = dd.getDependencyManager();
    TransactionController tc = lcc.getTransactionExecute();

    /* get the column descriptor for column to be renamed and
     * using it's position in the table, set the referenced
     * column map of the table indicating which column is being
     * renamed. Dependency Manager uses this to find out the
     * dependents on the column.
     */
    columnDescriptor = td.getColumnDescriptor(oldObjectName);
    columnPosition = columnDescriptor.getPosition();
    FormatableBitSet toRename = new FormatableBitSet(td.getColumnDescriptorList().size() + 1);
    toRename.set(columnPosition);
    td.setReferencedColumnMap(toRename);
   
    dm.invalidateFor(td, DependencyManager.RENAME, lcc);

    //look for foreign key dependency on the column.
    constraintDescriptorList = dd.getConstraintDescriptors(td);
    for(int index=0; index<constraintDescriptorList.size(); index++)
    {
      constraintDescriptor = constraintDescriptorList.elementAt(index);
      int[] referencedColumns = constraintDescriptor.getReferencedColumns();
      int numRefCols = referencedColumns.length;
      for (int j = 0; j < numRefCols; j++)
      {
        if ((referencedColumns[j] == columnPosition) &&
          (constraintDescriptor instanceof ReferencedKeyConstraintDescriptor))
          dm.invalidateFor(constraintDescriptor, DependencyManager.RENAME, lcc);
      }
    }

    // Drop the column
    dd.dropColumnDescriptor(td.getUUID(), oldObjectName, tc);
    columnDescriptor.setColumnName(newObjectName);
    dd.addDescriptor(columnDescriptor, td,
             DataDictionary.SYSCOLUMNS_CATALOG_NUM, false, tc);

    //Need to do following to reload the cache so that table
    //descriptor now has new column name
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);

      // If column has a default we drop the default and
      // any dependencies
      if (cd.getDefaultInfo() != null)
      {
        DefaultDescriptor defaultDesc = cd.getDefaultDescriptor(dd);
        dm.clearDependencies(lcc, defaultDesc);
      }
    }

    /* Drop the columns */
    dd.dropAllColumnDescriptors(tableId, tc);

    /* Drop all table and column permission descriptors */
    dd.dropAllTableAndColPermDescriptors(tableId, tc);

    /* Drop the constraints */
    dropAllConstraintDescriptors(td, activation);

    /*
    ** Drop all the conglomerates.  Drop the heap last, because the
    ** store needs it for locking the indexes when they are dropped.
    */
    cds = td.getConglomerateDescriptors();

    long[] dropped = new long[cds.length - 1];
    int numDropped = 0;
    for (int index = 0; index < cds.length; index++)
    {
      ConglomerateDescriptor cd = cds[index];

      /* if it's for an index, since similar indexes share one
       * conglomerate, we only drop the conglomerate once
       */
      if (cd.getConglomerateNumber() != heapId)
      {
        long thisConglom = cd.getConglomerateNumber();

        int i;
        for (i = 0; i < numDropped; i++)
        {
          if (dropped[i] == thisConglom)
            break;
        }
        if (i == numDropped// not dropped
        {
          dropped[numDropped++] = thisConglom;
          tc.dropConglomerate(thisConglom);
          dd.dropStatisticsDescriptors(td.getUUID(), cd.getUUID(), tc);
        }
      }
    }

    /* Prepare all dependents to invalidate.  (This is there chance
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.