Manual oracle plsql_intermedio_2012

División de Educación Continua – FCA – UNAM http.//dec.fca.unam.mx

2012

Universidad Nacional Autónoma de México Facultad de Contaduría y Administración División de Educación Continua

Oracle PL/SQL Intermedio

[Oracle PL/SQL Intermedio]


División de Educación Continua

Liverpool #66 Col. Juárez C.P. 06600 Tel. 5533-1617 al 19, 01800-8-332-322

Página: http://dec.fca.unam.mx

Página 2 de 48

Contenido

Contenido ................................................................................................................................... 2

Lista de procedimientos .............................................................................................................. 5

Lista de figuras ........................................................................................................................... 5

Lista de tablas ............................................................................................................................ 6

Lista de ejemplos ....................................................................................................................... 6

Objetivo ...................................................................................................................................... 8

1. Introducción a las Unidades de Programa ........................................................................ 9

Antecedentes ......................................................................................................................... 9

1.1. Definición................................................................................................................. 10

1.2. Tipos ....................................................................................................................... 10

1.2.1. Procedimientos ........................................................................................................ 10

1.2.2. Funciones ................................................................................................................ 10

1.2.3. Paquetes ................................................................................................................. 10

1.2.4. Triggers ................................................................................................................... 11

1.3. Ventajas .................................................................................................................. 11

1.3.1. Modularidad ............................................................................................................. 11

1.3.2. Diseño sencillo de aplicaciones ............................................................................... 11

1.3.3. Flexibilidad en el mantenimiento .............................................................................. 11

1.3.4. Agrupamiento en paquetes ...................................................................................... 11

1.3.5. Reutilización ............................................................................................................ 11

1.3.6. Mejor rendimiento .................................................................................................... 11

2. Crear procedimientos almacenados y funciones ............................................................. 12





Página 3 de 48

2.1. Procedimientos almacenados y funciones ............................................................... 12

2.1.1. Secciones de un procedimiento o función................................................................ 12

2.1.1.1. Encabezado .......................................................................................................... 12

2.1.1.2. Sección declarativa ............................................................................................... 12

2.1.1.3. Sección ejecutable ................................................................................................ 12

2.1.1.4. Sección de manejo de excepciones ...................................................................... 13

2.2. Crear y ejecutar procedimientos almacenados ........................................................ 13

2.2.1. Crear y ejecutar funciones ....................................................................................... 15

2.2.2. Modos de parámetros .............................................................................................. 17

2.2.3. Tipos de parámetros ................................................................................................ 17

2.2.4. Valores predeterminados para parámetros IN ......................................................... 18

2.2.5. Notación de parámetros por posición, por nombre y mixta ...................................... 19

3. Mantenimiento de Procedimientos Almacenados y Funciones ....................................... 20

3.1. Recompilar .............................................................................................................. 20

3.2. Eliminar ................................................................................................................... 21

3.3. Diccionario de datos ................................................................................................ 21

4. Crear y mantener paquetes ............................................................................................ 22

4.1. Paquetes ................................................................................................................. 22

4.1.1. Secciones de un paquete ........................................................................................ 23

4.1.1.1. Especificación ....................................................................................................... 23

4.1.1.2. Cuerpo .................................................................................................................. 23

4.2. Crear paquetes ........................................................................................................ 23

4.3. Mantener Paquetes. ................................................................................................ 26

4.3.1. Eliminar paquetes .................................................................................................... 27

4.3.2. Recompilar paquetes ............................................................................................... 27





Página 4 de 48

5. Triggers de bases de datos ............................................................................................ 28

5.1. Triggers de bases de datos ..................................................................................... 28

5.1.1. Introducción ............................................................................................................. 28

5.1.2. Tareas que puede realizar un trigger ....................................................................... 28

5.1.3. Triggers DML ........................................................................................................... 29

5.1.4. Predicados condicionales para sentencias DML ...................................................... 29

5.1.5. Seudoregistros OLD y NEW ....................................................................................... 30

5.1.6. Resumen de tipos de triggers .................................................................................. 31

5.2. Crear triggers de bases de datos ............................................................................. 31

5.3. Mantener triggers de bases de datos ....................................................................... 34

5.3.1. Activar, desactivar y compilar triggers ..................................................................... 34

5.3.2. Consultas para obtener información sobre triggers .................................................. 35

Fuentes de Información ............................................................................................................ 36

Bibliografía ........................................................................................................................... 36

Referencias Web ..................................................................... ¡Error! Marcador no definido.

Anexo A. Procedimientos útiles para trabajar con Oracle Database XE ................................... 37

Anexo B. Instrucciones para crear tablas de ejemplo ............................................................... 46

Contacto ................................................................................................................................... 48





Página 5 de 48

Lista de procedimientos

Procedimiento 1. Crear espacio de trabajo y entrar al entorno de programación en SQL ......... 37

Procedimiento 2. Entrar al entorno de programación en SQL ................................................... 41

Lista de figuras

Figura 1. Ejemplo de código de un programa de aplicación...................................................... 10





Página 6 de 48

Lista de tablas

Tabla 1. Vistas del sistema relacionadas con procedimientos y funciones ............................... 21

Tabla 2. Momentos de ejecución de un trigger ......................................................................... 29

Tabla 3. Predicados condicionales para determinar sentencia DML ......................................... 29

Tabla 4. Valores de los seudoregistros OLD y NEW ................................................................... 30

Tabla 5. Resumen de tipos de triggers ..................................................................................... 31

Lista de ejemplos

Ejemplo 1 Crear primer procedimiento para formar email ......................................................... 13

Ejemplo 2. Instrucciones para ejecutar un procedimiento ......................................................... 14

Ejemplo 3 Crear primera función para calcular cuadrado de un número................................... 16

Ejemplo 4. Instrucciones para ejecutar una función .................................................................. 16

Ejemplo 5. Tipo de parámetro con atributo %TYPE ................................................................... 17

Ejemplo 6. Tipo de parámetro con atributo %ROWTYPE ............................................................. 18

Ejemplo 7. Tipos de datos restringidos con atributos %TYPE y %ROWTYPE ............................. 18

Ejemplo 8. Parámetros IN con valores predeterminados .......................................................... 19

Ejemplo 9. Notaciones de parámetros por posición, por nombre y mixta .................................. 19

Ejemplo 10. Recompilar un procedimiento ............................................................................... 20

Ejemplo 11. Eliminar un procedimiento y una función............................................................... 21

Ejemplo 12. Consultas para obtener información sobre procedimientos y funciones ................ 22

Ejemplo 13. Instrucciones para crear un paquete (especificación y cuerpo) ............................. 23

Ejemplo 14. Crear el primer paquete para administrar empleados ........................................... 24

Ejemplo 15. Consulta para obtener información sobre paquetes .............................................. 25





Página 7 de 48

Ejemplo 16. Instrucciones para ejecutar funciones de un paquete ........................................... 26

Ejemplo 17. Instrucciones para ejecutar procedimientos de un paquete................................... 26

Ejemplo 18. Instrucciones para eliminar paquetes .................................................................... 27

Ejemplo 19. Instrucciones para recompilar un paquete ............................................................ 27

Ejemplo 20. Ejemplo de trigger con predicados condicionales ................................................. 32

Ejemplo 21. Instrucciones para desencadenar trigger con predicados condicionales ............... 32

Ejemplo 22. Ejemplo de trigger para llevar bitácora de movimientos ........................................ 33

Ejemplo 23. Activar, desactivar y compilar triggers ................................................................... 34

Ejemplo 24. Consultas para obtener información sobre triggers ............................................... 35





Página 8 de 48

Objetivo

