Copyright: Oracle Dependency Analyzer - 9.0.4.4  Copyright © 1995, 2004, Oracle Corporation  All Rights Reserved


About dependency analysis

Related Topics

Dependency analysis gives you more control of your development environment by allowing you to efficiently manage your application development and release environment, thereby ensuring higher quality software. For a graphical overview of how dependency analysis works, refer to How dependency analysis works.

Dependency analysis identifies the relationships between objects in an application and allows you to determine the impact of change. It provides the answer to:

•	"tell me everything that uses an object", and allows the developer to see the impact of making a change to part of the application

•	questions similar to, "If I release or deploy a new version of an Oracle Form, what other components does it need to compile or run?"

Why analyze dependencies

Structured and unstructured objects held in the repository are analyzed and meaningful data is recorded about the relationships between these files and any objects defined within them. This is the dependency information, and it can be used for a variety of development, documentation, quality assurance and maintenance purposes. For example:

•	Planning can be improved since the dependency and impact information allows you to determine the scope and costs of any changes.

•	Knowing which objects are used by an object can help you to trace bugs. For example, consider an Oracle Form which calls five database packages, uses a couple of views and has a library attached. A bug logged against the form could originate from one of these dependent objects.

•	Once a bug has been found, it is easier to determine which components in the system are affected by it. The dependency analysis also helps to identify duplicate bugs which may be logged against different modules,  but which originate from a bug in the same underlying sub component.

•	A release manager can check that all the files needed for a release configuration are present.

•	A development manager can identify referenced objects that do not exist in the application or repository.

•	All the dependencies in an application can be documented automatically.

•	A developer can find out which elements will be affected by a change to source code, and whether this may impact someone else's work.

•	Performance improvements can be made, for example, by identifying inappropriately defined indexes.

The Dependency Manager

The Dependency Manager is a tool that allows you to examine dependency information in the repository. For information about the Dependency Manager dialog, refer to About the Dependency Manager.

All users can use the Dependency Manager to view dependency information, but only users who have the correct repository privilege can run dependency analysis, manually add dependencies, purge dependencies, and so on.

In Windows, repository privileges are set in the Repository Administration Utility, using the Repository User Properties dialog.

In UNIX, repository privileges are set using the command line tool. For more information, refer to the Oracle Repository Command Line Tool Guide.


An entity that you want to record a dependency with. For example, a file, C method, Java class, table, column and so on. An object could be:

•	elements in program source code, e.g. files, C function calls

•	structured objects in the repository, e.g. tables or columns


ncludes objects stored in the repository such as table and module definitions, however there is often some unstructured data, such as PL/SQL application logic or attached logic, stored within their definitions.


Files of any type that are stored in the repository. For example:

•	.fmb and .fmx files

•	Java programs

•	seed data scripts

•	Word documents


A dependency is the relationship between two objects, where either:

•	one object uses the other, a "uses" relationship

•	the object provides something to other, a "provides" relationship


How dependency analysis works

Related Topics

This diagram shows how dependency analysis is performed.  Each of the elements in the diagram are described below.

Workarea and files in local filesystem

Dependency analysis acts on objects in the context of a workarea.

Files of any type are held in repository in the form of BLOBs. Parsing of files takes place in the filesystem, and so it can only be performed when the local files are synchronized with those in the repository. Synchronization is performed automatically for files that are not under version control or that are checked out. For information about synchronizing files, refer to About synchronization.

For modeled objects such as table and module definitions which are repository based, the structured parser extracts the dependencies directly from the repository.

A parser interprets the file by extracting details of the things that the file uses, and the things that the file provides which may be used by another file or object. Click here for an example.

If you are using a versioned repository, the specific versions of an object in the configuration are identified and kept track of as the version is incremented. Dependency analysis can only be performed on checked in or non-versioned objects. For more information, refer to Dependency analysis in a versioned repository.

For information about running the dependency analysis, refer to Analyzing dependencies.

Analysis stage

This performs behind-the-scenes processing.

Parser mapping file

The parser mapping file determines which parser is used to parse an object, file or block of text. If you write your own parsers, you can add to or change this list.

For information about the parser mapping file, refer to About the Parser Mapping File.

For an overview of writing your own parsers, refer to About writing a parser.

Pre-defined and user-defined parsers

If the parser comes across an object or some code that needs another parser, it is marked as such, and when the first parser has finished the next is called automatically. For example, if the Oracle Forms forms parser finds a block of PL/SQL, it will call the PL/SQL parser when the Oracle Forms forms parser has finished. Click here for an example of a parser calling another parser.

The parser called is the one that is associated with the type of object in the Parser Mapping File. For more information, refer to About the parser mapping file

For information about the parsers supplied with Oracle Designer, refer to About parsers.

You can write your own parser to record a specific type of dependency information. An overview is given in About writing a parser.

Dependency filter file

You can filter out dependency types before they are added to the XML output file by changing the entries in the Dependency filter file. For more information, refer to About filtering dependencies.

Parser results

One XML output file is produced for each object that is parsed. For more information, refer to About XML.

DTD

The XML output file contains two types of information:

•	markup information

•	data from the parsing process

The Document Type Description (DTD) provides the details needed to interpret the markup information. For more information, refer to About the DTD.

Import stage

The XML output file is interpreted by the DTD, and this information is converted into PL/SQL at the import stage.

Dependency analysis data

The PL/SQL file produced by the import stage is run, and the results of the dependency analysis are stored in the repository.

Dependency Manager

Once dependency analysis has been run, the dependency information in the repository can be investigated using the Dependency Manager. For more information, refer to About the Dependency Manager dialog.


Example of a parser calling another parser

Related Topics

Consider an .fmb file which has sections of PL/SQL in triggers and program units which cannot be parsed by the Oracle Forms forms parser. Instead, the XML output from the Oracle Forms forms parser contains a block prefixed by the DTD to_parse syntax, which identifies the parser that will be automatically called next.

For example:

<to_parse ext='.plsql'>
<![CDATA[
BEGIN
     SELECT name, age
     FROM employees
     WHERE dept_id=5;
END;

]]>

</to_parse>

For more information, refer to About the DTD.


Example of parsing unstructured data

Related Topics

File to parse

This is a SQL file, held on the local filesystem, which creates a view MANAGERS based on the table EMPLOYEES.

CREATE OR REPLACE FORCE VIEW MANAGER

(MANAGER_ID,

MANAGER_NAME)

AS SELECT

     EME.EMPLOYEE_ID

     EME.EMPLOYEE_NAME

FROM EMPLOYEE EME

WHERE EME.EMPLOYEE_TYPE = 'Manager'

Dependencies detected

The SQL parser parses this file and identifies the following dependencies:

•	the file uses the table EMPLOYEE, and its columns EMPLOYEE_ID, EMPLOYEE_NAME AND EMPLOYEE_TYPE

•	the file provides,, the view MANAGER, with the columns MANAGER_ID and MANAGER_NAME, and somewhere in the application there will be files or modeled objects which use this view and its columns

Click here for an example of a uses/provides relationship.

XML output

The XML output for this file is shown below, and points to note are:

•	the header contains information about which parser is run, on which file and the workarea context

•	the SQL parser inserts entries for each of the objects used or provided by the file

•	the <status value='Certain'/> entry means that the parser is certain of the dependency type. When the parser cannot be sure of the dependency type, then the entry has the status 'Tentative'. For more information, refer to About the dependency status.

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE parse_context SYSTEM 'file:/D:/orant/repadm61/java/ia.dtd'>

<parse_context workarea_name='Dependency Analysis'>

<parsed_object type='PRIMARY_ACCESS_FILE'>
<source>
   <file name='D:\dependmgr\ddl\manager.sql'/>
</source>

<dependency type='Uses'
            subtype='Select'>
   <target name='EMPLOYEE.EMPLOYEE_TYPE'
           type='COLUMN'/>
   <status value='Certain'/>
</dependency>

<dependency type='Uses'
            subtype='Select'>
   <target name='EMPLOYEE'
           type='RELATION_DEFINITION'/>
   <status value='Certain'/>
</dependency>

<dependency type='Uses'
            subtype='Select'>
   <target name='EMPLOYEE.EMPLOYEE_ID'
           type='COLUMN'/>
   <status value='Certain'/>
</dependency>

<dependency type='Uses'
            subtype='Select'>
   <target name='MANAGER'
           type='RELATION_DEFINITION'/>
   <status value='Certain'/>
</dependency>

<dependency type='Provides'
   <target name='MANAGER.MANAGER_ID'
           type='COLUMN'/>
   <status value='Certain'/>
</dependency>

<dependency type='Provides'>
   <target name='MANAGER.MANAGER_NAME'
           type='COLUMN'/>
   <status value='Certain'/>
</dependency>

<dependency type='Provides'
            subtype='Principal'>
   <target name='manager.sql'
           type='PRIMARY_ACCESS_FILE'/>
   <status value='Certain'/>
</dependency>

<dependency type='Uses'
            subtype='Select'>
   <target name='EMPLOYEE.EMPLOYEE_TYPE'
           type='COLUMN'/>
   <status value='Certain'/>
</dependency>

</parsed_object>


Example of a uses/used by relationship
Example of a uses/provides relationship

Related Topics

The uses/provides relationship is illustrated in the diagram below.

In this example, form ref.fmb has a block, ControlBlock, which also has an item, ControlItem. These two objects are related with a provides relationship as they are not subclassed from another object. Form xyz.fmb subclasses the two objects in ref.fmb and these objects are recorded with a uses relationship. The form also has an alert object, ErrorAlert, which is not subclassed from another object and so is recorded with a provides relationship.


An object in the repository using a global name is modeled is by having a Uses dependency between the object and the global name. In this case the global name is the supplier and the object is the client in the dependency.


An object in the repository providing a global name is modeled is by having a Provides dependency between the object and the global name. The object is the supplier in the dependency and the global name is the client.


Dependency analysis in a versioned repository

Related Topics

In a versioned repository, only one version of an object can appear in a workarea. Dependency analysis operates in the context of a workarea, therefore only one version of an object can contribute to any dependency relationships. A dependency relates two object versions; the dependency itself is not versioned.

Dependency analysis in a versioned repository differs from that in a non-versioned repository when an object in the workarea uses a name and there is no provider of that name in the workarea. The Dependency Manager shows all the objects outside the workarea that are providers of that name, and it is up to you to identify which is the correct one. In addition in a versioned repository, you might also have to decide which version of the object is the correct one.

Click here for an example of a uses/provides relationship.

The Dependency Manager has a utility, Search for out of workarea, that displays likely object versions to help you. About


About XML

Related Topics

Extensible Markup Language (XML) is a data interchange language based on Standard Generalized Markup Language (SGML). It is a W3C standard which has wide industry support for the interchange of data. The format of an XML document is data with markup information.

For more information about XML, connect to:

•	http://www.w3.org/XML

The parsers analyze files or structured information and produce output in XML format. This allows dependencies to be identified between disparate sources. XML documents contain:

•	markup information in the format defined in the Document Type Declaration (DTD).

•	character data, which is the dependency information identified in the source file or structured object

You can write your own parsers to generate XML output that describes the dependencies for a type of file. The parser can be written in any language, but the output has to conform to the correct XML format. For more information, refer to About writing a parser.

An XML output file is generated for each object analyzed, and the filename has the format:

<folder name>_<path name>_<object name>.xml

Click here for an example of an XML file.


XML Example

Related Topics

This SQL file is called MyFile.sql:

select name
from employees
where age < 25

The XML produced by parsing it is:


About the Document Type Description
About the DTD

Related Topics

An XML document contains two types of information:

•	markup information

•	data from the parsing process

The DTD (Document Type Description) provides the information needed to interpret the markup information.

See also

About XML

The dependency analysis DTD

Detailed description of the DTD elements

An example of XML using the DTD


Dependency analysis DTD

Related Topics

This is the DTD that interprets the XML output by a dependency analysis parser. For more information, refer to About the DTD.

Click here for detailed information about the DTD elements.

<!ELEMENT parse_context ( parsed_object* ) >
<!ATTLIST parse_context
   workarea_name CDATA #REQUIRED
>

<!ELEMENT parsed_object ( source, ( dependency | to_parse )* ) >
<!ATTLIST parsed_object
   type          CDATA #REQUIRED
>

<!ELEMENT source ( file | repos_object ) >

<!ELEMENT file EMPTY >
<!ATTLIST file
   name          CDATA #REQUIRED
>

<!ELEMENT repos_object EMPTY >
<!ATTLIST repos_object
   irid          CDATA #REQUIRED
   ivid          CDATA #REQUIRED
>

