Examples with ColumnDescriptor org.apache.derby.iapi.sql.dictionary.ColumnDescriptor used on opensource projects

Example 26 with ColumnDescriptor

use of org.apache.derby.iapi.sql.dictionary.ColumnDescriptor in project derby by apache.

the class CreateConstraintConstantAction method genColumnPositions.

/**
 * Generate an array of column positions for the column list in
 * the constraint.
 *
 * @param td	The TableDescriptor for the table in question
 * @param columnsMustBeOrderable	true for primaryKey and unique constraints
 *
 * @return int[]	The column positions.
 */
private int[] genColumnPositions(TableDescriptor td, boolean columnsMustBeOrderable) throws StandardException {
    int[] baseColumnPositions;
    // Translate the base column names to column positions
    baseColumnPositions = new int[columnNames.length];
    for (int i = 0; i < columnNames.length; i++) {
        ColumnDescriptor columnDescriptor;
        // 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);
        }
        // (for primaryKey and unique constraints)
        if (columnsMustBeOrderable && (!columnDescriptor.getType().getTypeId().orderable(cf))) {
            throw StandardException.newException(SQLState.LANG_COLUMN_NOT_ORDERABLE_DURING_EXECUTION, columnDescriptor.getType().getTypeId().getSQLTypeName());
        }
        // Remember the position in the base table of each column
        baseColumnPositions[i] = columnDescriptor.getPosition();
    }
    return baseColumnPositions;
}

Example 27 with ColumnDescriptor

use of org.apache.derby.iapi.sql.dictionary.ColumnDescriptor in project derby by apache.

the class CreateTableConstantAction method executeConstantAction.

// INTERFACE METHODS
/**
 *	This is the guts of the Execution-time logic for CREATE TABLE.
 *
 *	@see ConstantAction#executeConstantAction
 *
 * @exception StandardException		Thrown on failure
 */
