PL/SQL (Procedural Language/SQL)

¿QUÉ ES PL/SQL?
• PL/SQL es una extension de SQL con características de lenguaje
de programación.
• Sentencias de manipulación y consulta de datos, se incluyen sin
tener que desarrollar programas.
ENTORNO PLS/SQL

Motor PL/SQL
PL/SQL Ejecutor de
Bloque Bloque Sentencias
PL/SQL PL/SQL SQL
Procedurales

Ejecutor de Sentencias SQL

Servidor Oracle
BENEFICIOS DE PL/SQL
• Mejora Rendimiento.
• Modularización.
• Es portable
• Puede declarer identificadores
• Puede programar con las estructuras de control de un lenguaje
procedural
• Puede manejar errores.
PL/SQL – Tipos de Bloques
FUNCIÓN
PROCEDIMIENTO
BLOQUE ANÓNIMO
FUNCTION name
PROCEDURE name IS
[DECLARE] RETURN datatype IS
BEGIN
BEGIN BEGIN
SENTENCIAS
SENTENCIAS
SENTENCIAS
[EXCEPTION]
[EXCEPTION]
[EXCEPTION]
END;
END;
END;

• PL/SQL es el lenguaje que tiene uno o mas bloques. Estos bloques

pueden estar separado o anidados unos con otros. Por lo tanto un
bloque puede representar una pequeña parte de otro bloque.
PL/SQL – Tipos de Bloques
Concepto de Programa Descripción Disponibilidafd
Bloques anónimos Bloque de PL/SQL no identificados que están Todos los ambientes de
dentro de una aplicación o son suministrados PL/SQL
interactivamente
Aplicación Bloques nombrados de PL/SQL guardados en Los componentes de
Procedimientos o una aplicación o biblioteca compartida herramientas de Oracle
Funciones pueden aceptar parámetros y pueden ser Developer.
invocadas repetidamentes por su nombre.
Almacenamiento Bloques nombrados de PL/SQL guardados en Servidor Oracle
Procedimientos o un servidor Oracle: pueden aceptar
Funciones parámetros y pueden ser invocados
repetidamente por su nombre
Paquetes (Aplicación o Nombrar módulos de PL/SQL que agrupan Servidor de Oracle
almacenamiento) procedimientos relacionados funciones e
identificadores.
PL/SQL
• PL/SQL es el lenguaje de programación que propociona
ORACLE para extender SQL estándar con otro tipo de
estructuras e instrucciones:
1. Variables y tipos
2. Estructuras de control
Bucles y sentencias IF-THEN-ELSE
3. Procedimientos y funciones
4. Tipos de objetos y métodos
 PL/SQL
• Estructura básica de un bloque:
DECLARE (opcional)
/* Declaración de uso local: variables cursores, excepciones
de usuario */
BEGIN (obligatorio)
/* Sección ejecutable (obligatoria) órdenes SQL y
procedimientos*/
EXCEPTION (opcional)
/* Zona de control de errores */
END; (obligatorio)
• Las secciones de manejo de excepciones y de declaraciones son
opcionales.
• Los bloques pueden contener otros bloques (sub-bloques)
• Los comentarios van entre /* */ Si no ocupan mas de una línea , se puede
escribir despues de – (2 guiones)
PL/SQL - Variables
• Sección de declaración de variables
Contiene la declaración de:
Tipos de datos
Constantes
Variables
También se declaran cursores y excepciones definindas por el
usuario
Las variables externas se declaran en SQL *Plus y se escriben
precedidas de ‘:’
PL/SQL - Variables
• Tipos de datos en PL/SQL:
Number,
Char
Varchar/varchar2
Date
Boolean
entre otros
• La sintaxis para declarar variables o constante es:
nombre [CONSTANT] TIPO [NOT NULL] [:= expresión]
• No se diferencia entre mayúsculas y minúsculas
PL/SQL - Variables
• La cláusula CONSTANT indica la definición de una constante
que debe ser inicializada y cuyo valor no puede ser
modificado.
• [NOT NULL]: Obliga a tener valor.
• Tipo puede ser:
Tipos de datos: tipo de dato de la variable
Identificador%TYPE: se refiere al tipo de dato usado por una columna de la
tabla.
Identificador%ROWTYPE: es una fila variable con los mismos nombres y tipos
que las columnas de una tabla o fila recuperada de un cursor.
PL/SQL – Declaración de Variables
• Variables y constantes. Ejemplo
DECLARE
v_cedula varchar2(13);
v_nombre varchar2(30);
c_factor CONSTANT number(3,2):= 0.10;
v_cedula1 cliente.cedula%type;
v_precio number := 300;
cur_Rcliente cliente%ROWTYPE;
PL/SQL – Declaración de Variables
• CURSORES
Es un área de trabajo definidas para las consultas que devuelvan
mas de una fila.
Permite la manipulación de datos
Se le pueden pasar parámetros
• Tipos de Cursores
Cursor simple
Cursores con paso de parámetros
Cursores con actualización
PL/SQL – Cursores
• CURSOR simple – Sintaxis
CURSOR nombre_cursor IS
sentencia_select;
• Ejemplo
DECLARE
….
CURSOR c_cliente IS
SELECT cl.cedula, cl. Nombre
FROM cliente cl
WHERE cl.tipo_trabajo = ‘jefe’;
PL/SQL – Cursores
• CURSOR con paso de parámetros – Sintaxis
CURSOR nombre_cursor [parámetros] IS
sentencia_select;
• Los parámetros de un cursor se pueden utilizar para definir
variables con valores de entrada.
• La consulta SQL asociada se ejecuta utilizando esos
parámetros
• Parámetros
(nombre_parametros tipo_parametros, …)
PL/SQL – Cursores
• CURSOR con paso de parámetros – Sintaxis
CURSOR nombre_cursor [parámetros] IS
sentencia_select;
• Ejemplo
CURSOR cur_cliente (v_provincia cliente.provincial%types) is
SELECT cl.cedula, cl.nombre
FROM clientes cl
WHERE cl.provincial = v_provincia;
PL/SQL – Cursores
• Operaciones con cursors
Open: abre los cursores
Fetch: lee los datos
Close: Cierra los cursores