<!ELEMENT to_parse ( PCDATA ) >
<!ATTLIST to_parse
   ext           CDATA #REQUIRED
>

<!ELEMENT dependency ( target, status ) >
<!ATTLIST dependency
   type          ( Uses | Provides | CDATA ) #REQUIRED
   subtype       CDATA #IMPLIED
>

<!ELEMENT target EMPTY >
<!ATTLIST target
   name          CDATA #REQUIRED
   type          CDATA #REQUIRED
>

<!ELEMENT status EMPTY >
<!ATTLIST status
   value         ( Certain | Tentative | Excluded | Permanent ) "Certain"
>


Description of the DTD elements

Related Topics

Click on the element name for detailed information.

parse_context

parsed_object

source

file

repos_object

to_parse

dependency

target

status

Click here to see the DTD.

Click here for an example of an XML file.


DTD element - parse_context
parse_context

Related Topics

This is the main element of the XML document and describes the context in which the parsing was performed. A parse_context can contain a zero, or one or more parsed_objects.

<!ELEMENT parse_context ( parsed_object* ) >
<!ATTLIST parse_context
   workarea_name CDATA #REQUIRED >

Attribute	Use
workarea_name	The name of the workarea used when parsing

Click here to see the DTD.

Click here for an example of an XML file showing a parse_context element.


DTD element - parsed_object
parsed_object

Related Topics

The parsed_object element is the object that was parsed. It may be a file or a structured object in the repository, such as a module, table or column.

The parsed_object must contain:

•	a source

•	zero, or one or more dependencies

•	zero, or one or more to_parse elements. Another parser is called automatically to parse these elements before the import stage.

<!ELEMENT parsed_object ( source, ( dependency | to_parse )* ) >
<!ATTLIST parsed_object
   type          CDATA #REQUIRED >

Attribute	Use
type	The long name for this type of element in the repository model. When the object is a file in the repository, this is PRIMARY_ACCESS_FILE.

Click here to see the DTD.

Click here for an example of an XML file showing a parsed_object element.


DTD element - source
source

A source element describes whether the parsed_object is a file or a repos_object, The source is is dependent on the value of parsed_object's dependency type property. There are no attributes.

<!ELEMENT source ( file | repos_object ) >

Click here to see the DTD.

Click here for an example of an XML file showing a source element.


DTD element - file
file

Related Topics

When the source is a file, this element describes the file in the local filesystem which was used as the source of the parsed_object . The file path is used to map this onto a file held in the repository.

<!ELEMENT file EMPTY >
<!ATTLIST file
   name          CDATA #REQUIRED >

Attribute	Use
name	Fully qualified name of the file in the local file system

Click here to see the DTD.

Click here for an example of an XML file showing a file as the source element.


DTD element - repos_object
repos_object

Related Topics

When the source is a repos_object, this element describes the object in the repository which was used as the source of the parsed_object . The irid and ivid - along with the type of the parsed_object - are sufficient to uniquely identify an object in the repository.

<!ELEMENT repos_object EMPTY >
<!ATTLIST repos_object
   irid          CDATA #REQUIRED
   ivid          CDATA #REQUIRED >

Attribute	Use
irid	a unique identifier for this object in the repository
ivid	an identifier for the version of this object in the repository

Click here to see the DTD.

Click here for an example of an XML file.


DTD element - to_parse
to_parse

Related Topics

The to_parse element is used internally to mark up sections of code that need parsing by a different parser. For example, if the C parser comes across some SQL code it will output a to_parse block so that the SQL parser is automatically called when the C parser has finished to handle the marked-up block.

<!ELEMENT to_parse ( PCDATA ) >
<!ATTLIST to_parse
   ext           CDATA #REQUIRED >

Attribute	Use
ext	File extension of the file that contains the data to be parsed by another parser, e.g. ".java" or ".sql".  This is used by the parser mapping file to determine which parser will be used to parse the block of text. For more information, refer to About the Parser Mapping File.
Note:	If you write your own parser, you must ensure that any data that is dumped in a <to_parse> block uses the XML notation <![CDATA[your_data]]>, where your_data is the block of data to be parsed by the other parser. This ensures that the data is not mistaken for XML.

Click here to see the DTD.

Click here for an example of an XML file.


DTD element - dependency
dependency

Related Topics

The dependency element describes the relationship between the source parsed_object and the target object.

A dependency must have a target and a status.

<!ELEMENT dependency ( target, status ) >
<!ATTLIST dependency
   type          ( Uses | Provides | CDATA ) #REQUIRED
   subtype       CDATA #IMPLIED >

Attribute	Use
type	One of: • Uses - the source has a 'uses' relationship with the target • Provides - the target is defined in the source  User-defined dependency types (CDATA) are supported but they must first be defined in the repository using the Manage User Defined Dependency Types dialog from the Dependency Manager. How
subtype	This is used to further define the dependency relationship.  User-defined subtypes are supported (CDATA), but they must first be defined in the repository using the Manage User Defined Dependency Types dialog from the Dependency Manager. How  Note that every parsed_object has one Provides Principal relationship (i.e. where the type is Provides and the subtype is Principal) which is used to identify the name of the parsed object in the repository and the Dependency Manager dialog.
Examples of dependency types and subtypes

In the case of tables and columns, when the type is Uses, the subtype is one of Select, Insert, Update or Delete to indicate the type of statement in which they are being used.

For more information, refer to About dependency types and sub types.

Click here to see the DTD.

Click here for an example of an XML file showing a target element.


DTD element - target
target

Related Topics

A target element describes the target of a dependency relationship.

<!ELEMENT target EMPTY >
<!ATTLIST target
   name          CDATA #REQUIRED
   type          CDATA #REQUIRED >

Attribute	Use
name	the name of the dependency target. This is a string generated by the parser that globally the object.
type	The type of object. This is the Global Name Domain.
If you were writing your own parser, you would:

•	define the type in the repository using Manage User Defined Global Name Domains. How

•	write the parser so that the name of the target is a string that identifies an individual instance within that global name domain. For more information, refer to About writing a parser

Click here to see the DTD.

Click here for an example of an XML file showing a target element.


DTD element - status
status

Related Topics

The status element describes the status of a dependency.

<!ELEMENT status EMPTY >
<!ATTLIST status
   value         ( Certain | Tentative | Excluded | Permanent ) "Certain" >

Attribute	Use
value	Status value. Possible values are: • Certain - a dependency is flagged as Certain when the parser is certain of the dependency relationship. • Tentative - a dependency is flagged as Tentative if the parser cannot assign it as Certain. • Excluded • Permanent
For more information, refer to About the dependency status.

Click here to see the DTD.

Click here to see and example of an XML file showing some status values.


Analyzing dependencies

Related Topics

You can start dependency analysis from the command line tool, or from the Dependency Manager dialog.

•	When you run dependency analysis from the command line tool, you have a lot of control over the objects and files that are parsed and what happens to the results of the parsing. For more information about using the dependencyanalyze command, refer to Analyzing dependencies from the command line tool.

•	When you run dependency analysis from the Dependency Manager dialog, there are fewer parameters that you can control, however the Dependency Manager allows you to select the objects or objects to analyze from the Navigator and see the results quickly. For more information about running dependency analysis from the Dependency Manager dialog, refer to Analyzing dependencies from the Dependency Manager.

In a development environment, you could run dependency analysis from the command line tool as a batch processing job at the same time every day, for example, midnight, and use the Dependency Manager dialog to perform analysis on specific areas to identify problems.


Analyzing dependencies from the command line tool

Related Topics

Running dependency analysis using the dependencyanalyze command from the command line tool gives you most control over what you analyze and what happens to the results of the analysis. The list below describes some of the options for the dependencyanalyze command. For detailed information about the dependencyanalyze command and its options, refer to the Oracle Repository Command Line Tool Guide.

Note	Only users with the repository privilege MANAGE_DEPENDENCY can use the dependencyanalyze command. For more information, refer to Repository privileges for dependency analysis.

•	You can filter the object types that are analyzed using the -ty option and specifying an element type. You can only enter one type, and the resulting output only reports on dependency instances for that type. For more information, refer to About filtering dependencies.

Tip:	You can view the types available using the following command at the JRCMD> prompt
lsfolder -ty

•	You can specify that a parser mapping file other than the default is used using the -mf option. If you do not specify the name of a file in the local filesystem, then the file referenced by the registry key \HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE\repcom61\IAMAP61 is used. For more information, refer to About the Parser Mapping File.

•	You can overwrite existing dependency information, in the dependency tables in the repository using the -rd option.

Note:	Information of existing dependencies that have had their status changed to Permanent are not overwritten. For more information, refer to About the dependency status.

•	When you are parsing C and Pro*C files, you can include a comma separated list of the filesystem directories that are required by program files using the -inc option. If spaces exist in any of the directory names, you should enclose the list in quotes, e.g. "bob.h,main headers.h,header.h". For more information, refer to C/Pro*C parser.

•	When you are parsing C and Pro*C files, you can define a comma-separated list of the NAME=VALUE pairs that are required by program files using the -def option. If spaces exist in any of the pair names, enclose the list in quotes, e.g. "one=two,three=four,five=a lot". For more information, refer to C/Pro*C parser.

•	You can filter dependencies before the are imported into the repository based on the rules in a specified file using the -fd option. If you do not specify the name of a file in the local filesystem, then the file referenced by the registry key \HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE\repcom61\IAFILTER61 is used. For more information, refer to About filtering dependencies.

•	You can use a DTD file other than the default DTD to interpret the XML file or files using the -x option. If you do not specify the name of a file in the local filesystem, then the file referenced in the registry key \HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE\repcom61\IADTD61 is used. For more information, refer to About the DTD.

•	You can choose to parse all objects, regardless of whether or not they have changed since they were last parsed. Use the -pa command to do this.


Starting the Oracle Repository Command Line Tool Guide

For more information about the the command line tool, refer to the Oracle Repository Command Line Tool Guide, either by:

•	clicking here

•	or if that does not work on your machine, by choosing Start→Programs→Oracle Repository n.n Doc→Command Line Tool Reference Guide.


Analyzing dependencies from the Dependency Manager dialog

Related Topics

You can run dependency analysis from the the Dependency Manager dialog using the Build Dependencies dialog.

Containers do not have dependencies, so if you want to analyze dependencies for a container the command is called Build Dependencies for Contents of Selection. Otherwise the command is Build Dependencies.

All users can use the Dependency Manager to examine dependency analysis results, but only users who have the correct repository privilege can perform any other actions, such as dependency purging, manually adding dependencies, running dependency analysis. For more information, refer to Repository privileges for dependency analysis.

To analyze dependencies from the Dependency Manager

1.	Select the object from the Navigator, the Summary View tab or the Detail View tab.

2.	Click [image] or

3.	If you want analyze all objects, regardless of whether or not they have changed since they were last analyzed check the Analyze up to date objects check box.

4.	If you want to overwrite existing dependency information and re-analyze the dependencies, check the Overwrite existing dependencies check box.

5.	Click Start.

6. 	If some dependencies show 'Failed' click Show console to see what caused the failure.

NOTE:	You can set the dependency manager to use a specific parser when analyzing by clicking the Options button on the Build Dependencies dialog.


Repository privileges for dependency analysis

Related Topics

All users can use the Dependency Manager to view dependency information, but only users who have the correct repository privilege can run dependency analysis either from the command line tool or the Dependency Manager, manually add dependencies, purge dependencies, and so on.

In Windows, repository privileges are set in the Repository Administration Utility, using the Repository User Properties dialog.

In UNIX, repository privileges are set using the command line tool. For more information, refer to the Oracle Repository Command Line Tool Guide.

With dependencies repository privilege not set

Users cannot create, update or delete dependency information. They can use the Dependency Manager to:

•	use the Show Dependencies dialog and view dependency information

•	use the Dependency Manager Finder to find specific objects and their dependency information

With dependencies repository privilege set

Users can create, update and delete dependency information. Therefore they can use all the functionality of:

•	the dependencyanalyze command in the command line tool.

•	the Dependency Manager, including running dependency analysis, manually adding dependencies, global name domains, dependency types, and purging unwanted dependency information.

Using the dependency repository privilege

In a development environment, you could set the repository privileges so that:

•	developers have their dependency repository privilege not set. They can examine the results of dependency analysis using the Dependency Manager, but they cannot change any of it.

•	development managers have their dependency repository privilege set so that they can create, update and delete dependency information.


Finding an object in the Dependency Manager

Related Topics

You can find an object in the Navigator using this dialog box. About

The search can be set to be case-sensitive, the wildcard character * can be used to widen the search, and you can use \ to search for objects are different levels. For example:

Enter...	To find...
Object name: ACT1 Object type: Table Definition	All tables called ACT1
Object name: ACT*	Any object at any level that begins which ACT
Object name: *\* Object type: Table Definition	All tables one level deep
To find an object:

1.	In the Dependency Manager, display the Finder by selecting File→Find...

2.	Enter the object name in the Object Name field.

3.	To narrow the search, you can select an object type from the drop-down list.

4.	If necessary, reset Match Case.

4.	Click Find. A list of the objects that match these conditions is displayed in the results list.

When you have found the object you want, you can:

•	double-click the object to make it the current selection in the Dependency Manager Navigator

•	right-click the object and select Show Dependencies. This displays the Show Dependencies dialog


About filtering dependencies

Related Topics

Dependency analysis can generate a large amount of information that can impact performance.  However you can reduce this by using a dependency filter file.  Dependency filter files are used when the dependency manager is invoked through the repository object navigator.  They can also be used when dependency analysis is run from the command line, by using the -fd option with the dependencyanalyze command.  (For more information about using the dependencyanalyze command, refer to the Oracle Repository Command Line Tool Guide.)

Note:	This type of filtering, which reduces the amount of dependency information that is imported into the repository, should not be confused with the filter in the Dependency Manager that reduces the amount of information that is displayed in the Dependency Manager. For more information, refer to Dependency Manager summary filter.

The filter file shipped with Oracle Designer is \JAVA\iafilters.fil, and you can copy and edit it to add new conditions on which filtering should be performed. How

Changing the criteria on which to filter

In the filter file, you can enter criteria in the following format to determine the dependencies which are not recorded in the XML output, and therefore are not imported into the repository:

<language>, <type>, <name>

where:

<language>	is the file extension associated with a particular language in the parser mapping file. About
<type>	is the type associated with the global name
<name>	is the global name
The wildcard * can be used, and spaces are ignored. Each set of <language>, <type>, <name> must appear on a new line.

For example:

c, C_FUNCTION, max	ignore C functions called 'max'
*, *, max	ignore anything called 'max'
sql, *, dual	ignore anything in SQL called 'dual'
*, DB_COLUMN, created_date	ignore any columns called 'created_date'
Inheriting filters for languages

In the filter file, you can specify that one language can inherit filters from one or more other languages using the following format:

inherit <language> from <language>\n

For example:

inherit pc from c

inherit pc from sql

inherit odf from sql


Adding new conditions to filter dependencies during parsing

Related Topics

You can add your own conditions to a filter file that is referred to when dependency analysis is run from the command line so that certain types of dependency are not added to the repository. About

To add new filtering conditions

1.	If you have not already done so, make a copy of the dependency filter file, iafilters.fil. This is located in the \repadm61\java folder.

2.	Using Notepad, or a similar text editor, open the file iafilters.fil.

3.	Edit it to add the appropriate new conditions.

4.	Save the dependency filter file. Use the -fd option with the dependencyanalyze command line utility to call the dependency filter file. About


Displaying dependency object properties

Related Topics

The Dependency Properties dialog displays the properties of the dependency that you have selected.

To open the Dependency Instance Viewer dialog:

1.	In either the Summary View pane or the Detail View pane, select the object that you are interested in.

2.	Choose Results→View Dependency Instances.

Tip:	You can also open the Dependency Property dialog by clicking


Opening the Dependency Manager from the Repository Object Navigator
Opening the Dependency Manager

Related Topics

You can open the Dependency Manager from the Repository Object Navigator, the Design Editor or from the Windows Start menu.

To open the Dependency Manager from the Repository Object Navigator:

•	Choose Tools→Dependency Manager.

To open the Dependency Manager from the Design Editor:

•	Choose Tools→Dependency Manager.

To open the Dependency Manager from Windows Start menu:

1.	From the Windows Start menu, choose Programs→Oracle Designer 6.i→Repository Dependency Manager.

2.	In the Connect Dialog, enter the username, password and database alias (connect string) that you normally use to connect to the repository.


Using the Summary Filter

Related Topics

You can use the Summary Filter to reduce the amount of information displayed in the Summary View pane of the Dependency Manager.

To limit dependency information in the Summary View pane

1.	In the Dependency Manager, choose Results→Summary Filter.

2.	Select one or more objects types from the list in the left column.

3.	Click > to move the selected object types to the right hand column.

4.	Click Update. The Summary View pane changes so that the object types in the right-hand column are not displayed.

5.	Click Finish to close the Summary Filter.


About dependency purging

Related Topics

You should purge dependency information from the repository on a regular basis to prevent performance problems. Dependency purging is run in the context of a workarea and the version histories of objects wthin the workarea are used to identify the dependencies should be purged. How

You select the dependency information to keep by specifying:

•	one or more branches. For example, you could keep the dependency information for the latest versions on the main branch.

•	one or more configurations. For example, you could keep dependency information for object versions in a particular configuration.

Dependencies for all other versions of objects in the workarea are purged.

Tip	To purge all dependency information, create a purging policy which does not specify any branches or configurations.


Purging dependency information from the repository

Related Topics

You should purge dependency information from the repository on a regular basis to prevent performance problems.

To define a new dependency purging policy

1.	From the Properties tab, click Add at the bottom of the dialog. The cursor moves to the Dependency Purging Policy name field. Enter a name for the purging policy.

2.	To select a branch to specify dependency information to keep, click Add in the Branch Purging pane. Click ... in the Branch field, and select the branch from the list displayed. You can add more than one branch.

3.	To select a configuration to specify dependency information to keep, click Add in the Conguration Purging Policy pane. Click on ... in the Configuration field and select a configuration from the list displayed. You can add more than one configuration.

4.	Click OK. The dependency purging policy is saved.

To run dependency purging

1.	From the Run tab, click Choose and select from the list of defined dependency purging policies. Details of the policy are displayed.

2.	If this is the policy you want, click Apply, otherwise select another policy.

3.	Click OK.


Requerying the repository (Dependency Manager)
Requerying the repository

Related Topics

Requerying the repository redisplays the contents of the navigator to show any changes in the repository since this session was started. As a result objects may be added to, updated in, or removed from, the set of objects visible in the navigator.

To requery the navigator

•	In the Dependency Manager, select File → Requery.


Identifying out of workarea objects (Dependency Manager)
Identifying out of workarea objects

Related Topics

The Dependency Manager helps you to identify uses objects that are in the repository but not in the current workarea. It does this by tracking the configurations that contain the most meaningful groupings of these objects.

You can select the objects to search for from either the Detail View tab or the Summary tab, provided that you have used Include out of workarea in the Show Dependencies dialog.

To identify out of workarea objects

1.	In the Detail View tab or the Summary tab of the Dependency Manager, select the object or objects for which you want to search.

Tip	You can reduce the time this takes to run by just selecting objects that you are confident about.

2.	Right click and select Search on out of workarea...

3.	The configurations that match the objects you are looking for are displayed. Double-click on a configuration to display details.


About parsers

Related Topics

A parser is a software component that examines an object and derives meaningful data from it. A number of pre-defined parsers are supplied with Oracle Repository, and these are described below.

In practice, you will probably find that you need to write your own parser to suit your requirements. This is described in Writing a parser.

Click on one of the links below to see:

•	a description of the supplied parser

•	the dependencies that this parser identifies (i.e. where the dependency type = Uses)

•	objects that are provided that this parser recognizes (i.e. where the dependency type = Provides)

•	other parsers called by the selected parser

•	any other information you might need to ensure that the parser runs correctly

C and Pro*C parser which parses C and Pro*C files, extracting dependencies such as called functions and included files.

Java parser which parses Java code for objects such as called functions, and Java tables and columns.

Oracle Forms Object Library parser which parses .olb files.

Oracle Forms Form Module parser which parses .fmb files.

Oracle Forms Menu Module parser which parses .mmb files.

Oracle Reports Report Module parser which parses .rdf files generated by Report Generator.

PL/SQL Library parser which parses PL/SQL Library objects.

PL/SQL parser which parses PL/SQL code for objects such as package globals, user exits and called functions.

SQL parser which parses SQL code for objects such as SQL tables and columns, and called functions.

Structured parser which parses structured objects such as database tables, columns and constraints.


C/Pro*C parser

Related Topics

This parses C and Pro*C files, extracting dependencies such as called functions and included files, and, in Pro*C files, SQL dependencies.

Prerequisites

•	The compiler you are using must be in your path.

•	The file must compile correctly first. If there are errors in the code, the parser will fail.

Dependency Analysis using the Command Line Tool

When you run dependency analysis from the command line, you can pass in lists of directories to search for #include files using the option -inc, and include any #define variables using the option -def. This information is passed to the preprocessor. For more information about using the dependencyanalyze command, refer to the Oracle Repository Command Line Tool Guide.

C/Pro*C parser dependencies

Provides objects

Called parsers


C/Pro*C parser - dependency objects

Related Topics

This is a list of the dependencies, i.e. where the type=Uses, that the supplied C/Pro*C parser detects within C or Pro*C code, including the dependent objects and their source (the location of dependency within a C or Pro*C source file).

Dependency Object	Dependency Source	Name Format	Global name domain
C Function Call	• Any function body • Variable initializer • Hash Define • Pointer to function • Return Type • Parameter	Function	C_FUNCTION
C Header File	• Source file	Header file name without path	C_INCLUDE
A function call can be made from any block of C source code within a function body. It may be a direct call or an indirect one through a pointer or #define. This is recorded as a Uses relationship and the global name is of the format "file_name.function_name(param_type1, param_type2, ...)" with the type C_FUNCTION.


C/Pro*C parser - provides objects

Related Topics

This is a list of the provides objects, i.e. where the type=Provides, that the supplied C/Pro*C parser detects within C or Pro*C code.

Provides Object	Where Defined	Name Format	Global name domain
C Function	• Header file • Source file	Function	C_FUNCTION


C/Pro*C parser - other parsers called

Related Topics

Any PL/SQL present will be parsed by the PL/SQL parser which is called from the C/Pro*C parser.

Language	Used in
PL/SQL	Pro*C block of code in a function.
SQL	A Pro*C DML or DDL statement in a function, for example: DB_DATABASE DB_RELATION DB_COLUMN


Java parser

Related Topics

This parses Java code for objects such as called functions, and Java tables and columns.

Prerequisites

Java files have to be parsed in an environment that can run the Java application, so:

•	the environment variable CLASSPATH must be set up with references to all the .class files of any dependencies present.

•	all the Java source code should be built and available on the CLASSPATH.

To set up the CLASSPATH variable using the Dependency Manager:

1. From the Dependency Manager select, Navigator → Build Dependencies

2. From the Build dependencies dialog box, click the options button

3. In the Build dependency options dialog box, enter the CLASSPATH in the Classpath field

To set up the CLASSPATH variable using the Command Line Tool:

•	From the Command Line Tool include the -cpth option when using the dependencyanalyze command. For more information about using the dependencyanalyze command, refer to the Oracle Repository Command Line Tool Guide.

Notes:	The parser can parse files for versions of JDK 1.0.x to 1.1.x.
.SQLJ files are treated the same way as .java files

Java dependencies

Provides objects

Called parsers


Java parser - dependency objects

Related Topics

This is a list of the dependencies, i.e. where the type=Uses, that the supplied Java parser detects within Java code, including the dependent objects and their source.

Dependency Object	Dependency Source	Name Format	Global name domain
Package	.java file	package_name	JAVA_PACKAGE
Class	Package	package_name.class_name	JAVA_CLASS
Nested top-level class or member class	Class	package_name.class_name$inner_class($inner_class)*	JAVA_CLASS
Nested top-level class or member class	Interface	package_name.interface_name$inner_class($inner_class)*	JAVA_CLASS
Local class	Method	package_name.[interface|class]_name#method_name$local_class	JAVA_CLASS
Interface	Package	package_name.interface_name	JAVA_INTERFACE
Nested top-level interface	Interface	package_name.interface_name$inner_interface($inner_interface)*	JAVA_INTERFACE
Nested top-level interface	Class	package_name.interface_name$class_interface($inner_interface)*	JAVA_INTERFACE
Local interface	Method	package_name.[interface|class]_name#method_name$local_interface	JAVA_INTERFACE


Java parser - provides objects

Related Topics

This is a list of the provides objects, i.e. where the type=Provides, that the supplied Java parser detects within Java code.

