Libro de Referencia Del Curso

FACULTAD DE INGENIERA ELECTRNICA Y
TELECOMUNICACIONES - FIET
DEPARTAMENTO DE SISTEMAS
ESPECIALIZACIN EN DESARROLLO DE SOLUCIONES

INFORMTICAS (EDSI)
UNIVERSIDAD DEL CAUCA
FACULTAD DE INGENIERA ELECTRNICA Y

TELECOMUNICACIONES - FIET
DEPARTAMENTO DE SISTEMAS
Libro:
MANIPULACIN AVANZADA DE BASES DE DATOS
Profesor:
MIGUEL ANGEL NIO ZAMBRFANO
Popayn, Colombia, Junio de 2009
Universidad del Cauca

Facultad de Ingeniera Electrnica y Telecomunicaciones
Departamento de Sistemas
TABLA DE CONTENIDO
1
CAPTULO 1: INTRODUCCIN A LA MANIPULACION DE DATOS CON SQL Y ORACLE. 4

1.1
1.2
1.3
1.4
1.5
1.6
DECLARACIN DE CURSORES .............................................................................................................. 73

APERTURA DE UN CURSOR .................................................................................................................. 74
RECUPERACIN DE FILAS .................................................................................................................... 76
CIERRE DE UN CURSOR ........................................................................................................................ 79
CAPTULO 6: MANEJO DE ERRORES............................................................................................ 80

6.1
6.2
6.3
CONTROL CONDICIONAL: SENTENCIA IF ............................................................................................. 58

CONTROLES DE ITERACIN: LAS SENTENCIAS LOOP Y EXIT ............................................................. 61
CONTROLES DE SECUENCIA: LAS SENTENCIAS GOTO Y NULL .......................................................... 66
PROCESAMIENTO DE TRANSACCIONES ................................................................................................ 68
CAPTULO 5: MANEJO DE CURSORES ......................................................................................... 72

5.1
5.2
5.3
5.4
SET DE CARACTERES Y UNIDADES LXICAS ........................................................................................ 50

DELIMITADORES E IDENTIFICADORES .................................................................................................. 51
TIPOS DE DATOS Y CONVERSIONES ..................................................................................................... 52
ALCANCE Y VISIBILIDAD ..................................................................................................................... 55
CAPTULO 4: ESTRUCTURAS DEL LENGUAJE........................................................................... 57

4.1
4.2
4.3
4.4
QU ES PL/SQL?............................................................................................................................... 42
ESTRUCTURAS DE BLOQUE .................................................................................................................. 42
VARIABLES Y CONSTANTES ................................................................................................................. 43
CURSORES ........................................................................................................................................... 43
MANEJO DE ERRORES .......................................................................................................................... 44
SUBPROGRAMAS.................................................................................................................................. 45
PAQUETES ........................................................................................................................................... 45
VENTAJAS EN LA UTILIZACIN DE PL/SQL.......................................................................................... 46
CAPTULO 3: FUNDAMENTOS DEL LENGUAJE ......................................................................... 50

3.1
3.2
3.3
3.4
FUNCIONES Y TIPOS DE DATOS .................................................................................................. 12

REPORTES EN SQL*PLUS .............................................................................................................. 17
MANIPULACIN DE DATOS ......................................................................................................... 22
TABLAS Y VISTAS .......................................................................................................................... 25
OPTIMIZACIN DE INSTRUCCIONES DE MANIPULACIN DE DATOS EN SQL .......................................... 36
CAPTULO 2: INTRODUCCIN A PL/SQL..................................................................................... 42

2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
COMANDOS DE RECUPERACIN DE INFORMACION.................................................................................. 4
EXCEPCIONES PREDEFINIDAS ............................................................................................................... 80

EXCEPCIONES DEFINIDAS POR EL USUARIO .......................................................................................... 82
USO DE SQLCODE Y SQLERRM ...................................................................................................... 84
CAPTULO 7: SUBPROGRAMAS ...................................................................................................... 86

7.1
7.2
PROCEDIMIENTOS ................................................................................................................................ 88
FUNCIONES .......................................................................................................................................... 89
Especializacin en Desarrollo de Soluciones Informticas 2

7.3
7.4
7.5
8
CAPTULO 8: PAQUETES .................................................................................................................. 98

8.1
8.2
8.3
USO DE PARMETROS ......................................................................................................................... 91

RECURSIVIDAD .................................................................................................................................... 93
POLIMORFISMO .................................................................................................................................... 95
VENTAJAS DE LA UTILIZACIN DE PAQUETES ...................................................................................... 99

ESPECIFICACIN DE PAQUETES .......................................................................................................... 101
CUERPO DE UN PAQUETE ................................................................................................................... 101
BIBLIOGRAFIA .................................................................................................................................... 103
TABLA DE ANEXOS
ANEXO A: LABORATORIOS DEL CURSO.................................................................................................. 104
ANEXO B: MODELO DE DATOS DEL LIBRO DE REFERENCIA ............................................................. 110
ANEXO C: SCRIPTS DE CREACION DE TABLAS...................................................................................... 111
ANEXO D: SCRIPTS DE CARGA DE DATOS .............................................................................................. 112

CAPTULO 1: INTRODUCCIN A LA MANIPULACION DE DATOS CON

SQL Y ORACLE
Los comandos de SQL permiten crear, almacenar, cambiar, recuperar, y mantener la

informacin almacenada en la base de datos de ORACLE. Podemos clasificar los comandos de
SQL en tres grupos:
Comandos de manipulacin de datos.
Comandos de definicin de datos.
Comandos varios.
1.1
COMANDOS DE RECUPERACIN DE INFORMACION
SELECT
Esta sentencia muestra una o ms filas, con sus respectivas columnas, las cuales pueden ser
extradas de una o ms tablas, vistas o sinnimos. El nmero de columnas a visualizar puede ser
parcial o total.
Para poder utilizar esta sentencia, es necesario:
- Existencia de la tabla, vista o sinnimo a visualizar.
- Poseer el privilegio de acceso a la tabla, vista o sinnimo o los privilegios del administrador de
la base de datos (DBA).
Los parmetros mnimos requeridos para el uso de esta sentencia son:
SELECT Columnas
FROM Origen_datos
Columnas: son los nombres de todas aquellas columnas que se desea visualizar, los cuales
debern de estar separados por una coma (,). Si se desean visualizar todas las columnas de la
tabla, se podr abreviar la operacin, colocando en lugar de los nombre de las columnas, un
asterisco (*); adicionalmente puede usarse como columnas de visualizacin las constantes,
operaciones aritmticas, funciones, nidos de funciones y funciones de grupo.
Origen_datos: son los nombres de todas aquellas tablas, vistas o sinnimos de los cuales se
desea extraer la informacin, los cuales debern estar separados por una coma (,).
Seleccin de columnas
Como se dijo anteriormente se pueden visualizar de forma total o parcial las columnas de una
tabla. A continuacin se muestra un ejemplo de cada caso:
Caso 1:

Visualizacin de todas las columnas de la tabla empleado, usando para ello, los nombres de
cada una de las columnas.
Nota: lo indicado en cursiva pertenece al prompt de SQL, por lo tanto no deber transcribirse.
SQL> SELECT NOMBRE, CARGO, SALARIO, NUMDEPT
2 FROM EMPLEADO;
Visualizacin de la ejecucin:
NOMBRE
CARGO
------------------------------------------------MARA PREZ
SECRETARIA
LUIS CARRILLO
CHOFER
FRANCISCO MONTERO
GERENTE
LAURA MONTILLA
GERENTE
CARLOS FERNANDEZ
CHOFER
SALARIO
----------20.000
10.000
35.000
38.000
11.000
NUMDEPT
-----------------02
01
01
01
02
Caso 2:
Visualizacin de todas las columnas de la tabla empleados, usando para ello, el asterisco (*).
Nota: Suponer para este ejemplo que la tabla empleado, tiene las siguientes columnas:
- NOMBRE
- CARGO
- SALARIO
- NUMDEPT
SQL> SELECT *
2 FROM EMPLEADO;
NOMBRE
CARGO
-----------------------------------------------MARA PREZ
SECRETARIA
LUIS CARRILLO
CHOFER
FRANCISCO MONTERO
GERENTE
LAURA MONTILLA
GERENTE
CARLOS FERNANDEZ
CHOFER
SALARIO
----------20.000
10.000
35.000
38.000
11.000
NUMDEPT
-----------------02
01
01
01
02
Caso 3:
Visualizacin de la columna NOMBRE y SALARIO, de la tabla empleados, calculando a su vez
un bono del 10 %.
SQL> SELECT NOMBRE, SALARIO, SALARIO*.10 BONO
2 FROM EMPLEADO;
NOMBRE
SALARIO
BONO

-----------------------------MARA PREZ
LUIS CARRILLO
FRANCISCO MONTERO
LAURA MONTILLA
CARLOS FERNANDEZ
----------------- ---------------20.000
2.000
10.000
1.000
35.000
3.500
38.000
1.800
11.000
1.100
Si al momento de manipular una tabla, no recuerda los nombres de las columnas o el tipo al cual
pertenecen, se puede usar el comando DESCRIBE el cual facilitar dicha informacin.
DESCRIBE Origen_datos
Abreviacin: DESC
Origen_datos: es el nombre de la tabla, vista o sinnimo de la cual se desea conocer: el nombre
de las columnas; con datos nulos; y tipo de las columnas (Number, Char, etc.).
Ejemplo:
SQL > DESCRIBE EMPLEADO;
Name
NULL?
Type
-------------- -------------- ------------------------NOMBRE
CHAR(15)
CARGO
CHAR(15)
SALARIO
NUMBER(8,2)
NUMDEPT
CHAR(10)
Suponga el caso donde se desea conocer, los nombre de todos los cargos de empleados, que
existen en nuestra empresa. Para ello se asume que dicha informacin no se repetir. Para lograr
esto debe hacer uso del parmetro DISTINCT, perteneciente a la sentencia SELECT.
La sintaxis es la siguiente:
SELECT DISTINCT Columnas
FROM Origen_datos
A continuacin se muestra un ejemplo para visualizar todos los cargos que posee nuestra
empresa, sin repetir ningn cargo.
SQL > SELECT DISTINCT CARGO
2 FROM EMPLEADO;
CARGO
--------------------SECRETARIA
CHOFER
GERENTE

Operadores de seleccin
Los operadores de seleccin combinan dos consultas o sub-consultas en un resultado.
Operadores de seleccin:
- UNION
- INTERSECT
- MINUS
UNION: Busca filas comunes y no comunes en dos o ms tablas.
Ejemplo:
Mostrar todos los empleados que ganen ms de 20000. Esto se deber de realizar para todos los
departamentos.
SQL > SELECT NOMBRE, SALARIO
2 FROM EMP_TALLER
3 WHERE SALARIO > 20000
4 UNION
5 SELECT NOMBRE, SALARIO
6 FROM EMP_ADMIN
7 WHERE SALARIO > 20000
8 UNION
9 SELECT NOMBRE, SALARIO
10 FROM EMP_COMPUT
11 WHERE SALARIO > 20000;
INTERSECT: Busca las filas comunes en dos o ms tablas.
Ejemplo:
Mostrar todos los cargos que sean comunes, para todos los departamentos.
SQL > SELECT CARGO
2 FROM EMP_TALLER
3 INTERSECT
4 SELECT CARGO
5 FROM EMP_ADMIN
6 INTERSECT
7 SELECT CARGO
8 FROM EMP_COMPUT;
MINUS: Busca las filas que aparezcan en la primera consulta, pero que a su vez, no aparezcan
en a segunda consulta.
Ejemplo:
Mostrar todos los cargos que se encuentren en el departamento EMP_TALLER pero que a su
vez, no se encuentren en el departamento EMP_ADMIN.
SQL > SELECT CARGO
2 FROM EMP_TALLER

3 MINUS
4 SELECT CARGO
5 FROM EMP_ADMIN;
Alias o nombre sustitutos
Un alias es un nombre temporal que slo tiene efecto durante la operacin en curso, el cual
sustituye a un nombre de tabla o de columna.
Los alias son utilizados cuando:
- Se necesita abreviar el nombre original.
- Cuando se manejan dos o ms tablas en una operacin, y en estas existen columnas de igual
nombre, se crea una ambigedad, ya que el manejador de la base de datos, no sabr a que tablas
se est refiriendo. Cuando se pide visualizar, una columna en particular; por tal motivo, se debe
usar un alias de tabla en una de las columnas.
- Cuando queremos cambiar el nombre de la etiqueta que identifica la columna, al momento de
visualizar la informacin de la base de datos.
Ejemplo 1:
SQL > SELECT NOMBRE "NOMBRE DEL TRABAJADOR"
2 FROM EMPLEADO;
Ejemplo 2:
SQL > SELECT NOMBRE NOM
2 FROM EMPLEADO;
Ejemplo 3:
SQL > SELECT NOMBRE, DEP.NUMDEPT
2 FROM EMPLEADO, DEPARTAMENTOS DEP;
Ejemplo 4:
SQL > SELECT NOMBRE, SALARIO * .10 BONO
2 FROM EMPLEADO;
Seleccin de filas
La instruccin SELECT, puede entregar mltiples registros o filas, de una o ms tablas. Pero su
verdadera utilidad radica en poder hacer una seleccin de los datos que cumplan con una
determinada condicin. Para tal fin, se har uso del parmetro WHERE.
La condicin de bsqueda se puede formar bajo la siguiente regla:
Nombre de columna Expresin
o operador de comparacin o
Expresin Nombre de columna

Operadores de comparacin (en orden de precedencia).

-----------------------------------------------------------------------------------------------------Smbolo
Significado
-----------------------------------------------------------------------------------------------------=
Igual a.
!= < > ^=
Diferente de.
>
Mayor que.
>=
Mayor o igual que.
<
Menor que.
<=
Menor o igual que.
IN (lista)
Igual a uno de los elementos de la lista de valores.
LIKE
Busca todo lo que cumpla con el patrn de bsqueda.
IS NULL
Es un valor nulo.
BETWEEN ... AND ...
Entre dos valores.
-----------------------------------------------------------------------------------------------------Operadores lgicos (en orden de precedencia).
-----------------------------------------------------------------------------------------------------Smbolo
Significado
-------------------------------------------------------------------------------------NOT
No. (Niega una condicin)
AND
Y.
OR
O.
-------------------------------------------------------------------------------------Nota: para cambiar el orden de precedencia de alguno de los operadores antes mencionados se
deber hacer uso de los parntesis "(", ")".
Ejemplo 1:
Mostrar todos los empleados, que pertenezcan al departamento 01 y que devenguen un salario
mayor de 10.000 y el cargo sea GERENTE
SQL> SELECT *
2 FROM EMPLEADO
3 WHERE NUMDEPT = 01
4 AND SALARIO > 20.000
5 AND CARGO = 'GERENTE';
Ejemplo 2:
Mostrar los salarios de todos los empleados que estn entre 10.000 y 20.000.
SQL> SELECT *
2 FROM EMPLEADO
3 WHERE SALARIO BETWEEN 10000 AND 20000;

Ejemplo 3:
Mostrar todos los empleados que devenguen salarios de 10.000, 11.000 y 20.000.
SQL> SELECT *
2 FROM EMPLEADO
3 WHERE SALARIO IN (10000, 11000, 20000);
Ejemplo 4:
Mostrar todos los empleados que tengan en la segunda posicin de su nombre la letra "A".
SQL> SELECT *
2 FROM EMPLEADO
3 WHERE NOMBRE LIKE '_A%';
En ocasiones, al ejecutar una sentencia SELECT, observamos la existencia de varias filas con el
mismo nmero de departamento, pero en forma dispersa. Cuando esto ocurre, tal vez sea un
poco difcil, poder apreciar en conjunto, el nombre de los empleados existentes por cada
departamento.
Esta dificultad desaparecera, si toda sta informacin apareciese agrupada por departamento.
Para solucionar este problema, se hace uso de la clusula GROUP BY.
Para usar la clusula GROUP BY es necesario, que el o los nombres de las columnas que
aparecen en la sentencia SELECT, hallan sido especificadas en la sentencia GROUP BY, o en
su defecto poseer una de las funciones de agrupamiento (explicadas en la seccin Tipos de datos
y funciones).
Ejemplo:
Mostrar una lista de todos los cargos que existen por departamento. En dicha lista se mostrar:
nmero de departamento, cargo y cantidad de cargos similares por departamento.
SQL> SELECT NUMDEPT, CARGO, COUNT(CARGO) CANTIDAD
2 FROM EMPLEADO
3 GROUP BY NUMDEPT, CARGO;
GROUP BY puede ser acompaado por la clusula HAVING, siendo su uso no obligatorio,
pero cuando se usa, se debe acompaar de la clusula GROUP BY. Su funcin, es la de crear
una condicin de agrupamiento; su forma de trabajo es similar a la clusula WHERE.
Ejemplo:
Realizar el ejemplo anterior, teniendo en cuenta, que esta vez, se realizar la agrupacin y
mostrar todos aquellos departamentos cuya cantidad por cargo sea menor de 5.
SQL> SELECT NUMDEPT, CARGO, COUNT(*) CANTIDAD
2 FROM EMPLEADO
3 GROUP BY NUMDEPT, CARGO
4 HAVING COUNT(*) < 5;

En ocasiones es necesario mostrar la informacin de la base de datos, ordenada por una o ms

columnas, ya sea ascendente o descendente. Para este fin, haremos uso de la clusula ORDER
BY.
Nota: el uso de la clusula ORDER BY, slo tendr efecto sobre la visualizacin de la
informacin de la base de datos, y no, sobre la base de datos.
Ejemplo:
Mostrar todos los empleados del departamento 01, ordenados de la siguiente manera:
- Nombre, cargo y departamento ordenado ascendentemente.
- Salario ordenado descendentemente.
La prioridad de ordenacin es la siguiente:
- Nombre.
- Cargo.
- Salario.
- Departamento.
SQL> SELECT *
2 FROM EMPLEADO
4 ORDER BY NOMBRE, CARGO, SALARIO DESC, NUMDEPT;
Hasta este momento, hemos ordenado la visualizacin de una tabla, por medio de los nombre de
las columnas. Tambin podemos realizar esta operacin colocando en vez del nombre de la
columna, la posicin de la misma. Cuando se indican los nombres de las columnas a visualizar,
la posicin de esta, ser la misma posicin que hemos colocado en la sentencia; pero cuando se
coloca el asterisco (*), para indicar que se visualicen todas las columnas, la posicin de estas
ser, la misma que elegimos al momento de crear la tabla.
Ejemplo 1:
Mostrar la tabla empleados ordenada por la segunda columna, teniendo en cuenta, que la
informacin deber aparecer de la siguiente manera:
NOMBRE, SALARIO, CARGO
SQL> SELECT NOMBRE, SALARIO, CARGO
2 FROM EMPLEADO
3 ORDER BY 2;
Ejemplo 2:
Mostrar la tabla empleados ordenada por la segunda columna, teniendo en cuenta, que la
posicin de dicha columna, deber ser la misma que se uso, al momento de crear la tabla.
SQL> SELECT *
2 FROM EMPLEADO
3 ORDER BY 2;

1.2
FUNCIONES Y TIPOS DE DATOS
Las sentencias de SQL, permiten hacer diferentes clculos aritmticos, como lo son los
siguientes (en orden de precedencia):
*
MULTIPLICACIN.
/
DIVISIN.
+
SUMA.
RESTA.
Nota: a los anteriores se le puede cambiar el orden de precedencia con el uso de parntesis "(", ")".
Ejemplo:
SQL> SELECT NOMBRE, SALARIO*12 "SALARIO ANUAL", SALARIO/30
2 FROM EMPLEADO;
Como se pudo apreciar, el poder de las sentencias de SQL, se ve incrementado, al tener la
posibilidad de realizar operaciones aritmticas; pero esto no es todo, ya que existe una gran
variedad de funciones matemticas, que hacen ms poderoso a SQL. A continuacin una breve
resea:
-----------------------------------------------------------------------------------------------------------------Funciones numricas
Utilidad
-----------------------------------------------------------------------------------------------------------------NVL(n, m)
Convierte el valor "n", a un valor "m", cuando "n" es nulo.
MOD(n, m)
Devuelve el residuo de la divisin de "n" entre "m".
SQRT(n)
Devuelve la raz cuadrada de "n".
ROUND(n, m)
"n" es redondeado a la cantidad de "m" dgitos decimales si "m" es
positivo y unidades si "m" es negativo.
TRUNC(n, m)
"n" es truncado a la cantidad de "m" dgitos decimales si "m" es positivo
y unidades si "m" es negativo.
SIGN(n)
Si n es menor que cero, la funcin retorna -1. Si n es igual que cero, la
funcin retorna 0. Si n es mayor que cero, la funcin retorna 1.
POWER(n, m)
Obtiene el resultado de "n" elevado a la "m".
ABS(n)
Retorna el valor absoluto de un valor "n".
Ceil(n)
Retorna el menor entero, mayor o igual que "n".
Floor(n)
Retorna el mayor entero, menor o igual que "n".
------------------------------------------------------------------------------------------------------------------Nota: "n", "m" son valores de tipo numrico entero, los cuales pueden ser constantes o nombres de columnas.
"f" son formatos numricos
------------------------------------------------------------------------------------------------------------------Funciones de fecha y hora

