|Oracle9i Database Concepts
Release 1 (9.0.1)
Part Number A88856-02
The definitions of some objects, including views and procedures, reference other objects, such as tables. As a result, the objects being defined are dependent on the objects referenced in their definitions. This chapter discusses the dependencies among schema objects and how Oracle automatically tracks and manages these dependencies. It includes:
Some types of schema objects can reference other objects as part of their definition. For example, a view is defined by a query that references tables or other views. A procedure's body can include SQL statements that reference other objects of a database. An object that references another object as part of its definition is called a dependent object, while the object being referenced is a referenced object. Figure 19-1 illustrates the different types of dependent and referenced objects:
If you alter the definition of a referenced object, dependent objects may or may not continue to function without error, depending on the type of alteration. For example, if you drop a table, no view based on the dropped table is usable.
Oracle automatically records dependencies among objects to alleviate the complex job of dependency management for the database administrator and users. For example, if you alter a table on which several stored procedures depend, Oracle automatically recompiles the dependent procedures the next time the procedures are referenced (executed or compiled against).
To manage dependencies among schema objects, all of the schema objects in a database have a status:
The schema object has been compiled and can be immediately used when referenced.
The schema object must be compiled before it can be used.
Only dependent objects can be invalid. Tables, sequences, and synonyms are always valid.
If a view, procedure, function, or package is invalid, Oracle may have attempted to compile it, but errors relating to the object occurred. For example, when compiling a view, one of its base tables might not exist, or the correct privileges for the base table might not be present. When compiling a package, there might be a PL/SQL or SQL syntax error, or the correct privileges for a referenced object might not be present. Schema objects with such problems remain invalid.
Oracle automatically tracks specific changes in the database and records the appropriate status for related objects in the data dictionary.
Status recording is a recursive process. Any change in the status of a referenced object changes the status not only for directly dependent objects, but also for indirectly dependent objects.
For example, consider a stored procedure that directly references a view. In effect, the stored procedure indirectly references the base tables of that view. Therefore, if you alter a base table, the view is invalidated, which then invalidates the stored procedure. Figure 19-2 illustrates indirect dependencies:
When a schema object is referenced directly in a SQL statement or indirectly through a reference to a dependent object, Oracle checks the status of the object explicitly specified in the SQL statement and any referenced objects, as necessary. Oracle's action depends on the status of the objects that are directly and indirectly referenced in a SQL statement:
A view or PL/SQL program unit can be compiled and made valid if the following conditions are satisfied:
INSERTprivilege for the referenced table.
A view depends on the base tables or views referenced in its defining query. If the defining query of a view is not explicit about which columns are referenced, for example,
SELECT * FROM table, then the defining query is expanded when stored in the data dictionary to include all columns in the referenced base table at that time.
If a base table or view of a view is altered, renamed, or dropped, then the view is invalidated, but its definition remains in the data dictionary along with the privileges, synonyms, other objects, and other views that reference the invalid view.
An attempt to use an invalid view automatically causes Oracle to recompile the view dynamically. After replacing the view, the view might be valid or invalid, depending on the following conditions:
SELECT * FROM tablequery, because the defining query is expanded at view creation time and permanently stored in the data dictionary.
Oracle automatically invalidates a program unit when the definition of a referenced object is altered. For example, assume that a standalone procedure includes several statements that reference a table, a view, another standalone procedure, and a public package procedure. In that case, the following conditions hold:
Some data warehouses drop indexes on tables at night to facilitate faster loads. However, all views dependent on the table whose index is dropped get invalidated. This means that subsequently running any package that reference these dropped views will invalidate the package.
Remember that whenever you create a table, index, and view, and then drop the index, all objects dependent on that table are invalidated, including views, packages, package bodies, functions, and procedures. This protects updatable join views.
To make the view valid again, use one of the following commands:
Each session that references a package construct has its own instance of that package, including a persistent state of any public and private variables, cursors, and constants. All of a session's package instantiations including state can be lost if any of the session's instantiated packages are subsequently invalidated and recompiled.
Oracle notices when a DML object or system privilege is granted to or revoked from a user or
PUBLIC and automatically invalidates all the owner's dependent objects. Oracle invalidates the dependent objects to verify that an owner of a dependent object continues to have the necessary privileges for all referenced objects. Internally, Oracle notes that such objects do not have to be recompiled. Only security authorizations need to be validated, not the structure of any objects. This optimization eliminates unnecessary recompilations and prevents the need to change a dependent object's time stamp.
Oracle9i Application Developer's Guide - Fundamentals for information about forcing the recompilation of an invalid view or program unit
Function-based indexes depend on functions used in the expression that defines the index. If a PL/SQL function or package function is changed, then the index is marked as disabled.
This section discusses requirements for function-based indexes and what happens when a function is changed in any manner, such as when it is dropped or privileges to use it are revoked.
To create a function-based index:
CREATE ANY INDEXand
GLOBAL QUERY REWRITE.
To use a function-based index:
NULLvalues from the indexed expression, because
NULLvalues are not stored in indexes.
The following sections describe additional requirements.
Any user-written function used in a function-based index must have been declared with the
DETERMINISTIC keyword to indicate that the function will always return the same output return value for any given set of input argument values, now and in the future.
The index owner needs the
EXECUTE privilege on the function used to define a function-based index. If the
EXECUTE privilege is revoked, Oracle marks the index
DISABLED. The index owner does not need the
EXECUTE WITH GRANT OPTION privilege on this function to grant
SELECT privileges on the underlying table.
A function-based index depends on any function that it is using. If the function or the specification of a package containing the function is redefined (or if the index owner's
EXECUTE privilege is revoked), then the following conditions hold:
DISABLEDindex fail if the optimizer chooses to use the index.
DISABLEDindex fail unless the index is also marked
UNUSABLEand the initialization parameter
SKIP_UNUSABLE_INDEXESis set to true.
To re-enable the index after a change to the function, use the
ALTER INDEX ... ENABLE statement.
When a dependent object is created, Oracle takes the following steps:
Because of how Oracle resolves references, it is possible for an object to depend on the nonexistence of other objects. This situation occurs when the dependent object uses a reference that would be interpreted differently were another object present. For example, assume the following:
COMPANYschema contains a table named
EMPis created for
COMPANY.EMPis granted to the
JWARDschema does not contain a table or private synonym named
JWARDcreates a view in his schema with the following statement:
JWARD creates the
DEPT_SALARIES view, the reference to
EMP is resolved by first looking for
JWARD.EMP as a table, view, or private synonym, none of which is found, and then as a public synonym named
EMP, which is found. As a result, Oracle notes that
JWARD.DEPT_SALARIES depends on the nonexistence of
JWARD.EMP and on the existence of
Now assume that
JWARD decides to create a new view named
EMP in his schema using the following statement:
JWARD.EMP does not have the same structure as
As it attempts to resolve references in object definitions, Oracle internally makes note of dependencies that the new dependent object has on "nonexistent" objects--schema objects that, if they existed, would change the interpretation of the object's definition. Such dependencies must be noted in case a nonexistent object is later created. If a nonexistent object is created, all dependent objects must be invalidated so that dependent objects can be recompiled and verified and all dependent function-based indexes must be marked unusable.
Therefore, in the previous example, as
JWARD.EMP is created,
JWARD.DEPT_SALARIES is invalidated because it depends on
JWARD.EMP. Then when
JWARD.DEPT_SALARIES is used, Oracle attempts to recompile the view. As Oracle resolves the reference to
EMP, it finds
JWARD.EMP (PUBLIC.EMP is no longer the referenced object). Because
JWARD.EMP does not have a
SAL column, Oracle finds errors when replacing the view, leaving it invalid.
In summary, you must manage dependencies on nonexistent objects checked during object resolution in case the nonexistent object is later created.
In addition to managing dependencies among schema objects, Oracle also manages dependencies of each shared SQL area in the shared pool. If a table, view, synonym, or sequence is created, altered, or dropped, or a procedure or package specification is recompiled, all dependent shared SQL areas are invalidated. At a subsequent execution of the cursor that corresponds to an invalidated shared SQL area, Oracle reparses the SQL statement to regenerate the shared SQL area.
Tracking dependencies and completing necessary recompilations are performed automatically by Oracle. Local dependency management occurs when Oracle manages dependencies among the objects in a single database. For example, a statement in a procedure can reference a table in the same database.
Remote dependency management occurs when Oracle manages dependencies in distributed environments across a network. For example, an Oracle Forms trigger can depend on a schema object in the database. In a distributed database, a local view's defining query can reference a remote table.
Oracle manages all local dependencies using the database's internal dependency table, which keeps track of each schema object's dependent objects. When a referenced object is modified, Oracle uses the depends-on table to identify dependent objects, which are then invalidated.
For example, assume a stored procedure
UPDATE_SAL references the table
JWARD.EMP. If the definition of the table is altered in any way, the status of every object that references
JWARD.EMP is changed to
INVALID, including the stored procedure
UPDATE_SAL. As a result, the procedure cannot be executed until it has been recompiled and is valid. Similarly, when a DML privilege is revoked from a user, every dependent object in the user's schema is invalidated. However, an object that is invalid because authorization was revoked can be revalidated by "reauthorization," in which case it does not require full recompilation.
Oracle also manages application-to-database and distributed database dependencies. For example, an Oracle Forms application might contain a trigger that references a table, or a local stored procedure might call a remote procedure in a distributed database system. The database system must account for dependencies among such objects. Oracle uses different mechanisms to manage remote dependencies, depending on the objects involved.
Dependencies among stored procedures including functions, packages, and triggers in a distributed database system are managed using time stamp checking or signature checking.
The dynamic initialization parameter
REMOTE_DEPENDENCIES_MODE determines whether time stamps or signatures govern remote dependencies.
Oracle9i Application Developer's Guide - Fundamentals for details about managing remote dependencies with time stamps or signatures
In the time stamp checking dependency model, whenever a procedure is compiled or recompiled its time stamp (the time it is created, altered, or replaced) is recorded in the data dictionary. The time stamp is a record of the time the procedure is created, altered, or replaced. Additionally, the compiled version of the procedure contains information about each remote procedure that it references, including the remote procedure's schema, package name, procedure name, and time stamp.
When a dependent procedure is used, Oracle compares the remote time stamps recorded at compile time with the current time stamps of the remotely referenced procedures. Depending on the result of this comparison, two situations can occur:
Actual time stamp comparison occurs when a statement in the body of a local procedure executes a remote procedure. Only at this moment are the time stamps compared using the distributed database's communications link. Therefore, all statements in a local procedure that precede an invalid procedure call might execute successfully. Statements subsequent to an invalid procedure call do not execute at all. Compilation is required. However, any DML statements executed before the invalid procedure call are rolled back.
Oracle provides the additional capability of remote dependencies using signatures. The signature capability affects only remote dependencies. Local dependencies are not affected, as recompilation is always possible in this environment.
The signature of a procedure contains information about the following items:
(IN, OUT, and IN OUT)
If the signature dependency model is in effect, a dependency on a remote program unit causes an invalidation of the dependent unit if the dependent unit contains a call to a procedure in the parent unit, and the signature of this procedure has been changed in an incompatible manner. A program unit can be a package, stored procedure, stored function, or trigger.
Oracle does not manage dependencies among remote schema objects other than local-procedure-to-remote-procedure dependencies.
For example, assume that a local view is created and defined by a query that references a remote table. Also assume that a local procedure includes a SQL statement that references the same remote table. Later, the definition of the table is altered.
As a result, the local view and procedure are never invalidated, even if the view or procedure is used after the table is altered, and even if the view or procedure now returns errors when used In this case, the view or procedure must be altered manually so errors are not returned. In such cases, lack of dependency management is preferable to unnecessary recompilations of dependent objects.
Code in database applications can reference objects in the connected database. For example, OCI, Precompiler, and SQL*Module applications can submit anonymous PL/SQL blocks. Triggers in Oracle Forms applications can reference a schema object.
Such applications are dependent on the schema objects they reference. Dependency management techniques vary, depending on the development environment. Refer to the appropriate manuals for your application development tools and your operating system for more information about managing the remote dependencies within database applications.