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]

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.

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.

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.

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.

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.

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.

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.

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.

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',
'roberto.solis@empresa.com',
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.

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',
'andre.preciado@empresa.com',
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', 'macosta@empresa.com', 7000, 10);
VALUES(empleado_seq.NEXTVAL, 'Carolina', 'Buelna', 'cbuelna@empresa.com ', 6800,
10);
VALUES(empleado_seq.NEXTVAL, 'Eva', 'Montes', 'emontes@empresa.com ', 8000, 10);
VALUES(empleado_seq.NEXTVAL, 'Laura', 'Trejo', 'ltrejo@empresa.com ', 15000, 20);
VALUES(empleado_seq.NEXTVAL, 'Miguel', 'Romero', 'mromero@empresa.com ', 18500,
20);
VALUES(empleado_seq.NEXTVAL, 'Norma', 'Zola', 'nzola@empresa.com ', 19000, 20);
VALUES(empleado_seq.NEXTVAL, 'Patricia', 'Chávez', 'pchavez@empresa.com ', 10000,
30);
VALUES(empleado_seq.NEXTVAL, 'Sonia', 'Humm', 'shumm@empresa.com ', 25000, 30);
VALUES(empleado_seq.NEXTVAL, 'Victor', 'Ibarra', 'vibarra@empresa.com ', 9500, 30);
VALUES(empleado_seq.NEXTVAL, 'Mónica', 'Gómez', 'mgomez@empresa.com ', 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
erivera@dec.fca.unam.mx
Subjefa de la División
Mtra. Adriana Arias Cedillo
aarias@dec.fca.unam.mx
Coordinador Administrativo
Lic. Héctor Mauricio Moguel Martínez
hmoguel@dec.fca.unam.mx
Coordinador Académico
Lic. Gabriel Guevara Gutiérrez
gguevara@dec.fca.unam.mx

Manual oracle plsql_intermedio_2012

Más contenido relacionado

La actualidad más candente (15)

Destacado (20)

Similar a Manual oracle plsql_intermedio_2012 (20)

Manual oracle plsql_intermedio_2012