Al finalizar el curso, el participante será capaz de:

1. Entender la estrategia de creación de unidades de programa dentro de

una base de datos.

2. Crear y mantener unidades de programa dentro de una base de datos.

3. Encapsular varias unidades de programa en un paquete.

4. Construir y mantener triggers de bases de datos.





Página 9 de 48

1. Introducción a las Unidades de Programa

Antecedentes

Existen al menos tres técnicas para interactuar con una base de datos desde los programas de

aplicación (Elmasri, 2007, pp. 252 y ss.). La más utilizada es la incrustación de comandos SQL dentro

de los lenguajes de programación de propósito general. Es decir, dentro de las líneas de código del

lenguaje de programación se incluyen (incrustan) líneas de código del lenguaje SQL. Esta técnica es

conocida como SQL embebido (embedded SQL) o SQL incrustado.

La segunda técnica consiste en utilizar bibliotecas, conocidas como APIs (Application

Programming Interfaces), de funciones de bases de datos. La más conocida es la biblioteca ODBC.

Estas bibliotecas incluyen funciones para conectar, consultar y actualizar la base de datos.

Finalmente, la tercera técnica hace uso de un lenguaje de programación de bases de datos. En

esta técnica hablamos de añadir estructuras de un lenguaje de programación de propósito general,

como serían ciclos y condicionales, al lenguaje SQL, lo que da como resultado un lenguaje de bases

de datos.

Este curso está diseñado para conocer en buena medida la tercera de las tres técnicas

mencionadas. Para tal fin haremos uso del lenguaje de programación de bases de datos PL/SQL1 de

Oracle. Las ventajas que tiene la tercera de las técnicas con respecto a las demás serán presentadas

más adelante, especialmente en la sección 1.3.

Por ahora observe y analice el siguiente ejemplo de código de un programa de aplicación

hecho en Java. ¿Qué técnicas, de las mencionadas anteriormente, son utilizadas en el ejemplo?

1 Recordemos que PL/SQL es un lenguaje procedural extendido a partir del lenguaje SQL. Fue

desarrollado por Oracle para permitir portabilidad y procesamiento de transacciones. Más información en

http://docs.oracle.com/cd/E11882_01/appdev.112/e25519/overview.htm#CEGGFECE.

http://docs.oracle.com/cd/E11882_01/appdev.112/e25519/overview.htm#CEGGFECE





Página 10 de 48

Figura 1. Ejemplo de código de un programa de aplicación

1.1. Definición

Definiremos una unidad de programa como un contenedor de código, es decir, objetos que

guardan bloques de código PL/SQL que se encuentra almacenado en nuestra base de datos. Estas

unidades de programa deben tener asociado un nombre y pueden ser ejecutada las veces que sea

necesario. Además, nos permiten descomponer problemas complejos en unidades de programación

más simples que podemos reutilizar en varias aplicaciones2.

Por otra parte, es posible incluir comandos SQL para manipulación de datos (DML) y para

definición de datos (DDL) dentro de estas unidades de programa.

1.2. Tipos

En este curso nos abocaremos a cuatro tipos de unidades de programa. En seguida las

enumeramos y damos una breve descripción de cada una.

1.2.1. Procedimientos

Son unidades de programa que permiten ejecutar una o varias acciones.

1.2.2. Funciones

Son unidades de programa que realizan un cálculo y regresan un valor.

1.2.3. Paquetes

Son unidades de programa que contienen procedimientos y funciones, los cuales son

ejecutados como una unidad. Podemos pensar en paquetes como aplicaciones completas.

2 Si desea ampliar su información sobre este tema, puede visitar el sitio

http://docs.oracle.com/cd/E11882_01/appdev.112/e25518/adfns_packages.htm#autoId0.

http://docs.oracle.com/cd/E11882_01/appdev.112/e25518/adfns_packages.htm#autoId0





Página 11 de 48

1.2.4. Triggers

Son unidades de programa que se ejecutan automáticamente cuando se da un evento en la

base de datos. Los triggers son ejecutados generalmente cuando se modifican los datos de una tabla

1.3. Ventajas

Usar unidades de programa nos permite reutilizar el mismo código en varias aplicaciones o

repetir su ejecución dentro de la misma aplicación. Además, nos brinda las siguientes ventajas.

1.3.1. Modularidad

Las unidades de programa nos permiten dividir un programa en módulos bien definidos.

1.3.2. Diseño sencillo de aplicaciones

Al diseñar una aplicación es posible posponer la implementación detallada de las unidades de

programa hasta que el programa principal esté definido totalmente. Después de que el programa

principal esté definido totalmente se pueden implementar una por una las unidades de programa con el

fin de hacer pruebas individuales para cada unidad.

1.3.3. Flexibilidad en el mantenimiento

Es posible modificar una unidad de programa sin modificar los programas que la mandan

ejecutar.

1.3.4. Agrupamiento en paquetes

Las unidades de programas pueden agruparse en paquetes, lo que mejora diversos aspectos

de la implementación (se verán en la sección 4)

1.3.5. Reutilización

Varias aplicaciones pueden utilizar la misma unidad de programa o el mismo paquete.

1.3.6. Mejor rendimiento

Cada unidad de programa es compilada y almacenada en forma ejecutable. Esto permite que

sea ejecutada varias veces de forma más ágil, ya que estas unidades de programa son ejecutadas en

el servidor de bases de datos. Sólo basta una simple llamada desde una aplicación para realizar

numerosos procesamientos de datos.





Página 12 de 48

También, usar unidades de programa reduce el tráfico en la red y mejora los tiempos de

respuesta. Además, las unidades de programa son compartidas entre varios usuarios, lo que reduce

requerimientos de memoria y de ejecución.

2. Crear procedimientos almacenados y funciones

2.1. Procedimientos almacenados y funciones

Como vimos, los procedimientos almacenados y funciones son bloques de código PL/SQL que

se encuentran almacenados en nuestra base de datos3. También son llamados subprogramas y

ambos son conocidos en la tecnología de bases de datos con el nombre genérico de procedimientos

almacenados.

2.1.1. Secciones de un procedimiento o función

En términos generales todo procedimiento o función incluye cuatro secciones que

describiremos a continuación.

2.1.1.1. Encabezado

Especifica el nombre y los parámetros del procedimiento o función. Los parámetros son

opcionales, esto es, el procedimiento o función puede tener o no parámetros de acuerdo al objetivo

para el que fueron creados.

2.1.1.2. Sección declarativa

Esta sección es opcional. En ella se declaran tipos, cursores, constantes, variables,

excepciones y subprogramas a nivel local. Todos los anteriores dejan de existir cuando el

procedimiento o función terminan de ejecutarse.

2.1.1.3. Sección ejecutable

Esta sección es obligatoria. Contiene instrucciones para asignar valores, controlar la ejecución

de las instrucciones y manipular datos.

3 Si desea ver documentación en línea sobre este tema visite el sitio

http://docs.oracle.com/cd/E11882_01/appdev.112/e25519/subprograms.htm#LNPLS008.

http://docs.oracle.com/cd/E11882_01/appdev.112/e25519/subprograms.htm#LNPLS008





Página 13 de 48

2.1.1.4. Sección de manejo de excepciones

Esta sección es opcional. Contiene instrucciones para manejar posibles errores de ejecución.

2.2. Crear y ejecutar procedimientos almacenados

Como habíamos dejado establecido, los procedimientos almacenados permiten ejecutar una o

varias acciones. Éstos son creados con el comando CREATE PROCEDURE.

Para ejecutar un procedimiento es necesario utilizar su nombre y definir valores para cada uno

de sus parámetros, por ejemplo aumenta_salario(12, 5000);

