Manual PLSQL

GEDICA TRAINING & CONSULTING C.A.
ITRODUCCIÓ A PL/SQL
09/03/2005
TABLA DE CONTENIDO
ITRODUCCIO A PL/SQL ...................................................................................................4

OBJETIVOS DEL CURSO: .............................................................................................................................. 4
CONTENIDO PROGRAMÁTICO: .................................................................................................................. 4
ESTRATEGIAS METODOLÓGICAS:............................................................................................................. 5
RECURSOS AUDIOVISUALES Y EVALUACIÓN: ...................................................................................... 5
REQUISITOS DE ADMISIÓN: ........................................................................................................................ 5
Capítulo 1....................................................................................................................................6
ITRODUCCIO A PL/SQL ....................................................................................................6
ITRODUCCIÓ A PL/SQL............................................................................................................ 7
ESTRUCTURA DE LOS BLOQUES DE PL/SQL.......................................................................... 8
TIPOS DE BLOQUE .......................................................................................................................... 9
Bloques Anónimos ........................................................................................................................................... 10
Subprogramas................................................................................................................................................... 10
SINTAXIS DE BLOQUES PL/SQL................................................................................................................ 11
TIPOS DE DATOS E PL/SQL...................................................................................................... 15
VARIABLES E PL/SQL................................................................................................................ 16
TIPOS DE VARIABLE EN PL/SQL............................................................................................................... 16
DECLARACIO DE VARIABLES E PL/SQL .......................................................................... 20
VARIABLES TIPO ATRIBUTO E PL/SQL............................................................................... 23
Variables tipo RECORD .................................................................................................................................. 23
Variables tipo TABLE ..................................................................................................................................... 24
ASIGADO VALORES A VARIABLES .................................................................................... 26
BLOQUES ITEROS Y ALCACE DE VARIABLES ............................................................ 28
Alcance ............................................................................................................................................................ 29
OPERADORES ................................................................................................................................. 29
OPERADORES NUMERICOS ....................................................................................................................... 29
OPERADORES LOGICOS O BOOLEANOS ................................................................................................ 29
PRACTICA 1................................................................................................................................................... 31
Capítulo 2..................................................................................................................................32
FUCIOES E PL/SQL......................................................................................................32
FUCIOES E PL/SQL................................................................................................................ 33
ITERACTUADO CO EL ORACLE SERVER...................................................................... 33
COMPARACION DE INSTRUCCIONES SQL y PL/SQL............................................................................ 34
RECUPERANDO DATOS – La cláusula SELECT ........................................................................................ 34
INSERTANDO DATOS – La cláusula INSERT............................................................................................. 36
ACTUALIZANDO DATOS – La cláusula UPDATE ..................................................................................... 36
BORRANDO DATOS – La cláusula DELETE............................................................................................... 37
Lenguaje Procedimental PL/SQL/ 1

CONTROL DE TRANSACCIONES............................................................................................................... 37
PRACTICA 2................................................................................................................................................... 40
Capítulo 3..................................................................................................................................41
ESTRUCTURAS DE COTROL ............................................................................................41
ESTRUCTURAS DE COTROL DE PL/SQL.............................................................................. 42
CONDICIONALES ......................................................................................................................................... 42
La sentencia IF ................................................................................................................................................. 43
ITERACIONES ............................................................................................................................................... 45
ETIQUETAS.................................................................................................................................................... 49
CURSORES ....................................................................................................................................... 51
CURSORES en SQL........................................................................................................................................ 51
CURSORES EN PL/SQL ................................................................................................................................ 53
PRACTICA 3................................................................................................................................................... 62
Capítulo 4..................................................................................................................................63
MAEJO DE ERRORES ........................................................................................................63
MAEJO DE ERRORES E PL/SQL ........................................................................................... 64
EXCEPCIONES PREDEFINIDAS ................................................................................................................. 64
MANEJANDO EXCEPCIONES..................................................................................................................... 65
EL PRAGMA EXCEPTION_INIT.................................................................................................................. 66
EXCEPCIONES DEFINIDAS POR EL USUARIO ....................................................................................... 67
PRACTICA 4................................................................................................................................................... 70
Capítulo 5..................................................................................................................................71
PROGRAMAS ALMACEADOS E LA BASE DE DATOS...............................................71
IGEIERIA DEL LEGUAJE PL/SQL ..................................................................................... 72
INGENIERIA DE PL/SQL .............................................................................................................................. 72
IGEIERIA DE PL/SQL RESIDETE E EL RDBMS .......................................................... 73
DIFERENCIA ENTRE PROCEDIMIENTO Y FUNCION ............................................................................ 74
CARACTERISTICAS DE PROCEDIMIENTOS Y FUNCIONES ................................................................ 74
USOS DE PROCEDIMIENTOS Y FUNCIONES .......................................................................................... 75
CREACION Y COMPILACION DE PROCEDIMIENTOS Y FUNCIONES................................................ 75
Instrucciones Válidas en Procedimientos y Funciones .................................................................................... 77
Instrucciones No Validas en Procedimientos y Funciones............................................................................... 78
EJECUCION DE PROCEDIMIENTOS Y FUNCIONES ALMACENADOS ............................................... 78
COMPILACIO DE ERRORES E PL/SQL............................................................................... 80
ERRORES DE PL/SQL ................................................................................................................................... 80
ERRORES DEFINIDOS POR EL USUARIO ................................................................................................ 81
ELIMINACION DE PROCEDIMIENTOS Y FUNCIONES .......................................................................... 82
PAQUETES ....................................................................................................................................... 83
ESTADO PERSISTENTE ............................................................................................................................... 83
ESTRUCTURA DE UN PAQUETE ............................................................................................................... 84
DEPENDENCIAS ENTRE PAQUETES ........................................................................................................ 84
ESPECIFICACIONES PARA LA CREACION DE PAQUETES .................................................................. 85
PRACTICA 5................................................................................................................................................... 88

Capítulo 6..................................................................................................................................89
TRIGGERS DE BASE DE DATOS.........................................................................................89
TRIGGERS o DISPARADORES DE EVETOS.......................................................................... 90
RESTRICCIONES DE LOS TRIGGERS........................................................................................................ 92
DEFINICION Y CREACION DE TRIGGERS............................................................................................... 93
CREACION DE UN TRIGGER DE BASE DE DATOS ................................................................................ 94
SECUENCIA DE EJECUCION DE UN TRIGGER DE BASE DE DATOS ................................................. 94
Predicados Condicionales ................................................................................................................................ 96
ELIMINANDO UN TRIGGER DE BASE DE DATOS ................................................................................. 98
PRACTICA 6................................................................................................................................................... 99

ITRODUCCIO A PL/SQL
En este taller los participantes aprenderán a escribir programas en PL\SQL, a almacenarlos en

la base de datos, y luego accesarlos desde cualquier otra interfaz.
OBJETIVOS DEL CURSO:
• Crear, ejecutar y mantener procedimientos, funciones, paquetes, triggers de la base de

datos y tipos de objetos
• Administrar la construcción de programas PL/SQL
• Describir los ambientes de desarrollo PL/SQL
COTEIDO PROGRAMÁTICO:
• Introducción a PL\SQL
• Estructura de los bloques
• Tipos de Bloques
• Declaración de variables
• Operadores
• Funciones en PL\SQL
• Estructuras de Control
• Cursores
• Manejo de Errores
• Programas almacenados en la B.D.
• Triggers de Base de Datos.

ESTRATEGIAS METODOLÓGICAS:
• Utilización de laminas audiovisuales las cuales serán transmitidas durante el curso.

• Realización de ejercicios prácticos, los cuales son asignados por el instructor.
RECURSOS AUDIOVISUALES Y EVALUACIÓ:
• diapositivas elaboradas en power point

• Para la evaluación se realizaran distintas practicas dirigidas por el instructor.
REQUISITOS DE ADMISIÓ:
• Introducción a SQL y SQL Avanzado

Capítulo 1
ITRODUCCIO A PL/SQL

ITRODUCCIÓ A PL/SQL
El SQL es un lenguaje muy poderoso, permite visualizar, modificar, o borrar múltiples

registros con el uso de una simple instrucción. También puede ser usado para crear reportes,
empleando para ello muy poco esfuerzo. Esto nos da la ventaja, de realizar accesos a la base de
datos, sin la necesidad de poseer un software especializado.
Es muy probable que en sus prácticas de SQL, UD. haya sentido la necesidad de usar
condiciones, bucles, o declarar variables, como lo hacía en los lenguajes de tercera generación,
como lo son Pascal, Basic, C, Cobol, etc. Para mayor sorpresa observó que esto no es posible
usando solo SQL. Fue por la razón que se hizo necesaria una herramienta que concediera todas las
ventajas de SQL y a su vez, todas las ventajas de un lenguaje de tercera generación. Es así como
nace PL/SQL.
PL/SQL es clasificado como un lenguaje procedimental, debido al uso de bucles,

condicionales, y declaración de variables; su entrada y salida es a través de parámetros o medios
intermedios.
Los bloques de PL/SQL, se pueden escribir en SQL*Plus, para realizar accesos rápidos a la
base de datos, sin la necesidad de utilizar un software especializado, pero PL/SQL también es
empleado en otras herramientas de ORACLE, (como por ejemplo FORMS, REPORTS, Pro*C,
POWER*OBJECTS, entre otras), para la elaboración de programas de gran envergadura.

ESTRUCTURA DE LOS BLOQUES DE PL/SQL
El lenguaje de programación PL/SQL es un lenguaje estructurado por bloques. En este, los

programas son divididos en bloques lógicos. Cada bloque es independiente y consta de tres
secciones: Sección Declarativa (opcional), Ejecutable (Obligatoria) y de Manejo de Excepciones
(Opcional). Solo las palabras reservadas BEGIN y END son obligatorias y al menos una
instrucción dentro de ellas. La tabla siguiente describe brevemente las tres secciones:
Sección Descripción Inclusión

Declarativa Contiene todas las variables, constantes, cursores y Opcional
excepciones definidas por el usuario que son
referenciadas en la sección Ejecutable y en la misma
sección Declarativa
Ejecutable Contiene instrucciones SQL para manipular la data en la Obligatoria
base de datos e instrucciones PL/SQL que permiten
manipular la data en el bloque
Manejo de Excepciones Indica las acciones a tomar cuando ocurra una condición Opcional
anormal o algún error durante la ejecución de las
instrucciones de la sección Ejecutable
La estructura básica de un bloque de PL/SQL es la siguiente:
DECLARE
-- Declaraciones de variables, cursores y excepciones
BEGIN -- Inicio de Bloque
-- Instrucciones SQL;
-- Instrucciones PL/SQL;
EXCEPTION;
-- Instrucciones para el manejo de errores
END; -- Fin de Bloque
/ -- Comando de ejecución del bloque

Cada instrucción de SQL o cada sentencia de control de PL/SQL debe estar terminada en
punto y coma (;)
Para ejecutar un bloque de PL/SQL se debe utilizar un slash (/). Cuando el bloque se ha
ejecutado exitosamente, debe aparecer el mensaje siguiente:
PL/SQL procedure successfully completed
En PL/SQL un error es llamado una excepción.
Las palabras reservadas DECLARE, BEGIN y EXCEPTION son las únicas que no están
seguidas de punto y coma.
TIPOS DE BLOQUE
Cada unidad de programa de PL/SQL se compone de uno o más bloques, estos bloques
pueden ser independientes o estar inmersos uno dentro de otro. Puede haber cualquier número de
sub-bloques internos o anidados. Se conocen dos tipos de bloque anónimos y subprogramas
(Procedimientos y Funciones). La siguiente figura ilustra la estructura de los tipos de bloques
conocidos:
Anónimo Procedimiento Función
[DECLARE] PROCEDURE nombre IS FUNCTION nombre IS

BEGIN BEGIN RETURN tipo_dato
--- Instrucciones --- Instrucciones BEGIN ----
[EXCEPTION] [EXCEPTION] Instrucciones
--- Instrucciones --- Instrucciones RETURN valor,
END; END; [EXCEPTION] ---
Instrucciones
END;

Bloques Anónimos
Son bloques sin nombre, se declaran en un punto de la aplicación desde el cual se ejecutan.
Se puede insertar un bloque anónimo dentro de otro programa que posea un precompilador, como
Pro*C o ejecutarse desde SQL*Plus. El cuerpo de instrucciones de los Triggers lo conforman
bloques de este tipo.
Subprogramas
Son bloques de PL/SQL con nombre. Estos pueden tomar parámetros de entrada y devolver
valores a su vez una vez finalizada la ejecución. Se pueden invocar desde diferentes puntos en la
aplicación. Se declaran como Procedimientos y Funciones, en general se elabora un procedimiento
para ejecutar alguna tarea compleja o repetitiva, y una función para calcular algún valor.
Puede almacenar subprogramas en la base de datos o declararlos como parte de una