Utilidad
------------------------------------------------------------------------------------------------------------------ADD_MONTHS(n, m)
Adiciona a "n" la cantidad de meses que indique "m",
"m" puede ser positivo o negativo.

LAST_DAY(n)
NEXT_DAY(n, c)
Retorna el ltimo da del mes "n".

Retorna una fecha superior a "n" cuyo da de la semana,
sea igual a "c".
MONTHS_BETWEEN(n, m)
Retorna la cantidad de meses entre las fechas "n" y "m".
Si "n" es mayor que "m" el resultado ser positivo, caso
contrario, ser negativo.
SYSDATE
Retorna la fecha y hora en curso del sistema.
------------------------------------------------------------------------------------------------------------------Nota: "n", "m" son valores de tipo fecha y hora (segn el caso). "c" es un valor de tipo caracter.
-------------------------------------------------------------------------------------------------------------------Funciones de caracteres
Utilidad
-------------------------------------------------------------------------------------------------------------------INITCAP(c1)
Retorna la primera letra del contenido de "c1", en maysculas, y
todas las dems letras en minsculas.
UPPER(c1)
Retorna el contenido de "c1" en maysculas.
LOWER(c1)
Retorna el contenido de "c1" en minsculas.
SUBSTR(c1, n1, n2)
Extrae del contenido de "c1", "n2" caracteres, partiendo desde la
posicin "n1".
LENGTH(c1)
Retorna el nmero de dgitos del contenido de "c1"
LPAD(c1, n1,[c2])
Muestra el contenido de c1, colocando por el lado izquierdo los
caracteres "c2". El espacio (en caracteres) para la visualizacin
de "c2" ser igual a "n1" menos la cantidad de caracteres de
"c1". Si "c2" no existe, se tomar por defecto espacio en blanco.
RPAD(c1, n1,[c2])
Muestra el contenido de c1, colocando por el lado derecho los
caracteres "c2". El espacio (en caracteres) para la visualizacin
de "c2" ser igual a "n1" menos la cantidad de caracteres de "c1".
Si "c2" no existe, se tomar por defecto espacio en blanco.
REPLACE(c1, c2, [c3])
Se busca "c2" en el contenido de "c1", si es encontrada, se
sustituye por "c3", de lo contrario la funcin devolver NULL. Si
no se especifica "c3", y "c2" es encontrada en "c1", por defecto se
borrar.
TRANSLATE(c1, c2, c3)
Se busca "c2", caracter a caracter en el contenido de "c1", si es
encontrado, se sustituye por su caracter correspondiente
almacenado en "c3", de lo contrario no tendr ningn efecto
sobre "c1". Ejemplo: TRANSLATE('HOLA', 'AHOL', 'OCHA')
Resultado de la ejecucin: CHAO.
------------------------------------------------------------------------------------------------------------------Nota: "c1", "c2", "c3", es un valor de tipo caracter, el cual puede ser un nombre entre comillas, o un nombre de
columna. "n1", "n2" son valores numricos enteros.

-------------------------------------------------------------------------------------------------------------------Funciones de conversin
Utilidad
-------------------------------------------------------------------------------------------------------------------TO_CHAR(d, [f])
Convierte un valor de tipo fecha u hora "d", a un valor de (Conversin
tipo char, pudiendo especificar opcionalmente un formato de tipo fecha
y hora) "f". Si no se especifica el formato "f", por defecto se tomar
"DD-MON-YY". La funcin de TO_CHAR, es cambiar la forma de
visualizacin de la fecha u hora.
TO_CHAR(n, [f])
Convierte un valor de tipo numrico "n", a un valor de tipo (Conversin
numrica) char, pudiendo especificar opcionalmente un formato "f". La
funcin de TO_CHAR, es cambiar la forma de visualizacin de un
nmero.
TO_DATE(c, [f])
Convierte el contenido de "c", a un valor de tipo fecha u hora, pudiendo
especificar opcionalmente un formato "f" Si no se especifica el formato
"f", por defecto se tomar "DD-MON-YY". TO_NUMBER(c) Convierte
el contenido de "c", a un valor de tipo numrico. Nota: se asume que
"c" contienen caracteres numricos.
CONVERT(c, set1, set2) Conversin entre dos diferentes implementaciones de una misma
seleccin de caracteres, ejemplo: de caracteres multilenguaje DEC8 bit a
caracteres multilenguaje HP 8 bit. "c" es el caracter a convertir. "set1", es
la seleccin de caracteres destino. "set2" es la seleccin de caracteres
fuente.
------------------------------------------------------------------------------------------------------------------Nota: "d" es un valor de tipo fecha u hora. "n" es un valor de tipo numrico. "c" es un valor de
tipo caracter. "f" es un modelo de formato.
JUEGO DE CARACTERES DE MULTILENGUAJE MS COMUNES:
------------------------------------------------------------------------------------------------------------------Nombre
Significado
-------------------------------------------------------------------------------------------------------------------US7ASCII US
7-bit ASCII (usado por defecto)
WE8DEC
DEC's Western European 8 bit ASCII.
WE8HP
HP's Western European 8 bit ASCII
F7DEC
DEC's French 7-bit ASCII.
WEIBMPC
Western European 8-bit ASCII (usado por las IBM PC).
-------------------------------------------------------------------------------------------------------------------MODELOS DE FORMATO:
Formatos numericos ms utilizados:
-------------------------------------------------------------------------------------------------------------------Elemento Ejemplo
Descripcin
-------------------------------------------------------------------------------------------------------------------9 9999
La cantidad de nueves (9) determina el ancho del numero a mostrar.

0 0999
Muestra ceros a la izquierda de un nmero.
$ $9999
Prefija a un valor con el simbolo de moneda.
B B9999
Muestra espacios en blanco (B) a la izquierda de un nmero.
Coma 9,999
Muestra una coma en esta posicin.
Punto 99.99
Muestra un punto decimal en esta posicin.
-------------------------------------------------------------------------------------------------------------------Formatos de tipo fecha ms utilizados:
------------------------------------------------------------------------------------------------------------------Elemento
Significado
------------------------------------------------------------------------------------------------------------------YYYY
Los cuatro dgitos del ao.
YYY
Los ltimos tres dgitos del ao.
YY
Los ltimos dos dgitos del ao.
Y
El ltimo digito del ao.
MM
Nmero del mes (del 1 al 12).
MON
Nombre del mes (abreviado a 3 letras)
MONTH
Nombre del mes, acompaado de un mximo de 9 caracteres en
blanco.
D
Das de la semana (del 1 al 7).
DD
Das del mes (del 1 al 31).
DDD
Das del ao (del 1 al 366).
MI
Minutos.
SS
Segundos.
-------------------------------------------------------------------------------------------------------------------Funciones de agrupamiento
Utilidad
-------------------------------------------------------------------------------------------------------------------AVG(n)
Retorna el average de la columna "n", ignorando valores nulos.
COUNT(n)
Retorna el nmero de filas que tiene la columna "n", ignorando
valores nulos.
MAX(n)
Retorna el mximo valor de la columna "n".
MIN(n)
Retorna el mnimo valor de la columna "n".
SUM(n)
Retorna la sumatoria de los valores de la columna "n".
GREATEST(n, m)
Retorna el mayor entre "n" y "m".
LEAST(n, m)
Retorna el menor entre "n" y "m".
DECODE(c, n1, r1, n2, r2) d Retorna el valor "r1", si "c" es igual a "n1", Retorna el valor "r2",
si "c" es igual a "n2", En caso de no coincidir con ningn valor
de la lista retorna "d". El valor "d" puede omitirse. Nota: pueden
haber tantos n y r como se deseen.
USER
Retorna el nombre del usuario que se encuentra conectado
actualmente a la base de datos.

USERENV({'ENTRYID' |
Retorna la informacin sobre el usuario y/o seccin que

'SESSIONID' | est siendo utilizada por una aplicacin,
funcionando para 'TERMINAL' | una tabla de auditoria. Si la
opcin es ENTRYID, la funcin 'LANGUAGE' | retorna un
identificador de entrada disponible para }) auditoria; si la opcin
es SESSIONID retorna un Identificador de la seccin de
auditoria del usuario; si la opcin es TERMINAL, retorna el
identificador del sistema operativo del terminal del usuario; si la
opcin es LANGUAGE retorna el lenguaje en uso (como el
ingles), determinado por los parmetros LANGUAGE en el
INIT.ORA.
VSIZE(n)
Retorna el nmero de bytes usados para almacenar una expresin
"n".
-------------------------------------------------------------------------------------------------------------------Nota: Las funciones anteriores sirven para todo tipo de datos.
Ejemplo:
Mostrar el nmero de departamento, el salario ms alto, el salario promedio y el total de salarios
por departamento y la informacin deber aparecer de la siguiente manera:
Departamento Mximo Salario Salario Promedio Total Salarios
SQL> SELECT NUMDEPT Departamento,
2 MAX(SALARIO) "Mximo Salario",
3 AVG(SALARIO) "Salario Promedio",
4 SUM(NVL(SALARIO, 0)) "Total Salario"
5 FROM EMPLEADO
6 WHERE NUMDEPT IS NOT NULL
7 GROUP BY NUMDEPT;
Mostrar la cantidad de empleados, que devengen salarios:
- Menores o iguales a 15.000;
- Entre 15.001 y 20.000;
- Superiores o iguales a 20.000.
Esto se realizar para todos aquellos departamentos que tengn ms de 5 empleados. A
continuacin un ejemplo del formato de aparicin.
Departamento
Del # AL 15000 HAY x# Del 15001 AL 20000 HAY x# Ms de 20001 HAY x#
SQL> SELECT 'Departamento ' || RPAD(NUMDEPT,66,' ') ||
2 'Del ' ||
3 TO_CHAR(NVL(MIN(DECODE(SIGN(SALARIO-15000),-1, SALARIO)),0)) ||
4 ' AL 15000 HAY ' ||
5 TO_CHAR(COUNT(DECODE(SIGN(SALARIO-15000),-1,1,0,1))) ||
6 ' Del 15001 AL 20000 HAY ' ||

7 TO_CHAR(COUNT(DECODE(LEAST(GREATEST(SALARIO,15001),20000),
8 SALARIO, SALARIO))) ||
9 ' Mas de 20001 HAY ' || TO_CHAR(COUNT(
10 DECODE(GREATEST(SALARIO, 20001),SALARIO, SALARIO))) " "
11 FROM EMPLEADO02
12 WHERE NUMDEPT IS NOT NULL
13 GROUP BY RPAD(NUMDEPT,66,' ')
14 HAVING COUNT(*) >= 5
1.3
REPORTES EN SQL*PLUS
Anteriormente se han elaborado reportes simples, los cuales carecen de ciertos detalles, como
ttulos, formato, totalizacin, etc. Para lograr esto se har uso de los comandos de SQL*Plus, lo
cual permitir, crear reportes de mejor calidad, los cuales se podrn visualizar por pantalla, por
impresora, o simplemente almacenar su salida en un archivo.
Comandos de formato de SQL*Plus
TTITLE
Uso: Muestra un ttulo en el tope cada pgina del reporte.
Forma abreviada: TTI.
Sintaxis: TTITLE [ep [texto | variable ] ] | [OFF | ON ].
ep: ver: especificaciones de impresin.
OFF: desactiva la opcin.
ON: activa la opcin.
BTITLE
Uso: Muestra un ttulo en el pie de pgina del reporte.
Forma abreviada: BTI.
Sintaxis: BTITLE [ep [texto | variable ] ] | [OFF | ON ].
ep: ver: especificaciones de impresin.
OFF: desactiva la opcin.
ON: activa la opcin.
COLUMN
Uso: Sirve para especificar los atributos con los cuales van a ser mostrados una columna, tal
como encabezados de las columnas, alineacin, formato de los datos y el manejo de los datos.
Forma abreviada: COL
Sintaxis: COLUMN [{Columna | expresin} [opciones] ].
Opciones:
ALIAS JUSTIFY [ LEFT | CENTER | CENTRE | RIGHT ] OLD_VALUE
CLEAR LIKE PATTERN
COLOR LINEAPP [ LINE | MARK | BOTH] WRAPPED
FOLD_AFTER NEWLINE

FOLD_BEFORE NEW_VALUE
FORMAT NOPRINT
HEADING NULL
BREAK
Uso: Indica cuando y como cambia el formato de impresin en el reporte, tal como,
suprimiendo los valores duplicados para la columna especificada, saltando lineas, al cambiar el
valor de la columna, mostrando clculos especificados a travs de un COMPUTE.
Forma abreviada: BRE
Sintaxis: BREAK [ ON columnas del Select [ accin [ accin]]] ...
COMPUTE
Uso: Permite realizar clculos e imprimir sumatorias, usando varios clculos estndares, sobre
subgrupos, de filas seleccionadas.
Forma abreviada: COMP
Sintaxis: COMPUTE [funcin ...
OFF {expresiones | columna | alias}...
ON {expresiones | columna | alias | REPORT | ROW}]
Funciones permitidas en el comando COMPUTE:
AVG Obtiene el promedio de valores no nulos.
COUNT Obtiene la cantidad de los valores no nulos.
MAXIMUM Obtiene el mximo valor.
MINIMUM Obtiene el mnimo valor.
NUMBER Obtiene el nmero de filas.
STD Obtiene la desviacin estndar de valores no nulos.
SUM Obtiene la sumatoria de valores no nulos.
VARIANCE Obtiene la varianza de valores no nulos.
SET
Uso: Establece los aspectos de ambiente de SQL*Plus, para la seccin actual de trabajo, tales
como:
- Fija los atributos del display para los datos numricos LONG, CHAR y DATE; definicin de
tamao de pgina PAGESIZE, linea LINESIZE, arreglos de memoria ARRAYSIZE, espaciado
entre columnas SPACE, etc.
- Fija los atributos para los parmetros de ambiente tales como impresin de encabezados,
cubierta, salidas a pantallas, pie de pgina, mensajes, etc.
Sintaxis: SET variable del sistema.
VARIABLES DEL SISTEMA MS USADAS
ECHO

Uso: Cuando est activo, muestra los comandos que estn siendo ejecutados. Caso contrario
cuando esta desactivado.
Sintaxis: ECHO {OFF | ON}
FEEDBACK
Uso: Muestra el nmero de registros retornados por una consulta, cuando la misma selecciona
un mnimo de "n" registros.
Cuando se coloca ON, "n" ser igual a uno. Cuando se coloca OFF, "n" ser igual a cero; por
defecto "n", vale 6.
Forma abreviada: FEED.
Sintaxis: FEEDBACK {6 | n | OFF | ON}
n: es el mnimo nmero de registros que debe procesar la instruccin para ser mostrado el
FEEDBACK
NULL
Uso: Selecciona un texto que representar a los valores nulos. Por defecto este ser espacio.
Sintaxis: NULL texto
PAGESIZE
Uso: Selecciona el nmero de lineas por pginas
Forma abreviada: PAGES
Sintaxis: PAGESIZE {14 | n}
SPACE
Uso: Selecciona el nmero de espacios entre columnas.
Forma abreviada: SPA.
Sintaxis: SPACE {1 | n}
ESPECIFICACIONES DE IMPRESIN
COL
Uso: Hace que el prximo valor de tipo CHAR, aparezca en la columna "n" de una linea.
Sintaxis: COL n
SKIP
Uso: Salta hacia una nueva linea "n" veces. Si n es mayor que 1, n-1 lineas en blanco aparecern
despus del prximo valor de tipo carcter.
Sintaxis: SKIP n
TAB
Uso: Salta "n" columnas hacia adelante o hacia atrs dependiendo si el valor de "n" es positivo o
negativo. Columnas se refiere a posicin de impresin.
Sintaxis: TAB n

LEFT
Uso: Alinea un valor de tipo char a la izquierda.
Sintaxis: LEFT
CENTER
Uso: Alinea un valor de tipo char al centro.
Sintaxis: CENTER
RIGHT
Uso: Alinea un valor de tipo char a la derecha
Sintaxis: RIGHT
BOLD
Uso: Imprime los datos en negrita
Sintaxis: BOLD
FORMAT
Uso: Especifica el modelo de formato o mscara en el cual se mostrarn los datos de la columna
especificada.
Sintaxis: FORMAT mscara o formato.
A continuacin se mostrar la codificacin para la generacin de un reporte, el cual rene una
buena parte, de lo expuesto anteriormente. Para ello se necesitar hacer uso de un editor, o
procesador de palabras (que grabe en formato ASCII); una vez realizado esto, gurdelo con el
nombre de su preferencia, pero con extensin SQL. Una vez realizado el paso anterior, se puede
ejecutar de dos formas:
- START nombre.sql
o
- @nombre.sql
Ejemplo:
SET PAUSE ON
SET PAGESIZE 24
SET ECHO OFF
SET FEEDBACK OFF
TTITLE RIGHT 'PAGINA' SQL.PNO SKIP 2 CENTER 'REPORTE DE PERSONAL' SKIP 2 CENTER 'Producido por el departamento de personal' SKIP 2
BTITLE CENTER 'Informacin confidencial'
COLUMN DEPTNO HEADING 'DEPARTAMENTO' FORMAT 99
COLUMN NOMBRE FORMAT A10
COLUMN CARGO FORMAT A10

COLUMN SALARIO HEADING 'SALARIO|MENSUAL' FORMAT $99,990.00

COLUMN ANUAL HEADING 'SALARIO|ANUAL' FORMAT 999,990.00
SET SPACE 6
BREAK ON NUMDEPT SKIP 2 ON REPORT
COMPUTE SUM AVG OF SALARIO ON NUMDEPT REPORT
COMPUTE STD OF ANUAL ON NUMDEPT REPORT
SET NULL 'DESCONOCIDO'
SELECT NUMDEPT, NOMBRE, CARGO, SALARIO, SALARIO*12 ANUAL
FROM EMPLEADO
ORDER BY NUMDEPT
Como salida se visualizar
PAGINA 1
REPORTE DE PERSONAL
Producido por el departamento de personal
SALARIO SALARIO
DEPARTAMENTO NOMBRE CARGO MENSUAL ANUAL
----------------------- ---------------- ------------------ ---------------------- --------------------------10 PEDRO OBRERO $2,450.00 29,400.00
MANUEL PRESIDENTE $5,000.00 60,000.00
EMILIO GERENTE $1,500.00 18,000.00
TERESA LIMPIEZA $1,300.00 15,600.00
JOS SUB-GERENTE $1,500.00 18,000.00
LUIS PASANTE DESCONOCIDO DESCONOCIDO
CHANG PASANTE DESCONOCIDO DESCONOCIDO
INGRID SECRETARIA $2,000.00 24,000.00
CARMEN SECRETARIA $2,550.00 30,600.00
**************** ---------------------- ----------------------------avg $2,328.57
sum $16,300.00
std 34,824.70
Informacin confidencial
PAGINA 2
REPORTE DE PERSONAL
SALARIO SALARIO
----------------------- -------------- ------------------ ---------------------- ---------------------20 RODRIGO LIMPIEZA $800.00 9,600.00
ISABEL LIMPIEZA $1,100.00 3,200.00
GERARDO ANALISTA $3,000.00 36,000.00
DILIA ANALISTA $3,000.00 36,000.00
LUIS SECRETARIO $2,000.00 24,000.00
PETRONILO GERENTE $2,975.00 35,700.00
**************** ---------------------- ---------------------avg $2,145.83
sum $12,875.00

