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

Example 11 with ColumnDescriptorList

use of org.apache.derby.iapi.sql.dictionary.ColumnDescriptorList 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 12 with ColumnDescriptorList

use of org.apache.derby.iapi.sql.dictionary.ColumnDescriptorList 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 13 with ColumnDescriptorList

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

the class UpdateNode method bindStatement.

/**
 * Bind this UpdateNode.  This means looking up tables and columns and
 * getting their types, and figuring out the result types of all
 * expressions, as well as doing view resolution, permissions checking,
 * etc.
 * <p>
 * Binding an update will also massage the tree so that
 * the ResultSetNode has a set of columns to contain the old row
 * value, followed by a set of columns to contain the new row
 * value, followed by a column to contain the RowLocation of the
 * row to be updated.
 *
 * @exception StandardException		Thrown on error
 */
@Override
public void bindStatement() throws StandardException {
    // We just need select privilege on the expressions
    getCompilerContext().pushCurrentPrivType(Authorizer.SELECT_PRIV);
    FromList fromList = new FromList(getOptimizerFactory().doJoinOrderOptimization(), getContextManager());
    TableName cursorTargetTableName = null;
    CurrentOfNode currentOfNode = null;
    ResultColumnList afterColumns = null;
    DataDictionary dataDictionary = getDataDictionary();
    // check if targetTable is a synonym
    if (targetTableName != null) {
        TableName synonymTab = resolveTableToSynonym(this.targetTableName);
        if (synonymTab != null) {
            this.synonymTableName = targetTableName;
            this.targetTableName = synonymTab;
        }
    }
    // 
    if (inMatchingClause()) {
        tagOriginalResultSetColumns();
    }
    // collect lists of objects which will require privilege checks
    ArrayList<String> explicitlySetColumns = getExplicitlySetColumns();
    List<CastNode> allCastNodes = collectAllCastNodes();
    tagPrivilegedNodes();
    // tell the compiler to only add privilege checks for nodes which have been tagged
    TagFilter tagFilter = new TagFilter(TagFilter.NEED_PRIVS_FOR_UPDATE_STMT);
    getCompilerContext().addPrivilegeFilter(tagFilter);
    bindTables(dataDictionary);
    // for positioned update, get the cursor's target table.
    if (SanityManager.DEBUG) {
        SanityManager.ASSERT((resultSet != null && resultSet instanceof SelectNode), "Update must have a select result set");
    }
    SelectNode sel;
    sel = (SelectNode) resultSet;
    targetTable = (FromTable) sel.fromList.elementAt(0);
    if (targetTable instanceof CurrentOfNode) {
        positionedUpdate = true;
        currentOfNode = (CurrentOfNode) targetTable;
        cursorTargetTableName = currentOfNode.getBaseCursorTargetTableName();
        // instead of an assert, we might say the cursor is not updatable.
        if (SanityManager.DEBUG) {
            SanityManager.ASSERT(cursorTargetTableName != null);
        }
    }
    if (targetTable instanceof FromVTI) {
        targetVTI = (FromVTI) targetTable;
        targetVTI.setTarget();
    } else {
        // we get it from the cursor supplying the position.
        if (targetTableName == null) {
            // verify we have current of
            if (SanityManager.DEBUG)
                SanityManager.ASSERT(cursorTargetTableName != null);
            targetTableName = cursorTargetTableName;
        } else // the named table is the same as the cursor's target.
        if (cursorTargetTableName != null) {
            // be the same as a correlation name in the cursor.
            if (!targetTableName.equals(cursorTargetTableName)) {
                throw StandardException.newException(SQLState.LANG_CURSOR_UPDATE_MISMATCH, targetTableName, currentOfNode.getCursorName());
            }
        }
    }
    // because we verified that the tables match
    // and we already bound the cursor or the select,
    // the table descriptor should always be found.
    verifyTargetTable();
    // add UPDATE_PRIV on all columns on the left side of SET operators
    addUpdatePriv(explicitlySetColumns);
    /* Verify that all underlying ResultSets reclaimed their FromList */
    if (SanityManager.DEBUG) {
        SanityManager.ASSERT(fromList.size() == 0, "fromList.size() is expected to be 0, not " + fromList.size() + " on return from RS.bindExpressions()");
    }
    // 
    // Add generated columns whose generation clauses mention columns
    // in the user's original update list.
    // 
    ColumnDescriptorList addedGeneratedColumns = new ColumnDescriptorList();
    ColumnDescriptorList affectedGeneratedColumns = new ColumnDescriptorList();
    addGeneratedColumns(targetTableDescriptor, resultSet, affectedGeneratedColumns, addedGeneratedColumns);
    /*
		** The current result column list is the one supplied by the user.
		** Mark these columns as "updated", so we can tell later which
		** columns are really being updated, and which have been added
		** but are not really being updated.
		*/
    resultSet.getResultColumns().markUpdated();
    /* Prepend CurrentRowLocation() to the select's result column list. */
    if (SanityManager.DEBUG)
        SanityManager.ASSERT((resultSet.getResultColumns() != null), "resultColumns is expected not to be null at bind time");
    /* Normalize the SET clause's result column list for synonym */
    if (synonymTableName != null)
        normalizeSynonymColumns(resultSet.getResultColumns(), targetTable);
    /* Bind the original result columns by column name */
    normalizeCorrelatedColumns(resultSet.getResultColumns(), targetTable);
    resultSet.bindResultColumns(targetTableDescriptor, targetVTI, resultSet.getResultColumns(), this, fromList);
    // don't allow overriding of generation clauses
    forbidGenerationOverrides(resultSet.getResultColumns(), addedGeneratedColumns);
    // the code for old way of generating unique ids.
    if (dataDictionary.checkVersion(DataDictionary.DD_VERSION_DERBY_10_11, null)) {
        // Replace any DEFAULTs with the associated tree for the default if
        // allowed, otherwise throw an exception
        resultSet.getResultColumns().replaceOrForbidDefaults(targetTableDescriptor, resultSet.getResultColumns(), true);
        resultSet.getResultColumns().checkForInvalidDefaults();
        resultSet.getResultColumns().forbidOverrides(resultSet.getResultColumns());
    } else {
        LanguageConnectionContext lcc = getLanguageConnectionContext();
        if (lcc.getAutoincrementUpdate() == false)
            resultSet.getResultColumns().forbidOverrides(null);
    }
    /*
		** Mark the columns in this UpdateNode's result column list as
		** updateable in the ResultColumnList of the table being updated.
		** only do this for FromBaseTables - if the result table is a
		** CurrentOfNode, it already knows what columns in its cursor
		** are updateable.
		*/
    boolean allColumns = false;
    if (targetTable instanceof FromBaseTable) {
        ((FromBaseTable) targetTable).markUpdated(resultSet.getResultColumns());
    } else if ((targetTable instanceof FromVTI) || (targetTable instanceof FromSubquery)) {
        resultColumnList = resultSet.getResultColumns();
    } else {
        /*
			** Positioned update: WHERE CURRENT OF
			*/
        if (SanityManager.DEBUG) {
            SanityManager.ASSERT(currentOfNode != null, "currentOfNode is null");
        }
        ExecPreparedStatement cursorStmt = currentOfNode.getCursorStatement();
        /*
			** If there is no update column list, we need to build
			** out the result column list to have all columns.
			*/
        if (!cursorStmt.hasUpdateColumns()) {
            /*
				** Get the resultColumnList representing ALL of the columns in the 
				** base table.  This is the "before" portion of the result row.
				*/
            getResultColumnList();
            /*
				** Add the "after" portion of the result row.  This is the update
				** list augmented to include every column in the target table.
				** Those columns that are not being updated are set to themselves.
				** The expanded list will be in the order of the columns in the base
				** table.
				*/
            afterColumns = resultSet.getResultColumns().expandToAll(targetTableDescriptor, targetTable.getTableName());
            /*
				** Need to get all indexes here since we aren't calling
				** getReadMap().
				*/
            getAffectedIndexes(targetTableDescriptor, (ResultColumnList) null, (FormatableBitSet) null);
            allColumns = true;
        } else {
            /* Check the updatability */
            resultSet.getResultColumns().checkColumnUpdateability(cursorStmt, currentOfNode.getCursorName());
        }
    }
    changedColumnIds = getChangedColumnIds(resultSet.getResultColumns());
    // 
    // Trigger transition tables are implemented as VTIs. This short-circuits some
    // necessary steps if the source table of a MERGE statement is a trigger
    // transition table. The following boolean is meant to prevent that short-circuiting.
    // 
    boolean needBaseColumns = (targetVTI == null) || inMatchingClause();
    /*
		** We need to add in all the columns that are needed
		** by the constraints on this table.  
		*/
    if (!allColumns && needBaseColumns) {
        getCompilerContext().pushCurrentPrivType(Authorizer.NULL_PRIV);
        try {
            readColsBitSet = new FormatableBitSet();
            FromBaseTable fbt = getResultColumnList(resultSet.getResultColumns());
            afterColumns = resultSet.getResultColumns().copyListAndObjects();
            readColsBitSet = getReadMap(dataDictionary, targetTableDescriptor, afterColumns, affectedGeneratedColumns);
            afterColumns = fbt.addColsToList(afterColumns, readColsBitSet);
            resultColumnList = fbt.addColsToList(resultColumnList, readColsBitSet);
            /*
				** If all bits are set, then behave as if we chose all
				** in the first place
				*/
            int i = 1;
            int size = targetTableDescriptor.getMaxColumnID();
            for (; i <= size; i++) {
                if (!readColsBitSet.get(i)) {
                    break;
                }
            }
            if (i > size) {
                readColsBitSet = null;
            }
        } finally {
            getCompilerContext().popCurrentPrivType();
        }
    }
    ValueNode rowLocationNode;
    if (needBaseColumns) {
        /* Append the list of "after" columns to the list of "before" columns,
			 * preserving the afterColumns list.  (Necessary for binding
			 * check constraints.)
			 */
        resultColumnList.appendResultColumns(afterColumns, false);
        /* Generate the RowLocation column */
        rowLocationNode = new CurrentRowLocationNode(getContextManager());
    } else {
        rowLocationNode = new NumericConstantNode(TypeId.getBuiltInTypeId(Types.INTEGER), 0, getContextManager());
    }
    ResultColumn rowLocationColumn = new ResultColumn(COLUMNNAME, rowLocationNode, getContextManager());
    rowLocationColumn.markGenerated();
    /* Append to the ResultColumnList */
    resultColumnList.addResultColumn(rowLocationColumn);
    /*
		 * The last thing that we do to the generated RCL is to clear
		 * the table name out from each RC. See comment on 
		 * checkTableNameAndScrubResultColumns().
		 */
    checkTableNameAndScrubResultColumns(resultColumnList);
    /* Set the new result column list in the result set */
    resultSet.setResultColumns(resultColumnList);
    // 
    if (inMatchingClause()) {
        associateAddedColumns();
    }
    // SQL 2011, section 6.10, SR 4b.
    SelectNode.checkNoWindowFunctions(resultSet, "<update source>");
    /* Bind the expressions */
    super.bindExpressions();
    /* Bind untyped nulls directly under the result columns */
    resultSet.getResultColumns().bindUntypedNullsToResultColumns(resultColumnList);
    /* Bind the new ResultColumn */
    rowLocationColumn.bindResultColumnToExpression();
    resultColumnList.checkStorableExpressions();
    /* Insert a NormalizeResultSetNode above the source if the source
		 * and target column types and lengths do not match.
		 */
    if (!resultColumnList.columnTypesAndLengthsMatch()) {
        resultSet = new NormalizeResultSetNode(resultSet, resultColumnList, null, true, getContextManager());
        if (hasCheckConstraints(dataDictionary, targetTableDescriptor) || hasGenerationClauses(targetTableDescriptor)) {
            /* Get and bind all check constraints and generated columns on the columns
	 			 * being updated.  We want to bind the check constraints and
	 			 * generated columns against
	 			 * the after columns.  We need to bind against the portion of the
	 			 * resultColumns in the new NormalizeResultSet that point to 
	 			 * afterColumns.  Create an RCL composed of just those RCs in
	 			 * order to bind the check constraints.
	 			 */
            int afterColumnsSize = afterColumns.size();
            afterColumns = new ResultColumnList(getContextManager());
            ResultColumnList normalizedRCs = resultSet.getResultColumns();
            for (int index = 0; index < afterColumnsSize; index++) {
                afterColumns.addElement(normalizedRCs.elementAt(index + afterColumnsSize));
            }
        }
    }
    if (null != targetVTI && !inMatchingClause()) {
        deferred = VTIDeferModPolicy.deferIt(DeferModification.UPDATE_STATEMENT, targetVTI, resultColumnList.getColumnNames(), sel.getWhereClause());
    } else // not VTI
    {
        /* we always include triggers in core language */
        boolean hasTriggers = (getAllRelevantTriggers(dataDictionary, targetTableDescriptor, changedColumnIds, true).size() > 0);
        ResultColumnList sourceRCL = hasTriggers ? resultColumnList : afterColumns;
        /* bind all generation clauses for generated columns */
        parseAndBindGenerationClauses(dataDictionary, targetTableDescriptor, afterColumns, resultColumnList, true, resultSet);
        /* Get and bind all constraints on the columns being updated */
        checkConstraints = bindConstraints(dataDictionary, getOptimizerFactory(), targetTableDescriptor, null, sourceRCL, changedColumnIds, readColsBitSet, true, /* we always include triggers in core language */
        new boolean[1]);
        /* If the target table is also a source table, then
             * the update will have to be in deferred mode
             * For updates, this means that the target table appears in a
             * subquery.  Also, self referencing foreign keys are
             * deferred.  And triggers cause an update to be deferred.
             */
        if (resultSet.subqueryReferencesTarget(targetTableDescriptor.getName(), true) || requiresDeferredProcessing()) {
            deferred = true;
        }
        TransactionController tc = getLanguageConnectionContext().getTransactionCompile();
        autoincRowLocation = dataDictionary.computeAutoincRowLocations(tc, targetTableDescriptor);
    }
    identitySequenceUUIDString = getUUIDofSequenceGenerator();
    getCompilerContext().popCurrentPrivType();
    getCompilerContext().removePrivilegeFilter(tagFilter);
    // 
    for (CastNode value : allCastNodes) {
        addUDTUsagePriv(value);
    }
}