En la instrucción anterior, los valores 12 y 5000 son parámetros del procedimiento, éstos

podrían corresponder al identificador del empleado y al aumento en salario.

Veamos ahora un primer ejemplo de cómo crear y ejecutar un procedimiento. Ingrese al

entorno Application Express con el nombre de usuario y contraseña que le asignaron. Luego ingrese a

la sección SQL Commands del SQL Workshop. En el espacio de programación escriba el código del

Ejemplo 1. Para crear el procedimiento marque las instrucciones y ejecútelas con el comando

EXECUTE.

Ejemplo 1 Crear primer procedimiento para formar email

-- Encabezado: nombre y parámetros

CREATE OR REPLACE PROCEDURE crear_email (

nombre1 VARCHAR2,

nombre2 VARCHAR2,

empresa VARCHAR2

)

IS

-- Sección declarativa

email VARCHAR2(40);

mensaje_error VARCHAR2(30) := 'Email demasiado largo.';

BEGIN -- Sección ejecutable

email := nombre1 || '.' || nombre2 || '@' || empresa;

DBMS_OUTPUT.PUT_LINE ('Email: ' || email);

EXCEPTION -- Sección para manejo de excepciones

WHEN VALUE_ERROR THEN

DBMS_OUTPUT.PUT_LINE(mensaje_error);

END;

/

El código anterior concatena los valores de las variables nombre1, nombre2 y empresa para

crear una cuenta de correo electrónico. La cuenta de correo es almacenada en la variable email y

desplegada con el paquete DBMS_OUTPUT, que sirve para desplegar mensajes o monitorear la





Página 14 de 48

ejecución de las unidades de programas4. De hecho, se utiliza el procedimiento PUT_LINE(), que

permite desplegar una línea.

También se ejemplifica el manejo de excepciones. Si el email concatenado supera los 20

caracteres de la variable email, se produce un error. En ese momento el procedimiento detiene su

ejecución y pasa a ejecutar la sección de manejo de excepciones. En esta sección se imprime,

mediante el paquete DBMS_OUTPUT y el procedimiento PUT_LINE(), un mensaje de error.

Para ejecutar el procedimiento de Oracle podemos utilizar cualquiera de los grupos de

instrucciones del Ejemplo 2.

Ejemplo 2. Instrucciones para ejecutar un procedimiento

(1) BEGIN

crear_email('Juan', 'Ramos', 'miempresa');

END;

/

(2) EXECUTE crear_email('Juan', 'Ramos', 'miempresa');

(3) DECLARE

nombre VARCHAR2(20);

apellido VARCHAR2(20);

empresa VARCHAR2(20);

BEGIN

nombre := 'Juan';

apellido := 'Ramos';

empresa := 'miempresa';

crear_email(nombre, apellido, empresa);

END;

/

(4) BEGIN

crear_email('JuanFrancisco', 'RamosGutierrez', 'miempresacomercial');

END;

/

4 Más información sobre este paquete en

http://docs.oracle.com/cd/E11882_01/appdev.112/e25788/d_output.htm#autoId0. En SQL* Plus es necesario

activar una variable de entorno para ver las impresiones de este paquete, el comando que debe ejecutarse es

SET SERVEROUTPUT ON.

http://docs.oracle.com/cd/E11882_01/appdev.112/e25788/d_output.htm#autoId0





Página 15 de 48

El primer grupo de instrucciones (1) crea un bloque de programación para ejecutar el

procedimiento almacenado. Dentro de ese bloque se únicamente se llama al procedimiento utilizando

su nombre y pasando valor a sus parámetros.

En el segundo caso (2) se utiliza el comando EXECUTE para ejecutar el procedimiento.

Observe que no es necesario declarar un bloque de programación. Además, el punto y coma del final

es opcional. Esta manera de ejecutar un procedimiento funciona en SQL*Plus, pero no puede

funcionar en el entorno gráfico.

El tercer grupo de instrucciones (3) es un ejemplo en donde se declaran primero tres variables

(DECLARE). Después en el bloque de programación (BEGIN) se asigna valor a estas variables.

Finalmente se ejecuta el procedimiento utilizando las variables en lugar de valores.

La cuarta instrucción (4) ejecuta el procedimiento con cadenas de caracteres muy largas. Esto

se hace con el fin de probar si el procedimiento maneja adecuadamente el error cuando el correo

electrónico rebasa el tamaño de la variable email VARCHAR2(40). Como puede ver, después de

ejecutar esta instrucción, Oracle responde con el mensaje de error Email demasiado largo.

2.2.1. Crear y ejecutar funciones

Como dijimos arriba, las funciones realizan un cálculo y regresan un valor. Son creadas con el

comando CREATE FUNCTION.

Para ejecutar una función es necesario crear una expresión donde asignemos a una variable el

resultado de su ejecución, para ello debemos utilizar el nombre de la función y definir los valores para

cada uno de sus parámetros, por ejemplo salario_actual := obtener_salario(12);

En el ejemplo anterior, el valor 12 es el parámetro de la función obtener_salario(), ese

valor correspondería al identificador del empleado, el cual nos permitiría obtener su salario y

almacenarlo en la variable salario_actual.

Las funciones, a diferencia de los procedimientos, deben incluir la cláusula RETURN en la

sección de encabezado para indicar el tipo de dato de retorno. Además, cualquier secuencia de

programación dentro de la sección ejecutable debe terminar en la instrucción RETURN.

Veamos ahora un primer ejemplo de cómo crear y ejecutar una función. Ingrese al entorno

Application Express con el nombre de usuario y contraseña que le asignaron. Luego ingrese a la





Página 16 de 48

sección SQL Commands del SQL Workshop. En el espacio de programación escriba el código del

Ejemplo 3. Para crear la función marque las instrucciones y ejecútelas con el comando EXECUTE.

Ejemplo 3 Crear primera función para calcular cuadrado de un número

-- Encabezado: nombre y parámetros

CREATE OR REPLACE FUNCTION cuadrado (base NUMBER)

RETURN NUMBER -- Cláusula RETURN

AS

-- Sección declarativa

cuadrado_base NUMBER;

BEGIN -- Sección ejecutable

cuadrado_base := base * base;

RETURN cuadrado_base; -- Instrucción RETURN

END;

/

El código anterior calcula el cuadrado del número introducido mediante el único parámetro de la

función. Observe que es necesario usar la cláusula RETURN para establecer que la función regresará

un valor de tipo de dato NUMBER. Además, al interior de la sección ejecutable aparece la instrucción

RETURN para regresar el valor calculado.

Para ejecutar una función de Oracle podemos utilizar cualquiera de los grupos de instrucciones

del Ejemplo 4.

Ejemplo 4. Instrucciones para ejecutar una función

1) BEGIN

DBMS_OUTPUT.PUT_LINE(cuadrado(100));

END;

/

2) SELECT cuadrado(100) as cuadrado FROM dual;

El primer grupo de instrucciones crea un bloque de programación para ejecutar la función.

Dentro de ese bloque se utiliza el paquete DBMS_OUTPUT, que sirve para desplegar mensajes o

monitorear la ejecución de las unidades de programas5. En especial se utiliza el procedimiento

PUT_LINE(), que permite desplegar una línea.

5 Más información sobre este paquete en

http://docs.oracle.com/cd/E11882_01/appdev.112/e25788/d_output.htm#autoId0.

http://docs.oracle.com/cd/E11882_01/appdev.112/e25788/d_output.htm#autoId0





Página 17 de 48

En el segundo caso se utiliza el comando SELECT del lenguaje SQL para ejecutar la función.

Observe que se hace uso de la tabla DUAL6. Esta tabla es creada automáticamente desde la