std 71,068.05
PAGINA 3
REPORTE DE PERSONAL
SALARIO SALARIO
----------------------- -------------- --------------------- ---------------------- ---------------------30 TOMAS VENDEDOR $1,600.00 19,200.00
RAQUEL LIMPIEZA $2,850.00 34,200.00
ORLANDO VENDEDOR DESCONOCIDO DESCONOCIDO
GLORIA VENDEDOR $1,250.00 15,000.00
JUDITH VENDEDOR $950.00 1,400.00
MARA VENDEDOR $1,500.00 8,000.00
JOSEFINA VENDEDOR $1,250.00 15,000.00
**************** ---------------------- ---------------------avg $1,566.67
sum $9,400.00
std 55,051.68
PAGINA 4
REPORTE DE PERSONAL
SALARIO SALARIO
-------------------------- -------------- ------------------ ---------------------- --------------------------------------------- ---------------------avg $2,030.26
sum $38,575.00
std 689,055.92
1.4
MANIPULACIN DE DATOS
En ocasiones se hace necesario, insertar informacin en algunas tablas, de la base de datos. Para
este fin se tiene el comando INSERT.
INSERT INTO nombre_de_tabla [(columna1, columna2...)]
VALUES (valor1, valor2...).
INSERT permite adicionar una nueva fila, a la tabla especificada; esto se puede hacer con todas
las columnas (colocando los valores de todas las columnas en el mismo orden de la tabla) o con
algunas columnas (colocando despus del nombre de la tabla, el nombre de las columnas en las
cuales se desea insertar la informacin y despus de VALUES, los valores que tendrn estas).

Ejemplo 1:
Insertar una nueva fila, (con todas sus columnas), a la tabla empleado.
SQL > INSERT INTO EMPLEADO
2 VALUES ('INGRID', 'SECRETARIA', 18000, 01);
Ejemplo 2:
Insertar una nueva fila, (con las columnas nombre y salario), a la tabla empleado.
SQL > INSERT INTO EMPLEADO (NOMBRE, SALARIO)
2 VALUES ('INGRID', 18000);
Ejemplo 3:
Insertar una nueva fila, (con las columnas nombre y fecha), a la tabla cumpleaos.
Nota: cumpleaos ser reemplazado por cumpleanos, para evitar problemas con SQLPLUS.
SQL > INSERT INTO CUMPLEANOS (NOMBRE, FECHA)
2 VALUES ('INGRID', TO_DATE('931802', 'YYDDMM'));
Ejemplo 4:
Insertar una o ms fila, a la tabla empleado usando las columnas nombre y salario, donde el
sistema, sea el que pida los valores de cada columna, gracias al uso de & para crear variables.
SQL > INSERT INTO EMPLEADO (NOMBRE, SUELDO)
2 VALUES (&NOMBRE, &SUELDO);
Ejemplo 5:
Insertar una o ms fila, a la tabla empleado usando las columnas nombre y salario tomando
datos de otra tabla.
SQL > INSERT INTO EMPLEADO (NOMBRE, SUELDO)
2 SELECT NOMBRE, SUELDO * 1.25 FROM EMPLEADO_VIEJO;
Imaginese el caso, que una vez impreso un reporte, hemos detectado un error en los datos del
mismo y por lo tanto deseamos corregirlo, es aqu donde entra en juego el comando UPDATE.
UPDATE nombre_de_la_tabla
SET columna1 = valor, columna2 = valor...
[WHERE condicin]
Ejemplo 1:
Aumentar el salario un 20% a todos los empleados del departamento 01.
SQL > UPDATE EMPLEADO
2 SET SALARIO = SALARIO+SALARIO*0.2
3 WHERE NUMDEPT = 01;
Ejemplo 2:

Aumentar el salario un porcentaje a todos los empleados, usando un porcentaje por

departamento.
SQL > UPDATE EMPLEADO
2 SET SALARIO = SALARIO + SALARIO * DECODE(NUMDEPT,01,0.2,02,0.3,.015)
Ejemplo 3:
Aumentar el salario con el 10 % del promedio de salarios de su departamento.
SQL > UPDATE EMPLEADO A SET SALARIO =
2 ( SELECT SALARIO+ AVG(SALARIO)*.10 FROM EMPLEADO B
3 WHERE B.NUMDEPT = A.NUMDEPT);
Para poder borrar una fila o un conjunto de filas se har uso del comando DELETE
DELETE FROM nombre_de_la_tabla
[WHERE condicin]
Ejemplo 1:
Eliminar los empleados del departamento 02
SQL > DELETE FROM EMPLEADO
Ejemplo 2:
Eliminar los empleados que tengan un salario mayor del promedio de salarios de su
departamento.
SQL > DELETE EMPLEADO A WHERE SALARIO >
2 ( SELECT AVG(B.SALARIO) FROM EMPLEADO B
3 WHERE B.NUMDEPT = A.NUMDEPT);
Transaccin
Se considera como una transaccin, todos aquellos cambios realizados a la base de datos, una
vez ejecutado el comando COMMIT.
COMMIT guarda en forma "permanente", todos los cambios realizados a la base de datos.
------------------ COMMIT
|
| INSERT...
|
| DELETE...
TRANSACCIN |
| UPDATE...
|
| INSERT...
|
------------------ COMMIT

La contra parte de COMMIT, es ROLLBACK. Esta instruccin ignora todos los cambios
realizados a la base de datos, excepto si previamente se ha realizado un COMMIT.
------------------ COMMIT
|
| INSERT...
TRANSACCION |
| DELETE...
|
| ---------------- ROLLBACK
|
TRANSACCION | UPDATE...
|
| INSERT...
|
------------------ COMMIT
Existe tambin una forma de ignorar, parcialmente los cambios realizados a la base de datos.
Esto se logra introduciendo marcas, que tienen como finalidad, informar al comando
ROLLBACK, hasta donde deben ser ignorados, los cambios efectuados a la base de datos. La
forma de realizar estas marcas, es por medio del comando SAVEPOINT.
------------------ COMMIT
|
| INSERT...
|
| SAVEPOINT A
|
| DELETE...
TRANSACCION |
| UPDATE...
|
| ROLLBACK TO SAVEPOINT A
|
| INSERT...
|
------------------ COMMIT
1.5
TABLAS Y VISTAS
Como crear una tabla?

El nombre de una tabla debe de cumplir con las siguientes reglas.
- Debe ser de 1, a mximo 30 caracteres y el primero debe ser alfabtico.
- Debe contener los caracteres:

A - Z,
a - z,
0 - 9,
subrayado (_)
$ y # (son smbolos legales pero pueden causar problemas).
- No deben ser palabras reservadas de SQL.
- No pueden tener el mismo nombre de los objetos usados por ORACLE.
Sintaxis:
CREATE TABLE [usuario.]nombre_de_la_tabla
({nombre_de_columna tipo | tabla_de_integridad}
[, {{nombre_de_columna tipo | tabla_de_integridad}]...)
STORAGE (Initial nK Next nK Pctincrease n Maxextents n Minextents n);
El "tipo", puede ser de tipo CHAR, DATE, LONG, NUMBER.
Reglas de integridad
PRIMARY KEY
Es la columna o conjunto de columnas, que permite la identificacin nica, de cada fila de la
tabla; llamadas claves primarias.
CHECK
Es la definicin de la regla del negocio, las cuales involucran columnas contra valores
constantes.
FOREIGN KEY
Es la columna o conjunto de ellas, que establecen una relacin con una clave primaria de otra
tabla. Esto indica, que para el conjunto de columnas, de la fila de la tabla "A", debe existir, el
mismo conjunto de columnas y valores en la tabla "B".
[NOT] NULL
Permite validar que la columna pueda tener o no, valores nulos, en otras palabras, si la columna
es mandatoria.
UNIQUE
Es la columna o conjunto de ellas, que permiten una identificacin nica alterna, de cada fila de
la tabla, llamadas claves secundarias o alternas.
REFERENCES
Es una clave fornea de una columna simple.
Reglas de STORAGE
Indica el almacenamiento con que trabajar la tabla que vaya a ser creada, basado en el tamao
de la extenciones o anexos de espacio (extents).

Initial Indica el espacio inicial de creacin de la tabla (Primer Extents)

Next Segundo extents a ser asignado a la tabla.
Pctincrease Porcentaje de incremento para entre los extents requeridos por la tabla
a partir del tercero.
Maxextents Es la cantidad mxima de extents que puede crecer una tabla.
Minextents Es la cantidad mnima necesaria de extents para poder crear la tabla.
Ejemplo 1:
Crear una tabla llamada EMPLEADO2, con las columnas:
- CODIGO
- NOMBRE
- CARGO
- CODJEFE
- SALARIO
- NUMDEPT
Caso Clave Primaria Simple, Clave foranea Simple
SQL > CREATE TABLE EMPLEADO2
2 (CODIGO NUMBER(4) PRIMARY KEY,
3 NOMBRE CHAR(10) CHECK(NOMBRE = UPPER(NOMBRE)),
4 CARGO CHAR(10),
5 CODJEFE NUMBER(4) REFERENCES EMPLEADO2 (CODIGO),
6 SALARIO NUMBER(7,2) CHECK(SALARIO <= 80000),
7 NUMDEPT NUMBER(2) NOT NULL REFERENCES DEPT (NUMDEPT));
Caso Clave Primaria Compuesta, Clave foranea Compuesta
2 (CODIGO NUMBER(4) NOT NULL,
3 NOMBRE CHAR(10) CHECK(NOMBRE = UPPER(NOMBRE)),
4 CARGO CHAR(10),
5 CODJEFE NUMBER(4) ,
6 SALARIO NUMBER(7,2) CHECK(SALARIO <= 80000),
7 NUMDEPT NUMBER(2) NOT NULL REFERENCES DEPT (NUMDEPT),
8 PRIMARY KEY(CODIGO,NUMDEPT),
9 FOREIGN KEY(CODJEFE,NUMDEPT) REFERENCES EMPLEADO2);
Ejemplo 2:
Crear una tabla llamada EMPLEADO3, basada en EMPLEADO2.
Los nombres de las columnas sern:
NOMBRE, SALARIO
2 AS SELECT NOMBRE, SALARIO
3 FROM EMPLEADO2


Como hacer modificaciones en una tabla?
La sentencia ALTER TABLE, permite alterar las siguiente definiciones de una tabla:
- Adicionar columnas o integridad.
- Modificar las definiciones de una columna (CHAR, NUMBER, NOT NULL, etc.).
- Borrar definiciones de integridad.
Sintaxis para adicionar:
ALTER TABLE nombre_de_la_tabla
ADD ({nombre_columna tipo | tabla integridad}
[, {nombre_columna tipo | tabla integridad}]...)
Ejemplo:
SQL > ALTER TABLE DEPARTAMENTO
2 ADD (CODJEFE NUMBER(4)
3 REFERENCES EMPLEADO(CDIGO) CONSTRAINT EMP_FK);
Sintaxis para modificar:
MODIFY({nombre_columna definicin_de_columna}
[, {nombre_columna definicin_de_columna}...)
Ejemplo:
SQL > ALTER TABLE EMPLEADO
2 MODIFY NOMBRE CHAR(20);
Sintaxis para borrar
DROP CONSTRAINT (nombre_de_integridad)
Ejemplo:
SQL > ALTER TABLE DEPARTAMENTO
2 DROP CONSTRAINT EMP_FK;
Como renombrar una tabla?
Usamos la sentencia RENAME
Sintaxis:
RENAME tabla_vieja
TO tabla_nueva
Como borrar una columna de una tabla?
En el caso de querer remover una columna de una tabla, debemos hacer uso de nuestra
imaginacin y conocimientos antes adquiridos.
Ejemplo:
Suponga que la tabla EMPLEADO2, posee las siguientes columnas:
- NOMBRE

- CARGO
- SALARIO
- NUMDEPT
Se pide eliminar la columna NUMDEPT
Se crea una nueva tabla a partir de la tabla EMPLEADO2
SQL > CREATE TABLE TEMPORAL (NOMBRE, CARGO, SALARIO)
2 AS SELECT NOMBRE, CARGO, SALARIO
3 FROM EMPLEADO2;
Se borra la tabla EMPLEADO2
SQL > DROP TABLE EMPLEADO2;
Se renombra la tabla TEMPORAL por EMPLEADO2
SQL > RENAME TEMPORAL
2 TO EMPLEADO2;
Como crear una vista?
La forma de crear una vista es la misma que se utiliza para crear una tabla, pero utilizando una
instruccin SELECT accesando columnas de una o varias tablas.
Sintaxis: CREATE VIEW nombre de la vista
AS SELECT clausula Select;
Ejemplo;
Crear una visin de los datos de la table empleado para el departamento 10
SQL > CREATE VIEW VISTA_EMP
2 AS SELECT NOMBRE, CARGO, SALARIO
3 FROM EMPLEADO
Ventajas de las vistas
- Seguridad (Permite dar acceso a partes de una tabla a otros usuario).
- Conveniencia (puede acortar la codificacin en un programa, ya que evita la realizacin de
instrucciones SELECT que se repiten).
- Perspectivas (Se puede visualizar pedazos de varias tablas). select numero from factura_cliente
order by numero desc
Cmo visualizar una vista?
La forma de visualizar una vista es la misma que se utiliza para visualizar una tabla. (Se utilizan
los mismos parmetros de la sentencia SELECT).
SQL > SELECT *
2 FROM VISTA_EMP;
Actualizacin de una tabla a travs de una vista
SQL > UPDATE VISTA_EMP
2 SET SALARIO = 20000

3 WHERE SALARIO = 15000;

Como se pudo observar en el ejemplo anterior, un usuario puede cambiar el contenido de una
tabla, a travs de una vista. En ocasiones es necesario evitar, que se modifiquen o inserten filas,
que luego no podrn ser visualizadas por medio de la sentencia SELECT. Con este objetivo se
utilizar la clusula WITH CHECK OPTION.
Ejemplo:
SQL > CREATE VIEW VISTA_EMP2
2 AS SELECT NOMBRE, CARGO
3 FROM EMPLEADO
5 WITH CHECK OPTION;
De esta manera cuando intentemos realizar una actualizacin no permitida tendremos lo
siguiente:
SQL > UPDATE VISTA_EMP2
2 SET NUMDEPT = 05
3 WHERE SALARIO > 30000;
ORA-014022: view WITH CHECK OPTION where-clause violation.
(Mensaje arrojado).
Este error se debe, a que la vista creada, slo permite visualizar a los empleados del
departamento 01. Si este cambio se hubiese efectuado, no se podra observar los cambios
realizados en la tabla, dando a pensar, que se elimin la informacin, cosa que sera falso.
Slo se pueden modificar valores sobre aquellas vistas que sean sobre una sola tabla y que no
involucren funciones de grupo, columnas artificiales 0u operadores.
Accesos a tablas y vistas
El DBA y los dueos de tablas son los nicos que pueden otorgar privilegios a otros usuarios
para que puedan visualizar, modificar o borrar, un objeto de la base de datos (tablas, vistas,
etc.). Estos privilegios se otorgan o quitan por medio del comando GRANT.
Sintaxis:
GRANT {privilegio_del_objeto [, privilegio_del_objeto] ... } | ALL [ PRIVILEGES]}
ON [usuario.]objeto
TO {usuario | PUBLIC } [, usuario]...
[WITH GRANT OPTION]
Los privilegios de los objetos son los siguientes:
- Para las tablas: ALTER, DELETE, INDEX, INSERT, REFERENCES, SELECT o UPDATE.
- Para las vistas: DELETE, INSERT, SELECT o UPDATE.
- Para las secuencias: ALTER o SELECT.
ALL PRIVILEGES: significa que el objeto tendr todos los privilegios.
ON: especifica el nombre de una tabla, vista o sinnimo, al cual se le van a otorgar los
privilegios.
TO: usuario o usuarios a los cuales se les estn dando los privilegios.

PUBLIC: son todos los usuarios que se encuentran en la base de datos y los que en un futuro se
presenten.
WITH GRANT OPTION: permite a un usuario, otorgar privilegios a otros usuarios, sobre los
objetos a los cuales tiene acceso.
Ejemplo 1:
Otorgar todos los privilegios de la tabla empleado, a todos los usuarios de la base de datos.
SQL > GRANT ALL
2 ON EMPLEADO
3 TO PUBLIC;
Ejemplo 2:
Otorgar el privilegio SELECT al usuario system, permitindole a este, otorgar dicho privilegio a
otros usuarios.
SQL > GRANT SELECT
2 ON EMPLEADO
3 TO SYSTEM
4 WITH GRANT OPTION;
Sinnimos:
Los sinnimos son nombres por medio de los cuales, se puede hacer referencia a una tabla o
vista. Estos se utilizan por razones de seguridad y conveniencia, teniendo las siguientes
ventajas:
- Referenciar una tabla o vista, sin tener que especificar el dueo de la misma.
- Referenciar una tabla o vista, sin tener que especificar la base de datos en donde la tabla o la
vista existe.
- Proveer otro nombre para la tabla.
Sintaxis para la creacin de un sinnimo:
CREATE [PUBLIC] SYNONYM [usuario.]sinnimo
FOR [usuario.]tabla_o_vista [@enlace_con_la_base_de_datos]
PUBLIC: indica que el sinnimo, podr ser utilizado por todos los usuarios. Por defecto slo
podr ser utilizado por el usuario que cre el sinnimo.
SYNONYM: nombre del sinnimo.
ENLACE_CON_LA_BASE_DE_DATOS: Cadena de caracteres que se utiliza para enlazar con
una base de datos remota.
Ejemplo:
SQL > CREATE SYNONYM TRABAJADOR
2 FOR PABLO.EMPLEADO;
SQL > SELECT *
2 FROM TRABAJADOR;

II.6.- INDICES Y GENERADORES DE SECUENCIAS

El acceso a los datos contenidos en las tablas, puede ser de dos formas:
- Bsqueda secuencial por toda la tabla.
- Bsqueda selectiva, a travs de un ndice.
Los ndices son estructuras opcionales, los cuales estn asociados a tablas, con la finalidad de
aumentar la velocidad de las consultas y evitar la duplicidad de filas. Cada tabla puede tener un
nmero ilimitado de ndices. La regla para escribir el nombre de un ndice, es similar al de una
tabla, pero es recomendable colocar como prefijo, la letra "I" a todo nombre de ndice.
Cuando crear un ndice?
Si Ud. anticipadamente sabe que se va a recuperar un poco menos del 15%, de las filas
contenidas en una gran tabla, cuyas columnas van a ser frecuentemente referenciadas por una
clusula WHERE, entonces Ud. deber de crear un ndice.
Caractersticas de las columnas a indexar.
- Las columnas deben ser frecuentemente referenciadas por la clusula WHERE.
- Todos sus valores deben ser nicos (el mejor caso).
- Ancho rango de valores.
- Muchos valores nulos o relativamente pocos valores.
Sintaxis:
CREATE [UNIQUE] INDEX ndice ON
tabla (columna [ASC | DESC] [, columna [ASC | DESC]] ...)}...
STORAGE (.... ... ... );
UNIQUE: indica que las columnas involucradas, deben contener valores nicos.
ndice: nombre del ndice a crear
tabla: nombre de una tabla existente, a partir de la cual se crear un ndice.
ASC / DESC: crea los ndices en forma ascendente o descendente.
columna: nombre de la columna por la cual se va a ordenar.
Nota: el nmero mximo de columnas concatenadas, que se puede tener en un ndice simple, es
de 16.
Ejemplo 1:
SQL > CREATE INDEX I_EMPLEADO
2 ON EMPLEADO(NOMBRE);
Ejemplo 2:
SQL > CREATE UNIQUE INDEX I_EMPLEADO
2 ON EMPLEADO(NOMBRE);
Cmo remover un ndice de la base de datos?
Sintaxis: DROP INDEX nombre_del_indice
Ejemplo:

SQL > DROP INDEX I_EMPLEADO;

