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

Example 1 with SubConstraintDescriptor

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

the class DataDictionaryImpl method getConstraintDescriptorViaHeap.

/**
 * Return a (single or list of) catalog row descriptor(s) from
 * SYSCONSTRAINTS through a heap scan
 *
 * @param scanQualifiers			qualifiers
 * @param ti						The TabInfoImpl to use
 * @param parentTupleDescriptor		The parentDescriptor, if applicable.
 * @param list						The list to build, if supplied.
 *									If null, then caller expects a single descriptor
 *
 * @return	The last matching descriptor
 *
 * @exception StandardException		Thrown on error
 */
protected TupleDescriptor getConstraintDescriptorViaHeap(ScanQualifier[][] scanQualifiers, TabInfoImpl ti, TupleDescriptor parentTupleDescriptor, ConstraintDescriptorList list) throws StandardException {
    SYSCONSTRAINTSRowFactory rf = (SYSCONSTRAINTSRowFactory) ti.getCatalogRowFactory();
    ExecRow outRow;
    ScanController scanController;
    TransactionController tc;
    ConstraintDescriptor cd = null;
    // Get the current transaction controller
    tc = getTransactionCompile();
    outRow = rf.makeEmptyRow();
    /*
		** Table scan
		*/
    scanController = tc.openScan(// conglomerate to open
    ti.getHeapConglomerate(), // don't hold open across commit
    false, // for read
    0, TransactionController.MODE_TABLE, TransactionController.ISOLATION_REPEATABLE_READ, // all fields as objects
    (FormatableBitSet) null, // start position - first row
    (DataValueDescriptor[]) null, // startSearchOperation - none
    0, // scanQualifier,
    scanQualifiers, // stop position -through last row
    (DataValueDescriptor[]) null, // stopSearchOperation - none
    0);
    try {
        while (scanController.fetchNext(outRow.getRowArray())) {
            SubConstraintDescriptor subCD = null;
            switch(rf.getConstraintType(outRow)) {
                case DataDictionary.PRIMARYKEY_CONSTRAINT:
                case DataDictionary.FOREIGNKEY_CONSTRAINT:
                case DataDictionary.UNIQUE_CONSTRAINT:
                    subCD = getSubKeyConstraint(rf.getConstraintId(outRow), rf.getConstraintType(outRow));
                    break;
                case DataDictionary.CHECK_CONSTRAINT:
                    subCD = getSubCheckConstraint(rf.getConstraintId(outRow));
                    break;
                default:
                    if (SanityManager.DEBUG) {
                        SanityManager.THROWASSERT("unexpected value from " + " rf.getConstraintType(outRow) " + rf.getConstraintType(outRow));
                    }
            }
            if (SanityManager.DEBUG) {
                SanityManager.ASSERT(subCD != null, "subCD is expected to be non-null");
            }
            cd = (ConstraintDescriptor) rf.buildDescriptor(outRow, subCD, this);
            /* If dList is null, then caller only wants a single descriptor - we're done
				 * else just add the current descriptor to the list.
				 */
            if (list == null) {
                break;
            } else {
                list.add(cd);
            }
        }
    } finally {
        scanController.close();
    }
    return cd;
}

Example 2 with SubConstraintDescriptor

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

the class DataDictionaryImpl method getConstraintDescriptorViaIndex.

/**
 * Return a (single or list of) ConstraintDescriptor(s) from
 * SYSCONSTRAINTS where the access is from the index to the heap.
 *
 * @param indexId	The id of the index (0 to # of indexes on table) to use
 * @param keyRow	The supplied ExecIndexRow for search
 * @param ti		The TabInfoImpl to use
 * @param td		The TableDescriptor, if supplied.
 * @param dList		The list to build, if supplied.  If null, then caller expects
 *					a single descriptor
 * @param forUpdate			Whether or not to open scan for update
 *
 * @return	The last matching descriptor
 *
 * @exception StandardException		Thrown on error
 */