instalación de Oracle y permite calcular expresiones mediante la cláusula SELECT.

2.2.2. Modos de parámetros

El modo de un parámetro indica su comportamiento. Los modos posibles son IN, OUT e IN

OUT. El modo IN es el modo por defecto, indica que el parámetro pasa un valor al procedimiento o

función. El modo OUT indica que el parámetro recibirá un valor dentro del procedimiento o función.

Finalmente, el modo IN OUT indica que el parámetro pasa un valor y después recibe otro valor dentro

del procedimiento o función.

Las buenas prácticas de programación recomiendan que en el caso de las funciones se evite

utilizar parámetros OUT o IN OUT, ya que la función está pensada para regresar un valor y no tiene

por qué modificar los valores de los parámetros. De hecho, en Oracle si una función utiliza parámetros

IN o IN OUT los resultados pueden ser inesperados.

2.2.3. Tipos de parámetros

Los parámetros de un procedimiento o función deben ser asociados a un tipo de datos. Existen

dos posibilidades para hacer esto. Por una parte podemos usar tipos no restringidos como NUMBER o

VARCHAR2. Estos tipos no pueden declararse con un tamaño asociado, es decir, está prohibido

declarar NUMBER(3) o VARCHAR2(40). Por otra podemos emplear tipos de datos restringidos

usando los atributos %TYPE o %ROWTYPE.

Declarar un parámetro con %TYPE asegura que el parámetro sea del mismo tipo que la columna

asociada al atributo %TYPE. En el Ejemplo 5 la declaración del procedimiento asigna al parámetro

numero_depto el mismo tipo de datos de la columna numDepto de la tabla Empleados.

Ejemplo 5. Tipo de parámetro con atributo %TYPE

CREATE OR REPLACE PROCEDURE aumenta_salario (

numero_depto Empleados.numDepto%TYPE

…

6 Más información sobre esta tabla en

http://docs.oracle.com/cd/E11882_01/server.112/e26088/queries009.htm#SQLRF20036.

http://docs.oracle.com/cd/E11882_01/server.112/e26088/queries009.htm#SQLRF20036





Página 18 de 48

Es recomendable utilizar el atributo %TYPE ya que si el tipo de datos de la columna cambia, no

tenemos que hacer cambios en nuestros procedimientos o funciones.

El atributo %ROWTYPE crea un registro que contiene todas las columnas de la tabla

especificada. Como puede verse en el Ejemplo 6, el parámetro empleado_info es creado como un

registro con todas las columnas de la tabla Empleado.

Ejemplo 6. Tipo de parámetro con atributo %ROWTYPE


empleado_info Empleados%ROWTYPE

…

Como comentario final de esta sección, podemos decir que las funciones pueden regresar un

valor declarado con el atributo %ROWTYPE. Veamos un ejemplo que utiliza estos tipos de datos

restringidos.

Ejemplo 7. Tipos de datos restringidos con atributos %TYPE y %ROWTYPE

CREATE OR REPLACE PROCEDURE datos_empleado (

id_empleado IN Empleados.idEmpleado%TYPE

)

IS

datos_empleado Empleados%ROWTYPE;

BEGIN

SELECT * INTO datos_empleado

FROM Empleados

WHERE idEmpleado = id_empleado;

DBMS_OUTPUT.PUT('ID: ' || datos_empleado.idEmpleado);

DBMS_OUTPUT.NEW_LINE;

DBMS_OUTPUT.PUT('NOMBRES: ' || datos_empleado.nombres);


DBMS_OUTPUT.PUT('APELLIDOS: ' || datos_empleado.apellidos);


DBMS_OUTPUT.PUT('CORREO ELECTRÓNICO: ' || datos_empleado.correoE);


END;

/

-- Para ejecutar el procedimiento

BEGIN

datos_empleado (1);

END;

/

2.2.4. Valores predeterminados para parámetros IN

Es posible declarar un parámetro de modo IN con un valor predeterminado (por defecto). Un

parámetro con este valor se convierte en un parámetro opcional. Esto es, si en la llamada del





Página 19 de 48

procedimiento o función se omite este parámetro, se toma el valor predeterminado. De lo anterior se

desprende que un parámetro sin valor predeterminado es un parámetro obligatorio.

En el Ejemplo 8 se puede ver cómo se declaran dos parámetros opcionales: cantidad y

bono, cada uno con su valor predeterminado (1000 y 500). En la llamada al procedimiento podemos

omitir los valores tanto de uno, como del otro.

Ejemplo 8. Parámetros IN con valores predeterminados

CREATE OR REPLACE PROCEDURE aumenta_salario_bono (

id_empleado IN Empleados.idEmpleado%TYPE,

cantidad IN Empleados.salario%TYPE := 1000,

bono IN Empleados.salario%TYPE := 500

) IS

BEGIN

UPDATE Empleados

SET salario = salario + cantidad + bono


END;

/

-- Para ejecutar el procedimiento

BEGIN

aumenta_salario (9); -- igual a aumenta_salario_bono(9, 1000, 500)

aumenta_salario (10, 2000);-- igual a aumenta_salario_bono(10, 2000, 500)

END;

/

-- Para consultar cambios realizados

SELECT * FROM Empleados WHERE idEmpleado IN (9, 10);

2.2.5. Notación de parámetros por posición, por nombre y mixta

Podemos utilizar tres notaciones para especificar parámetros en la llamada a un procedimiento

o función. La primera es por posición, que nos obliga a poner los parámetros en el mismo orden en el

que fueron declarados. La segunda es por nombre, en este caso utilizamos en nombre del parámetro y

lo asociamos a su valor con la siguiente sintaxis parámetro => valor. La tercera es mixta en el

sentido de que permite iniciar con notación por posición y después utilizar notación por

nombre.

Las notaciones por nombre y mixta son empleadas cuando tenemos parámetros

opcionales. Veamos el Ejemplo 9.

Ejemplo 9. Notaciones de parámetros por posición, por nombre y mixta






Página 20 de 48

id_empleado IN Empleados.idEmpleado%TYPE,

cantidad IN Empleados.salario%TYPE := 1000

) IS

BEGIN

UPDATE Empleados

SET salario = salario + cantidad


END;

/

BEGIN

aumenta_salario (5, 2000); -- por posición

aumenta_salario (id_empleado => 6, cantidad => 2000); -- por nombre

aumenta_salario (cantidad => 2000, id_empleado => 7); -- por nombre

aumenta_salario (8, cantidad => 2000); -- mixta

END;

/


SELECT * FROM Empleados WHERE idEmpleado IN (5, 6, 7, 8);

3. Mantenimiento de Procedimientos Almacenados y Funciones

3.1. Recompilar

Para recompilar un procedimiento o función debemos utilizar los comandos ALTER

PROCEDURE o ALTER FUNTION respectivamente. Es recomendable hacerlo después de modificar

tablas, vistas o cualquier objeto asociado a nuestro procedimiento o función. Recompilar previene

errores de ejecución y disminuye el tiempo que toma ejecutar la unidad de programa. El muestra cómo

recompilar el procedimiento aumenta_salario.

Ejemplo 10. Recompilar un procedimiento

ALTER PROCEDURE aumenta_salario COMPILE;

Es importante recordar que recompilar no significa cambiar la declaración o definición del

procedimiento o función. Para modificar estas unidades de programa es necesario eliminarlas y

volverlas a crear o bien utilizar la instrucción CREATE OR REPLACE. La cláusula OR REPLACE

primero borra el procedimiento o función (en caso de que exista) y luego lo vuelve a crear.





Página 21 de 48

3.2. Eliminar