Example 14 with ColumnDescriptorList

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

the class CreateViewConstantAction method executeConstantAction.

// INTERFACE METHODS
/**
 *	This is the guts of the Execution-time logic for CREATE VIEW.
 *
 *	@see ConstantAction#executeConstantAction
 *
 * @exception StandardException		Thrown on failure
 */
public void executeConstantAction(Activation activation) throws StandardException {
    TableDescriptor td;
    UUID toid;
    ColumnDescriptor columnDescriptor;
    ViewDescriptor vd;
    LanguageConnectionContext lcc = activation.getLanguageConnectionContext();
    DataDictionary dd = lcc.getDataDictionary();
    DependencyManager dm = dd.getDependencyManager();
    TransactionController tc = lcc.getTransactionExecute();
    /*
		** 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);
    SchemaDescriptor sd = DDLConstantAction.getSchemaDescriptorForCreate(dd, activation, schemaName);
    /* Create a new table descriptor.
		 * (Pass in row locking, even though meaningless for views.)
		 */
    DataDescriptorGenerator ddg = dd.getDataDescriptorGenerator();
    td = ddg.newTableDescriptor(tableName, sd, tableType, TableDescriptor.ROW_LOCK_GRANULARITY);
    dd.addDescriptor(td, sd, DataDictionary.SYSTABLES_CATALOG_NUM, false, tc);
    toid = td.getUUID();
    // for each column, stuff system.column
    ColumnDescriptor[] cdlArray = new ColumnDescriptor[columnInfo.length];
    int index = 1;
    for (int ix = 0; ix < columnInfo.length; ix++) {
        columnDescriptor = new ColumnDescriptor(columnInfo[ix].name, index++, columnInfo[ix].dataType, columnInfo[ix].defaultValue, columnInfo[ix].defaultInfo, td, (UUID) null, columnInfo[ix].autoincStart, columnInfo[ix].autoincInc, columnInfo[ix].autoincCycle);
        cdlArray[ix] = columnDescriptor;
    }
    dd.addDescriptorArray(cdlArray, td, DataDictionary.SYSCOLUMNS_CATALOG_NUM, false, tc);
    // add columns to the column descriptor list.
    ColumnDescriptorList cdl = td.getColumnDescriptorList();
    for (int i = 0; i < cdlArray.length; i++) cdl.add(cdlArray[i]);
    /* Get and add a view descriptor */
    vd = ddg.newViewDescriptor(toid, tableName, viewText, checkOption, (compSchemaId == null) ? lcc.getDefaultSchema().getUUID() : compSchemaId);
    for (int ix = 0; ix < providerInfo.length; ix++) {
        /* We should always be able to find the Provider */
        Provider provider = (Provider) providerInfo[ix].getDependableFinder().getDependable(dd, providerInfo[ix].getObjectId());
        dm.addDependency(vd, provider, lcc.getContextManager());
    }
    // store view's dependency on various privileges in the dependeny system
    storeViewTriggerDependenciesOnPrivileges(activation, vd);
    dd.addDescriptor(vd, sd, DataDictionary.SYSVIEWS_CATALOG_NUM, true, tc);
}

