SUBCONSULTAS

DEFINICION DE SUBCONSULTA
UNA SUBCONSULTA ES UNA
SENTENCIA SELECT INCRUSTADA EN
UNA CLAUSULA DE OTRA SENTENCIA
SELECT DE SQL
SELECT <LISTA DE COLUMNAS SELECCIONADAS>
FROM <TABLAS>
WHERE EXPRESION OPERADOR
(SELECT <LISTA DE COLUMNAS SELECCIONADAS>
FROM <TABLA>)
2

SUBCONSULTAS
UNA SUBCONSULTA SE EJECUTA PRIMERO
Y SU RESULTADO ES USADO PARA
COMPLETAR LA CONDICION DE LA
CONSULTA PADRE.
SINTAXIS
UNA SUBCONSULTA DEBE ESTAR ENTRE
PARNTESIS.
UNA SUBCONSULTA DEBE APARECER A LA
DERECHA DEL OPERADOR DE COMPARACION
UNA SUBCONSULTA NO PUEDE CONTENER UN
ORDER BY. SE PUEDE USAR SLO UN ORDER
BY EN UNA SENTENCIA SELECT PADRE.
3

SUBCONSULTA
SELECCIONE EL NOMBRE Y SALARIO
DE AQUELLOS EMPLEADOS QUE SU
TRABAJO (JOB) SEA EL MISMO DEL
EMPLEADO CUYO CDIGO SEA IGUAL
A 7369. Y SALARIOS SEAN MENORES
QUE EL PROMEDIO DEL SALARIO DE
LOS EMPLEADOS.

SUBCONSULTAS
SQL> SELECT JOB FROM EMP WHERE EMPNO=7369;
JOB
--------CLERK
SQL> SELECT AVG(SAL) FROM EMP;
AVG(SAL)
---------2073,21429
SQL> SELECT ENAME, SAL FROM EMP WHERE JOB='CLERK' AND SAL<2073.21429;
ENAME
SAL
---------- ---------SMITH
800
ADAMS
1100
JAMES
950
MILLER
1300
SELECT ENAME,SAL
FROM EMP
WHERE JOB=(SELECT JOB FROM EMP WHERE EMPNO=7369)
AND SAL<(SELECT AVG(SAL) FROM EMP);
ENAME
SAL
---------- ---------SMITH
800
ADAMS
1100
JAMES
950
MILLER
1300

SUBCONSULTAS

EJE.
SELECCIONE LOS NOMBRES Y SUELDOS DE LOS EMPLEADOS QUE
TRABAJAN EN EL MISMO DEPARTAMENTO QUE EL EMPLEADO QUE
TIENE EL MENOR SUELDO.
CUAL ES MENOR SUELDO:
SELECT MIN(SAL) FROM EMP;
800
EN QUE DEPARTAMENTO TRABAJA LA PERSONA QUE TIENE EL
MENOR SUELDO
SELECT DEPTNO FROM EMP WHERE SAL=(SELECT MIN(SAL) FROM
EMP);
20
QUIENES SON LOS EMP Y QUE SUELDO TIENEN LOS EMPLEADOS
QUE TRABAJAN EN EL MISMO DEPARTAMENTO QUE EMPLEADO QUE
TIENE EL MENOR SUELDO.
SELECT ENAME,SAL FROM EMP
WHERE DEPTNO=
(SELECT DEPTNO FROM EMP WHERE SAL=
(SELECT MIN(SAL) FROM EMP));
6

SUBCONSULTA
UNA SUBCONSULTA ES MUY UTIL CUANDO
ESCRIBIMOS SENTENCIAS SQL QUE REQUIEREN
VALORES BASADOS EN VALORES CONDICIONALES
DESCONOCIDOS.
PODEMOS IMAGINAR QUE CADA CONSULTA ES UN
BLOQUE, LAS SUBCONSULTAS SON INTERIORES Y
LA CONSULTA PRINCIPAL ES LA EXTERNA O PADRE.
UNA SUBCONSULTA PUEDE DEVOLVER FILAS
UNICAS ( LAS MAS COMUNES) DENOMINADAS
SUBCONSULTAS DE COLUMNA INDIVIDUAL, EN
LAS CUALES SE UTILIZA OPERADORES DE
COMPARACION COMUNES.
LOS OPERADORES PARA SUBCONSULTAS QUE
DEVUELVEN FILAS MULTIPLES REALIZAN UNA
COMPARACION MULTIPLE.
7

OPERADORES DE COMPARACION

OPERADORES DE
COMPARACION
INDIVIDUAL

OPERADORES DE
COMPARACION
MULTIPLE

IGUAL A

>

MAYOR QUE

>=

MAYOR QUE O IGUAL A

<

MENOR QUE

<=

MENOR QUE O IGUAL

<>

NO IGUAL A

IN

COMPARA UN VALOR A TODOS LOS VALORES QUE

RETORNA UNA SUBCONSULTA

ANY

COMPARA UN VALOR A TODOS LOS VALORES QUE

RETORNA LA SUBCONSULTA Y LA COMPARACION ES
FALSA SI NO DEVUELVE NINGUNA FILA.

ALL

COMPARA EL VALOR A TODOS LOS VALORES QUE

DEVUELVE LA SUBCONSULTA Y DEVUELVE VERDADERO
SI NO DEVUELVE FILAS.
8

LOS COMPARADORES ANY Y ALL

Select * from emp

Where sal>=all
(select sal from emp where deptno=30)
And
Deptno=10;

OPERADORES DE COMPARACION DE FILA

MULTIPLE
SELECCIONE A LOS EMPLEADOS QUE GANAN EL
MISMO SALARIO QUE EL MINIMO POR
DEPARTAMENTO.
SELECT ENAME,SAL,DEPTNO
FROM EMP
WHERE SAL IN
(SELECT MIN(SAL) FROM EMP GROUP BY DEPTNO);
MEJOR SERIA
SELECT ENAME, DEPTNO, SAL FROM EMP WHERE
(DEPTNO,SAL) IN (SELECT DEPTNO,MIN(SAL) FROM
EMP GROUP BY DEPTNO);
10

USANDO SUBCONSULTAS EN LA CLAUSULA FROM

UNA SUBCONSULTA ES UNA FUENTE DE INFORMACION AL IGUAL

QUE UNA TABLA O UNA VISTA.
ES DECIR EL RESULTADO DE UNA CONSULTA ES TABLA
ALMACENADA EN LA MEMORIA DE BASE DE DATOS
HALLE LA RELACION DE EMPLEADOS QUE TIENEN SUELDO MAYOR
QUE EL SUELDO PROMEDIO DEL DEPARTAMENTO.

SELECT A.ENAME, A.SAL,A.DEPTNO,B.SALPROM

FROM EMP A,
(SELECT DEPTNO,AVG(SAL) SALPROM FROM EMP
GROUP BY DEPTNO) B
WHERE A.DEPTNO=B.DEPTNO AND A.SAL>B.SALPROM
ORDER BY A.ENAME;

11

SUBCONSULTA DE MULTIPLES COLUMNAS

SELECT ENAME,SAL,DEPTNO
FROM EMP
WHERE (DEPTNO,SAL) IN
(SELECT DEPTNO, MIN(SAL)
FROM EMP
GROUP BY DEPTNO);

12

SUBCONSULTAS CORRELACIONADAS
QUE EMPLEADOS GANAN MAS
SALARIO QUE EL SALARIO PROMEDIO
DE SU RESPECTIVO DEPARTAMENTO.
SQL> SELECT DEPTNO,ENAME,SAL
2 FROM EMP E
3 WHERE SAL>(SELECT AVG(SAL) FROM EMP WHERE E.DEPTNO=DEPTNO)
4 ORDER BY DEPTNO;
DEPTNO ENAME SAL
---------- ---------- ---------10 KING
5000
20 JONES
2975
20 SCOTT
3000
20 FORD
3000
30 BLAKE
2850

13

SUBCONSULTA CORRELACIONADA
UNA SUBCONSULTA CORRELACIONADA ES UNA
SUBCONSULTA QUE SE EVALUA UNA VEZ POR CADA FILA
PROCESADA POR LA SENTENCIA PADRE.
LA CONSULTA PADRE PUEDE SER UN SELECT, UPDATE O
DELETE.
ORACLE REALIZA UN SUBCONSULTA CORRELACIONADA
CUANDO LA SUBCONSULTA REFERENCIA UNA COLUMNA DE
LA TABLA DE LA CONSULTA PADRE.
FUNCIONA DE LA SIGUIENTE MANERA:
TRAE UNA FILA CANDIDATA (TRAIDA POR LA CONSULTA
EXTERNA)
EJECUTA LA CONSULTA INTERNA USANDO EL VALOR DE FILA
CANDIDATA
USA LOS VALORES OBTENIDOS DE LA CONSULTA INTERNA PARA
CALIFICAR O DESCALIFICAR LA CANDIDATA.
REPETIR MIENTRAS EXISTAN FILAS CANDIDATAS.