• Pasos:
1. Declarar el cursor
2. Abrir el cursor en la zona de procedimiento
3. Leer el cursor. Es necesario ejecutar un bucle para leer todos los cursores
4. Cerrar cursor
PL/SQL – Control de Cursores
PL/SQL – Cursores
• ATRIBUTOS DE LOS CURSORES
Se le añaden al nombre del cursor

%NOTFOUND: Se usa para detectar el final de un cursor. Devuelve TRUE si la

última lectura falla porque no hay filas disponibles y FALSE si recupera
%FOUND: El contrario de %NOTFOUND
%ROWCOUNT: Devuelve el número de filas leídas
%ISOPEN: Devuelve TRUE si el cursor está abierto y FALSE si no lo está
PL/SQL – Cursores
• Ejemplo uso cursor
DECLARE
CURSOR cur_emp IS select cedula, nombre
from empleado;
emp_registro cur_emp%ROWTYPE;
BEGIN
OPEN cur_emp;
LOOP
FETCH cur_emp INTO emp_registro;
EXIT WHEN cur_emp%NOTFOUND;
….
END LOOP;
CLOSE cur_emp;
END;
PL/SQL – Alcance de Variables
• El alcance o visibilidad de las variables sigue estas reglas:

1. Una variable es visible en el bloque en el cual se declara y en

todos los sub-bloques, a menos que se aplique la regla 2.
2. Si se declara una variable en un sub-bloque con el mismo nombre
que una variable del bloque contenedor (externo), la variable del
sub-bloque es la que tiene prioridad en el sub-bloque.
 PL/SQL – Alcance de Variables
DECLARE Operador de
concatenación ||
a number(2) := 2;
BEGIN
DBMS_OUTPUT.PUT_LINE(‘Valor de a externa ’ || a);
DECLARE
a number(3) := 20;
SUB-BLOQUE
BEGIN
DBMS_OUTPUT.PUT_LINE(‘Valor de a interna ’|| a);
END;
DBMS_OUTPUT.PUT_LINE(‘Valor de a ’|| a);
END;
/ Para ejecutar en SQL*Plus
Nota: Para ver los resultados de la
Imprime: impression en SQL*Plus se debe ejecutar
Valor de a externa 2 SQL> SET SERVEROUTPUT ON
Valor de a interna 20
Valor de a 2
• En PL/SQL se puede usar directamente el lenguaje de manipulación de
datos DML de SQL, es decir, INSERT, UPDATE, DELETE, SELECT (el
select requiere usar INTO o estar asociado con un cursor)
• Para usar sentencias DDL en PL/SQL, es decir, CREATE, DROP, ALTER se
puede hacer así:
Begin
EXECUTE IMMEDIATE ‘CREATE TABLE t(valor number(5))’;
End;
/
• La sentencia DDL NO lleva punto y coma dentro de las comillas
simples.
• Lo que sigue a IMMEDIATE puede ser una variable tipo varchar2
• Usar EXECUTE IMMEDIATE sólo cuando sea indispensable, lo siguiente
es necesario, aunque funciona:
Begin
EXECUTE IMMEDIATE ‘insert into t values(97)’;
End;
/
• Es mas simple:
Begin
insert into t values(97);
End;
/
• En PL/SQL, las funciones numéricas (SQRT, ROUND, POWER, etc.), de
caractares (LENGTH, UPPER, INITCAP, SUBSTR, etc.), de fechas
(ADD_MONTHS, MONTHS_BETWEEN, etc.); se pueden usar fuera de
una sentencia SQL pero las funciones de grupo (COUNT, SUM, AVG,
MAX, etc.) solo se pueden usar dentro de una sentencia SQL.
• Ejemplo:
DROP TABLE empleado;
CREATE TABLE empleado(
cod NUMBER(8) primary key,
nom VARCHAR2(8) not null,
fecha_ing DATE,
sueldo number(8) CHECK(sueldo > 0)
);
 v_fi queda de tipo fecha_ing de empleado
