PRÁCTICA

Procedimientos, Funciones y Secuencias

 Procedimientos, funciones y secuencias

Indice

1 SUBPROGRAMAS. .................................................................................................................................................................... 3

1.1 DEFINICIÓN DE PROCEDIMIENTOS Y FUNCIONES. ............................................................... 3

1.1.1 Ejemplo creación de procedimiento. ................................................................................................... 3
1.1.2 Ejemplo creación de función. ............................................................................................................... 4
1.2 LLAMADAS A PROCEDIMIENTOS Y FUNCIONES. ..................................................................... 4
1.3 DOCUMENTACIÓN DE PROCEDIMIENTOS Y FUNCIONES ....................................................... 5
1.4 DEPURACIÓN DE PROCEDIMIENTOS Y FUNCIONES. .............................................................. 5
1.5 PACKAGE ............................................................................................................................... 5
1.5.1 Ejemplo creación de package................................................................................................................ 5
2 SECUENCIAS............................................................................................................................................................................ 7

2.1 DEFINIR Y REFERENCIAR SECUENCIAS. ................................................................................ 7

2.1.1 Ejemplo de secuencia. ............................................................................................................................ 7
EJERCICIO 1. ...................................................................................................................................................................................... 8
EJERCICIO 2....................................................................................................................................................................................... 9
EJERCICIO 3....................................................................................................................................................................................... 9

Pág. 2 de 9
 Procedimientos, funciones y secuencias

1 Subprogramas.
Oracle permite acceder y manipular información de la base de datos definiendo objetos procedurales
(subprogramas) que se almacenan en la base de datos. Estos objetos procedurales son unidades de
programa PL/SQL: Funciones y Procedimientos almacenados.

Los procedimientos o funciones son bloques PL/SQL con nombre, que pueden recibir parámetros y
pueden ser invocados desde distintos entornos: SQL*PLUS, Oracle*Forms, desde otros procedimientos y
funciones y desde otras herramientas Oracle y aplicaciones.

Packages es un método de encapsular ó agrupar en una sola unidad Procedimientos y Funciones

relacionados lógicamente.

Los procedimientos y funciones llevan a cabo tareas específicas. Las funciones devuelven un valor.
Se crean desde el SQL*PLUS o SQL*DBA.

1.1 Definición de procedimientos y funciones.

Para definir los procedimientos y funciones almacenados se usa el comando SQL:
CREATE PROCEDURE / FUNCTION.

La definición de un procedimiento ó función tiene dos partes: Especificación y Cuerpo.

• En la Especificación, se declara el nombre del subprograma, el nombre y tipo de los argumentos y,

sólo en las funciones, el nombre y tipo de dato del valor que devuelven.

• En el Cuerpo se define, mediante comandos y sentencias SQL y PL/SQL, la tarea específica que
realiza el subprograma.

Cuando se crea un procedimiento ó función, Oracle automáticamente compila el código fuente, guarda el
código objeto en un área compartida de la SGA (System Global Area) y almacena tanto el código fuente
como el código objeto en catálogos del diccionario de datos.

El código objeto permanece en la SGA, por tanto, los subprogramas se ejecutan más rápidamente y lo
pueden compartir muchos usuarios. Cuando es necesario liberar áreas de la SGA, Oracle aplica el algoritmo
‘menos-usado-recientemente’. Si en un momento determinado se libera el área SQL de un subprograma, la
próxima vez que se ejecute se vuelve a cargar el código objeto, que está almacenado en catálogo, en la SGA.

1.1.1 Ejemplo creación de procedimiento.

CREATE OR REPLACE PROCEDURE contratar_empleado

(w_código_emp IN emp.código_emp%TYPE,
w_fecha_alta IN emp.fecha_alta%TYPE,
w_depart IN emp.cod_depart%TYPE) IS
BEGIN
INSERT INTO emp(código_emp, fecha_alta, cod_depart)
VALUES (w_código_emp, w_fecha_alta, w_depart);
COMMIT WORK;
END contratar_empleado;