Provides Object	Where Defined	Name Format	Global name domain
Class	Package	package_name.class_name	JAVA_CLASS
Interface	Package	package_name.interface_name	JAVA_INTERFACE
Class	Class	package_name.class_name$inner_class($inner_class)*	JAVA_CLASS
Interface	Class	package_name.class_name$inner_interface($inner_interface)*	JAVA_INTERFACE
Class	Interface	package_name.interface_name$inner_class($inner_class)*	JAVA_CLASS
Interface	Interface	package_name.interface_name$inner_interface($inner_interface)*	JAVA_INTERFACE
Method	Class	package_name.class_name#method_name	JAVA_METHOD
Method	Interface	package_name.interface_name'method_name	JAVA_METHOD
Field	Class	package_name.class_name#field_name[type]	JAVA_FIELD
Field	Interface	package_name.interface_name#field_name[type]	JAVA_FIELD
Class	Method	package_name.[interface|class]_name#method_name$local_class	JAVA_CLASS
Interface	Method	package_name.[interface|class]_name#method_name$local_interface	JAVA_INTERFACE
Field	Method	package_name.[interface|class]_name#method_name$field_name	JAVA_FIELD


Java parser - other parsers called

Related Topics

Any .SQLJ files in the Java code will have their SQL code parsed by the SQL parser.


Oracle Forms Form Module parser

Related Topics

This parses .mmb files.

Prerequisites

•	Oracle Forms has to be installed.

•	If the path of any attached libraries has not been hard-coded in the form, their location must be that specified by the Oracle Forms registry keys FORMSnn_PATH (where nn relates to the release number) or the ORACLE_PATH.

•	When analyzing files that use object libraries,  the libraries must be present in the path specified in the Oracle Forms registry keys.

Oracle Forms Form Module parser dependencies

Provides objects

Called parsers

Points to consider


Oracle Forms Form Module parser - dependency objects

Related Topics

This is a list of the dependencies, i.e. where the type=Uses, that the supplied Oracle Forms form module parser detects, including the dependent objects and their source.

Dependency Object	Dependency Source	Name Format	Global name domain
Object Library Object	Subclass information of Forms object	ObjectLibrary.Object	OLB_<OBJECTTYPE>
Forms Object	Subclass information of Forms object	FormModule.Object	FORMS_<OBJECTTYPE>
PL/SQL Library	Library attached to form module	LibraryFile	PRIMARY_ACCESS_FILE
Database Subroutine	Block definition (block based on procedure datasource/datatarget)	Subroutine	PLSQL_MODULE_SUBROUTINE
Database Relation (table/view/materialized view)	Block Definition (block based on table - datasource/datatarget)	Relation	RELATION_DEFINITION
Java Bean/Pluggable Component	Item Implementation Class property	JavaClass	JAVA_TYPE
Database Column	Item Definition (block based on table - datasource/datatarget)	Relation.Column	COLUMN
Menu File (.MMX)	Form Module Definition menu module property, providing this is not set to 'DEFAULT', 'DEFAULT&SMARTBAR' or 'NULL'	MenuFile	PRIMARY_ACCESS_FILE
Menu Module	Form Module Definition, providing a menu file has been specified	MenuFile.MenuModule	MENU_MENU_MODULE
Icon File (.ICO)	Popup Menu Item icon property Window icon property	IconFile	PRIMARY_ACCESS_FILE
Oracle Reports Report	Report Definition	ReportFile	PRIMARY_ACCESS_FILE


This can be any defined Forms object, e.g. FORMS_BLOCK, except FORMS_FORM_MODULE.


Oracle Forms Form Module parser - provides objects

Related Topics

This is a list of the provides objects, i.e. where the type=Provides, that the supplied Oracle Forms form module parser detects.

Provides Object	Where Defined	Name Format	Global name domain
Alert	Form Module	FormModule.Alert	FORMS_ALERT
Block	Form Module	FormModule.Block	FORMS_BLOCK
Canvas	Form Module	FormModule.Canvas	FORMS_CANVAS
Editor	Form Module	FormModule.Editor	FORMS_EDITOR
Graphic	Canvas	FormModule.Canvas.Graphic	FORMS_GRAPHIC
Form Module	.FMB File	FormModule	FORMS_FORM_MODULE
Form Parameter	Form Module	FormModule.FormParameter	FORMS_FORM_PARAMETER
Item	Block	FormModule.Block.Item	FORMS_ITEM
LOV	Form Module	FormModule.LOV	FORMS_LOV
Popup Menu	Form Module	FormModule.PopupMenu	FORMS_MENU
Popup Menu Item	Popup Menu	FormModule.PopupMenu.MenuItem	FORMS_MENU_ITEM
Object Group	Form Module	FormModule.ObjectGroup	FORMS_OBJECT_GROUP
Program Unit Package Body	Form Module	FormModule.ProgramUnit	FORMS_PROGRAM_UNIT_BODY
Program Unit Package Spec	Form Module	FormModule.ProgramUnit	FORMS_PROGRAM_UNIT_SPEC
Program Unit Procedure	Form Module	FormModule.ProgramUnit	FORMS_PROGRAM_UNIT_PROC
Program Unit Function	Form Module	FormModule.ProgramUnit	FORMS_PROGRAM_UNIT_FUNC
Property Class	Form Module	FormModule.PropertyClass	FORMS_PROPERTY_CLASS
Record Group	Form Module	FormModule.RecordGroup	FORMS_RECORD_GROUP
Report	Form Module	FormModule.Report	FORMS_REPORT
Tab Page	Canvas	FormModule.Canvas.TabPage	FORMS_TAB_PAGE
Trigger	Form Module Block Item	FormModule.Trigger FormModule.Block.Trigger FormModule.Block.Item.Trigger	FORMS_TRIGGER
Visual Attribute	Form Module	FormModule.VisualAttribute	FORMS_VISUAL_ATTRIBUTE
Window	Form Module	FormModule.Window	FORMS_WINDOW


Oracle Forms Form Module parser - other parsers called

Related Topics

The following programming languages used by Oracle Forms are not directly analyzed by the Forms parser. Instead, these are parsed by the appropriate parser called by the Forms parser.

Language	Where Used
PL/SQL	• Triggers • Program Units • Item Formula Text (if calculation mode is Formula) • Popup Menu Item Code (if menu command type is PL/SQL)
SQL	• Record Group Query • Block Definition — Optimizer Hint — Order by Clause — Where Clause


Oracle Forms Form Module parser- points to consider

Related Topics

Object Groups

When you subclass an object group from one form into another, the child objects of the group are automatically expanded into the destination form. A dependency is recorded on the object group in the source form, but not the individual objects in the object group. If the object group is changed in the source form, for example if a child object is removed, then the destination is changed automatically. This means that the dependency is just on the object group and there is no dependency on the individual child objects.

Attached Libraries

When a library that has attached libraries is attached to a form, the libraries attached to the library are automatically expanded to the root level and a dependency is recorded on all the libraries.

Blocks based on Procedures

Blocks that are based on procedures will have a dependency recorded for the subroutine specified. No effort is made to work out what table and columns the block is based on as all of this information is held in the subroutine.


Oracle Forms Menu Module parser

Related Topics

This parses .mmb files.

Prerequisites

•	Oracle Forms has to be installed before you can parse Oracle Forms menus.

•	If the path of any attached libraries has not been hard-coded in the form, their location must be that specified by the Oracle Forms registry keys FORMSnn_PATH (where nn relates to the release number) or the ORACLE_PATH.

•	When analyzing files that use object libraries, the libraries must be present in the path specified in the Oracle Forms registry keys.

Oracle Forms Menu Module parser dependencies

Provides objects

Called parsers


Oracle Forms Menu Module parser - dependency objects

Related Topics

This is a list of the dependencies, i.e. where the type=Uses, that the supplied Oracle Forms menu module parser detects, including the dependent objects and their source.

Dependency Object	Dependency Source	Name Format	Global name domain
Icon File (.ICO)	Menu Item icon property	IconFile	PRIMARY_ACCESS_FILE
Object Library Object	Subclass information of menu object	ObjectLibrary.Object	OLB_<OBJECTTYPE>
Menu Object	Subclass information of menu object	MenuModule.Object	MENU_<OBJECTTYPE>


This can be any defined Menu object, e.g. MENU_BLOCK, except MENUS_MENU_MODULE.


Oracle Forms Menu Module parser - provides objects

Related Topics

This is a list of the provides objects, i.e. where the type=Provides, that the supplied Oracle Forms menu module parser detects.

Provides Object	Where Defined	Name Format	Global name domain
Object Group	Menu Module	MenuModule.ObjectGroup	MENU_OBJECT_GROUP
Menu Module	.MMB File	MenuModule	MENU_MENU_MODULE
Menu	Menu Module	MenuModule.Menu	MENU_MENU
Menu Item	Menu	MenuModule.MenuItem	MENU_MENU_ITEM
Menu Parameter	Menu Module	Menu.MenuParameter	MENU_MENU_PARAMETER
Program Unit Package Body	Menu Module	MenuModule.ProgramUnit	MENU_PROGRAM_UNIT_BODY
Program Unit Package Spec	Menu Module	MenuModule.ProgramUnit	MENU_PROGRAM_UNIT_SPEC
Program Unit Procedure	Menu Module	MenuModule.ProgramUnit	MENU_PROGRAM_UNIT_PROC
Program Unit Function	Menu Module	MenuModule.ProgramUnit	MENU_PROGRAM_UNIT_FUNC
Property Class	Menu Module	MenuModule.PropertyClass	MENU_PROPERTY_CLASS
Visual Attribute	Menu Module	MenuModule.VisualAttribute	MENU_VISUAL_ATTRIBUTE


Oracle Forms Menu Module parser - other parsers called

Related Topics

This is a list of programming languages used by menus that are analyzed by a parser called from the Oracle Forms menu parser.

Language	Used in
PL/SQL	• Program Units • Menu Module Startup Code • Menu Item Code (if menu command type is PL/SQL)


Oracle Forms Object Library parser

Related Topics

This parses .olb files.

Prerequisites

Oracle Forms has to be installed before you can parse object libraries

Oracle Forms Object Library dependencies

Provides objects

Called parsers

Points to consider


Oracle Forms Object Library parser - dependency objects

Related Topics

This is a list of the dependencies, i.e. where the type=Uses, that the supplied Oracle Forms object library parser detects, including the dependent objects and their source.

Dependency Object	Dependency Source	Name Format	Global name domain
Database Subroutine	Block definition (block based on procedure - datasource/datatarget)	Subroutine	PLSQL_MODULE_SUBROUTINE
Database Relation (table/view/materialized view)	Block Definition (block based on table - datasource/datatarget)	Relation	TAB
Java Bean/Pluggable Component	Item Implementation Class property	Java Class	JAVA_CLASS
Database Column	Item Definition (block based on table - datasource/datatarget)	Relation.Column	COL
Menu File (.MMX)	Form Module Definition menu module property, providing this is not set to "DEFAULT" "DEFAULT&SMARTBAR" or "NULL"	MenuFile	REP_FILE
Menu Module	Form Module Definition, providing a menu file has been specified	MenuFile.MenuModule	MENU_MENU_MODULE
Icon File (.ICO)	Popup Menu Item icon property Window icon property	IconFile	REP_FILE


Oracle Forms Object Library parser - provides objects

Related Topics

This is a list of the provides objects, i.e. where the type=Provides, that the supplied Oracle Forms object library parser detects.

Provides Object	Where Defined	Name Format	Global name domain
Alert	Object Library	ObjectLibrary.Alert	OLB_ALERT
Block	Object Library	ObjectLibrary.Block	OLB_BLOCK
Canvas	Object Library	ObjectLibrary.Canvas	OLB_CANVAS
Editor	Object Library	ObjectLibrary.Editor	OLB_EDITOR
Form Parameter	Object Library	ObjectLibrary.FormParameter	OLB_FORM_PARAMETER
Item	Object Library	ObjectLibrary.Item	OLB_ITEM
LOV	Object Library	ObjectLibrary.LOV	OLB_LOV
Menu	Object Library	ObjectLibrary.Menu	OLB_MENU
Menu Item	Object Library	ObjectLibrary.MenuItem	OLB_MENU_ITEM
Menu Parameter	Object Library	ObjectLibrary.MenuParameter	OLB_MENU_PARAMETER
Object Group	Object Library	ObjectLibrary.ObjectGroup	OLB_OBJECT_GROUP
Object Library Module	.OLB File	ObjectLibrary	OLB_OBJECT_LIBRARY
Program Unit Package Body	Object Library	ObjectLibrary.ProgramUnit	OLB_PROGRAM_UNIT_BODY
Program Unit Package Spec	Object Library	ObjectLibrary.ProgramUnit	OLB_PROGRAM_UNIT_SPEC
Program Unit Procedure	Object Library	ObjectLibrary.ProgramUnit	OLB_PROGRAM_UNIT_PROC
Program Unit Function	Object Library	ObjectLibrary.ProgramUnit	OLB_PROGRAM_UNIT_FUNC
Property Class	Object Library	ObjectLibrary.PropertyClass	OLB_PROPERTY_CLASS
Record Group	Object Library	ObjectLibrary.RecordGroup	OLB_RECORD_GROUP
Tab Page	Object Library	ObjectLibrary.TabPage	OLB_TAB_PAGE
Trigger	Object Library	ObjectLibary.Trigger	OLB_TRIGGER
Visual Attribute	Object Library	ObjectLibrary.VisualAttribute	OLB_VISUAL_ATTRIBUTE
Window	Object Library	ObjectLibrary.Window	OLB_WINDOW