DECLARE
v_fi empleado.fecha_ing%type;
v_nom varchar2(20) := upper(‘Alberto Duarte’);
Las variables ses las pueden
BEGIN inicializar en el DECLARE o en el
v_ fi := ADD_MONTHS(sysdate, -14); BEGIN

insert into empleado

values(4329,
substr(v_nom, 1, 8),
v_fi, Acá también se pueden
colocar los valores
10000); directamente y prescindir de
commit; las variables
END;
/
• Sobre las consultas SQL enPL/SQL:
Se debe proporcionar un lugar para guardar los datos devueltos en una
consulta (SELECT).
Esto se puede lograr mediante la cláusula
SELECT … INTO.
Sin embargo, un SELECT … INTO debe retornar una y sólo una fila:
 Si la consulta no recupera filas o recupera múltiples filas, ocurre un error (excepción).
 Los cursors sirven para consultas que recuperan 0, 1 o mas filas.
DECLARE
v_nom empleado.nom%type;
v_sue empleado.sueldo%type;
v_cuantos number(8);
BEGIN
select nom, sueldo INTO v_nom, v_sue
from empleado where cod = 4329;
dbms_output.put_line(‘El empleado ’|| v_nom || ‘ tiene
sueldo ’ || v_sue);
select count(*) into v_cuantos from empleado;
dbms_output.put_line(‘Total empleados ’|| v_cuantos);
END;
/
PL/SQL – Control de Flujo
• Las comparaciones lógicas son la base del control condicional
en PL/SQL. Los resultados son verdadero (TRUE), falso
(FALSE) o nulo (NULL).
• Cualquier “cosa” comparada con NULL retorna NULL
(desconocido).
• Los operadores lógicos son: <, >, =, !=, <=, >=, <>
• Sintaxis de sentencia IF:
DECLARE
v_a number := NULL;
BEGIN
if v_a = v_a then
dbms_output.put_line(‘NULL es igual a NULL’);
elsif v_a <> v_a then
dbms_output.put_line(‘NULL es diferente de NULL’);
else
dbms_output .put_line(‘Indefinido, NULL no es ni igual ni
diferente a NULL’);
end if;
END;
/
PL/SQL – Sentencias IF compuestas
• Las sentencias IF compuestas usan operadores lógicos como
AND, OR y NOT.
• Sintaxis:

IF condición AND condición THEN

sentencia;
END IF;
Lo anterior también se puede escribir con CASE así:
DECLARE
v_a number := NULL;
BEGIN
case
when v_a = v_a then
dbms_output.put_line(‘NULL es igual a NULL’);
when v_a <> v_a then
dbms_output.put_line(‘NULL es diferente de NULL’);
else
dbms_output .put_line(‘Indefinido, NULL no es ni igual ni
diferente a NULL’);
end case;
END;
/
declare
v_grade char(1) := upper('&up_grade');
v_appraisal varchar2(20);

