Manual Plsql

09/03/2005

GEDICA TRAINING & CONSULTING C.A.

I�TRODUCCIÓ� A PL/SQL

G E D I C A T R A I N I N G & C O N S U L T I N G C . A .

Lenguaje Procedimental PL/SQL/ 1

TABLA DE CONTENIDO

I�TRODUCCIO� 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

I�TRODUCCIO� A PL/SQL ....................................................................................................6

I�TRODUCCIÓ� 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

ASIG�A�DO VALORES A VARIABLES .................................................................................... 26

BLOQUES I�TER�OS Y ALCA�CE DE VARIABLES ............................................................ 28 Alcance ............................................................................................................................................................ 29

OPERADORES ................................................................................................................................. 29 OPERADORES NUMERICOS ....................................................................................................................... 29 OPERADORES LOGICOS O BOOLEANOS ................................................................................................ 29 PRACTICA 1................................................................................................................................................... 31

Capítulo 2..................................................................................................................................32

FU�CIO�ES E� PL/SQL......................................................................................................32

FU�CIO�ES E� PL/SQL................................................................................................................ 33

I�TERACTUA�DO 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

CONTROL DE TRANSACCIONES............................................................................................................... 37 PRACTICA 2................................................................................................................................................... 40

Capítulo 3..................................................................................................................................41

ESTRUCTURAS DE CO�TROL ............................................................................................41

ESTRUCTURAS DE CO�TROL 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

MA�EJO DE ERRORES ........................................................................................................63

MA�EJO 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 ALMACE�ADOS E� LA BASE DE DATOS...............................................71

I�GE�IERIA DEL LE�GUAJE PL/SQL ..................................................................................... 72 INGENIERIA DE PL/SQL.............................................................................................................................. 72

I�GE�IERIA DE PL/SQL RESIDE�TE 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 EVE�TOS.......................................................................... 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

I�TRODUCCIO� 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

CO�TE�IDO 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

I�TRODUCCIO� A PL/SQL

I�TRODUCCIÓ� 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 excepciones definidas por el usuario que son referenciadas en la sección Ejecutable y en la misma sección Declarativa

Opcional

Ejecutable Contiene instrucciones SQL para manipular la data en la base de datos e instrucciones PL/SQL que permiten manipular la data en el bloque

Obligatoria

Manejo de Excepciones Indica las acciones a tomar cuando ocurra una condición anormal o algún error durante la ejecución de las instrucciones de la sección Ejecutable

Opcional

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]

--- Instrucciones

[EXCEPTION]

--- Instrucciones

PROCEDURE nombre IS

--- Instrucciones

[EXCEPTION]

--- Instrucciones

FUNCTION nombre IS

RETURN tipo_dato

BEGIN ----

Instrucciones

RETURN valor,

[EXCEPTION] ---

Instrucciones

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

que esta inmerso dentro de una

aplicación o que es interactivo

Todos los entornos de

PL/SQL

Stored Procedure o

Función

Bloque PL/SQL con nombre

almacenado en el Oracle Server, puede

aceptar parámetros y ser llamado varias

veces usando el nombre

Oracle Server

Procedimiento o

Función de Aplicación

Bloque con nombre de PL/SQL

almacenado en una aplicación Developer

o una librería compartida, puede aceptar

parámetros y ser invocado repetidas

veces usando el nombre

Componentes Oracle

Developer, por ejemplo Forms

Paquete Modulo con nombre de PL/SQL

que agrupa objetos relacionados como

procedimientos, funciones e

identificadores

Componentes Oracle

Server y Oracle Developer, por

ejemplo Forms

Trigger de base de

Bloque de PL/SQL que esta

asociado a una tabla de la base de datos y

se ejecuta automáticamente cuando

ocurre el evento para el que fue definido

Oracle Server

Trigger de

aplicación

Bloque de PL/SQL que esta

asociado con un evento en la aplicación y

se ejecuta automáticamente cuando el

evento ocurre durante la ejecución

Componentes de Oracle

Developer, por ejemplo Forms

SI�TAXIS 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

IDE�TIFICADORES

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)

COME�TARIOS

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.

REFERE�CIAS

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

Estas variables no están cubiertas por este curso.

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;

:salario_mensual := salario_auxiliar / 12;

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;

salario_auxiliar := salario_auxiliar / 12;

dbms_output.put_line (‘El salario mensual es ‘

| | TO_CHAR(salario_auxiliar));

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 [CO�STA�T] 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] I�DEX 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

FOR i IN 1 .. filas LOOP

INSERT INTO EMPLEADO (EMPNO, NOMBRE, ...)

VALUES (empno_tab(i), ename_tab(i), ...);

END LOOP;

ASIG�A�DO 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