Pág. 3 de 9
 DBD Práctica-3 Procedimientos, funciones y secuencias
Sevilla, Febrero 2007, V 2007.02.1

1.1.2 Ejemplo creación de función.

CREATE OR REPLACE FUNCTION obtener_salario
(w_código_emp IN emp.código_emp%TYPE)
RETURN NUMBER
IS
w_salario emp.salario_emp%TYPE;
BEGIN
SELECT salario_emp
INTO w_salario
FROM emp
WHERE código _emp = w_código_emp;
RETURN (w_salario);
END obtener_salario;
Cada función debe devolver un valor del tipo especificado utilizando la sentencia RETURN.

1.2 Llamadas a procedimientos y funciones.

Los procedimientos y funciones definidos bien de forma independiente, bien dentro de un Package, se
pueden invocar desde diferentes entornos de ejecución:

• Desde otro procedimiento, función y triggers.

[Package.]nom-proc (par1, par2...parn);

CREATE PROCEDURE proceso ... IS ...

BEGIN
...
/* llamada al procedimiento contratar_empleado */
contratar_empleado (‘2645’,’19/12/1999’,’Contabilidad’);

/* llamada a la función obtener_salario */

w_sal :=obtener_salario (w_código);
...
END;

• Herramientas de desarrollo de aplicaciones de Oracle:

SQL*Plus, SQL*Dba, SQL*Forms, SQL*Menu, SQL*ReportWriter, etc.

EXECUTE [Package.]nom-pro (par1, par2,...parn)

EXECUTE contratar_empleado (‘2645’,’19/12/1999’,’Contabilidad’);

• Precompiladores de Oracle:
Pro*C, Pro*Cobol, Pro*PL/I, Pro*Ada, Pro*Fortran, etc. Se incluyen bloques PL/SQL embebidos en
programas escritos en lenguajes de alto nivel (C, Cobol, PL/I, etc.)

EXEC SQL EXECUTE

BEGIN
[Package.]nom-proc (:par1, :par2...,:parn) END;
END;
END-EXEC;
/
Pág. 4 de 9
 DBD Práctica-3 Procedimientos, funciones y secuencias
Sevilla, Febrero 2007, V 2007.02.1

1.3 Documentación de procedimientos y funciones

• Para obtener los nombres de todos los procedimientos y funciones se puede consultar la VISTA
USER_OBJECTS
SELECT object_name, object_type FROM USER_OBJECTS
WHERE object_type IN (‘PROCEDURE’ , ‘FUNCTION’);

• Para obtener el texto de un procedimiento o función almacenado se puede consultar la VISTA

USER_SOURCE
SELECT text FROM USER_SOURCE
WHERE type = ‘PROCEDURE’ AND name = ‘CONTRATAR_EMPLEADO’

• Para visualizar los errores de compilación se puede consultar la VISTA USER_ERRORS o el

comando SHOW ERRORS.

1.4 Depuración de procedimientos y funciones.

• Se pueden visualizar valores o mensajes desde un procedimiento o función, invocando al package
standard DBMS_OUPUT.

Procedimiento Descripción
DBMS_OUTPUT.PUT Añade texto a la línea actual
DBMS_OUTPUT.NEW_LINE Marca un final de línea
DBMS_OUTPUT.PUT_LINE Combina PUT y NEW_LINE

Es necesario activar SERVEROUTPUT desde SQL*PLUS o SQL*DBA para ver las salidas desde
procedimientos o funciones almacenados: SET SERVEROUTPUT ON

1.5 Package
Un Package es un objeto que permite encapsular ó agrupar procedimientos, funciones, cursores, variables,
etc. que están relacionados lógicamente y almacenarlos en la base de datos como una sola unidad.