Validacin de ndices:
Los problemas de hardware, pueden en ocasiones corromper los ndices de una tabla. Para
verificar que los ndices no estn corrompidos se hace uso de VALIDATE INDEX.
Sintaxis:
VALIDATE INDEX nombre_del_indice
Ejemplo:
SQL > VALIDATE INDEX I_EMPLEADO;
Index validated. (Mensaje arrogado).
Secuencias
Las secuencias son estructuras opcionales, su finalidad es generar nmeros enteros nicos, los
cuales pueden ser utilizados por mltiples usuarios. Una utilidad que se le puede dar a una
secuencia, es la de generar automticamente los nmeros de una clave primaria. La regla para
escribir el nombre de una secuencia, es similar al de una tabla, pero es recomendable colocar
como prefijo, la letra "S" a todo nombre de secuencia.
Sintaxis:
CREATE SEQUENCE secuencia
[INCREMENT BY {1|n}]
[START WITH n]
[ {MAXVALUE n | NOMAXVALUE}]
[ {MINVALUE n | NOMINVALUE}]...
secuencia: nombre de la secuencia.
INCREMENT BY: determina el intervalo de una secuencia numrica.
START WITH: es el nmero con el cual se comienza la secuencia. Por defecto cuando es
ascendente ser igual a MINVALUE y cuando es descendente ser igual a MAXVALUE.
MAXVALUE / NOMAXVALUE: mnimo valor de la secuencia a generar. Por defecto es uno.
MINVALUE / NOMINVALUE: mximo valor de la secuencia a generar. Por defecto es 10e27 1.
Ejemplo:
SQL > CREATE SEQUENCE S_DEPARTAMENTOS START WITH 200;
SQL > INSERT INTO DEPARTAMENTOS(NUMDEPT, DEPARTAMENTO)
2 VALUES (S_DEPARTAMENTOS.NEXTVAL, 'INFORMTICA');
NEXTVAL: es un nombre de seudo-columna, el cual es usado para generar un nmero de
secuencias especificas.
CURVAL: es un nombre de seudo-columna, el cual es usado para obtener el valor de la
secuencia en curso.
Cmo borrar una secuencia?

Sintaxis:
DROP SEQUENCE nombre_de_secuencia
Ejemplo:
SQL > DROP SEQUENCE S_DEPARTAMENTOS;
II.7.- CONSULTAS AVANZADAS DE ORACLE
JOIN: es la forma del comando SELECT para combinar filas de dos o ms tablas.
Tipos de JOIN
- Simple
- Equijoin (usando una condicin de igualdad).
- non-equijoin (usando varias condicin de igualdad otras).
- Externo
- A si mismo.
Join simple
Retorna filas de dos o ms tablas combinadas, a travs de una condicin de igualdad.
Sintaxis:
SELECT [tabla.]columna, [tabla.]columna...
FROM tabla1, tabla2...
WHERE [tabla1.]columna = [tabla2.]columna
Ejemplo (caso equijoin):
SQL > SELECT NOMBRE, SALARIO, EMPLEADO.NUMDEPT
2 FROM EMPLEADO, DEPARTAMENTO
3 WHERE EMPLEADO.NUMDEPT = DEPARTAMENTO.NUMDEPT;
Ejemplo (caso non-equijoin):
SQL > SELECT NOMBRE, SALARIO, EMPLEADO.NUMDEPT
2 FROM EMPLEADO, DEPARTAMENTO
3 WHERE EMPLEADO.NUMDEPT = DEPARTAMENTO.NUMDEPT
4 AND SALARIO BETWEEN 10000 AND 20000;
Join externo
Retorna el contenido de un join simple, ms, el contenido de las filas de una tabla que no hallan
podido ser combinado en la otra tabla.
Sintaxis:
WHERE [tabla1.]columna CONDICION [tabla2.]columna(+) o puede ser

WHERE [tabla1.]columna(+) CONDICION [tabla2.]columna

Ejemplo:
Mostrar un join de las tablas EMPLEADO y DEPARTAMENTOS. El campo de combinacin
es NUMDEPT. Si existe alguna fila del campo departamento que no haga una combinacin con
la tabla EMPLEADO, deber ser mostrada.
SQL > SELECT NOMBRE, SALARIO, DEPARTAMENTOS.NUMDEPT
2 FROM EMPLEADO, DEPARTAMENTOS
3 WHERE EMPLEADO.NUMDEPT(+) = DEPARTAMENTOS.DEPTNO;
Join a si mismo
Realiza una combinacin en una misma tabla.
Ejemplo:
Obtener una lista de empleados, en la cual se especifique el nombre de su jefe inmediato.
SQL > SELECT TRABAJADOR.NOMBRE, JEFE.NOMBRE
2 FROM EMPLEADO2 TRABAJADOR, EMPLEADO2 JEFE
3 WHERE TRABAJADOR.CODIGO = JEFE.CODJEFE;
Sub-query (sub-consulta).
Las sub-consultas seleccionan filas de una tabla con una condicin que depende de valores de
otra tabla.
Las sub-consultas deben aparecer en la clusula WHERE de una de las siguientes sentencias:
- SELECT
- INSERT
- UPDATE
- DELETE
Sintaxis:
SELECT ...
FROM ...
WHERE ...
(SELECT ...
FROM ...
WHERE ...);
Sub-consultas de filas simples
Las sub-consultas de filas simples, retornarn un valor para completar la condicin de la
clusula WHERE.
Ejemplo:
SQL > SELECT *
2 FROM DEPARTAMENTO

3 WHERE NUMDEPT = (SELECT MAX(NUMDEPT)

4 FROM EMPLEADO
5 WHERE CARGO = 'SECRETARIA');
Sub-consultas de filas mltiples
Las sub-consultas de filas mltiples, retornan ms de un valor para completar la condicin de la
clusula WHERE.
Ejemplo:
SQL > SELECT NOMBRE, CARGO
2 FROM EMPLEADO
3 WHERE NUMDEPT IN (SELECT NUMDEPT
4 FROM EMPLEADO
5 GROUP BY NUMDEPT HAVING COUNT(*) > 2 )
6 AND SALARIO > (SELECT AVG(SALARIO)
7 FROM EMPLEADO);
1.6
OPTIMIZACIN DE INSTRUCCIONES DE MANIPULACIN DE DATOS EN

SQL
Para escribir instrucciones optimas, se debe tener conocimiento del funcionamiento del
optimizador de SQL. El optimizador realiza un plan de ejecucin, el cual considera que ser
eficiente basado en factores tales como:
a.- Reglas de Construccin de la Instruccin
b.- Utilizacin de Indices
En la Versin 6 del Manejador de Base de Datos no se consideran los siguientes factores:
- Cantidad de filas existentes en las tablas
- Distribucin fsica de los datos en la tabla
- Distribucin de los valores de las claves en los ndices
Reglas de construccin:
- El orden de las tablas en la clusula FROM
Influye para la evaluacin de la tabla base a usarse al construir JOINS. Se recomienda que de
izquierda a derecha se coloquen las tablas de mayor volumen de datos accesados a la de menor
volumen.
Ejemplo:
EMPLEADOS tiene 5000 filas, DEPARTAMENTO tiene 20 filas,
FAMILIARES tiene 20000 filas
FROM FAMILIARES, EMPLEADOS, DEPARTAMENTO
Por cada registro de Departamento va a ir a Empleados, luego a familiares
La Evaluacin que realiza el manejador es de abajo hacia arriba y de derecha a izquierda,

lo optimo es ir de menos filas enlazando bsquedas que retornen menos filas.

.- Columnas mencionadas en la clusula WHERE
Reducen la cantidad de filas retornadas por instruccin del total de filas de la tabla, permitiendo
ademas el uso de ndices.
Ejemplo:
WHERE nombre = 'MIGUEL'
and Salario > 10000
and Codigo_departamento = 10
Buscara todos los departamentos 10 cuyo salario sea mayor de 10000 y el nombre sea MIGUEL.
.- Columnas mencionadas seleccionadas en la clusula SELECT
Reducen la cantidad de valores por fila retornados de la tabla, si las columnas mencionadas
existen en los ndices, la instruccin no necesitara ir a los datos. El uso del (*) como indicador
de seleccin de todas las columnas es menos eficiente que indicar los nombres de las columnas
y el orden en que fueron creadas.
Ejemplo:
SELECT numero_empleado, codigo_departamento
ms eficiente que
SELECT nombre, numero_empleado, codigo_departamento, salario, apellido
ms eficiente que
SELECT *
Nombres de Tablas y Columnas
Para obtener mejores tiempos de interpretacin y validacin sintctica (PARSE), es preferible
usar nombres cortos; esto no quiere decir nombre codificados, al contrario, indica usar
abreviaciones o conjuncin con palabras.
Ejemplo:
SELECT numero_del_empleado, codigo_del_departamento, primer_nombre,
primer_apellido
FROM empleados_compania
Menos eficiente que
SELECT nro_emp, cod_depto, nombre, apellido FROM empleados
No quiere decir que
SELECT nro_e, c_dep, nom, ape FROM C00101_emp
Uso de alias y preposiciones
Al construir JOINS con muchas tablas y nombres de columnas o tablas iguales es necesario y
recomendable el uso de alias o preposiciones. Esta regla permite utilizar menos caracteres en el
texto de la instruccin, lo que involucra menos tiempo de interpretacin (PARSE).

Ejemplo:
SELECT a.codigo_departamento, b.nombre_departamento, a.nombre empleado
FROM empleados a, departamentos b
WHERE a.codigo_departamento = b.codigo_departamento
Ms eficiente que
SELECT empleados.codigo_departamento,
departamentos.nombre_departamento,
empleados.nombre empleado
FROM empleados a, departamentos b
WHERE empleados.codigo_departamento =
departamentos.codigo_departamento
Ms eficiente que
SELECT a.codigo_departamento, b.nombre_departamento, c.nombre jefe,
a.nombre empleado
FROM empleados a, empleados c, departamentos b
WHERE a.nro_jefe = c.nro_empleado
AND a.codigo_departamento = b.codigo_departamento
El uso de parntesis para clarificar los predicados
Al construir columnas con funciones agrupadas o realizar muchas evaluaciones WHERE que
involucren muchos operandos, los parntesis facilitan al optimizador la interpretacin de una
instruccin.
Ejemplo:
WHERE numero_empleado = 10 or
numero_empleado = 20 and codigo_departamento = 10 or
salario > 10000 and codigo_departamento = 20
Seria mejor si
WHERE numero_empleado = 10 or
(numero_empleado = 20 and codigo_departamento = 10) or
(salario > 10000 and codigo_departamento = 20)
Construccin de las tablas e Indices
Orden de las Columnas al construir las tablas
Las columnas con mayor acceso deben ser las primeras, tales como Claves Primarias, Claves
Alternas, Claves Forneas; si existe alguna columna que acepte valores nulos debe ir de ltima.
Las columnas que se modifican mucho deben tener precedencia a las de valores nulos.
La Columna con formato LONG debe ser la ltima.
Ejemplo:
CREATE TABLE emp (nro_emp number(4) not null PRIMARY KEY,
cod_depto number(2) not null REFERENCE depto,

nombre char(30) not null,

apellido char(30) not null,
salario number(12,2) not null,
direccion char(90) not null,
nro_jefe number(4) REFERENCE emp,
comision number(12,2),
bonificacion number(12,2),
fotografia long raw);
Orden de las Columnas al construir ndices
Se construirn ndices principalmente a la clave primaria y clave alterna para conservar la
unicidad. Adicionalmente a las claves forneas para mejorar los JOINS y aquellas columnas con
mucho acceso a travs de clusulas WHERE.
Al construir Indices compuestos se debe tomar en cuenta lo siguiente:
- La prioridad de las columnas debe venir dado de las columnas con mayor cantidad
de valores reales a la de menor.
- Las columnas de mayor acceso deben preceder a las de menor acceso
- Columnas con Valores Numricos preceden a la de caracteres y estas a su vez a las de fechas.
- Debe tomarse en cuenta el orden de las columnas en la tabla.
Ejemplo:
CREATE UNIQUE INDEX i_emp1 ON emp (nro_emp);
CREATE INDEX i_emp2 ON emp (nombre, apellido);
CREATE INDEX i_emp3 ON emp (cod_deptno, salario)
CREATE INDEX i_emp4 ON emp (salario, comision)
Ms ptimos que
CREATE INDEX i_emp1 ON emp (nro_emp);
CREATE INDEX i_emp2 ON emp (apellido, nombre);
CREATE INDEX i_emp3 ON emp (salario, cod_deptno)
CREATE INDEX i_emp4 ON emp (comision, salario)
Parmetros de Almacenamiento
La forma en que se almacenaran los datos influir en el rendimiento de las instrucciones, por lo
tanto hay que prevenir y planificar un buen almacenamiento.
Lo principal es conocer la cantidad de filas que va almacenar una tabla y en base a esto la
cantidad de bytes a reservar para los datos, evitando crecimientos descontrolados, fraccionados
y dispersos, tratando de mantener los datos en espacios continuos y con privilegios de acceso
rpido (Discos ms rpidos). Estimar crecimientos y si es posible reservar el espacio con
anterioridad.
Determinar los grados de volatibilidad y actualizacin de los datos, para as poder sacar mejor
provecho de los bloques de datos. (PCTUSED y PCTFREE).

Utilizacin de Indices
El uso de ndices es ineficiente, al punto de no crearlos para los siguientes casos
- Tablas con menos de 5 bloques de datos
- Columnas cuyo porcentaje de valores iguales sea mayor al 20% del total de filas de la tabla.
- Columnas cuyo porcentaje de valores nulos sea muy alto
- Columnas cuyos valores sean transformados durante el acceso de la instruccin. La columna
tiene formato fecha, pero al realizar el acceso se transformo a caracter.
Ejemplo:
WHERE to_char(fecha_ingreso, 'MM') = '01'
WHERE nro_emp + 100 = 101
WHERE nombre || apellido like 'GERARDO%ARAQUE%'
Ineficiente al lado de
WHERE fecha_ingreso between to_date('01', 'MM')
and last_day(to_date('01','MM'))
WHERE nro_emp = 101 -100
WHERE nombre like 'GERARDO%ARAQUE%' or
apellido like 'GERARDO%ARAQUE%' or
(nombre like 'GERARDO%' and apellido like '%ARAQUE%')
Columnas con muchas actualizaciones de los valores
Las Actualizaciones sern lentas si existe un ndice, pero si el volumen de acceso sobre este
ndice es superior y es bien aprovechado se deben pesar, que es ms importante actualizaciones
rpidas o lecturas rpidas.
Ejemplo:
Una empresa de servicios de personal, ubica grupos de trabajo en alrededor de 1000 empresas y
tiene 10000 empleados.
UPDATE emp set empresa_sirve = 10
where grupo_trabajo = 'O';
a la semana
UPDATE emp set empresa_sirve = 41
where grupo_trabajo = 'O';
Comparado con accesos continuos
SELECT nombre FROM emp
WHERE empresa_sirce = 41;
SELECT nombre FROM emp
WHERE empresa_sirce = 11;
- Que ndices sern usados cuando existen varios ndices
Los ndices sern usados segn su especificacin en la clusula WHERE y al peso que tenga la
evaluacin que se este realizando.

PESOS DE LAS EVALUACIONES

Rango Evaluacin de Acceso
1.- Acceso por ROWID
2.- Uso completo de una Indice nico Compuesta mediante una igualdad a una expresin.
3.- Uso de una Indice nico simple mediante una igualdad una expresin.
4.- Uso completo de una Clave de Enlace de un CLUSTER mediante una igualdad con otra
Clave de Enlace de otra tabla del mismo CLUSTER.
5.- Uso completo de una Clave de Enlace de un CLUSTER mediante una igualdad una
expresin.
6.- Uso completo de un ndice no nico compuesto mediante una igualdad a una expresin.
7.- Uso completo de un ndice no nico mediante una igualdad a una expresin
8.- Un ndice compuesto usado mediante rango evaluativos de bsqueda limitada de las
primeras columnas o la primer columna igualdad a una expresin y el resto o un ndice simple
usando (like 'caracteres%' , between ).
9.- Un ndice compuesto usado mediante rango evaluativos de bsqueda ilimitada de las
primeras columnas usando ( >= , > , < , <= , like '%caracteres%')
Si existen durante la misma evaluacin ndices con el mismo rango y son ndices simples, sern
usados todos los del menor rango.
Uso de ndices en JOIN
Para el uso de un ndice en un JOIN el optimizador va a considerar el predicado de enlace de las
tablas, evaluando de cada lado del join cuales ndices tienen menor rango, si de ambos lados es
el mismo rango tendr precedencia la posicin de la tabla en la clusula FROM. Hay que tener
en cuenta en el predicado de join solo se usaran ndices de un lado del JOIN. Fuera del
Predicado de JOIN los ndices sern evaluados para la tabla que no haya usado indices.
Lo principal en un JOIN de muchas tablas es determinar cual debe ser la ruta de acceso a los
datos.
Ejemplo:
La tabla emp tiene tres ndices
nico i_emp1 (nro_emp) i_emp2 (cod_depto) i_emp3(nombre, apellido)
La tabla depto tiene un ndice
nico i_dep1 (cod_depto)
La tabla familiares tiene dos ndices
nico i_fam1 (nro_emp, cedula) i_fam2 (cedula)

CAPTULO 2: INTRODUCCIN A PL/SQL

2.1
QU ES PL/SQL?
PL/SQL provee una manera muy cmoda de relacionar los conceptos de bases de datos y
manejarlos mediante ciertas estructuras de control, dentro del contexto de una herramienta
netamente de programacin.
Su utilizacin es dentro del administrador de bases de datos Oracle y sus principales
caractersticas son la posibilidad que brinda de utilizar sentencias SQL para manipular datos
en Oracle y sentencias de control de flujo para organizar esta manipulacin de datos.
Dentro del lenguaje, es posible declarar constantes y variables, definir procedimientos y
funciones y atrapar errores en tiempo de ejecucin. As visto, PL/SQL combina la el poder
de la manipulacin de datos, con SQL, y las facilidades del procesamiento de los mismos, tal
como en los ms modernos lenguajes de programacin.
2.2
ESTRUCTURAS DE BLOQUE
PL/SQL es un lenguaje estructurado en bloques, lo que quiere decir que la unidad bsica de
codificacin son bloques lgicos, los que a su vez pueden contener otros sub-bloques dentro
de ellos, con las mismas caractersticas.
Un bloque (o sub-bloque) permite agrupar en forma lgica un grupo de sentencias. De esta
manera se pueden efectuar declaraciones de variables que slo tendrn validez en los
bloques donde stas se definan.
Un bloque PL/SQL tiene tres partes: una seccin de declaracin, una seccin de ejecucin y
otra de manejo de excepciones. Slo el bloque de ejecucin es obligatorio en un programa
PL/SQL.
Es posible anidar sub-bloques en la seccin ejecutable y de excepciones, pero no en la
seccin de declaraciones.

Figura 2-1: Estructura de bloques de un programa PL/SQL
2.3
VARIABLES Y CONSTANTES
PL/SQL permite declarar constantes y variables para ser utilizadas en cualquier expresin
dentro de un programa. La nica condicin exigida por PL/SQL es que cada variable (o
constante) debe estar declarada antes de ser utilizada en una expresin.
Las variables pueden corresponder a cualquier tipo de dato de SQL, tal como char, date o
number, o algn tipo de PL/SQL, como boolean o binary_integer.
Por ejemplo, si desea declarar una variable llamada part_no que almacene cuatro dgitos
numricos y otra variable in_stock de tipo booleano, es decir, que almacene solamente los
valores True o False, la declaracin se vera como sigue:
part_no
number(4) ;
in_stock
boolean ;
Cmo asignar valores a variables
Es posible asignar valores a las variables de dos formas. La primera utiliza el operador :=.
La variable se ubica al lado izquierdo y la expresin al lado derecho del smbolo.
Por ejemplo:
tax := price * tax_rate ;
bonus := current_salary * 0.10 ;
amount := TO_NUMBER(SUBSTR(750 dlares, 1, 3)) ;
valid := False ;
La segunda forma de asignar valores a variables es obtener valores directamente desde la
base de datos, como en:
SELECT sal * 0.10 INTO bonus FROM emp WHERE empno = emp_id ;
Declaracin de Constantes
En la declaracin de una constante (muy similar a la de una variable), se debe incorporar la
palabra reservada constant e inmediatamente asignar el valor deseado. En adelante, no se
permitirn reasignaciones de valores para aquella constante que ya ha sido definida.
Ejemplo: credit_limit CONSTANT real := 5000.00 ;
2.4
CURSORES
Los cursores son reas de trabajo que permiten ejecutar sentencias SQL y procesar la
informacin obtenida de ellos.
Hay dos tipos de cursores: implcitos y explcitos. PL/SQL declara implcitamente un cursor