Para eliminar un procedimiento o función utilizamos las instrucciones SQL DROP PROCEDURE

y DROP FUNCTION. Los siguientes son dos ejemplos de cómo eliminar un procedimiento y una

función.

Ejemplo 11. Eliminar un procedimiento y una función

DROP PROCEDURE aumenta_salario;

DROP FUNCTION cuadrado;

3.3. Diccionario de datos

Oracle incluye diversas vistas en el diccionario de datos que nos dan información sobre

nuestros procedimientos o funciones7. En la Tabla 1 se mencionan las principales.

Tabla 1. Vistas del sistema relacionadas con procedimientos y funciones

Vista del sistema Descripción

SYS.DBA_SOURCE

Describe el texto de todos los procedimientos y funciones de la base

de datos.

SYS.USER_SOURCE

Describe el texto de los procedimientos y funciones que pertenecen al

usuario conectado actualmente.

SYS.DBA_ARGUMENTS

Lista los argumentos de todos los procedimientos y funciones de la

base de datos.

SYS.USER_ARGUMENTS

Lista los argumentos de los procedimientos y funciones que

pertenecen al usuario conectado actualmente.

SYS.DBA_PROCEDURES

Describe todos los procedimientos y funciones PL/SQL de la base de

datos.

SYS.USER_PROCEDURES

Describe todos los procedimientos y funciones PL/SQL que

pertenecen al usuario conectado actualmente.

7 Para ver más información sobre las vistas y tablas del sistema visite el sitio

http://docs.oracle.com/cd/E11882_01/timesten.112/e21644/systemtables.htm#TTSYS346.

http://docs.oracle.com/cd/E11882_01/timesten.112/e21644/systemtables.htm#TTSYS346





Página 22 de 48

El Ejemplo 12 presenta cuatro consultas basadas en las vistas del sistema que mencionamos

atrás. La primera (1) y segunda (2) sirven para listar todos nuestros procedimientos y funciones. La

tercera (3) muestra los argumentos de cada uno. La cuarta (4) despliega el código del procedimiento

línea por línea.

Ejemplo 12. Consultas para obtener información sobre procedimientos y funciones

(1) SELECT DISTINCT name, type FROM USER_SOURCE WHERE TYPE IN

('PROCEDURE', 'FUNCTION') ORDER BY 2;

(2) SELECT object_name, object_type FROM USER_PROCEDURES

ORDER BY 1;

(3) SELECT object_name, argument_name, position, data_type

FROM USER_ARGUMENTS ORDER BY 1, 3;

(4) SELECT line, text FROM USER_SOURCE WHERE name =

'AUMENTA_SALARIO' ORDER BY 1;

4. Crear y mantener paquetes

4.1. Paquetes

Definiremos un paquete como una colección de objetos de programación (procedimientos,

funciones, variables, constantes, excepciones) relacionados y almacenados como una unidad dentro

de la base de datos8. Los paquetes brindan las siguientes ventajas.

Permiten mejor organización de una aplicación (¿cuáles eran los procedimientos para

administrar empleados?).

Mejoran el manejo de privilegios.

Es posible modificar el paquete sin recompilar los objetos que contiene (procedimientos y

funciones).

Oracle puede tener múltiple acceso a objetos de programación en memoria al mismo

tiempo.

8 Más información sobre este tema en

http://docs.oracle.com/cd/E11882_01/appdev.112/e25518/adfns_packages.htm#autoId2 y en

http://docs.oracle.com/cd/E11882_01/appdev.112/e25519/packages.htm#LNPLS009.

http://docs.oracle.com/cd/E11882_01/appdev.112/e25518/adfns_packages.htm#autoId2

http://docs.oracle.com/cd/E11882_01/appdev.112/e25519/packages.htm#LNPLS009





Página 23 de 48

Pueden contener variables globales disponibles para las funciones y procedimientos

almacenados en el paquete.

Un paquete puede contener varios procedimientos o funciones con el mismo nombre

(sobrecarga), con sólo cambiar el número de argumentos o el tipo de datos.

4.1.1. Secciones de un paquete

Un paquete tiene dos secciones. Cada una permite declarar o definir distintos objetos.

4.1.1.1. Especificación

En esta sección se declaran tipos, variables, constantes, funciones y procedimientos públicos,

es decir, que son visibles al exterior del paquete.

4.1.1.2. Cuerpo

En esta sección se definen los objetos declarados en la especificación y los que serán privados,

es decir, los que no serán visibles fuera del paquete.

4.2. Crear paquetes

En esta sección revisaremos cómo crear paquetes y ejecutar objetos dentro de ellos. Cada

sección de un paquete es creada con una instrucción diferente. Para la especificación utilizamos el

comando CREATE PACKAGE. Para el cuerpo del paquete usamos CREATE PACKAGE BODY. Es

recomendable usar la cláusula OR REPLACE para realizar modificaciones a nuestros paquetes. El

Ejemplo 13 muestra las instrucciones completas para crear un paquete.

Ejemplo 13. Instrucciones para crear un paquete (especificación y cuerpo)

CREATE OR REPLACE PACKAGE nombre_paquete AS ...

CREATE OR REPLACE PACKAGE BODY nombre_paquete AS ...

Cuando se crea el cuerpo del paquete es necesario asegurarse de que cada procedimiento o

función tenga los mismos parámetros que la especificación en cuanto al nombre, tipo y modo. En el

caso de las funciones también es necesario que el tipo de datos de retorno coincida en ambas

secciones. Obviamente, el nombre del paquete debe ser el mismo tanto en la especificación como en

el cuerpo.

El Ejemplo 14 muestra cómo crear un paquete con dos procedimientos y una función. Primero

se crea la especificación y después el cuerpo.





Página 24 de 48

Ejemplo 14. Crear el primer paquete para administrar empleados

-- Especificación del paquete.

CREATE or REPLACE PACKAGE administracion_empleados

IS

FUNCTION alta (

nombres VARCHAR2,

apellidos VARCHAR2,

correoE VARCHAR2,

salario NUMBER,

iddepto NUMBER

) RETURN NUMBER;

PROCEDURE baja (

empleado_id IN NUMBER

);

PROCEDURE aumenta_salario (

empleado_id IN NUMBER,

cantidad IN NUMBER

);

END administracion_empleados;

/

-- Cuerpo del paquete.

CREATE OR REPLACE PACKAGE BODY administracion_empleados

IS

FUNCTION alta (

nombres VARCHAR2,

apellidos VARCHAR2,

correoE VARCHAR2,

salario NUMBER,

iddepto NUMBER

) RETURN NUMBER

IS

nuevo_id NUMBER;

BEGIN

nuevo_id := empleado_seq.NEXTVAL;

INSERT INTO Empleados (

idEmpleado,

nombres,

apellidos,

correoE,

salario,

idDepto

)

VALUES (

nuevo_id,

nombres,

apellidos,

correoE,





Página 25 de 48

salario,

iddepto

);

RETURN (nuevo_id);

END alta;

PROCEDURE baja (

empleado_id IN NUMBER

)

IS

BEGIN

DELETE FROM Empleados

WHERE idEmpleado= empleado_id;

IF SQL%NOTFOUND THEN

raise_application_error(

-20011,

'El número de empleado no existe: ' || TO_CHAR(empleado_id)

);

END IF;

END baja;

PROCEDURE aumenta_salario (

empleado_id IN NUMBER,

cantidad IN NUMBER

)

IS

BEGIN

UPDATE Empleados

SET salario = salario + cantidad

WHERE idEmpleado = empleado_id;

IF SQL%NOTFOUND THEN

raise_application_error(

-20011,

' El número de empleado no existe: ' || TO_CHAR(empleado_id)

);

