ORACLE DBA - DEPENDENCIAS

Dependencias

Recompilación de objetos descompilados del esquema.

Las actualizaciones, parches y cambios de librerias pueden invalidar objetos del esquema. Una vez realizados los cambios los objetos dependientes serán revalidados de forma automatica cuando se usan. Esto puede tardar un rato e incluso tardar un tiempo inaceptable por lo que lo logico es recompilar las dependencias antes de las llamadas de los usuarios. Esto además permite descubrir si los cambios han afecteado al resto del codigo.

Identificación de objetos descompilados

COLUMN object_name FORMAT A30
SELECT owner,
       object_type,
       object_name,
       status
FROM   dba_objects
WHERE  status = 'INVALID'
ORDER BY owner, object_type, object_name;

Con esta información podemos decidir que metodo seguir para recompilar.

Recompilación manual

Para un numero pequeño de objetos es probable que la recompilación manual sea suficiente.

ALTER PACKAGE my_package COMPILE;
ALTER PACKAGE my_package COMPILE BODY;
ALTER PROCEDURE my_procedure COMPILE;
ALTER FUNCTION my_function COMPILE;
ALTER TRIGGER my_trigger COMPILE;
ALTER VIEW my_view COMPILE;

Hay que tener en cuenta que es necesario recompilar cabecera y cuerpo del paquete por separado. Alternativamente podemos usa el paquete DBMS_DDL:

EXEC DBMS_DDL('PACKAGE', 'MY_SCHEMA', 'MY_PACKAGE');
EXEC DBMS_DDL('PACKAGE BODY', 'MY_SCHEMA', 'MY_PACKAGE');
EXEC DBMS_DDL('PROCEDURE', 'MY_SCHEMA', 'MY_PROCEDURE');
EXEC DBMS_DDL('FUNCTION', 'MY_SCHEMA', 'MY_FUNCTION');
EXEC DBMS_DDL('TRIGGER', 'MY_SCHEMA', 'MY_TRIGGER');

Este metodo esta limitado a los objetos PL/SQL por lo que no es aplicable a vistas.

Script a medida

En algunos casos puede ser interesante escribir un script para identificar y compilar objetos descompilados. Un ejemplo para PACKAGE y PACKAGE BODY seria:

SET SERVEROUTPUT ON SIZE 1000000
BEGIN
  FOR cur_rec IN (SELECT owner,
                         object_name,
                         object_type,
                         DECODE(object_type, 'PACKAGE', 1,
                                             'PACKAGE BODY', 2, 2) AS recompile_order
                  FROM   dba_objects
                  WHERE  object_type IN ('PACKAGE', 'PACKAGE BODY')
                  AND    status != 'VALID'
                  ORDER BY 4)
  LOOP
    BEGIN
      IF cur_rec.object_type = 'PACKAGE' THEN
        EXECUTE IMMEDIATE 'ALTER ' || cur_rec.object_type || 
            ' "' || cur_rec.owner || '"."' || cur_rec.object_name || '" COMPILE';
      ElSE
        EXECUTE IMMEDIATE 'ALTER PACKAGE "' || cur_rec.owner || 
            '"."' || cur_rec.object_name || '" COMPILE BODY';
      END IF;
    EXCEPTION
      WHEN OTHERS THEN
        DBMS_OUTPUT.put_line(cur_rec.object_type || ' : ' || cur_rec.owner || 
                             ' : ' || cur_rec.object_name);
    END;
  END LOOP;
END;
/

Con este metodo hay que tener mucho cuidado ya que puedes acabar recompilando algunos objetos varias veces dependiendo del orden de ejecucion de la recompilación. Los procedimientos que nos da oracle y que están explicados a continuación si que tiene en cuenta el orden adecuado.

DBMS_UTILITY.compile_schema

El procedimiento COMPILE_SCHEMA del paquete DBMS_UTILITY compila todos los procedures, functions, packages, y triggers de un esquema. Hay que tener muy en cuenta que tampoco recompila las vistas.

EXEC DBMS_UTILITY.compile_schema(schema => 'SCOTT');

UTL_RECOMP

El paquete UTL_RECOMP contiene 2 procedimientos para recompilar objetos descompilados. RECOMP_SERIAL recompila los objetos uno por uno mientras que RECOMP_PARALLEL recompila en paralelo usando el numero de threads especificado.

PROCEDURE RECOMP_SERIAL(
   schema   IN   VARCHAR2    DEFAULT NULL,
   flags    IN   PLS_INTEGER DEFAULT 0);

PROCEDURE RECOMP_PARALLEL(
   threads  IN   PLS_INTEGER DEFAULT NULL,
   schema   IN   VARCHAR2    DEFAULT NULL,
   flags    IN   PLS_INTEGER DEFAULT 0);

los parametros son: * schema - El esquema a recompilar, si es nulo se recompilan todos los objetos descompilados de la base de datos. * threads - El numero de threads a utilizar, si es nulo se usa el valor de "job_queue_processes". Un valor adecuado es el numero de CPU's disponibles. * flags - Se usa para pruebas y diagnostico interno.

-- Schema level.
EXEC UTL_RECOMP.recomp_serial('SCOTT');
EXEC UTL_RECOMP.recomp_parallel(4, 'SCOTT');

-- Database level.
EXEC UTL_RECOMP.recomp_serial();
EXEC UTL_RECOMP.recomp_parallel(4);

-- Using job_queue_processes value.
EXEC UTL_RECOMP.recomp_parallel();
EXEC UTL_RECOMP.recomp_parallel(NULL, 'SCOTT');

Restricciones del paquete: -La ejecucion en paralelo utiliza la cola de trabajos. Todos los trabajos se dehabilitan hasta que la operación termina. -Debe ejecutarse con el usuario SYS u otros con permisos de SYSDBA. -Deber exitir STANDARD, DBMS_STANDARD, DBMS_JOB and DBMS_RANDOM. -El ejecutar comandos DDL a la vez puede provocar interbloqueos.

Explicación de la sintaxis utilizada para los comandos:
Las palabras en mayusculas son comandos de oracle.
Las palabras en minusculas son opiones modificables
Las partes enmarcadas con [] son opcionales
Las palabras en negrita son las opciones por defecto
Las partes enmarcadas con {} son alternativas (una u otra).
El simbolo | indica OR