public void executeConstantAction(Activation activation) throws StandardException {
    TableDescriptor td;
    UUID toid;
    SchemaDescriptor schemaDescriptor;
    ColumnDescriptor columnDescriptor;
    ExecRow template;
    LanguageConnectionContext lcc = activation.getLanguageConnectionContext();
    DataDictionary dd = lcc.getDataDictionary();
    DependencyManager dm = dd.getDependencyManager();
    TransactionController tc = lcc.getTransactionExecute();
    /* Mark the activation as being for create table */
    activation.setForCreateTable();
    // setup for create conglomerate call:
    // o create row template to tell the store what type of rows this
    // table holds.
    // o create array of collation id's to tell collation id of each
    // column in table.
    template = RowUtil.getEmptyValueRow(columnInfo.length, lcc);
    int[] collation_ids = new int[columnInfo.length];
    for (int ix = 0; ix < columnInfo.length; ix++) {
        ColumnInfo col_info = columnInfo[ix];
        if (col_info.defaultValue != null) {
            /* If there is a default value, use it, otherwise use null */
            template.setColumn(ix + 1, col_info.defaultValue);
        } else {
            template.setColumn(ix + 1, col_info.dataType.getNull());
        }
        // get collation info for each column.
        collation_ids[ix] = col_info.dataType.getCollationType();
    }
    /* create the conglomerate to hold the table's rows
		 * RESOLVE - If we ever have a conglomerate creator
		 * that lets us specify the conglomerate number then
		 * we will need to handle it here.
		 */
    long conglomId = tc.createConglomerate(// we're requesting a heap conglomerate
    "heap", // row template
    template.getRowArray(), // column sort order - not required for heap
    null, collation_ids, // properties
    properties, tableType == TableDescriptor.GLOBAL_TEMPORARY_TABLE_TYPE ? (TransactionController.IS_TEMPORARY | TransactionController.IS_KEPT) : TransactionController.IS_DEFAULT);
    /*
		** 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.
		*/
    if (tableType != TableDescriptor.GLOBAL_TEMPORARY_TABLE_TYPE)
        dd.startWriting(lcc);
    SchemaDescriptor sd;
    if (tableType == TableDescriptor.GLOBAL_TEMPORARY_TABLE_TYPE)
        sd = dd.getSchemaDescriptor(schemaName, tc, true);
    else
        sd = DDLConstantAction.getSchemaDescriptorForCreate(dd, activation, schemaName);
    // 
    // Create a new table descriptor.
    // 
    DataDescriptorGenerator ddg = dd.getDataDescriptorGenerator();
    if (tableType != TableDescriptor.GLOBAL_TEMPORARY_TABLE_TYPE) {
        td = ddg.newTableDescriptor(tableName, sd, tableType, lockGranularity);
        dd.addDescriptor(td, sd, DataDictionary.SYSTABLES_CATALOG_NUM, false, tc);
    } else {
        td = ddg.newTableDescriptor(tableName, sd, tableType, onCommitDeleteRows, onRollbackDeleteRows);
        td.setUUID(dd.getUUIDFactory().createUUID());
    }
    toid = td.getUUID();
    // Save the TableDescriptor off in the Activation
    activation.setDDLTableDescriptor(td);
    /* NOTE: We must write the columns out to the system
		 * tables before any of the conglomerates, including
		 * the heap, since we read the columns before the
		 * conglomerates when building a TableDescriptor.
		 * This will hopefully reduce the probability of
		 * a deadlock involving those system tables.
		 */
    // for each column, stuff system.column
    int index = 1;
    ColumnDescriptor[] cdlArray = new ColumnDescriptor[columnInfo.length];
    for (int ix = 0; ix < columnInfo.length; ix++) {
        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();
        }
        if (// dealing with autoinc column
        columnInfo[ix].autoincInc != 0) {
            columnDescriptor = new ColumnDescriptor(columnInfo[ix].name, index++, columnInfo[ix].dataType, columnInfo[ix].defaultValue, columnInfo[ix].defaultInfo, td, defaultUUID, columnInfo[ix].autoincStart, columnInfo[ix].autoincInc, columnInfo[ix].autoinc_create_or_modify_Start_Increment, columnInfo[ix].autoincCycle);
            // 
            if (dd.checkVersion(DataDictionary.DD_VERSION_DERBY_10_11, null)) {
                CreateSequenceConstantAction csca = makeCSCA(columnInfo[ix], TableDescriptor.makeSequenceName(toid));
                csca.executeConstantAction(activation);
            }
        } else {
            columnDescriptor = new ColumnDescriptor(columnInfo[ix].name, index++, columnInfo[ix].dataType, columnInfo[ix].defaultValue, columnInfo[ix].defaultInfo, td, defaultUUID, columnInfo[ix].autoincStart, columnInfo[ix].autoincInc, columnInfo[ix].autoincCycle);
        }
        cdlArray[ix] = columnDescriptor;
    }
    if (tableType != TableDescriptor.GLOBAL_TEMPORARY_TABLE_TYPE) {
        dd.addDescriptorArray(cdlArray, td, DataDictionary.SYSCOLUMNS_CATALOG_NUM, false, tc);
    }
    // now add the column descriptors to the table.
    ColumnDescriptorList cdl = td.getColumnDescriptorList();
    for (int i = 0; i < cdlArray.length; i++) cdl.add(cdlArray[i]);
    // 
    // Create a conglomerate desciptor with the conglomId filled in and
    // add it.
    // 
    // RESOLVE: Get information from the conglomerate descriptor which
    // was provided.
    // 
    ConglomerateDescriptor cgd = ddg.newConglomerateDescriptor(conglomId, null, false, null, false, null, toid, sd.getUUID());
    if (tableType != TableDescriptor.GLOBAL_TEMPORARY_TABLE_TYPE) {
        dd.addDescriptor(cgd, sd, DataDictionary.SYSCONGLOMERATES_CATALOG_NUM, false, tc);
    }
    // add the newly added conglomerate to the table descriptor
    ConglomerateDescriptorList conglomList = td.getConglomerateDescriptorList();
    conglomList.add(cgd);
    /* Create any constraints */
    if (constraintActions != null) {
        /*
			** Do everything but FK constraints first,
			** then FK constraints on 2nd pass.
			*/
        for (int conIndex = 0; conIndex < constraintActions.length; conIndex++) {
            // skip fks
            if (!constraintActions[conIndex].isForeignKeyConstraint()) {
                constraintActions[conIndex].executeConstantAction(activation);
            }
        }
        for (int conIndex = 0; conIndex < constraintActions.length; conIndex++) {
            // only foreign keys
            if (constraintActions[conIndex].isForeignKeyConstraint()) {
                constraintActions[conIndex].executeConstantAction(activation);
            }
        }
    }
    // 
    for (int ix = 0; ix < columnInfo.length; ix++) {
        addColumnDependencies(lcc, dd, td, columnInfo[ix]);
    }
    // 
    // The table itself can depend on the user defined types of its columns.
    // 
    adjustUDTDependencies(lcc, dd, td, columnInfo, false);
    if (tableType == TableDescriptor.GLOBAL_TEMPORARY_TABLE_TYPE) {
        lcc.addDeclaredGlobalTempTable(td);
    }
    // Indicate that the CREATE TABLE statement itself depends on the
    // table it is creating. Normally such statement dependencies are
    // added during compilation, but here we have a bootstrapping issue
    // because the table doesn't exist until the CREATE TABLE statement
    // has been executed, so we had to defer the creation of this
    // dependency until now. (DERBY-4479)
    dd.getDependencyManager().addDependency(activation.getPreparedStatement(), td, lcc.getContextManager());
}