begin
v_appraisal :=
case
when v_grade = 'A' then 'Excelente'
when v_grade = 'B' then 'Muy Bueno'
when v_grade = 'C' then 'Bueno'
else 'No aprueba el grado'
end;
DBMS_OUTPUT.PUT_LINE('Grado '||v_grade||' '||
' Su calificación es: '||' '|| v_appraisal);
end;
PL/SQL – Ciclos o Iteraciones
a) Bucles simples: LOOP Ejemplo
declare
LOOP v_contador number := 1;
secuencia de instrucciones; begin
END LOOP; LOOP
insert into temporal
values (v_contador, ‘ejemplo’);
Para salir del ciclo se usa:
v_contador := v_contador + 1;
EXIT WHEN v_contador > 50;
EXIT [WHEN condición]
END LOOP;
end;
PL/SQL – Ciclos o Iteraciones
b) Bucles condicionales: WHILE Ejemplo
Repetirá una secuencia de declare
instrucciones hasta que la v_contador number := 1;
condición controladora del ciclo
deje de ser cierta. Su sintaxis es: begin
WHILE v_Contador <= 50 LOOP
WHILE condición LOOP insert into temporal
secuencia de instrucciones; values (v_contador,
END LOOP; ‘ejemplo’);
v_contador := v_contador + 1;
END LOOP;
end;
PL/SQL – Ciclos o Iteraciones
c) Bucles numéricos: FOR Ejemplo
Permite repetir una secuencia de declare
instrucciones un número fijo de v_contador number := 1;
veces. Su sintaxis es:
begin
FOR índice IN [REVERSE]
FOR v_Contador IN 1 .. 50 LOOP
entero..entero LOOP
insert into temporal
secuencia de instrucciones;
values (v_contador,
END LOOP;
‘ejemplo’);
El incremento del FOR siempre es
1. END LOOP;
end;
 PL/SQL – Procedure
¿Qué es un procedure
(procedimiento)?
• Es un tipo de subprograma que
realiza una acción.
• Los procedimientos se pueden
almacenar en una base de
datos, como objetos de
esquema, para repetir su
ejecución.
Sintaxis
Create [or replace] procedure
nombre_procedimiento
[(parámetro1 modo tipoDato,
parámetro2 modo tipoDato, …)]
is/as
[declaración variables locales]
begin
bloque pl/sql;
end [nombre_procedmiento];
PL/SQL – Procedures
Concepto de Programa Descripción
Nombre_procedimiento Nombre del procedimiento
parámetro Nombre de una variable PL/SQL cuyo valor se rellena en el
entorno de llamada o se transfiere a él, o ambas cosas,
dependiendo del modo que se utilice.
modo Tipo de parámetro:
IN (por defecto)
OUT
IN OUT
TipoDato Tipo de dato del parámetro: puede ser cualquier tipo de dato SQL
o PL/SQL. Puede ser el tipo de dato TYPE, %ROWTYPE o cualquier
otro tipo de dato escalar o compuesto
Bloque PL/SQL Cuerpo procedural que define la acción que realiza el
procedimiento
PL/SQL – Desarrollo de los Procedure
PL/SQL – Parámetros Formales y Parámetros Reales
• Parámetros Formales: variables declaradas en la lista de
parámetros de la especificación de un subprograma.
Create or replace procedure aumentoSalario (p_id number,
p_monto number)
….
• Parámetros Reales: variables o expresiones a las que se hace
referencia en la lista de parámetros de la llamada de un
subprograma.
aumentoSalario (v_id, 2000)
PL/SQL – Modos de Parámetros Procedurales
PL/SQL – Parámetros IN

176 p_id

Create or replace procedure aumentoSalario

(p_id IN empleados.empleadoId%Type)
Is
Begin
update empleados
set salario = salario * 1.10
where empleadoId = p_id;
commit;
End aumentoSalario;
PL/SQL – Parámetros OUT Create or replace procedure queryEmp
(p_id IN empleados.empladoid%type
p_nombre OUT emplados.apellido%type
p_salario OUT empleados.salario%type
p_comision OUT empleados.comision%type)
Is
Begin
select apellido, salario, comision
into p_nombre,p_salario,p_comision
from empleados
where empleadoId = p_id;
End queryEmp;
PL/SQL – Parámetros IN OUT
Entorno de llamada Procedimiento formateaTelefono

59342391631 (593)42-391631 p_numFono

Create or replace procedure formateaTelefono

(p_numFono IN OUT varchar2)
Is
Begin
p_numFono := ‘(‘ || substr(p_numFono, 1, 3) ||
‘)’ || substr(p_numFono, 4, 2) ||
‘-’ || substr(p_numFono, 6) ;
End formateaTelefono;
 PL/SQL – Function