protected ConstraintDescriptor getConstraintDescriptorViaIndex(int indexId, ExecIndexRow keyRow, TabInfoImpl ti, TableDescriptor td, ConstraintDescriptorList dList, boolean forUpdate) throws StandardException {
    SYSCONSTRAINTSRowFactory rf = (SYSCONSTRAINTSRowFactory) ti.getCatalogRowFactory();
    ConglomerateController heapCC;
    ConstraintDescriptor cd = null;
    ExecIndexRow indexRow1;
    ExecRow outRow;
    RowLocation baseRowLocation;
    ScanController scanController;
    TransactionController tc;
    // Get the current transaction controller
    tc = getTransactionCompile();
    outRow = rf.makeEmptyRow();
    heapCC = tc.openConglomerate(ti.getHeapConglomerate(), false, 0, TransactionController.MODE_RECORD, TransactionController.ISOLATION_REPEATABLE_READ);
    /* Scan the index and go to the data pages for qualifying rows to
		 * build the column descriptor.
		 */
    scanController = tc.openScan(// conglomerate to open
    ti.getIndexConglomerate(indexId), // don't hold open across commit
    false, (forUpdate) ? TransactionController.OPENMODE_FORUPDATE : 0, TransactionController.MODE_RECORD, TransactionController.ISOLATION_REPEATABLE_READ, // all fields as objects
    (FormatableBitSet) null, // start position - exact key match.
    keyRow.getRowArray(), // startSearchOperation
    ScanController.GE, // scanQualifier,
    null, // stop position - exact key match.
    keyRow.getRowArray(), // stopSearchOperation
    ScanController.GT);
    while (scanController.next()) {
        SubConstraintDescriptor subCD = null;
        // create an index row template
        indexRow1 = getIndexRowFromHeapRow(ti.getIndexRowGenerator(indexId), heapCC.newRowLocationTemplate(), outRow);
        scanController.fetch(indexRow1.getRowArray());
        baseRowLocation = (RowLocation) indexRow1.getColumn(indexRow1.nColumns());
        boolean base_row_exists = heapCC.fetch(baseRowLocation, outRow.getRowArray(), (FormatableBitSet) null);
        if (SanityManager.DEBUG) {
            // it can not be possible for heap row to disappear while
            // holding scan cursor on index at ISOLATION_REPEATABLE_READ.
            SanityManager.ASSERT(base_row_exists, "base row doesn't exist");
        }
        switch(rf.getConstraintType(outRow)) {
            case DataDictionary.PRIMARYKEY_CONSTRAINT:
            case DataDictionary.FOREIGNKEY_CONSTRAINT:
            case DataDictionary.UNIQUE_CONSTRAINT:
                subCD = getSubKeyConstraint(rf.getConstraintId(outRow), rf.getConstraintType(outRow));
                break;
            case DataDictionary.CHECK_CONSTRAINT:
                subCD = getSubCheckConstraint(rf.getConstraintId(outRow));
                break;
            default:
                if (SanityManager.DEBUG) {
                    SanityManager.THROWASSERT("unexpected value " + "from rf.getConstraintType(outRow)" + rf.getConstraintType(outRow));
                }
        }
        if (SanityManager.DEBUG) {
            SanityManager.ASSERT(subCD != null, "subCD is expected to be non-null");
        }
        /* Cache the TD in the SCD so that
			 * the row factory doesn't need to go
			 * out to disk to get it.
			 */
        subCD.setTableDescriptor(td);
        cd = (ConstraintDescriptor) rf.buildDescriptor(outRow, subCD, this);
        /* If dList is null, then caller only wants a single descriptor - we're done
			 * else just add the current descriptor to the list.
			 */
        if (dList == null) {
            break;
        } else {
            dList.add(cd);
        }
    }
    scanController.close();
    heapCC.close();
    return cd;
}

Example 3 with SubConstraintDescriptor

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

the class SYSCONSTRAINTSRowFactory method buildDescriptor.

// /////////////////////////////////////////////////////////////////////////
// 
// ABSTRACT METHODS TO BE IMPLEMENTED BY CHILDREN OF CatalogRowFactory
// 
// /////////////////////////////////////////////////////////////////////////
/**
 * Make a ConstraintDescriptor out of a SYSCONSTRAINTS row
 *
 * @param row a SYSCONSTRAINTS row
 * @param parentTupleDescriptor	Subconstraint descriptor with auxiliary info.
 * @param dd dataDictionary
 *
 * @exception   StandardException thrown on failure
 */