Oracle Forms Object Library parser - other parsers called

Related Topics

The following programming languages used by object libraries are not directly analyzed by the Object Library parser. Instead, these will be parsed by the appropriate parser called by the Object Library parser.

Language	Where Used
PL/SQL	• Triggers • Program Units • Item Formula Text (if the calculation mode is Formula) • Popup Menu Item Code (if the menu command type is PL/SQL)
SQL	• Record Group Query • Block Definition • Optimizer Hint • Order By Clause • Where Clause


Oracle Forms Object Library parser - points to consider

Related Topics

Blocks based on Procedures

Blocks that are based on procedures will have a dependency recorded for the subroutine specified. No effort is made to work out what table and columns the block is based on as all of this information is held in the subroutine. If the subroutine is held in the repository and is parsed this information will be available to the user.


Oracle Reports Report Module parser

Related Topics

This parses .rdf files generated by Report Generator.

Prerequisites

•	Oracle Reports has to be installed.

•	The location of any attached libraries must be that specified by the Oracle Forms registry keys FORMSnn_PATH (where nn relates to the release number) or the ORACLE_PATH.

Oracle Reports Report Module dependencies

Provides objects

Called parsers


Oracle Reports Report Module parser - dependency objects

Related Topics

This is a list of the dependencies, i.e. where the type=Uses, that the supplied Oracle Reports report module parser detects, including the dependent objects and their source.

Dependency Object	Dependency Source	Name Format	Global name domain
PL/SQL Library	Library attached to Report Module	LibraryFile	REPOS_FILE
Database Relation (table/view/materialized view)	Query • SQL • Ref Cursor • Parameter List of Values	Relation	TAB
Database Column	Database Column in Query	Relation.Column	COL
Oracle Reports Report	Called from PL/SQL	ReportFile	REPOS_FILE


Oracle Reports Report Module parser - provides objects

Related Topics

This is a list of the provides objects, i.e. where the type=Provides, that the supplied Oracle Reports report module parser detects.

Provides Object	Where Defined	Name Format	Global name domain
PL/SQL Library	Library attached to Report Module	LibraryFile	REPOS_FILE
Database Relation (table/view/materialized view)	Query • SQL • Ref Cursor • Parameter List of Values	Relation	TAB
Database Column	Database Column in Query	Relation.Column	COL


Oracle Reports Report Module parser- other parsers called

Related Topics

Any SQL or PL/SQL used in an Oracle Reports Report is parsed by the appropriate parser which is called by the Oracle Reports Report Module parser.

Language	Where Used
PL/SQL	Triggers Program Units Formula Column
SQL	Query Definition Parameter List of Views


PL/SQL parser

Related Topics

This parses PL/SQL code for objects such as package globals, user exits and called functions.

Notes

Schema prefixes are not added to the dependency object name formats because the same object could be referenced in one place using the schema as part of the reference, and in another place without the referencing the schema.

When a function is called without any parameters, it is impossible to be completely sure whether it is a function call or a variable. In this case the dependency status is Tentative.

PL/SQL dependencies

Provides objects


PL/SQL parser - dependency objects

Related Topics

This is a list of the dependencies, i.e. where the type=Uses, that the supplied PL/SQL parser detects, including the dependent objects and their source.

Dependency Object	Dependency Description	Name Format	Global name domain
Database Relation	These can be referenced in DML statements that appear in the PL/SQL.	Relation	TAB
Database Column	These can be referenced in DML statements that appear in the PL/SQL.	Relation.Column	COLUMN
Subroutine	Functions and procedures can be called from within PL/SQL, these functions/procedures can exist on the server or the client depending on the location of the PL/SQL. For example a trigger in Forms can have PL/SQL that calls a program unit in the same form.	Package.Subroutine In the case of Forms, if a program unit is defined in a subroutine called, e.g. MYFUNC, the name generated is <FORMNAME>.MYFUNC	PLSQL_MODULE_SUBROUTINE
Package Type	PL/SQL variables can be declared to be of a user type that is defined in a package	Package.Type	PLSQL_MODULE_PACKAGE_TYPE
Package Variable	Package variables can be referenced directly by other PL/SQL subroutines/packages	Package.Variable	PLSQL_MODULE_PACKAGE_VARIABLE
Package Cursor	Package cursors can be referenced directly by other PL/SQL subroutines/packages	Package.Cursor	PLSQL_MODULE_PACKAGE_CURSOR
Database Link	DML statements can access specific objects via database links	DatabaseLink	DATABASE_LINK
Relation Index	Optimizer hints used in DML statements can reference relation indexes	Relation.Index	RIN
Sequence	Sequences are used to get NEXTVAL and CURRVAL values	Sequence	SEQUENCE


PL/SQL parser - provides objects

Related Topics

This is a list of the provides objects, i.e. where the type=Provides, that the supplied PL/SQL parser detects.

Provides Object	Where Defined	Name Format	Global name domain
Package Body	The PL/SQL being analyzed could provide a package body.	PackageBody	PLSQL_MODULE_PACKAGE_BODY
Package Specification	The PL/SQL being analyzed could provide a package body.	PackageSpec	PLSQL_MODULE_PACKAGE_SPEC
Subroutine	The PL/SQL being analyzed could provide a subroutine. The subroutine could also belong to a package definition.	Subroutine Package.Subroutine	PLSQL_MODULE_SUBROUTINE
Package Subtype	Packages can provide "public" subtypes.	Package.Subtype	PLSQL_MODULE_PACKAGE_SUBTYPE
Package Variable	Packages can provide "public" variables.	Package.Variable	PLSQL_MODULE_PACKAGE_VARIABLE
Package Cursor	Packages can provide "public" cursors.	Package.Cursor	PLSQL_MODULE_PACKAGE_CURSOR
Package Type	Packages can provide "public" types.	Package.Type	PLSQL_MODULE_PACKAGE_TYPE


PL/SQL Library parser

Related Topics

This parses PL/SQL Library objects.

Prerequisites

•	The Oracle Forms has to be installed before you can parse PL/SQL libraries.

•	The libraries have to be present in the path specified in the Oracle Forms registry keys.

PL/SQL Library dependencies

Provides objects

Called parsers


PL/SQL Library parser - dependency objects

Related Topics

This is a list of the dependencies, i.e. where the type=Uses, that the supplied PL/SQL library parser detects, including the dependent objects and their source.

Dependency Object	Dependency Source	Name Format	Global name domain
PL/SQL Library Object	Library attachment	Library	REPOS_FILE


PL/SQL Library parser - provides objects

Related Topics

This is a list of the provides objects, i.e. where the type=Provides, that the supplied PL/SQL Library parser detects.

Provides Object	Where Defined	Name Format	Global name domain
Library Module	.PLL file (binary) .PLD file (text)	Library	LIBRARY_LIBRARY_MODULE


PL/SQL Library parser - other parsers called

Related Topics

Any PL/SQL is parsed by the PL/SQL parser which is called by the PL/SQL Library parser.

Language	Where Used
PL/SQL	Program Units


SQL parser

Related Topics

This parses SQL code for objects such as SQL tables and columns, and called functions.

SQL dependencies

Provides objects

Other parsers called


SQL parser - dependency objects

Related Topics

This is a list of the dependencies, i.e. where the type=Uses, that the supplied SQL parser detects, including the dependent objects and their source. For further information about the many ways in which these dependency objects can be used, refer to the Oracle8 SQL Reference manuals.

Dependency Object	Dependency Description
Column	These can be referenced in various SQL statements. The Insert/Update/Delete/Select usages are recorded.
Constraint	These can be referenced in various SQL statements.
Cluster	Can be used in Optimizer hints and CREATE TABLE statements.
Database Link	These can be referenced in various SQL statements
Function	Functions can be called from within SQL, these functions/procedures can exist on the server or the client depending on the location of the PL/SQL. For example a SQL statement used in Forms can call a program unit in the same form.
Index	Can be used in Optimizer hints and when creating constraints.
Library	Used in CREATE FUNCTION statement.
Package	SQL can reference package instances; calling functions and procedures as well as accessing variables defined in the package.
Partition	These can be referenced in various SQL statements.
Procedure	Functions and procedures can be called from within SQL, these functions/procedures can exist on the server on the client depending on the location of the PL/SQL. For example a SQL statement used in Forms can call a program unit in the same form.
Role	Used in CREATE ROLE statement to create nested roles.
Sequence	These can be referenced in various SQL statements.
Materialized View	These can be referenced in various SQL statements. The Insert/Update/Delete/Select usages should also be recorded on the dependency.
Synonym	These can be referenced in various SQL statements, where other objects can be referenced by synonyms.
Table	These can be referenced in various SQL statements. The Insert/Update/Delete/Select usages should also be recorded on the dependency.
Tablespace	Can be used in create statements.
Trigger	Can be used in create table/view/materialized view statements.
User	These can be referenced in various SQL statements.
View	These can be referenced in various SQL statements. The Insert/Update/Delete/Select usages are also recorded.


SQL parser - provides objects

Related Topics

This is a list of the provides objects, i.e. where the type=Provides, that the supplied SQL parser detects.

For SQL objects, available subtypes are Create, Alter, Drop, and this table shows which is available for each type of object.

Provides Object	Created?	Altered?	Dropped?
Column
Constraint
Cluster
Context
Control File
Database
Database Link
Dimension
Directory
Function
Index
Index Type
Library
Materialized View
Materialized View Log
Outline
Package
Package Body
Partition
Procedure
Profile
Role
Rollback Segment
Schema
Sequence
Synonym
Table
Tablespace
Trigger
User (Same as schema)
View


SQL parser- other parsers called

Related Topics

CREATE JAVA statements are parsed by the Java parser.


Structured parser

Related Topics

This parses structured objects such as database tables, columns and constraints in the repository.

Prerequisites

•	Before parsing a module with a language "Oracle Forms", Oracle Forms has to be installed.

•	Before parsing a module with a language "Oracle Reports", Oracle Reports has to be installed.

Structured parser dependencies

Provides objects

Called parsers

Points to consider


Structured parser - dependency objects

Related Topics

This is a list of the dependencies, i.e. where the type=Uses, that the supplied structured parser detects, including the dependent objects and their source.

Dependency Object	Dependency Source	Name Format	Global name domain
Relation	General Module Re-usable Module Component Re-usable LOV View Definition Materialized View Definition Foreign Key Constraint	Relation	RELATION_DEFINITION
Column	General Module Re-usable Module Component Re-usable LOV View Definition Materialized View Definition Foreign Key Constraint	Relation.Column	COLUMN
Re-usable Module Component	General Module	Re-usable Module Component	REUSABLE_MCO
Re-usable List Of Values	General Module	Re-usable List of Values	REUSABLE_LOV
Sequence	Column	Sequence	SEQUENCE
Domain	Column	Domain	DOMAIN


Structured parser - provides objects

Related Topics

This is a list of the provides objects, i.e. where the type=Provides, that the supplied structured parser detects.

Global name domain	Global qualified name format	Global base name
AL_EVENT		application logic event
CCO	relation_definition	constraint
CIN	cluster	cluster_index
COL	relation_definition	column
DBU	database	database_user
DCO	relation_definition	constraint
DOM		domain
DSY	table_definition view_definition snapshot_definition	database_synonym
FCO	relation_definition	constraint
GEM		general_module
GRP	database	role
OCL		cluster
ORS	database	rollback_segment
OSQ		sequence
OTB	database	tablespace
PCO	relation_definition	constraint
PLM		plsql_module
PLSQL_MODULE_PACKAGE		package
PLSQL_MODULE_SUBROUTINE		subroutine
PLSQL_MODULE_TRIGGER	package	trigger
PLSQL_MODULE_CURSOR	package	cursor
RLV		module_unit
RMC		module_unit
RIN	table_definition snapshot_definition	relation_index
TAB		table_definition view_definition snapshot_definition
TBP	database.database_user. table_implementation	table_partition
TRG	table_definition view_definition	database_trigger
UCO	relation_definition	constraint