para todas las sentencias de manipulacin de datos, incluyendo las consultas que retornan
slo una fila. Para consultas que devuelven ms de una fila, es posible declarar
explcitamente un cursor que procese las filas en forma individual.
Por ejemplo:
DECLARE
CURSOR curs_01 IS
SELECT empno, ename, job FROM emp WHERE deptno=20;
El conjunto de filas retornado se denomina set de resultados. Su tamao est determinado

por el nmero de filas que calzan con el criterio de seleccin de la query que implementa el
cursor. Las filas son procesadas de a una cada vez.
En el captulo dedicado exclusivamente a estos componentes del lenguaje, se detallarn las
caractersticas de las diferentes modalidades de utilizacin de los cursores.
Figura 2-2: Recuperacin de filas a travs de un cursor
2.5
MANEJO DE ERRORES
PL/SQL provee una fcil manera de detectar y procesar ciertas condiciones de error
predefinidas (o definidas por el usuario), llamadas excepciones.
Cuando ocurre un error se procesa una excepcin, esto es, se detiene la ejecucin normal del
programa y se transfiere el control a un segmento especial del programa que tiene por objeto
manejar estas situaciones excepcionales. Estas rutinas que se codifican en forma separada se

conocen con el nombre de exception handlers.

Las excepciones predefinidas son gatilladas automticamente por el sistema cuando ocurre
un error de cierta naturaleza. Adems, es posible alcanzar excepciones definidas con el
usuario, simplemente haciendo un llamado a stas utilizando la sentencia raise.
2.6
SUBPROGRAMAS
En PL/SQL existen dos tipos de subprogramas, llamados procedimientos y funciones, los

que pueden manejar parmetros de entrada y de salida. Un subprograma es un programa en
miniatura, que comienza con un encabezado, una seccin opcional de declaraciones, una
seccin de ejecucin y una seccin opcional de manejo de excepciones, como cualquier otro
programa de PL/SQL.
2.7
PAQUETES
Es posible almacenar lgicamente un conjunto de tipos de datos relacionados, variables,

cursores e incluso subprogramas dentro de un paquete. Cada paquete involucra la definicin
y tratamiento de todos los elementos recin mencionados.
Los paquetes se descomponen en dos partes: una especificacin y un cuerpo.
La especificacin (package specification) es idntica a una seccin de declaracin de
aplicaciones. En esta especie de encabezado es posible declarar tipos, constantes, variables,
excepciones, cursores y subprogramas disponibles para su uso en el cuerpo del paquete. De
esta manera, el cuerpo (package body) define la implementacin de esos subprogramas
declarados en el apartado anterior.
Ejemplo de uso de paquetes:
CREATE PACKAGE emp_actions as
-- package specification
PROCEDURE hire_employee (empno NUMBER, ename CHAR, ) ;

PROCEDURE fire_employee (empid NUMBER) ;
END emp_actions ;

CREATE PACKAGE BODY emp_actions AS
-- package body
PROCEDURE hire_employee (empno NUMBER, ename CHAR, ) IS

BEGIN
INSERT INTO emp VALUES (empno, ename, );
END hire_employee;
PROCEDURE fire_employee (emp_id NUMBER) IS
BEGIN
DELETE FROM emp WHERE empno = emp_id;
END fire_employee;
END emp_actions;
Los paquetes pueden ser compilados y almacenados en una base de datos Oracle y su
contenido puede ser compartido por varias aplicaciones. Cuando un paquete es llamado para
su ejecucin, ste se almacena completamente en memoria la primera vez. Las siguientes
llamadas no requieren efectuar este procedimiento cada vez y por esto aumentan la eficiencia
de los programas.
2.8
VENTAJAS EN LA UTILIZACIN DE PL/SQL
PL/SQL es un lenguaje de procesamiento de transacciones completamente portable y con un

alto rendimiento, que proporciona las siguientes ventajas al ser utilizado:
Soporte para SQL
Soporte para la programacin orientada a objetos
Mejor rendimiento
Alta productividad
Completa portabilidad
Integracin con Oracle garantizada
Seguridad
Soporte para SQL
SQL se ha convertido en el lenguaje estndar de bases de datos por su flexibilidad de uso y

facilidad de aprenderlo. Unos pocos comandos permiten la fcil manipulacin de

prcticamente toda la informacin almacenada en una base de datos.
SQL es no-procedural, lo cual significa que es Oracle quien se preocupar de cmo ejecutar
de la mejor manera un requerimiento sealado en una sentencia SQL. No es necesaria la
conexin entre varias sentencias porque Oracle las ejecuta de a una a la vez.
PL/SQL le permite a usted una completa manipulacin de los datos almacenados en una base
Oracle, proporciona comandos de control de transacciones y permite utilizar las funciones de
SQL, operadores y pseudocolumnas. As, usted puede manipular los datos en Oracle de una
manera flexible y segura. Adems, PL/SQL soporta tipos de datos de SQL, lo que reduce la
necesidad de convertir los datos al pasar de una a otra aplicacin.
PL/SQL tambin soporta SQL dinmico, una avanzada tcnica de programacin que
convierte a sus aplicaciones en ms flexibles y verstiles.
Soporte para Programacin Orientada a Objetos

Los objetos se han convertido en una herramienta ideal para modelar situaciones de la vida
real. Con su utilizacin es posible reducir el costo y tiempo de construccin de aplicaciones
complejas. Otra ventaja es que utilizando una metodologa de este tipo es posible mantener
diferentes equipos de programadores construyendo aplicaciones basadas en el mismo grupo
de objetos.
Permitir el encapsulamiento del cdigo en bloques es el primer paso para la implementacin
de mtodos asociados a diferentes tipos de objetos construidos tambin con PL/SQL.
Mejor rendimiento
Sin PL/SQL, Oracle tendra que procesar las instrucciones una a una. Cada llamada
producira un overhead considerable, sobre todo si consideramos que estas consultas viajan a
travs de la red.
Por el contrario, con PL/SQL, un bloque completo de sentencias puede ser enviado cada vez
a Oracle, lo que reduce drsticamente la intensidad de comunicacin con la base de datos.
Los procedimientos almacenados escritos con PL/SQL son compilados una vez y
almacenados en formato ejecutable, lo que produce que las llamadas sean ms rpidas y
eficientes. Adems, ya que los procedimientos almacenados se ejecutan en el propio
servidor, el trfico por la red se reduce a la simple llamada y el envo de los parmetros
necesarios para su ejecucin.

El cdigo ejecutable se almacena en cach y se comparte a todos los usuarios, redundando en

mnimos requerimientos de memoria y disminuyendo el overhead al mnimo.
Alta productividad
Si se decide utilizar otros productos de Oracle como Oracle Forms y Oracle Reports, es
posible integrar bloques completos de PL/SQL en un trigger de Oracle Forms, debido a que
PL/SQL es el mismo en todos los ambientes.
Completa portabilidad
Las aplicaciones escritas con PL/SQL son portables a cualquier sistema operativo y
plataforma en la cual se encuentre corriendo Oracle. En otras palabras, PL/SQL corre
dondequiera que se encuentre corriendo Oracle tambin. Esto significa que se pueden
codificar libreras que podrn ser reutilizadas en otros ambientes.

Integracin con Oracle

PL/SQL y los lenguajes SQL en general se encuentran perfectamente integrados. PL/SQL
soporta todos los tipos de datos de SQL. Los atributos %TYPE y %ROWTYPE integran
PL/SQL con SQL, permitiendo la declaracin de variables basado en tipos de columnas de
tablas de la base de datos. Lo anterior provee independencia de los datos, reduce costos de
mantencin y permite a los programas adaptarse a los cambios en la base de datos para
cumplir con las nuevas necesidades del negocio.
Seguridad
Los procedimientos almacenados construidos con PL/SQL habilitan la divisin de la lgica
del cliente con la del servidor. De esta manera, se previene que se efecte manipulacin de
los datos desde el cliente. Adems, se puede restringir el acceso a los datos de Oracle,
permitiendo a los usuarios la ejecucin de los procedimientos almacenados para los cuales
tengan privilegios solamente.

CAPTULO 3: FUNDAMENTOS DEL LENGUAJE
Este captulo se centra en pequeos aspectos del lenguaje, tal como el grupo de caracteres
vlidos, las palabras reservadas, signos de puntuacin y otras reglas de formacin de
sentencias que es preciso conocer antes de empezar a trabajar con el resto de
funcionalidades.
3.1
SET DE CARACTERES Y UNIDADES LXICAS
Las instrucciones del lenguaje deben ser escritas utilizando un grupo de caracteres vlidos.
PL/SQL no es sensible a maysculas o minsculas. El grupo de caracteres incluye los
siguientes:
Letras maysculas y minsculas de la A a la Z
Nmeros del 0 al 9
Los smbolos ( ) + - * / < > = ! ~ ^ ; . @ % , # $ & _ | { } ? [ ]
Tabuladores, espacios y saltos de carro
Una lnea de texto en un programa contiene lo que se conoce como unidades lxicas, los que
se clasifican como sigue:
Delimitadores (smbolos simples y compuestos)
Identificadores (incluye palabras reservadas)
Literales
Comentarios
Por ejemplo en la instruccin:
bonus := salary * 0.10; -- clculo del bono
se observan las siguientes unidades lxicas:
Los identificadores bonus y salary
El smbolo compuesto :=
Los smbolos simples * y ;
El literal numrico 0.10
El comentario clculo del bono

Para asegurar la fcil comprensin del cdigo se pueden aadir espacios entre identificadores
o smbolos. Tambin es una buena prctica utilizar saltos de lnea e indentaciones para
permitir una mejor legibilidad.
Ejemplo:
IF x>y THEN max := x; ELSE max := y; END IF;
Puede reescribirse de la siguiente manera para mejorar el aspecto y legibilidad:
IF x > y THEN
max := x;
ELSE
max := y;
END IF;
3.2
DELIMITADORES E IDENTIFICADORES
Un delimitador es un smbolo simple o compuesto que tiene un significado especial dentro

de PL/SQL. Por ejemplo, es posible utilizar delimitadores para representar operaciones
aritmticas, por ejemplo:
Smbolo
+
%
.
/
(
)
:
,
*
=
<
>
@
;
-
Significado
operador de suma
indicador de atributo
delimitador de caracteres
selector de componente
operador de divisin
expresin o delimitador de lista
expresin o delimitador de lista
indicador de variable host
separador de tems
operador de multiplicacin
delimitador de un identificador entre comillas
operador relacional
operador relacional
operador relacional
indicador de acceso remoto
terminador de sentencias
negacin u operador de substraccin
Los delimitadores compuestos consisten de dos caracteres, como por ejemplo:

Smbolo
:=
=>
||
**
<<
>>
/*
*/
..
<>
!=
^=
<=
>=
--
Significado
operador de asignacin
operador de asociacin
operador de concatenacin
operador de exponenciacin
comienzo de un rtulo
fin de un rtulo
comienzo de un comentario de varias lneas
fin de un comentario de varias lneas
operador de rango
operador relacional
operador relacional
operador relacional
operador relacional
operador relacional
comentario en una lnea
Los identificadores incluyen constantes, variables, excepciones, cursores, subprogramas y

paquetes. Un identificador se forma de una letra, seguida opcionalmente de otras letras,
nmeros, signo de moneda, underscore y otros signos numricos.
La longitud de un identificador no puede exceder los 30 caracteres. Se recomienda que los
nombres de los identificadores utilizados sean descriptivos.
Algunos identificadores especiales, llamados palabras reservadas, tienen un especial
significado sintctico en PL/SQL y no pueden ser redefinidos. Son palabras reservadas, por
ejemplo, BEGIN, END, ROLLBACK, etc.
3.3
TIPOS DE DATOS Y CONVERSIONES
Cada constante y variable posee un tipo de dato el cual especifica su forma de

almacenamiento, restricciones y rango de valores vlidos. Con PL/SQL se proveen diferentes
tipos de datos predefinidos. Un tipo escalar no tiene componentes internas; un tipo
compuesto tiene otras componentes internas que pueden ser manipuladas individualmente.
Un tipo de referencia almacena valores, llamados punteros, que designan a otros elementos
de programa. Un tipo lob (large object) especifica la ubicacin de un tipo especial de datos
que se almacenan de manera diferente.
En la figura 3-1 se muestran los diferentes tipos de datos predefinidos y disponibles para ser
utilizados.

Figura 3-1:
Tipos de datos de PL/SQL
Conversiones
Algunas veces se hace necesario convertir un valor desde un tipo de dato a otro. En PL/SQL
se aceptan las conversiones de datos implcitas y explcitas.
Una conversin explcita es aquella que se efecta utilizando las funciones predefinidas. Por
ejemplo, para convertir un valor de carcter a fecha o nmero se utiliza TO_DATE o
TO_NUMBER.
Existe una cantidad limitada de funciones de conversin, que implementan esta caracterstica
de conversin explcita.
Cuando se hace necesario, PL/SQL puede convertir un tipo de dato a otro en forma implcita.
Esto significa que la interpretacin que se dar a algn dato ser el que mejor se adecue
dependiendo del contexto en que se encuentre. Tampoco significa que todas las conversiones
son permitidas. Algunos ejemplos de conversin implcita ms comunes se dan cuando
variables de tipo char se operan matemticamente para obtener un resultado numrico.
Si PL/SQL no puede decidir a qu tipos de dato de destino puede convertir una variable se
generar un error de compilacin.
Tabla de conversiones implcitas

Hasta
Desde
BIN_INT
CHAR
DATE
LONG
NUMBER
PLS_INT
RAW
ROWID
VARCHAR2
BIN_INT
CHAR
DATE
X
X
X
X
X
X
X
X
X
X
X
X
LONG
X
X
X
NUMBER
X
X
PLS_INT
X
X
RAW
ROWID
X
X
X
X
X
VARCHAR2
X
X
X
X
X
X
X
X
Uso de %TYPE
El atributo %TYPE define el tipo de una variable utilizando una definicin previa de otra
variable o columna de la base de datos.
Ejemplo:
DECLARE
credito
REAL(7,2);
debito
credito%TYPE;
Tambin se podra declarar una variable siguiendo el tipo de un campo de alguna tabla,
como por ejemplo en:
debito
cuenta.debe%TYPE;
La ventaja de esta ltima forma es que no es necesario conocer el tipo de dato del campo
debe de la tabla emp, manteniendo la independencia necesaria para proveer ms
flexibilidad y rapidez en la construccin de los programas.
Uso de %ROWTYPE
El atributo %ROWTYPE precisa el tipo de un registro (record) utilizando una definicin
previa de una tabla o vista de la base de datos. Tambin se puede asociar a una variable
como del tipo de la estructura retornada por un cursor.
Ejemplo:
DECLARE
emp_rec
emp%ROWTYPE;
CURSOR c1 IS SELECT deptno, dname, loc FROM dept;
dept_rec
c1%ROWTYPE;
En este ejemplo la variable emp_rec tomar el formato de un registro completo de la tabla
emp y la variable dept_rec se define por una estructura similar a la retornada por el cursor
c1.

3.4
ALCANCE Y VISIBILIDAD
Las referencias a un identificador son resueltas de acuerdo a su alcance y visibilidad dentro

de un programa. El alcance de un identificador es aquella regin de la unidad de programa
(bloque, subprograma o paquete) desde la cual se puede referenciar al identificador.
Un identificador es visible slo en las regiones en que se puede referenciar.
La figura 3-2 muestra el alcance y visibilidad de la variable x, la cual est declarada en dos
bloques cerrados diferentes.
Los identificadores declarados en un bloque de PL/SQL se consideran locales al bloque y
globales a todos sus sub-bloques o bloques anidados. De esto se desprende que un mismo
identificador no se puede declarar dos veces en un mismo bloque pero s en varios bloques
diferentes, cuantas veces se desee.
Figura 3-2:
Alcance y Visibilidad de Identificadores

Este ejemplo ilustra el alcance y visibilidad (o posibilidad de ser referenciada) de una

determinada variable x, que ha sido declarada en dos bloques anidados. La variable ms
externa tiene un alcance ms amplio pero cuando es referenciada en el bloque en que se ha
declarado otra variable con el mismo nombre, es esta ltima la que puede ser manipulada y
no la primera.

CAPTULO 4: ESTRUCTURAS DEL LENGUAJE
Este captulo muestra como estructurar el flujo de control dentro de un programa PL/SQL.
Se podr entender como las distintas sentencias se encuentran conectadas mediante un
poderoso y simple control de estructuras que constan de un punto de entrada y uno de salida.
En su conjunto estas estructuras pueden manejar cualquier situacin y permiten una correcta
estructuracin del programa.
De acuerdo con el Teorema de la Estructura, cualquier programa computacional puede ser
escrito utilizando las estructuras bsicas de control que se muestran en la figura 4-1. Estas se
pueden combinar de todas las maneras necesarias para alcanzar la solucin de un problema
dado.
Las estructuras de seleccin verifican cierta condicin, despus ejecutan cierta secuencia de
expresiones dependiendo si la condicin result ser verdadera o falsa. Una condicin es
cualquier variable o expresin que retorna un valor booleano (TRUE o FALSE). Las
estructuras de iteracin ejecutan una secuencia de sentencias repetidamente mientras la
condicin permanezca verdadera. Las estructuras de secuencia simplemente ejecutan una
secuencia de estamentos en el orden que ocurren.
Seleccin
Secuencia
Iteracin
F
T
Figura 4-1:
Estructuras de Control

4.1
CONTROL CONDICIONAL: SENTENCIA IF
A menudo es necesario tomar alternativas de accin dependiendo de las circunstancias. La

sentencia IF permite ejecutar una secuencia de acciones condicionalmente. Esto es, si la
secuencia es ejecutada o no depende del valor de la condicin a evaluar. Existen tres modos
para esta instruccin: IF THEN, IF THEN ELSE y IF THEN ELSIF.
IF THEN
Este es el modo ms simple y consiste en asociar una condicin con una secuencia de
sentencias encerradas entre las palabras reservadas THEN y END IF (no ENDIF).
Ejemplo:
IF condicin THEN
secuencia_de_sentencias
END IF;
La secuencia de sentencias es ejecutada slo si la condicin es verdadera. Si la condicin es
falsa o nula no realiza nada. Un ejemplo real de su utilizacin es la siguiente:
IF condicin THEN
calcular_bonus (emp_id)
UPDATE sueldos SET pago = pago + bonus WHERE emp_no = emp_id;
END IF;
IF THEN ELSE
Esta segunda modalidad de la sentencia IF adiciona una nueva palabra clave: ELSE, seguida
por una secuencia alternativa de acciones:
IF condicin THEN
secuencia_de_sentencias_1
ELSE

END IF;
La secuencia de sentencias en la clusula ELSE es ejecutada solamente si la condicin es
falsa o nula. Esto implica que la presencia de la clusula ELSE asegura la ejecucin de
alguna de las dos secuencias de estamentos. En el ejemplo siguiente el primer UPDATE es
ejecutado cuando la condicin es verdadera, en el caso que sea falsa o nula se ejecutar el
segundo UPDATE:
IF tipo_trans = CR THEN
UPDATE cuentas SET balance = balance + credito WHERE
ELSE
UPDATE cuentas SET balance = balance debito WHERE
END IF;
Las clusulas THEN y ELSE pueden incluir estamentos IF, tal como lo indica el siguiente
ejemplo:
IF tipo_trans = CR THEN
UPDATE cuentas SET balance = balance + credito WHERE
ELSE
IF nuevo_balance >= minimo_balance THEN
UPDATE cuentas SET balance = balance debito WHERE
ELSE
RAISE fondos_insuficientes;
END IF;
END IF;