aplicación, estos subprogramas pueden ser llamados desde cualquier parte, si están en la base de
datos, o desde cualquier parte de la aplicación si solo pertenecen a esta.
La siguiente tabla muestra los diferentes programas que pueden crearse en PL/SQL:
Tipo de Programa Descripción Disponibilidad

Anónimo Bloque sin nombre de PL/SQL Todos los entornos de
que esta inmerso dentro de una PL/SQL
aplicación o que es interactivo
Stored Procedure o Bloque PL/SQL con nombre Oracle Server
Función almacenado en el Oracle Server, puede
aceptar parámetros y ser llamado varias
veces usando el nombre

Procedimiento o Bloque con nombre de PL/SQL Componentes Oracle

Función de Aplicación almacenado en una aplicación Developer Developer, por ejemplo Forms
o una librería compartida, puede aceptar
parámetros y ser invocado repetidas
veces usando el nombre
Paquete Modulo con nombre de PL/SQL Componentes Oracle
que agrupa objetos relacionados como Server y Oracle Developer, por
procedimientos, funciones e ejemplo Forms
identificadores
Trigger de base de Bloque de PL/SQL que esta Oracle Server
datos asociado a una tabla de la base de datos y
se ejecuta automáticamente cuando
ocurre el evento para el que fue definido
Trigger de Bloque de PL/SQL que esta Componentes de Oracle
aplicación asociado con un evento en la aplicación y Developer, por ejemplo Forms
se ejecuta automáticamente cuando el
evento ocurre durante la ejecución
SITAXIS DE BLOQUES PL/SQL
Debido a que PL/SQL es una extensión de SQL, las reglas de sintaxis en general que aplican
a SQL también aplican al lenguaje PL/SQL:
Los identificadores y literales, así como otras unidades léxicas, pueden estar separadas por
uno o más espacios u otros delimitadores que no puedan ser confundidos como parte de la unidad
léxica. No puede insertar espacios dentro de las unidades léxicas excepto en cadenas de caracteres
literales y comentarios.

Las instrucciones pueden estar en una misma línea, pero las palabras clave deben estar en una
única línea.
DELIMITADORES
Los delimitadores son símbolos simples o compuestos que adquieren un significado especial
al ser interpretados por PL/SQL, la siguiente tabla muestra los símbolos que maneja este lenguaje:
Símbolo Significado Símbolo Significado

+ Operador de adición <> Operador “diferente de”
- Operador de sustracción/negación != Operador “diferente de”
* Operador de multiplicación || Operador de concatenación
/ Operador de división real -- Comentario de una línea
= Operador “igual a” /* Delimitador “apertura de
comentario”
@ Indicador de acceso remoto */ Delimitador “cierre de
comentario”
; Terminador de instrucción := Operador de asignación

IDETIFICADORES
Los identificadores son usados para nombrar programas PL/SQL, ítems y unidades, entre las
cuales pueden incluir variables, constantes, excepciones, cursores, variables de cursores,
subprogramas y paquetes. Las reglas para nombrar un identificador en PL/SQL son las mismas que
para nombrar variables.
LITERALES
Un literal es un valor explícito ya sea numérico, string, caracter o booleano. Es un valor no

representado por un identificador.
Los literales incluyen todos los caracteres imprimibles en PL/SQL, estos son letras, números,
espacios y caracteres especiales.
Los literales numéricos se pueden representar por un valor simple entero o punto flotante (por
ejemplo 5 ó -650.76) o en notación científica (por ejemplo 3.45E-5 lo que representa 3.4x10-5)
COMETARIOS
Los comentarios son utilizados para documentar los programas y facilitar el mantenimiento
de los mismos. En PL/SQL los comentarios deben estar precedidos por dos guiones de separación
(--) sin blanco entre ellos, si el comentario ocupa una línea o encerrado entre los separadores de
inicio y fin /* y */, si el comentario ocupa varias líneas.

El siguiente ejemplo muestra el uso de los comentarios:
…
v_salario NUMBER(9,2);
BEGIN -- Este es el inicio del bloque

/* En este bloque se calcula el salario anual basado en el salario
mensual el cual es dado por el usuario como dato de entrada */
v_salario := &p_salario_mensual * 12;
END; -- Este es el final de la transacción

TIPOS DE DATOS E PL/SQL
La siguiente tabla muestra un resumen de los tipos de datos base de PL/SQL:
Tipo de Dato Descripción

VARCHAR2(long. max) Cadena de caracteres de longitud variable con un máximo de “long.
max” pueden llegar hasta un máximo de 32.767 bytes y no tiene longitud
por defecto
NUMBER[(posic, dec)] Numero de precisión fija o flotante con “posic” posiciones y “dec”
posiciones decimales
DATE Fecha y Hora hasta una precisión de minutos y segundos
CHAR[(long.max)] Caracteres de longitud fija hasta un máximo de 32.767 bytes, por defecto
la longitud es 1
LONG Cadenas de caracteres de hasta 2 Gbytes de longitud. Estos datos no
pueden ser seleccionados y almacenados en una variable PL/SQL
RAW Números enteros hasta 255
LONG RAW Datos en formato binario de hasta 2 Gbytes, generalmente utilizado para
imágenes, este tipo de dato no es interpretado por PL/SQL
BOOLEAN Valores lógicos, pueden almacenar tres posibles valores VERDADERO,
FALSO o NULL
BINARY_INTEGER Valores enteros entre –2.147.483.647 y 2.147.483.647
PLS_INTEGER Valores enteros entre -2.147.483.647 y 2.147.483.647 pero los cuales
requieren menor almacenamiento que los demás tipos numéricos
RECORD Columnas tipo registro
TABLE Arreglo de una dimensión
ROWID Dirección de fila en formato hexadecimal

VARIABLES E PL/SQL
Con PL/SQL se pueden declarar variables, estas variables pueden ser utilizadas para recibir
valores resultantes de la ejecución de consultas SQL, o pueden aparecer en cualquier tipo de
expresiones que aparezcan dentro del bloque PL para el cual fueron declaradas. Algunas ventajas
del uso de variables son las siguientes:
• Almacenamiento temporal de datos

• Calculo de valores sin nuevos accesos a la base de datos
• Pueden ser reutilizadas en distintas partes del bloque de instrucciones
• Son fáciles de mantener y actualizar
TIPOS DE VARIABLE E PL/SQL
En PL/SQL se pueden declarar distintos tipos de variables:
ESCALARES
Son variables que contienen valores simples, almacenan principalmente valores que
corresponden a los mismos tipos básicos de las columnas de una tabla. También pueden almacenar
valores lógicos.
COMPUESTAS
Son variables que contienen varios tipos de datos, como los registros.

REFERECIAS
Son variables de tipo puntero referencian posiciones de almacenamiento de otros objetos.

Estas variables no están cubiertas por este curso.
LOB
Variables llamadas localizadores. Indican la localización de objetos complejos cuyo

almacenamiento real esta en archivos fuera de base de datos, como por ejemplo imágenes, texto,
vídeo, etc de hasta 4 GB de longitud.
Los tipos de dato LOB (Objetos Largos) permiten localización eficiente y acceso aleatorio a
los datos, existen los siguientes tipos de datos LOB:
• CLOB : (Character Large Object) se utilizan para almacenar grandes cantidades

de texto en la base de datos.
• BLOB: (Binary Large Object) se utiliza para almacenar en la base de datos

objetos binarios.
• BFILE : (Binary File) se utiliza para almacenar archivos binarios fuera de la base
de datos, en archivos del sistema operativo.
• NCLOB: (National Language Character Large Object) se utiliza para almacenar

grandes bloques de datos en la base de datos con formatos de presentación
multilenguaje.
Además existen variables que no son de PL/SQL:

Variables Bind (de enlace), son variables que se declaran en una sesión y sirven
para almacenar cálculos parciales, son las variables utilizadas para el pase de
parámetros al runtime durante la ejecución de uno o más programas PL/SQL. Para
declarar una variable bind durante una sesión de SQL*Plus se utiliza el comando
VARIABLE seguido del nombre de la variable y el tipo, a continuación se muestra un
ejemplo :
VARIABLE valor_de_retorno NUMBER

VARIABLE mensaje_devuelto VARCHAR2(60)
Tanto SQL como SQL*Plus pueden referenciar las variables bind, y SQL*Plus puede
visualizar su valor o utilizarla como cualquier variable durante la ejecución de cualquier bloque.
Para visualizar el contenido de una variable de tipo bind se utiliza el comando PRINT. El siguiente
ejemplo ilustra el uso del comando PRINT:
SQL> VARIABLE tot_sueldo NUMBER

...
SQL> PRINT tot_sueldo
Variables Host: son llamadas también variables de sustitución, se definen

precediendo al identificador por el símbolo ampersand, se referencian dentro de los
bloques de PL/SQL colocando inclusive el símbolo ampersand y su efecto es el de
sustituir completamente la variable por la cadena que recibe como entrada. El siguiente
ejemplo muestra un ejemplo en el cual se hace uso de ambos tipos de variables,
contiene comandos de SQL*Plus y un bloque completo de PL/SQL :

VARIABLE salario_mensual NUMBER

ACCEPT salario_anual PROMPT ‘Introduzca el Salario Anual : ‘
DECLARE
salario_auxiliar NUMBER(12,2) := &salario_anual;
BEGIN
:salario_mensual := salario_auxiliar / 12;
END;
/
PRINT salario_mensual
También podemos ver el contenido de las variables bind usadas dentro de un bloque
PL/SQL, desde dentro del mismo bloque, haciendo uso del paquete DBMS_OUTPUT.PUT_LINE
que es un paquete proporcionado por ORACLE y PUT_LINE es un procedimiento dentro de ese
paquete. El siguiente ejemplo muestra el uso del paquete DBMS_OUTPUT:
SET SERVER OUTPUT ON

ACCEPT salario_anual PROMPT ‘Introduzca el Salario Anual : ‘
DECLARE
salario_auxiliar NUMBER(12,2) := &salario_anual;
BEGIN
salario_auxiliar := salario_auxiliar / 12;
dbms_output.put_line (‘El salario mensual es ‘
| | TO_CHAR(salario_auxiliar));
END;
/

Observe que en este ejemplo no se hace uso de ninguna variable host.
DECLARACIO DE VARIABLES E PL/SQL
Es necesario declarar todos los identificadores en la sección declarativa antes de referenciar

estos en cualquier bloque PL/SQL, se pueden asignar valores iniciales a las variables durante la
declaración, cada variable debe estar en una línea de declaración separada.
Sintaxis: identificador [COSTAT] tipo_dato [OT ULL] [:= | DEFAULT expresión];
Donde:
identificador: es el nombre de la variable
CONSTANT: restringe la variable al único valor de inicialización, no puede ser cambiado
tipo_dato: es un tipo de dato valido, escalar, compuesto, referencia o LOB
NOT NULL: indica que la variable no puede contener un valor nulo, las variables que
poseen esta cláusula deben ser inicializadas
expresión: es cualquier expresión PL/SQL valida, puede ser un literal, otra variable o una
expresión que involucra operadores y funciones
En la declaración debe considerar lo siguiente:
Los nombres de variables deben obedecer las mismas reglas que los objetos SQL
Es recomendable usar ciertos estándares en los nombres para mayor facilidad de
comprensión y mantenimiento del código, por ejemplo v_nombre indicara el nombre
de una variable y c_nombre indicara el nombre de una constante
Se puede inicializar la variable usando el operador de asignación, o usando la
palabra reservada DEFAULT, si no hay asignación inicial el valor será NULL hasta
que se realice la primera asignación

Dos objetos pueden tener el mismo nombre, si están definidos en bloques distintos,
cuando esto sucede, solo puede usarse en un bloque el objeto que esta definido en él
No se debe asignar nombres de variables con el mismo nombre de una columna
referenciada en el bloque, cuando esto sucede al referenciar el nombre de la variable, el
manejador asumirá que se está consultando la columna y puede generar errores
Los identificadores no deben tener más de 30 caracteres. El primer carácter debe ser
una letra, los restantes caracteres pueden ser letras, números o caracteres especiales
A continuación se muestran algunos ejemplos de declaración de variables:
Ejemplos de variable tipo UMBER:

DECLARE
EDAD NUMBER(2);
SUELDO NUMBER(8,2);
SUELDO NUMBER(8,2) := 0;
PI CONSTANT NUMBER(5,4) := 3.141592;
Ejemplos de variable tipo CHAR:

DECLARE
NOMBRE CHAR(20);
DEPARTAMENTO CHAR(14) NOT NULL := 'ADMINISTRACIÓN';
LETRAINICIAL CHAR;
Ejemplos de variable tipo DATE:

DECLARE
NACIMIENTO DATE;
FUNDACION DATE :='17-JAN-94';
NACIMIENTO DATE NOT NULL;

Ejemplos de variable tipo BOOLEA:

DECLARE
DISPONIBLE BOOLEAN;
DISPONIBLE BOOLEAN := NULL;
DISPONIBLE BOOLEAN NOT NULL := TRUE;