Example 28 with ColumnDescriptor

use of org.apache.derby.iapi.sql.dictionary.ColumnDescriptor in project derby by apache.

the class AlterTableConstantAction method modifyColumnConstraint.

/**
 * Workhorse for modifying column level constraints.
 * 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);
    // 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());
                // not null ie is backed by unique index
                if (!(desc.getIndexDescriptor().isUnique() || desc.getIndexDescriptor().hasDeferrableChecking())) {
                    break;
                }
                // replace backing index with a unique when not null index.
                recreateUniqueConstraintBackingIndexAsUniqueWhenNotNull(desc, td, activation, lcc);
            }
        }
    }
    ColumnDescriptor newColumnDescriptor = new ColumnDescriptor(colName, columnDescriptor.getPosition(), dataType, columnDescriptor.getDefaultValue(), columnDescriptor.getDefaultInfo(), td, columnDescriptor.getDefaultUUID(), columnDescriptor.getAutoincStart(), columnDescriptor.getAutoincInc(), columnDescriptor.getAutoincCycle());
    // Update the ColumnDescriptor with new default info
    dd.dropColumnDescriptor(td.getUUID(), colName, tc);
    dd.addDescriptor(newColumnDescriptor, td, DataDictionary.SYSCOLUMNS_CATALOG_NUM, false, tc);
}

Example 29 with ColumnDescriptor

use of org.apache.derby.iapi.sql.dictionary.ColumnDescriptor in project derby by apache.

the class AlterTableConstantAction method validateNotNullConstraint.

/**
 * Make sure that the columns are non null
 * If any column is nullable, check that the data is null.
 *
 * @param	columnNames	names of columns to be checked
 * @param	nullCols	true if corresponding column is nullable
 * @param	numRows		number of rows in the table
 * @param	lcc		language context
 * @param	errorMsg	error message to use for exception
 *
 * @return true if any nullable columns found (nullable columns must have
 *		all non null data or exception is thrown
 * @exception StandardException on error
 */