14

15

SUBCONSULTA CORRELACIONADA
SQL> SELECT EMPNO,SAL,DEPTNO
2 FROM EMP EXTERNA
3 WHERE SAL>
4 (SELECT AVG(SAL) FROM EMP INTERNA
5 WHERE
6 EXTERNA.DEPTNO=INTERNA.DEPTNO);
EMPNO
SAL DEPTNO
---------- ---------- ---------7566
2975
20
7698
2850
30
7788
3000
20
7839
5000
10
7902
3000
20
COMO LA CONSULTA EXTERNA (OUTER) Y LA INTERNA (INNER) AMBAS USAN
LA TABLA EMP EN LA CLAUSULA FROM SE LE DA UN ALIAS EN CADA
SELECCION PARA MAYOR CLARIDAD.
EL ALIAS NO SOLO HACE QUE LA SELECCIN COMPLETA SEA LEIBLE Y
COMPRENSIBLE, SINO QUE SIN EL NO SE EJECUTA CORRECTAMENTE, LA
SENTENCIA INTERNA NO PODRIA DISTINGUIR LA COLUMNA DE LA TABLA
INTERNA DE LA EXTERNA.
16

EXISTS
ES UN OPERADOR LGICO (VERDADERO O FALSO). VERIFICA
SI UN VAOR ESTA O NO.
HALLAR AQUELLOS EMP A LOS QUE AL MENOS UNA PERSONA
LES REPORTA (SON JEFES DE POR LO MENOS UNA
PERSONA).
SELECT EMPNO, ENAME, JOB, DEPTNO
FROM EMP OUTER
WHERE EXISTS
(SELECT EMPNO FROM EMP INNER WHERE INNER.MGR=OUTER.EMPNO);
EMPNO ENAME
JOB
---------- ---------- --------- ---------7566 JONES
MANAGER
7698 BLAKE
MANAGER
7782 CLARK
MANAGER
7788 SCOTT
ANALYST
7839 KING
PRESIDENT
7902 FORD
ANALYST

DEPTNO
20
30
10
20
10
20

6 filas seleccionadas.
17

EXISTS
CUANDO NO SEA NECESARIO DEVOLVER VALORES
DE COLUMNAS Y SOLO IMPORTE QUE EXISTE UNA
FILA O MAS QUE CUMPLAN LAS CONDICIONES, SE
USA EXISTS
HALLE LOS DEPT QUE NO TIENEN EMPLEADOS:
SQL> SELECT DEPTNO, DNAME
2 FROM DEPT
3 WHERE NOT EXISTS
4 (SELECT 1 FROM EMP WHERE DEPT.DEPTNO=EMP.DEPTNO);
DEPTNO DNAME
---------- -------------40 OPERATIONS

PARA OBTENER ESTA FILA SE HA DEVUELTO UN UNO EN LA SUBCONSULTA

AL NO ENCONTRAR NINGUNA FILA QUE TENGA NUMEROS DE
DEPARTAMENTOS A LOS QUE APUNTA LA CONSULTA PADRE.
18

TRANSACCIONES

EL SERVIDOR ORACLE SE ASEGURA DE MANTENER LA

CONSISTENCIA DE DATOS A TRAVES DE LAS TRANSACCIONES.
LAS TRANSACCIONES LE DAN MAYOR FLEXIBILIDAD Y CONTROL
CUANDO SE CAMBIAN LOS DATOS Y SE ASEGURA DE MANTENER
LA CONSISTENCIA DE LOS DATOS EN EL EVENTO DEL PROCESO
DEL USUARIO QUE FALLE O SI FALLA EL SISTEMA.
LAS TRANSACCIONES SON SENTENCIAS DEL SISTEMAS DEL
LENGUAJE DE MANIPULACION DE DATOS QUE HACEN UN CAMBIO
DE DATOS CONSISTENTE.
UNA TRANSACCION SE INICIA CUANDO LA 1RA SENTENCIA
EJECUTABLE ES ENCONTRADA Y TERMINA CUANDO OCURRE
ALGUNA DE LAS SIGUIENTES ACCIONES:

SE EJECUTA UNA SENTENCIA COMMIT O ROLLBACK

ES EJECUTADA UNA SENTENCIA DDL.
SE EJECUTA UNA SENTENCIA GRANT O REVOKE
EL USUARIO SALE DEL SQL +
LA MAQUINA O SISTEMA FALLE

DESPUES DE QUE UNA TRANSACCION TERMINE, LA SIGUIENTE

SENTENCIA EJECUTABLE AUTOMATICAMENTE INICIA LA SIGUIENTE
TRANSACCION.

19

COMMIT
PARA TERMINAR UNA TRANSACCION
Y HACER QUE LOS CAMBIOS
REALIZADOS A LA BASE DE DATOS
SEAN PERMANENTES.
NO SE REQUIEREN PRIVILEGIOS
PARA REALIZAR UN COMMIT;

20

ROLLBACK
ELIMINA TODOS LOS CAMBIOS QUE HA
RECIBIDO LA BASE DE DATO HASTA EL
ULTIMO COMMIT.

21

SAVEPOINT
SIRVE PARA IDENTIFICAR UN PUNTO
DE UNA TRANSACCION A LA QUE
POSTERIORMENTE PODEMOS
REGRESAR CON UN ROLLBACK
UPDATE emp SET sal = 2000 WHERE ename = 'BLAKE';
SAVEPOINT blake_sal;
UPDATE emp SET sal = 1500 WHERE ename = 'CLARK';
SAVEPOINT clark_sal;
SELECT ENAME,SAL FROM emp
WHERE ENAME ='BLAKE' OR ENAME = 'CLARK';
ROLLBACK TO SAVEPOINT blake_sal;
SELECT ENAME,SAL
FROM emp
WHERE ENAME ='BLAKE' OR ENAME = 'CLARK';
ROLLBACK;
22

LENGUAJE DE
PROCEDIMIENTO PARA
SQL

23

DEFINICION DE PLSQL
PL/SQL SUPLEMENTA EL LENGUAJE ESTANDAR DE BASE DE
DATOS RELACIONALES, CON AMPLIO RANGO DE
POSIBILIDADES DE PROCESAMIENTO
PL/SQL ES UN LENGUAJE PROCEDIMENTAL (PROGRAMA
DEFINIDO COMO UNA SERIE DE ORDENES QUE SE EJECUTAN
SECUENCIALMENTE, PARA PRODUCIR UN RESULTADO), QUE
SOPORTA PROGRAMAS NOMBRADOS Y PAQUETES, MUCHA
DE SU SINTAXIS FUE COPIA DEL LENGUAJE ADA Y DEL
ORACLE LAS FUNCIONES PREHECHAS ASI COMO LOS TIPOS
DE DATOS.
PERMITE LA CONSTRUCCION DE PROGRAMAS QUE
CONSISTEN EN SECUENCIAS DE SENTENCIAS SQL
COMBINADAS CON SENTENCIAS DE CONTROL.

24

CONCEPTOS BASICOS DEL PL/SQL

PL/SQL ESTA ESTRUCTURADO EN BLOQUES Y PUEDE USAR SENTENCIAS

CONDICIONALES, BUCLES Y SALTOS PARA CONTROLAR EL FLUJO DEL
PROGRAMA.
LAS VARIABLES PUEDEN SER DEFINIDAS DE TAL FORMA DE QUE SEAN
VISIBLES UNICAMENTE EN EL BLOQUE DONDE SE LES DECLARE.
LOS PROCEDIMIENTOS DEL PL/SQL SON DE 3 TIPOS, PROCEDIMIENTOS
ANONIMOS, PROCEDIMIENTOS NOMBRADOS Y FUNCIONES NOMBRADAS.
UN PROCEDIMIENTO ANONIMO ES UN PROCEDIMIENTO SIN NOMBRE Y NO
PUEDE SER LLAMADO.
UN PROCEDIMIENTO CON NOMBRE PUEDE SER LLAMADO, PUEDE ACEPTAR
PARAMETROS PERO NO PUEDE DEVOLVER NINGUN VALOR.
UNA FUNCION NOMBRADA TAMBIEN PUEDE SER LLAMADA, PUEDE ACEPTAR
PARAMETROS Y CASI SIEMPRE DEVUELVE VALORES.
UN PROCEDIMIENTO TIENE LA SIGUIENTES PARTES:

DECLARE EN DONDE SE DEFINEN LAS VARIABLES O OBJETOS

BEGIN SENTENCIAS SQL O CONTROL QUE CONSTRUYEN LOS BLOQUES.
EXCEPTION AREA DONDE SE MANIPULAN LAS EXCEPCIONES.
END; MARCADOR DE FIN DE BLOQUE.

25

CONCEPTOS BASICOS DEL PL/SQL

EJE :DECLARE
TEMP_COMM EMP.COMM%TYPE;
BEGIN
SELECT NVL(COMM,0) INTO TEMP_COMM FROM EMP
WHERE EMPNO = 7934;
IF TEMP_COMM > 0 THEN
UPDATE EMP
SET COMM = (TEMP_COMM*1.175) WHERE EMPNO =7934;