VARIABLES TIPO ATRIBUTO E PL/SQL
Los objetos de PL/SQL (variables y constantes) y las operaciones efectuadas sobre los
objetos de la base de datos (tablas, vistas y columnas), pueden ser asociados con los siguientes
atributos:
%ROWTYPE : Este atributo es utilizado para declarar una variable con la estructura
idéntica a la de una fila en una tabla o vista. A continuación se muestra un ejemplo:
FILA_EMP EMPLEADO%ROWTYPE;
En la declaración anterior, la estructura del identificador FILA_EMP será idéntica a la de la

fila en la tabla EMPLEADO.
%TYPE: Este atributo es utilizado para declarar una variable del mismo tipo como:
- Una columna de una tabla o vista
- Una variable previamente declarada
A continuación se muestra un ejemplo de este tipo de declaración:
TRABAJADOR EMPLEADO.NOMBRE%TYPE;
En este ejemplo, el identificador TRABAJADOR será del mismo tipo que la columna
NOMBRE de la tabla EMPLEADO.
Variables tipo RECORD
Se utilizan para declarar registros con campos especificados por el usuario.
Sintaxis : TYPE nombre_tipo IS RECORD nombre_campo tipo_campo [OT ULL]

:= expresión _pl/sql

A continuación se muestra un ejemplo de una declaración de variable de tipo RECORD:
DECLARE
TYPE emprectyp IS RECORD
(empno NUMBER(4) NOT NULL,
ename VARCHAR2(10),
job VARCHAR2(14),
......
deptno NUMBER (4));
La siguiente declaración, define la variable reg_emp como de tipo registro con la estructura
definida en la declaración anterior.
emp_rec emprectyp;
Los campos de un registro, pueden ser inicializados en la declaración
DECLARE
TYPE timetyp IS RECORD
(second NUMBER(2) :=0,
minute NUMBER(2) := 0,
hour NUMBER(2) := 0);
Variables tipo TABLE
Se tiene un nuevo tipo de dato el cual permite ser usado como un arreglo, es el tipo TABLE.
A continuación se muestra la sintaxis para declarar variables de tipo table.

TYPE nombre_tipo IS TABLE OF columna_tipo/nombre_tabla.nombre_columna%TYPE

[OT ULL] IDEX BY BINARY_INTEGER
A continuación se muestra un ejemplo de una declaración de variable tipo TABLE:
DECLARE
TYPE enametabtyp IS TABLE OF CHAR(10)
INDEX BY BINARY_INTEGER;
DECLARE
TYPE enametabty IS TABLE OF emp.ename%TYPE
INDEX BY BINARY_INTEGER;
Al declarar una variable de PL/SQL como de tipo TABLE se deben tener en cuenta las
siguientes consideraciones:
No puede ser inicializada en la declaración

Puede ser pasada como parámetro de procedimientos
No pueden ser utilizadas en una cláusula INTO.
Para referenciar sus valores, se debe utilizar la posición del elemento que se
desea manipular o consultar. De la misma manera que cuando se referencian
posiciones de un arreglo o vector.
En el siguiente ejemplo, se muestra la forma de insertar en la tabla EMPLEADO los valores

del vector filas pasado como parámetro al procedimiento insertar_datos_emp

PROCEDURE insertar_datos_emp
(filas BINARY_INTEGER, empno_tab empnotabtyp, ename_tab enametabtyp) IS
BEGIN
FOR i IN 1 .. filas LOOP
INSERT INTO EMPLEADO (EMPNO, NOMBRE, ...)
VALUES (empno_tab(i), ename_tab(i), ...);
END LOOP;
END;
ASIGADO VALORES A VARIABLES
Para asignar un valor a una variable, deberá escribir una sentencia PL/SQL. En el lado
izquierdo estará el nombre de la variable ya declarada, a continuación el operador de asignación
(:=) y seguidamente el valor o la expresión cuyo resultado se almacenara en la variable, terminando
con punto y coma (;).
Sintaxis: identificador := expresión;
Donde:
identificador: es el nombre de la variable
expresión: puede ser una variable, un literal o una llamada a función, pero no una columna de
base de datos
Ejemplo 1: Asignar a la variable PROMEDIO, el promedio de 5, 10 y 30

Ejemplo 2: Almacenar en la variable SALARIOMENSUAL el salario del empleado

PABLO
SELECT SALARIO ITO SALARIOMENSUAL

FROM EMPLEADO
WHERE NOMBRE = 'PABLO';
Evaluando Condiciones con el Valor ULL
Se puede determinar una condición de NULL con el operador IS NULL

Cualquier expresión aritmética que contenga un valor NULL el resultado será NULL
El valor NULL en las operaciones de concatenación se tratara como un string vacío

BLOQUES ITEROS Y ALCACE DE VARIABLES
En los bloques PL/SQL una variable declarada en la sección de declaraciones, solo es visible
dentro de ese bloque. Un bloque que sea declarado a su vez dentro de otro (bloque interno) puede
acceder a las variables que fueron declaradas en el bloque principal que lo contiene y manipular el
contenido de estas variables, además de las variables que sean declaradas en su propia sección de
declaración. Sin embargo, las variables declaradas en el bloque interno no pueden visualizarse en el
bloque externo.
El siguiente cuadro muestra un ejemplo del ámbito de visualización de las variables en un

bloque interno:
…
DECLARE
X
BINARY_INTEGER;
BEGIN
-- Instrucciones
X := X + 1;
DECLARE
Y NUMBER; Alcance
de X
BEGIN
…
Y := Y + X; Alcance
… de Y
END;
…
END;
En el ejemplo anterior observe que en bloque interno tanto la variable X, que fue declarada
en el bloque externo, como la variable Y propia del bloque, son visibles en tanto que en el bloque

externo solo es visible la variable X. Esto se debe a que una variable declarada en un bloque, tiene
vida solo mientras el bloque se ejecuta, y desaparece al terminar la ejecución de ese bloque.
Alcance
El alcance de un identificador es la zona de una unidad de programa, sea esta un bloque,

subprograma o paquete desde donde puede ser referenciado ese identificador.
OPERADORES
Los operadores son símbolos reservados de PL/SQL que permiten la comparación de dos o
más expresiones para permitir la obtención de un resultado BOOLEANO. Se conocen varios tipos
de operadores, a continuación se muestran los operadores que maneja PL/SQL:
OPERADORES UMERICOS
Operador Significado
< menor que
> mayor que
= igual a
!= ó <> diferente de
<= menor o igual a
>= mayor o igual a
OPERADORES LOGICOS O BOOLEAOS
Operador Significado
AND Y

OR O
NOT Negación
Los operadores lógicos poseen un valor de verdad que puede ser TRUE o FALSE, o en su
defecto puede ser NULL o vacío. Dependiendo de los valores de las dos expresiones que en un
momento dado se estén comparando, los valores posibles de la comparación para cada tipo de
operador se muestran a continuación:
Para el operador AD
TRUE FALSE NULL

TRUE TRUE FALSE NULL
FALSE FALSE FALSE FALSE
NULL NULL FALSE NULL
Para el operador OR
TRUE FALSE NULL

TRUE TRUE TRUE TRUE
FALSE TRUE FALSE FALSE
NULL TRUE NULL NULL
Para el operador OT
TRUE FALSE NULL

FALSE TRUE NULL

PRACTICA 1
1. Desarrollar un bloque de programa simple, que muestre el costo final de un producto, al
aplicar el Iva de 15% al precio solicitado como entrada.
2. Declarar una tabla PL/SQL denominada estudiante con los campos nombre, edad y sexo. El
programa deberá mostrar un mensaje indicando que la misma esta vacío, utilice los
métodos vistos.

Capítulo 2
FUCIOES E PL/SQL

FUCIOES E PL/SQL
El lenguaje de programación PL/SQL soporta todas las funciones provistas por SQL. Todas
las funciones, excepto las de agrupamiento, pueden ser utilizadas como parte de una instrucción
PL/SQL que no involucra cláusulas de SQL. La tabla siguiente muestra algunas de las funciones
que pueden utilizarse clasificadas por tipo:
Tipo de función Funciones pertenecientes al tipo

Numéricas SQRT, ROUND, POWER, TRUNC, TO_NUMBER
Carácter LENGTH, UPPER, LOWER, INITCAP, LPAD, RPAD, LTRIM,
TO_CHAR, SUBSTR
Fecha y Hora ADD_MONTHS, MONTHS_BETWEEN, LAST_DAY, TO_DATE
De Grupo AVG, MAX, MIN, COUNT, SUM
ITERACTUADO CO EL ORACLE SERVER
El lenguaje de programación PL/SQL soporta totalmente las sentencias del lenguaje de

manipulación de datos de SQL. Esto significa que puede soportar las instrucciones: SELECT de
recuperación de datos, UPDATE de actualización de datos, INSERT de inserción de datos y
DELETE de eliminación de datos. También soporta las instrucciones que permiten el control de
transacciones y el resguardo de la integridad en la base de datos, como son COMMIT, para guardar
de forma permanente los datos en la base de datos, ROLLBACK para anular una transacción que
no haya sido guardada previamente con una instrucción commit, SAVEPOINT para fijar un punto
de control que sirve para devolver parcialmente una transacción, desde el lugar en que se encuentra
hasta el punto donde se definió el savepoint, y LOCK TABLE para el bloqueo de tablas durante las
modificaciones críticas de datos.

Los identificadores de cada sentencia son primero verificados para comprobar si son
columnas de una tabla de la base de datos, en caso de no serlo, el manejador asumirá que es un
identificador de PL/SQL.
COMPARACIO DE ISTRUCCIOES SQL y PL/SQL
Un bloque PL/SQL no es una unidad de transacción. Las sentencias COMMIT,

ROLLBACK y SAVEPOINT son independientes de los bloques, sin embargo pueden
usarse dentro de cualquier bloque
PL/SQL no soporta instrucciones de definición de datos, tales como CREATE, DROP o

ALTER
PL/SQL no soporta instrucciones de control de lenguaje, tales como GRANT y REVOKE
RECUPERADO DATOS – La cláusula SELECT
Al igual que en SQL, para recuperar datos de la base de datos se hace uso de la cláusula
SELECT, con la única variante de que para poder manipular el resultado mediante instrucciones
PL/SQL se necesitan variables de almacenamiento propias de PL/SQL, puesto que las columnas no
se pueden manipular directamente.
Sintaxis: SELECT lista_de_columnas

ITO {lista_de_variables | nombre_registro}
FROM tabla
WHERE condición;
Donde:

lista_de_columnas: es la lista de una o más columnas que se recuperan en la consulta, puede

contener expresiones SQL, funciones de fila o funciones de grupo
lista_de_variables: es una lista de variables escalares, deben coincidir tanto en posición como en
tipo de dato y número, con las columnas que se recuperan en la consulta
nombre_registro: es el bloque PL/SQL que recibirá los valores
Tabla : indica la o las tablas desde las cuales se hace la consulta
condición: es la condición de búsqueda, puede contener nombres de columnas, expresiones,
constantes y operadores de comparación, incluyendo variables PL/SQL
La cláusula INTO es obligatoria, debe aparecer entre las opciones SELECT y FROM. Se
utiliza para especificar las variables que almacenaran los valores de las columnas que retornara la
consulta. La consulta debe retorna una y solo una fila, si retorna mas de una generara un error, igual
sucede cuando la consulta no retorna ninguna fila. En PL/SQL los errores pueden capturarse y
tratarse de manera diferente para que el programa no se detenga de manera abrupta, a este proceso
se le llama manejo de excepciones y será explicado en capítulos posteriores.
En el siguiente ejemplo se muestra un ejemplo del uso de la cláusula INTO:
DECLARE
v_deptno NUMBER(2);
v_loc VARCHAR2(15);
BEGIN
SELECT deptno, loc
INTO v_deptno, v_loc
FROM dept
WHERE dname = ‘VENTAS’;
END;

ISERTADO DATOS – La cláusula ISERT
La inserción de datos desde PL/SQL cumple las mismas especificaciones de la inserción

hecha desde SQL. A continuación se muestra un ejemplo de la inserción de datos desde un bloque
PL/SQL:
DECLARE
SUELDO NUMBER(6,2) := 5000.50;
EMPLEADO CHAR(25) := 'MONICA';
BEGIN
INSERT INTO EMPLEADO (NOMBRE, CARGO,
SALARIO)
VALUES (EMPLEADO, 'SECRETARIA', SUELDO);
END;
ACTUALIZADO DATOS – La cláusula UPDATE
En el siguiente ejemplo se muestra un caso de una posible inserción desde un bloque

PL/SQL:
DECLARE
BEGIN

