Circular Dependencies
A circular dependency occurs when the attribute selected for the
Then clause of a cascading attribute rule (the driven attribute) directly or indirectly drives one or more of the attributes you have selected for an
If or
And If condition of the same rule. This means that another cascading attribute rule or chain of cascading attribute rules exist where the attribute you are trying to set as the driven attribute for the rule already drives one or more of the attributes you are trying to set as driver attributes. These existing rules can be local rules created on the current type, or
rules inherited from a parent type.
The system does not allow you to create new rules, or edit existing rules on the current type in a way that would result in a circular dependency.
The system does not prevent creating new rules or editing existing rules on a parent type in such a way that results in a circular dependency on a subtype. In this scenario, when you next view the Cascading Attributes tab for the subtype, a message displays alerting you that circular dependencies now exist. The subtype can be saved with those circular dependencies in effect.
|
|
After making changes to the rules for a parent type, always inspect the rules for any subtypes with inherited rules enabled, to make sure that the rules appear as expected. Modify rules on the subtypes as needed.
|
For example, assume that the following cascading attribute rules are created on a subtype:
• If Country=USA, then State=Arizona, Colorado, Florida
• If State=Arizona, then City=Avondale, Bisbee, Douglas
Creating the following cascading attribute rule on the parent type would result in a circular dependency:
• If City= Bisbee, then Country=USA
The
Attribute Set Report cannot run if there are circular dependencies on the current type.
To fix circular dependencies resulting from inherited rules, you can do one or more of the following:
• Update or delete the rules created locally on the subtype to correct the circular dependency.
• Update or delete the rules created on the parent type that are causing the circular dependency on the subtype. Because the type hierarchy can be many levels deep, the problem rules can be on the immediate parent type or an ancestor type many levels above the subtype in the type hierarchy.