SELECT SALARIO I�TO 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 I�TER�OS Y ALCA�CE 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; BEGIN

Alcance

… Y := Y + X; …

Alcance

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 BOOLEA�OS

Operador Significado

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 A�D

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

FU�CIO�ES 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

I�TERACTUA�DO 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 I�STRUCCIO�ES 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

� PL/SQL no soporta instrucciones de control de lenguaje, tales como GRANT y REVOKE

RECUPERA�DO 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

I�TO {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);

SELECT deptno, loc

INTO v_deptno, v_loc

FROM dept

WHERE dname = ‘VENTAS’;

I�SERTA�DO DATOS – La cláusula I�SERT

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';

INSERT INTO EMPLEADO (NOMBRE, CARGO,

SALARIO)

VALUES (EMPLEADO, 'SECRETARIA', SUELDO);

ACTUALIZA�DO DATOS – La cláusula UPDATE

En el siguiente ejemplo se muestra un caso de una posible inserción desde un bloque

PL/SQL:

DECLARE

UPDATE EMPLEADO

SET SALARIO = SALARIO * 1.5

WHERE EMPNO = 500;

BORRA�DO 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';

DELETE FROM EMPLEADO

WHERE NOMBRE = EMPLEADO

AND CODIGO = 1050;

COMMIT;

CO�TROL DE TRA�SACCIO�ES

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

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;

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 CO�TROL

ESTRUCTURAS DE CO�TROL 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.

CO�DICIO�ALES

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 <=

30.000

DECLARE

SUELDO NUMBER;

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)

UPDATE EMPLEADO

SET SALARIO = SUELDO + 4000;

END IF;

COMMIT;

�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.

ITERACIO�ES

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

sentencia o grupo de sentencias

condición de salida del bucle

E�D 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;

INSERT INTO TEMPORAL (NUMERO1, TEXTO)

VALUES (CONTADOR, 'HOLA');

CONTADOR := CONTADOR + 1;

EXIT WHEN CONTADOR = 10;

END LOOP;

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

E�D 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:

FOR I IN 1..10 LOOP

VALUES (I, 'HOLA');

END LOOP;

BUCLE CO�DICIO�AL (WHILE)

Repite una o más sentencias mientras la condición de control de la iteración sea verdadera

Sintaxis: WHILE condición LOOP

E�D 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;

WHILE CONTADOR < 10 LOOP

VALUES (CONTADOR, ‘HOLA’);

CONTADOR := CONTADOR + 1;

END LOOP;

SE�TE�CIA 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 sentencia o grupo de sentencias <<ETIQUETA>> sentencia o grupo de sentencias . . . . . . . . . . . . . . . . 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] E�D Nombre_etiqueta;

En el siguiente ejemplo se muestra el uso de las etiquetas para referenciar bloques:

<<BLOQUEEXTERNO>>

DECLARE

N NUMBER;

N := 5;

<<BLOQUEINTERNO>>

DECLARE

X NUMBER := 10;

N CHAR(10) := 'DOS';

INSERT INTO TEMPORAL

VALUES (BLOQUEEXTERNO.N, X, N);

COMMIT;

END BLOQUEINTERNO;

END BLOQUEEXTERNO;

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:

<<ETIQUETA>>

FOR I IN 1..10 LOOP

-- sentencias a ejecutar

DECLARE

I NUMBER := 10;

INSERT INTO TEMPORAL

VALUES (I, ETIQUETA.I, 'COMPLETO');

END LOOP ETIQUETA;

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;

DELETE FROM item

WHERE num_orden = v_orden;

:filas_borradas := ‘ Se eliminaron : ‘||

to_char(SQL%ROWCOUNT)|| ‘ filas’;

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.

DIFERE�CIAS E�TRE 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 I�TO 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

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

%FOUND Booleano Evalúa TRUE si el FETCH mas reciente retornó una fila

%ROWCOUNT Numérico Contiene el total de filas recuperadas por el 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 I�TO 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;

E�D LOOP;

E�D;

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,

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 CURRE�T 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

DECLARE CURSOR empleados IS SELECT empno, nombre, salario FROM empleado WHERE numdept = 01 FOR UPDATE NOWAIT;

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

…. ….

… …

Capítulo 4

MA�EJO DE ERRORES

MA�EJO 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

EXCEPCIO�ES PREDEFI�IDAS

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

MA�EJA�DO EXCEPCIO�ES

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_MA�Y_ROWS y

�O_DATA_FOU�D

DECLARE SUELDO NUMBER; BEGIN SELECT SALARIO INTO SUELDO 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�_I�IT

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;

EXCEPCIO�ES DEFI�IDAS 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 SELECT SALARIO INTO SUELDO FROM EMPLEADO WHERE CODIGO = 2000; IF SUELDO < 3000 THEN RAISE AUMENTO;