UPDATE EMPLEADO
SET SALARIO = SALARIO * 1.5
WHERE EMPNO = 500;
END;
BORRADO DATOS – La cláusula DELETE
Igual que en las operaciones anteriores, la eliminación de datos desde un bloque PL/SQL es
idéntica a la eliminación de datos hecha desde SQL. A continuación se muestra un ejemplo:
DECLARE
EMPLEADO EMPLEADO.NOMBRE%TYPE := 'MONICA';
BEGIN
DELETE FROM EMPLEADO
WHERE NOMBRE = EMPLEADO
AND CODIGO = 1050;
COMMIT;
END;
COTROL DE TRASACCIOES
El lenguaje PL/SQL permite un control total de la lógica de las transacciones, tomando como
transacción el mismo criterio que en SQL. Esto permite que el usuario pueda controlar totalmente
los cambios que se efectúan en la base de datos, guardando algunos grupos de datos y descartando
otros si la situación así lo requiere. Una transacción comienza con la primera instrucción SQL que

se ejecuta y finaliza con el próximo COMMIT o ROLLBACK exitoso, el final de una transacción
puede ocurrir de manera explícita, por una instrucción dentro de un bloque PL/SQL o de manera
implícita, por algún evento en el entorno de SQL donde se está ejecutando el bloque de
instrucciones, por ejemplo la culminación de una sesión SQL*Plus termina automáticamente la
transacción pendiente. Para marcar un punto intermedio en el procesamiento de la transacción se
utiliza el comando SAVEPOINT.
Sintaxis : SAVEPOINT punto_intermedio;

Donde:
punto_intermedio: es el nombre de punto de control hasta donde se reversará la transacción
en caso de usar una sentencia ROLLBACK.
Los comandos de control de transacciones son completamente soportados por PL/SQL, sin
embargo algunas instalaciones pueden imponer algunas restricciones al uso de estos.
A continuación se muestra un ejemplo de la aplicación de las cláusulas de control de

transacciones:
DECLARE
BEGIN
INSERT INTO EMPLEADO (NOMBRE, CARGO,
SALARIO)
VALUES (EMPLEADO, 'SECRETARIA',
SUELDO);
SAVEPOINT A;

DELETE FROM EMPLEADO

WHERE NOMBRE = 'LUIS'
AND CODIGO = 2350;
SAVEPOINT B;
UPDATE EMPLEADO
SET SALARIO = SUELDO
WHERE NOMBRE = EMPLEADO
OR NUMDEPT = 01;
ROLLBACK TO SAVEPOINT B;
COMMIT;
END;
/

PRACTICA 2
1. Crear un bloque PL/SQL que muestre por pantalla cuantos registros tiene la tabla
Empleados.
2. Crear un bloque PL/SQL que inserte una fila a la tabla empleados. Todos los datos debe ser
solicitados por pantalla.
3. Crear un bloque PL/SQL que actualice el nombre del registro insertado en el ejercicio
anterior.
4. Crear un bloque PL/SQL que elimine el registro insertado en el ejercicio anterior

Capítulo 3
ESTRUCTURAS DE COTROL

ESTRUCTURAS DE COTROL DE PL/SQL
En PL/SQL se puede controlar el flujo de control de las operaciones mediante el uso de dos
tipos de estructuras de control básicas: CONDICIONALES con la sentencia IF e ITERACIONES
con la sentencia LOOP.
CODICIOALES
El condicional es una sentencia que controla la ejecución de sus bloques de instrucciones

dependiendo del valor de verdad que retorna una o más comparaciones que gobiernan a la
instrucción. En PL/SQL el resultado de una comparación puede arrojar como resultado: TRUE,
FALSE o NULL.
Cuando es posible la aparición de un valor NULL, se debe tomar en cuenta lo siguiente:
• Cuando se realiza una comparación entre un valor NO NULO y un valor NULO, el

resultado siempre será NULO.
• Cuando se realiza un cálculo (suma, resta, etc.) de un valor NO NULO y un valor
NULO el resultado siempre será NULO, exceptuando la concatenación.
A continuación se muestran algunos ejemplos:
10 + NULL --------------------> el resultado será NULO.

'ANA' || NULL || 'LISIS' ------> el resultado será ANALISIS.

La sentencia IF
Permite la ejecución de una o varias sentencias dependiendo de que el valor de verdad que
retorna una condición resulte verdadero. En la instrucción condicional puede haber una o más
condiciones en la misma instrucción, en este caso cada una gobernará la ejecución de un grupo de
instrucciones y todas las condiciones deben ser excluyentes entre sí.
Sintaxis: IF condición THE

sentencia o grupo de sentencias
[ELSIF condición THE
sentencia o grupo de sentencias]
. . . . . . . .
. . . . . . . . (grupo de ELSIF)
. . . . . . . .
[ELSE
sentencia o grupo de sentencias por defecto]
END IF;
Donde:
condición: es como su nombre lo indica, el parámetro que permitirá la ejecución o no de las

instrucciones que están dentro del IF. Si la condición es verdadera las sentencias asociadas al IF se
ejecutan, en el caso contrario (FALSE o NULL), no se ejecutan.
sentencias o grupo de sentencias: son el conjunto de instrucciones que formarán el

algoritmo que se ejecutará cuando la condición se cumpla.
Ejemplo de IF: Construya un programa que permita obtener como parámetro de entrada
desde teclado un código de empleado, buscará el salario del mismo y aumentar el sueldo según la
tabla siguiente:

Rango de sueldos Monto de

aumento
De 10.000 a 20.000 5.000
> 20.000 y <= 4.000
30.000
DECLARE
SUELDO NUMBER;
BEGIN
SELECT SALARIO INTO SUELDO
FROM EMPLEADO
WHERE CODIGO = &IDENTIFICA;
IF (SUELDO => 10000) AND (SUELDO <= 20000) THEN
UPDATE EMPLEADO
SET SALARIO = SUELDO + 5000;
ELSIF (SUELDO > 20000) AND (SUELDO < 30000)
THEN
UPDATE EMPLEADO
SET SALARIO = SUELDO + 4000;
END IF;
COMMIT;
END;
/
OTA: El ampersand (&) es usado en los bloques de PL/SQL, (cuando se trabaja con SQL*PLUS), para
facilitar el ingreso de parámetros. Los parámetros serán recibidos e interpretados al momento de la ejecución del bloque.
Como se puede observar en el ejemplo anterior, código es igual a &IDENTIFICA, donde &IDENTIFICA va a ser
sustituido por el valor introducido por el usuario al momento de ejecutar el bloque de PL/SQL.

ITERACIOES
Una iteración es la ejecución repetida de un conjunto de instrucciones, múltiples veces hasta

que se cumpla una condición, que permite la finalización del ciclo. Existen dos formas de realizar
una iteración:
Por medio de bucles

Por medio de la sentencia GOTO
Existen cuatro tipos de bucles:
Bucle simple
Bucle numérico (FOR)
Bucle condicional (WHILE)
BUCLE SIMPLE
Repite una o más sentencias múltiples veces.

Sintaxis: LOOP
condición de salida del bucle
ED LOOP;
Donde:
LOOP: indica el inicio del bucle
sentencia o grupo de sentencias: conjunto de instrucciones a ejecutar
condición: requisito de salida del bucle. Si a un bucle no se le coloca una condición de salida,
este permanecerá ejecutándose indefinidamente.
La condición de salida posee la siguiente estructura:

EXIT [nombre_de_etiqueta] [WHE condición];

El "nombre_de_etiqueta" se utiliza cuando se desea salir, no solamente del bucle en curso,

sino también de uno más externo a este.
A continuación se muestra un ejemplo de bucle simple:
Ejemplo 2: Construya un programa que permita insertar en una tabla temporal diez veces la
cadena de caracteres “HOLA”:
DECLARE
CONTADOR NUMBER(3) := 0;
BEGIN
LOOP
INSERT INTO TEMPORAL (NUMERO1, TEXTO)
VALUES (CONTADOR, 'HOLA');
CONTADOR := CONTADOR + 1;
EXIT WHEN CONTADOR = 10;
END LOOP;
END;
/
BUCLE UMÉRICO (FOR)
Repite una o más sentencias un número fijo de veces.

Sintaxis: FOR índice I [ REVERSE ] entero_1 . . entero_2 LOOP
ED LOOP;
Donde:
índice: es la variable de conteo y control del bucle. Esta variable es implícitamente de tipo
numérico, el cual podrá ser referenciado dentro del bucle, pero no podrá asignársele valor

REVERSE: realiza el conteo de mayor a menor, (si no se coloca este parámetro el conteo se
realizará de menor a mayor).
entero_1 y entero_2: rango en el que se va a realizar el conteo.
Ejemplo 3: Elabore el mismo programa del ejemplo2, usando un bucle numérico:
BEGIN
FOR I IN 1..10 LOOP
VALUES (I, 'HOLA');
END LOOP;
END;
/
BUCLE CODICIOAL (WHILE)
Repite una o más sentencias mientras la condición de control de la iteración sea verdadera
Sintaxis: WHILE condición LOOP

ED LOOP;
Donde:
condición: es la condición que gobierna la ejecución
Ejemplo 3: Elabore el mismo programa del ejemplo2, usando el bucle while:
DECLARE
CONTADOR NUMBER(3) := 0;
BEGIN

WHILE CONTADOR < 10 LOOP

VALUES (CONTADOR, ‘HOLA’);
CONTADOR := CONTADOR + 1;
END LOOP;
END;
/
SETECIA GOTO
La sentencia GOTO, como en otros lenguajes de programación, permite saltar

incondicionalmente hacia una línea específica de un bloque PL/SQL identificada mediante una
etiqueta, pudiendo así alterar la secuencia normal de la ejecución del programa. La etiqueta debe ir
encerrada entre dobles símbolos de “menor que” y “mayor que”
Sintaxis: . . . . . . . .
. . . . . . . .
GOTO ETIQUETA
<<ETIQUETA>>
. . . . . . . .
. . . . . . . .
Está permitido el uso de la sentencia GOTO cuando:

- Se ejecute dentro de una misma secuencia de instrucciones
- Se cierra una secuencia de sentencias
No está permitido utilizar la sentencia GOTO:
- Para ir a una etiqueta que se encuentre dentro de un bucle o estructura condicional.

ETIQUETAS
Las etiquetas se pueden usar para referenciar valores en bloques y bucles, que de otra manera
no podrían ser visibles a causa de las reglas de alcance. Las etiquetas tienen que ser especificadas
previa a sentencias ejecutables.
Sintaxis : <<Nombre_etiqueta>>
DECLARE
declaraciones
BEGIN
sentencias a ejecutar
[EXCEPTION
excepciones manejadas en el bloque]
ED Nombre_etiqueta;
En el siguiente ejemplo se muestra el uso de las etiquetas para referenciar bloques:
BEGIN
<<BLOQUEEXTERNO>>
DECLARE
N NUMBER;
BEGIN
N := 5;
<<BLOQUEINTERNO>>
DECLARE
X NUMBER := 10;
N CHAR(10) := 'DOS';
BEGIN
INSERT INTO TEMPORAL
VALUES (BLOQUEEXTERNO.N, X, N);

COMMIT;
END BLOQUEINTERNO;
END BLOQUEEXTERNO;
END;
/
En el ejemplo anterior, se está utilizando el nombre del bloque para decirle a PL/SQL, que el
valor "N" que deberá ser procesado, es el que se declaró en el bloque externo y no el que se declaró
en el bloque interno.
En el siguiente ejemplo se muestra el uso de las etiquetas para referenciar bucles:
BEGIN
<<ETIQUETA>>
FOR I IN 1..10 LOOP
-- sentencias a ejecutar
DECLARE
I NUMBER := 10;
BEGIN
INSERT INTO TEMPORAL
VALUES (I, ETIQUETA.I, 'COMPLETO');
END;
END LOOP ETIQUETA;
END;
/
En el ejemplo anterior, se toma el valor "I" del bloque interno y el valor "I" del bucle FOR,
referenciado por la etiqueta, al momento de realizar la inserción.

CURSORES
CURSORES en SQL
Cuando se manda a ejecutar una instrucción SQL, el manejador Oracle Server abre un área
en memoria en la cual el comando es interpretado y, en caso de ser correcto, el comando es
ejecutado. A esta área de memoria se le llama CURSOR.
Cuando comienza la ejecución de la instrucción, PL/SQL crea un cursor implícito que posee
el identificador de SQL. PL/SQL maneja este cursor automáticamente, sin embargo el programador
puede declarar explícitamente cursores para el tratamiento secuencial de filas de datos, la forma de
hacer esto se explicará en secciones subsiguientes. Hay cuatro atributos asociados a los cursores
que nos permiten controlar y verificar el resultado de su ejecución, estos atributos son:
SQL%ROWCOUNT Retorna el número de filas que fueron afectadas por la mas reciente
instrucción de SQL, es un valor entero
SQL%FOUND Valor lógico BOOLEANO que retorna VERDADERO si la más reciente
instrucción SQL afectó una o más filas de datos
SQL%NOTFOUND Valor BOOLEANO que retorna FALSO si la mas reciente instrucción SQL
no afectó ninguna fila de datos
SQL%HISOPEEN Siempre evalúa en FALSO debido a que PL/SQL cierra implícitamente los
cursores inmediatamente después que son ejecutados
Los atributos de cursores permiten evaluar que pasó en el último cursor implícito utilizado,
estos atributos pueden utilizarse en instrucciones PL/SQL pero no pueden ser utilizados en
instrucciones SQL. Se puede utilizar estos atributos en la sección de excepciones de un bloque para
conocer el resultado de la ejecución de una instrucción de manipulación de datos y tomar las
acciones necesarias como emitir mensajes de número de registros afectados.