Los métodos de definición de Packages, permiten especificar qué variables, cursores, procedures, etc. son
públicos (accesibles directamente por los usuarios) y cuáles privados (no accesibles por los usuarios).
Un Package se crea en dos partes separadas: Especificación y Cuerpo:
• Especificación (CREATE PACKAGE): se declaran los constructores públicos del Package. Esta
parte del Package es la interface con las aplicaciones de los usuarios.
• Cuerpo (CREATE PACKAGE BODY): se declaran los constructores privados del Package y se
definen todos los procedimientos y funciones (públicos y privados).

1.5.1 Ejemplo creación de package.

Crear un Package (p-emp) para encapsular en una sola unidad, las funciones, procedimientos, etc.
necesarios para gestionar el mantenimiento de los empleados.

En la Especificación del Package (CREATE PACKAGE). Se declaran todas las variables, funciones,
procedimientos, etc. que sean públicos; es decir, accesibles desde las aplicaciones de los usuarios:
Variable wtotal-emp (número total de empleados),
Función inserta-emp (insertar empleado, devuelve la clave primaria del nuevo empleado)
Procedimiento borra-emp (borrar empleado) y
Procedimiento actualiza-comsal (actualizar comisiones de salario de un empleado).

Pág. 5 de 9
 DBD Práctica-3 Procedimientos, funciones y secuencias
Sevilla, Febrero 2007, V 2007.02.1

Podemos ver que al declarar los procedimientos y funciones, sólo se incluye la parte de Especificación; es
decir, nombre del procedimiento, nombre y tipo de los argumentos y, sólo en las funciones, el nombre y
tipo de dato del valor que devuelven.

CREATE PACKAGE p-emp AS

wtotal-emp NUMBER; /* variable global */
FUNCTION inserta-emp
(codemp VARCHAR2,
nomemp VARCHAR2,
srgcat NUMBER,
fchalt DATE,
comsal NUMBER,
srgdep NUMBER,
cojefe NUMBER)
RETURN NUMBER;
PROCEDURE borra-emp
(n-emp NUMBER);
PROCEDURE actualiza-comsal
(n-emp NUMBER,
comsal-incr NUMBER);
END p-emp;

En el Cuerpo del Package (CREATE PACKAGE BODY). Se declaran todas las variables, procedimientos,
funciones, etc. que sean privados; es decir, no accesibles desde las aplicaciones; y se definen los
procedimientos y funciones públicos y privados. En este caso, se declara la variable privada wfecha-actual
(fecha actual) y se definen la función inserta-emp y los procedimientos borra-emp y actualiza-comsal que se
declararon en la parte de Especificación del Package.

CREATE PACKAGE BODY p-emp AS

wfecha-actual DATE; /* variable privada */

FUNCTION inserta-emp
(codemp Varchar2...) IS
RETURN new-empno Number(10);
BEGIN
....
END inserta-emp;

PROCEDURE borra-emp
(n-emp IN Number) AS
BEGIN
....
END borra-emp;

PROCEDURE actualiza-comsal
(n-emp IN Number,
comsal-incr IN Number) AS
BEGIN
....
END actualiza-comsal;
END p-emp;

Pág. 6 de 9
 DBD Práctica-3 Procedimientos, funciones y secuencias
Sevilla, Febrero 2007, V 2007.02.1

2 Secuencias.
Las secuencias (sequences) son objetos que facilitan la generación automática de series numéricas.

Los usos más frecuentes de las secuencias, son:

• La generación automática de claves primarias
• Coordinar las claves de múltiples filas o tablas.

Las secuencias son independientes de las tablas; por tanto, una misma secuencia se puede usar para generar
valores de columnas numéricas de una ó más tablas.

Una forma muy común de implementar en las aplicaciones la generación de series numéricas, es forzar que
cada transacción que solicita un nuevo número bloquee la tabla, seleccione el último número, lo incremente
y libere la tabla. Con esta implementación, si dos usuarios quieren obtener el siguiente número al mismo
tiempo, uno de los dos tendrá que esperar a que termine la transacción del otro.