Structured parser - other parsers called

Related Topics

The table below shows the Repository or multi-line text properties used by a given language and the Repository element types on which it is defined. The last column shows the language in which the multi-line text will be parsed.

User application logic is code that is entered into Oracle Repository in the form of PL/SQL. It can either be a named routine or an event code segment. A named routine can be a package body, package specification, procedure or a function.

An event code segment is code that gets generated into a client-side Form or Report event such as WHEN_NEW_FORM_INSTANCE or BeforeReportTrigger.

Module Language	Repository Element	Repository Property/ Multi-line Text Type	Description	Parse Language
Oracle Forms	GENERAL_MODULE	ALCODE	Application Logic	PL/SQL
	MODULE_COMPONENT	ALCODE	Application Logic	PL/SQL
	ACTION_ITEM	ALCODE	Application Logic	PL/SQL
	MODULE_DETAIL_TABLE_USAGE	CDWHCL	Where Clause of Query	SQL
		LVWHCL	Lookup Validation WHERE Clause	SQL
	ITEM	CDIPLS	PL/SQL Block	PL/SQL
		DEFAULT_VALUE	Default Value	PL/SQL
		DEFAULT_VALUE_TYPE	Literal, Server Function, Client Function
		ALCODE	Application Logic	PL/SQL
	UNBOUND_ITEM	CDEXPR	Derivation Text	SQL or PL/SQL
	CUSTOM_LINK	JNCOND	Join Condition	SQL
	DOMAIN_CONSTRAINT	WHERECL	Where Condition	SQL
Oracle Reports	GENERAL_MODULE	ALCODE	Application Logic	PL/SQL
	MODULE_ARGUMENT	ALCODE	Application Logic	PL/SQL
	WINDOW	ALCODE	Application Logic	PL/SQL
	ACTION_ITEM	ALCODE	Application Logic	PL/SQL
	MODULE_DETAIL_TABLE_USAGE	CONNEC	Connect By Clause	SQL
		STWITH	Start With Clause	SQL
	ITEM	FORMATTING	PL/SQL user defined function
		DEFAULT_VALUE	Default Value	SQL
		DEFAULT_VALUE_TYPE	Server Function	PL/SQL
		ALCODE	Application Logic	PL/SQL
	UNBOUND_ITEM	CDEXPR	Derivation Text	SQL or PL/SQL
	CUSTOM_LINK	JNCOND	Join Condition	SQL
PL/SQL	CHECK_CONSTRAINT	CDWHCL	Where/Validation Condition	SQL
	COLUMN	CDEXPR	Derivation Expression	SQL
		DERIVATION_EXPRESSION_TYPE	Derivation Expression Type
		DEFAULT_VALUE	Default Value	PL/SQL
		DEFAULT_VALUE_TYPE	Server Function	PL/SQL
		CDWHCL	Where/Validation Condition	SQL
		WHERE_VALIDATION_TYPE	Where/Validation Type	SQL
	DATABASE_TRIGGER	CDIWHN	Trigger When Condition	SQL
	PLSQL_MODULE	CDIPLS	Private Declaration	PL/SQL
		CDIPLS	PL/SQL Block	PL/SQL
		CDISPC	Package Specification	PL/SQL
	INDEX_ENTRY	INDEX_FUNCTION	Index Function	SQL
	SNAPSHOT_DEFINITION	LGEXPR	Free Format Select Text	SQL
		CDWHCL	Where/Validation Condition	SQL
	VIEW_DEFINITION	LGEXPR	Free Format Select Text	SQL
		CDWHCL	Where/Validation Condition	SQL
Web PL/SQL	GENERAL_MODULE	ALCODE	Application Logic	PL/SQL
	MODULE_COMPONENT	ALCODE	Application Logic	PL/SQL
	ACTION_ITEM	ALCODE	Application Logic	PL/SQL
	MODULE_DETAIL_TABLE_USAGE	LVWHCL	Lookup Validation WHERE Clause	SQL
		CONNEC	Connect By Clause	SQL
		STWITH	Start With Clause	SQL
	ITEM	FORMATTING	PL/SQL user defined function
		DEFAULT_VALUE	Default Value	PL/SQL
		DEFAULT_VALUE_TYPE	Server Function	PL/SQL
		ALCODE	Application Logic	PL/SQL
	CUSTOM_LINK	JNCOND	Join Condition	SQL
Visual Basic	MODULE_DETAIL_TABLE_USAGE	CDWHCL	Where Clause of Query	SQL
		LVWHCL	Lookup Validation WHERE Clause	SQL
Java	JAVA_MODULE	CDIJAV	Java Block	JAVA


Structured parser- points to consider

Related Topics

Oracle 8 for Objects

The structured parser currently does not support Oracle 8 objects, e.g. Object Types.

Repository Objects

This table lists the compound versionable repository objects on which the structured parser operates.

Element Short Name	Element description
GEM	General Module
DOM	Domain
JAM	Java Module
OCL	Cluster Definition
ORC	Oracle Database
OSQ	Sequence Definition
PLM	PL/SQL Module
RLV	Reusable List of Values
RMC	Reusable Module Component
SNP	Snapshot Definition
TAB	Table Definition
VW	View Definition


Contents

# $ K A About the Dependency Manager

# $ K A Dependency Manager Finder

# $ K A Manage User Defined Global Name Domains

# $ K A New or Edit Global Name Domain

# $ K A Manage User Defined Dependency Types

# $ K A New or Edit Dependency Type

# $ K A Dependency Manager Purging dialog

# $ K A Manually adding dependencies using the Insertion Wizard

# $ K A Summary View Filter

# $ K A Show Dependencies

# $ K A Build Dependencies

# $ K A Dependency Properties

# $ K A Search for out of workarea


About the Dependency Manager

Related Topics

The Dependency Manager is a versatile tool which has a number of components and utilities for creating and maintaining dependency analysis information in the repository. About

Note	All users can use the Dependency Manager to examine dependency information, but only users who have the correct repository privilege can perform any other actions, such as dependency purging, manually adding dependencies, running dependency analysis. For more information, refer to Repository privileges for dependency analysis

Component	Function
Navigator	Objects in the repository are displayed with icons to indicate their type, and with + nodes to indicate that there are further levels that you can drill-down to by clicking the nodes. Not all objects can have their dependencies analyzed. To find out which objects in the navigator will be analyzed by one of the supplied parsers, refer to About parsers. The 'dependencies' topic for each parser indicates the objects that are analyzed by that parser. To display the dependencies of an object, select it in the Navigator, and click the [image] button. The dependency details are displayed in the Detail View tab or Summary View tab. When the name of an object in the Navigator is grayed out, the message below the Navigator indicates that the dependencies have not been built for this object and the objects below it. When the name is in italics, the message below the Navigator indicates that this object has changed since the dependencies were analyzed.  You can make multiple selections in the Navigator.
Detail View tab	This displays a tabular summary of the uses and used by relationships for the object you selected in the Navigator You can reduce the amount of information displayed using the Summary Filter
Summary View tab	This displays a hierarchical view of the uses and used by relationships for the object you selected in the Navigator.  Objects that are involved in the dependency are shown in red. Objects are grouped into Uses and Used by relationships. Within that, they are grouped by: • objects that are contained within the current workarea. • objects that are outside the current workarea, but within the repository • (Uses only) objects that are not present in the repository. This could mean that the object is only present on the local filesystem, or indicate an object that has not yet been parsed.
The Dependency Manager maintains a history of the selections you have made, and you can cycle through these by clicking on [image] and [image].

When you use the Dependency Manager, you will notice that the menus, and their options, change according to the type of component or window that is active, thus presenting only the options that are appropriate for the selection in the active window.


Dependency Manager Finder

Related Topics

Enables you to find an object in the Dependency Manager Navigator.  How

The results of a search are stored until the next search is performed, or until the Dependency Manager is closed.

Dialog box options

Object Name

The object for which you want to search. You can use the wildcard character * to widen the search, and  \ to search for objects are different levels

Object Type

Select the object type from the drop-down list.

Match Case

When this is selected, only objects whose name matches the the characters you have entered using the same case are selected. For example, if you specify the object name FORMABC and have Match Case selected, formabc is not found.

To cancel a search, click Stop. You may find that the Finder takes a while to stop.


Manage User Defined Global Name Domains (Dependency Manager)
Manage User Defined Global Name Domains

Related Topics

Only the global name domains you have defined in the repository are displayed in this dialog, so initially it is empty. For information about the global name domains supplied with Oracle Repository, refer to About global name domains

You can add, edit and delete user defined global name domains in the repository. How

Dialog box options

Add

A window opens that allow you to enter the new global name domain.

Edit

A window opens that allow you to edit the highlighted global name domain.

Delete

The highlighted global name domain is deleted.


New or Edit Global Name Domain (Dependency Manager)
New or Edit Global Name Domain

Related Topics

You can add a new global name domain or edit an existing user defined global name domain. How

Note	Only user defined global name domains are displayed in this dialog.

Dialog box options

Name

The name of the global name domain.

Display Name

The display name of the global name domain

Display Plural Name

The display name for multiples of this global name domain instance.


Manage User Defined Dependency Types (Dependency Manager)
Manage User Defined Dependency Types

Related Topics

Only the dependency types you have defined in the repository are displayed in this dialog, so initially it is empty. For further information, refer to About dependency types

You can add, edit and delete user defined dependency types in the repository. How

Dialog box options

Add

A window opens that allow you to enter the new dependency type.

Edit

A window opens that allow you to edit the highlighted dependency type.

Delete

The highlighted dependency type is deleted.


Dependency Type (Dependency Manager)
New or Edit Dependency Type

Related Topics

You can add a new dependency type or edit an existing user defined dependency type.

Note	Only user defined dependency types are displayed in this dialog.

Dialog box options

Type

The dependency type.

Sub Type

The sub type of the dependency


Dependency Manager - Purging
Dependency Manager Purging dialog

Related Topics

This dialog allows you to remove unwanted dependency information from the repository on a regular basis  to prevent performance problems. You do this by defining purging policies in the Properties tab and then selecting which policy to use on the Run tab. How

The first time the purging dialog is displayed the Properties tab is displayed. Once you have entered purging policies, the Run tab is displayed first.

Dialog box options - Properties tab

Dependency Purging Policy

A name for this dependency purging policy.

Branch Purging Policy

The name and number of one or more branches for which the dependency information should be kept.

Configuration Purging Policy

The name of one or more configurations for which dependency information should be kept.

Dialog box options - Run tab

Select the policy to run by clicking on Choose... and selecting from the list of policies displayed.

Specify rollback segment

The rollback segment should be large enough to ensure the purge procedure completes successfully i.e., the default rollback segment may be too small. The dropdown list shows the rollback segments that are available for the purge operation. If none of these is large enough, your database administrator can define one.


Manually adding dependencies using the Insertion Wizard

Related Topics

The Insertion Wizard, available from the Dependency Manager, allows you to manually add dependency information to the repository.

To use the wizard, follow the instructions on the screen.

The Dependency Types listed in this dialog are the Uses types and sub types used by the supplied parsers, and any dependency types and sub types you have defined. For more information, refer to About dependency types and sub types.


Summary View Filter (Dependency Manager)
Summary View Filter

Related Topics

This dialog allows you to select the types of dependency information to display in the Dependency Manager. How

Select one more more types from the left hand pane and click the right arrow to move them to the right pane. Dependencies of these types will not be displayed in the Summary View pane of the Dependency Manager.


Show Dependencies (Dependency Manager)
Show Dependencies

Related Topics

You can specify the dependency details that are displayed in the Summary View tab and Detail View tab for the object you have selected.

Dialog box options

Uses

Note that this is disabled when showing dependencies for a global name node.

Show uses

When selected, specifies that objects used by the selection (uses objects) are displayed in the Summary View tab and Detail View tab.

Include out of workarea

When selected, specifies that references to dependent objects that are not present in the current workarea are displayed.

Include missing

When selected, specifies that references to dependent objects that are not present in the repository or the supplier object has not yet been parsed.

Of type

Specifies that only dependent objects of the selected type are displayed.

Used by

Show used by

When selected, specifies that objects using the selection (used by objects) are displayed in the Summary View tab and Detail View tab.

Of type

Specifies that only dependent objects of the selected type are displayed.


Build Dependencies (Dependency Manager)
Build Dependencies

Related Topics

You can analyze dependencies for one or more objects. How

The table shows the objects you have selected from the Dependency Manager.

Dialog box options

Synchronize filesystem before analyzing