END IF;

END aumenta_salario;

END administracion_empleados;

/

Para ver los paquetes que hemos creado y los subprogramas asociados podemos utilizar la

consulta del Ejemplo 15.

Ejemplo 15. Consulta para obtener información sobre paquetes

SELECT object_name, procedure_name FROM user_procedures WHERE object_type =

'PACKAGE';





Página 26 de 48

Finalmente, para ejecutar los procedimientos o funciones incluidos dentro de los paquetes

utilizamos la notación nombre_paquete.nombre_procedimiento o

nombre_paquete.nombre_funcion. En el Ejemplo 16 y Ejemplo 17 podemos ver cómo hacerlo.

Ejemplo 16. Instrucciones para ejecutar funciones de un paquete

(1) DECLARE

nuevo_empleado NUMBER(6);

BEGIN

nuevo_empleado := administracion_empleados.alta(

'Roberto',

'Solís',

'[email protected]',

2500,

20);

DBMS_OUTPUT.PUT_LINE('El ID del nuevo empleado es: ' ||

TO_CHAR(nuevo_empleado));

END;

/


SELECT * FROM Empleados;

Ejemplo 17. Instrucciones para ejecutar procedimientos de un paquete

(1) BEGIN

administracion_empleados.baja(11);

END;

/



(2) BEGIN

administracion_empleados.aumenta_salario(1, 1000);

END;

/



4.3. Mantener Paquetes.

En esta sección describiremos las instrucciones para eliminar y recompilar paquetes.





Página 27 de 48

4.3.1. Eliminar paquetes

Para eliminar un paquete utilizamos la instrucción DROP PACKAGE. Esta instrucción elimina

tanto la especificación del paquete como su cuerpo. Si lo que queremos es eliminar un procedimiento o

función dentro de un paquete, debemos volver a crear el paquete sin ese procedimiento o función.

Es posible eliminar sólo el cuerpo de un paquete. Pare ello debemos agregar la cláusula BODY.

Si esta cláusula no aparece, se entiende que se desea eliminar tanto el cuerpo como la especificación.

Eliminar sólo el cuerpo permite que todos los objetos que hacen referencia al paquete permanezcan

validos e inalterables. El Ejemplo 18 muestra cómo eliminar el cuerpo del paquete

administracion_empleados, además muestra cómo eliminar todo el paquete.

Ejemplo 18. Instrucciones para eliminar paquetes

DROP PACKAGE BODY administracion_empleados;

DROP PACKAGE administracion_empleados;

4.3.2. Recompilar paquetes

Podemos recompilar la especificación, el cuerpo o todo un paquete con el comando ALTER

PACKAGE. Este tipo de recompilación se conoce como recompílación explícita y es buena idea ya que

disminuye la probabilidad de errores de ejecución y aumenta el rendimiento de la base de datos. Con

este comando son recompilados todos los procedimientos y funciones del paquete. El comando ALTER

PACKAGE no cambiar la definición de un paquete, si queremos cambiarla debemos eliminarlo y

volverlo a crear. Entonces, para compilar un paquete utilizamos la instrucción ALTER PACKAGE

nombre_paquete COMPILE [SPECIFICATION | BODY | PACKAGE]. El muestra cómo compilar

el cuerpo del paquete administracion_empleados así como todo el paquete completo.

Ejemplo 19. Instrucciones para recompilar un paquete

ALTER PACKAGE administracion_empleados COMPILE;

ALTER PACKAGE administracion_empleados COMPILE BODY;





Página 28 de 48

5. Triggers de bases de datos

5.1. Triggers de bases de datos

5.1.1. Introducción

Un trigger es una unidad de programa almacenada en la base de datos que se ejecuta

automáticamente cuando ocurre un evento9. Esto implica que no es posible mandar ejecutar un trigger

de manera explícita, como se hace con los procedimientos y las funciones, sólo la base de datos

puede hacerlo. Lo que sí es posible es habilitar o deshabilitar un trigger.

Para crear un trigger se utiliza el comando CREATE TRIGGER. Es necesario indicar el evento

que desencadena el trigger y el objeto sobre el que actúa este evento, generalmente una tabla.

También es posible indicar si el trigger se ejecuta antes o después de que el evento suceda y si el

trigger se ejecuta por cada renglón que afecta el evento.

Si el trigger se crea para una tabla o vista, entonces el evento es una sentencia DML10

(INSERT, DELETE, UPDATE) y se conoce como trigger DML. Por otro lado, si el trigger se crea para

un esquema o para la base de datos, entonces el evento puede ser una sentencia DDL11 (CREATE,

DROP) o una operación sobre la base de datos (LOGON), en este caso el trigger es llamado trigger de

sistema.

5.1.2. Tareas que puede realizar un trigger

Un trigger brinda funcionalidad a la base de datos. Permite realizar labores rutinarias y de

administración. Algunas de las principales tareas que puede realizar son:

Llevar una bitácora de eventos.

Recopilar estadísticas de acceso a tablas.

Asegurar la integridad referencial entre tablas almacenadas en distintos nodos de una base

de datos distribuida.

9 Más información sobre triggers de bases de datos en

http://docs.oracle.com/cd/E11882_01/appdev.112/e25519/triggers.htm#LNPLS020.

10 DML, del inglés Data Manipulation Language.

11 DDL, del inglés Data Definition Language.

http://docs.oracle.com/cd/E11882_01/appdev.112/e25519/triggers.htm#LNPLS020





Página 29 de 48

Prevenir modificaciones a los datos en horarios fuera de lo normal.

Prevenir transacciones inválidas.

Obligar a que se cumplan reglas de negocio que no pueden asegurarse con restricciones

de integridad (constraints).

5.1.3. Triggers DML

Un trigger DML es creado para una tabla o vista y se ejecuta automáticamente cuando se da un

evento de INSERT, DELETE o UPDATE. Este tipo de trigger puede ejecutarse en cuatro momentos que

se muestran en la Tabla 2.

Tabla 2. Momentos de ejecución de un trigger

Nombre Momento de ejecución

BEFORE trigger a nivel de sentencia Antes de que el evento sea ejecutado

AFTER trigger a nivel de sentencia Después de que el evento sea ejecutado

BEFORE trigger a nivel de renglón Antes de cada renglón que afecta el evento.

AFTER trigger a nivel de renglón Después de cada renglón que afecta el evento.

Un trigger DML ejecutado por una sentencia UPDATE puede llevar una lista de columnas, de

manera tal que el trigger sólo se ejecutará si alguna de esas columnas es modificada.

5.1.4. Predicados condicionales para sentencias DML

Los trigger DML pueden declararse para ser ejecutados por una sentencia DML o por varias de

ellas, incluso por las tres. Dada esta situación, resulta conveniente conocer qué sentencia

desencadenó la ejecución del trigger. Esto se puede saber gracias a cuatro predicados condicionales

que almacenan el valor de TRUE de acuerdo a la sentencia que desencadenó el trigger (véase Tabla

3).

Tabla 3. Predicados condicionales para determinar sentencia DML

Predicado condicional Almacena TRUE cuando





Página 30 de 48

INSERTING Un INSERT desencadenó el trigger.

UPDATING Un UPDATE desencadenó el trigger.

UPDATING('columna') Un UPDATE en la columna especificada desencadenó el trigger.

DELETING Un DELETE en la columna especificada desencadenó el trigger.

5.1.5. Seudoregistros OLD y NEW

Si un trigger se ejecuta para cada renglón que afecta la sentencia DML, el trigger tiene acceso

a los datos del renglón que está siendo afectado. Dicho acceso se logra mediante los seudoregistros