private boolean validateNotNullConstraint(String[] columnNames, boolean[] nullCols, int numRows, LanguageConnectionContext lcc, String errorMsg) throws StandardException {
    boolean foundNullable = false;
    StringBuilder constraintText = new StringBuilder();
    /* 
		 * Check for nullable columns and create a constraint string which can
		 * be used in validateConstraint to check whether any of the
		 * data is null.  
		 */
    for (int colCtr = 0; colCtr < columnNames.length; colCtr++) {
        ColumnDescriptor cd = td.getColumnDescriptor(columnNames[colCtr]);
        if (cd == null) {
            throw StandardException.newException(SQLState.LANG_COLUMN_NOT_FOUND_IN_TABLE, columnNames[colCtr], td.getName());
        }
        if (cd.getType().isNullable()) {
            if (numRows > 0) {
                // already found a nullable column so add "AND"
                if (foundNullable)
                    constraintText.append(" AND ");
                // Delimiting the column name is important in case the
                // column name uses lower case characters, spaces, or
                // other unusual characters.
                constraintText.append(IdUtil.normalToDelimited(columnNames[colCtr]));
                constraintText.append(" IS NOT NULL ");
            }
            foundNullable = true;
            nullCols[colCtr] = true;
        }
    }
    /* if the table has nullable columns and isn't empty 
		 * we need to validate the data
		 */
    if (foundNullable && numRows > 0) {
        if (!ConstraintConstantAction.validateConstraint((String) null, constraintText.toString(), null, /* not used for not nullable constraints yet */
        td, lcc, false, false)) {
            if (errorMsg.equals(SQLState.LANG_NULL_DATA_IN_PRIMARY_KEY_OR_UNIQUE_CONSTRAINT)) {
                // soft upgrade mode
                throw StandardException.newException(SQLState.LANG_NULL_DATA_IN_PRIMARY_KEY_OR_UNIQUE_CONSTRAINT, td.getQualifiedName());
            } else if (errorMsg.equals(SQLState.LANG_NULL_DATA_IN_PRIMARY_KEY)) {
                // alter table add primary key
                throw StandardException.newException(SQLState.LANG_NULL_DATA_IN_PRIMARY_KEY, td.getQualifiedName());
            } else {
                // alter table modify column not null
                throw StandardException.newException(SQLState.LANG_NULL_DATA_IN_NON_NULL_COLUMN, td.getQualifiedName(), columnNames[0]);
            }
        }
    }
    return foundNullable;
}

Example 30 with ColumnDescriptor

use of org.apache.derby.iapi.sql.dictionary.ColumnDescriptor in project derby by apache.

the class AlterTableConstantAction method modifyColumnDefault.

/**
 * Workhorse for modifying the default value of a column.
 *
 * @param       ix 		the index of the column specfication in the ALTER
 *						statement-- currently we allow only one.
 * @exception	StandardException, thrown on error.
 */
