Oracle CDD/Repository is an active, distributed repository system that
allows users to organize, manage, control, and integrate tools and
applications across an entire enterprise.
A repository is a central location where elements can be defined,
stored, and shared. Elements correspond to various entities involved
in a project. These include data definitions, models, files, reports,
databases, tools, and system configurations. Oracle CDD/Repository
allows you to manage these entities throughout the system life cycle
and across multiple applications.
Elements also correspond to structures that support an integrated
computing environment. These structures further configuration
management, project management, system building, file management, and
tool integrations. Oracle CDD/Repository allows you to organize and
manage the environment for maximum efficiency and reporting.
Oracle CDD/Repository provides full access to the capabilities of
previous versions of CDD/Plus and includes the following capabilities:
o Extensible object-oriented information model
The information model is implemented as an element type hierarchy
that specifies both the relationship of elements and their
definitions. You can extend the element type hierarchy to
incorporate new schema information as needed.
o Project support
Oracle CDD/Repository includes functionality that furthers
configuration management, project management, system building, file
management, and tool integration.
1 – Compatibility with Previous Versions
CDD/Repository supports information in two formats:
o Metadata manipulated with the Common Dictionary Operator (CDO)
Oracle CDD/Repository continues to support dictionaries created by
previous versions of CDD/Plus. You can continue to work with these
dictionaries without taking advantage of new features. A CDO
dictionary is created on your system when you install Oracle
CDD/Repository.
o Metadata manipulated with the Dictionary Management Utility (DMU)
CDD/Plus continues to support dictionaries created by older
versions of the CDD and the utilities that manipulate those
dictionary definitions---DMU, CDDL, and CDDV.
If a DMU dictionary does not already exist on your system, Oracle
CDD/Repository creates one during the installation procedure. The
installation also installs the compatibility repository, a special
overlapping CDO dictionary that coordinates DMU format definitions
and CDO format definitions.
You manipulate DMU dictionary definitions through the DMU utility;
however, you can also read DMU definitions through CDO.
For the most part, the features of Oracle CDD/Repository do not affect
dictionaries that were created by earlier versions of the CDD. This
means that you can continue to access established DMU dictionaries with
products such as DATATRIEVE and ACMS.
Oracle CDD/Repository provides the DMU, CDDL, and CDDV utilities in
addition to the CDO utility so you can perform all your dictionary work
as with previous releases of CDD. In addition, Oracle CDD/Repository
automatically translates definitions in existing dictionaries so that
you can read them from the CDO interface.
For more information on the features of DMU dictionaries, see the help
topics "DMU", "CDDL", and "CDDV".
2 – Environment Management Features
Oracle CDD/Repository provides the following environment management
capabilities:
o Configuration Management
Configuration management is tailored to the needs of large groups
working on complex development efforts. It provides for multiple
versions of system elements, multiple versions of system
configurations, and variant lines of development.
o Project Management
Project management allows you to switch between activities equated
to project tasks, and to maintain the current state of each
activity.
o User-Designed Approval Structures
These structures allow you to promote system elements to higher
levels (and wider visibility) as they become more stable or meet
specified criteria.
o Automatic Minimal System Building
The repository allows you to model system builds. You can
associate source and derived versions of files and represent
process information.
o Built-in File Management
Oracle CDD/Repository provides functions that you can use to
automatically manage project files.
o Tool Integration
Oracle CDD/Repository is designed to accommodate CASE
(Computer-Aided Software Engineering) and other tools so they work
together sharing information, activities, and procedures.
3 – Information Management Features
Oracle CDD/Repository provides the following information management
capabilities:
o Common View of Information
The repository provides a storage area for common elements and
their behaviors (methods) that can be accessed and shared by
multiple applications. Use (and re-use) of common elements and
methods saves development time.
o Consistency of Information
When multiple applications use the same elements and methods,
redundant information and conflicting definitions can be
eliminated. The repository includes a notification system that
alerts you to changes made to related elements. Pieces tracking
capabilities allow you to locate all uses of a shared element. You
can also check the effects of a projected change before the change
is made.
o Distribution of Information
The repository provides one logical storage point for information
which can be physically dispersed as appropriate to business needs
or computing loads.
o Integrity and Security of Information
The repository provides means by which you can grant or deny access
to elements and to repositories. It also provides journaling
capabilities that automatically protect repository sessions from
system failures.
o Comprehensive Information Model
The Oracle CDD/Repository Information Model contains a base set of
elements and methods that spans all phases of the software
development process. This allows you to model, manipulate, and
control all aspects of product and process as development occurs.
o Structured Information Model
The Information Model is implemented in the form of an
object-oriented type hierarchy. This form is designed to reduce
the amount of information that must be explicitly stated in
application code.
o Extensible Information Model
Through the Oracle CDD/Repository Callable Interface, you can
extend the information model to include additional elements and
methods. This functionality allows you to customize the
information model to integrate new applications and tools or to
address business-specific needs.
4 – IVP
The Oracle CDD/Repository Installation Verification Procedure (IVP)
files are provided by the installation. You can run the IVP after the
installation is complete by entering the following command:
$ @SYS$COMMON:[SYSTEST]CDD$IVP
5 – Release Notes
Release notes for Oracle CDD/Repository are contained in the files:
SYS$HELP:CDDnnn.RELEASE_NOTES
SYS$HELP:CDDnnn_RELEASE_NOTES.PS
Where nnn represents the Oracle CDD/Repository version number. For
example, to see the Version 7.2 release notes, type or print the
CDD072.RELEASE_NOTES file to read the release note information.
To find what release note files are available, use the following DCL
command:
$ DIRECTORY SYS$HELP:*.RELEASE_NOTES
6 – Upgrade Procedure
The recommended method of upgrading existing dictionaries or repositories is to use the CDD$UPGRADE.COM command procedure. The CDD$UPGRADE.COM command procedure automatically invokes the appropriate upgrade utility based on the version number you specify. The procedure is provided with the Oracle CDD/Repository installation. If you are performing an upgrade from a Version 5.n repository to a later Version 5.n or higher repository, CDD$UPGRADE.COM runs the CDO CONVERT utility using the CDO CONVERT/REPOSITORY command. This is referred to as a minor upgrade. In Version 5.0, the upgrade portion of the CONVERT command was disabled. However, in Version 5.1 and later, CDO CONVERT/REPOSITORY can be used to perform a minor upgrade. If you are performing an upgrade from a Version 4.n dictionary, the CDD$UPGRADE.COM procedure runs CDDX, the repository translation utility, using the REPOSITORY EXPORT and REPOSITORY IMPORT commands. This type of upgrade is referred to as a major upgrade. Note: DMU dictionaries do not require an upgrade. The CDD$UPGRADE.COM procedure and the REPOSITORY IMPORT and REPOSITORY EXPORT commands must be invoked from the DCL level. See the CDDX help topic for information on the REPOSITORY IMPORT and REPOSITORY EXPORT commands. You invoke the CONVERT/REPOSITORY command from CDO. See the description of the CDO CONVERT command in the CDO utility online help.
6.1 – Preparing for Upgrade
Before you upgrade a repository or use the REPOSITORY EXPORT command,
check the following:
o Ensure that you have SYSPRV or BYPASS privilege
o Check the paging file quota (PGFLQUOTA)
The .CDDX export file requires approximately one half the number of
blocks used by the CDD$DATABASE.RDB file.
The following table lists the PGFLQUOTA values required for the
upgrade:
CDD$DATABASE.RDB Size Required PGFLQUOTA
---------------------------------------------------
0-20,000 blocks 50,000-200,000 pages
20,000-35,000 blocks 70,000-200,000 pages
35,000-55,000 blocks 100,000-200,000 pages
55,000 + blocks 200,000 pages
---------------------------------------------------
o Verify the repository
o If you do not have an adequate backup of your repository, perform a
backup operation.
See the instructions in the Oracle CDD/Repository User's Guide for
verifying and backing up a repository.
o If you issue the REPOSITORY EXPORT command directly from the DCL
level, redefine the CDD$SEPARATOR as a slash character (/) if any
repository elements contain a period (.) in the name.
o If you are installing Oracle CDD/Repository, check for the
SYS$SHARE:CDA$ACCESS.EXE image, which is required by the upgrade
images.
Also, if you installing Oracle CDD/Repository and the process you
are in was created before the installation, log out and log back in
again before executing the CDD$UPGRADE.COM procedure (or run
CDD$UPGRADE.COM from the installing account) to update DCL
commands.
7 – User Account Quotas
To work with Oracle CDD/Repository, user accounts must have certain
quotas. The following are the minimum settings specific to the use of
Oracle CDD/Repository:
Account Quota Value
---------------------------------------
ASTLM 24
BIOLM 80
BYTLM 25,000
DIOLM 40
ENQLM 2,000
FILLM 100
PGFLQUO 50,000
---------------------------------------
Settings required by users on your system might differ substantially.
If you plan to use other layered products, the quotas required for
these products must be added to the value you choose for Oracle
CDD/Repository.
For information on adjusting user account quotas, see the Oracle
CDD/Repository installation guide.
8 – Glossary
This glossary defines Oracle CDD/Repository terms.
8.1 – 1-to-1_relation
One object relates to no more than one other object, which is not allowed to relate to other objects using that type of relation.
8.2 – 1-to-n_relation
An organization of relationships in which one element is related to multiple elements, with each element pair connected through a single relationship. Same as 1-to-many relation.
8.3 – Application Control Architecture (ACA) Services
A set of software services that allows a developer to integrate software applications in a distributed heterogeneous computing environment.
8.4 – approval_level
The position in a partition hierarchy that a system object attains after an approval process. At higher approval levels, the requirements are more stringent and the objects that reside there are more stable.
8.5 – argument_list
A list used to pass arguments to the Oracle CDD/Repository callable interface routines.
8.6 – argument_specifier
An entry in an argument list. An argument specifier consists of an argument name, argument value structure, and status field. See also argument list, value structure.
8.7 – ATIS
A Tools Integration Standard; a proposed common interface for tool integration.
8.8 – attachment_type
A characteristic of an element that describes how a version of the element is attached to a collection. An attachment type determines whether an element is updated from the latest replaced version in a partition or from the latest version in either your context or partition. An attachment type of Current indicates that the current element should be used in the updated collection---not the latest version from either the context or partition.
8.9 – attribute
See property.
8.10 – base_partition
A partition to which your context is attached. From the base partition, you can view all the elements in the partition, all the elements in its successive parent partitions, and all the elements in its related partitions. See also partition.
8.11 – binary_relationship
An organization of relationships in which one element is related to other elements. The element cannot be part of other relationships of the same type, as in a 1-to-n relationship.
8.12 – branch
A sequence of versions forming a line of development distinct from other sequences of versions of the same component. Each branch represents a parallel thread of development. Branches can be merged back into the main development path. Same as branch line of descent.
8.13 – branching
The act of creating a branch. Branching allows more than one programmer to work on a component at one time.
8.14 – branch_merge
A merge back into the line of descent from which the branch came and that does not require a content merge. Also called a genealogy merge. See also content merge.
8.15 – browser
A utility that presents repository information graphically and lets you "move through the repository" by traversing links between elements.
8.16 – check_in
See replace.
8.17 – check_out
See reserve.
8.18 – child_partition
A partition from which a version of a component may be promoted. There can be multiple child partitions to any partition. See also partition.
8.19 – class
In conventional object-oriented terminology, a template for objects. A class is comparable to an Oracle CDD/Repository element type.
8.20 – clone
When an object is included in a remote repository, through having a directory name entered for it in another repository or through being a member of a grouping relationship in another repository, a copy of that object resides in the remote repository. This copy is called a clone.
8.21 – closure_property
A property whose value is formed by traversing a relation recursively. See also relation property.
8.22 – collection
A set of versions taken from different components that implements a configuration.
8.23 – collection_hierarchy
A tree of collections that represents a system, subsystem, sub-subsystem, and so on.
8.24 – component
A set of branches. Broadly, the main line of descent and any branches. Similar to a VAX DEC/Code Management System (CMS) element.
8.25 – composite
A set of versions taken from different components. A composite is similar to, but more general than, a collection.
8.26 – computed_property
A property whose value is found or modified by invoking a method. See also normal property, relation property .
8.27 – configuration
Identifies the parts that make up a particular version of a system. For example, when a system passes a baselevel review, that version of the system is identified by a baseline.
8.28 – configuration_control
The mechanism by which a software component is promoted within a partition hierarchy based on its level of stability.
8.29 – configuration_hierarchy
A tree of configurations that represents a system, subsystems, sub-subsystems, and so on.
8.30 – configuration_management
Oracle CDD/Repository facilities for storing and manipulating information about configurations.
8.31 – content_merge
A merge in which the content of two versions has diverged and must be reconciled. See also branch merge.
8.32 – context
The work space in which you can modify elements. A context is attached to the base partition you specify, so you can reserve elements from the base partition and its successive parent partitions. A context provides a view into a project as represented by a repository. An element that represents views of the repository. It identifies a collection that represents a configuration, the base partition, and the configuration subdirectory.
8.33 – context_management
Oracle CDD/Repository facilities for storing, manipulating, and using context information.
8.34 – context_merge
The act of merging two contexts to form a single context.
8.35 – data_aggregate
A collection of data elements describing a record, an Oracle Rdb relation, or structure field.
8.36 – data_element
A field in Oracle CDD/Repository.
8.37 – dependency_graph_navigator
A network navigator that starts with a given element and follows the dependents and dependencies properties in both directions. The dependency graph navigator displays the complete dependency network for a system. This is the default navigator when you specify the /GRAPH qualifier.
8.38 – dependency_relationship
A relationship in which the modification of a member results in the automatic notification of the owner(s). You use dependency relationships when a change to the member means that the owner must also change.
8.39 – derived_object
A system object (typically an object file or an executable file) that is the result of applying a translation process to one or more source objects. Given the same source objects and translation processor, you can reproduce derived objects as needed.
8.40 – distribution
The ability to distribute information among several physical repositories.
8.41 – element
An object in conventional object-oriented terminology. An entity in the repository that generally represents a system object (such as a source file), a tool (such as a compiler), or a data definition.
8.42 – element_access_right
A right to a particular type of access to a specific element.
8.43 – element_editor
A facility that lets you create an element or lets you show or modify the information about an element.
8.44 – element ID
See element identifier.
8.45 – element_identifier
A unique value assigned by the system so that your program can work with an instance of an element type. Also called a handle.
8.46 – element_instantiation_hierarchy
The hierarchy formed by elements that are instances of their parents.
8.47 – element_type
A class in conventional object-oriented terminology. The type of an element is defined by its properties and methods. An element that represents a group of objects that have common characteristics.
8.48 – element_type_hierarchy
The hierarchy formed by the ELEMENT element type and its subtypes.
8.49 – entity-relationship_diagram
A diagram that illustrates how specific relations relate elements of one type to elements of another (or the same) type.
8.50 – error_stack
A stack upon which Oracle CDD/Repository places detailed information about errors as they occur.
8.51 – external_code_method
A method that is implemented outside of Oracle CDD/Repository by loading it at run time.
8.52 – external_program_method
A method that is implemented in a program invoked in a separate process.
8.53 – external_storage_file
A file that is represented in the repository but that Oracle CDD/Repository does not manage.
8.54 – freeze
An operation that prevents reserving the last version on the line of descent.
8.55 – genealogy_merge
See branch merge.
8.56 – ghost
A reserved, modifiable version of a component. The ghost version is visible only to the person who reserved it.
8.57 – handle
See element identifier.
8.58 – hierarchy_navigator
A tree-structured outline view of repository directories that lets you expand your view down to named repository elements. You can expand named elements to show what they contain and the elements on which they depend.
8.59 – illegal_function
A method function that results in an error indicating that no method was specified. An illegal function disallows a message on an element type.
8.60 – immutable
A versioned element that cannot be changed.
8.61 – inherit
To take on the attributes of a parent. An element type inherits the properties and methods of its supertypes.
8.62 – instance
A specific object that implements the element type.
8.63 – instance_hierarchy
A hierarchy in which sublevels are instances of higher levels.
8.64 – instance_list
A list of instances of a specific element type.
8.65 – instantiable
A type for which you can create an instance.
8.66 – integrated_tool
A tool that communicates and cooperates with other tools.
8.67 – internal_code_method
Methods linked into the Oracle CDD/Repository image and invoked by a subroutine call.
8.68 – internal_storage_file
A file represented in a repository and actively managed by Oracle CDD/Repository. For internal storage files, storage location is transparent to the user.
8.69 – leaf_partition
A partition that has no child partitions. See also partition .
8.70 – line_of_descent
A succession of versions in which each version results from modifying its predecessor in the line of descent. A single thread of development. See also main line of descent.
8.71 – list
An ordered sequence of value structures.
8.72 – logical_object
An object in the sense of a "part of the system" that may be a subdivision of an object represented by an element.
8.73 – main_line_of_descent
The line of descent made up of the versions that implement the root branch. The main thread of development. See also line of descent.
8.74 – member
A participant in a relationship. A member of a relationship cannot be deleted unless the relationship is deleted first.
8.75 – merge
To reconcile the differences between versions in separate branches of a component.
8.76 – message
The means by which tools manipulate objects. A message requests that an element perform some action, but it does not specify how to perform that action. The element responds by invoking the appropriate method to carry out the request.
8.77 – metadata_elements
Elements that define the repository schema.
8.78 – method
The specific response of an element to a message. Methods provide a customized response to messages in the sense that the method is specific to the element type that defines it.
8.79 – method_function
The function that implements a method, as opposed to the METHOD element that represents that behavior.
8.80 – method_refinement
The modification by an element type of its inherited methods to make them more specific to the needs of the objects represented by the type.
8.81 – multiple-inheritance_system
An object-oriented programming system in which each element type may inherit its characteristics from more than one supertype. See also single-inheritance system.
8.82 – mutable
The ability of a property to be changed even though the version it belongs to is replaced.
8.83 – naming_model
The Oracle CDD/Repository model that shows how element names are constructed and how they are resolved.
8.84 – navigator
A facility that lets you display hierarchies and graphs of elements and the relationships between them.
8.85 – network_navigator
A navigator that displays objects in graphical form.
8.86 – normal_property
A property for which values are stored directly in the repository. See also computed property, relation property.
8.87 – notice
An encoded report of the status of an element of Oracle CDD/Repository. When an element in the repository changes, Oracle CDD/Repository sends a message to related elements. The message contains a warning indicating that a portion of the repository has recently changed and that the change may affect the element receiving the message.
8.88 – n-to-m_relation
An organization of relationships in which multiple elements are related to multiple elements, with each element pair connected through a single relationship.
8.89 – null_function
A method function that does nothing. A null function serves as a placeholder for a preamble or postamble.
8.90 – object
See element.
8.91 – object_model
A way of representing elements in a repository. An object model includes the concept of objects, methods, and properties. It provides the base type hierarchy and methods necessary to define and manipulate objects. Any of the parts that make up a software system or participate in the process of developing software. Examples are source files, data definitions, documents, people, software tools, and so on.
8.92 – object-oriented_programming
A programming discipline in which operations are carried out by sending general requests (called messages) to objects, which are responsible for executing the appropriate detailed procedures (called methods) to implement the messages.
8.93 – owner
A participant in a relationship. When an owner is deleted, all the relationships that it owns also are deleted. The person who creates an element.
8.94 – parent_partition
A partition into which a version of a component in a child partition may be promoted. See also partition.
8.95 – partition
An element that groups version elements at a specified level of configuration control. A named division of the repository corresponding to an approval level. See also base partition, child partition, leaf partition, parent partition, partition, root partition.
8.96 – partition_control
A system by which components are made visible to a wider group of users.
8.97 – partition_hierarchy_navigator
A hierarchy navigator that starts with the currently selected element type and graphs elements that satisfy the forward property childPartition and backward properties parentPartition and basePartition.
8.98 – partition_list
An ordered list of partitions. You can see a version contained in a partition only if the partition is part of your partition list.
8.99 – persistent_process
An element that records the state of your work on a task by identifying a configuration as well as preserving current operating system information.
8.100 – postamble
Code that is executed after a method has been completed but before the method returns control to the client. Postamble is one way to customize a method. See also preamble.
8.101 – preamble
Code that is executed before a method is invoked. Preamble is one way to customize a method. See also postamble.
8.102 – processing_name
The name of an object in the Oracle CDD/Repository system. In most cases, the processing name is the same as the given name of the object.
8.103 – promote
To move an object to the next-higher partition.
8.104 – property
A named value associated with an element. A property provides information about the element or relates the element to one or more other elements. It also differentiates an element from other elements of the same type. An example of a property is the name of an element. In object-oriented terminology, property is the same as attribute.
8.105 – register
To make a tool known to the repository.
8.106 – related_partition
A partition that is linked to a partition in another partition hierarchy without being its parent, thus making the components in the related partition visible in the partition to which it is linked. See also partition.
8.107 – relation
Defines characteristics of a particular type of relationship between elements, such as the types of elements that can be owners and members of the relationship.
8.108 – relation_property
A property that is implemented by relationships. The value of the property is the result of traversing the relationship in a specified fashion. See also closure property, computed property, normal property .
8.109 – relationship
A specific relation that links two elements together in such a way that if you know one, you can find the other.
8.110 – relationship ID
The element identifier of a relationship.
8.111 – replace
To place a reserved version of a component back into the partition hierarchy. This causes the version to be read-only and visible in the current context's base partition. To make a previously reserved version public and immutable. Also known as checking in. See also reserve.
8.112 – repository
An expanded dictionary model that contains data as well as metadata. The repository contains configuration information and lets you create and delete files.
8.113 – repository_contents_navigator
A hierarchy navigator that starts with a given element (or CDD$DEFAULT) and follows the hasChildren property of elements. The repository contents navigator displays the contents of composite objects. It is the default navigator.
8.114 – reserve
To create a new, private, writable version of a component by copying an existing public, immutable version of a component into your context. Also known as checking out. See also replace.
8.115 – root_partition
A partition that has no parent partition. The root partition represents the highest level of configuration control in a partition hierarchy. See also partition.
8.116 – scan
An unordered list of element identifiers.
8.117 – scope
User access to specific elements in a repository.
8.118 – single-inheritance_system
An object-oriented programming system in which each element type inherits its characteristics from only one supertype. See also multiple-inheritance system.
8.119 – source_object
A system object you can create and from which you can make derived objects.
8.120 – subtype
An element type that inherits properties and methods from another element type a parent type or supertype.
8.121 – superop
The method that implements a given message for an element type's supertype.
8.122 – superop_function
A method function that invokes the method defined for an element type's supertype.
8.123 – supertype
The element type from which another element type inherits properties, methods, and messages.
8.124 – surrogate
An element that represents a system object without containing any of that object's data.
8.125 – tool
An application that performs or helps perform a software development task.
8.126 – traverse
To access a specified part of a relationship and gather information about the relationship.
8.127 – type_hierarchy
The definition of the element types, their properties, the messages that can be sent to them, and the methods that respond to those messages.
8.128 – type_hierarchy_navigator
A hierarchy navigator that starts with the ELEMENT element type and follows the subTypes property. The type hierarchy navigator displays the type hierarchy as implemented in Oracle CDD/Repository.
8.129 – type_list_navigator
A hierarchy navigator that starts with the ELEMENT_TYPE element type and follows the instances property. The type list navigator displays instances of types.
8.130 – type_refinement
The process by which a subtype is made more specialized than its supertype.
8.131 – type_registration
The process of defining new element types.
8.132 – uninstantiable
An element for which you cannot create instances.
8.133 – unreserve
To cancel a previous reserve operation on a version, discarding any changes that might have been made on the reserved version.
8.134 – value_structure
A data structure that identifies a data item's type and value or pointer to its value.
8.135 – variant
Alternate development occurring concurrently with main-line development.
8.136 – variant_branch
A branch consisting of elements that implement an alternate to the main line of descent.
8.137 – version
An element that records the state of a component at a specific time. Each version reflects the changes that were made at that particular point in development.
8.138 – version_graph_navigator
A network navigator that starts with the given element and follows the nextVersion and prevVersion properties in both directions. The version graph navigator displays all versions of the given element and their interconnections.
8.139 – version_management
Controls how versions are manipulated in the repository.