When you have selected files to be analyzed, this option allows you to force synchronization of files in the local filesystem with those in the repository.

Parsing files takes place in the filesystem, and so it can only be performed when the local files are synchronized with those in the repository. It is performed automatically for files that are not under version control or that are checked out. For more information, refer to About synchronization.

Analyse up to date objects

Check this box to parse all objects, regardless of whether or not they have changed since they were last parsed.

Overwrite existing dependencies

Check this box to overwrite existing dependency information when re-analyzing the dependencies.

Note:	Information of existing dependencies that have had their status changed to Permanent are not overwritten. For more information, refer to About the dependency status.

Show console

Check this box to show the console which displays the results of parsing. You can use this when you get a Failed result to see what happened and what caused the failure.

To close the console, uncheck the box.

Options Button

Click this button to open the Build dependency options dialog.


Dependency Properties (Dependency Manager)
Dependency Properties

Related Topics

This table shows the properties of the object you have selected. You can:

•	Change the status. For more information, refer to About the dependency status

•	Add a remark to this dependency

•	Set the value of Copy on Copy for for the Copy dialog for this dependency instance. The default is the value set for repository policies. For more information, refer to About policies

You could use this to preserve manually entered dependencies. The values are:

null	Uses the default set in the repository policy.
Y	Causes object dependencies to be copied by default when an object is copied, and it may override the value in the repository policy.
N	Causes object dependencies not to be copied when an object is copied, and it may override the value in the repository policy.
•	Set the value of Copy on Version for for the check out dialog for this dependency instance. The default is the value set for repository policies. For more information, refer to About policies

You could use this to preserve manually entered dependencies.  The values are:

null	Uses the default set in the repository policy
Y	Causes object dependencies to be copied by default when a new version of an object is created, and it may override the value in the repository policy.
N	Causes object dependencies not to be copied when a new version of an object is created, and it may override the value in the repository policy.


Search for out of workarea (Dependency Manager)
Search for out of workarea

Related Topics

The Dependency Manager helps you to track down used objects which are out of the workarea by finding configurations in the repository which contain most or all of the selected out of workarea objects.

Configurations

The configurations that are contain the out of workarea objects are shown. The match column shows the percentage match.

Double-click on a configuration to display information about it.

Objects for configuration <name>

This displays information about the configuration you have selected.


Build Dependencies options

Related Topics

You can set build dependency options to customize the way the Dependency Manager analyzes your dependencies.

You can use this dialog to specify a Java CLASSPATH to ensure that all dependencies in the Java class are analyzed.

Dialog box options

General
Parser mapping file

Use to specify that a parser mapping file other than the default is to be used. The parser mapping file specifies which parser is to be used to parse objects, files or blocks of text. The file used by default is the one identified on Windows systems by the registry setting:

\\HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE\repcom61\IAMAP61

and on UNIX systems by the Dependency Analyzer entry:

repcom61.IAMAP61 in the repository.ora file.

Parser filter file

Use to specify the file containing the rules to be used to filter dependencies before they are imported into the repository. The file used by default is the one identified on Windows systems by the registry setting:

\\HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE\repcom61\IAFILTER61

and on UNIX systems by the Dependency Analyzer entry:

repcom61.IAFILTER61 in the repository.ora file.

Java parser
Classpath

When you are parsing Java you must specify a classpath to ensure that all dependencies in the class are analyzed. If you do not specify a classpath the analysis will default the to current working directory.

NOTE:	The CLASSPATH environment variable are not used.

C parser
Include directories

Used only for parsing C and Pro*C objects. Use to specify a comma-separated list of include directories for the C preprocessor. If there are spaces in any of the directory names, enclose the list of names in quotation marks, for example:  "myprog.h,main headers.h,header.h".

Defines

Used only for parsing C and Pro*C objects.  Use to specify a comma-separated list of the NAME=VALUE pairs that are required by C program files. If any spaces exist in any of the pair names, enclose the list in quotation marks, for example:  "one=two,three=four,five=a lot".

Importer
XML DTD file

Use to specify that an XML DTD file other than the default is to be used. The XML DTD file provides information needed to interpret the dependency analysis information. The file used by default is the one identified on Windows systems by the registry setting:

\\HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE\repcom61\IADTD61

and on UNIX systems by the Dependency Analyzer entry:

repcom61.IADTD61 in the repository.ora file.

Do not import dependencies

Check this box to prevent the import stage being called when dependencies are analyzed. You could use this option if, for example, you want to examine the XML import file before it is imported into the repository.

NOTE:	In order to keep the XML file you must check the Keep XML file check box.

Keep XML file

Do not clean up the XML file after import. This may be of use to provide helpful debug information. The XML file is created in the system defined temporary directory or the current working directory if there is no system defined temporary directory.


About global name domains

Dependency objects are referenced in the repository by global name domains, which are version-independent objects that hold names in a standard form. In the DTD, they are specified by the target element.

If you write your own parser, you can add your own global name domains to the repository. How

For a list of the global name domains supplied with Oracle Repository showing the element types to which they correspond,  refer to Supplied global name domains.


Supplied global name domains

This table shows the global name domains that are installed with the product. and the element types to which they refer.

Global name domain	element type
AL_EVENT	Application Logic Event
C_FUNCTION	C Function
C_INCLUDE	C Include
DATABASE_CONTEXT	Context
DATABASE_DIMENSION	Dimension
DATABASE_INDEXTYPE	Index Type
DATABASE_LINK	Database Link
DATABASE_OUTLINE	Outline
FORMS_ALERT	Forms Alert
FORMS_BLOCK	Forms Block
FORMS_CANVAS	Forms Canvas
FORMS_EDITOR	Forms Editor
FORMS_FORM_MODULE	Forms Form Module
FORMS_FORM_PARAMETER	Forms Form Parameter
FORMS_GRAPHIC	Forms Graphic
FORMS_ITEM	Forms Item
FORMS_LOV	Forms List of Values
FORMS_MENU	Forms Menu
FORMS_MENU_ITEM	Forms Menu Item
FORMS_OBJECT_GROUP	Forms Object Group
FORMS_PROGRAM_UNIT_BODY	Forms Program Unit Body
FORMS_PROGRAM_UNIT_FUNC	Forms Program Unit Function
FORMS_PROGRAM_UNIT_PROC	Forms Program Unit Procedure
FORMS_PROGRAM_UNIT_SPEC	Forms Program Unit Spec
FORMS_PROPERTY_CLASS	Forms Property Class
FORMS_RECORD_GROUP	Forms Record Group
FORMS_RELATION	Forms Relation
FORMS_REPORT	Forms Report
FORMS_TAB_PAGE	Forms Tab Page
FORMS_TRIGGER	Forms Trigger
FORMS_VISUAL_ATTRIBUTE	Forms Visual Attribute
FORMS_WINDOW	Forms Window
JAVA_FIELD	Java Field
JAVA_METHOD	Java Method
JAVA_TYPE	Java Type
LIBRARY_LIBRARY_MODULE	Library Library Module
MENU_MENU	Menu Menu
MENU_MENU_ITEM	Menu Menu Item
MENU_MENU_MODULE	Menu Menu Module
MENU_MENU_PARAMETER	Menu Menu Parameter
MENU_OBJECT_GROUP	Menu Object Group
MENU_PROGRAM_UNIT_BODY	Menu Program Unit Body
MENU_PROGRAM_UNIT_FUNC	Menu Program Unit Function
MENU_PROGRAM_UNIT_PROC	Menu Program Unit Procedure
MENU_PROGRAM_UNIT_SPEC	Menu Program Unit Spec
MENU_PROPERTY_CLASS	Menu Property Class
MENU_VISUAL_ATTRIBUTE	Menu Visual Attribute
OLB_ALERT	OLB Alert
OLB_BLOCK	OLB Block
OLB_CANVAS	OLB Canvas
OLB_EDITOR	OLB Editor
OLB_FORM_PARAMETER	OLB Form Parameter
OLB_GRAPHIC	OLB Graphic
OLB_ITEM	OLB Item
OLB_LOV	OLB List of Values
OLB_MENU	OLB Menu
OLB_MENU_ITEM	OLB Menu Item
OLB_MENU_PARAMETER	OLB Menu Parameter
OLB_OBJECT_GROUP	OLB Object Group
OLB_OBJECT_LIBRARY	OLB Object Library
OLB_PROGRAM_UNIT_BODY	OLB Program Unit Body
OLB_PROGRAM_UNIT_FUNC	OLB Program Unit Function
OLB_PROGRAM_UNIT_PROC	OLB Program Unit Procedure
OLB_PROGRAM_UNIT_SPEC	OLB Program Unit Spec
OLB_PROPERTY_CLASS	OLB Property Class
OLB_RECORD_GROUP	OLB Record Group
OLB_REPORT	OLB Report
OLB_TAB_PAGE	OLB Tab Page
OLB_TRIGGER	OLB Trigger
OLB_VISUAL_ATTRIBUTE	OLB Visual Attribute
OLB_WINDOW	OLB Window
PLSQL_MODULE_PACKAGE_BODY	PLSQL Module Package Body
PLSQL_MODULE_PACKAGE_CURSOR	PLSQL Module Package Cursor
PLSQL_MODULE_PACKAGE_SPEC	PLSQL Module Package Spec
PLSQL_MODULE_PACKAGE_SUBTYPE	PLSQL Module Package Subtype
PLSQL_MODULE_PACKAGE_TYPE	PLSQL Module Package Type
PLSQL_MODULE_PACKAGE_VARIABLE	PLSQL Module Package Variable
PLSQL_MODULE_SUBROUTINE	PLSQL Module Subroutine
PLSQL_MODULE_TRIGGER	PLSQL Module Trigger
RELATION_PARTITION	Relation Partition
REPORTS_REPORT_MODULE	Reports Report Module
SHARED_LIBRARY	Shared Library


This is the global name domain that is displayed in the Dependency Manager.


This is the element type that corresponds to the global name domain.


Managing user defined global name domains

Related Topics

If you write your own parser, you will probably want to add your own global name domains to the repository. For more information, refer to About global name domains.

To add a new global name domain

1.	In the Dependency Manager, display the Manage User Defined Global Name Domains dialog by selecting Tools→Manage User Defined Global Name Domains...

If you have already defined some global name domains, they are displayed in this dialog, otherwise the window will be empty. Pre-defined global name domains are not displayed in this dialog.

2.	Click Add to display the New Global Name Domain dialog.

3.	In the Name field, enter the name of the new global name domain.

4.	In the Display Name field, enter the name to be displayed in the Dependency Manager.

5.	In the Display Plural Name field, enter a plural name to be used in the Dependency Manager when more than one instance exists.

6.	Click OK. The window closes and the repository is updated with the new global name domain.

To edit a user defined global name domain

1.	In the Dependency Manager, display the Manage User Defined Global Name Domains dialog by selecting Tools→Manage User Defined Global Name Domains...

2.	Select the user defined global name domain you want to edit.

3.	Click Edit to display the Edit Global Name Domain dialog.

3.	Edit the details in the Name field, the Display Name field, or the Display Plural Name field.

4.	Click OK. The window closes and the repository is updated with the amended information.

To delete a user defined global name domain

1.	In the Dependency Manager, display the Manage User Defined Global Name Domains dialog by selecting Tools→Manage User Defined Global Name Domains...

2.	Select the user defined global name domain you want to delete.

3.	Click Delete. The global name domain is deleted from the repository.

Note	You can only delete user defined global name domains that have not been used.


About writing a parser

Related Topics

This topic only lists the general principles involved in writing a parser and registering it so that it is run as part of the dependency analysis; it does not attempt to describe in detail the processes that have to be performed, however we do provide a sample parser to which you can refer.

Why write your own parser

You can write your own parser to:

•	record additional dependency types

•	reduce the number of dependencies recorded in the repository  to improve performance

•	record dependencies in source code written in other languages

Issues to consider

A parser analyzes the contents of a file or object, and captures dependency information. It produces one or more marked up XML files that are used to import the dependency information into the repository.

Detailed information is provided about the dependencies analyzed by the supplied parsers, and you can use this as a starting point when considering the dependency information, i.e. the uses and provides relationships, that you want your parser to record. For more information, refer to About parsers

We also provide a sample parser to show how easy it is to write, and illustrating the XML output by it. For more information, refer to Sample parser.

If necessary, you can write your parser so that it identifies more than the supplied 'Uses' and 'Provides' relationships and their sub types to identify the dependencies that you are interested in. In this case, you must record the new types and sub types in the repository using the Dependency Manager. For more information, refer to About dependency types and sub types.

