protected ReferencedKeyConstraintDescriptor(int constraintType,
    DataDictionary dataDictionary,
    TableDescriptor table,
    String constraintName,
    boolean deferrable,
    boolean initiallyDeferred,
    int[] columns,
    UUID constraintId,
    UUID indexId,
    SchemaDescriptor schemaDesc,
    boolean isEnabled,
    int referenceCount) 
{
		super(dataDictionary, table, constraintName, deferrable,
			  initiallyDeferred, columns, 
			  constraintId, indexId, schemaDesc, isEnabled);
		this.referenceCount = referenceCount;
		this.constraintType = constraintType;
}

Constructor for a KeyConstraintDescriptorImpl

Parameters:

constraintType - The type of the constraint

dataDictionary - The data dictionary that this descriptor lives in

table - The descriptor of the table the constraint is on

constraintName - The name of the constraint.

deferrable - If the constraint can be deferred.

initiallyDeferred - If the constraint starts life deferred.

columns - columns involved in the constraint

constraintId - UUID of constraint

indexId - The UUID for the backing index

schemaDesc - The SchemaDescriptor for the constraint

isEnabled - is the constraint enabled?

referenceCount - number of FKs (enabled only)

 public int decrementReferenceCount() 
{
		return referenceCount--;
}

Decrement the reference count by one.

 public final int getConstraintType() 
{
		return constraintType;
}

 public ConstraintDescriptorList getForeignKeyConstraints(int type) throws StandardException 
{
		if (SanityManager.DEBUG)
		{
			checkType(type);
		}
		// optimized for this case
		if (type == ENABLED)
		{
			// optimization to avoid any lookups if we know we
			// aren't referenced.
			if (!isReferenced())
			{
				return new ConstraintDescriptorList();
			}
			else if (fkEnabledConstraintList != null)
			{
				return fkEnabledConstraintList;
			}
			else if (fkConstraintList == null)
			{
				fkConstraintList = getDataDictionary().getForeignKeys(constraintId);
			}
			fkEnabledConstraintList = fkConstraintList.getConstraintDescriptorList(true);
			return fkEnabledConstraintList;
		}
		// not optimized for this case
		else if (type == DISABLED)
		{
			if (fkConstraintList == null)
			{
				fkConstraintList = getDataDictionary().getForeignKeys(constraintId);
			}
			return fkConstraintList.getConstraintDescriptorList(false);
		}
		else
		{
			if (fkConstraintList == null)
			{
				fkConstraintList = getDataDictionary().getForeignKeys(constraintId);
			}
			return fkConstraintList;
		}
}

Get the referencing foreign key constraints

 public int getReferenceCount() 
{
		return referenceCount;
}

Get the number of enabled fks that reference this key.

 public boolean hasNonSelfReferencingFK(int type) throws StandardException 
{
		boolean hasNonSelfReferenceFk = false;
		if (SanityManager.DEBUG)
		{
			checkType(type);
		}
		ConstraintDescriptor cd;
		ForeignKeyConstraintDescriptor fkcd;
		// Get a full list of referencing keys,
		ConstraintDescriptorList cdl = getForeignKeyConstraints(type);
 		int cdlSize = cdl.size();
		for (int index = 0; index <  cdlSize; index++)
		{
			cd = (ConstraintDescriptor) cdl.elementAt(index);
			if (! (cd instanceof ForeignKeyConstraintDescriptor))
			{
				continue;
			}
			fkcd = (ForeignKeyConstraintDescriptor) cd;
			if(!(fkcd.getTableId().equals(getTableId())))
			{
				hasNonSelfReferenceFk = true;
				break;
			}
		}
		return hasNonSelfReferenceFk;
}

Am I referenced by a FK on another table?

 public boolean hasSelfReferencingFK(ConstraintDescriptorList cdl,
    int type) throws StandardException 
{
		if (SanityManager.DEBUG)
		{
			checkType(type);
		}
		if (checkedSelfReferencing)
		{
			return hasSelfReferencing;
		}
		ConstraintDescriptor cd;
		ForeignKeyConstraintDescriptor fkcd;
		/* Get a full list of referencing keys, if caller
		 * passed in null CDL.
		 */
		if (cdl == null)
		{
			cdl = getForeignKeyConstraints(type);
		}
		int cdlSize = cdl.size();
		for (int index = 0; index <  cdlSize; index++)
		{
			cd = (ConstraintDescriptor) cdl.elementAt(index);
			if (! (cd instanceof ForeignKeyConstraintDescriptor))
			{
				continue;
			}
			fkcd = (ForeignKeyConstraintDescriptor) cd;
			if (fkcd.getReferencedConstraintId().equals(getUUID()))
			{
				hasSelfReferencing = true;
				break;
			}
		}
		return hasSelfReferencing;
}

Am I referenced by a FK on the same table?

 public int incrementReferenceCount() 
{
		return referenceCount++;
}

Bump the reference count by one.

 public boolean isReferenced() 
{
		return referenceCount != 0;
}

Is this constraint referenced? Returns true if there are enabled fks that reference this constraint.

 public boolean needsToFire(int stmtType,
    int[] modifiedCols) 
{
		/*
		** If we are disabled, we never fire
		*/
		if (!isEnabled)
		{
			return false;
		}
		if (!isReferenced() ||
			(stmtType == StatementType.INSERT))
		{
			return false;
		}
		if (stmtType == StatementType.DELETE ||
			stmtType == StatementType.BULK_INSERT_REPLACE)
		{
			return true;
		}
		// if update, only relevant if columns intersect
		return doColumnsIntersect(modifiedCols, getReferencedColumns());
}

Does this constraint need to fire on this type of DML? For referenced keys, fire if referenced by a fk, and stmt is delete or bulk insert replace, or stmt is update and columns intersect.