Académique Documents
Professionnel Documents
Culture Documents
2
PREFACIO
Este libro, refunde gran parte del material utilizado durante años, e impartido en
diversas academias de formación y empresas privadas, sirviendo de referencia y
ayuda a quien quiera iniciar un aprendizaje en el lenguaje PL/SQL, o mejorar el nivel
de conocimientos sobre el mismo.
3
4
Curso PL/SQL para Oracle 10G
ÍNDICE
CAPITULO 1 .................................................................................... 9
Fundamentos del lenguaje PL/SQL ............................................................. 9
Introducción............................................................................................................................ 9
Unidades léxicas .................................................................................................................. 13
Tipos de datos...................................................................................................................... 15
Declaración de variables...................................................................................................... 17
CAPITULO 2 .................................................................................. 21
Estructuras de control ................................................................................ 21
Introducción.......................................................................................................................... 21
IF – THEN – ELSE – END IF ............................................................................................... 21
CASE.................................................................................................................................... 22
LOOP ... END LOOP............................................................................................................ 23
WHILE .... LOOP... END LOOP ........................................................................................... 23
FOR ... LOOP .... END LOOP .............................................................................................. 24
GOTO................................................................................................................................... 24
Orden NULL ......................................................................................................................... 25
CAPITULO 3 .................................................................................. 27
Control de transacciones ........................................................................... 27
Introducción.......................................................................................................................... 27
COMMIT............................................................................................................................... 27
¿Cómo se realiza el proceso de validación (commit)? ........................................................ 27
ROLLBACK .......................................................................................................................... 31
¿Cómo se realiza el proceso de rechazo (rollback)? .......................................................... 31
SAVEPOINT <nombre_marcador>...................................................................................... 34
ROLLBACK TO <nombre_marcador_savepoint>................................................................ 34
CAPITULO 4 .................................................................................. 37
Creación de tipos ........................................................................................ 37
Introducción.......................................................................................................................... 37
Creación de un tipo RECORD (registro).............................................................................. 37
Creación de un tipo TABLE (pila/tabla de elementos)......................................................... 40
VARRAYS ............................................................................................................................ 42
CAPITULO 5 .................................................................................. 45
SQL vs PL/SQL ............................................................................................ 45
Introducción.......................................................................................................................... 45
Órdenes SQL ....................................................................................................................... 45
Utilización de SQL en PL/SQL ............................................................................................. 46
SQL Dinámico ...................................................................................................................... 47
CAPITULO 6 .................................................................................. 49
Cursores....................................................................................................... 49
¿Qué es un cursor? ............................................................................................................. 49
Cursores explícitos............................................................................................................... 49
Cursores implícitos............................................................................................................... 52
Cursores con SQL dinámico ................................................................................................ 52
CAPITULO 7 .................................................................................. 57
Subprogramas. ............................................................................................ 57
Introducción.......................................................................................................................... 57
Procedimientos .................................................................................................................... 57
Funciones............................................................................................................................. 62
Tablas del sistema asociadas .............................................................................................. 63
CAPITULO 8 .................................................................................. 65
Paquetes. ..................................................................................................... 65
Curso PL/SQL para Oracle 10G
Introducción.......................................................................................................................... 65
Especificación o cabecera del paquete ............................................................................... 65
Cuerpo del paquete.............................................................................................................. 66
Referenciando a los paquetes ............................................................................................. 67
Inicialización de un paquete................................................................................................. 68
Sobrecarga de paquetes...................................................................................................... 68
Dependencias ...................................................................................................................... 69
CAPITULO 9 .................................................................................. 73
Disparadores o Triggers. ............................................................................ 73
Introducción.......................................................................................................................... 73
Utilidad de los triggers.......................................................................................................... 73
Integridad Referencial .......................................................................................................... 74
Nombres del disparador....................................................................................................... 77
Momento del disparo............................................................................................................ 77
Suceso del disparo............................................................................................................... 77
Nivel de disparo ................................................................................................................... 78
Condición de disparo ........................................................................................................... 78
Sentencias de borrado y alteración de triggers ................................................................... 78
Uso de las situaciones anterior y posterior al trigger (:old y :new) ...................................... 79
Uso de predicados booleanos.............................................................................................. 79
Tablas mutantes................................................................................................................... 80
CAPITULO 10 ................................................................................ 87
Tratamiento de errores. .............................................................................. 87
Introducción.......................................................................................................................... 87
Declaración de excepciones ................................................................................................ 87
Excepciones definidas por el usuario .................................................................................. 88
Provocar excepciones.......................................................................................................... 89
Sintaxis de la sección EXCEPTION..................................................................................... 89
Uso de SQLCODE y SQLERRM ......................................................................................... 90
Utilización de RAISE_APPLICATION_ERROR ................................................................... 90
Utilización de EXCEPTION_INIT ......................................................................................... 91
Propagación de excepciones. .............................................................................................. 91
CAPITULO 11 ................................................................................ 97
Cursores avanzados. .................................................................................. 97
Bucles de extracción ............................................................................................................ 97
Bucles simples (LOOP..END LOOP) ................................................................................... 97
Bucles WHILE ...................................................................................................................... 98
Bucles FOR. ......................................................................................................................... 98
Cursores SELECT FOR UPDATE. ...................................................................................... 99
CAPITULO 12 .............................................................................. 103
Objetos. ...................................................................................................... 103
Introducción a los objetos .................................................................................................. 103
Bases de la programación orientada a objetos.................................................................. 103
Objetos e instancias de objetos ......................................................................................... 105
Bases de datos objeto-relaciones...................................................................................... 105
Definición de los tipos de objetos ...................................................................................... 106
Declaración, inicialización y asignación de valores a un objeto ........................................ 107
Especificación de métodos ................................................................................................ 108
Cuerpo de un objeto........................................................................................................... 108
Llamada a un método ........................................................................................................ 109
Borrado de los tipos de objeto ........................................................................................... 109
Modificación de tipos.......................................................................................................... 109
Creación de tablas de objetos............................................................................................ 110
Inserción de valores en una tabla de objetos. ................................................................... 110
CAPITULO 13 .............................................................................. 111
Entornos de ejecución PL/SQL. ............................................................... 111
Introducción........................................................................................................................ 111
CURSO PL/SQL para Oracle 10g – Documentación de apoyo 6
Impartido por: Antolín Muñoz Chaparro.
Contenidos elaborados por: Antolín Muñoz Chaparro.
Curso PL/SQL para Oracle 10G
CAPITULO 1 1
Fundamentos del lenguaje PL/SQL
Introducción
PL/SQL es un sofisticado lenguaje de programación que se utiliza para acceder a
bases de datos Oracle desde distintos entornos. PL/SQL está integrado con el servidor
de base de datos, de modo que el código puede ser procesado de forma rápida y
eficiente. También se encuentra disponible en varias de las herramientas de cliente
que posee Oracle, entre ellas SQL*PLUS, Developer Suite 10g, etc...
Esta instrucción determina que queremos borrar de la tabla estudiantes todos aquellos
cuyo nombre comience por "Pep", pero no dice como va a realizar el gestor de base
de datos, el proceso para conseguir eliminar dichos registros. Parece presumible que
recorrerá los datos de dicha tabla en un cierto orden para determinar que elementos
debe borrar y luego los eliminará, no obstante es algo que no nos interesa para la
instrucción.
Esta característica que le define, es posible, dado que es un lenguaje particular del
sistema gestor de bases de datos Oracle y no un lenguaje standard.
• El bloque.
• Manejo de errores y excepciones.
• Creación de procedimientos y funciones.
• Definición de variables y tipos.
• Estructuras de bucle.
• Cursores.
• Objetos.
El Bloque
Sintaxis:
DECLARE
<Sección declarativa>
BEGIN
<Sección de ejecución>
[EXCEPTION]
<Sección de control de errores>
END;
- Toda instrucción SELECT (no dinámica) que aparezca en este apartado deberá de
llevar incorporado el parámetro INTO.
- En esta sección sólo se admiten instrucciones de SQL del tipo DML (select, insert,
update y delete) o instrucciones SQL dinámicas, el resto no están permitidas,
produciéndose errores de compilación en caso de introducirlas (ej: alter, create,
drop, etc...)
Ejemplo de subprograma:
CREATE OR REPLACE PROCEDURE MI_PROGRAMA IS
Var1 NUMBER;
BEGIN
Var1 := 1;
END;
Ejemplo de disparador:
CREATE OR REPLACE TRIGGER MI_DISPARADOR
BEFORE INSERT OR UPDATE OF numero ON tabla_temporal
FOR EACH ROW
BEGIN
IF :new.numero < 0 THEN
RAISE_APPLICATION_ERROR(-20100,'Introduzca un valor
positivo');
END IF;
END mi_disparador;
Permite un control sobre los errores que se produzcan en la ejecución del código. Esta
gestión de errores presenta como ventaja la claridad para su manipulación, dado que
utiliza una sección independiente a la del código ejecutable.
Estructuras de bucle.
Cursores.
Nos permiten recuperar en memoria, un conjunto de filas de una tabla que se recorren
una a una para un tratamiento posterior.
Objetos.
No obstante, para que se haga completamente efectiva dicha salida a pantalla, antes
hay que activar el comando de ejecución en pantalla del paquete DBMS_OUTPUT,
siempre que se inicie una nueva sesión con la herramienta correspondiente.
SET SERVEROUTPUT;
Ejemplo:
Unidades léxicas
Es el conjunto de caracteres y gramática a utilizar en la programación de PL/SQL.
Contamos con los siguientes elementos:
• Identificadores.
• Palabras reservadas.
• Delimitadores.
• Literales.
• Comentarios.
Identificadores.
Un identificador tiene que comenzar obligatoriamente con una letra seguida por una
secuencia de caracteres entre los que se pueden incluir:
• letras
• números
• el símbolo $
• el carácter de subrayado _
• el símbolo #
Los espacios de nombres que existen para objetos que pertenecen a un esquema y
que objetos se almacenan en ellos son los siguientes:
Los espacios de nombre para objetos que no pertenecen a esquemas son los
siguientes:
• Contexts
• Directories
• Parameter files (PFILEs) and server parameter files (SPFILEs)
• Profiles
• Roles
• Rollback segments
• Tablespaces
• Users
Palabras reservadas.
Son todas aquellas que define Oracle como restringidas del lenguaje y cuyo nombre
no podrá llevar ningún otro objeto de la Base de Datos.
Delimitadores.
Literales.
Comentarios.
Tipos de datos
BINARY_DOUBLE
BINARY_FLOAT
BINARY_INTEGER
DEC
DECIMAL
DOUBLE PRECISION
FLOAT
INT
INTEGER
NATURAL Numéricos.
NATURALN
NUMBER
NUMERIC
PLS_INTEGER
POSITIVE
POSITIVEN
REAL
SIGNTYPE
SMALLINT
CHAR
CHARACTER
LONG
NCHAR De caracteres.
NVARCHAR2
STRING
VARCHAR
VARCHAR2
BOOLEAN Booleanos
DATE
TIMESTAMP
TIMESTAMP WITH TIMEZONE
TIMESTAMP WITH LOCAL TIMEZONE De fecha
INTERVAL YEAR TO MONTH
INTERVAL DAY TO SECOND
• Tipos compuestos:
RECORD
TABLE
VARRAY
REF CURSOR
REF tipo objeto
BFILE
LOB
CLOB
NLOB
Declaración de variables
La declaración de variables se realiza dentro de la sección DECLARE de un bloque y
su sintaxis es la siguiente:
Ejemplos:
DECLARE
Var1 NUMBER(5);
Var2 NUMBER := 10;
Var3 NUMBER(5) NOT NULL := 0;
Var4 CONSTANT VARCHAR2(10) := ‘Hola’
Var5 NUMBER DEFAULT 45;
Intervalo1 INTERVAL YEAR(3) TO MONTH;
Intervalo2 INTERVAL DAY(3) TO SECOND(3);
Var6 TIMESTAMP;
BEGIN
NULL;
END;
<variable> := <valor>;
A parte de los tipos standard definidos en ORACLE y que se encuentran han definido
con anterioridad, podemos utilizar 2 más:
¾ %TYPE.
Ejemplo:
DECLARE
Var_emple_nombre empleados.nombre%TYPE;
Subtipos.
Ejemplo:
DECLARE
SUBTYPE contador IS NUMBER(4);
Var_conta contador;
Sintaxis para la petición de un valor por pantalla para una variable numérica:
<variable> := &texto_a_mostrar;
Sintaxis para la petición de un valor por pantalla para una variable de texto:
<variable> := '&texto_a_mostrar';
Ejemplos:
DECLARE
Var1 NUMBER(3) := &Indique_la_edad;
Var2 VARCHAR2(100) := '&Indique_nombre_y_apellidos';
BEGIN
DBMS_OUTPUT.PUT_LINE('Usted se llama: '||VAR2);
DBMS_OUTPUT.PUT_LINE('Y su edad es:
'||TRIM(TO_CHAR(VAR1)));
END;