You must determine a standard naming convention for all objects involved in dependency relationships. For example, a naming convention for a Java class is package_name.class_name which can be used to uniquely describe a class within a build or runtime environment. These standard names are called 'global names', and they consist of the global name domain and the specific instance within that domain. Global name domains have to be registered in the repository using the Dependency Manager. For more information, refer to About global name domains.

When you write your own parser, the parser and the files it parses have to be recorded in the parser mapping file. For more information, refer to About the parser mapping file

Writing the parser

You can write a parser in any language. For example, you could write a simple Perl script that uses regular expressions such as grep, or you could write a fully functional parser. There are just a few common sense rules that have to be followed:

•	there can be only one instance of each dependency.

•	There must be one entry for each relationship. For example each of the following should have one entry:

−	a module using a table

−	the same module calling a procedure

−	the same module attached to a library

•	each entry must have the object name and type of each end of the relationship so that the Dependency Manager dialog can navigate to the real object in the repository

•	the parser must output XML in the correct format. For more information and examples of the XML, and information about the DTD (Document Type Description), refer to About XML.

You can check that the XML your parser is producing is correct by validating it against the DTD. For more information, refer to Validating XML output.

•	(optional) for database objects such as tables, columns, and views, information about the query, insert, update and delete properties has to be recorded as well as the relationship. For example, this procedure inserts and updates into table X

Note:	Any character data that is generated should be appropriately escaped according to the W3C XML specification.  The Annotated XML specification is available at the following Web site:

http://www.xml.com/axml/testaxml.htm


Sample parser (dependency analysis)
Sample parser

Related Topics

This parser is written in perl and it shows how easy it is to write a dependency analysis parser. For a given file, it identifies the 'Uses Include' dependencies.

To run this sample parser:

1.	Create two files as follows:

foo.h	#define HWORLD "Hello World/n" main() {    Printf(HWORLD); };
foo.c	#include "foo.h"
2.	Click here to see the sample parser. Copy the text and save it to a file called 'inc_parser.pl'

2.	Amend the .c entry in the supplied parser mapping file so that this is used as the C parser:

.c    => perl <path name>\inc_parser.pl

where <path name> is the path of the file.

3.	First, using the command line tool, run the upload command on the files (to upload them from the file system to the repository):

a.	ul foo.h

b.	ul foo.c

Next, again using the command line tool, run the dependencyanalyze command on the files. To connect the include dependencies found by the parser, you need a 'Provides Principal' for this type of file, which is achieved by running the dependency analyzer on the .h file:

c.	da foo.h

d.	da foo.c

 Click here to see the XML output file that is produced.

The analysis results can be viewed in the Dependency Manager.


Sample parser text (dependency analysis)
Sample parser text

Related Topics

This is the sample parser written in perl.

#!/usr/bin/perl

# This is a Perl program that implements an

# 'Include Parser'.

# For any given file or stdin, it delivers

# the #include file dependencies

use strict;

my $full_filename = shift;

local *INPUT;

if (defined $full_filename)

{

  # If we are passed a filename on the command line,

  # open the file for reading

  open INPUT, $full_filename

    or die;

}

else

{

  # If we are not passed a filename, we should read

  # from STDIN

  *INPUT = *STDIN;

}

while (<INPUT>)

{

  # Match #include <...> and #include "..."

  if (/\#include\s+[\<\"]([^\>\"]+)/)

  {

    # Output the dependency type, in this case the fact

    # that the C file uses these includes

    # $1 will be the included file

    print "<dependency type='Uses'\n";

    print "            subtype='Include'>\n";

    print "   <target name='$1'\n";

    print "           type='file'/>\n";

    print "   <status value='Certain'/>\n";

    print "</dependency>\n";

  }

}

# The analysis tool is looking for a successful return

exit(0);


Sample parser XML (dependency analysis)
Sample parser XML

Related Topics

This is the XML output by the sample parser.

<dependency type='Uses'

            subtype='Include'>

   <target name=stdio.h'

           type='file'/>

   <status value='Certain'/>

</dependency>

<dependency type='Uses'

            subtype='Include'>

   <target name=bar.h'

           type='file'/>

   <status value='Certain'/>

</dependency>

<dependency type='Uses'

            subtype='Include'>

   <target name=foo.h'

           type='file'/>

   <status value='Certain'/>

</dependency>


Validating XML output

Related Topics

There is a registry variable that allows you to validate your XML against the DTD. By default this is not done for performance reasons, but when you write your own parser, you can test your XML using it.

The registry key is HKEY_LOCAL_MACHINE/SOFTWARE/ORACLE/REPCOM61, and the variable is DEPIMP_VALIDATE_XML.

Value
Y	The XML is validated against the DTD when the parser is run. If the XML fails to validate against the DTD, the object is marked as 'Failed' in the Build Dependencies dialog. Use the console (by clicking Show Console) to see details of why the XML is invalid.
N	This is the default. The XML is not validated against the DTD when the parser is run.


About the parser mapping file

Related Topics

When dependency analysis is run, either from the command line tool or from the Dependency Manager, the parser used to analyze a specific file or object is determined by the content of the parser mapping file which maps each file extension to a parser.

 For detailed information about the dependencyanalyze command and its options, refer to the Oracle Repository Command Line Tool Guide.

For information about running dependency analysis from the Dependency Manager, refer to Analyzing dependencies from the Dependency Manager dialog

You can edit this file to add new file types for an existing parser, or to add new file types when you add a new parser to the system. How

The parser mapping file is <ORACLE_HOME>\repadm61\JAVA\iamappings.pmf, and it is similar to the example below:

.fmb  => oracle.des.ia.parser.forms.FormsParser         # Forms

.olb  => oracle.des.ia.parser.forms.ObjectLibraryParser # Object Library

.mmb  => oracle.des.ia.parser.forms.MenuParser          # Menus

.sql  => oracle.des.ia.parser.sql.SqlParserLoader       # SQL & PL/SQL

.pkh  => oracle.des.ia.parser.sql.SqlParserLoader       # SQL & PL/SQL (Install)

.java => oracle.des.ia.parser.java.JavaParser           # Java

.sqlj => oracle.des.ia.parser.java.JavaParser           # SQL/J

.i    => oracle.des.ia.parser.c.CParserLoader           # preprocessed C

.c    => oracle.des.ia.parser.c.CParserLoader           # C

.pc   => oracle.des.ia.parser.c.CParserLoader           # Pro*C

.pll  => oracle.des.ia.parser.library.LibraryParser     # PL/SQL Library (Binary)

.pld  => oracle.des.ia.parser.library.LibraryParser     # PL/SQL Library (Text)

.rdf  => oracle.des.ia.parser.reports.ReportsParser     # Reports


Updating the parser mapping file

Related Topics

When you write a new parser you need to amend the parser mapping file so that your parser is used with the types of file you specify. About

The format of the parser mapping file is:

<file extension> => <command line to execute for parser> #<comment>

The command used is the command line with the filename appended to it, for example, if the entry for the parser mapping file is

.txt => text_parser #text file parser

then the command line for the file myfile.txt is:

text_parser myfile.text

To update the parser mapping file

1.	If you have not already done so, make a copy of the parser mapping file, iamappings.pmf. This is located in the \repadm61\java folder.

2.	Using Notepad, or a similar text editor, open the file iamappings.pmf.

3.	Edit it to add the appropriate file extension and its associated parser. The format is:

<file extension> => <command line> #<comment>

For example:

.i => oracle.des.ia.parser.c.CParserLoader   # preprocessed C

4.	Save the parser mapping file.

Use the -mf option with the dependencyanalyze command line utility to call a parser mapping file other than that supplied with the Oracle Repository. For information, refer to Analyzing dependencies from the command line tool.


About dependency types and sub types

Related Topics

Dependency types and sub types are used to describe the relationship between dependent objects. In the DTD, they are specified by the dependency element.

Supplied types and sub types

A number of dependency types and sub types used by the supplied parsers are provided with the Oracle Repository. However when you write your own parser, or if you want to manually enter dependency information to the repository, you can define your own. How

Installed dependency type	When to use
Uses Alter	Indicates that the dependent object is used in an Alter SQL statement
Uses Call	Indicates that the dependency object is called from a Java class
Uses Delete	Indicates that the dependent object is used in a Delete SQL statement
Uses Drop	Indicates that the dependent object is used in a Drop SQL statement
Uses Extend	Indicates that a Java class extends the dependent object
Uses Implement	Indicates that a Java class implements the dependent object
Uses Include	This is not used in this release.
Uses  Insert	Indicates that the dependent object is used in an Insert SQL statement
Uses Instantiate	This is not used in this release.
Uses Select	Indicates that the dependent object is used in a Select SQL statement
Uses Throw	This is not used in this release.
Uses Update	Indicates that the dependent object is used in an Update SQL statement
Uses null	Indicates that no subtype is used
Provides Principal	Every parsed_object has one Principal Provides relationship which is used to identify the name of the parsed object in the repository and the Dependency Manager dialog.  Note that this type and sub type is not available in the Insertion Wizard.
 Examples of dependency types and subtypes

In the case of tables and columns, when the type is Uses, the subtype could be Select, Insert, Update or Delete to indicate the type of statement in which they are being used.

In the case of a Forms .fmb  file which uses a word document as a specification for the form, you could manually define a new Uses sub type to be 'Specification'.

Click here for an example of a uses/provides relationship.

Click here to see the DTD.

Click here for an example of an XML file showing Uses Select and Provides Principal types and subtypes.


Managing user defined dependency types

Related Topics

The Oracle Repository contains a number of dependency types and sub types which are used by the supplied parsers. However, if you write your own parser, or if you want to describe dependency relationships you manually add to the repository, you can add your own dependency types and sub types to the repository.

For more information about types and sub types, refer to About dependency types and sub types.

To add a new dependency type and sub type

1.	In the Dependency Manager, display the Manage User Defined Dependency Types dialog by selecting Tools→Manage User Defined Dependency Types...

If you have already defined some dependency types, they are displayed in this dialog, otherwise the window will be empty. Pre-defined dependency types and sub types are not displayed in this dialog.

2.	Click Add to display the New Dependency Type dialog.

4.	In the Type field, enter the name of the new dependency type.

5.	In the Sub Type field, enter the name of the new sub type.

6.	Click OK. The window closes and the repository is updated with the new dependency type and sub type.

To edit a user defined dependency type and sub type

1.	In the Dependency Manager, display the Manage User Defined Dependency Types dialog by selecting Tools→Manage User Defined Dependency Types...

2.	Select the user defined dependency type you want to edit.

3.	Click Edit to display the Edit Dependency Type dialog.

3.	Edit the details in the Type field or the Sub Type field.

4.	Click OK. The window closes and the repository is updated with the amended information.

To delete a user defined dependency type and sub type

1.	In the Dependency Manager, display the Manage User Defined Dependency Types dialog by selecting Tools→Manage User Defined Dependency Types...

2.	Select the user defined dependency type you want to delete.

3.	Click Delete. The dependency type and sub type is deleted from the repository.

Note	You can only delete user defined dependency types that have not been used.


About the dependency status

Related Topics

The dependency status is represented in the Dependency Manager by a single character which indicates whether the dependency is Certain, Tentative, Permanent or Excluded.

In the DTD, it is specified by the status. element.

Certain

A certain dependency is one that is known to be true. It can either be set by the parser during parsing, or changed manually. For example, you can change a Tentative dependency that you know to be true to Certain. How

When the object or objects are reparsed, this dependency is removed, and it will only appear again if the dependency still exists.

Tentative

Dependencies can be set to Tentative when the parser does not know them to be true. You can change a Tentative dependency to Certain manually. How

When the object or objects are reparsed, this dependency is removed, and it will only appear again if the dependency still exists.

Permanent

A Permanent dependency is one that is known to be true, and it will not be removed on reparsing the same object(s), even though the dependency may no longer exist. A dependency can only be set to Permanent manually. How

Excluded

An Excluded dependency is one which may or may not be true, but which should not be shown or reintroduced on re-parsing of either client or supplier. They can only be set manually. How

Caution:	Exercise great care in setting a dependency to Excluded. Once a dependency has been flagged as Excluded it will not be displayed in the Dependency Manager again, and there is no way to change the dependency status to another value.


Changing the dependency status

Related Topics

You can change the status of a dependency instance. About

To change the status of a dependency instance:

1.	In the Dependency Manager, open the Dependency Properties dialog. How

2.	Make sure that you are viewing the correct dependency instance. When there is more than one you can move between them using the [image] and [image] buttons.

3.	When more than one row of dependency properties is displayed, make sure that you have the correct one, and select the new status. About

4.	Enter a meaningful remark in the Remark column.

5.	Click OK.