public TupleDescriptor buildDescriptor(ExecRow row, TupleDescriptor parentTupleDescriptor, DataDictionary dd) throws StandardException {
    ConstraintDescriptor constraintDesc = null;
    if (SanityManager.DEBUG) {
        SanityManager.ASSERT(row.nColumns() == SYSCONSTRAINTS_COLUMN_COUNT, "Wrong number of columns for a SYSCONSTRAINTS row");
    }
    DataValueDescriptor col;
    ConglomerateDescriptor conglomDesc;
    DataDescriptorGenerator ddg;
    TableDescriptor td = null;
    int constraintIType = -1;
    int[] keyColumns = null;
    UUID constraintUUID;
    UUID schemaUUID;
    UUID tableUUID;
    UUID referencedConstraintId = null;
    SchemaDescriptor schema;
    String tableUUIDString;
    String constraintName;
    String constraintSType;
    String constraintStateStr;
    boolean deferrable = ConstraintDefinitionNode.DEFERRABLE_DEFAULT;
    boolean initiallyDeferred = ConstraintDefinitionNode.INITIALLY_DEFERRED_DEFAULT;
    boolean enforced = ConstraintDefinitionNode.ENFORCED_DEFAULT;
    int referenceCount;
    String constraintUUIDString;
    String schemaUUIDString;
    SubConstraintDescriptor scd;
    if (SanityManager.DEBUG) {
        if (!(parentTupleDescriptor instanceof SubConstraintDescriptor)) {
            SanityManager.THROWASSERT("parentTupleDescriptor expected to be instanceof " + "SubConstraintDescriptor, not " + parentTupleDescriptor.getClass().getName());
        }
    }
    scd = (SubConstraintDescriptor) parentTupleDescriptor;
    ddg = dd.getDataDescriptorGenerator();
    /* 1st column is CONSTRAINTID (UUID - char(36)) */
    col = row.getColumn(SYSCONSTRAINTS_CONSTRAINTID);
    constraintUUIDString = col.getString();
    constraintUUID = getUUIDFactory().recreateUUID(constraintUUIDString);
    /* 2nd column is TABLEID (UUID - char(36)) */
    col = row.getColumn(SYSCONSTRAINTS_TABLEID);
    tableUUIDString = col.getString();
    tableUUID = getUUIDFactory().recreateUUID(tableUUIDString);
    /* Get the TableDescriptor.  
		 * It may be cached in the SCD, 
		 * otherwise we need to go to the
		 * DD.
		 */
    if (scd != null) {
        td = scd.getTableDescriptor();
    }
    if (td == null) {
        td = dd.getTableDescriptor(tableUUID);
    }
    /* 3rd column is NAME (varchar(128)) */
    col = row.getColumn(SYSCONSTRAINTS_CONSTRAINTNAME);
    constraintName = col.getString();
    /* 4th column is TYPE (char(1)) */
    col = row.getColumn(SYSCONSTRAINTS_TYPE);
    constraintSType = col.getString();
    if (SanityManager.DEBUG) {
        SanityManager.ASSERT(constraintSType.length() == 1, "Fourth column type incorrect");
    }
    boolean typeSet = false;
    switch(constraintSType.charAt(0)) {
        case 'P':
            constraintIType = DataDictionary.PRIMARYKEY_CONSTRAINT;
            typeSet = true;
        case 'U':
            if (!typeSet) {
                constraintIType = DataDictionary.UNIQUE_CONSTRAINT;
                typeSet = true;
            }
        case 'F':
            if (!typeSet)
                constraintIType = DataDictionary.FOREIGNKEY_CONSTRAINT;
            if (SanityManager.DEBUG) {
                if (!(parentTupleDescriptor instanceof SubKeyConstraintDescriptor)) {
                    SanityManager.THROWASSERT("parentTupleDescriptor expected to be instanceof " + "SubKeyConstraintDescriptor, not " + parentTupleDescriptor.getClass().getName());
                }
            }
            conglomDesc = td.getConglomerateDescriptor(((SubKeyConstraintDescriptor) parentTupleDescriptor).getIndexId());
            /* Take care the rare case of conglomDesc being null.  The
				 * reason is that our "td" is out of date.  Another thread
				 * which was adding a constraint committed between the moment
				 * we got the table descriptor (conglomerate list) and the
				 * moment we scanned and got the constraint desc list.  Since
				 * that thread just added a new row to SYSCONGLOMERATES, 
				 * SYSCONSTRAINTS, etc.  We wouldn't have wanted to lock the
				 * system tables just to prevent other threads from adding new
				 * rows.
				 */
            if (conglomDesc == null) {
                // we can't be getting td from cache because if we are
                // here, we must have been in dd's ddl mode (that's why
                // the ddl thread went through), we are not done yet, the
                // dd ref count is not 0, hence it couldn't have turned
                // into COMPILE_ONLY mode
                td = dd.getTableDescriptor(tableUUID);
                if (scd != null)
                    scd.setTableDescriptor(td);
                // try again now
                conglomDesc = td.getConglomerateDescriptor(((SubKeyConstraintDescriptor) parentTupleDescriptor).getIndexId());
            }
            if (SanityManager.DEBUG) {
                SanityManager.ASSERT(conglomDesc != null, "conglomDesc is expected to be non-null for backing index");
            }
            keyColumns = conglomDesc.getIndexDescriptor().baseColumnPositions();
            referencedConstraintId = ((SubKeyConstraintDescriptor) parentTupleDescriptor).getKeyConstraintId();
            keyColumns = conglomDesc.getIndexDescriptor().baseColumnPositions();
            break;
        case 'C':
            constraintIType = DataDictionary.CHECK_CONSTRAINT;
            if (SanityManager.DEBUG) {
                if (!(parentTupleDescriptor instanceof SubCheckConstraintDescriptor)) {
                    SanityManager.THROWASSERT("parentTupleDescriptor expected to be instanceof " + "SubCheckConstraintDescriptor, not " + parentTupleDescriptor.getClass().getName());
                }
            }
            break;
        default:
            if (SanityManager.DEBUG) {
                SanityManager.THROWASSERT("Fourth column value invalid");
            }
    }
    /* 5th column is SCHEMAID (UUID - char(36)) */
    col = row.getColumn(SYSCONSTRAINTS_SCHEMAID);
    schemaUUIDString = col.getString();
    schemaUUID = getUUIDFactory().recreateUUID(schemaUUIDString);
    schema = dd.getSchemaDescriptor(schemaUUID, null);
    /* 6th column is STATE (char(1)) */
    col = row.getColumn(SYSCONSTRAINTS_STATE);
    constraintStateStr = col.getString();
    if (SanityManager.DEBUG) {
        SanityManager.ASSERT(constraintStateStr.length() == 1, "Sixth column (state) type incorrect");
    }
    // 
    switch(constraintStateStr.charAt(0)) {
        case 'E':
            deferrable = false;
            initiallyDeferred = false;
            enforced = true;
            break;
        case 'D':
            deferrable = false;
            initiallyDeferred = false;
            enforced = false;
            break;
        case 'e':
            deferrable = true;
            initiallyDeferred = true;
            enforced = true;
            break;
        case 'd':
            deferrable = true;
            initiallyDeferred = true;
            enforced = false;
            break;
        case 'i':
            deferrable = true;
            initiallyDeferred = false;
            enforced = true;
            break;
        case 'j':
            deferrable = true;
            initiallyDeferred = false;
            enforced = false;
            break;
        default:
            if (SanityManager.DEBUG) {
                SanityManager.THROWASSERT("Invalidate state value '" + constraintStateStr + "' for constraint");
            }
    }
    /* 7th column is REFERENCECOUNT, boolean */
    col = row.getColumn(SYSCONSTRAINTS_REFERENCECOUNT);
    referenceCount = col.getInt();
    switch(constraintIType) {
        case DataDictionary.PRIMARYKEY_CONSTRAINT:
            constraintDesc = ddg.newPrimaryKeyConstraintDescriptor(td, constraintName, deferrable, initiallyDeferred, // genReferencedColumns(dd, td), //int referencedColumns[],
            keyColumns, constraintUUID, ((SubKeyConstraintDescriptor) parentTupleDescriptor).getIndexId(), schema, enforced, referenceCount);
            break;
        case DataDictionary.UNIQUE_CONSTRAINT:
            constraintDesc = ddg.newUniqueConstraintDescriptor(td, constraintName, deferrable, initiallyDeferred, // genReferencedColumns(dd, td), //int referencedColumns[],
            keyColumns, constraintUUID, ((SubKeyConstraintDescriptor) parentTupleDescriptor).getIndexId(), schema, enforced, referenceCount);
            break;
        case DataDictionary.FOREIGNKEY_CONSTRAINT:
            if (SanityManager.DEBUG) {
                SanityManager.ASSERT(referenceCount == 0, "REFERENCECOUNT column is nonzero for fk constraint");
            }
            constraintDesc = ddg.newForeignKeyConstraintDescriptor(td, constraintName, deferrable, initiallyDeferred, // genReferencedColumns(dd, td), //int referencedColumns[],
            keyColumns, constraintUUID, ((SubKeyConstraintDescriptor) parentTupleDescriptor).getIndexId(), schema, referencedConstraintId, enforced, ((SubKeyConstraintDescriptor) parentTupleDescriptor).getRaDeleteRule(), ((SubKeyConstraintDescriptor) parentTupleDescriptor).getRaUpdateRule());
            break;
        case DataDictionary.CHECK_CONSTRAINT:
            if (SanityManager.DEBUG) {
                SanityManager.ASSERT(referenceCount == 0, "REFERENCECOUNT column is nonzero for check constraint");
            }
            constraintDesc = ddg.newCheckConstraintDescriptor(td, constraintName, deferrable, initiallyDeferred, constraintUUID, ((SubCheckConstraintDescriptor) parentTupleDescriptor).getConstraintText(), ((SubCheckConstraintDescriptor) parentTupleDescriptor).getReferencedColumnsDescriptor(), schema, enforced);
            break;
    }
    return constraintDesc;
}