OLD y NEW. La manera de hacer referencia a un valor de estos seudoregistros es mediante la

instrucción :seudoregistro.nombre_campo, por ejemplo, :NEW.idEmpleado. Los valores que

toman estos seudoregistros dependen de la sentencia que desencadenó el trigger y son mostrados en

la Tabla 4.

Tabla 4. Valores de los seudoregistros OLD y NEW

Sentencia Valor de OLD.nombre_campo Valor de NEW.nombre_campo

INSERT NULL Valores posteriores al INSERT

UPDATE Valores previos al UPDATE Valores posteriores al UPDATE

DELETE Valores previos al DELETE NULL

Para hacer buen uso de los seudoregistros debemos cuidar las siguientes restricciones.

No es posible usar el seudoregistro sin nombre de columna, por ejemplo, esta instrucción

está prohibida :NEW := NULL.

Un seudoregistro no puede pasar como parámetro.

Un trigger no puede cambiar los valores del seudoregistro OLD.

Un DELETE trigger no puede cambiar los valores del seudoregistro NEW.





Página 31 de 48

Un AFTER trigger no puede cambiar los valores del seudoregistro NEW, ya que la sentencia

DML se ejecuta antes del trigger.

Un BEFORE trigger puede cambiar los valores del seudoregistro NEW antes de que la

sentencia INSERT o UPDATE los cambien en la tabla.

5.1.6. Resumen de tipos de triggers

En la Tabla 5 se ofrece un resumen de los tipos de triggers posibles de acuerdo a las

características discutidas. Sirva esta tabla como referencia para discusiones posteriores. Recuerde

que es posible la combinación de categorías.

Tabla 5. Resumen de tipos de triggers

Categoría Descripción Tipos de triggers

Sentencia Evento DML que desencadena el trigger INSERT trigger

DELETE trigger

UPDATE trigger

Momento Antes o después del evento que desencadena el

trigger

BEFORE trigger

AFTER trigger

Nivel Nivel de afectación del evento DML. Indica si el

trigger se ejecuta por la sentencia o por cada renglón

afectado.

Trigger a nivel de renglón

Trigger a nivel de sentencia

Objeto

asociado

Objeto al que afecta el evento, pueden ser tablas y

vistas, o esquemas y base de datos.

Trigger DML

Trigger de sistema

5.2. Crear triggers de bases de datos

En esta sección se darán ejemplos de cómo crear triggers con las características expuestas en

los apartados anteriores.

El muestra las instrucciones para crear un trigger que utiliza los predicados condicionales para

indicar, mediante la impresión de un letrero, qué evento lo desencadenó.





Página 32 de 48

Ejemplo 20. Ejemplo de trigger con predicados condicionales

CREATE OR REPLACE TRIGGER trg_predicados

BEFORE

INSERT OR

UPDATE OF salario, idDepto OR

DELETE

ON Empleados

BEGIN

CASE

WHEN INSERTING THEN

DBMS_OUTPUT.PUT_LINE('Trigger desencadenado por INSERT');

WHEN UPDATING('salario') THEN

DBMS_OUTPUT.PUT_LINE('Trigger desencadenado por UPDATE de salario');

WHEN UPDATING('idDepto') THEN

DBMS_OUTPUT.PUT_LINE('Trigger desencadenado por UPDATE de idDepto');

WHEN DELETING THEN

DBMS_OUTPUT.PUT_LINE('Trigger desencadenado por DELETE');

END CASE;

END;

/

Ejemplo 21. Instrucciones para desencadenar trigger con predicados condicionales

(1) -- Desencadenar trigger por INSERT

DECLARE

nuevo_empleado NUMBER(6);

BEGIN

nuevo_empleado := administracion_empleados.alta(

'Andrea',

'Preciado',

'[email protected]',

19000,

30);

DBMS_OUTPUT.PUT_LINE('El ID del nuevo empleado es: ' ||

TO_CHAR(nuevo_empleado));

END;

/

(2) -- Desencadenar trigger por DELETE

BEGIN

administracion_empleados.baja(12);

END;

/

(3) -- Desencadenar trigger por UPDATE de salario

BEGIN


END;

/

-- Desencadenar trigger por UPDATE de idDepto





Página 33 de 48

UPDATE empleados SET idDepto=20 WHERE idEmpleado=1;

Ejemplo 22. Ejemplo de trigger para llevar bitácora de movimientos

—- Crear tabla bitácora

—- DROP TABLE bitac_salarios;

CREATE TABLE bitac_salarios (

idEmpleado NUMBER,

fecha_mov TIMESTAMP,

salario_nuevo NUMBER,

salario_anterior NUMBER

);

-- Crear trigger para llevar bitácora de movimientos

CREATE OR REPLACE TRIGGER tri_bitacora_salario

AFTER UPDATE OF salario ON Empleados

FOR EACH ROW

BEGIN

INSERT INTO bitac_salarios (idEmpleado, fecha_mov, salario_nuevo,

salario_anterior)

VALUES (:NEW.idEmpleado, SYSDATE, :NEW.salario, :OLD.salario);

END;

/

—- Desencadenar trigger modificando salario

BEGIN


END;

/

—- Revisar registro de movimientos en bitácora

SELECT * FROM bitac_salarios;

—- Desencadenar trigger modificando salario para varios registros

UPDATE Empleados

SET salario = salario + 1000

WHERE idDepto = 20;

—- Revisar registro de movimientos en bitácora

SELECT * FROM bitac_salarios;





Página 34 de 48

5.3. Mantener triggers de bases de datos

En esta sección revisaremos algunas opciones para el mantenimiento de triggers.

Específicamente, aquellos comandos para activar, desactivar, compilar y eliminar triggers. Además,

ponemos algunas consultas al diccionario de datos que son útiles para obtener información sobre

nuestros triggers.

5.3.1. Activar, desactivar y compilar triggers

El comando ALTER TRIGGER permite activar, desactivar y compilar triggers12. No sirve para

modificar la definición de un trigger, para ello es necesario eliminarlo y volverlo a crear, o utilizar la

instrucción CREATE OR REPLACE TRIGGER.

La instrucción general es ALTER TRIGGER nombre_trigger [ENABLE | DISABLE |

COMPILE ]. El Ejemplo 23 muestra algunas instrucciones asociadas a este comando.

Ejemplo 23. Activar, desactivar y compilar triggers

-- Desactivar un trigger

ALTER TRIGGER trg_predicados DISABLE;

-- Ejecutar DML sobre tabla para verificar si se dispara el trigger.

BEGIN


END;

/

-- Activar un trigger

ALTER TRIGGER trg_predicados ENABLE;

-- Ejecutar DML sobre tabla para verificar si se dispara el trigger.

BEGIN


END;

/

-- Compilar un trigger

ALTER TRIGGER trg_predicados COMPILE;

Las principales razones por las que un trigger es desactivado son:

Cargar datos en una tabla de manera rápida, evitando que se desencadenen los triggers

asociados.

12

Para desactivar todos los triggers de una tabla utilice el comando ALTER TABLE nombre_tabla [

ENABLE | DISABLE ] ALL TRIGGERS.





Página 35 de 48

Volver a cargar los datos en una tabla.

5.3.2. Consultas para obtener información sobre triggers

En el Ejemplo 24 podemos encontrar dos consultas que nos muestran información sobre

nuestros triggers. La primera muestra algunas características de un trigger específico, para ello hace

uso de la vista de sistema USER_TRIGGERS. La segunda muestra las primeras líneas del cuerpo del

trigger, haciendo uso de la misma vista de sistema13.

Ejemplo 24. Consultas para obtener información sobre triggers

-- Características de un trigger.