El siguiente ejemplo muestra un uso posible de los atributos de cursores:
VARIABLE filas_borradas VARCHAR2(20)

DECLARE
v_orden NUMBER := 605;
BEGIN
DELETE FROM item
WHERE num_orden = v_orden;
:filas_borradas := ‘ Se eliminaron : ‘||

to_char(SQL%ROWCOUNT)|| ‘ filas’;
END;
/
PRINT filas_borradas
Los cursores como se indicó anteriormente son áreas de memoria que contienen filas de datos
de una sentencia SQL durante la ejecución, existen dos tipos de cursores:
CURSORES IMPLÍCITOS
Creados y controlados totalmente por el manejador. Se crean cursores implícitos al ejecutar

cualquier sentencia de manipulación de datos, estas son SELECT, INSERT, UPDATE y DELETE
Cursores explícitos
Creados y manejados totalmente por el programador. Los cursores creados explícitamente, se

crean utilizando la sentencia SELECT para leer múltiples registros y dejarlos en un área de
memoria identificada con el nombre del cursor. Usando el identificador del cursor los registros
pueden ser recuperados y procesados secuencialmente.

DIFERECIAS ETRE CURSORES EXPLÍCITOS E IMPLÍCITOS
Cursor explícito Cursor implícito

Requieren ser declarados No requieren ser declarados
Requieren ser abiertos y cerrados El cursor se abre y se cierra automáticamente
CURSORES E PL/SQL
Los cursores en PL/SQL son cursores explícitos, para crear y manipular este tipo de cursores
se deben tener en cuenta varios aspectos, tomando en cuenta que el control de estos es
responsabilidad del programador:
Sintaxis: DECLARE
CURSOR nombre_del_cursor IS sentencia select;
Para poder utilizar correctamente un cursor explícito, debe seguir los siguientes pasos:
Paso 1: Declarar el cursor

Paso 2: Abrir el cursor, para ello se utiliza la instrucción OPEN seguida del nombre del
cursor
OPEN nombre_del_cursor
Paso 3: Recuperar los datos en secuencia, para esto se utiliza la cláusula FETCH. Esta
cláusula permite la recuperación de los registros uno a uno en secuencia
FETCH nombre_del_cursor ITO variable1, variable2... ;
En este caso la cláusula INTO funciona igual que cuando se utiliza para recuperar datos en
cualquier instrucción de SQL. La primera columna obtenida será asignada a la variable1, la segunda

a la variable2, y así sucesivamente. El orden de estas columnas está fijado por la sentencia
SELECT, al momento de la creación del cursor.
Paso 4: Cerrar el cursor, para ello se utiliza la cláusula CLOSE seguida del nombre del
cursor
CLOSE nombre_de_cursor;
El siguiente ejemplo muestra la declaración y utilización de un cursor explícito llamado

MICURSOR.
Ejemplo 3: Elabore un programa que permita obtener el nombre y el salario de todos

aquellos empleados que ganan mas de $12.000, e insertar estos en otra tabla llamada
TABLANUEVA
DECLARE
SALARIOLIMITE NUMBER(4) := 12000;
MINOMBRE EMPLEADO.NOMBRE%TYPE;
MISALARIO EMPLEADO.SALARIO%TYPE;
CURSOR MICURSOR IS -- Declaración del cursor Paso 1
SELECT NOMBRE, SALARIO
FROM EMPLEADO
WHERE SALARIO > SALARIOLIMITE;
BEGIN
OPEN MICURSOR; -- Apertura del cursor Paso 2
LOOP
-- Recuperación de los datos Paso 3
FETCH MICURSOR INTO MINOMBRE, MISALARIO;
EXIT WHEN MICURSOR%NOTFOUND;
INSERT INTO TABLANUEVA
VALUES (MINOMBRE, MISALARIO);
END LOOP;
CLOSE MICURSOR; -- Cierre del cursor
COMMIT;
END;
/

ATRIBUTOS DE CURSORES EXPLICITOS
Atributo Tipo Descripción
%ISOPEN Booleano Evalúa TRUE si el cursor está abierto
Evalúa TRUE si el FETCH mas reciente no

%NOTFOUND Booleano retornó ninguna fila
Evalúa TRUE si el FETCH mas reciente retornó

%FOUND Booleano una fila
Contiene el total de filas recuperadas por el

%ROWCOUNT Numérico cursor
CURSORES Y REGISTROS
Es posible manejar la recuperación de las filas de datos de un cursor usando un registro

PL/SQL como variable de salida. Ejemplo:
DECLARE
CURSOR empleados IS
SELECT empno, nombre
FROM empleado;
reg_empleado empleados%ROWTYPE;
...
FETCH empleados ITO reg_empleado;
BUCLES FOR DE TIPO CURSOR
También se puede utilizar la instrucción FOR para declarar y utilizar un cursor sin que se
tenga que utilizar explícitamente las instrucciones de APERTURA, RECUPERACION DE
DATOS ni CIERRE del cursor, sino que la misma estructura se encarga de estas operaciones al
momento de su ejecución.

Sintaxis : FOR nombre_del_registro I nombre_del_cursor LOOP

sentencias que serán ejecutadas para cada fila retornada
END LOOP;
Donde:
Nombre del registro: contendrá cada fila de datos que sea recuperada, las columnas de datos
en el registro se pueden referenciar utilizando el nombre del registro seguido del nombre o alias de
la columna separados por un punto.
ombre_del_registro.ombre_de_la_columna
El funcionamiento de un bucle FOR de tipo cursor es el siguiente:
Cuando el cursor de bucle es ejecutado, implícitamente se abre el cursor (OPE).

Cuando una fila satisface la consulta o query asociado al cursor, implícitamente se
ejecuta una búsqueda (FETCH).
Cuando no hay más filas que satisfagan la búsqueda, implícitamente el cursor es
cerrado (CLOSE).
A continuación se muestra el mismo ejemplo XX para ilustrar el manejo de un cursor

utilizando el bucle FOR, en este ejemplo FILACURSOR es el registro de datos del cursor
MICURSOR
DECLARE
SALARIOLIMITE NUMBER(5) := 12.000;
TOTALSALARIO NUMBER(9,2) := 0;
CURSOR MICURSOR IS
SELECT NOMBRE, SALARIO
FROM EMPLEADO
WHERE SALARIO > SALARIOLIMITE;
BEGIN
FOR FILACURSOR IN MICURSOR LOOP

INSERT INTO TABLANUEVA

VALUES (FILACURSOR.NOMBRE,
FILACURSOR.SALARIO);
TOTALSALARIO := TOTALSALARIO +
FILACURSOR.SALARIO;
END LOOP;
COMMIT;
END;
/
REAPERTURA DE U CURSOR
Esta técnica se utiliza para reabrir un cursor con otros valores de inicialización.
El siguiente ejemplo muestra la reapertura de un cursor con un nuevo valor de la variable

SALARIOMIN
DECLARE
BONOTOTAL NUMBER(8,2) := 0;
SALARIOMIN EMPLEADO.SALARIO%TYPE :=
1000;
BONOAUMENTO EMPLEADO.SALARIO%TYPE;
CURSOR BONO IS
SELECT SALARIO * .10
FROM EMPLEADO
WHERE SALARIO > SALARIOMIN;
BEGIN
OPEN BONO;
LOOP
FETCH BONO INTO BONOAUMENTO;
EXIT WHEN BONO%NOTFOUND;
BONOTOTAL := BONOTOTAL + BONOAUMENTO;
IF BONOTOTAL > 2000 THEN
CLOSE BONO;
SALARIOMIN := SALARIOMIN + 500;
BONOTOTAL := 0;
-- Reapertura del cursor, pero con un nuevo
-- valor de SALARIOMIN
OPEN BONO;

END IF;
. . . . . . . .
. . . . . . . .
END LOOP;
END;
/
CURSOR FOR USADO COMO SUB-QUERIES
En este caso no es necesario declarar el cursor. Ejemplo:

BEGI
FOR reg_empleado I (SELECT empno, nombre
FROM empleado) LOOP
instrucciones;
ED LOOP;
ED;
DECLARACIÓ DE U CURSOR CO PARÁMETROS
Los cursores pueden parametrizarse de manera que puedan ser abiertos y cerrados en
diferentes instantes de tiempo, con distintos valores que permiten variar la condición de
recuperación de los datos.
Sintaxis: DECLARE
CURSOR nombre_del_cursor [(nombre_del_parámetro tipo_del_parámetro)]
IS sentencia_select_realizando_la_consulta;
El siguiente ejemplo muestra la utilización de un cursor parametrizado, el cursor

MICURSOR es abierto 2 veces, la primera con sueldo 2000 y la segunda con sueldo 3000
DECLARE
CURSOR MICURSOR (SUELDO NUMBER) IS
SELECT NOMBRE
FROM EMPLEADO

WHERE SALARIO > SUELDO;

BEGIN
OPEN MICURSOR (2000);
. . . . . . . .
. . . . . . . . (otras sentencias)
. . . . . . . .
OPEN MICURSOR (3000);
END;
/
En el siguiente ejemplo, se muestra la utilización del atributo de cursor SQL%NOTFOUND.

Se intenta modificar un registro en la tabla EMPLEADO y al no encontrarlo se inserta la
información en la tabla.
. . . . . . . .
UPDATE EMPLEADO
SET SALARIO = SALARIO*10.0
WHERE NOMBRE = 'JOSE';
IF SQL%NOTFOUND THEN
--Si no existe el empleado se inserta.
INSERT INTO EMPLEADO(CODIGO, NOMBRE,
SALARIO)
VALUES (4332, 'JOSÉ', 10000);
END IF;
. . . . . . . .
CURSORES SELECT FOR UPDATE
A menudo, el procesamiento que se lleva a cabo en un bucle de extracción modifica las filas
extraídas por el cursor. PL/SQL proporciona una sintaxis conveniente para estas situaciones. El
método consta de dos partes: la cláusula FOR UPDATE en la declaración del cursos, y la cláusula
WHERE CURRENT OF en una orden UPDATE o DELETE.
FOR UPDATE

La cláusula FOR UPDATE es parte de una orden SELECT. Es la última cláusula de la orden,
después de la cláusula ORDER BY (si existe). La sintaxis es:
SELECT … FROM … FOR UPDATE [OF referencia_columna ] [NOWAIT]
Donde referencia_columna es una columna, o lista de columnas, de la tabla sobre la que se realiza
la consulta. Por ejemplo,
DECLARE
CURSOR empleados IS
SELECT empno, nombre, salario
FROM empleado
WHERE numdept = 01
FOR UPDATE NOWAIT;
Al estar presente la cláusula FOR UPDATE en la sentencia SELECT , se ejecutan bloqueos

exclusivos sobre las filas del conjunto activo antes de que termine la ejecución de la orden OPEN
del cursor. Estos bloqueos evitan que otras sesiones cambien las filas del conjunto activo antes de
que la transacción se confirme. La orden NOWAIT hace que, si las filas están bloqueadas, con
anterioridad, por otra sesión, la orden OPEN termina inmediatamente devolviendo el error:
ORA-54: resource busy and acquire with NOWAIT specified.
WHERE CURRET OF
Si se declare el cursor con la cláusula FOR UPDATE, puede emplearse la cláusula WHERE
CURRENT OF en una orden UPDATE o DELETE. La sintaxis de esta cláusula es la siguiente:
WHERE CURRENT OF cursor

Donde cursor es el nombre de un cursor declarado con una cláusula FOR UPDATE. La
cláusula WHERE CURRENT OF hace referencia a la fila recién extraída por el cursor.

PRACTICA 3
1. Elaborar un programa que consulte todos los registros de la tabla VENDEDOR y calcule
las comisiones en base al 8% de las ventas, actualice las comisiones para todos los
vendedores
2. Elabore un programa que llene la tabla GRUPO_NUMERO con diez grupos de números
del 1 al 10, el resultado del programa debe ser como sigue:
GRUPO NUMERO
1 1
1 2
1 3
…. ….
1 10
2 1
2 2
… …

Capítulo 4
MAEJO DE ERRORES

MAEJO DE ERRORES E PL/SQL
Los errores en PL/SQL son llamados excepciones. Cuando ocurre un error, el procesamiento
salta a la sección de EXCEPCIONES donde deben estar las instrucciones a ejecutarse en caso de
detectarse el error, si no existe el manejo de la excepción el manejador suspenderá la ejecución y
arrojará un mensaje indicando cual fue la condición que no fue tratada apropiadamente. Cuando el
manejo de la excepción es completado, el procesamiento del bloque termina.
Existen dos tipos de excepciones:

Excepciones predefinidas
Excepciones definidas por el usuario
EXCEPCIOES PREDEFIIDAS
Las excepciones predefinidas son un grupo de errores posibles totalmente reconocidos por el
manejador. La tabla siguiente muestra algunas de las excepciones predefinidas más comunes:
Nombre de excepción Causa del error

TOO_MANY_ROWS La cláusula SELECT... INTO recuperó más de una fila
NO_DATA_FOUND La cláusula SELECT ... INTO no recupero ninguna fila
VALUE_ERROR Error en la conversión de un valor, u ocurrió un error de restricción
DUP_VAL_ON_INDEX Existe un valor duplicado en la columna de indexación
INVALID_CURSOR Especificación de cursor invalida
ZERO_DIVIDE Ocurrió una división por cero

MAEJADO EXCEPCIOES
Como se indicó anteriormente, cuando ocurre una excepción el control de la ejecución salta
hasta la sección de excepciones, donde estarán las instrucciones de manejo de la condición de error
apropiadas.
Sintaxis: . . . . . . . . . .
EXCEPTIO
WHE nombre_de_la_excepción [OR nombre_de_la_excepción ... ] THE
instrucciones_de_manejo_de_excepcion;
WHE OTHERS THE
secuencia_de_sentencias;
Donde:
EXCEPTION: indica el comienzo de la sección de manejo de excepciones.
WHEN: indica que a continuación se indicará el nombre de la excepción, además se
especificarán las acciones a tomar cuando ocurra esta condición.
WHEN OTHERS: es el conjunto de acciones que se ejecutaran en caso de ocurrir alguna
excepción no considerada en las declaraciones que la preceden
El siguiente ejemplo ilustra el manejo de la excepción predefinida TOO_MAY_ROWS y