Example 15 with ColumnDescriptorList

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

the class DDLConstantAction method adjustUDTDependencies.

/**
 * Adjust dependencies of a table on ANSI UDTs. We only add one dependency
 * between a table and a UDT. If the table already depends on the UDT, we don't add
 * a redundant dependency.
 */
protected void adjustUDTDependencies(LanguageConnectionContext lcc, DataDictionary dd, TableDescriptor td, ColumnInfo[] columnInfos, boolean dropWholeTable) throws StandardException {
    if ((!dropWholeTable) && (columnInfos == null)) {
        return;
    }
    TransactionController tc = lcc.getTransactionExecute();
    int changedColumnCount = columnInfos == null ? 0 : columnInfos.length;
    HashMap<String, AliasDescriptor> addUdtMap = new HashMap<String, AliasDescriptor>();
    HashMap<String, AliasDescriptor> dropUdtMap = new HashMap<String, AliasDescriptor>();
    HashSet<String> addColumnNames = new HashSet<String>();
    HashSet<String> dropColumnNames = new HashSet<String>();
    // and the old ones which are candidates for removal
    for (int i = 0; i < changedColumnCount; i++) {
        ColumnInfo ci = columnInfos[i];
        // skip this column if it is not a UDT
        AliasDescriptor ad = dd.getAliasDescriptorForUDT(tc, columnInfos[i].dataType);
        if (ad == null) {
            continue;
        }
        String key = ad.getObjectID().toString();
        if (ci.action == ColumnInfo.CREATE) {
            addColumnNames.add(ci.name);
            // no need to add the descriptor if it is already on the list
            if (addUdtMap.get(key) != null) {
                continue;
            }
            addUdtMap.put(key, ad);
        } else if (ci.action == ColumnInfo.DROP) {
            dropColumnNames.add(ci.name);
            dropUdtMap.put(key, ad);
        }
    }
    // and this is not a DROP TABLE command
    if (!dropWholeTable && addUdtMap.isEmpty() && dropUdtMap.isEmpty()) {
        return;
    }
    // 
    // Now prune from the add list all udt descriptors for which we already have dependencies.
    // These are the udts for old columns. This supports the ALTER TABLE ADD COLUMN
    // case.
    // 
    // Also prune from the drop list add udt descriptors which will still be
    // referenced by the remaining columns.
    // 
    ColumnDescriptorList cdl = td.getColumnDescriptorList();
    int totalColumnCount = cdl.size();
    for (int i = 0; i < totalColumnCount; i++) {
        ColumnDescriptor cd = cdl.elementAt(i);
        // skip columns that are being added and dropped. we only want the untouched columns
        if (addColumnNames.contains(cd.getColumnName()) || dropColumnNames.contains(cd.getColumnName())) {
            continue;
        }
        // nothing to do if the old column isn't a UDT
        AliasDescriptor ad = dd.getAliasDescriptorForUDT(tc, cd.getType());
        if (ad == null) {
            continue;
        }
        String key = ad.getObjectID().toString();
        // ha, it is a UDT.
        if (dropWholeTable) {
            dropUdtMap.put(key, ad);
        } else {
            if (addUdtMap.get(key) != null) {
                addUdtMap.remove(key);
            }
            if (dropUdtMap.get(key) != null) {
                dropUdtMap.remove(key);
            }
        }
    }
    adjustUDTDependencies(lcc, dd, td, addUdtMap, dropUdtMap);
}