SELECT Trigger_type, Triggering_event, Table_name, Status

FROM USER_TRIGGERS

WHERE Trigger_name = 'TRG_PREDICADOS';

-- Muestra las primeras líneas del cuerpo del trigger

SELECT Trigger_body

FROM USER_TRIGGERS

WHERE Trigger_name = 'TRG_PREDICADOS';

13

Para ver el cuerpo completo del trigger puede ejecutar la instrucción "SET LONG 10000".





Página 36 de 48

Fuentes de Información

Bibliografía

Elmasri, R. y Navathe, S. (2007). Fundamentos de sistemas de bases de datos. Madrid:

Pearson Educación.





Página 37 de 48

Anexo A. Procedimientos útiles para trabajar con Oracle Database

XE

En este anexo podrá encontrar varios procedimientos útiles para el trabajo de programación en

Oracle Database XE. Estos procedimientos se incluyen en este material a manera de apoyo.

Procedimiento 1. Crear espacio de trabajo y entrar al entorno de programación en SQL

1. Desde el botón Iniciar seleccione la opción Get Started del grupo Oracle Database 11g

Express Edition. Esta opción abrirá su navegador predeterminado y le dará acceso al

entorno de trabajo de Oracle.

2. En el entorno de trabajo de Oracle seleccione la opción Application Express.





Página 38 de 48

3. Lo anterior dará como resultado una página de acceso. Ingrese en la caja de texto

Username el nombre de usuario SYS y en la caja de texto Password la palabra curso.

Luego presione el botón Login. Lo anterior le dará acceso al sistema como el usuario de

administración SYS.

4. Si los datos fueron escritos correctamente, aparecerá una página para crear su espacio de

trabajo. Asegúrese de poner los siguientes datos. Luego presione el botón Create

Workspace.

a. Database User: Create New

b. Database Username: CURSODEC

c. Application Express Username: cursodec

d. Password: curso100%

e. Confirm Password: curso100%





Página 39 de 48

5. Oracle le confirmará la creación exitosa de su espacio de trabajo y le brindará la opción de

ingresar con el usuario que creó. Haga clic en To begin, click here to login, para ingresar a

la página de acceso de su espacio de trabajo.

6. En la página de acceso de su espacio de trabajo llene las cajas de texto con la información

que proporcionó en el paso 4 y presione el botón Login.





Página 40 de 48

7. Ahora se encuentra en su espacio de trabajo. Para comenzar a programar en SQL

seleccione la opción SQL Commands del menú SQL Workshop.

8. El paso anterior abre la página de programación en SQL, en donde realizaremos todos los

ejercicios del curso. Para confirmar que puede comenzar a trabajar, escriba la instrucción

SELECT * FROM demo_customers; luego márquela y presione el botón Run. Como

resultado deberán desplegarse varios registros en la parte inferior de la página, como se ve

en la siguiente figura. Si puede ver estos registros está listo para comenzar a programar en

SQL.





Página 41 de 48

Procedimiento 2. Entrar al entorno de programación en SQL

Este procedimiento se realiza siempre y cuando ya haya creado su espacio de trabajo. Si

no ha creado su espacio de trabajo, realice el Procedimiento 1.

1. Desde el botón Iniciar seleccione la opción Get Started del grupo Oracle Database 11g

Express Edition. Esta opción abrirá su navegador predeterminado y le dará acceso al

entorno de trabajo de Oracle.





Página 42 de 48

2. En el entorno de trabajo de Oracle seleccione la opción Application Express.

3. Lo anterior dará como resultado una página de acceso. Ingrese en la caja de texto

Username el nombre de usuario SYS y en la caja de texto Password la palabra curso.

Luego presione el botón Login. Lo anterior le dará acceso al sistema como el usuario de

administración SYS.





Página 43 de 48

4. Si los datos fueron escritos correctamente, aparecerá una página para crear su espacio de

trabajo (si no ha creado su espacio de trabajo realice el Procedimiento 1). Dado que usted

ya ha creado su espacio de trabajo, debe seleccionar la opción Already have an account?

Login Here, que se encuentra del lado derecho de la página (sección Getting Started). Esto

le permitirá ingresar a la página de acceso de su espacio de trabajo.

5. En la página de acceso de su espacio de trabajo llene las cajas de texto con la siguiente

información. Luego presione el botón Login.

a. Workspace: CURSODEC

b. Username: cursodec

c. Password: curso100%





Página 44 de 48

6. Ahora se encuentra en su espacio de trabajo. Para comenzar a programar en SQL

seleccione la opción SQL Commands del menú SQL Workshop.

7. El paso anterior abre la página de programación en SQL, en donde realizaremos todos los

ejercicios del curso. Para confirmar que puede comenzar a trabajar, escriba la instrucción

SELECT * FROM demo_customers; luego márquela y presione el botón Run. Como

resultado deberán desplegarse varios registros en la parte inferior de la página, como se ve

en la siguiente figura. Si puede ver estos registros está listo para comenzar a programar en

SQL.





Página 45 de 48





Página 46 de 48

Anexo B. Instrucciones para crear tablas de ejemplo

—- DROP SEQUENCE empleado_seq;

CREATE SEQUENCE empleado_seq

START WITH 1

INCREMENT BY 1;

—- DROP TABLE Empleados;

CREATE TABLE Empleados (

idEmpleado NUMERIC PRIMARY KEY,

nombres VARCHAR2(40),

apellidos VARCHAR2(40),

correoE VARCHAR(40),

salario NUMERIC,

idDepto NUMERIC

);

-- DELETE FROM Empleados;

INSERT INTO Empleados

VALUES(empleado_seq.NEXTVAL, 'Marlene', 'Acosta', '[email protected]', 7000, 10);


VALUES(empleado_seq.NEXTVAL, 'Carolina', 'Buelna', '[email protected] ', 6800,

10);


VALUES(empleado_seq.NEXTVAL, 'Eva', 'Montes', '[email protected] ', 8000, 10);


VALUES(empleado_seq.NEXTVAL, 'Laura', 'Trejo', '[email protected] ', 15000, 20);


VALUES(empleado_seq.NEXTVAL, 'Miguel', 'Romero', '[email protected] ', 18500,

20);


VALUES(empleado_seq.NEXTVAL, 'Norma', 'Zola', '[email protected] ', 19000, 20);


VALUES(empleado_seq.NEXTVAL, 'Patricia', 'Chávez', '[email protected] ', 10000,

30);


VALUES(empleado_seq.NEXTVAL, 'Sonia', 'Humm', '[email protected] ', 25000, 30);


VALUES(empleado_seq.NEXTVAL, 'Victor', 'Ibarra', '[email protected] ', 9500, 30);


VALUES(empleado_seq.NEXTVAL, 'Mónica', 'Gómez', '[email protected] ', 12000, 30);

—- SELECT * FROM Empleados;

-- La siguiente imagen muestra el resultado esperado.





Página 47 de 48





Página 48 de 48

Contacto

Para cualquier duda o aclaración puede contactarnos en:

01-800-8-DEC-FCA

01-800-8-332-322

Teléfonos

(55) 5514 4948, (55) 5514 4794

Conmutador

(55) 5533 1617 al 19

Jefe de la División

Mtro. Eric M. Rivera Rivera

[email protected]

Subjefa de la División

Mtra. Adriana Arias Cedillo

[email protected]

Coordinador Administrativo

Lic. Héctor Mauricio Moguel Martínez

[email protected]

Coordinador Académico

Lic. Gabriel Guevara Gutiérrez

[email protected]

Manual oracle plsql_intermedio_2012

Documents

Transcript of Manual oracle plsql_intermedio_2012