IF THEN ELSIF
Algunas veces se requiere seleccionar una accin de una serie de alternativas mutuamente
exclusivas. El tercer modo de la sentencia IF utiliza la clave ELSIF (no ELSEIF) para
introducir condiciones adicionales, como se observa en el ejemplo siguiente:
IF condicin_1 THEN
ELSIF condicin_2 THEN
ELSE
END IF;
Si la primera condicin es falsa o nula, la clusula ELSIF verifica una nueva condicin.
Cada sentencia IF puede poseer un nmero indeterminado de clusulas ELSIF; la palabra
clave ELSE que se encuentra al final es opcional.
Las condiciones son evaluadas una a una desde arriba hacia abajo. Si alguna es verdadera, la
secuencia de sentencias que corresponda ser ejecutada. Si cada una de las condiciones
analizadas resultan ser falsas, la secuencia correspondiente al ELSE ser ejecutada:
BEGIN
IF sueldo > 50000 THEN

bonus : = 1500;
ELSIF sueldo > 35000 THEN
bonus : = 500;
ELSE
bonus : = 100;

END IF;
INSERT INTO sueldos VALUES (emp_id, bonus, );
END;
Si el valor de sueldo es mayor que 50.000, la primera y segunda condicin son verdaderas,
sin embargo a bonus se le asigna 1500, ya que la segunda condicin jams es verificada. En
este caso slo se verifica la primera condicin para luego pasar el control a la sentencia
INSERT.
4.2
CONTROLES DE ITERACIN: LAS SENTENCIAS LOOP Y EXIT
La sentencia LOOP permite ejecutar una secuencia de acciones mltiples veces. Todas ellas
gobernadas por una condicin que regula la ejecucin de la iteracin.
Existen tres modalidades para esta instruccin: LOOP, WHILE LOOP y FOR LOOP.
LOOP
El modo bsico (o infinito) de LOOP encierra una serie de acciones entre las palabras clave
LOOP y END LOOP, como en el siguiente ejemplo:
LOOP
secuencia_de_instrucciones
END LOOP;
Con cada iteracin del ciclo las sentencias son ejecutadas. Para terminar estos ciclos de
ejecucin se utiliza la palabra clave EXIT. Es posible ubicar innumerables EXIT dentro del
loop, obviamente ninguno fuera de l. Existen dos modalidades para utilizar esta sentencia:
EXIT y EXIT WHEN.
EXIT
La clusula EXIT obliga al loop a concluir incondicionalmente. Cuando se encuentra un
EXIT en el cdigo, el loop es completado inmediatamente y pasa el control a la prxima

sentencia.
LOOP
IF ranking_credito < 3 THEN
EXIT; --Termina el loop inmediatamente

END IF;
END LOOP;
Es necesario recordar que esta sentencia debe estar dentro del loop. Para completar un
bloque PL/SQL antes de que su final natural sea alcanzado, es posible utilizar la instruccin
RETURN.
EXIT WHEN
Esta sentencia permite terminar el loop de manera condicional. Cuando se encuentra un
EXIT la condicin de la clusula WHEN es evaluada. Si la condicin es verdadera el loop es
terminado y el control es pasado a la prxima sentencia.
Ejemplo:
LOOP
FECTH c1 INTO
EXIT WHEN c1%NOTFOUND; -- termina el loop si la condicin es verdadera
END LOOP;
CLOSE c1;
Hasta que la condicin no sea verdadera el loop no puede completarse, esto implica que
necesariamente dentro de las sentencias el valor de la condicin debe ir variando. En el
ejemplo anterior si la ejecucin de FETCH retorna una fila la condicin es falsa. Cuando
FETCH falla al retornar una fila, la condicin es verdadera por lo que el loop es completado

y el control es pasado a la sentencia CLOSE.

La sentencia EXIT WHEN reemplaza la utilizacin de un IF. A modo de ejemplo se
pueden comparar los siguientes cdigos:
IF count > 100 THEN
EXIT;
END IF;
EXIT WHEN count > 100;
Ambos cdigos son equivalentes, pero el EXIT WHEN es ms fcil de leer y de entender.
Etiquetas
En todos los bloques escritos en PL/SQL, los ciclos pueden ser rotulados. Un rtulo es un
identificador encerrado entre los signos dobles << y >> y debe aparecer al comienzo de un
loop, como se muestra a continuacin:
<<rtulo>>
LOOP
secuencia de sentencias
END LOOP;
La ltima sentencia puede cambiarse tambin por END LOOP rtulo;
WHILE - LOOP
Esta sentencia se asocia a una condicin con una secuencia de sentencias encerradas por las
palabras clave LOOP y END LOOP, como sigue:
WHILE condicin LOOP

END LOOP;
Antes de cada iteracin del ciclo se evala la condicin. Si sta es verdadera se ejecuta la
secuencia de sentencias y el control se devuelve al inicio del loop. Si la condicin en falsa o
nula, el ciclo se rompe y el control se transfiere a la prxima instruccin, fuera del loop.
FOR - LOOP
En las instrucciones anteriores el nmero de iteraciones es desconocido, mientras no se
evala la condicin del ciclo. Con una instruccin del tipo FOR-LOOP, la iteracin se
efecta un nmero finito (y conocido) de veces. La sintaxis de esta instruccin es la
siguiente:
FOR contador IN [REVERSE] valor_minimo..valor_maximo LOOP
END LOOP;
El contador no necesita ser declarado porque por defecto se crea para el bloque que
involucra el ciclo y luego se destruye.
Por defecto, la iteracin ocurre en forma creciente, es decir, desde el menor valor aportado
hasta el mayor. Sin embargo, si se desea alterar esta condicin por defecto, se debe incluir
explcitamente en la sentencia la palabra REVERSE.
Los lmites de una iteracin pueden ser literales, variables o expresiones, pero que deben
evaluarse como nmeros enteros.
Un contador de loop tiene validez slo dentro del ciclo. No es posible asignar un valor a una
variable contadora de un loop, fuera de l.
Ejemplo:
FOR cont IN 1..10 LOOP
END LOOP;
sum := cont + 1 ;
-- Esto no est permitido

La sentencia EXIT tambin puede ser utilizada para abortar la ejecucin del loop en forma
prematura. Por ejemplo, en el siguiente trozo de programa la secuencia normal debera
completarse luego de 10 veces de ejecutarse, pero la aparicin de la clusula EXIT podra
hacer que sta termine antes:
FOR j IN 1..10 LOOP

FETCH c1 INTO emprec;
EXIT WHEN c1%NOTFOUND;
END LOOP;
O tambin se puede utilizar:
<<externo>>
FOR i IN 1..5 LOOP
FOR j IN 1..10 LOOP

FETCH c1 INTO emprec;
EXIT externo WHEN c1%NOTFOUND;
-- sale de ambos ciclos
END LOOP;
END LOOP externo;
-- el control retorna a esta lnea

4.3
CONTROLES DE SECUENCIA: LAS SENTENCIAS GOTO Y NULL
Ocasionalmente podra ser til la utilizacin de una sentencia de este tipo. A pesar de que es
sabido que la sentencia GOTO redunda en un cdigo ms complejo y desordenado a veces
podra cooperar en la implementacin de un programa. La sentencia nula puede cooperar con
la fcil lectura del cdigo cuando este sobrepasa una cantidad determinada de instrucciones y
torna ms difcil su comprensin.
GOTO
La sentencia GOTO obliga a saltar a un rtulo del programa en forma incondicional. El
rtulo debe ser nico dentro de su alcance y debe preceder a una sentencia ejecutable o a un
bloque PL/SQL. Cuando es ejecutada, esta instruccin transfiere el control a la sentencia o
bloque rotulada.
Los siguientes ejemplos ilustran una forma vlida de utilizar la sentencia GOTO y otra no
vlida.
Ejemplo vlido:
BEGIN
<<actualiza>>
BEGIN
UPDATE emp SET
END;
GOTO <<<actualiza>>
END;

Ejemplo no vlido:
DECLARE
done BOOLEAN;
BEGIN
FOR i IN 1..50 LOOP

IF done THEN
GOTO fin_loop;
END IF;
<<fin_loop>>
END LOOP;
-- Ilegal
-- Esta no es una sentencia ejecutable
END;
Restricciones
Algunas restricciones en la utilizacin de un GOTO son las siguientes: una sentencia de este
tipo no puede saltar dentro de una sentencia IF, LOOP o un sub-bloque. Tampoco se puede
utilizar GOTO dentro del bloque de excepciones para salir de l.
NULL
La sentencia NULL especifica explcitamente inaccin. No hace nada ms que pasar el
control del programa a la siguiente sentencia. Tambin sirve como un comodn para hacer el
cdigo ms entendible, advirtiendo que la alternativa sealada no requiere codificacin.
Ejemplo:
EXCEPTION

WHEN zero_divide THEN

Rollback;
WHEN value_error THEN
INSERT INTO errores VALUES
Commit;
WHEN others THEN
NULL;
END;
4.4
PROCESAMIENTO DE TRANSACCIONES
Existen tcnicas bsicas que permiten salvaguardar la consistencia de la base de datos de

forma explcita, es decir, manejable por el usuario o programador.
Las tareas o jobs que maneja Oracle son llamadas sesiones. Una sesin de usuario comienza
cuando se corre un programa o se conecta a la base a travs de una herramienta. Oracle
administra la concurrencia con los mecanismos de control adecuados, que garantizan que se
mantenga siempre la integridad de los datos.
Oracle tambin permite la habilitacin de bloqueos para controlar el acceso concurrente a los
datos. Un bloqueo permite el acceso exclusivo a ciertos datos por un breve periodo de
tiempo, ya sea a travs de una tabla o fila de datos.
Una transaccin es una serie de sentencias SQL de manipulacin de datos que provee una
unidad lgica de trabajo. Cada sentencia SQL corresponde a una transaccin. Esta unidad es
reconocida por Oracle con la finalidad de proveer la caracterstica de asegurar las
transacciones efectuadas en la base de datos (commit) o deshacerlas (rollback). Si un
programa falla a la mitad de una transaccin, la base de datos se recupera automticamente
hasta el ltimo punto guardado.
Las sentencias commit y rollback permiten asegurar que todos los cambios efectuados sobre
la base de datos se guardarn permanentemente o se descartarn en forma definitiva. Todas
las sentencias que se ejecutan desde la ocurrencia del ltimo commit o rollback comprenden
la transaccin (o grupo de transacciones) activa. La sentencia savepoint establece un punto
de procesamiento dentro de una transaccin y funciona de manera similar a un rtulo (ver

captulo 3).
Uso de COMMIT
La sentencia commit finaliza la transaccin actual efecta los cambios en la base de datos de
forma permanente. Mientras un usuario no efecta el commit, el resto de usuarios que
accesan la misma base en forma concurrente no vern los cambios que este primer usuario
ha estado efectuando. Slo despus de ejecutada la sentencia todos los usuarios de la base
estarn en condiciones de ver los cambios implementados por el usuario que hace el commit.
Ejemplo:
BEGIN
UPDATE cuenta SET bal = mi_bal debito WHERE num_cta = 7715 ;
UPDATE cuenta SET bal = mi_bal + credito WHERE num_cta = 7720 ;

COMMIT WORK;
END;
La sentencia COMMIT libera todas las filas bloqueadas de la tabla cuenta. La palabra
clave work no tiene otro efecto que permitir la fcil lectura de la instruccin, pero es
perfectamente prescindible dentro del lenguaje.
Note que la palabra end al final del cdigo indica el final del bloque, no el fin de la
transaccin. Una transaccin puede abarcar ms de un bloque, como tambin dentro de un
mismo bloque pueden ocurrir muchas transacciones.
Uso de ROLLBACK
La sentencia rollback finaliza la transaccin actual y deshace todos los cambios realizados
en la base de datos en la transaccin activa. Considrese el caso del ejemplo siguiente, donde
se inserta informacin en tres tablas diferentes y se toma la precaucin de que si se trata de
insertar un valor duplicado en una clave primaria, se genera un error (controlado con la

sentencia rollback).
Ejemplo:
DECLARE
emp_id integer;
BEGIN
SELECT empno, INTO emp_id, FROM new_emp WHERE
INSERT INTO emp VALUES(emp_id, );

INSERT INTO tax VALUES(emp_id, );
INSERT INTO pay VALUES(emp_id, );
EXCEPTION
WHEN DUP_VAL_ON_INDEX THEN
ROLLBACK;
END;

Uso de SAVEPOINT
Con la sentencia savepoint es posible nombrar y marcar un punto determinado donde se
podr retornar el control luego de ejecutarse una sentencia rollback.
Ejemplo:
DECLARE
emp_id emp.empno%TYPE;
BEGIN
UPDATE emp SET WHERE empno=emp_id;
DELETE FROM emp WHERE
SAVEPOINT do_insert;
INSERT INTO emp VALUES (emp_id, );
EXCEPTION
WHEN DUP_VAL_ON_INDEX THEN
ROLLBACK TO do_insert;
END;
Es posible establecer puntos de control (savepoint) en programas recursivos. En ese caso,

cada instancia de la llamada al programa mantendr sus propios puntos de control y el que se
encuentre activo corresponder a la instancia del programa que se est ejecutando.

CAPTULO 5: MANEJO DE CURSORES
Los cursores permiten manejar grupos de datos que se obtienen como resultado de una
consulta SQL que retorna una o ms filas.
PL/SQL utiliza dos tipos de cursores: implcitos y explcitos. Siempre declara un cursor
implcito para cualquier sentencia de manipulacin de datos, incluyendo aquellas que
retornan slo una fila.
Sin embargo, para las queries que retornan ms de una fila, usted debe declarar un cursor
explcito para ser usado en una instruccin FOR.
No se pueden usar sentencias de control para cursores implcitos, como en el caso de los
cursores explcitos, por lo que no se revisarn en este captulo.
Los Cursores Explcitos son aquellos que devuelven cero, una o ms filas, dependiendo de
los criterios con que hayan sido construidos. Un cursor puede ser declarado en la primera
seccin de un programa PL/SQL (declare).
Existen tres comandos para controlar un cursor: OPEN, FETCH y CLOSE. En un principio,
el cursor se inicializa con la instruccin OPEN. Enseguida, se utiliza la instruccin FETCH
para recuperar la primera fila o conjunto de datos. Se puede ejecutar FETCH repetidas veces
hasta que todas las filas hayan sido recuperadas. Cuando la ltima fila ya ha sido procesada,
el cursor se puede liberar con la sentencia CLOSE.
Es posible procesar varias queries en paralelo, declarando y abriendo mltiples cursores.

5.1
DECLARACIN DE CURSORES
Los cursores deben ser declarados antes de ser utilizados en otras sentencias. Cuando se
declara un cursor, a ste se le da un nombre y se asocia con una consulta especfica usando la
sintaxis siguiente:
DECLARE
CURSOR nombre_cursor [ (parmetro1 [, parmetro2]) ]
[RETURN tipo_de_retorno] IS sentencia_select ;
Donde tipo_de_retorno debe representar a un registro o una fila en una tabla de la base y los
parmetros siguen la siguiente sintaxis:
nombre_del_parametro [IN] tipo_de_dato [ { := | DEFAULT} expresin ]
Por ejemplo, los cursores c1 y c2 se pueden declarar como sigue:

DECLARE
CURSOR c1 IS SELECT empno, ename, job, sal FROM emp WHERE sal>1000 ;
CURSOR c2 RETURN dept%ROWTYPE IS
SELECT * from dept WHERE deptno = 10 ;
El nombre del cursor (c1 y c2 en el ejemplo) corresponde a un identificador no declarado, no

a un nombre de variable de PL/SQL. No se pueden asignar valores a un nombre de cursor ni
utilizarlos en una expresin.
Un cursor puede recibir parmetros, los cuales deben ser declarados con la clusula IN para
formalizar su incorporacin. Los parmetros pueden ser inicializados con algn valor, pero
estos pueden ser cambiados en cualquier oportunidad.
El alcance de los parmetros es local al cursor, lo que significa que ellos slo pueden ser
referenciados dentro de la consulta especificada en la declaracin del mismo. Estos valores
son utilizados por la query cuando el cursor se abre.

5.2
APERTURA DE UN CURSOR
Al abrir un cursor se ejecuta inmediatamente la consulta e identifica el conjunto resultado, el

que consiste de todas las filas que concuerdan con el criterio de seleccin de ste. Para los
cursores que se abren con la clusula For Update, la sentencia de apertura del cursor
adems bloquea esas filas retornadas. Un ejemplo es el siguiente:
DECLARE
CURSOR c1 IS SELECT ename, job FROM emp WHERE sal > 3000;
BEGIN
OPEN c1;
END;
Pasaje de Parmetros
Se utiliza tambin la sentencia OPEN para pasar los parmetros al cursor, en caso de que
ste los requiera. Por ejemplo:
DECLARE
emp_name
emp.name%TYPE;
salary
emp.sal%TYPE;
CURSOR c1 (name VARCHAR2, salary NUMBER) IS SELECT
Cualquiera de estas sentencias abre el cursor:

OPEN c1(emp_name, 3000);
OPEN c1(John, 1500);
OPEN c1(emp_name, salary);

Obsrvese que en este ejemplo, cuando se utiliza la variable salary en la declaracin se

refiere al nombre del segundo parmetro del cursor. Sin embargo, cuando es usada en una
sentencia OPEN se refiere a la variable del programa.

5.3
RECUPERACIN DE FILAS
La sentencia FETCH permite recuperar los conjuntos de datos de a uno a la vez. Despus de
cda recuperacin y carga de un set de datos el cursor avanza a la fila siguiente.
Ejemplo:
FETCH c1 INTO my_empno, my_ename, my_deptno;
Para cada columna retornada en un cursor y especificada en la declaracin del mismo debe
existir una variable compatible en tipo en la lista INTO.
Tpicamente se utiliza la sentencia FETCH dentro de un conjunto de instrucciones como el
siguiente:
LOOP
FETCH c1 INTO mi_registro;
--- se procesa el registro
END LOOP;
Eventualmente, la sentencia FETCH fallar, es decir, no retornar ningn conjunto de datos.

Cuando esto sucede, no se gatilla una excepcin, luego se debe detectar esta condicin
utilizando los atributos del cursor %FOUND y/o %NOTFOUND.
Algunos atributos de los cursores se detallan a continuacin:
Uso de %FOUND
Luego de que un curso ha sido abierto, pero antes de recuperar la primera fila el valor del
atributo %FOUND es nulo. A continuacin, tomar el valor TRUE cada vez que obtenga
una fila del set de resultados (en cada FETCH que se haga) y slo alcanzar el valor FALSE
cuando ya no existan ms filas para mostrar en el set de resultados.

Ejemplo:
LOOP
FETCH c1 INTO
IF c1%FOUND THEN
-- fetch exitoso
ELSE
-- fetch fall; se sale del loop
EXIT;
END IF;
END LOOP;
Uso de %NOTFOUND
Es el opuesto lgico de %FOUND. Cada vez que una sentencia FETCH retorne una fila
vlida, este atributo devolver FALSO. Slo alcanzar el valor TRUE cuando no haya ms
filas en un cursor y se ejecute la sentencia FETCH (sin xito por lo tanto).
Ejemplo:
LOOP
FETCH c1 INTO
END LOOP;
Uso de %ISOPEN
Este atributo toma el valor verdadero (TRUE) cuando un cursor se encuentra abierto. De otra
manera, retorna FALSO.

Uso de %ROWCOUNT
Cuando un cursor es abierto, este atributo es seteado en 0 (cero). En adelante, cada vez que
se recuperen filas exitosamente con un FETCH, este valor se ir incrementando en uno.
Cuando se utiliza con cursores implcitos, este atributo devuelve el total de filas afectadas
por una instruccin del tipo INSERT, UPDATE o DELETE.

5.4
CIERRE DE UN CURSOR
La sentencia que deshabilita un cursor, CLOSE, se utiliza de la siguiente manera:

CLOSE c1;
Una vez que un cursor ya ha sido cerrado, es posible volverlo a abrir sin tener que declararlo
otra vez. Cualquier otra operacin que se desee efectuar sobre un cursor no operativo
(cerrado) provocar una excepcin del tipo invalid_cursor.

