| /* |
| |
| Derby - Class org.apache.derby.impl.sql.catalog.SYSCONSTRAINTSRowFactory |
| |
| Licensed to the Apache Software Foundation (ASF) under one or more |
| contributor license agreements. See the NOTICE file distributed with |
| this work for additional information regarding copyright ownership. |
| The ASF licenses this file to you under the Apache License, Version 2.0 |
| (the "License"); you may not use this file except in compliance with |
| the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| |
| */ |
| |
| package org.apache.derby.impl.sql.catalog; |
| |
| import java.sql.Types; |
| |
| import org.apache.derby.catalog.UUID; |
| import org.apache.derby.iapi.error.StandardException; |
| import org.apache.derby.shared.common.sanity.SanityManager; |
| import org.apache.derby.iapi.services.uuid.UUIDFactory; |
| import org.apache.derby.iapi.sql.dictionary.CatalogRowFactory; |
| import org.apache.derby.iapi.sql.dictionary.ConglomerateDescriptor; |
| import org.apache.derby.iapi.sql.dictionary.ConstraintDescriptor; |
| import org.apache.derby.iapi.sql.dictionary.DataDescriptorGenerator; |
| import org.apache.derby.iapi.sql.dictionary.DataDictionary; |
| import org.apache.derby.iapi.sql.dictionary.SchemaDescriptor; |
| import org.apache.derby.iapi.sql.dictionary.SubCheckConstraintDescriptor; |
| import org.apache.derby.iapi.sql.dictionary.SubConstraintDescriptor; |
| import org.apache.derby.iapi.sql.dictionary.SubKeyConstraintDescriptor; |
| import org.apache.derby.iapi.sql.dictionary.SystemColumn; |
| import org.apache.derby.iapi.sql.dictionary.TableDescriptor; |
| import org.apache.derby.iapi.sql.dictionary.TupleDescriptor; |
| import org.apache.derby.iapi.sql.execute.ExecRow; |
| import org.apache.derby.iapi.sql.execute.ExecutionFactory; |
| import org.apache.derby.iapi.types.DataValueDescriptor; |
| import org.apache.derby.iapi.types.DataValueFactory; |
| import org.apache.derby.iapi.types.SQLChar; |
| import org.apache.derby.iapi.types.SQLInteger; |
| import org.apache.derby.iapi.types.SQLVarchar; |
| import org.apache.derby.impl.sql.compile.ConstraintDefinitionNode; |
| |
| /** |
| * Factory for creating a SYSCONTRAINTS row. |
| * |
| */ |
| |
| public class SYSCONSTRAINTSRowFactory extends CatalogRowFactory |
| { |
| private static final String TABLENAME_STRING = "SYSCONSTRAINTS"; |
| |
| protected static final int SYSCONSTRAINTS_COLUMN_COUNT = 7; |
| protected static final int SYSCONSTRAINTS_CONSTRAINTID = 1; |
| protected static final int SYSCONSTRAINTS_TABLEID = 2; |
| protected static final int SYSCONSTRAINTS_CONSTRAINTNAME = 3; |
| protected static final int SYSCONSTRAINTS_TYPE = 4; |
| protected static final int SYSCONSTRAINTS_SCHEMAID = 5; |
| public static final int SYSCONSTRAINTS_STATE = ConstraintDescriptor.SYSCONSTRAINTS_STATE_FIELD; |
| protected static final int SYSCONSTRAINTS_REFERENCECOUNT = 7; |
| |
| protected static final int SYSCONSTRAINTS_INDEX1_ID = 0; |
| protected static final int SYSCONSTRAINTS_INDEX2_ID = 1; |
| protected static final int SYSCONSTRAINTS_INDEX3_ID = 2; |
| |
| private static final boolean[] uniqueness = { |
| true, |
| true, |
| false |
| }; |
| |
| private static final int[][] indexColumnPositions = |
| { |
| {SYSCONSTRAINTS_CONSTRAINTID}, |
| {SYSCONSTRAINTS_CONSTRAINTNAME, SYSCONSTRAINTS_SCHEMAID}, |
| {SYSCONSTRAINTS_TABLEID} |
| }; |
| |
| private static final String[] uuids = |
| { |
| "8000002f-00d0-fd77-3ed8-000a0a0b1900" // catalog UUID |
| ,"80000036-00d0-fd77-3ed8-000a0a0b1900" // heap UUID |
| ,"80000031-00d0-fd77-3ed8-000a0a0b1900" // SYSCONSTRAINTS_INDEX1 |
| ,"80000033-00d0-fd77-3ed8-000a0a0b1900" // SYSCONSTRAINTS_INDEX2 |
| ,"80000035-00d0-fd77-3ed8-000a0a0b1900" // SYSCONSTRAINTS_INDEX3 |
| }; |
| |
| ///////////////////////////////////////////////////////////////////////////// |
| // |
| // CONSTRUCTORS |
| // |
| ///////////////////////////////////////////////////////////////////////////// |
| |
| SYSCONSTRAINTSRowFactory(UUIDFactory uuidf, ExecutionFactory ef, DataValueFactory dvf) |
| { |
| super(uuidf,ef,dvf); |
| initInfo(SYSCONSTRAINTS_COLUMN_COUNT, TABLENAME_STRING, |
| indexColumnPositions, uniqueness, uuids ); |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////// |
| // |
| // METHODS |
| // |
| ///////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Make a SYSCONTRAINTS row |
| * |
| * @return Row suitable for inserting into SYSCONTRAINTS. |
| * |
| * @exception StandardException thrown on failure |
| */ |
| public ExecRow makeRow(TupleDescriptor td, TupleDescriptor parent) |
| throws StandardException |
| { |
| DataValueDescriptor col; |
| ExecRow row; |
| int constraintIType; |
| UUID oid; |
| String constraintSType = null; |
| String constraintID = null; |
| String tableID = null; |
| String constraintName = null; |
| String schemaID = null; |
| |
| boolean deferrable = |
| ConstraintDefinitionNode.DEFERRABLE_DEFAULT; |
| boolean initiallyDeferred = |
| ConstraintDefinitionNode.INITIALLY_DEFERRED_DEFAULT; |
| boolean enforced = |
| ConstraintDefinitionNode.ENFORCED_DEFAULT; |
| |
| int referenceCount = 0; |
| |
| if (td != null) |
| { |
| ConstraintDescriptor constraint = (ConstraintDescriptor)td; |
| /* |
| ** We only allocate a new UUID if the descriptor doesn't already have one. |
| ** For descriptors replicated from a Source system, we already have an UUID. |
| */ |
| oid = constraint.getUUID(); |
| constraintID = oid.toString(); |
| |
| oid = constraint.getTableId(); |
| tableID = oid.toString(); |
| |
| constraintName = constraint.getConstraintName(); |
| |
| constraintIType = constraint.getConstraintType(); |
| switch (constraintIType) |
| { |
| case DataDictionary.PRIMARYKEY_CONSTRAINT: |
| constraintSType = "P"; |
| break; |
| |
| case DataDictionary.UNIQUE_CONSTRAINT: |
| constraintSType = "U"; |
| break; |
| |
| case DataDictionary.CHECK_CONSTRAINT: |
| constraintSType = "C"; |
| break; |
| |
| case DataDictionary.FOREIGNKEY_CONSTRAINT: |
| constraintSType = "F"; |
| break; |
| |
| default: |
| if (SanityManager.DEBUG) |
| { |
| SanityManager.THROWASSERT("invalid constraint type"); |
| } |
| } |
| |
| schemaID = constraint.getSchemaDescriptor().getUUID().toString(); |
| |
| // constraint characteristics |
| deferrable = constraint.deferrable(); |
| initiallyDeferred = constraint.initiallyDeferred(); |
| enforced = constraint.enforced(); |
| |
| referenceCount = constraint.getReferenceCount(); |
| } |
| |
| /* Insert info into sysconstraints */ |
| |
| /* RESOLVE - It would be nice to require less knowledge about sysconstraints |
| * and have this be more table driven. |
| */ |
| |
| /* Build the row to insert */ |
| row = getExecutionFactory().getValueRow(SYSCONSTRAINTS_COLUMN_COUNT); |
| |
| /* 1st column is CONSTRAINTID (UUID - char(36)) */ |
| row.setColumn(SYSCONSTRAINTS_CONSTRAINTID, new SQLChar(constraintID)); |
| |
| /* 2nd column is TABLEID (UUID - char(36)) */ |
| row.setColumn(SYSCONSTRAINTS_TABLEID, new SQLChar(tableID)); |
| |
| /* 3rd column is NAME (varchar(128)) */ |
| row.setColumn(SYSCONSTRAINTS_CONSTRAINTNAME, new SQLVarchar(constraintName)); |
| |
| /* 4th column is TYPE (char(1)) */ |
| row.setColumn(SYSCONSTRAINTS_TYPE, new SQLChar(constraintSType)); |
| |
| /* 5th column is SCHEMAID (UUID - char(36)) */ |
| row.setColumn(SYSCONSTRAINTS_SCHEMAID, new SQLChar(schemaID)); |
| |
| /* 6th column is STATE (char(1)) */ |
| row.setColumn(SYSCONSTRAINTS_STATE, |
| new SQLChar(encodeCharacteristics(deferrable, initiallyDeferred, enforced))); |
| |
| /* 7th column is REFERENCED */ |
| row.setColumn(SYSCONSTRAINTS_REFERENCECOUNT, new SQLInteger(referenceCount)); |
| |
| return row; |
| } |
| |
| /* |
| * Encode the characteristics of the constraints into a single character. |
| * |
| * {deferrable, initiallyDeferred, enforced} -> 'e' |
| * {deferrable, initiallyDeferred, not enforced} -> 'd' |
| * {deferrable, immediate, enforced} -> 'i' |
| * {deferrable, immediate, not enforced} -> 'j' |
| * {not deferrable, immediate, enforced} -> 'E' |
| * {not deferrable, immediate, not enforced -> 'D' |
| * |
| * Other combinations are prohibited and not used. Note that the |
| * value 'E' is only value used prior to version 10.11, and as |
| * such upward compatibily since by default, constraints are {not |
| * deferrable, immediate, enforced}. |
| */ |
| private String encodeCharacteristics( |
| boolean deferrable, boolean initiallyDeferred, boolean enforced) { |
| char c; |
| |
| if (deferrable) { |
| if (initiallyDeferred) { |
| if (enforced) { |
| c = 'e'; // deferrable initially deferred enforced |
| } else { |
| c = 'd'; // deferrable initially deferred not enforced |
| } |
| } else { |
| if (enforced) { |
| c = 'i'; // deferrable initially immediate enforced |
| } else { |
| c = 'j'; // deferrable initially immediate not enforced |
| } |
| } |
| } else { |
| if (initiallyDeferred) { |
| if (SanityManager.DEBUG) { |
| SanityManager.NOTREACHED(); |
| } |
| c = 'E'; |
| } else { |
| if (enforced) { |
| c = 'E'; // not deferrable initially immediate enforced |
| } else { |
| c = 'D'; // not deferrable initially immediate not enforced |
| } |
| } |
| } |
| |
| return String.valueOf(c); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // 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; |
| // fall through |
| |
| case 'U' : |
| if (! typeSet) |
| { |
| constraintIType = DataDictionary.UNIQUE_CONSTRAINT; |
| typeSet = true; |
| } |
| // fall through |
| |
| 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"); |
| } |
| |
| // Cf. the encoding description in javadoc for |
| // #encodeCharacteristics. |
| // |
| // This code is cloned by DB_Key.makeDeferredClauses(). |
| // |
| 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(); |
| |
| /* now build and return the descriptor */ |
| |
| switch (constraintIType) |
| { |
| case DataDictionary.PRIMARYKEY_CONSTRAINT : |
| constraintDesc = ddg.newPrimaryKeyConstraintDescriptor( |
| td, |
| constraintName, |
| deferrable, |
| initiallyDeferred, |
| keyColumns,//genReferencedColumns(dd, td), //int referencedColumns[], |
| constraintUUID, |
| ((SubKeyConstraintDescriptor) |
| parentTupleDescriptor).getIndexId(), |
| schema, |
| enforced, |
| referenceCount); |
| break; |
| |
| case DataDictionary.UNIQUE_CONSTRAINT : |
| constraintDesc = ddg.newUniqueConstraintDescriptor( |
| td, |
| constraintName, |
| deferrable, |
| initiallyDeferred, |
| keyColumns,//genReferencedColumns(dd, td), //int referencedColumns[], |
| 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, |
| keyColumns,//genReferencedColumns(dd, td), //int referencedColumns[], |
| 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; |
| } |
| |
| /** |
| * Get the constraint ID of the row. |
| * |
| * @param row The row from sysconstraints |
| * |
| * @return UUID The constraint id |
| * |
| * @exception StandardException thrown on failure |
| */ |
| protected UUID getConstraintId(ExecRow row) |
| throws StandardException |
| { |
| DataValueDescriptor col; |
| String constraintUUIDString; |
| |
| /* 1st column is CONSTRAINTID (UUID - char(36)) */ |
| col = row.getColumn(SYSCONSTRAINTS_CONSTRAINTID); |
| constraintUUIDString = col.getString(); |
| return getUUIDFactory().recreateUUID(constraintUUIDString); |
| } |
| |
| /** |
| * Get the constraint name of the row. |
| * |
| * @param row The row from sysconstraints |
| * |
| * @return UUID The constraint name |
| * |
| * @exception StandardException thrown on failure |
| */ |
| protected String getConstraintName(ExecRow row) |
| throws StandardException |
| { |
| DataValueDescriptor col; |
| String constraintName; |
| |
| /* 3rd column is CONSTRAINTNAME (char(128)) */ |
| col = row.getColumn(SYSCONSTRAINTS_CONSTRAINTNAME); |
| constraintName = col.getString(); |
| return constraintName; |
| } |
| |
| /** |
| * Get the schema ID of the row. |
| * |
| * @param row The row from sysconstraints |
| * |
| * @return UUID The schema |
| * |
| * @exception StandardException thrown on failure |
| */ |
| protected UUID getSchemaId(ExecRow row) |
| throws StandardException |
| { |
| DataValueDescriptor col; |
| String schemaUUIDString; |
| |
| /* 5th column is SCHEMAID (UUID - char(36)) */ |
| col = row.getColumn(SYSCONSTRAINTS_SCHEMAID); |
| schemaUUIDString =col.getString(); |
| return getUUIDFactory().recreateUUID(schemaUUIDString); |
| } |
| |
| /** |
| * Get the table ID of the row. |
| * |
| * @param row The row from sysconstraints |
| * |
| * @return UUID The table id |
| * |
| * @exception StandardException thrown on failure |
| */ |
| protected UUID getTableId(ExecRow row) |
| throws StandardException |
| { |
| DataValueDescriptor col; |
| String tableUUIDString; |
| |
| /* 2nd column is TABLEID (UUID - char(36)) */ |
| col = row.getColumn(SYSCONSTRAINTS_TABLEID); |
| tableUUIDString = col.getString(); |
| return getUUIDFactory().recreateUUID(tableUUIDString); |
| } |
| |
| /** |
| * Get the constraint type out of the row. |
| * |
| * @param row The row from sysconstraints |
| * |
| * @return int The constraint type as an int |
| * |
| * @exception StandardException thrown on failure |
| */ |
| protected int getConstraintType(ExecRow row) |
| throws StandardException |
| { |
| DataValueDescriptor col; |
| int constraintIType; |
| String constraintSType; |
| |
| /* 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"); |
| } |
| |
| switch (constraintSType.charAt(0)) |
| { |
| case 'P' : |
| constraintIType = DataDictionary.PRIMARYKEY_CONSTRAINT; |
| break; |
| |
| case 'U' : |
| constraintIType = DataDictionary.UNIQUE_CONSTRAINT; |
| break; |
| |
| case 'C' : |
| constraintIType = DataDictionary.CHECK_CONSTRAINT; |
| break; |
| |
| case 'F' : |
| constraintIType = DataDictionary.FOREIGNKEY_CONSTRAINT; |
| break; |
| |
| default: |
| if (SanityManager.DEBUG) |
| { |
| SanityManager.THROWASSERT("Fourth column value invalid"); |
| } |
| constraintIType = -1; |
| } |
| |
| return constraintIType; |
| } |
| |
| /** |
| * Builds a list of columns suitable for creating this Catalog. |
| * |
| * |
| * @return array of SystemColumn suitable for making this catalog. |
| */ |
| public SystemColumn[] buildColumnList() |
| { |
| return new SystemColumn[] { |
| SystemColumnImpl.getUUIDColumn("CONSTRAINTID", false), |
| SystemColumnImpl.getUUIDColumn("TABLEID", false), |
| SystemColumnImpl.getIdentifierColumn("CONSTRAINTNAME", false), |
| SystemColumnImpl.getIndicatorColumn("TYPE"), |
| SystemColumnImpl.getUUIDColumn("SCHEMAID", false), |
| SystemColumnImpl.getIndicatorColumn("STATE"), |
| SystemColumnImpl.getColumn("REFERENCECOUNT", Types.INTEGER, false) |
| }; |
| } |
| |
| } |