Una de las principales ventajas de las secuencias frente a implementar la generación de éstas series de
números en las aplicaciones, es que permiten la generación simultánea de múltiples números
garantizando que son únicos. De esta forma, mejora la concurrencia de las aplicaciones.

2.1 Definir y referenciar secuencias.

Para definir las secuencias, se utiliza el comando CREATE SEQUENCE en el que, además del nombre, se
especifican una serie de parámetros: valor inicial, intervalo entre los números, valor mínimo, máximo, etc.

CREATE SEQUENCE nombre_secuencia

[INCREMENT BY n]
[START WITH n]
[MAXVALUE n]
...;
Los valores de las secuencias se referencian en comandos SQL usando las pseudo-columnas Nextval y
Currval.

Para generar el siguiente número de una secuencia, se referencia a nombre_secuencia.Nextval.

La primera referencia a Nextval devuelve el valor inicial de la secuencia (parámetro START WITH); las
sucesivas referencias generan los siguientes números de la serie (parámetro INCREMENT BY).

Para referenciar al número actual de una secuencia, se usa nombre_secuencia.Currval.

Los usos posibles de Nextval y Currval son:

• Claúsula Values del comando Insert
• Lista Select del comando Select
• Claúsula Set del comando Update.

2.1.1 Ejemplo de secuencia.

CREATE SEQUENCE sec_emp
INCREMENT BY 1
START WITH 1;

Pág. 7 de 9
 DBD Práctica-3 Procedimientos, funciones y secuencias
Sevilla, Febrero 2007, V 2007.02.1

En el siguiente ejemplo podemos ver la utilidad de las secuencias para obtener los valores de la clave
primaria de la tabla Empleado y para coordinar los valores de las claves primarias de las tabla Empleado
y la tabla Salario.

• Insertar fila en la tabla Empleado

INSERT INTO Empleado (srgemp,codemp...) VALUES (sec_emp.NEXTVAL, “emp01”...);
• Insertar empleado en la tabla Salarios
INSERT INTO Salario (srgemp,fchmes...) VALUES (sec_emp.CURRVAL...)

Con el comando CREATE SEQUENCE creamos la secuencia (sec_emp) para obtener los valores de la
clave primaria de la tabla Empleado.

Para introducir un empleado nuevo ejecutamos el comando SQL INSERT y en la claúsula VALUES, para
especificar el valor del campo clave (srgemp), referenciamos a la pseudo-columna sec_emp.NEXTVAL.

Al referenciar a sec_emp.NEXTVAL, Oracle genera automáticamente un nuevo valor único de la clave

primaria de la tabla Empleado.

Ejercicio 1.
Añadir registros a la tabla de empleados, utilizando una secuencia que genere el código de empleado.

CREATE TABLE empleados

(cod_emp integer,
nom_emp char(10) not null,
salario number(9,2) DEFAULT 100000,
fecha_nac date DEFAULT SYSDATE,
comision number(3,2) CHECK (comision>=0 AND comision <=1),
cod_jefe integer,
PRIMARY KEY (cod_emp),
FOREIGN KEY (cod_jefe) REFERENCES empleados
ON DELETE CASCADE);

Pág. 8 de 9
 Procedimientos, funciones y secuencias

Ejercicio 2.
Crear un procedimiento para insertar un nuevo empleado en la tabla Empleados.
Los argumentos del procedimiento son los valores de los atributos del empleado.

Para obtener el valor de la clave primaria del nuevo empleado, utilizamos una secuencia que la genere
automáticamente.

Ejercicio 3.
Crear una función para calcular el sueldo total de un empleado pasado como parámetro. Tenga en cuenta
que hay que añadir la comisión (que es un porcentaje adicional del salario) al salario.

Es posible también llamar a la función desde un bloque PL/SQL:

Genere un bloque PL/SQL anónimo (un procedimiento BEGIN ….. END que no es necesario
nominarlo) y pruébelo desde la WorkSheet con una instrucción DBMS_OUTPUT.

Pág. 9 de 9