CAPTULO 6: MANEJO DE ERRORES
En PL/SQL una advertencia o condicin de error es llamada una excepcin. Estas pueden ser
definidas en forma interna (en tiempo de ejecucin de un programa) o explcitamente por el
usuario. Ejemplos de excepciones definidas en forma interna son la divisin por cero y la
falta de memoria en tiempo de ejecucin. Estas mismas condiciones excepcionales tienen
sus nombres propios y pueden ser referenciadas con ellos: zero_divide y storage_error.
Tambin se pueden definir excepciones a medida y nombrarlas de alguna forma, utilizando
las reglas de construccin mencionadas en el captulo 2.
Cuando ocurre un error se alcanza la excepcin, esto quiere decir que se ejecuta la porcin
del programa donde sta se encuentra implementada, transfirindose el control a ese bloque
de sentencias. Las excepciones definidas por el usuario deben ser alcanzadas explcitamente
utilizando la sentencia raise.
Con las excepciones ser pueden manejar los errores cmodamente sin necesidad de mantener
mltiples chequeos por cada sentencia escrita. Tambin provee claridad en el cdigo desde
el momento en que permite mantener las rutinas correspondientes al tratamiento de los
errores en forma separada de la lgica del negocio.
6.1
EXCEPCIONES PREDEFINIDAS
Las excepciones predefinidas no necesitan ser declaradas. Simplemente se utilizan cuando

estas son gatilladas por algn error determinado.
La siguiente es la lista de las excepciones predeterminadas por PL/SQL y una breve
descripcin de cundo son accionadas:
Nombre Excepcin
ACCESS_INTO_NULL
COLLECTION_IS_NULL
CURSOR_ALREADY_OPEN
Gatillada cuando
SQLCODE
El programa intent asignar valores a -6530

los atributos de un objeto no
inicializado
El programa intent asignar valores a -6531
una tabla anidada an no inicializada
El programa intent abrir un cursor -6511

DUP_VAL_ON_INDEX
INVALID_CURSOR
INVALID_NUMBER
LOGIN_DENIED
NO_DATA_FOUND
NOT_LOGGED_ON
PROGRAM_ERROR
ROWTYPE_MISMATCH
SELF_IS_NULL
STORAGE_ERROR
SUBSCRIPT_BEYOND_COUNT
que ya se encontraba abierto.

Recuerde que un cursor de ciclo FOR
automticamente lo abre y ello no se
debe especificar con la sentencia
OPEN
El programa intent almacenar
valores duplicados en una columna
que se mantiene con restriccin de
integridad de un ndice nico (unique
index)
El programa intent efectuar una
operacin no vlida sobre un cursor
En una sentencia SQL, la conversin
de una cadena de caracteres hacia un
nmero falla cuando esa cadena no
representa un nmero vlido
El programa intent conectarse a
Oracle con un nombre de usuario o
password invlido
Una sentencia SELECT INTO no
devolvi valores o el programa
referenci un elemento no inicializado
en una tabla indexada
El programa efectu una llamada a
Oracle sin estar conectado
PL/SQL tiene un problema interno
Los elementos de una asignacin (el
valor a asignar y la variable que lo
contendr) tienen tipos incompatibles.
Tambin se presenta este error cuando
un
parmetro
pasado
a
un
subprograma no es del tipo esperado
El parmetro SELF (el primero que es
pasado a un mtodo MEMBER) es
nulo
La memoria se termin o est
corrupta
El programa est tratando de
referenciar un elemento de un arreglo
indexado que se encuentra en una
-1
-1001
-1722
-1017
+100
-1012
-6501
-6504
-30625
-6500
-6533

SUBSCRIPT_OUTSIDE_LIMIT
SYS_INVALID_ROWID
TIMEOUT_ON_RESOURCE
TOO_MANY_ROWS
VALUE_ERROR
ZERO_DIVIDE
6.2
posicin ms grande que el nmero

real de elementos de la coleccin
El programa est referenciando un
elemento de un arreglo utilizando un
nmero fuera del rango permitido
(por ejemplo, el elemento -1)
La conversin de una cadena de
caracteres hacia un tipo rowid fall
porque la cadena no representa un
nmero
Se excedi el tiempo mximo de
espera por un recurso en Oracle
Una sentencia SELECT INTO
devuelve ms de una fila
Ocurri un error aritmtico, de
conversin o truncamiento. Por
ejemplo, sucede cuando se intenta
calzar un valor muy grande dentro de
una variable ms pequea
El programa intent efectuar una
divisin por cero
-6532
-1410
-51
-1422
-6502
-1476
EXCEPCIONES DEFINIDAS POR EL USUARIO
PL/SQL permite al usuario definir sus propias excepciones, las que debern ser declaradas y
gatilladas explcitamente utilizando otros comandos del lenguaje.
Declaracin
Las excepciones slo pueden ser declaradas en el segmento Declare de un bloque,
subprograma o paquete. Se declara una excepcin escribiendo su nombre seguida de la
palabra clave EXCEPTION. Las declaraciones son similares a las de variables, pero recuerde
que una excepcin es una condicin de error, no un tem de datos. Aun as, las mismas reglas
de alcance aplican tanto sobre variables como sobre las excepciones.
Ejemplo:
DECLARE

error_01
EXCEPTION;
Reglas de Alcance
Una excepcin no puede ser declarada dos veces en un mismo bloque. Tal como las
variables, una excepcin declarada en un bloque es local a ese bloque y global a todos los
sub-bloques que comprende.
La sentencia RAISE
La sentencia RAISE permite gatillar una excepcin en forma explcita. Es factible utilizar
esta sentencia en cualquier lugar que se encuentre dentro del alcance de la excepcin.
Ejemplo:
DECLARE
out_of_stock
EXCEPTION;
total
NUMBER(4);
-- declaracin de la excepcin
BEGIN
IF total < 1 THEN

RAISE out_of_stock;
-- llamado a la excepcin
END IF;
EXCEPTION
WHEN out_of_stock THEN
-- manejar el error aqu
WHEN OTHERS THEN
END;

Finalmente, cabe destacar la existencia de la excepcin OTHERS, que simboliza cualquier

condicin de excepcin que no ha sido declarada. Se utiliza comnmente al final del bloque
de excepciones para absorber cualquier tipo de error que no ha sido previsto por el
programador. En ese caso, es comn observar la sentencia ROLLBACK en el grupo de
sentencias de la excepcin o alguna de las funciones SQLCODE SQLERRM, que se
detallan en el prximo punto.
6.3
USO DE SQLCODE Y SQLERRM
Al manejar una excepcin es posible apoyarse con las funciones predefinidas SQLCode y
SQLErrm para aclarar al usuario la situacin de error acontecida.
Sqlcode siempre retornar el nmero del error de Oracle y un 0 (cero) en caso exitoso al
ejecutarse una sentencia SQL.
Por otra parte, Sqlerrm retornar el correspondiente mensaje de error para la situacin
ocurrida. Tambin es posible entregarle a la funcin SQLERRM un nmero negativo que
represente un error de Oracle y sta devolver el mensaje asociado.
Estas funciones son muy tiles cuando se utilizan en el bloque de excepciones, para aclarar
el significado de la excepcin OTHERS, cuando sta ocurre.
Estas funciones no pueden ser utilizadas directamente en una sentencia SQL, pero s se
puede asignar su valor a alguna variable de programa y luego usar esta ltima en alguna
sentencia.
Ejemplo:
DECLARE
err_num
NUMBER;
err_msg
VARCHAR2(100);
BEGIN
EXCEPTION
WHEN OTHERS THEN
err_num := SQLCODE;

err_msg := SUBSTR(SQLERRM, 1, 100);

INSERT INTO errores VALUES(err_num, err_msg);
END;

CAPTULO 7: SUBPROGRAMAS
Los subprogramas son bloques de instrucciones de PL/SQL que pueden ser invocados por
otros y recibir parmetros. En PL/SQL existen dos tipos de subprogramas: Los
Procedimientos y las Funciones. Por regla general, se utiliza un procedimiento para ejecutar
una accin especfica y una funcin para calcular un valor.
Los subprogramas tambin constan de una seccin de declaraciones, un cuerpo que se
ejecuta y una seccin opcional de manejo de excepciones.
Ejemplo:
PROCEDURE debit_account (acct_id INTEGER, amount REAL) IS
old_balance REAL;
new_balance REAL;
overdrown EXCEPTION;
BEGIN
SELECT bal INTO old_balance FROM accts WHERE acct_no = acct_id;
new_balance := old_balance amount;
IF new_balance < 0 THEN
RAISE overdrown;
ELSE
UPDATE accts SET bal = new_balance WHERE acct_no = acct_id;
END IF;
EXCEPTION
WHEN overdrown THEN
END debit_account;

En el ejemplo, cuando el subprograma es invocado, recibe los parmetros acct_id y amount.

Con el primero de ellos selecciona el valor del campo bal y lo almacena en old_balance.
Luego almacena una diferencia en otra variable, new_balance, la que de ser negativa
gatillar una condicin de excepcin definida por el usuario (overdrown).
Figura 7-1: Estructura de un Paquete
Ventajas de los subprogramas

Los subprogramas proveen extensibilidad, es decir, permite crear nuevos programas cada
vez que se necesiten, los cuales pueden ser invocados fcilmente y sus resultados utilizados
de inmediato.
Tambin aportan modularidad. Esto es, permite dividir un gran programa en mdulos
lgicos ms pequeos y fciles de manejar. Esto apoya el diseo de programas utilizando la
metodologa top-down.
Adems, los subprogramas proveen las caractersticas de reusabilidad y mantenibilidad. Una
vez construido, un subprograma puede ser utilizado en cualquier nmero de aplicaciones. Si
la definicin del tema que implementa es cambiada, entonces slo se debe alterar el
subprograma y no todos los lugares donde es referenciado.
Finalmente, construir subprogramas agregan abstraccin, lo que implica que es preciso
conocer slo qu es lo que hacen y no cmo estn implementados necesariamente.

7.1
PROCEDIMIENTOS
Un procedimiento es un subprograma que ejecuta una accin especifica. La sintaxis para

