...
The
Concept |
---|
t | 900000000000534007|Module dependency reference set| |
---|
|
represents dependencies between different
release
. In each case, the dependency indicates which
targetEffectiveTime Specref |
---|
RefType | (field) |
---|
t | targetEffectiveTime |
---|
|
of each particular
a given
sourceEffectiveTime Specref |
---|
RefType | (field) |
---|
t | sourceEffectiveTime |
---|
|
of the dependent
requires.
...
The
Gloss |
---|
t | Module dependency reference set |
---|
|
is a
String - String - Specref |
---|
RefType | (data type) |
---|
t | String |
---|
|
which is used to represent dependencies between
, taking account of
versioning. Its structure is shown in the following table.
Field | Data type | Purpose |
---|
id | UUID | A A 128 bit unsigned Integer Specref |
---|
RefType | (data type) |
---|
t | Integer |
---|
| , uniquely identifying this . Different versions of a reference set member share the same id but have different effectiveTime Specref |
---|
RefType | (field) |
---|
t | effectiveTime |
---|
| . This allows a reference set member to be modified or made active (i.e. removed from the active set) at a specified time. |
effectiveTime | Time (data type) | The inclusive date or time at which this version of the identified became the current version. The current version of this at time T is the version with the most recent effectiveTime Specref |
---|
RefType | (field) |
---|
t | effectiveTime |
---|
| prior to or equal to time T . |
active | Boolean | The state of the identified as at the specified effectiveTime Specref |
---|
RefType | (field) |
---|
t | effectiveTime |
---|
| . If active = 1 (true) the is part of the current version of the set, if active = 0 (false) the is not part of the current version of the set. |
moduleId | SCTID | Identifies the that contains this as at the specified effectiveTime Specref |
---|
RefType | (field) |
---|
t | effectiveTime |
---|
| . The value must be a of Concept |
---|
t | 900000000000443000|Module (core metadata concept)| |
---|
| within the metadata . In this , moduleId also refers to the dependent source . Thus each contains the rows of the Concept |
---|
t | 900000000000534007|Module dependency reference set| |
---|
| that represent its dependencies on other . |
refsetId ) | SCTID | Identifies the to which this belongs. In this case, set to Concept |
---|
t | 900000000000534007|Module dependency reference set| |
---|
|
|
referencedComponentId | SCTID | The identifier of a target on which the dependent (identified by moduleId ) depends. Thus must be a of Concept |
---|
t | 900000000000443000|Module (core metadata concept)| |
---|
| . |
sourceEffectiveTime RefType | (field) |
---|
t | sourceEffectiveTime |
---|
|
| Time | The effective time of the dependent source (identified by moduleId by ). This specifies a version of that , consisting of all that have the same moduleId as this in their states as at the specified targetEffectiveTime Specref |
---|
RefType | (field) |
---|
t | targetEffectiveTime |
---|
| . targetEffectiveTime |
| Time | The effective time of the target required to satisfy the dependency (identified by referencedComponentId (field) Specref |
---|
RefType | (field) |
---|
t | referencedComponentId |
---|
| ). This specifies a version of that , consisting of all with the moduleId specified by referencedComponentId Specref |
---|
RefType | (field) |
---|
t | referencedComponentId |
---|
| in their states as at the specified targetEffectiveTime Specref |
---|
RefType | (field) |
---|
t | targetEffectiveTime |
---|
| . |
Anchor |
---|
| _7da5ff8f-9913-478c-8b35-8df009e328e9 |
---|
| _7da5ff8f-9913-478c-8b35-8df009e328e9 |
---|
|
Notes on usage
...
It is the responsibility of the organization owning and maintaining a dependent module to identify all modules on which it depends. They do this by adding rows to the
Concept |
---|
t | 900000000000534007|Module dependency reference set| |
---|
|
within the dependent module. Because these added member must be in the dependent module, the
moduleId of the
member record is also the identifier of the dependent (source) module. The target module on which the source module depends is identified by the
referencedComponentId (field) Specref |
---|
RefType | (field) |
---|
t | referencedComponentId |
---|
|
.
A module version may depend on one or more other module versions, and many module versions may have a dependency on a single module version. Cyclic module version dependencies are not allowed. If module-A depends on module-B, then module-B cannot depend on module-A.
...
Dependencies are specified between module versions, not just dependencies between modules. Therefore, it is possible to specify a dependency from a module released on one date to an earlier version of another module. The version of the dependent module is specified by the sourceEffectiveTime
Specref |
---|
RefType | (field) |
---|
t | sourceEffectiveTime |
---|
|
and the version of the module on which it depends is specified by the
targetEffectiveTime Specref |
---|
RefType | (field) |
---|
t | targetEffectiveTime |
---|
|
.
Note: Current practice assumes the refset.id column contains the same identifier for all versions of the dependencies between the same pair of modules. This approach means that at any given time only one version of each module has effective dependencies. Therefore, to review the dependencies of an earlier version, a snapshot for an earlier time must be checked. An alternative approach has been suggested by some people in which a new identifier is allocated to each dependency of each module. This would then mean that all past dependencies would be visible in a snapshot view. It would also mean that it would be possible release updated dependencies for an existing module version while also releasing more up-to-date versions of the same module with different dependencies. This added flexibility comes at the price of additional complexity and for the time-being the
continues to use the simpler approach in which each new version of a dependency supersedes the dependency between earlier versions of the same pair of modules.
...
Each component within a
references a
moduleId . This is the
that the component is currently mastered in (from the
effectiveTime Specref |
---|
RefType | (field) |
---|
t | effectiveTime |
---|
|
held on the component record). A module is simply a collection of
that are maintained as a unit by a single organization. It is the organization 's responsibility to organize the components in each
that it is responsible for into one or more modules, in a way that best fits its business needs.
...
At the point of release, if any
within a module has changed, then a new row will be added to
Concept |
---|
t | 900000000000534007|Module dependency reference set| |
---|
|
for the module's
, with the
effectiveTime (field) Specref |
---|
RefType | (field) |
---|
t | effectiveTime |
---|
|
set to the date of the new release, irrespective of whether the other fields in the module
record itself have changed. The updated |Module|
record identifies that some components within the module have been updated in this release. Where no components within a module have been updated, then a new module record will not be added and the module's
effectiveTime Specref |
---|
RefType | (field) |
---|
t | effectiveTime |
---|
|
field will not change from the previous release.
Each
will be in one, and only one
. The module that a component is mastered in may change over time, and when this happens, the component's
moduleId field will be updated (in the usual way by appending a row for the component).
Each module will be in one and only one
. Modules will not straddle
. The
that a module resides in is defined by the
SCTID of the module. A module may not move from one
to another over time. If the components within a module are to be moved to another
, then a new module must be created within the destination
to host the components that are to be transferred.
...
Note: The table above omits the initial four columns of data present in the release file. These follow the standards versioning pattern
, , effectiveTime , , active , , active (field). Additionally, to aid understanding, the table above also shows the
from one of the
associated with each of the identified
. The release file only contains the
.
...
Note: The tables above omit the initial three columns of data present in the release file. These follow the standards versioning pattern id
, effectiveTime , , active , . Additionally, to aid understanding, the tables above also show the
from one of the
associated with each of the identified
. The release file only contains the
.