O_DATA_FOUD
DECLARE
SUELDO NUMBER;
BEGIN
FROM EMPLEADO
WHERE CODIGO = 2000;
EXCEPTION
WHEN TOO_MANY_ROWS OR NO_DATA_FOUND THEN
RAISE_APPLICATION_ERROR(-20100,'No retorna filas o demasiadas filas
retornadas');
END;
/

EL PRAGMA EXCEPTIO_IIT
Este pragma permite asociar una excepción nominada con un error ORACLE determinado,
lo que permite interceptar de forma específica dicho error, en lugar de a través de un gestor
OTHERS. El pragma EXCEPTION_INIT se emplea de la forma siguiente:
PRAGMA EXCEPTION_INIT (nombre_excepción, número_error_Oracle);
Donde nombre_excepción es el nombre de una excepción declarada con anterioridad al

pragma, y número_error_Oracle es el código de error que se desea asociar con esta excepción
nominada. Este pragma debe incluirse en la sección declarativa.
DECLARE
E_EMPLEADOS EXCEPTION;
PRAGMA EXCEPTION_INIT(E_EMPLEADOS,-2292);
V_NUMDEP DEPARTAMENTO.NUMDEPT%TYPE = 1;
BEGIN
DELETE FROM DEPARTAMENTO
WHERE NUMDEPT = V_NUMDEPT;
COMMIT;
EXCEPTION
WHEN E_EMPLEADOS THEN
DBMS_OUTPUT.PUT_LINE(‘NO SE PUEDE ‘||
‘BORRAR DEPARTAMENTO||
TO_CHAR(V_NUMDEP));
END;

EXCEPCIOES DEFIIDAS POR EL USUARIO
Además de las excepciones predefinidas el usuario puede definir sus propias excepciones, y
obligar la ocurrencia de esa excepción, o de una predeterminada. Para definir una excepción propia
se debe declarar previamente la excepción de la siguiente manera:
Sintaxis: DECLARE
nombre_excepcion_propia EXCEPTIO;
Una vez definida la excepción puede activarse, esto es hacer que el control salte hasta la
sección de excepciones en el punto donde la excepción aparece, utilizando la cláusula RAISE.
Sintaxis: RAISE nombre_excepcion;
La cláusula RAISE se puede utilizar para activar (levantar) una excepción tanto de usuario
como predefinida, sencillamente colocando el nombre de la excepción que se desea activar a
continuación de la cláusula RAISE.
El siguiente ejemplo ilustra la forma de declarar y activar una excepción de usuario, en este
se define la excepción AUMENTO y se activa la misma en caso de que el sueldo sea menor a 3000.
Al activarse la excepción el control va al manejo de la excepción y actualiza la tabla EMPLEADO
colocando el salario en 5000.
DECLARE
SUELDO NUMBER;
AUMENTO EXCEPTION;
BEGIN
FROM EMPLEADO
IF SUELDO < 3000 THEN
RAISE AUMENTO;

EXCEPTION
WHEN AUMENTO THEN
UPDATE EMPLEADO
SET SALARIO = 5000
COMMIT;
END;
/
La cláusula RAISE también puede usarse sin el nombre de la excepción, con la condición
que se utilice dentro del manejador de excepciones. La finalidad de realizar esto, es para reactivar la
excepción en curso.
Cuando una excepción ocurre, esta inmediatamente es buscada en el manejador de

excepciones del bloque en curso, en caso de no encontrarse, se busca en el manejador de
excepciones del próximo bloque, y así sucesivamente hasta encontrarse. Si no es encontrado un
manejador para la excepción ocurrida, esta, es pasada al ambiente que invoco a PL/SQL.
En algunos casos se hace necesario tener el control sobre excepciones, que no han sido
predefinidas por ORACLE.
Sintaxis para definir excepciones

PRAGMA EXCEPTION_INIT(definición_del_usuario, código_de_la_excepción);
DECLARE
CODIGOERROR NUMBER;
MENSAJEERROR CHAR(70);
FORMATOFECHA EXCEPTION;
PRAGMA EXCEPTION_INIT(FORMATOFECHA, -1858);
BEGIN
UPDATE EMPLEADO
SET FECHACONTRATO = 'JAN-10-93' -- error en el formato de fecha

WHERE NUMEMP = 6659;

EXCEPTION
WHEN FORMATOFECHA THEN
ROLLBACK;
UPDATE EMP
SET FECHACONTRATO = '10-JAN-93'
WHERE NUMEMP = 6659;
COMMIT;
WHEN OTHERS THEN
CODIGOERROR := SQLCODE;
MENSAJEERROR := SQLERRM;
INSERT INTO TABLAERRORES
VALUES(CODIGOERROR, MENSAJEERROR);
RAISE_APPLICATION_ERROR(CODIGOERROR,MENSAJEERROR);
END;
/
La sentencia SQLCODE retorna el código de la excepción ocurrida y la sentencia

SQLERRM retorna el mensaje asociado a la excepción en curso. La instrucción
RAISE_APPLICATIO_ERROR permite enviar códigos y mensajes de error.

PRACTICA 4
1. Elaborar un programa que consulte los datos de un empleado, si el empleado no existe,
mostrar un mensaje que indique “El código de empleado X no Existe. Ingrese un código
valido”.
2. Elaborar un programa que ingrese un nuevo empleado, antes de insertar el registro debe
validad que el código de empleado no existe, si existe mostrar un error que indique, “El
código X ya esta asignado. Por favor utilice un nuevo código”.
3. Elaborar un programa para actualizar el salario de un empleado que el usuario introduzca,
antes de actualizar valide que el salario nuevo sea mayor al salario actual, de lo contrario
arroje un error que indica que no puede disminuir el salario del empleado.

Capítulo 5
PROGRAMAS ALMACEADOS E LA
BASE DE DATOS

IGEIERIA DEL LEGUAJE PL/SQL
IGEIERIA DE PL/SQL
Ingeniería de PL/SQL
Bloque de PL/SQL
Bloque de PL/SQL
DECLARE
Procedimiento DECLARE
Procedimiento Procedimiento
BEGIN Procedimiento Ejecutor
Procedimiento BEGIN de
SQL Procedimiento sentencias
Procedimiento SQL Procedimental
SQL Procedimiento
END; SQL
END;
Ejecutor de sentencias SQL en el RDBMS de ORACLE

IGEIERIA DE PL/SQL RESIDETE E EL RDBMS
ORACLE RDBMS
Programa anfitrión
Ingeniería de PL/SQL
Lenguaje anfitrión
Lenguaje anfitrión
Bloque de PL/SQL
Bloque de PL/SQL
DECLARE
DECLARE
Procedimiento
Procedimiento
Procedimiento Ejecutor
Procedimiento
BEGIN de
BEGIN
Procedimiento sentencias
Procedimiento
SQL Procedimental
SQL
Procedimiento
Procedimiento
SQL
SQL
END;
END;
Lenguaje anfitrión
Lenguaje anfitrión
Lenguaje anfitrión
Ejecutor de sentencias SQL

PROCEDIMIETOS Y FUCIOES ALMACEADAS
Un procedimiento almacenado o una función almacenada es un conjunto de instrucciones

de SQL y PL/SQL que se crean con la finalidad de realizar una tarea específica. Se almacenan en la
base de datos como un objeto y pueden ser invocados desde allí por cualquier programa que tenga
permisología de acceso sobre estos.
DIFERECIA ETRE PROCEDIMIETO Y FUCIO
Procedimiento Función
Solo puede retornar valores mediante el uso Retorna siempre un valor en el nombre de la
de parámetros función
Se invocan solo con el nombre y operan Deben aparecer en algún lugar donde se
como si el código estuviera en el lugar donde se pueda almacenar el valor que retorna
llaman
CARACTERISTICAS DE PROCEDIMIETOS Y FUCIOES
Almacenamiento en forma compilada en la Base de Datos

Pueden llamar a otros procedimientos/funciones o a sí mismo
Pueden ser llamados desde todos los clientes del ambiente

USOS DE PROCEDIMIETOS Y FUCIOES
• Permiten definir las reglas o funciones del negocio, por ejemplo, Crear una orden,
Eliminar un cliente.
• Encapsula una transacción, por ejemplo, recolecta y procesa información desde
nodos remotos
• Permiten crear programas con código genérico (compartido o común), por ejemplo,
Calculo del impuesto sobre la renta
• Los procedimientos y funciones son compilados en la Base de Datos al momento de
su creación. La forma y el texto compilado de un procedimiento o función son
almacenados en el diccionario de datos.
CREACIO Y COMPILACIO DE PROCEDIMIETOS Y FUCIOES
Para crear un procedimiento o función almacenado, se utiliza la instrucción CREATE

PROCEDURE para que el nuevo código sea almacenarlo en la base de datos. Debido a que los
procedimientos y funciones son tratados como objetos de la base de datos, se puede utilizar la
cláusula REPLACE PROCEDURE para cambiar un procedimiento o función ya existente.
Sintaxis: CREATE OR REPLACE PROCEDURE esquema.ombre_Procedimiento

[( Argumento [IN] [OUT] [IN OUT] Tipo Dato )] IS
Cuerpo de Programa PL/SQL
AS
/

Los argumentos pueden operar en tres modos, dependiendo del modo, el argumento se tratará
como un parámetro por valor o por referencia. La siguiente tabla muestra el tipo de argumento
posible para los parámetros en PL/SQL:
Modo Descripción
IN Parámetro por valor, no modifica los valores que recibe como parámetro. Es el modo
por defecto
OUT Parámetro de solo salida, no puede contener un valor de entrada al momento de llamar
al procedimiento o función
IN OUT Parámetro por referencia, puede contener valores de entrada al procedimiento y
cualquier modificación del parámetro dentro del procedimiento o función se reflejara en
el correspondiente parámetro externo
El siguiente ejemplo ilustra la forma de crear un procedimiento. Crear un procedimiento que

acepte un código de empleado como entrada y elimine el empleado de la tabla EMPLEADO.
CREATE PROCEDURE borra_empleado (

empid NUMBER) IS
BEGIN
DELETE
FROM empleado
WHERE empno = empid;
END;
/

El siguiente ejemplo ilustra la forma de crear una función. Crear una función que acepte
como entrada un número de cuenta contable y retorne el saldo del balance de la cuenta
CREATE FUNCTION obtener_saldo_bal (

cuenta NUMBER)
RETURN NUMBER
IS
saldo_cuenta NUMBER := 0;
BEGIN
SELECT balance
INTO saldo_cuenta
FROM cuentas
WHERE ncuenta = cuenta;
RETURN (saldo_cuenta);
END;
/
Nótese que en el ejemplo anterior existe la cláusula RETURN, que no aparece en el

procedimiento anterior, esta cláusula es la que permite retornar el valor de la función.
Instrucciones Válidas en Procedimientos y Funciones
Instrucciones SQL, DML o PL/SQL

Llamadas a procedimientos y funciones almacenadas en la Base de Datos
(incluyendo posibles llamadas recursivas)
Llamadas a otros procedimientos y funciones en una Base de Datos remota.

Instrucciones o Validas en Procedimientos y Funciones
Instrucciones DDL
Instrucciones dinámicas de SQL
Las instrucciones COMMIT, ROLLBACK y SAVEPOINT en procedimientos
llamados remotamente
EJECUCIO DE PROCEDIMIETOS Y FUCIOES ALMACEADOS
Dependiendo del lugar desde el cual se realiza la llamada al procedimiento, existen diferentes
formas de ejecutar un procedimiento almacenado. A continuación se listan las formas de invocar un
procedimiento almacenado:
Desde un bloque PL/SQL sin el esquema de usuario propietario

nombre_procedimiento(parámetros);
Desde otro esquema de usuario: usuario.nombre_procedimiento(parámetros);
Procedimiento almacenado en una base de datos remota:

usuario.nombre_procedimiento@enlace_remoto(parámetros);
Desde alguna herramienta Oracle: EXECUTE nombre_procedimiento(parámetros);

En bloques anónimos de PL/SQL, cuando el EXECUTE no esta disponible
BEGIN
END;
Desde una aplicación precompilada:
EXEC SQL nombre_procedimiento(parámetros);

Desde OCI
CALL OSQL3 (cursor, /*interpretador*/
"BEGIN
END;"
CALL OBNDRV (..);
CALL OEXEC (..);

COMPILACIO DE ERRORES E PL/SQL
ERRORES DE PL/SQL
La compilación de PL/SQL es ejecutada por la ingeniería de PL/SQL en ORACLE. Los

errores de sintaxis en la compilación se almacenan en el diccionario de datos, esto se debe a que
ORACLE puede recompilar un procedimiento automáticamente, y en consecuencia debe tener
algún lugar para colocar los posibles errores.
Para visualizar los errores generados por la compilación de un procedimiento o función

almacenada, se hace uso del comando SHOW ERRORS o bien se pueden consultar las vistas
USER_ERRORS, ALL_ERRORS o DBA_ERRORS
Para ilustrar el manejo de errores en PL/SQL trate de crear un procedimiento llamado TEST1
usando el código siguiente:
SQL> CREATE PROCEDURE test1 IS BEGIN test2; END;
A continuación muestre los errores de compilación, para ello use la instrucción SHOW
ERRORS
SQL> SHOW ERRORS
El resultado debe ser similar al siguiente:
LINE/COL ERROR
------------------------------- -----------------------------------------------------------------
1/17 PLS-00103: Encountered the symbol "BEGIN" when expecting one of
the following:
( ; is with as compress compiled wrapped

The symbol "is" was substituted for "BEGIN" to continue.

Para recompilar un procedimiento o función, se debe borrar el objeto y luego recrearlo,
usando las sentencias DROP y CREATE, o simplemente reemplazar el código existente mediante
el uso de la cláusula CREATE OR REPLACE. También puede recompilarse un procedimiento
mediante la instrucción ALTER PROCEDURE, suponiendo, claro está, que el procedimiento
existe.
ERRORES DEFIIDOS POR EL USUARIO
El usuario puede definir errores y puede hacer que al activarse el error se retorne el número y
el mensaje del error, los cuales previamente deben haber sido definidos por el usuario, para esto:
• Se debe definir el grupo de errores de aplicación
• Se sugiere estandarizar los números y mensajes de error a través de la creación de una tabla
en la Base de Datos, para mantener los errores y mensajes, y ejecutar un SELECT … INTO antes
de llamar al procedimiento
Sintaxis: RAISE_APPLICATIO_ERROR (error_number, 'Texto del mensaje')
• El rango numérico entre -20000 a -20999, esta reservado en ORACLE para los errores
definidos por el usuario
• ORACLE no verifica que los errores definidos por el usuario sean únicos
Para ilustrar lo dicho anteriormente, consideremos el siguiente ejemplo.
Crear un procedimiento que active un mensaje de error definido por el usuario si la condición
que se indica no es encontrada.

CREATE PROCEDURE analiza_num_emp (empid NUMBER)

AS
BEGIN
IF empid <= 0 THEN
raise_application_error(-20100, 'Numero de empleado debe ser > 0');
ELSE
DELETE
FROM empleado
END IF;
END;
/
ELIMIACIO DE PROCEDIMIETOS Y FUCIOES
Al igual que las tablas, los procedimientos y funciones también pueden ser eliminados. La
sintaxis para eliminar un procedimiento es:
DROP PROCEDURE nombre_procedimiento;

La sintaxis para eliminar una función es:
DROP FUNCTION nombre_funcion;

PAQUETES
Un paquete es un objeto de la base de datos que agrupa construcciones de programas

relacionados en una sola unidad lógica. Un paquete contiene uno o más objetos almacenados en la
base de datos, los cuales están disponibles para el usuario en cualquier instante. El cuerpo del
paquete puede ser reemplazado sin afectar las especificaciones. Los paquetes pueden contener
objetos, tales como:
• Procedimientos
• Funciones
• Definiciones de Cursores
• Definiciones de Variables y Constantes
• Definiciones de Excepciones
ESTADO PERSISTETE
Los paquetes retienen el último estado válido de los objetos que contienen, mientras esté
activa la sesión del usuario que invoca al paquete o un objeto contenido en él, esto significa que:
Las variables retienen los valores asignados y los cursores retienen las áreas de
contexto y posicionamiento de datos
El estado persistirá a través de las llamadas que realice el usuario dentro de una
sesión
Cada sesión tiene su propio control de versiones del estado del paquete

ESTRUCTURA DE U PAQUETE
• Especificaciones del Paquete : Es el área declarativa de la construcción del paquete, en la

cual se indican los nombres y parámetros de los procedimientos y funciones públicas
disponibles, así como los nombres de las variables y cursores públicos
• Cuerpo del Paquete : Es el área de texto donde se coloca el código de los procedimientos y
funciones que el paquete contiene
Dentro del Cuerpo de un paquete se pueden especificar otros procedimientos y funciones

privadas, solo disponibles para las construcciones que están dentro del mismo paquete
• Definición del Código de todas las construcciones que integran el paquete
DEPEDECIAS ETRE PAQUETES
Package PK
Especificaciones
Procedure A
variable C
variable D PK.A;
procedure A x := PK.C;
procedure B
i := D;
Cuerpo
j := C;

• Si un procedimiento A llama a otro procedimiento B, y ninguno de los dos pertenece a un

paquete, entonces cualquier cambio que afecte al código del procedimiento B provocará que el
procedimiento A se marque automáticamente para ser recompilado
• Si un procedimiento individual A, llama a un procedimiento B que se encuentra dentro de
un paquete, entonces ningún cambio en el código del procedimiento B afectara al procedimiento A
• Si un procedimiento A de un paquete, llama a un Procedimiento B de otro paquete, ningún
cambio que tenga lugar en el código de cualquiera de los procedimientos generará dependencia de
recompilación en el otro
ESPECIFICACIOES PARA LA CREACIO DE PAQUETES
Se deben especificar por separado, tanto la cabecera como el cuerpo del paquete. Para la
definición de la cabecera la sintaxis es la siguiente:
Sintaxis: CREATE OR REPLACE PACKAGE esquema.Nombre_del_Paquete [IS] [AS]

Especificaciones del Paquete;
/
Para la definición del cuerpo del paquete, la sintaxis es la siguiente:
CREATE OR REPLACE PACKAGE BODY esquema.Nombre_del_Paquete [IS] [AS]

Cuerpo de las Construcciones del Paquete;
Variables y Constantes;
/

A continuación se muestra un ejemplo que ilustra la forma de crear la cabecera de un

paquete.
CREATE PACKAGE paq_empleado AS

/* declaraciones publicas */
PROCEDURE insertar_empleado( Empno NUMBER,
Ename VARCHAR2,
mgr NUMBER,
sal NUMBER,
comm NUMBER,
deptno NUMBER);
PROCEDURE borrar_empleado ( empid NUMBER );
/* variables globales */
valid VARCHAR2(1);
END paq_empleado;
/
El siguiente ejemplo ilustra la forma de crear el cuerpo del paquete definido anteriormente:
CREATE PACKAGE BODY paq_empleado AS

/* Procedimiento de registro de empleados */
PROCEDURE insertar_empleado (
empno NUMBER, ename VARCHAR2,
mgr NUMBER, sal NUMBER,
comm NUMBER, deptno NUMBER) IS
BEGIN
Valid := chequea_num (empno);
/* si el empleado no existe se podrá incluir */
IF valid = 'T' THEN
INSERT INTO empleado (empno, ename, mgr, sal, comm, deptno)
VALUES (empno, ename, mgr, sal, comm, deptno);
END IF;
END;
/* Procedimiento de despido de empleado */
PROCEDURE borrar_empleado (empid NUMBER) IS
BEGIN
DELETE FROM empleado
END;
/* Función para chequear que el número de empleado es válido */

FUNCTION chequea_num (empno NUMBER) RETURN VARCHAR2

IS
answer VARCHAR2;
BEGIN
answer := 'T';
IF empno < 0 THEN
answer := 'F';
END IF;
RETURN (answer);
END;
END paq_empleado; /* fin del cuerpo del paquete */
/
Como se dijo anteriormente, la compilación de un paquete se realiza al momento de crearlo,

sin embargo se puede realizar, también de manera manual haciendo uso de la cláusula ALTER:
Sintaxis: ALTER PACKAGE [esquema.]Nombre_del_Paquete COMPILE [BODY]
[PACKAGE]
Para eliminar un paquete, se utiliza la cláusula DROP, recuerde que un paquete es también
un objeto de la base de datos:
Sintaxis: DROP PACKAGE [esquema.]Nombre_del_Paquete;

PRACTICA 5
1. Crear un procedimiento con el nombre valida_no_existe_cliente, donde el empleado debe
recibir el código del cliente y consultar si existe, de ser así, retornar un error con el mensaje
“El código del cliente ya existe”
2. Crear una función llamada busca_direccion_cliente, que reciba el código del cliente y
retorne la dirección del mismo.
3. Crear una función llamada busca_descripcion_producto que reciba el código del producto y
retorne el nombre del mismo.
4. Crear un procedimiento para insertar un nuevo cliente, debe recibir los valores a insertar, y
antes de ejecutar el insert debe validar que el cliente no exista, para esto utilice el
procedimiento creado en el ejercicio 1.
5. Crear un procedimiento llamado maneja_error que le permita controlar los errores que
ocurren en el sistema, el procedimiento debe recibir el código del error, el mensaje y el
nombre del programa que lo origina, debe insertar estos valores en la tabla errores_sistema
junto con la fecha y hora en la que ocurrió el error, luego propagar el error.
6. Modifique los programas de los ejercicios 1 y 4 para que cuando ocurre un error cualquiera
que este sea, ejecuten el procedimiento 5.

Capítulo 6
TRIGGERS DE BASE DE DATOS

TRIGGERS o DISPARADORES DE EVETOS
Los triggers son eventos que se activan automáticamente cuando en la base de datos ocurre el
evento al cual están asociados. Un trigger se asocia a un objeto que contiene datos modificables en
la base de datos, esto es una tabla o una vista, y se dispara cuando ocurre un cambio en el contenido
de ese objeto.
El uso de triggers confiere amplios beneficios al programador, pues le permiten realizar

múltiples labores de verificación de integridad, auditoria o manejo de posibles errores durante la
manipulación de datos almacenados en la base de datos.
Los triggers ayudan a lograr la integridad en aquellas bases de datos que requieren tablas
desnormalizadas, es decir copias de tablas grandes a tablas más pequeñas, técnica que se utiliza con
la finalidad de aumentar la velocidad de ejecución.
Los triggers permiten la creación de tablas de auditoria, con el fin de saber que registro,
usuario, columna, fecha, hora y datos fueron modificados durante una transacción. De esta manera
se podrá preservar tanto el dato antiguo como el dato nuevo en aquellos valores que son críticos.
Los triggers también son utilizados ampliamente en bases de datos distribuidas, para llevar
controles sobre la data, así como también llevar un control de las reglas del negocio.
Según el tipo de operación, asociados internamente a la base de datos existen tres tipos de
triggers:
Triggers tipo Insert, los cuales se disparan al insertar filas

Triggers tipo Update, los cuales se disparan al actualizar filas
Triggers tipo Delete, los cuales se disparan al borrar filas

De acuerdo al momento en que se disparan en relación con el evento al cual están asociados,
los triggers pueden ser:
Before, se disparan antes de que la acción se ejecute

After, se disparan después que la acción se ha ejecutado
La siguiente tabla muestra las posibles combinaciones de activación de los triggers según el
tipo de trigger de que se trate y al instante de activación:
Instante de activación
Acción Before After
Insert Before Insert After Insert
Update Before Update After Update
Delete Before Delete After Delete
De acuerdo a la acción que genera su activación, los triggers pueden ser:
Por transacción, se disparan cuando la transacción se ha completado

Por fila, se disparan inmediatamente después de procesar una fila de datos
Un evento en la base de datos dispara uno o varios de los triggers definidos en la tabla
anterior, y cada una de estas combinaciones puede estar asociada a una transacción o a una fila, de
manera excluyente. Esto significa que existen un total de doce triggers asociados a las tablas o
vistas de la base de datos.

RESTRICCIOES DE LOS TRIGGERS
Debido a que los triggers de base de datos pueden ser manejados por el usuario, pero el
control de las operaciones internas y de la modificación de los datos es responsabilidad única del
manejador, los triggers tienen ciertas restricciones, a continuación se listan algunas:
• No se pueden usar cláusulas de control de operación. Esto significa que desde un trigger
de base de datos no se puede realizar COMMIT, ni ROLLBACK ni tampoco SAVEPOINT.
Por lo tanto las transacciones deben ser terminadas por quien disparó un trigger y no por el
trigger en sí
• Los triggers de base de datos no pueden crearse sobre una instrucción SELECT, ni pueden
asociarse a instrucciones DDL, tales como son CREATE, ALTER o DROP
• Los triggers de base de datos no pueden asociarse a las tablas del Diccionario de Datos
• Los triggers de base de datos solo se activan cuando ocurre el evento al cual están
asociados, esto quiere decir que su activación no puede ser forzada por el usuario

DEFIICIO Y CREACIO DE TRIGGERS
Un trigger de Base de Datos definido por el usuario está formado por un bloque de PL/SQL
asociado a una tabla específica. Se dispara de manera implícita cuando se ejecuta la instrucción
asociada a la tabla.
Applicación Base de Datos

UPDATE
UPDATE t triger
SET...;
INSERT tabla T
INSERT
INTO t....;
triger
DELETE
FROM t...;
DELETE
triger
A continuación se muestra un ejemplo de la secuencia de ejecución de un trigger de base de

datos
Antes del comando trigger
EMPLEADO DEPARTAMENTO
Antes del trigger de fila
100 10
Despues del trigger de fila
50
120 Antes del trigger de fila
240 10
260 40
280 20
Antes del trigger de fila
300 30
301 10
Despues del comando trigger

CREACIO DE U TRIGGER DE BASE DE DATOS
Un trigger de base de datos puede ser creado de manera similar a la creación de cualquier
otro objeto de la base de datos, para ello se hace uso de la cláusula CREATE TRIGGER.
Sintaxis: CREATE TRIGGER [esquema.]nombre_de _trigger [BEFORE | AFTER]

[DELETE | INSERT | UPDATE] [OR ] [OF] (columnas) ON [esquema.]tabla
REFERENCING [OLD | NEW] AS viejo | nuevo [FOR EACH ROW WHEN condición
bloque_pl/sql ];
/
Donde:
esquema: indica el entorno de usuario
nombre_de_trigger: indica el nombre con el cual se va a crear el trigger
columnas: indica las columnas de la tabla a las cuales va a estar asociado el trigger
tabla: indica el nombre de la tabla a la cual va a estar asociado el trigger
condición: restringe la activación del trigger a las filas que cumplen esta condición
bloque_pl/sql: contiene el bloque de instrucciones que conforman el cuerpo del
trigger
Los triggers de Base de Datos son almacenados separados de otros objetos, de manera que
un trigger de Base de Datos y una tabla pueden tener el mismo nombre, sin embargo es
recomendable la utilización de nombres únicos.
SECUECIA DE EJECUCIO DE U TRIGGER DE BASE DE DATOS
1. La instrucción INSERT, UPDATE o DELETE pasa al manejador ORACLE

2. El manejador chequea y ejecuta el trigger de comando BEFORE

3. Por cada fila afectada por el comando SQL :
4. Se ejecuta el trigger de fila BEFORE
5. Se modifica la fila y se chequean las restricciones de integridad
6. Se ejecuta el trigger de fila AFTER
7. Se complementa la validación de las restricciones de integridad chequeando las
posibles violaciones
8. Se ejecuta el trigger de comando AFTER
9. El control regresa a la aplicación. Si un trigger de comando de Base de Datos falla,
los cambios hechos por el trigger de comando se reversan.
Se pueden tener procedimientos almacenados referenciados en el texto del trigger, siempre y

cuando estos no hagan COMMIT ni violen las restricciones expresas para los triggers.
Para referenciar los valores nuevos o viejos de una columna en expresiones de trigger de fila
se utilizan los prefijos:
:OLD contiene el valor de la columna antes de efectuar el cambio

:NEW contiene el valor que afectará a la columna después de efectuar el cambio
Ejemplo
IF :NEW.salario < :OLD.salario ......
La expresión :NEW.salario contiene el nuevo valor de la columna salario antes de efectuarse

el cambio y la expresión :OLD.salario contiene el valor antiguo de la columna salario.
Al tratar de referenciar los valores :NEW y :OLD se deben tener en cuenta las siguientes
consideraciones:

• Los valores NEW y OLD están disponibles únicamente en los triggers de fila
• Los valores NEW y OLD están disponibles en el UPDATE
• El valor OLD en un INSERT es nulo
• El trigger de fila BEFORE puede asignar valores a :NEW si no es asignado el valor por la
cláusula UPDATE SET o lista INSERT VALUES
• Se puede usar la cláusula REFERENCING para remplazar :NEW y :OLD con otros
nombres relacionados
• Los dos puntos no son necesarios al referenciar en la cláusula WHEN
Si el trigger de Base de Datos se puede disparar sobre más de un tipo de operaciones DML,
se puede usar el predicado condicional para determinar la operación del DML que ocasiona el
disparo del trigger de Base de Datos.
Predicados Condicionales
• IF INSERT ...
• IF UPDATING ....
• IF DELETING .....
Se puede tener el mismo trigger en la Base de Datos para un DELETE, INSERT y UPDATE,
y usar el predicado condicional para determinar qué ocasionó que se disparase el trigger de Base de
Datos. Esto resulta más fácil que mantener tres triggers por separados. Esto siempre y cuando los
procedimientos no contengan cláusulas de control de operaciones, tales como COMMIT.
El siguiente ejemplo muestra la forma de crear un trigger, haciendo uso de los valores NEW,
OLD y de los predicados condicionales.

CREATE TRIGGER salario_total

AFTER DELETE OR INSERT OR UPDATE OF departamento, salario
ON empleado
FOR EACH ROW
BEGIN
/* se asume departamento,salario como no nulos */
IF DELETING OR
(UPDATING AND
:OLD.departamento <> :NEW.departamento) THEN
UPDATE departamento_renta /* separa las tablas que referencian a

departamento */
SET total_salario =total_salario - :OLD.salario
WHERE departamento = :OLD.departamento;
END IF;
IF INSERTING OR
UPDATING AND
(:OLD.departamento = :NEW.departamento) AND
(:OLD.salario <> :NEW.salario) THEN
UPDATE departamento_compras
SET total_salario = total_salario + (:NEW.salario -
:OLD.salario)
WHERE departamento = :OLD.departamento;
END IF;
END;
/

En el caso anterior la opción AFTER DELETE OR INSERT OR UPDATE, indica que el

trigger se disparará después de culminar la acción de inserción o actualización. La opción FOR
EACH ROW indica que el trigger se activará una vez por cada fila de datos que sea procesada.
Antes de la ejecución de cualquier instrucción de actualización sobre la columna SALARIOS

de la tabla NOMINA o la inserción de un nuevo registro, provocará que el trigger definido
anteriormente se active, ejecutando las instrucciones del bloque PL/SQL que conforman el cuerpo
del trigger.
ELIMIADO U TRIGGER DE BASE DE DATOS
Debido a que un trigger es también un objeto de Base de Datos, para borrar un trigger se
utiliza la cláusula DROP.
Sintaxis: DROP TRIGGER esquema.nombre_trigger;
La siguiente instrucción permite la eliminación del trigger creado anteriormente:
DROP TRIGGER tr_upd_salario;
Para la creación y manipulación de triggers se deben tener en cuenta las siguientes

consideraciones:
Los triggers de Base de Datos no pueden ser alterados, para modificar un trigger
este debe ser eliminado y recreado
La eliminación de un trigger no afecta los privilegios de seguridad existente

asociados a una tabla
Si una tabla es eliminada, los triggers definidos sobre ella también serán eliminados

PRACTICA 6
1. Elabore un trigger sobre la tabla empleado, para controlar que cuando se ejecute una
actualización de los salarios, el salario nuevo sea siempre mayor al salario actual, pero no
debe ser mayor a 1.000.000 de lo contrario arroja mensajes de error por cada caso. Y
controlar estos a través del procedimiento mensaje_error.
2. Elabore un trigger sobre la tabla empleado para controlar que cuando si inserte un nuevo
empleado, el nombre se inserte en mayúscula, y si la fecha de ingreso no es colocada
entonces se asigne la fecha actual. Adicionalmente si el nuevo empleado pertenece al
departamento de investigación u operaciones insertar los registros en las tablas
emp_investigacion y emp_operaciones.
3. Elabore un trigger sobre la tabla empleado que le permita guardar en la tabla
control_registros si ocurre un evento de actualización o eliminación. En dicha tabla debe
guardarse la fecha en que ocurrió el evento, el usuario que lo ejecuto, y si se trata de una
actualización el valor viejo del campo modificado y el valor nuevo, además del campo
clave del registro que se actualizo, es decir, el código del empleado, si lo que ocurre es una
eliminación guardar el campo clave del registro eliminado.

Manual PLSQL

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Manual PLSQL

Uploaded by

Copyright:

Available Formats

GEDICA TRAINING & CONSULTING C.A.

ITRODUCCIO A PL/SQL ...................................................................................................4

Lenguaje Procedimental PL/SQL/ 1

Lenguaje Procedimental PL/SQL/ 2

Lenguaje Procedimental PL/SQL/ 3

En este taller los participantes aprenderán a escribir programas en PL\SQL, a almacenarlos en

OBJETIVOS DEL CURSO:

• Crear, ejecutar y mantener procedimientos, funciones, paquetes, triggers de la base de

Lenguaje Procedimental PL/SQL/ 4

• Utilización de laminas audiovisuales las cuales serán transmitidas durante el curso.

RECURSOS AUDIOVISUALES Y EVALUACIÓ:

• diapositivas elaboradas en power point

• Introducción a SQL y SQL Avanzado

Lenguaje Procedimental PL/SQL/ 5

Lenguaje Procedimental PL/SQL/ 6

El SQL es un lenguaje muy poderoso, permite visualizar, modificar, o borrar múltiples

PL/SQL es clasificado como un lenguaje procedimental, debido al uso de bucles,

Lenguaje Procedimental PL/SQL/ 7

ESTRUCTURA DE LOS BLOQUES DE PL/SQL

El lenguaje de programación PL/SQL es un lenguaje estructurado por bloques. En este, los

Sección Descripción Inclusión

La estructura básica de un bloque de PL/SQL es la siguiente:

Lenguaje Procedimental PL/SQL/ 8

PL/SQL procedure successfully completed

En PL/SQL un error es llamado una excepción.

[DECLARE] PROCEDURE nombre IS FUNCTION nombre IS

Lenguaje Procedimental PL/SQL/ 9

Puede almacenar subprogramas en la base de datos o declararlos como parte de una

Tipo de Programa Descripción Disponibilidad

Lenguaje Procedimental PL/SQL/ 10

Procedimiento o Bloque con nombre de PL/SQL Componentes Oracle

SITAXIS DE BLOQUES PL/SQL

Lenguaje Procedimental PL/SQL/ 11

Símbolo Significado Símbolo Significado

Lenguaje Procedimental PL/SQL/ 12

Un literal es un valor explícito ya sea numérico, string, caracter o booleano. Es un valor no

Lenguaje Procedimental PL/SQL/ 13

El siguiente ejemplo muestra el uso de los comentarios:

BEGIN -- Este es el inicio del bloque

v_salario := &p_salario_mensual * 12;

END; -- Este es el final de la transacción

Lenguaje Procedimental PL/SQL/ 14

TIPOS DE DATOS E PL/SQL

La siguiente tabla muestra un resumen de los tipos de datos base de PL/SQL:

Tipo de Dato Descripción

Lenguaje Procedimental PL/SQL/ 15

• Almacenamiento temporal de datos

TIPOS DE VARIABLE E PL/SQL

En PL/SQL se pueden declarar distintos tipos de variables:

Lenguaje Procedimental PL/SQL/ 16

Son variables de tipo puntero referencian posiciones de almacenamiento de otros objetos.

Variables llamadas localizadores. Indican la localización de objetos complejos cuyo

• CLOB : (Character Large Object) se utilizan para almacenar grandes cantidades

• BLOB: (Binary Large Object) se utiliza para almacenar en la base de datos

• NCLOB: (National Language Character Large Object) se utiliza para almacenar

Además existen variables que no son de PL/SQL:

Lenguaje Procedimental PL/SQL/ 17

VARIABLE valor_de_retorno NUMBER

SQL> VARIABLE tot_sueldo NUMBER

Variables Host: son llamadas también variables de sustitución, se definen

Lenguaje Procedimental PL/SQL/ 18

VARIABLE salario_mensual NUMBER

SET SERVER OUTPUT ON