construirlos es la siguiente:
PROCEDURE nombre [ (parmetro [, parmetro, ] ) ] IS
[declaraciones_locales]
BEGIN
sentencias_ejecutables
[EXCEPTION
condiciones_de_excepcin]
END [nombre] ;
Adems, cada parmetro se escribe con la siguiente notacin:
nombre_parmetro [IN | OUT [NOCOPY] | IN OUT [NOCOPY] tipo_de_dato

[ { := | DEFAULT } expresin ]
En los pasajes de parmetros no se puede precisar el largo de alguno de ellos explcitamente,
como en:
PROCEDURE xxx (param01 CHAR(5)) IS

Esta sentencia es invlida. Debera decir slo param01 CHAR, sin especificar el largo
del carcter.
Sin embargo, si es absolutamente necesario restringir el largo de una cadena como la del
ejemplo, se puede corregir la situacin codificando la llamada al procedimiento xxx de la
siguiente manera:

DECLARE
temp CHAR(5);
SUBTYPE Char5 IS temp%TYPE;
PROCEDURE xxx (param01 Char5) IS
Un procedimiento posee dos partes: una especificacin y un cuerpo. La especificacin es
simple, comienza con la palabra PROCEDURE y termina (en la misma lnea) con el nombre
del procedimiento o la lista de parmetros (que es opcional).
El cuerpo del procedimiento comienza con la palabra reservada IS y termina con END,
seguido opcionalmente por el nombre del procedimiento.
7.2
FUNCIONES
Una funcin es un subprograma que calcula un valor. La sintaxis para construir funciones es
la siguiente:
FUNCTION nombre [ (parmetro [, parmetro, ] ) ] RETURN tipo_de_dato IS
BEGIN
sentencias_ejecutables
[EXCEPTION
condiciones_de_excepcin]
END [nombre] ;
Y la sintaxis de los parmetros es idntica al caso de los procedimientos:

nombre_parmetro [IN | OUT [NOCOPY] | IN OUT [NOCOPY] tipo_de_dato
[ { := | DEFAULT } expresin ]
La funcin tambin posee una especificacin y un cuerpo. El segmento de especificacin

comienza con la palabra FUNCTION y termina con la clusula RETURN, la cual especifica
el tipo de dato retornado por la funcin.
El cuerpo comienza con la palabra IS y termina con la palabra END, es decir, incluye las
secciones de declaraciones, sentencias ejecutables y una parte opcional de manejo de
excepciones.
Ejemplo:
FUNCTION revisa_salario (salario REAL, cargo CHAR(10)) RETURN BOOLEAN IS
salario_minimo REAL;
salario_maximo REAL;
BEGIN
SELECT lowsal, highsal INTO salario_minimo, salario_maximo
FROM salarios WHERE job = cargo ;
RETURN (salario >= salario_minimo) AND (salario <= salario_maximo)
END revisa_salario ;
Esta misma funcin de ejemplo puede ser llamada desde una sentencia PL/SQL que reciba
un valor booleano, como por ejemplo, en:
DECLARE
renta_actual REAL;
codcargo CHAR(10);
BEGIN
IF revisa_salario (renta_actual, codcargo) THEN

La funcin revisa_salario acta como una variable de tipo booleano, cuyo valor depende de
los parmetros recibidos.

La sentencia RETURN
Esta sentencia termina inmediatamente la ejecucin de un programa, retornando el control al
bloque de programa que lo llam. No se debe confundir con la clusula return de las
funciones, que especifica el tipo de dato devuelto por ella.
Un subprograma puede contener varias sentencias Return. Si se ejecuta cualquiera de ellas,
el subprograma completo se termina.
La sintaxis para los procedimientos es simple, slo se necesita la palabra RETURN. Sin
embargo, en el caso de las funciones, esta sentencia debe contener un valor, que es aquel que
se va a devolver al programa que la llam. La expresin que sigue a la sentencia puede ser
tan compleja como se desee pero siempre debe respetar el tipo de datos que est definido en
la cabecera (especificacin) de la funcin.
Una funcin debe contener como mnimo una sentencia RETURN, de otra manera, al no
encontrarla, PL/SQL generar la excepcin PROGRAM_ERROR.
7.3
USO DE PARMETROS
Los subprogramas traspasan informacin utilizando parmetros. Las variables o expresiones

referenciadas en la lista de parmetros de una llamada a un subprograma son llamados
parmetros actuales. Las variables declaradas en la especificacin de un subprograma y
utilizadas en el cuerpo son llamados parmetros formales.
En este ltimo caso (para los parmetros formales) se pueden explicitar tres modos
diferentes para definir la conducta de los parmetros: IN, OUT e IN OUT.
Sin embargo, evite usar los tipos de parmetros OUT e IN OUT en las funciones, ya que por
su naturaleza stas devuelven un slo dato y no a travs de parmetros. Es una mala prctica
hacer que una funcin devuelva muchos valores; para eso utilice los procedimientos.

Parmetros de modo IN
Estos parmetros son la entrada a las funciones y procedimientos y actan dentro de ellas
como constantes, es decir, sus valores no pueden ser alterados dentro de un subprograma.
Los parmetros actuales (que se convierten en formales dentro de un subprograma) pueden
ser constantes, literales, variables inicializadas o expresiones.
Parmetros de modo OUT

Un parmetro de salida (OUT) permite comunicar valores al bloque de programa que invoc
al subprograma que utiliza este parmetro. Esto quiere decir adems, que es posible utilizar
un parmetro de este tipo como si fuera una variable local al subprograma.
En el programa que invoca la funcin o procedimiento, el parmetro de modo OUT debe ser
una variable, nunca una expresin o una constante.
Parmetros de modo IN OUT

Esta modalidad permite proporcionar valores iniciales a la rutina del subprograma y luego
devolverlos actualizados. Al igual que el tipo anterior, un parmetro de este tipo debe
corresponder siempre a una variable.
Si la salida de un subprograma es exitosa, entonces PL/SQL asignar los valores que
corresponda a los parmetros actuales (los que reciben los valores de los parmetros
formales en la rutina que llama al subprograma). Por el contrario, si la salida del
subprograma se produce con un error no manejado en alguna excepcin, PL/SQL no
asignar ningn valor a los parmetros actuales.
Resumen de las caractersticas de los parmetros

IN
OUT
IN OUT
es el tipo por defecto

pasa
valores
a
subprograma
debe ser especificado

debe ser especificado
un retorna valores a quien lo pasa valores iniciales al
llam
subprograma y retorna un
valor actualizado a quien lo
llam
un parmetro formal acta parmetros formales actan parmetros formales actan

como una constante
como
una
variable
inicializada
a un parmetro formal no se a un parmetro formal debe a un parmetro formal podra
le puede asignar un valor
asignrsele un valor
asignrsele un valor
los parmetros actuales los parmetros actuales los parmetros actuales
pueden
ser
constantes, deben ser variables
deben ser variables
variables
inicializadas,
literales o expresiones
7.4
como variables
RECURSIVIDAD
La recursividad es una poderosa tcnica que simplifica el diseo de algoritmos.

Bsicamente, la recursividad significa autoreferencia. Se aplica cuando un mismo algoritmo
debe ser utilizado varias veces dentro de la solucin a un problema determinado, cambiando
cada vez las condiciones iniciales de cada ejecucin (del algoritmo).
Un programa recursivo es aquel que se llama a si mismo. Piense en una llamada recursiva
como una llamada a otro subprograma que hace lo mismo que el inicial. Cada llamada crea
una nueva instancia de todos los tems declarados en el subprograma, incluyendo
parmetros, variables, cursores y excepciones.
Se recomienda ser muy cuidadoso con las llamadas recursivas. Entre otras cosas, existe un
mximo de veces que un mismo cursor puede ser abierto y eso se define en una variable de
Oracle llamada OPEN_CURSORS. Al menos alguna vez la recursividad se debe revertir, es
decir, las autoreferencias deben darse un nmero finito de veces.
Ejemplo:
FUNCTION factorial (n POSITIVE) RETURN INTEGER IS
-- devuelve n!
BEGIN
IF n = 1 THEN
-- condicin de trmino
RETURN 1
ELSE
RETURN n * factorial(n 1);
-- esta es la llamada recursiva
END IF;

END factorial;
Recursividad versus Iteracin
La recursividad no es una herramienta considerada fundamental en la programacin
PL/SQL. Cualquier problema que requiera su utilizacin tambin puede ser resuelto
utilizando iteracin. Una versin iterativa de un programa es usualmente ms fcil de disear
y de entender. Sin embargo, la versin recursiva es ms simple, pequea y ms fcil de
depurar. A modo de ejemplo, observe las siguientes dos versiones de cmo calcular el
nmero n-simo de la serie de Fibonacci:
-- Versin recursiva
FUNCTION fib (n POSITIVE) RETURN INTEGER IS
BEGIN
IF (n = 1) OR (n = 2) THEN
RETURN 1;
ELSE
RETURN fib(n 1) + fib(n 2);
END IF;
END fib;
-- Versin iterativa
FUNCTION fib (n POSITIVE) RETURN INTEGER IS
pos1 INTEGER := 1;
pos2 INTEGER := 0;
cum INTEGER;
BEGIN
IF (n = 1) OR (n = 2) THEN

RETURN 1;
ELSE
cum := pos1 + pos2;
FOR i IN 3..n LOOP
pos2 := pos1;
pos1 := cum;
cum := pos1 + pos2;
END LOOP;
RETURN cum;
END IF;
END fib;
La versin recursiva de la funcin fib es mucho ms elegante que la iterativa. Sin embargo,
esta ltima es ms eficiente; corre ms rpido y utiliza menos memoria del computador.
Si las llamadas son demasiadas se podr advertir la diferencia en eficiencia. Considere esto
para futuras implementaciones de una u otra alternativa.
7.5
POLIMORFISMO
El polimorfismo es una caracterstica del manejo de objetos. Significa que es posible definir
ms de un objeto con los mismos nombres, pero diferenciados nicamente por la cantidad o
tipo de los parmetros que reciben o devuelven.
En el caso de los subprogramas, es posible declarar mas de uno con el mismo nombre, pero
se deber tener la precaucin de diferenciarlos en cuanto al tipo de parmetros que utilizan.
Ejemplo:
PROCEDURE initialize (tab OUT DateTabTyp, n INTEGER) IS
BEGIN

FOR i IN 1..n LOOP

tab(i) := SYSDATE;
END LOOP;
END initialize;

PROCEDURE initialize (tab OUT RealTabTyp, n INTEGER) IS

BEGIN
FOR i IN 1..n LOOP
tab(i) := 0.0;
END LOOP;
END initialize;
Estos procedimientos slo difieren en el tipo de dato del primer parmetro. Para efectuar una
llamada a cualquiera de ellos, se puede implementar lo siguiente:
DECLARE
TYPE DateTabTyp IS TABLE OF DATE INDEX BY BINARY_INTEGER;
TYPE RealTabTyp IS TABLE OF REAL INDEX BY BINARY_INTEGER;
hiredate_tab
DateTabTyp;
comm_tab
RealTabTyp;
indx
BINARY_INTEGER;
BEGIN
indx := 50;
initialize(hiredate_tab, indx);
-- llama a la primera versin
initialize(comm_tab, indx);
-- llama a la segunda versin
...
END;

CAPTULO 8: PAQUETES
Un paquete es un esquema u objeto que agrupa tipos de PL/SQL relacionados, tems y

subprogramas. Los paquetes se constituyen de dos partes: la especificacin y el cuerpo.
La especificacin es la interfaz con las aplicaciones. En ella es posible declarar los tipos,
variables, constantes, excepciones, cursores y subprogramas disponibles para su uso
posterior.
El cuerpo define completamente a cursores y subprogramas e implementa lo que se declar
inicialmente en la especificacin.
Es posible depurar y modificar cuantas veces se desee el cuerpo de un paquete sin necesidad
de alterar por ello la especificacin del mismo.
Ejemplo de creacin de paquetes:

CREATE OR REPLACE PACKAGE emp_actions AS
-- Especificacin del paquete
TYPE EmpRecTyp IS RECORD (emp_id INTEGER, salary REAL);

CURSOR desc_salary RETURN EmpRecTyp;
PROCEDURE hire_employee (
ename VARCHAR2,
job
VARCHAR2,
mgr
NUMBER,
sal
NUMBER,
comm NUMBER,
deptno NUMBER);
PROCEDURE fire_employee(emp_id NUMBER);
END emp_actions;

CREATE OR REPLACE PACKAGE BODY emp_actions AS
-- Cuerpo del paquete
CURSOR desc_salary RETURN EmpRecTyp IS

SELECT empno, sal FROM emp ORDER BY sal DESC;
PROCEDURE hire_employee (
ename VARCHAR2,
job
VARCHAR2,
mgr
NUMBER,
sal
NUMBER,
comm NUMBER,
deptno NUMBER) IS
BEGIN
INSERT INTO emp VALUES (empno_seq.NEXTVAL, ename, job, mgr,
SYSDATE, sal, comm, deptno);
END hire_employee;
PROCEDURE fire_employee (emp_id NUMBER) IS
BEGIN
DELETE FROM emp WHERE empno = emp_id;
END fire_employee;
END emp_actions;
8.1
VENTAJAS DE LA UTILIZACIN DE PAQUETES
Modularidad
Los paquetes permiten encapsular tipos relacionados, tems y subprogramas en lo que se
denomina un mdulo de PL/SQL. Cada paquete es diseado de manera que sea fcil de

entender y con interfaces simples, claras y bien definidas.
Diseo fcil de aplicaciones

Cuando se disea una aplicacin, todo lo que se necesita para comenzar es la informacin
declarativa que se escribe en una especificacin de paquete. Usted puede escribirla e incluso
compilarla sin la necesidad de haber creado previamente el cuerpo del mismo.
Ocultamiento de informacin
Dentro de los paquetes se puede especificar que tipos, tems y subprogramas sern pblicos
(visibles y accesibles) o privados (ocultos e inaccesibles). La idea fundamental es dar a
conocer solamente aquellos componentes que pueden ser modificados en alguna instancia,
manteniendo la integridad del paquete en todo momento.
Agregan Funcionalidad
Variables y cursores que han sido empaquetados para su uso pblico persisten durante toda
la duracin de la sesin. As, ellos pueden ser compartidos por todos los subprogramas que
se ejecutan en el mismo ambiente. Con eso tambin se puede mantener la informacin a
travs de todas las transacciones sin tener que almacenarla en la base de datos.
Rendimiento
Cuando se llama a un subprograma empaquetado por primera vez, ste es almacenado
completamente en memoria. De esta manera, las sucesivas llamadas a los subprogramas del
mismo paquete sern ms rpidas. Tambin es posible cambiar la definicin de una funcin
empaquetada sin tener que alterar los subprogramas que la llaman.

8.2
ESPECIFICACIN DE PAQUETES
Una especificacin de paquete contiene declaraciones pblicas. El alcance de esas

declaraciones es local al esquema de base de datos y global al paquete. As, los tems
declarados son accesibles desde su aplicacin y desde cualquier lugar dentro del mismo
paquete.
La siguiente es una declaracin de funcin que es posible encontrar en una especificacin de
paquete:
FUNCTION factorial (n INTEGER) RETURN INTEGER; -- devuelve el factorial de n
Esta es toda la informacin que usted requiere para llamar posteriormente a la funcin
factorial.
El contenido de un paquete puede ser referenciado de esta manera incluso desde triggers de
base de datos, procedimientos almacenados y otras herramientas de Oracle.
8.3
CUERPO DE UN PAQUETE
El cuerpo de un paquete implementa una especificacin de paquete. Contiene la definicin

de cada cursor y subprograma declarado en la especificacin. Recuerde que todos los
subprogramas definidos en el cuerpo de un paquete estarn accesibles solamente si han sido
especificados previamente.
En un cuerpo pueden encontrarse tambin declaraciones privadas (tipos y otros tems)
necesarias dentro del paquete y cuyo alcance se limita tambin al cuerpo del mismo y no est
disponible para ser accesado desde otros paquetes.
Si en una declaracin de paquete slo se encuentran declaraciones de tipos, constantes,
variables y excepciones el cuerpo del paquete se hace innecesario. Sin embargo, se reitera
que cualquier definicin de cursor o subprograma debe estar implementada en el cuerpo del
mismo paquete.

El paquete STANDARD
Dentro de PL/SQL existe un paquete llamado standard, el cual provee el conjunto de tipos,
excepciones y subprogramas que estn disponibles automticamente en el ambiente de
trabajo de PL/SQL.
Por ejemplo, en l se define la funcin ABS, que retorna el valor absoluto de un argumento y
que se define como sigue:
FUNCTION ABS (n NUMBER) RETURN NUMBER;
El contenido del paquete standard es visible desde todas las aplicaciones y puede ser
accesado incluso desde triggers y procedimientos almacenados. Si usted decidiera redeclarar
la funcin ABS puede hacerlo. Sin embargo, an tendra la posibilidad de referenciar la
funcin del mismo nombre que existe en el paquete standard, utilizando la notacin punto,
como en: STANDARD.ABS(x)
La mayora de las funciones de conversin preconstruidas en PL/SQL son polimrficas. Por

ejemplo, el paquete standard contiene las siguientes declaraciones:
FUNCTION TO_CHAR(right DATE) RETURN VARCHAR2 ;

FUNCTION TO_CHAR(left NUMBER) RETURN VARCHAR2 ;
FUNCTION TO_CHAR(left DATE, right VARCHAR2) RETURN VARCHAR2 ;
FUNCTION TO_CHAR(left NUMBER, right VARCHAR2) RETURN VARCHAR2 ;
PL/SQL resuelve la llamada a la instancia de la funcin que corresponda observando los

tipos de datos de los parmetros actuales y formales.

BIBLIOGRAFIA
Este documento ha sido organizado en su totalidad a partir de as siguientes
refefrencias bibliogrficas. Se han realizado algunos cambios a los mismos con el fin
de crear un texto gua para el presente curso. No se encontraron autores de los
mismos, sin embargo se coloca las fuentes de Internet en los cuales fueron
encontrados.
Su uso es expresamente academico de acuerdo a las Leyes de derecho de Autor:
1. Manual del Curso de PL SQL. http://www.taringa.com. Consultado 17 de Junio
de 2009.
2. Introduccin al Desarrollo de Aplicaciones ORACLE. Conceptos Bsicos de SQL
PLUS. http://www.taringa.com. Consultado 17 de Junio de 2009.

ANEXO A: LABORATORIOS DEL CURSO
Laboratorio #1
Objetivo:
Al finalizar el primer laboratorio, el alumno se familiarizar con PL/SQL y el ambiente de
desarrollo SQL plus. Manejo de variables y tipos de datos. Tambin aprender los primeros
pasos en la creacin de programas.
Procedimiento:
1. Abrir el entorno de trabajo de SQL plus y conocer la interfaz de trabajo de este software,
especficamente en el ambiente en que se desarrollan los programas con PL/SQL.
-
Se presentaran diversos ejemplos sobre manejo de SQL con los datos.
2. Como requerimiento opcional, el alumno podr investigar la herramienta SQL plus con
el fin de soltar la mano en el manejo de sta.
Fin del Laboratorio #1

Laboratorio #2
Objetivo:
Al final del segundo laboratorio, el alumno aprender a construir aplicaciones utilizando
todas las estructuras de control aprendidas hasta aqu. Tambin ejercitar la construccin de
sentencias SQL utilizndolas contra la base de datos de ejemplo.
Procedimiento:
1. Abrir el entorno de trabajo de SQL plus y crear un procedimiento que realice diferentes
tareas donde sea obligatorio el uso de las sentencias de control de flujo aprendidas
(condicionales e iterativas).
2. Se debern ejecutar consultas SQL contra la base de datos que efecten las tareas
indicadas en el mismo momento del laboratorio por su profesor.

Laboratorio #3
Objetivo:
En este laboratorio se efectuar un reforzamiento de todos los temas vistos en clases y se
completar con la prctica del manejo de cursores.
Procedimiento:
1. Repasar las estructuras de control, bloques y dems componentes de un programa vistos
en clases.
2. Se practicar con la declaracin, apertura, utilizacin (recuperacin de filas) y cierre de
los cursores.
3. Se usarn los atributos de los cursores en programas creados en el mismo laboratorio.
4. De manera opcional se mostrar un programa real construido en un proyecto de DMR.

Laboratorio #4
Objetivo:
Al final del laboratorio, el alumno habr aprendido a manejar excepciones dentro de un
programa. Conocer la forma en que estas se gatillan y como manejar el error para evitar
cadas fatales de los programas en tiempo de ejecucin.
Procedimiento:
1. Se provocarn de manera intencional varios errores para estudiar el comportamiento de
un programa en esos casos.
2. Al final del laboratorio deber existir un programa (puede ser alguno creado en un
laboratorio anterior) totalmente estable, es decir, que acepte cualquier tipo de error y lo
maneje de manera adecuada.

Laboratorio #5
Objetivo:
El alumno aprender cmo crear procedimientos y funciones y cmo comunicarlos mediante
el uso de parmetros de entrada, salida y de entrada/salida.
Procedimiento:
1. El alumno crear un procedimiento nuevo que reciba cierta cantidad de parmetros.
2. Luego, crear otro procedimiento diferente que efectuar un llamado al primero y lo
obligar a ejecutarse con ciertos valores en sus parmetros.
3. A continuacin se crear una funcin que ser llamada desde ambos procedimientos. Se
debern probar las caractersticas de recursividad de las funciones.
4. Finalmente y en forma opcional se debern probar las caractersticas de polimorfismo de
las funciones, implementando el ejemplo que aparece en el manual del curso.

Laboratorio #6
Objetivo:
Al finalizar este laboratorio, el alumno estar en condiciones de crear especificaciones y
cuerpos de paquetes.
Procedimiento:
1. El alumno crear una especificacin de paquete que comprenda todas las funciones y
procedimientos creados en los laboratorios del curso. Slo se crear un package
specification.
2. En el cuerpo del paquete deber copiar la definicin de todos sus subprogramas que
declar en la seccin de especificacin del paquete que est creando.

ANEXO B: MODELO DE DATOS DEL LIBRO DE REFERENCIA
EMPLEADO
Atributo
Cdigo
Nombres
Ap. Paterno
Ap. Materno
Sexo
Fecha Ncto.
Renta
Cargo
Depto.
Valores
100
Sergio
Contreras
Ruiz
M
14/Jul/1965
$220.000
A1
S01
101
Marco Antonio
Fernndez
Castro
M
18/Sep/1970
$185.000
A2
S01
102
Luis Fernando
Crcamo
Vergara
M
15/Oct/1973
$350.000
B1
S02
103
Mara Cecilia
Poblete
Romero
F
03/Ene/1971
$510.000
B1
S03
DEPARTAMENTO
Atributo
Cdigo
Nombre
Valores
S01
Finanzas
S02
Contabilidad
S03
Personal
CARGO
Atributo
Cdigo
Nombre
Renta Mnima
Renta Mxima
Valores
A1
Contador
$200.000
$410.000
A2
Asistente
$120.000
$230.000
B1
Jefe de Area
$350.000
$500.000
CARGAS
Atributo
Cdigo
Nombre
Apellidos
Fecha Ncto.
Cod. Empleado
Valores
C1
Claudia
Fernndez Lara
01/Feb/1992
101
C2
Marta
Fernndez Lara
09/Jul/1998
101
C3
Celia
Crcamo Vera
17/Feb/1988
102
C4
Francisco
Romero Poblete
23/Nov/1990
103

ANEXO C: SCRIPTS DE CREACION DE TABLAS

create table EMPLEADO(
id_empl number(3)
not null,
nomb_empl
varchar2(25)
not null,
apepat
varchar2(15)
not null,
apemat
varchar2(15)
null,
sexo
char(1)
not null,
fechanac
date
null,
renta
number(10)
not null,
id_cargo char(2)
not null,
id_depto char(3)
not null,
CONSTRAINT pk_empleado PRIMARY KEY (id_empl)
);
create table DEPARTAMENTO(
id_depto char(3)
not null,
nomb_depto
varchar2(15)
not null,
CONSTRAINT pk_departamento PRIMARY KEY (id_depto)
);
create table CARGO(
id_cargo char(2)
not null,
nomb_cargo
varchar2(15)
not null,
rentaminnumber(10)
not null,
rentamax
number(10)
not null,
CONSTRAINT pk_cargo PRIMARY KEY (id_cargo)
);
create table CARGAS(
cod_carga
varchar2(3)
not null,
nomb_carga
varchar2(20)
not null,
apell_carga
varchar2(20)
not null,
fnac_carga
date
not null,
id_empl number(3)
not null,
CONSTRAINT pk_cargas PRIMARY KEY (cod_carga)
);

ANEXO D: SCRIPTS DE CARGA DE DATOS

INSERT INTO empleado(id_empl, nomb_empl, apepat, apemat, sexo, fechanac, renta, id_cargo, id_depto)
VALUES (100, Sergio, Contreras, Ruiz, M, TO_DATE(14/07/1965, dd/mm/yyyy), 220000, A1,
S01);
VALUES (101, Marco Antonio, Fernndez, Castro, M, TO_DATE(18/09/1970, dd/mm/yyyy),
185000, A2, S01);
VALUES (102, Luis Fernando, Crcamo, Vergara, M, TO_DATE(15/10/1973, dd/mm/yyyy),
350000, B1, S02);
VALUES (103, Mara Cecilia, Poblete, Romero, F, TO_DATE(03/01/1971, dd/mm/yyyy), 510000,
B1, S03);
INSERT INTO departamento(id_depto, nomb_depto) VALUES (S01, Finanzas);
INSERT INTO departamento(id_depto, nomb_depto) VALUES (S02, Contabilidad);
INSERT INTO departamento(id_depto, nomb_depto) VALUES (S03, Personal);
INSERT INTO cargo(id_cargo, nomb_cargo, rentamin, rentamax) VALUES (A1, Contador, 200000,
410000);
INSERT INTO cargo(id_cargo, nomb_cargo, rentamin, rentamax) VALUES (A2, Asistente, 120000,
230000);
INSERT INTO cargo(id_cargo, nomb_cargo, rentamin, rentamax) VALUES (B1, Jefe de Area, 350000,
500000);
INSERT INTO cargas(cod_carga, nomb_carga, apell_carga, fnac_carga, id_empl) VALUES (C1, Claudia,
Fernndez Lara, TO_DATE(01/02/1992, dd/mm/yyyy), 101);
INSERT INTO cargas(cod_carga, nomb_carga, apell_carga, fnac_carga, id_empl) VALUES (C2, Marta,
Fernndez Lara, TO_DATE(09/07/1998, dd/mm/yyyy), 101);
INSERT INTO cargas(cod_carga, nomb_carga, apell_carga, fnac_carga, id_empl) VALUES (C3, Celia,
Crcamo Vera, TO_DATE(17/02/1988, dd/mm/yyyy), 102);
INSERT INTO cargas(cod_carga, nomb_carga, apell_carga, fnac_carga, id_empl) VALUES (C4,
Francisco, Romero Poblete, TO_DATE(23/11/1990, dd/mm/yyyy), 103);

Libro de Referencia Del Curso

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Libro de Referencia Del Curso

Diunggah oleh

Hak Cipta:

Format Tersedia

FACULTAD DE INGENIERA ELECTRNICA Y

ESPECIALIZACIN EN DESARROLLO DE SOLUCIONES

UNIVERSIDAD DEL CAUCA

FACULTAD DE INGENIERA ELECTRNICA Y

Popayn, Colombia, Junio de 2009

Universidad del Cauca

CAPTULO 1: INTRODUCCIN A LA MANIPULACION DE DATOS CON SQL Y ORACLE. 4

DECLARACIN DE CURSORES .............................................................................................................. 73

CAPTULO 6: MANEJO DE ERRORES............................................................................................ 80

CONTROL CONDICIONAL: SENTENCIA IF ............................................................................................. 58

CAPTULO 5: MANEJO DE CURSORES ......................................................................................... 72

SET DE CARACTERES Y UNIDADES LXICAS ........................................................................................ 50

CAPTULO 4: ESTRUCTURAS DEL LENGUAJE........................................................................... 57

CAPTULO 3: FUNDAMENTOS DEL LENGUAJE ......................................................................... 50

FUNCIONES Y TIPOS DE DATOS .................................................................................................. 12

CAPTULO 2: INTRODUCCIN A PL/SQL..................................................................................... 42

COMANDOS DE RECUPERACIN DE INFORMACION.................................................................................. 4

EXCEPCIONES PREDEFINIDAS ............................................................................................................... 80

CAPTULO 7: SUBPROGRAMAS ...................................................................................................... 86

Especializacin en Desarrollo de Soluciones Informticas 2

Universidad del Cauca

CAPTULO 8: PAQUETES .................................................................................................................. 98

USO DE PARMETROS ......................................................................................................................... 91

VENTAJAS DE LA UTILIZACIN DE PAQUETES ...................................................................................... 99

BIBLIOGRAFIA .................................................................................................................................... 103

Especializacin en Desarrollo de Soluciones Informticas 3

Universidad del Cauca

CAPTULO 1: INTRODUCCIN A LA MANIPULACION DE DATOS CON

Los comandos de SQL permiten crear, almacenar, cambiar, recuperar, y mantener la

COMANDOS DE RECUPERACIN DE INFORMACION

Especializacin en Desarrollo de Soluciones Informticas 4

Universidad del Cauca

Especializacin en Desarrollo de Soluciones Informticas 5

Universidad del Cauca

Especializacin en Desarrollo de Soluciones Informticas 6

Universidad del Cauca

Especializacin en Desarrollo de Soluciones Informticas 7

Universidad del Cauca

Especializacin en Desarrollo de Soluciones Informticas 8

Universidad del Cauca

Operadores de comparacin (en orden de precedencia).

Especializacin en Desarrollo de Soluciones Informticas 9

Universidad del Cauca

Especializacin en Desarrollo de Soluciones Informticas 10

Universidad del Cauca

En ocasiones es necesario mostrar la informacin de la base de datos, ordenada por una o ms

Especializacin en Desarrollo de Soluciones Informticas 11

Universidad del Cauca

FUNCIONES Y TIPOS DE DATOS

------------------------------------------------------------------------------------------------------------------Funciones de fecha y hora

Especializacin en Desarrollo de Soluciones Informticas 12

Universidad del Cauca

Retorna el ltimo da del mes "n".

Especializacin en Desarrollo de Soluciones Informticas 13

Universidad del Cauca

Especializacin en Desarrollo de Soluciones Informticas 14

Universidad del Cauca

Especializacin en Desarrollo de Soluciones Informticas 15

Universidad del Cauca

Retorna la informacin sobre el usuario y/o seccin que

Especializacin en Desarrollo de Soluciones Informticas 16

Universidad del Cauca

Especializacin en Desarrollo de Soluciones Informticas 17

Universidad del Cauca