EXCEPTION WHEN AUMENTO THEN UPDATE EMPLEADO SET SALARIO = 5000 WHERE CODIGO = 2000; 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 ALMACE�ADOS E� LA BASE DE DATOS

I�GE�IERIA DEL LE�GUAJE PL/SQL

I�GE�IERIA DE PL/SQL

Bloque de PL/SQL

DECLARE

Procedimiento

Ingeniería de PL/SQL

Procedimental

sentencias

Ejecutor

Ejecutor de sentencias SQL en el RDBMS de ORACLE

Bloque de PL/SQL

DECLARE

Procedimiento

I�GE�IERIA DE PL/SQL RESIDE�TE E� EL RDBMS

Bloque de PL/SQL

DECLARE

Procedimiento

Ingeniería de PL/SQL

Procedimental

sentencias

Ejecutor

Ejecutor de sentencias SQL

Bloque de PL/SQL

DECLARE

Procedimiento

ORACLE RDBMS

Programa anfitrión

Lenguaje anfitrión

PROCEDIMIE�TOS Y FU�CIO�ES ALMACE�ADAS

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.

DIFERE�CIA E�TRE PROCEDIMIE�TO Y FU�CIO�

Procedimiento Función

Solo puede retornar valores mediante el uso

de parámetros

Retorna siempre un valor en el nombre de la

función

Se invocan solo con el nombre y operan

como si el código estuviera en el lugar donde se

llaman

Deben aparecer en algún lugar donde se

pueda almacenar el valor que retorna

CARACTERISTICAS DE PROCEDIMIE�TOS Y FU�CIO�ES

� 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 PROCEDIMIE�TOS Y FU�CIO�ES

• 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 PROCEDIMIE�TOS Y FU�CIO�ES

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

DELETE

FROM empleado

WHERE empno = empid;

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

saldo_cuenta NUMBER := 0;

SELECT balance

INTO saldo_cuenta

FROM cuentas

WHERE ncuenta = cuenta;

RETURN (saldo_cuenta);

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 PROCEDIMIE�TOS Y FU�CIO�ES ALMACE�ADOS

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

nombre_procedimiento(parámetros);

� Desde una aplicación precompilada:

EXEC SQL nombre_procedimiento(parámetros);

� Desde OCI

CALL OSQL3 (cursor, /*interpretador*/

"BEGIN

nombre_procedimiento(parámetros);

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 DEFI�IDOS 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)

IF empid <= 0 THEN

raise_application_error(-20100, 'Numero de empleado debe ser > 0');

DELETE

FROM empleado

WHERE empno = empid;

END IF;

ELIMI�ACIO� DE PROCEDIMIE�TOS Y FU�CIO�ES

Al igual que las tablas, los procedimientos y funciones también pueden ser eliminados. La

sintaxis para eliminar un procedimiento es:

La sintaxis para eliminar una función es:

DROP PROCEDURE nombre_procedimiento;

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 PERSISTE�TE

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

DEPE�DE�CIAS E�TRE PAQUETES

variable D

procedure A

procedure B

variable C

Procedure A

i := D;

j := C;

Package PK

x := PK.C;

Especificaciones

Cuerpo

• 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

ESPECIFICACIO�ES 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 WHERE empno = empid; 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 EVE�TOS

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.

RESTRICCIO�ES 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

DEFI�ICIO� 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

tabla T

UPDATE t

SET...;

INSERT

INTO t....;

DELETEFROM t...;

UPDATEtriger

DELETE

triger

INSERT

A continuación se muestra un ejemplo de la secuencia de ejecución de un trigger de base de

EMPLEADO DEPARTAMENTO

Antes del comando trigger

Antes del trigger de fila

Despues del trigger de fila

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.

SECUE�CIA 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

/* 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;

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.

ELIMI�A�DO 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

Documents

Transcript of Manual Plsql

PLSQL Notes

Plsql Examples

Advanced Plsql

Plsql Guide

plsql les01

PLSQL plsql Complete

PLSQL Dev Tool Manual

PLSQL Cursors

Plsql Samp

Practice PLSQL

PLSQL Tutorial

oracle plsql training | oracle online training | oracle plsql demo | oracle plsql course

Oracle Plsql

Plsql overview

Manual de PLSQL Developer 5

Plsql les04

Unwrapping Oracle PLSQL - Macrotone Consulting Homemacrotoneconsulting.co.uk/images/Documents/unwrap.pdf · Macrotone Consulting Ltd Unwrapping PLSQL unwrap Unwrapping Oracle PLSQL

Plsql Mid2

Documentation PLSQL

PLSQL_sPLSQL_s01_l03 Creating PLSQL Blocks.pdf01_l03 Creating PLSQL Blocks