¿Qué es un Function (función)? Sintaxis
• Un bloque que retorna un valor. Create [or replace] function
nombre_funcion
• Objeto almacenado en la base
de datos como un esquema. [(parámetro1 modo tipoDato,
parámetro2 modo tipoDato, …)]
• Llamado como una parte de una
expression o usado para Return tipoDato is/as
proveer el valor de un [declaración variables locales]
parámetro. begin
bloque pl/sql;
Return expresion;
end [nombre_funcion];
PL/SQL – Formas de ejecutar una Función
• Invocarla como parte de una expresión PL/SQL
Usando una variable de host para obtener el resultado:
VARIABLE v_credito number
EXECUTE : v_credito := obtenerCredito(101)
Usando una variable local para obtener el resultado:
DECLARE v_credito number clientes.limiteCredito%type;
BEGIN
v_credito := obtenerCredito(101);
End;
• Usando como otro paramétro para otro subprograma
EXECUTE dbms_output.put_line(obtenerCredito(101))
• Usando en una sentencia SQL (sujeto a restricciones)
Select obtenerCredito(idCliente) from Clientes;
PL/SQL – Restricciones para llamadas de una Función desde una
expression SQL
• Las funciones definidas por el usuario que son llamadas
desde una expression SQL debe:
Estar almacenada en la base de datos
Aceptar sólo parámetros IN con tipos de datos válidos, no los
especificados en PL/SQL
Retornar un tipo de dato válido SQL, no los tipos de datos
especificados en PL/SQL
• Cuando la función es llamada desde una sentencia SQL
Los parámetros deben estar especificados con notación posicional
Usted debe ser el propietario de la función para tener privilegios
de ejecución.
 PL/SQL – Lineamientos para llamados de Funciones desde una
expresión SQL
Funciones llamadas desde:
• Una sentencias SELECT no puede contener sentencias DML
• Una sentencia Update o Delete sobre una tabla T no puede consultar
o contener una DML sobre la misma tabla T.
• La sentencia SQL no puede contener un fin de transacción (no puede
ejecutar una operación de COMMIT o ROLLBACK)
Llamadas a subprogramas que rompan estas restricciones no son
permitidas también en la función.
PL/SQL – Tratando con cursores
declare
cursor c_estudiantes is
select nombres||' '|| apellido1||' '|| apellido2 Nombres, Direccion, ciudadNac
from estudiantes;
v_nombres varchar2(100);
v_direccion varchar2(50);
v_ciudadNac varchar2(5);
begin
open c_estudiantes; /*abro el cursor c_estudiantes */
FETCH c_estudiantes into v_nombres, v_direccion, v_ciudadNac;
while c_estudiantes%found
loop
DBMS_OUTPUT.PUT_LINE(v_nombres || ' ' || v_direccion || ' ' || v_ciudadNac);
FETCH c_estudiantes INTO v_nombres, v_direccion, v_ciudadNac;
end loop;
close c_estudiantes;
end;
PL/SQL – Tratando con cursors con Parámetros
declare
cursor c_estudiantes (p_ciudadNac varchar2) is
select nombres||' '|| apellido1||' '|| apellido2, ciudadNac
from estudiantes
where CIUDADNAC = p_ciudadNac;
v_nombres varchar2(100);
v_ciudadNac varchar2(5);
begin
open c_estudiantes('GYE'); /*abro el cursor c_estudiantes */
loop
FETCH c_estudiantes into v_nombres, v_ciudadNac;
exit when c_estudiantes%NOTFOUND;
DBMS_OUTPUT.PUT_LINE(v_nombres || ' ' || v_ciudadNac);
end loop;
close c_estudiantes;
end;
PL/SQL – Tratando con cursores
declare
v_nombre MATERIAS.NOMBRE%type;
v_codSiug MATERIAS.CODSIUG%type;
v_contadorFilas number;
cursor c_materias is
select nombre, codSiug
from materias;
begin
select count(*) into v_contadorFilas from materias;
open c_materias; /*abro el cursor c_materias */
for i in 1 .. v_contadorFilas loop
FETCH c_materias into v_nombre, v_codSiug;
DBMS_OUTPUT.PUT_LINE(v_nombre || ' ' || v_codSiug);
end loop;
close c_materias;
end;
PL/SQL – Variables tipo cursores

DURANTE LA AL FINALIZAR LA DESPUÉS DE

ATRIBUTO ANTES DE ABRIR AL ABRIR
RECUPERACIÓN RECUPERACIÓN CERRAR
%NOTFOUND ORA-1001 NULL FALSE TRUE ORA-1001
%FOUND ORA-1001 NULL TRUE FALSE ORA-1001
%ISOPEN FALSE TRUE TRUE TRUE FALSE
Número de
registros que ha
Número total de
%ROWFOUND ORA-1001 0 recuperado ORA-1001
Registros
hasta el
momento
PL/SQL – Excepction
PL/SQL – Excepction
PL/SQL – Excepction
PL/SQL – Excepction
PL/SQL – Excepction
PL/SQL – Excepction
PL/SQL – Excepction
PL/SQL – Excepction
PL/SQL – Excepction