ELSE
UPDATE EMP
SET COMM = 200 WHERE EMPNO = 7934;

END IF;
COMMIT;
EXCEPTION
WHEN NO_DATA_FOUND THEN
INSERT INTO ERRORES (CODE, MESSAGE) VALUES(99, EMPNO 21 NOT FOUND');
END;

26

VARIABLES Y CONSTANTES: ESTOS OBJETOS SON USADOS PARA

ALMACENAR Y MANIPULAR DATOS. PUEDEN SER DEL TIPO CHAR,
VARCHAR2, NUMBER, DATE O BOOLEAN
TODAS LAS SENTENCIAS SQL SON SOPORTADAS POR EL PL/SQL
INCLUYENDO SENTENCIAS DE CONTROL DE TRANSACCIONES.
REGISTROS DE TIPOS DE DATOS COMPUESTOS SOPORTAN
GRUPOS DE CAMPOS.
EL CONTROL DE FLUJO SE REALIZA A TRAVES DE IF Y GOTO Y
ETIQUETAS.
MANIPULACION DE CURSORES (AREA DE MEMORIA QUE MANTIENE
UN CONJUNTO RESULTADO DE FILAS) PUEDE SER DEFINIDA Y
MANIPULADA PERMITIENDO EL PROCESO DE MULTIPLES FILAS UNA
A UNA.
EL BLOQUE DE MANIPULACION DE EXCEPCIONES TIENE LA
HABILIDAD DE CAPTURAR Y MANIPULAR CONDICIONES DE ERROR
(EXCEPCIONES IMPLICITAS).
ES POSIBLE GENERAR EXCEPCIONES EXPLICITAS CON LA LOGICA
DEL PROGRMA Y LOS ERRORES DE DATOS
BLOQUES DE CODIGO SE PUEDEN ALMACENAR COMO OBJETOS
DEL ORACLE COMO PROCEDIMIENTOS, FUNCIONES, PAQUETES
(PACKAGE) O TRIGGERS (DISPARADORES).

27

 EL CODIGO PL/SQL SIEMPRE DEBE CONSTITUIR UN BLOQUE.

COMO MINIMO DEBE ESTAR DELIMITADO POR LAS PALABRAS
BEGIN Y END.
LAS SENTENCIAS SELECT SON SENTENCIAS SQL
INCRUSTADAS EN EL PL/SQL.
LAS SENTENCIAS SELECT DEBEN RETORNAR SOLO UNA
FILA. SI NO DEVUELVE FILAS O DEVUELVE MAS DE UNA FILA
GENERARA UN ERROR
SI SE DESEA MANIPULAR UN GRUPO DE FILAS SE DEBE
MANIPULAR CON UN CURSOR
LA CLAUSULA INTO ES MANDATORIA PARA LAS SENTENCIAS
SELECT PARA ALMACENAR LOS VALORES QUE DEVUELVEN.
SI SE INCLUYE UNA SECCION EXCEPTION, LAS SENTENCIAS
PROGRAMADAS EN ELLA SOLO SON PROCESADAS SI LA
CONDICION A LA QUE SE REFIEREN OCURRE.
LA EJECUCION DE UN BLOQUE SE TERMINA DESPUES DE
QUE SE EJECUTA LA RUTINA DE EXCEPTION SE EJECUTA.
LOS BLOQUES DEL PL/SQL PUEDEN ANIDARSE, EL
ANIDAMIENTO PUEDE SER UBICADO EN CUALQUIER PARTE
DEL BLOQUE, INCLUIDA LA SECCION EXCEPTION.
28

DECLARANDO VARIABLES Y CONTANTES

DECLARE
V_NUM1 NUMBER NOT NULL := 10109;
NUM8 NUMBER(3,1);
XYZ NUMBER(2,2) := 31.8;
ABC12 NUMBER(9,2) := XYZ * 131;
V_CHR1 CHAR(89);
V_CHR2 VARCHAR2(12) := "JANUARY";
TODAY DATE := SYSDATE;
TRUEFALSE BOOLEAN;
DECLARE
PI CONSTANT NUMBER(9,3) := 3.142;
VAT CONSTANT NUMBER(4,2) := 17.5;
DECLARE
V_NUM1 JD11.BOOK.COST%TYPE;
29

REGISTROS DE PL/SQL
LOS REGISTROS SON VARIABLES QUE CONTIENEN UNA COLECCION
SEPARADA DE CAMPOS.
CADA CAMPO INDIVIDUALMENTE ES DIRECCIONABLE Y
REFERENCIABLE
LOS CAMPOS EN UN REGISTRO PUEDEN SER DE DIFERENTES TIPOS
DE DATOS Y TAMAOS COMO COLUMNAS EN UNA TABLA
LOS REGISTROS SON UNA MANERA CONVENIENTE DE ALMACENAR
UNA FILA DE UNA TABLA DE LA BASE DE DATOS.
USE EL ATRIBUTO %ROWTYPE PARA DECLARAR UN REGISTRO
BASADO EN UNA FILA DE UNA TABLA. LOS CAMPOS TOMAN LOS
NOMBRES Y TIPOS DE DATOS DE LAS COLUMNAS DE LA TABLA O
VISTA.
(V_ENAME VARCHAR)
IS
R_EMP EMP%ROWTYPE;
BEGIN
SELECT * INTO R_EMP FROM EMP
WHERE EMP.ENAME=V_ENAME;
DBMS_OUTPUT.PUT_LINE('R_EMP.EMPNO :'||R_EMP.EMPNO);
END;

30

PROCEDIMIENTO ANNIMO

SET SERVEROUTPUT ON; --ACTIVA LA VARIABLE DE ENTORNO SERVEROUTPUT

DECLARE
V_ENAME EMP.ENAME%TYPE := 'BLAKE';
/*V_ENAME SER DEL MISMO TIPO DE DATO QUE EMP.ENAME
Y TENDRA POR VALOR INICIAL BLAKE*/
R_EMP EMP%ROWTYPE;
BEGIN
SELECT * INTO R_EMP FROM EMP
WHERE EMP.ENAME=V_ENAME;
DBMS_OUTPUT.PUT_LINE('D''ONOFRIO'||'EMP.EMPNO :'||R_EMP.EMPNO);
/*ESCRIBE EN PANTALLA, SE USA PARA PROBAR LOS RESULTADOS
DE NUESTROS PROCEDIMIENTOS*/
END;

31

SET SERVEROUTPUT ON;

DECLARE
V_ENAME EMP.ENAME%TYPE := 'BLAKE';
R_EMP EMP%ROWTYPE;
BEGIN
SELECT * INTO R_EMP FROM EMP
WHERE EMP.ENAME=V_ENAME;
DBMS_OUTPUT.PUT_LINE('R_EMP.EMPNO :'||R_EMP.EMPNO);
END;

32

DECLARE
start_time CHAR(8);
finish_time CHAR(8);
elapsed_time NUMBER(10);
BEGIN
/* Get system time as seconds past midnight. */
SELECT TO_CHAR(SYSDATE,'SSSSS') INTO start_time FROM sys.dual;
-- do something
/* Get system time again. */
SELECT TO_CHAR(SYSDATE,'SSSSS') INTO finish_time FROM sys.dual;
/* Compute elapsed time in seconds. */
elapsed_time := finish_time - start_time;
dbms_output.put_line(finish_time||' '||start_time||' '|| elapsed_time);
END;

33

ASIGNACIONES
SE PUEDEN ASIGNAR VALORES A UNA
VARIABLE EN CUALQUIER PARTE DEL
BLOQUE, INCLUYENDO EN LA SECCION DE
CREACION DE UNA VARIABLE.
NUM1 := NUM1 + NUM2 + (NUM3 * 3);
ANUM3 := AVG_COST * 7 + NVL(AVG_BUY_COST, 0);
SENT := 1;
STR1 := El sueldo es = '|| TO_CHAR(SAL);
CHR1 := 'ABCDEFG';
FLAG1 := TRUE;FLAG1 := FALSE;
MALE := UPPER(TITLE);
34

CURSORES IMPLICITOS

CUANDO SE EJECUTA UNA SENTENCIA SQL EL SERVIDOR DE BASE

DE DATOS ABRE UN AREA DE MEMORIA EN DONDE EL COMANDO
ES COMPILADO Y EJECUTADO. ESTA AREA SE LE DENOMINA
CURSOR
PL/SQL PROVEE ALGUNOS ATRIBUTOS QUE PERMITE EVALUAR
QUE SUCEDE CUANDO UN CURSOR IMPLICITO SE TERMINA DE
USAR.

35

CURSORES EXPLICITOS
LOS SELECT QUE SE PRESENTAN EN EL PL/SQL SON
CONOCIDOS COMO INCRUSTADOS.
DEBEN RETORNAR UNA FILA
SI RETORNA MAS DE UNA FILA SE REQUIERE MANIPULAR LOS
DATOS MEDIANTE UN CURSOR.
LOS CURSORES SON CONTROLADOS POR LOS SIGUIENTES
COMANDOS:
DECLARE

DEFINE EL NOMBRE Y ESTRUCTURA DEL CURSOR JUNTO CON LA

SENTENCIA SELECT QUE PUEBLE EL CURSOR CON DATOS. LA
CONSULTA ES VALIDADA PERO NO EJECUTADA.

OPEN

EJECUTA LA CONSULTA QUE PUEBLA EL CURSOR CON FILAS.

FETCH

CARGA LA FILA DIRECCIONADA POR EL PUNTERO DEL CURSOR EN

LAS VARIABLES Y MUEVE EL PUNTERO DEL CURSOR A LA SIGUIENTE
FILA.

CLOSE

LIBERA LOS DATOS DEL CUROSR Y LOS CIERRA. EL CURSOR PUEDE

SER REABIERTO PARA REFRESCAR SUS DATOS.
36

ATRIBUTOS DE LOS CURSORES

%ROWCOUNT

NUMERO DE FILAS PROCESADAS POR LA SENTENCIA SQL.

%FOUND

TRUE SI POR LO MENOS UNA FILA FUE PROCESADA.

%NOTFOUND

TRUE SI NINGUNA FILA FUE PROCESADA

%ISOPEN

TRUE SI EL CURSOR ESTA ABIERTO.

FALSE SI EL CUROSR NO HA SIDO ABIERTO O SE HA CERRADO.
SOLO PARA CURSORES EXPLICITOS.

is
cursor c1 is
select empno,ename,job,sal from emp;
r_emp c1%rowtype;
begin
open c1;
dbms_output.put_line(c1%ROWCOUNT||' '||r_emp.empno||'>>>>>>>>');
loop
fetch c1 into r_emp;
exit when c1%notfound;
dbms_output.put_line('**'||c1%ROWCOUNT||' '||' '||r_emp.empno);
end loop;
37
close c1;
end;

SQL> set serveroutput on

SQL> exec cursor01;
0 >>>>>>>>
**1 7369
**2 7499
**3 7521
**4 7566
**5 7654
**6 7698
**7 7782
**8 7788
**9 7839
**10 7844
**11 7876
**12 7900
**13 7902
**14 7934
Procedimiento PL/SQL terminado correctamente.

38

EJE. CURSORES EXPLICITOS

DECLARE
CURSOR MYCUR IS SELECT ISBN, COST FROM JD11.BOOK;
THISISBN NUMBER(10);
THISCOST NUMBER(10,2);
BEGIN
OPEN MYCUR;
LOOP
FETCH MYCUR INTO THISISBN, THISCOST;
EXIT WHEN MYCUR%NOTFOUND;
END LOOP;
CLOSE MYCUR;
END;

39

EJE. CURSORES EXPLICITOS

DECLARE
CURSOR MYCUR IS
SELECT ISBN, COST FROM JD11.BOOK;
PARTBOOK MYCUR%ROWTYPE;
BEGIN
OPEN MYCUR;
LOOP
FETCH MYCUR INTO PARTBOOK;
EXIT WHEN MYCUR%NOTFOUND;
IF PARTBOOK.ISBN = 21 THEN PARTBOOK.COST = 19.10;
END IF;
END LOOP;
CLOSE MYCUR;
END;

40

EJE. CURSORES EXPLICITOS

DECLARE
CURSOR MYCUR IS SELECT ISBN, COST FROM JD11.BOOK;
PARTBOOK MYCUR%ROWTYPE;
BEGIN
OPEN MYCUR;
LOOP
FETCH MYCUR INTO PARTBOOK;
EXIT WHEN MYCUR%NOTFOUND;
IF PARTBOOK.ISBN = 21 THEN
DELETE FROM JD11.BOOK
WHERE CURRENT OF MYCUR;
END IF;
END LOOP;
CLOSE MYCUR;
END;
41

as
cursor c1 is select empno,deptno, sal, nvl(comm,0) v_comm from emp order by deptno;
r_emp c1%rowtype;
begin
open c1;
loop
fetch c1 into r_emp;
exit when c1%notfound;
dbms_output.put_line(r_emp.empno||' '||r_emp.v_comm||' '||r_emp.deptno);
if r_emp.v_comm>0 and r_emp.deptno=10 then
begin
r_emp.v_comm:=r_emp.v_comm*1.10;
dbms_output.put_line
(r_emp.empno ||'nueva comisin '||r_emp.v_comm) ;
end;
elsif r_emp.v_comm=0 and r_emp.deptno=20 then
begin
r_emp.v_comm:=r_emp.v_comm+500;
dbms_output.put_line
(r_emp.empno ||'nueva comisin '||r_emp.v_comm) ;
end;
elsif r_emp.v_comm>0 and r_emp.deptno=30 then
begin
r_emp.v_comm:=r_emp.v_comm+650;
dbms_output.put_line
(r_emp.empno ||'nueva comisin '||r_emp.v_comm) ;
end;
end if;
end loop;
close c1;
end;

42

(NUMIN NUMBER,DENOMINADOR NUMBER)

IS
X NUMBER;
BEGIN
X := NUMIN / DENOMINADOR;
DBMS_OUTPUT.PUT_LINE('DIVISION :'||X);
EXCEPTION
WHEN ZERO_DIVIDE THEN
DBMS_OUTPUT.PUT_LINE('DIVISION POR 0');
WHEN OTHERS THEN
DBMS_OUTPUT.PUT_LINE('ALGUN OTRO PROBLEMA');
END DBZ_EXCEPTION;

43

MANIPULACION DE
EXCEPCIONES

SQL PERMITE DETECTAR Y PROCESAR CONDICIONES DE ERROR

PREDEFINIDOS O DEFINIDOS POR EL USUARIO. DENOMINADO
EXCEPCIONES.
CUANDO OCURRE UN ERROR UNA EXCEPCIN SE LEVANTA, LA
EJECUCIN NORMAL SE DETIENE Y TRANSFIERE EL CONTROL A LA
PARTE DE MANIPULACIN DEL ERROR DEL BLOQUE DE PL/SQL.
LAS EXCEPCIONES PREDEFINIDAS SON LEVANTADAS
IMPLCITAMENTE, LAS EXCEPCIONES DEFINIDAS POR EL USUARIO
DEBEN SER EXPLCITAMENTE LEVANTADAS EXPLCITAMENTE CON
UN SENTENCIA RAISED.
SI SU CODIGO NO MANEJA UNA EXCEPCIN, EL PROGRAMA
TERMINAR NORMALMENTE EN EL FIN DEL CDIGO PL/SQL Y EL
CONTROL SE PASARA EL CONTROL AL SISTEMA OPERATIVO.
SI SE CREAN EXCEPCIONES PROPIAS SE EMPLEA LA SENTENCIA
RAISE_APLICATION_ERROR .
PERMITE QUE LOS USUARIOS PREDEFINAN SUSMENSAJES DE
ERROR. LOS RANGOS DE ERRORES SE NUMERAN DE -20000 A
-20999.
44

CREATE TABLE TEMP (

C1 NUMBER,
C2 NUMBER,
C3 CHAR(3));

INSERT INTO TEMP VALUES(-1,1,ABC);

DECLARE
BAD_VALUE EXCEPTION;
C1_VAL NUMBER;
BEGIN
SELECT C1 INTO C1_VAL FROM TEMP WHERE C2=1;
IF C1_VAL<0 THEN
RAISE BAD_VALUE;

ELSE
DBMS_OUTPUT.PUT_LINE(OK)
END IF;
EXCEPTION
WHEN BAD_VALUE
THEN
DBMS_OUTPUT.PUT_LINE(EXCEPCION CAPTURADA);
WHEN NO_DATA_FOUND THEN
DBMS_OUTPUT.PUT_LINE(NO HAY DATOS);

END;
.
/
UPDATE TEMP SET C1=10 WHERE C2=1;

45

EXCEPCIONES PREDEFINIDAS

CURSOR_ALREADY_OPEN
INVALID_CURSOR
INVALID_NUMBER
OUT_VAL_ON_INDEX
NO_DATA_FOUND
LOGIN_DENIED
NOT_LOGGED_ON
PROGRAM_ERROR
ROWTYPE_MISMATCH
STORAGE_ERROR
TIMEOUT_ON_RESOURCE
46

DECLARE
BAD_VALUE EXCEPTION;
C1_VAL NUMBER;
BEGIN
SELECT C1 INTO C1_VAL FROM TEMP WHERE C2=1;
IF C1_VAL<0 THEN
RAISE BAD_VAL;

ELSE
DBMS_OUTPUT.PUT_LINE(OK)
END IF;
EXCEPTION
WHEN BAD_VAL
THEN
DBMS_OUTPUT.PUT_LINE(EXCEPCION CAPTURADA);
WHEN NO_DATA_FOUND
THEN
DBMS_OUTPUT.PUT_LINE(SIN DATOS);
WHEN OTHERS
THEN
DBMS_OUTPUT.PUT_LINE(EXCEPCION DESCONOCIDA);

47

DECLARE
TEMP_COST JD11.BOOK.COST%TYPE;
TEMP_ISBN JD11.BOOK.ISBN%TYPE;
BEGIN
SELECT ISBN, COST INTO TEMP_ISBN, TEMP_COST FROM
JD11.BOOK WHERE ISBN > 21;
IF TEMP_COST > 0 THEN UPDATE JD11.BOOK SET COST =
(TEMP_COST*1.175) WHERE ISBN > 21;
ELSE UPDATE JD11.BOOK SET COST = 21.32 WHERE ISBN > 21;
END IF;
COMMIT;
EXCEPTION
WHEN NO_DATA_FOUND THEN INSERT INTO JD11.ERRORS (CODE,
MESSAGE) VALUES(99, NOT FOUND);
WHEN TOO_MANY_ROWS THEN INSERT INTO JD11.ERRORS (CODE,
MESSAGE) VALUES(99, TOO MANY);
WHEN OTHERS THEN INSERT INTO JD11.ERRORS (CODE, MESSAGE)
VALUES(99, SOME ERROR OCCURRED);
END;

48

(inval NUMBER)
IS
PARNO EXCEPTION;
IMPARNO EXCEPTION;
BEGIN
IF MOD(inval, 2) = 1 THEN
RAISE IMPARNO;
ELSE
RAISE PARNO;
END IF;
EXCEPTION
WHEN PARNO THEN
RAISE_APPLICATION_ERROR(-20001, 'INGRESO NUMERO
PAR');
WHEN IMPARNO THEN
RAISE_APPLICATION_ERROR(-20999, 'INGRESO NUMERO
IMPAR');
END raise_app_error;

49

EXCEPTIONS

LAS EXCEPCIONE SON IDENTIFICADORES QUE SE LEVANTAN

DURANTE LA EJECUCION DE UN BLOQUE PARA TERMINAR SU
ACCION.
HAY DOS CLASES DE EXCEPCIONES:
PREDEFINIDAS: ORACLE PREDEFINE ERRORES QUE SON ASOCIADAS
CON CODIGOS DE ERROR ESPECIFICOS.
DEFINIDOS POR EL USUARIO: DECLARADAS POR EL USUARIO. SE PUEDE
ASOCIAR CON CODIGO DE ERROR.

LAS EXCEPCIONES SE PROPAGAN EN LOS BLOQUES ANIDADOS

HASTA QUE UNA DE ELLAS SEA MANIPULADA.

DECLARE
TEMP_COST NUMBER(10,2);
TEMP_ISBN NUMBER(10);
BEGIN
SELECT ISBN, COST INTO TEMP_ISBN, TEMP_COST FROM JD11.BOOK WHERE ISBN > 21;
IF TEMP_COST > 0 THEN UPDATE JD11.BOOK SET COST = (TEMP_COST*1.175) WHERE ISBN > 21;
ELSE UPDATE JD11.BOOK SET COST = 21.32 WHERE ISBN > 21;
END IF;
COMMIT;
EXCEPTION
WHEN NO_DATA_FOUND THEN INSERT INTO JD11.ERRORS (CODE, MESSAGE) VALUES(99, 'NOT
FOUND');
WHEN TOO_MANY_ROWS THEN INSERT INTO JD11.ERRORS (CODE, MESSAGE) VALUES(99, 'TOO
MANY');
END;
50

DECLARE
SALARY_ERROR EXCEPTION;
OUT_SALARY NUMBER;
BEGIN
SELECT SAL INTO OUT_SALARY
FROM EMP
WHERE ENAME =SCOTT;
IF OUT_SALARY>10000
THEN
RAISE SALARY_ERROR;

END IF;
EXCEPTION
WHEN SALARY_ERROR
THEN
DBMS_OUTPUT.PUT_LINE(SALARIO EXCEDE 10000);
WHEN OTHERS
THEN
NULL;

END;

51

EXCEPTIONS
DECLARE
TEMP_COST NUMBER(10,2);
TEMP_ISBN NUMBER(10);
ERR_MSG VARCHAR2(100);
ERR_CDE NUMBER;
BEGIN
SELECT ISBN, COST INTO TEMP_ISBN, TEMP_COST FROM JD11.BOOK WHERE ISBN > 21;
IF TEMP_COST > 0 THEN UPDATE JD11.BOOK SET COST = (TEMP_COST*1.175) WHERE ISBN > 21;
ELSE UPDATE JD11.BOOK SET COST = 21.32 WHERE ISBN > 21;
END IF;
COMMIT;
EXCEPTION
WHEN NO_DATA_FOUND THEN INSERT INTO JD11.ERRORS (CODE, MESSAGE) VALUES(99, NOT FOUND);
WHEN TOO_MANY_ROWS THEN INSERT INTO JD11.ERRORS (CODE, MESSAGE) VALUES(99, TOO MANY);
WHEN OTHERS THEN
ERR_MSG := SUBSTR(SQLERRM,1,100); /*MENSAJE DE ERROR*/
ERR_CDE := SQLCODE; /*CODIGO DE ERROR DE ORACLE*/
INSERT INTO JD11.ERRORS (CODE, MESSAGE) VALUES(ERR_CDE, ERR_MSG);
END;

52

EXCEPTIONS
DECLARE
TEMP_COST NUMBER(10,2);
TEMP_ISBN NUMBER(10);
THIS_IS_WRONG EXCEPTION;
BEGIN
SELECT ISBN, COST INTO TEMP_ISBN, TEMP_COST
FROM JD11.BOOK WHERE ISBN < 0;
RAISE THIS_IS_WRONG
EXCEPTION
WHEN THIS_IS_WRONG THEN INSERT INTO
JD11.ERRORS (CODE, MESSAGE) VALUES(99,
OOPS);
END;

53

CREATE TABLE ERRORS (CODE NUMBER, MESSAGE VARCHAR2(100));

TABLE CREATED.

CREATE OR REPLACE procedure EXECPTION_ERRORS

(P_EMPNO NUMBER, P_SUELDO_MIN NUMBER)
IS
SAL_ERROR EXCEPTION;
ERR_MSG VARCHAR(100);
ERR_CODE NUMBER;
V_SAL EMP.SAL%TYPE;
V_COMM EMP.COMM%TYPE;
BEGIN
SELECT SAL, COMM INTO V_SAL, V_COMM
FROM EMP
WHERE EMPNO=P_EMPNO;
IF V_SAL<P_SUELDO_MIN THEN
RAISE SAL_ERROR;
ELSE
NULL;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
ERR_MSG:=SUBSTR(SQLERRM,1,100);
ERR_CODE:=SQLCODE;
INSERT INTO ERRORS VALUES(ERR_CODE,ERR_MSG);
WHEN SAL_ERROR THEN
INSERT INTO ERRORS VALUES(-199,'HAY QUE SUBIR ESTE SALARIO');
END;
54

SQL> EXEC EXECPTION_ERRORS(7900,900);

PL/SQL PROCEDURE SUCCESSFULLY COMPLETED.
SQL> SELECT * FROM ERRORS;
NO ROWS SELECTED
SQL> EXEC EXECPTION_ERRORS(7369,900);
PL/SQL PROCEDURE SUCCESSFULLY COMPLETED.
SQL> SELECT * FROM ERRORS;
CODE MESSAGE
-----------------------------------------------------------------------------------------199 HAY QUE SUBIR ESTE SALARIO
SQL> EXEC EXECPTION_ERRORS(90,900);
PL/SQL PROCEDURE SUCCESSFULLY COMPLETED.
SQL> SELECT * FROM ERRORS;
CODE MESSAGE
-----------------------------------------------------------------------------------------199 HAY QUE SUBIR ESTE SALARIO
100 ORA-01403: NO DATA FOUND
55

(p_empno number, p_sueldo_min number)

is
sal_error exception;
err_msg varchar(100);
err_code number;
v_sal emp.sal%type;
v_comm emp.comm%type;
begin
select sal, comm into v_sal, v_comm
from emp
where empno=p_empno;
if v_sal<p_sueldo_min then
raise sal_error;
else
null;
end if;
exception
when no_data_found then
err_msg:=substr(sqlerrm,1,100);
err_code:=sqlcode;
insert into errors values(err_code,err_msg);
when sal_error then
insert into errors values(-199,'hay que subir este salario');
end;
56

SET LINESIZE 200;

SET PAGESIZE 80;
SET HEADING OFF;

SQL> SELECT TEXT FROM USER_SOURCE WHERE NAME='EXECPTION_ERRORS';

PROCEDURE
"EXECPTION_ERRORS" (P_EMPNO NUMBER, P_SUELDO_MIN NUMBER)
IS
SAL_ERROR EXCEPTION;
ERR_MSG VARCHAR(100);
ERR_CODE NUMBER;
V_SAL EMP.SAL%TYPE;
V_COMM EMP.COMM%TYPE;
BEGIN
SELECT SAL, COMM INTO V_SAL, V_COMM
FROM EMP
WHERE EMPNO=P_EMPNO;
IF V_SAL<P_SUELDO_MIN THEN
RAISE SAL_ERROR;
ELSE
NULL;
END IF;SET LINESIZE
EXCEPTION
WHEN NO_DATA_FOUND THEN
ERR_MSG:=SUBSTR(SQLERRM,1,100);
ERR_CODE:=SQLCODE;
INSERT INTO ERRORS VALUES(ERR_CODE,ERR_MSG);
WHEN SAL_ERROR THEN
INSERT INTO ERRORS VALUES(-199,'HAY QUE SUBIR ESTE SALARIO');
END;

57

FUNCIONES
CREAREMOS LA FUNCIN FACTORIAL, QUE CALCULA EL FACTORIAL DE
UN NUMERO ENTERO POSITIVO
CREATE OR REPLACE FUNCTION FACTORIAL
(N POSITIVE)
RETURN INTEGER --DEVUELVE N!
IS
E_ERR EXCEPTION;
BEGIN

IF N<1 THEN RAISE E_ERR; END IF;

IF N=1 THEN RETURN 1; --N!=1

ELSE RETURN N*FACTORIAL(N-1);--LLAMADA RECURSIVA

END IF;

EXCEPTION

WHEN E_ERR THEN

RETURN -1000;

WHEN OTHERS THEN

RETURN -1000;
END;
SELECT FACTORIAL(3) FROM DUAL;
58

 SI LLAMAMOS ESTA FUNCIN DESDE UN PROCEDIMIENTO

TENDREMOS:
CREATE OR REPLACE PROCEDURE FORYFUNCTION

IS
A INTEGER :=21;
V_FACT INTEGER;
E_ERR EXCEPTION;
BEGIN

FOR CUENTA IN 1 .. 20 LOOP

A:=A-CUENTA;

IF A<1 THEN RAISE E_ERR; END IF;

SELECT FACTORIAL(A) INTO V_FACT FROM DUAL;

DBMS_OUTPUT.PUT_LINE('CONTADOR :'||
CUENTA||'ACUMULADOR :'||A||' '||V_FACT);

END LOOP;
EXCEPTION
WHEN E_ERR THEN
DBMS_OUTPUT.PUT_LINE (V_FACT||' '||'YA ESTAMOS EN
VALORES NEGATIVOS');
END;
59

USUARIOS

CREAR UN USUARIO
REM CREAR UN USUARIO (ABR 2005)
REM CREA EL USUARIO JORGE CON PASSWORD TIGER
REM OPTIONALMENTE SE PUEDE ESPECIFICA EL TABLASPACE DE DEFAULT Y LAS CANTIDADES DE MEMORIA ASIGNADA
REM DEFAULT TABLESPACE NOMBRE_TABLESPACE
REM QUOTA 10M ON NOMBRE_TABLESAPACE
REM QUOTA 5M OM TEMP_TABLESPACE
REM QUOTA 5M ON SYSTEM
REM PROFILE ENGINEER
REM

CREATE USER JORGE IDENTIFIED BY TIGER;

REM
REM ASIGNA LOS PRIVILEGIOS DE Y ROLES A LOS USUARIOS Y ROLES
REM PARA ASIGNAR PRIVILEGIOS A LOS OBJETOS, USE EL COMANDO GRANT (PRIVILEGIOS DE OBJETOS).
REM PARA ASIGNAR PRIVILEGIOS DEL SISTEMA DE TENER ASIGNADA LA OPTION ADMIN OPTION O DEBE
REM HABERSELE ASIGNADO EL PRIVILEGIO GRANT ANY PRIVILEGE

GRANT CONNECT TO JORGE IDENTIFIED BY TIGER;

REM
REM RESOURCE ES UN ROL
REM QUE INCLUYE LAS SIGUIENTE PRIVILEGIOS:
REM CREATE CLUSTER : UN CLUSTER ES UN ESQUEMA DE OBJETOS QUE CONTIENEN UNA O MAS TABLAS
REM QUE TODAS TIENE UNA O MAS COLUMNAS EN COMUN. COMPARTEN LOS MISMOS VALORES EN ESTAS COLUMNAS COMUNES
REM CREATE PROCEDURE
REM CREATE SEQUENCE
REM CREATE TABLE
REM CREATE TRIGGER

GRANT RESOURCE TO JORGE;

REM

ALTER USER JORGE DEFAULT TABLESPACE USER_DATA;

REM

ALTER USER JORGE TEMPORARY TABLESPACE TEMPORARY_DATA;

REM

CONNECT JORGE/TIGER@ORCL

REM

ALTER SESSION SET NLS_TERRITORY = AMERICA;

REM

ALTER SESSION SET NLS_LANGUAGE = AMERICAN;

REM

60

 ESTANDO EN SYS O SYSTEM, LE

ASIGNO EL DERECHO DE DAR
DERECHOS SOBRE SUS TABLAS A
SCOTT CON:
GRANT GRANT ANY PRIVILEGE TO
SCOTT;
DENTRO DE SCOTT
GRANT SELECT ON EMP TO JORGE;
ENTONCES JORGE PODRA REALIZAR
SELECT * FROM SCOTT.EMP;
61

EN EL USUARIO SYSTEM/MANAGER SE CREA UN NUEVO USUARIO (LIBRO) PARA DEPOSITAR ESTOS

NUEVOS OBJETOS:
CREATE USER LIBRO IDENTIFIED BY LIBRO;
ALTER USER LIBRO DEFAULT TABLESPACE USERS
QUOTA UNLIMITED ON USERS;
ALTER USER LIBRO TEMPORARY TABLESPACE TEMP;
GRANT CONNECT TO LIBRO;--LES DA OPCIONES DE CONECTARSE Y CREAR OBJETOS EN ESTE USUARIO
GRANT RESOURCE TO LIBRO;--LES DA PERMISO DE USAR LOS TABLESPACE USERS
CREANDO LAS TABLAS Y LOS INDICES.
CREATE TABLE TEMA (
CODIGO
VARCHAR2(12) NOT NULL,
SUBCODIGO
INTEGER NOT NULL,
DESCRIPCION
VARCHAR2(60) NULL,
RANGOPAGINAS
VARCHAR2(15) NULL
SUBCODIGOPADRE
INTEGER NULL,
);
ALTER TABLE TEMA
ADD ( PRIMARY KEY (CODIGO, SUBCODIGO) ) ;
ALTER TABLE TEMA
ADD ( FOREIGN KEY (CODIGO, SUBCODIGOPADRE)
REFERENCES TEMA
ON DELETE SET NULL ) ;
O TAMBIEN:
CREATE TABLE TEMA (
CODIGO
VARCHAR2(12) NOT NULL,
SUBCODIGO
INTEGER NOT NULL,
DESCRIPCION
VARCHAR2(60) NULL,
RANGOPAGINAS
VARCHAR2(15) NULL,
SUBCODIGOPADRE
INTEGER NULL,
PRIMARY KEY (CODIGO, SUBCODIGO),
FOREIGN KEY (CODIGO, SUBCODIGOPADRE)
REFERENCES TEMA
ON DELETE SET NULL
);

62

INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )

VALUES ('0201571684' ,1 ,'GUA DEL USUARIO DEL LENGUAJE DE MODELAMIENTO DE DATOS' ,' ' ,1 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,2 ,'PREFACIO' ,'XV' ,1 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,3 ,'SECCION 1: INICIANDO' ,'1' ,1 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,4 ,'CAPITULO 1: POR QUE MODELAMOS' ,'3' ,3 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,5 ,'LA IMPORTANCIA DE MODELAR' ,'4' ,4 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,6 ,'PRINCIPIOS DEL MODELAMIENTO' ,'7' ,4 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,7 ,'MODELANDO ORIENTADO AL OBJETO' ,'10' ,4 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,8 ,'CAPITULO 2: INTRODUCCIN AL UML' ,'13' ,3 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,9 ,'UNA REVISION AL UML' ,'17' ,8 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,10 ,'UN MODELO CONCEPTUAL DEL UML' ,'17' ,8 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,11 ,'ARQUITECTURA' ,'30' ,8 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,12 ,'CICLO DE VIDA DE DESARROLLO DE SOFTWARE' ,'33' ,8 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,13 ,'SECCION 2 : MODELAMIENTO ESTRUCTURAL BASICO' ,'45' ,1 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,14 ,'CAPITULO 4 : CLASES' ,'47' ,13 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,15 ,'INICIANDO LAS CLASES' ,'47' ,14 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,16 ,'CONCEPTOS Y TERMINOS' ,'49' ,14 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,17 ,'TECNICAS DE MODELAMIENTO COMUN' ,'54' ,14 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,18 ,'CAPITULO 5: INTERRELACIONES' ,'61' ,13 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,19 ,'INICIADO' ,'62' ,18 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,20 ,'CONCEPTOS Y TERMINOS' ,'63' ,18 );
INSERT INTO TEMA (CODIGO ,SUBCODIGO ,DESCRIPCION ,RANGOPAGINAS ,SUBCODIGOPADRE )
VALUES ('0201571684' ,21 ,'TECNICAS DE MODELAMIENTO' ,'69' ,18 );

63

 COLUMN DESCRIPCION FORMAT A60;- - SOLO PARA DARLE EL

FORMATO A LA SALIDA
SELECT LEVEL, LPAD(' ',2*LEVEL-2)||DESCRIPCION
DESCRIPCION, RANGOPAGINAS,TEMA.SUBCODIGO,
TEMA.SUBCODIGOPADRE
FROM TEMA
CONNECT BY PRIOR SUBCODIGO = SUBCODIGOPADRE
START WITH SUBCODIGOPADRE IS NULL;

64

LEVEL DESCRIPCION
RANGOPAGINAS SUBCODIGO SUBCODIGOPADRE
---------- ----------------------------------------------------------------------------- ---------------------------- --------------------1 GUA DEL USUARIO DEL LENGUAJE DE MODELAMIENTO DE DATOS
1
2 PREFACIO
XV
2
1
2 SECCION 1: INICIANDO
1
3
1
3 CAPITULO 1: POR QUE MODELAMOS
3
4
3
4
LA IMPORTANCIA DE MODELAR
4
5
4
4
PRINCIPIOS DEL MODELAMIENTO
7
6
4
4
MODELANDO ORIENTADO AL OBJETO
10
7
4
3 CAPITULO 2: INTRODUCCIN AL UML
13
8
3
4
UNA REVISION AL UML
17
9
8
4
UN MODELO CONCEPTUAL DEL UML
17
10
8
4
ARQUITECTURA
30
11
8
4
CICLO DE VIDA DE DESARROLLO DE SOFTWARE
33
12
8
2 SECCION 2 : MODELAMIENTO ESTRUCTURAL BASICO
45
13
1
3 CAPITULO 4 : CLASES
47
14
13
4
INICIANDO LAS CLASES
47
15
14
4
CONCEPTOS Y TERMINOS
49
16
14
4
TECNICAS DE MODELAMIENTO COMUN
54
17
14
3 CAPITULO 5: INTERRELACIONES
61
18
13
4
INICIADO
62
19
18
4
CONCEPTOS Y TERMINOS
63
20
18
4
TECNICAS DE MODELAMIENTO
69
21
18
21 ROWS SELECTED.

65

SQL> COL NOMBRE FORMAT A15

SQL> SELECT LEVEL, LPAD('**',2*LEVEL-2)||ENAME NOMBRE, DEPTNO,EMP.EMPNO,
EMP.MGR
2 FROM EMP
3 CONNECT BY PRIOR EMPNO = MGR
4 START WITH MGR IS NULL;

LEVEL NOMBRE DEPTNO EMPNO MGR

--------- --------------- ------------- ---------- ---------1 KING
10
7839
2 **JONES
20
7566
7839
3 **SCOTT
20
7788
7566
4 **ADAMS
20
7876
7788
3 **FORD
20
7902
7566
4 **SMITH
20
7369
7902
2 **BLAKE
30
7698
7839
3 **ALLEN
30
7499
7698
3 **WARD
30
7521
7698
3 **MARTIN
30
7654
7698
3 **TURNER
30
7844
7698
3 **JAMES
30
7900
7698
2 **CLARK
10
7782
7839
3 **MILLER
10
7934
7782

14 rows selected.

SQL>

66

ESTRUCTURAS DE CONTROL DE PROCESOS

IF PROVEE CONTROL SELECTIVO DE LAS ACCIONES BASADAS EN
LA VERIFICACIONDE UNA CONDICION

IF A = 1 THEN
D := 1 + E;
E1 := H * 1.176;
ELSIF A = 1 THEN
E := 1 + D;
E1 := H * 1.1876;
E2 := 3;
ELSIF A = 3 THEN
B := 1.123;
ELSE B := 2.01;
END IF;

67

ESTRUCTURAS DE CONTROL DE PROCESOS

Loop PROVEE REPETICIONES DE LAS

SENTENCIAS DEL GRUPO SIN UNA
CONDICION.
EXIT PROVEE UNA RUPTURA DEL LOOP
LOOP
I := I + 1;
IF I = 10 THEN
EXIT;
END IF;
END LOOP;
LOOP
I := I + 1;
EXIT WHEN I = 10;
END LOOP;
68

ESTRUCTURAS DE CONTROL DE PROCESOS

BUCLES FOR PROVEE LA EJECUCION DE ITERACIONES BASADO

EN UNA CUENTA.

FOR CNT IN 12 .. 150 LOOP

A := A + (CNT * 10);
EXIT WHEN A > 12900;

END LOOP;
FOR CNT IN REVERSE 18 .. 121 LOOP
A := A + (CNT * 10);

END LOOP;

69

ESTRUCTURAS DE CONTROL DE PROCESOS

BUCLE WHILE PROVEE EJECUCIONDE SENTENCIAS
ITERATIVA BASADA EN UNA CONDICION

WHILE B > 0 AND JAD11 <> Lift OR JAD11 <> Platform LOOP
FOR CNT IN REVERSE 18 .. 121 LOOP
A := A + (CNT * 10);
IF A > 12900 THEN
JAD11 = Platform;
END IF;

END LOOP;

END LOOP;

70

PROCEDIMIENTOS
CREATE OR REPLACE PROCEDURE EMP_COUNT
(NUM_DEPT_PARAM number)
IS
E_COUNT NUMBER;
V_DNAME VARCHAR2(14);
BEGIN
SELECT DNAME INTO V_DNAME FROM DEPT WHERE
DEPTNO=NUM_DEPT_PARAM;
SELECT COUNT(*) INTO E_COUNT
FROM EMP
WHERE DEPTNO=NUM_DEPT_PARAM;
IF E_COUNT > 1 THEN
dbms_output.put_line('HAY '|| e_count || ' EN '||V_DNAME);
ELSIF e_count = 1 THEN
dbms_output.put_line('HAY UN EMP EN '||V_DNAME);
ELSE
dbms_output.put_line('NO HAY EMP EN '|| V_DNAME);
END IF;
END;
71

PROCEDIMIENTOS
CREATE OR REPLACE PROCEDURE CUENTA_PRO_DEPT
V_DNAME DEPT.DNAME%TYPE;
CUENTA NUMBER;
CURSOR CUR_EMP IS
SELECT D.DNAME, COUNT(E.DEPTNO) AS NUM_EMP
FROM DEPT D, EMP E
WHERE D.DEPTNO = E.DEPTNO(+) GROUP BY D.DNAME;
BEGIN
OPEN CUR_EMP;
LOOP
FETCH CUR_EMP INTO V_DNAME, CUENTA;
EXIT WHEN CUR_EMP%NOTFOUND;
IF CUENTA = 0 THEN dbms_output.put_line('NINGUN EMP PARA
|| V_DNAME);
ELSE
dbms_output.put_line(CUENTA ||
EMPLEADOS PARA ' || V_DNAME);
END IF;
END LOOP;
CLOSE CUR_EMP;
END;
72

73

SEGURIDAD

74

TRIGGERS O DISPARADORES
Un trigger es un bloque PL/SQL asociado a una tabla, que se
ejecuta cuando una determinada instruccin en SQL se va a
ejecutar sobre dicha tabla.
La sintaxis para crear un trigger es la siguiente:
CREATE [OR REPLACE] TRIGGER
{BEFORE|AFTER} {DELETE|INSERT|UPDATE [OF col1, col2, . . .,
colN]
[OR {DELETE|INSERT|UPDATE [OF col1, col2, . . ., colN]. . .]}
ON table
[REFERENCING OLD AS oldname, NEW as newname]
[FOR EACH ROW [WHEN (condition)]]
pl/sql_block
El uso de OR REPLACE permite sobreescribir un trigger existente.
Si se omite, y el trigger existe, se producir, un error.
El modificador FOR EACH ROW indica que el trigger se disparar
cada vez que se desee hacer operaciones sobre una fila de la tabla.
Si se acompaa del modificador WHEN, se establece una
restriccin; el trigger solo actuar, sobre las filas que satisfagan la
75
restriccin.

Disparadores en Oracle
Uso de disparadores
Evitar ejecucin de transacciones invlidas
Garantizar el cumplimiento de restricciones de
integridad y de reglas de negocio
Generar automticamente valores de columnas
derivadas

Mal uso
Para garantizar el cumplimiento de restricciones
que puedan ser definidas a nivel de esquema
CHECK
Disparadores recursivos
Gran tamao Procedimiento almacenado
76

Creacin de disparadores
CREATE TRIGGER BUpCUOTA
BEFORE UPDATE OF f_pago ON Cuota
FOR EACH ROW
WHEN (new.f_pago > old.f_venc)
BEGIN
raise_application_error(-20000, Cuota ||
TO_CHAR(:old.num_cuota) || del prestamo ||
TO_CHAR(:old.num_prest) || vencida. Por favor, dirigirse a la
gerencia.);
END;

77

 CREATE TRIGGER salary_check

BEFORE
INSERT OR UPDATE OF sal, job
ON emp
FOR EACH ROW
WHEN (new.job <> 'PRESIDENT')
DECLARE
minsal NUMBER
maxsal NUMBER
BEGIN
/* Se obtienen los valores minimo y maximo para el salario de */
/* un cargo determinado, usando la tabla sal_guide */
SELECT minsal, maxsal
INTO minsal, maxsal
FROM sal_guide
WHERE job = :new.job
/* Si el salario del empleado a insertar/modificar esta por */
/* debajo del minimo, o por encima del maximo, se genera */
/* un error. */
IF (:new.sal < minsal OR :new.sal > maxsal)
THEN raise_application_error(-20601, 'Salary '||:new.sal||
' out of range for job '||:new.job||' for employee '||
:new.ename);
END IF;
END;
78

 Este trigger impide que se agregue o

modifique un empleado con el sueldo
mayor o menor que los valores mximo y
mnimo respectivamente para su cargo.
Se agrega la restriccin de que el trigger
no se dispararn si el cargo es
PRESIDENTE.
Si se desea eliminar (borrar) un trigger, se
usa la instruccin:
SQL> DROP TRIGGER name;
79

Sobre la creacin de disparadores

Los nombres de los triggers deben ser nicos dentro de un esquema
dado.
Alguna de las dos, BEFORE o AFTER, debe ser utilizada en el CREATE
TRIGGER.
La sentencia activadora especifica el tipo de operacin que despierta el
disparador (DELETE, INSERT o UPDATE). En la sentencia activadora se
especifica la tabla asociada al trigger. Puede especificarse exactamente
una tabla (no una vista) en la sentencia activadora.
Si la sentencia activadora especifica un UPDATE se puede incluir una lista
de columnas en dicha sentencia. Si se incluye la lista de columnas, el
trigger se activa por un UPDATE slo si una de las columnas especificadas
es actualizada. Si se omite la lista, el trigger se activa cuando cualquier
columna de la tabla se actualiza. No se puede especificar lista de columnas
para INSERT o DELETE.
La presencia o ausencia de la opcin FOR EACH ROW determina si el
disparador es a nivel de filas (row trigger) o a nivel de sentencia
activadora (statement trigger). Especifica que el cuerpo del trigger se
ejecuta individualmente para cada una de las filas de la tabla que haya sido
afectada por la sentencia activadora.
Opcionalmente, se pueden incluir restricciones en la definicin de un
row trigger. Para ello se especifica, en una clusula WHEN, una expresin
booleana de SQL. Si se incluye una clusula WHEN, la expresin se evala
para cada una de las filas que el disparador afecta. 80
Si el resultado de la
evaluacin es TRUE, se ejecuta el cuerpo del trigger sobre la fila que hizo

Modificar disparadores
No hay modificacin explcita, se reemplaza.
1)CREATE OR REPLACE TRIGGER BUpCUOTA
2) DROP TRIGGER BUpCUOTA ; CREATE TRIGGER
BUpCUOTA

(Des)habilitar
ALTER TRIGGER BUpCUOTA ENABLE/DISABLE;
ALTER TABLE CUOTA ENABLE/DISABLE ALL
TRIGGERS;
81

FUNCIONES
Una funcin es un conjunto de
instrucciones en PL/SQL, que pueden ser
llamados usando el nombre con que se le
haya creado. Se diferencian de los
procedimientos, en que las funciones
retornan un valor al ambiente desde
donde fueron llamadas.

82

SINTAXIS
CREATE [OR REPLACE] FUNCTION
name [(param [IN] datatype) . . .]
RETURN datatype
[IS|AS] pl/sql_subprogram

83

 El uso de OR REPLACE permite sobreescribir

una funcin existente. Si se omite, y la funcin
ya existe, se producir, un error. El nico
modificador permitido para los parmetros es
IN, y si se omite, se tomar por defecto. Es
decir, solo se permiten parmetros de entrada.
Si se desea eliminar (borrar) una funcin, se usa
la instruccin:
SQL> DROP FUNCTION calcula_impuesto;
84

EJEMPLOS

Create or replace function calcula_impuesto

(monto in number)
return number
is
monto_imp number;
begin
select monto*tax_index into monto_imp from tax;
return monto_imp;
exception
when no_data_found
then return null;
end;
85

 CREATE OR REPLACE FUNCTION "ENTERO_A_TEXTO" (A

INTEGER) RETURN VARCHAR
IS
ERR EXCEPTION;
BEGIN
IF A<0 OR A>9 THEN RAISE ERR; END IF;
IF A=0 THEN RETURN 'CERO'; END IF;
IF A=1 THEN RETURN 'UNO'; END IF;
IF A=2 THEN RETURN 'DOS'; END IF;
IF A=3 THEN RETURN 'TRES'; END IF;
IF A=4 THEN RETURN 'CUATRO'; END IF;
IF A=5 THEN RETURN 'CINCO'; END IF;
IF A=6 THEN RETURN 'SEIS'; END IF;
IF A=7 THEN RETURN 'SIETE'; END IF;
IF A=8 THEN RETURN 'OCHO'; END IF;
IF A=9 THEN RETURN 'NUEVE'; END IF;
EXCEPTION
WHEN ERR THEN
RETURN 'NO VALIDO';
END;

86

 CREATE OR REPLACE FUNCTION "FACTORIAL" (n

positive)
return integer
--devuelve n!
is
E_ERR EXCEPTION;
begin
IF N<1 THEN
RAISE E_ERR;
END IF;
if n=1 then return 1; --n!=1
else return n*factorial(n-1);--llamada recursiva
end if;
exception
when E_ERR then
RETURN -1000;
WHEN OTHERS THEN
RETURN -1000;
end;
87

 CREATE OR REPLACE FUNCTION "SERVICIOS"

(p_empno number)return number
is
contratacion emp.hiredate%type;
annos number;
begin
select ((sysdate-hiredate)/30)/12 into annos from emp
where empno=p_empno;
if sql%notfound then
return 0;
end if;
return annos;
end;

If servicios(7521)>35
Endif;
SELECT SERVICIOS(7900) FROM DUAL;
SERVICIOS(7900)
--------------88
25.1752017

 create or replace function vol_cono (r number, h number)

return number
is
e_err exception;
begin
if r=0 and h=0
then return 0;
else
return ((3.1416*r*r*h)/3);
end if;
end;
SQL> select vol_cono(2,1) from dual;
VOL_CONO(2,1)
------------
4.1888

89

CREATE OR REPLACE FUNCTION EXISTEPAIS

(P_COUNTRY_ID COUNTRIES.COUNTRY_ID%TYPE)
RETURN NUMBER AS
V_EXISTE_PAIS NUMBER(1):=0;
BEGIN
SELECT 1 INTO V_EXISTE_PAIS FROM COUNTRIES WHERE
COUNTRIES.COUNTRY_ID=UPPER(P_COUNTRY_ID);
RETURN V_EXISTE_PAIS;
EXCEPTION
WHEN NO_DATA_FOUND THEN
RETURN V_EXISTE_PAIS;
END EXISTEPAIS;
90

CREATE OR REPLACE PROCEDURE "EMP_AUMENTOS"

(NUM_DEPT number, tope number)
--realiza aumentos a lo empleados de un dept identificado por num_dept
--que tengan un salario tope igual a tope
--si sus comisiones no son nulas aumentara el salario la comision
--de otra manera el aumento sera del 10%
IS
cursor c1 is select * from emp where deptno=num_dept and sal<=tope;
rowemp c1%rowtype;
BEGIN
open c1;
loop
fetch c1 into rowemp;
if c1%notfound then dbms_output.put_line('3. no hay registros'); end if;
exit when c1%notfound;
if nvl(rowemp.comm,0)>0 then
rowemp.sal:=rowemp.sal+rowemp.comm;
dbms_output.put_line('1. '||rowemp.ename||' recibio '|| rowemp.comm || '
de aumento.');
else
rowemp.sal:=rowemp.sal+rowemp.sal*.1;
dbms_output.put_line('2. '||rowemp.ename||' recibio '|| (rowemp.sal*.1) || '
de aumento');
end if;
end loop;
END;
91

 CREATE OR REPLACE PROCEDURE "EXECPTION_ERRORS"

(p_empno number, p_sueldo_min number)
is
sal_error exception;
err_msg varchar(100);
err_code number;
v_sal emp.sal%type;
v_comm emp.comm%type;
begin
select sal, comm into v_sal, v_comm
from emp
where empno=p_empno;
if v_sal<p_sueldo_min then
raise sal_error;
else
null;
end if;
exception
when no_data_found then
err_msg:=substr(sqlerrm,1,100);
err_code:=sqlcode;
insert into errors values(err_code,err_msg);
when sal_error then
insert into errors values(-199,'hay que subir este salario');
end;
92