private void modifyColumnDefault(int ix) throws StandardException {
    ColumnDescriptor columnDescriptor = td.getColumnDescriptor(columnInfo[ix].name);
    int columnPosition = columnDescriptor.getPosition();
    // Clean up after the old default, if non-null
    if (columnDescriptor.hasNonNullDefault()) {
        // Invalidate off of the old default
        DefaultDescriptor defaultDescriptor = new DefaultDescriptor(dd, columnInfo[ix].oldDefaultUUID, td.getUUID(), columnPosition);
        dm.invalidateFor(defaultDescriptor, DependencyManager.MODIFY_COLUMN_DEFAULT, lcc);
        // Drop any dependencies
        dm.clearDependencies(lcc, defaultDescriptor);
    }
    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();
    }
    /* Get a ColumnDescriptor reflecting the new default */
    columnDescriptor = new ColumnDescriptor(columnInfo[ix].name, columnPosition, columnInfo[ix].dataType, columnInfo[ix].defaultValue, columnInfo[ix].defaultInfo, td, defaultUUID, columnInfo[ix].autoincStart, columnInfo[ix].autoincInc, columnInfo[ix].autoinc_create_or_modify_Start_Increment, columnInfo[ix].autoincCycle);
    // Update the ColumnDescriptor with new default info
    dd.dropColumnDescriptor(td.getUUID(), columnInfo[ix].name, tc);
    dd.addDescriptor(columnDescriptor, td, DataDictionary.SYSCOLUMNS_CATALOG_NUM, false, tc);
    if (columnInfo[ix].action == ColumnInfo.MODIFY_COLUMN_DEFAULT_INCREMENT) {
        // adding an autoincrement default-- calculate the maximum value
        // of the autoincrement column.
        long maxValue = getColumnMax(td, columnInfo[ix].name, columnInfo[ix].autoincInc);
        dd.setAutoincrementValue(tc, td.getUUID(), columnInfo[ix].name, maxValue, true);
    } else if (columnInfo[ix].action == ColumnInfo.MODIFY_COLUMN_DEFAULT_RESTART) {
        dd.setAutoincrementValue(tc, td.getUUID(), columnInfo[ix].name, columnInfo[ix].autoincStart, false);
    }
    if ((columnInfo[ix].action == ColumnInfo.MODIFY_COLUMN_DEFAULT_INCREMENT) || (columnInfo[ix].action == ColumnInfo.MODIFY_COLUMN_DEFAULT_RESTART) || (columnInfo[ix].action == ColumnInfo.MODIFY_COLUMN_DEFAULT_CYCLE)) {
        // 
        if (dd.checkVersion(DataDictionary.DD_VERSION_DERBY_10_11, null)) {
            Long currentValue = null;
            // are just changing the increment. see DERBY-6579.
            if ((columnInfo[ix].action == ColumnInfo.MODIFY_COLUMN_DEFAULT_INCREMENT) || (columnInfo[ix].action == ColumnInfo.MODIFY_COLUMN_DEFAULT_CYCLE)) {
                currentValue = dd.peekAtIdentity(td.getSchemaName(), td.getName());
            }
            if (columnInfo[ix].action == ColumnInfo.MODIFY_COLUMN_DEFAULT_CYCLE) {
                if (columnInfo[ix].autoincCycle) {
                    // ALTER TABLE ALTER COLUMN $columnName SET CYCLE
                    if (currentValue == null) {
                        // 
                        // If the current value is NULL, then the sequence generator
                        // is exhausted and it must have been a NO CYCLE generator,
                        // which we are changing to CYCLE.
                        // According to the 2016 SQL Standard, section 4.27.2
                        // (Operations involving sequence generators),
                        // the next value of the sequence generator should be the minimum value
                        // (for an ascending sequence generator) or the maximum value
                        // (for a descending sequence generator). See DERBY-6961.
                        // This logic will have to change in the future if we
                        // let users configure the maximum and minimum values of identity columns.
                        // 
                        int topOrBottom = (columnInfo[ix].autoincInc > 0) ? RANGE_BOTTOM : RANGE_TOP;
                        currentValue = getRangeBound(columnInfo[ix].dataType, topOrBottom);
                    }
                } else {
                    // ALTER TABLE ALTER COLUMN $columnName SET NO CYCLE
                    // 
                    // If we are just about to issue the rollover value,
                    // set it to NULL in order to prevent cycling.
                    int topOrBottom = (columnInfo[ix].autoincInc > 0) ? RANGE_BOTTOM : RANGE_TOP;
                    Long rolloverValue = getRangeBound(columnInfo[ix].dataType, topOrBottom);
                    if ((currentValue != null) && (currentValue.equals(rolloverValue))) {
                        currentValue = null;
                    }
                }
            }
            DropTableConstantAction.dropIdentitySequence(dd, td, activation);
            // recreate the sequence
            String sequenceName = TableDescriptor.makeSequenceName(td.getUUID());
            CreateSequenceConstantAction csca = CreateTableConstantAction.makeCSCA(columnInfo[ix], sequenceName);
            csca.executeConstantAction(activation);
            // reset the current value of the sequence generator as necessary
            if ((columnInfo[ix].action == ColumnInfo.MODIFY_COLUMN_DEFAULT_INCREMENT) || (columnInfo[ix].action == ColumnInfo.MODIFY_COLUMN_DEFAULT_CYCLE)) {
                SequenceDescriptor sequence = dd.getSequenceDescriptor(dd.getSystemSchemaDescriptor(), sequenceName);
                RowLocation[] rowLocation = new RowLocation[1];
                SequenceDescriptor[] sequenceDescriptor = new SequenceDescriptor[1];
                dd.computeSequenceRowLocation(tc, sequence.getUUID().toString(), rowLocation, sequenceDescriptor);
                dd.updateCurrentSequenceValue(tc, rowLocation[0], true, null, currentValue);
            }
        }
    }
}