Administración de base de datos oracle - sesion 1

1-1-11 Copyright © ADA, 2005. Todos los derechos reservados.
Sesión 1Sesión 1
SQL y PL/SQLSQL y PL/SQL

Introducción a SQLIntroducción a SQL

ObjetivosObjetivos
• Recuperar datos de fila y de columna de las tablas con
la sentencia SELECT.
• Conocer y ejecutar sentencias DML para actualización
de datos.
• Utilizar funciones SQL para generar y recuperar datos
personalizados. Buscar datos mediante subconsultas
avanzadas.

Proceso de una Consulta
Proceso
de
Usuario
Proceso
de
servidor
Select * from emp
order by name;
Select * from emp
order by name;
Parse ------------- Execute -------------------- Fetch
Ok
Resultados
Sentencia
Manejo

Instrucciones SQL en Oracle
DML
Lenguaje de manipulación de datos, permite recuperar y
actualizar datos. Los comandos SQL utilizados son: INSERT,
UPDATE, DELETE y SELECT.
DDL
Lenguaje de definición de datos, es utilizado para modificar la
estructura de los objetos que soportan los datos. Los comandos
SQL utilizados son: CREATE, DROP, ALTER, etc.
DCL
Lenguaje de control de datos, es utilizada para controlar el
acceso a los datos. Los comandos SQL son: GRANT y REVOKE.
Tipos de comandos SQL:

Tabla de Sentencias DML
DELETE
INSERT
SELECT
UPDATE
MERGE
TRUNCATE
Table Data Manipulation Language Statements

Tabla de Sentencias DDL
Table Data Definition Language Statements
ALTER CLUSTER
ALTER DATABASE
ALTER DIMENSION
ALTER FUNCTION
ALTER INDEX
CREATE TABLE
CREATE TABLESPACE
CREATE TRIGGER
CREATE TYPE
CREATE USER
DROP OPERATOR
DROP PACKAGE
DROP PROCEDURE
DROP PROFILE
DROP ROLE
DROP SEQUENCE
DROP SYNONYM
DROP TABLE
DROP TABLESPACE
DROP TRIGGER

Control de Transacciones
COMMIT
ROLLBACK
SAVEPOINT
SET TRANSACTION
Table Transaction Control Statements
Control de Sesión
ALTER SESSION
SET ROLE
Table Session Control Statements

Control de Sistema
Table System Control Statement
ALTER SYSTEM

Instrucciones DML - Sentencia SELECT
La sentencia SELECT …. FROM se utiliza para consultar los
datos de las filas de una tabla de datos, siendo una tabla
estrictamente una matriz de filas y columnas.
SQL> SELECT empno, ename, sal, job FROM emp;
SQL> DESCRIBE emp;
SQL> DESC emp;
Para visualizar la estructura de una objeto se utiliza la sentencia
DESCRIBE de SQL*PLUS.

Operadores de Comparación
SQL> Select ename, sal FROM emp
WHERE sal BETWEEN 1000 AND 1500;
BETWEEN…AND
SQL> Select ename, sal, comm FROM emp
WHERE sal <= comm ;
=, >, <=, <,<= , <>

IN (...lista...)
SQL> Select ename FROM emp
WHERE ename LIKE ‘_A%’;
LIKE
SQL> Select ename, sal, mgr FROM emp WHERE
mgr
IN (7902,7566,7788);

IS NULL
/* Mostrar los empleados que no ganan comisión */
SQL> Select ename, job, comm FROM emp
WHERE comm IS NULL;

Operadores Lógicos
AND
OR
SQL> Select ename, job, sal FROM emp
WHERE sal >=1100 AND job=‘CLERK’;
SQL> Select ename, job, sal FROM emp
WHERE sal >=1100 OR job=‘CLERK’;

Operadores Lógicos
NOT
SQL> Select ename, job FROM emp
WHERE job NOT IN ( ‘CLERK’, ’MANAGER’,
’ANALYST’ );
También se puede combinar:
NOT BETWEEN - NOT NULL - NOT LIKE

Cláusula ORDER BY……DESC [ASC]
SQL> Select empno, ename, sal *12 as salario
FROM emp ORDER BY salario DESC;

Uso de ALIAS
SQL> Select A.empno, A.ename FROM emp A
ORDER BY A.ename DESC;
SQL> Select a.empno as codigo, a.ename as nombre
FROM emp A ORDER BY a.sal DESC;
SQL> Select a.empno codigo, a.ename nombre
FROM emp A ORDER BY sal DESC;

Funciones de Conversión :
LOWER (‘CURSO SQL’)
Funciones de Carácter :
Instrucciones DML - Funciones de una Fila
UPPER (‘sql course’)
INITCAP (‘sql course’)
Función

Funciones de manipulación de caracteres :
CONCAT (‘Hola’,’como estas ’)
SUBSTR (‘Profesor’,1,3)
LENGTH (‘Hola’)
Función
INSTR (‘Amigos’,’g’)
LPAD (salario,10,’*’)
TRIM (‘ Hola a todos ‘)

ROUND
Funciones numéricas :
TRUNC
MOD
Función
ROUND(45.926)
TRUNC(45.926)
MOD (1600,300)
Ejemplo
45.93
45.92
100
Resultado

MONTHS_BETWEEN(‘01-ENE-05’,’01-MAR-05’)
Funciones de Fecha :
ADD_MONTHS(sysdate,6)
NEXT_DAY(sysdate,1)
Función
3
11-ENE-06
Resultado
18-JUL-05
LAST_DAY(sysdate) 31-JUL-05
ROUND(sysdate,’MM’) 01-JUL-05
ROUND(sysdate,’YYYY’) 01-ENE-06
TRUNC(sysdate,’MM’) 01-JUL-05
TRUNC(sysdate,’YYYY’) 01-ENE-05

Ejemplo:
SQL> SELECT SYSDATE,ADD_MONTHS(SYSDATE,4)
AGREGAR_MES , NEXT_DAY(SYSDATE,1)
AGREGAR_SEMANA, LAST_DAY(sysdate) ULTIMO
FROM DUAL;

Funciones de conversión :
VARCHAR2 o CHAR
VARCHAR2 o CHAR
NUMBER
De
NUMBER
DATE
VARCHAR2
A
Conversión de tipos de datos implícitos
DATE VARCHAR2

YYYY
YEAR
MM
Formato
Año completo
Año en texto
Número de Mes
Descripción
Conversión de tipos de datos explícitos: TO_CHAR
MONTH Mes en texto
DY Día abreviado
DAY Día en texto

9
0
$
Formato
Representa un número
Fuerza que cero se muestre
Coloca un signo dólar
Descripción
Conversión de tipos de datos explícitos: TO_NUMBER
. Imprime un punto decimal
, Imprime un indicador de miles

YYYY
YEAR
MM
Formato
Año completo
Año en texto
Número de Mes
Descripción
Conversión de tipos de datos explícitos: TO_DATE
MONTH Mes en texto
DY Día abreviado
DAY Día en texto

Función NVL :
SQL> Select NVL(comm,0) FROM emp;
Convierte un nulo a un valor que puede ser un número,
un carácter o una fecha.
SQL> Select NVL(hiredate,sysdate) FROM emp;
SQL> Select NVL(job,’no job’) FROM emp;

EMP
Instrucciones DML - Funciones de múltiples Filas
EMPNO ENAME DEPTNO
----- ----------- ------------
7369 SMITH 20
7499 ALLEN 30
7521 WARD 30
7566 JONES 20
7654 MARTIN 30
7698 BLAKE 30
7782 CLARK 10
7788 SCOTT 20
7839 KING 10
7844 TURNER 30
7876 ADAMS 20
7900 JAMES 30
7902 FORD 50
7934 MILLER 10
DEPTNO DNAME LOC
------ -------------------- -------------
10 ACCOUNTING NEW YORK
20 RESEARCH DALLAS
30 SALES CHICAGO
40 OPERATIONS BOSTON
60 PRUEBA PRUEBA
DEPT

Tipos de Join:
Equijoin
SQL> SELECT a.ename, a.job, a.sal, b.dname
FROM emp a, dept b WHERE a.deptno = b.deptno ;
ENAME JOB SAL DNAME
-------------------- --------------- --------- --------------
SMITH CLERK 800.00 RESEARCH
ALLEN SALESMAN 1600.00 SALES
WARD SALESMAN 1250.00 SALES
……...
JAMES CLERK 950.00 SALES
FORD ANALYST 3000.00 RESEARCH
MILLER CLERK 1300.00 ACCOUNTING
14 rows selected

Tipos de Join:
Non- equijoin
SQL> SELECT a.* FROM emp a, salgrade b WHERE
a.sal BETWEEN b.losal and b.hisal;
GRADE LOSAL HISAL
---------- ---------- ----------
1 700 1200
2 1201 1400
3 1401 2000
4 2001 3000
5 3001 9999
ENAME JOB SAL GRADE
--------------- --------------- --------- ----------
SMITH CLERK 800.00 1
ADAMS CLERK 1100.00 1
JAMES CLERK 950.00 1
..…..
SCOTT ANALYST 3000.00 4
FORD ANALYST 3000.00 4
KING PRESIDENT 5000.00 5
14 rows selected

Tipos de Join:
Outer-Join
SQL> SELECT nvl(a.ename,'<VACIO>') ename,
NVL(a.sal,0.00) SAL, A.DEPTNO, NVL(b.dname,'NULL')
FROM emp a, dept b WHERE
a.deptno = b.deptno (+);

EMPNO ENAME DEPTNO
----- ----------- ------------
7369 SMITH 20
7499 ALLEN 30
7521 WARD 30
7566 JONES 20
7654 MARTIN 30
7698 BLAKE 30
7782 CLARK 10
7788 SCOTT 20
7839 KING 10
7844 TURNER 30
7876 ADAMS 20
7900 JAMES 30
7902 FORD 50
7934 MILLER 10
DEPTNO DNAME LOC
------ -------------------- -------------
20 RESEARCH DALLAS
30 SALES CHICAGO
60 PRUEBA PRUEBA
EMP DEPT

Resultado:
ENAME SAL DEPTNO DNAME
-------------------- ---------- ------------- --------------
SMITH 800 20 RESEARCH
ALLEN 1600 30 SALES
WARD 1250 30 SALES
JONES 2975 20 RESEARCH
MARTIN 1250 30 SALES
BLAKE 2850 30 SALES
CLARK 2450 10 ACCOUNTING
SCOTT 3000 20 RESEARCH
KING 5000 10 ACCOUNTING
TURNER 1500 30 SALES
ADAMS 1100 20 RESEARCH
JAMES 950 30 SALES
FORD 3000 50 NULL
MILLER 1300 10 ACCOUNTING
14 rows selected

Tipos de Join:
Outer-Join
SQL> SELECT nvl(a.ename,'<VACIO>') ename,
NVL(a.sal,0.00) SAL, NVL(A.DEPTNO,0) DEPTNO ,
NVL(b.dname,'NULL') FROM emp a, dept b
WHERE a.deptno (+) = b.deptno;

EMPNO ENAME DEPTNO
----- ----------- ------------
7369 SMITH 20
7499 ALLEN 30
7521 WARD 30
7566 JONES 20
7654 MARTIN 30
7698 BLAKE 30
7782 CLARK 10
7788 SCOTT 20
7839 KING 10
7844 TURNER 30
7876 ADAMS 20
7900 JAMES 30
7902 FORD 50
7934 MILLER 10
DEPTNO DNAME LOC
------ -------------------- -------------
20 RESEARCH DALLAS
30 SALES CHICAGO
60 PRUEBA PRUEBA
EMP DEPT

Resultado:
ENAME SAL DEPTNO DNAME
-------------------- ---------- ------------- --------------
CLARK 2450 10 ACCOUNTING
KING 5000 10 ACCOUNTING
MILLER 1300 10 ACCOUNTING
SMITH 800 20 RESEARCH
ADAMS 1100 20 RESEARCH
SCOTT 3000 20 RESEARCH
JONES 2975 20 RESEARCH
ALLEN 1600 30 SALES
BLAKE 2850 30 SALES
MARTIN 1250 30 SALES
JAMES 950 30 SALES
TURNER 1500 30 SALES
WARD 1250 30 SALES
<VACIO> 0 0 OPERATIONS
<VACIO> 0 0 PRUEBA
15 rows selected

Tipos de Join:
Self Join
SQL> SELECT a.ename EMPLEADO,a.sal SALARIO,
a.job OCUPACION, m.ename MANAGER
FROM emp a, emp m WHERE
a.mgr = m.empno and a.empno=7369;
EMPLEADO SALARIO OCUPACION MANAGER
-------------------- -------------- --------------- --------------------
SMITH 800.00 CLERK FORD

EMPNO ENAME JOB MGR
------- -------------------- --------------- -------
7369 SMITH CLERK 7902
7499 ALLEN SALESMAN 7698
7521 WARD SALESMAN 7698
7566 JONES MANAGER 7839
7654 MARTIN SALESMAN 7698
7698 BLAKE MANAGER 7839
7782 CLARK MANAGER 7839
7788 SCOTT ANALYST 7566
7839 KING PRESIDENT
7844 TURNER SALESMAN 7698
7876 ADAMS CLERK 7788
7900 JAMES CLERK 7698
7902 FORD ANALYST 7566
7934 MILLER CLERK 7782
EMP

Instrucciones DML - Funciones de Grupo
AVG, COUNT, MAX, MIN, STDDEV, SUM, VARIANCE
Ejemplo:
SQL> SELECT deptno, AVG(sal) FROM emp
GROUP BY deptno;
Estas funciones operan en grupos de registros para
entregar un resultado por grupos.
Estas funciones son:
DEPTNO AVG(SAL)
------ ----------
10 2916.66666666667
20 2175
30 1566.66666666667

Ejemplo:
SQL> SELECT deptno, job, sum(sal) FROM emp
GROUP BY deptno, job ;
DEPTNO JOB SUM(SAL)
----------- --------------- ----------
10 CLERK 1300
10 MANAGER 2450
10 PRESIDENT 5000
20 ANALYST 6000
20 CLERK 1900
20 MANAGER 2975
30 CLERK 950
30 MANAGER 2850
30 SALESMAN 5600

HAVING
Este comando permite filtrar los registros
agrupados.
Ejemplo:
SQL> SELECT deptno, job, sum(sal) FROM emp GROUP BY deptno, job
HAVING sum(sal)>2500;
DEPTNO JOB SUM(SAL)
----------- --------------- ----------
10 PRESIDENT 5000
20 ANALYST 6000
20 MANAGER 2975
30 MANAGER 2850
30 SALESMAN 5600

ROLLUP, CUBE
Estos comandos se utilizan
para totalizar los grupos de
datos.
Ejemplo:
SQL> SELECT deptno, job,
sum(sal) FROM emp
GROUP BY
ROLLUP(deptno,job) ;
DEPTNO JOB SUM(SAL)
------ --------------- -------------
10 CLERK 1300
10 MANAGER 2450
10 PRESIDENT 5000
10 8750
20 ANALYST 6000
20 CLERK 1900
20 MANAGER 2975
20 10875
30 CLERK 950
30 MANAGER 2850
30 SALESMAN 5600
30 9400
2902529025

ROLLUP, CUBE
Ejemplo:
SQL> SELECT deptno, job,
sum(sal) FROM emp
GROUP BY
CUBE (deptno, job) ;
DEPTNO JOB SAL
------ --------------- ----------
10 CLERK 1300
10 MANAGER 2450
10 PRESIDENT 5000
10 8750
20 ANALYST 6000
20 CLERK 1900
20 MANAGER 2975
20 10875
30 CLERK 950
30 MANAGER 2850
30 SALESMAN 5600
30 9400
ANALYST 6000
CLERK 4150
MANAGER 8275
PRESIDENT 5000
SALESMAN 5600
2902529025

Instrucciones DML - Subconsultas
Se puede manejar dentro de la cláusula de una
sentencia SELECT otra sentencia SELECT. La
cláusula puede ser :
WHERE, HAVING o FROM
Sintaxis:
SELECT select_list FROM table
WHERE expresión operador (SELECT select_list
FROM table) ;
Donde operador puede ser :
>, =, >=,<,<>, >= ó IN, ANY, ALL

a. Subconsultas de una fila
SQL> SELECT ename, sal FROM emp
WHERE sal > (SELECT sal FROM emp WHERE
empno=7566) ;
ENAME SAL
-------------------- -----------
SCOTT 3000.00
KING 5000.00
FORD 3000.00
Tipos de Subconsultas :
SAL
---------
2975.00

b. Subconsultas de múltiples filas
SQL> SELECT ename, sal, deptno FROM emp
WHERE sal IN (SELECT min(sal) FROM emp
group by deptno) ;
ENAME SAL DEPTNO
-------------------- --------- ------
SMITH 800.00 20
JAMES 950.00 30
MILLER 1300.00 10
MIN(SAL)
----------
1300
800
950

b. Subconsultas de múltiples columnas
SQL> SELECT ename, sal, deptno FROM emp
WHERE (deptno,sal) IN (SELECT
deptno,min(sal) FROM emp
group by deptno);

Instrucciones DML – Sentencia INSERT
Forma Convencional
SQL> INSERT INTO emp
VALUES (2296, ’AROMANO’, ’SALESMAN’, 7782 ,
to_date( ‘03/02/1997 ’, ’dd/mm/yyyy’ ), 1300 ,
NULL, 10) ;
Con variables de sustitución
SQL> INSERT INTO dept (deptno, dname, loc)
VALUES ( &departamento, ’&Nombre’,
’&Localizacion’ ) ;

Con prompts personalizados
SQL> ACCEPT depto_id prompt ‘Ingrese número dpto: ‘;
SQL> ACCEPT name_id prompt ‘Ingrese nombre dpto: ‘;
SQL> INSERT INTO dept (deptno, dname)
VALUES (&depto_id, ‘&name_id’ );

Copiando filas de otra tabla
SQL> INSERT INTO managers (id, name, salary,
hiredate) SELECT empno, ename, sal, hiredate
FROM emp WHERE job = ‘MANAGER’ ;
3 rows inserted

Instrucciones DML – Sentencia UPDATE
Forma convencional
SQL> UPDATE emp SET deptno = 20
WHERE empno=7782;
Con una subconsulta de múltiples columnas
SQL> UPDATE emp SET ( job , deptno) = ( Select job,
deptno FROM emp WHERE empno = 7788 )
WHERE empno = 7698 ;
JOB DEPTNO
-------------- -----------
ANALYST 20

Instrucciones DML – Sentencia UPDATE
Basándose en otras tablas
SQL> UPDATE emp
SET deptno = ( Select deptno FROM emp WHERE
empno = 7788 )
WHERE job = (Select job FROM emp WHERE
empno = 7788 ) ;
DEPTNO
------
20
JOB
---------------
CLERK

Instrucciones DML – Sentencia DELETE
Forma convencional
SQL> DELETE FROM dept
WHERE dname = ‘RESEARCH’ ;
Basándose en otra Tabla
SQL> DELETE FROM emp
WHERE deptno = (SELECT deptno FROM dept
WHERE dname = ‘SALES’ ) ;

Instrucciones DML – Sentencia MERGE
Forma convencional
SQL> MERGE INTO bonus D
USING (SELECT ename,job,sal,comm FROM emp
WHERE deptno = 30) S
ON (D.ename = S.ename)
WHEN MATCHED THEN
UPDATE SET D.comm = S.sal*1.25
WHEN NOT MATCHED THEN
INSERT (D.ename,D.job,D.sal,D.comm)
VALUES (S.ename,S.job,S.sal,S.sal*1.25);

Instrucciones DML – Sentencia TRUNCATE
Forma convencional
SQL> TRUNCATE TABLE bonus;

Introducción a PL/SQLIntroducción a PL/SQL

ObjetivosObjetivos
• Explicar como la arquitectura de PL/SQL mejora el
funcionamiento de una aplicación.
• Identificar las importantes extensiones que PL/SQL
proporciona a SQL.
• Escribir y ejecutar bloques de PL/SQL.

Estructura de un bloque PL/SQL
BLOQUE PL/SQL
DECLARE
.......
........
BEGIN
.....
.....
....
EXCEPTION
.....
......
END ;
Se declaran Variables, Exceptions
y Cursores.
Se manipulan las variables y cursores ya
definidos. Aquí se dan las instrucciones
procedimentales y de SQL. Es la única
sección obligatoria.
Para manejar errores que puedan existir
en el bloque anterior. Es decir, aquí se
introducen las rutinas de manejo de
Errores.

NOTA
- Solo se requiere que aparezca la sección ejecutable.
- Solo se permiten las siguientes instrucciones SQL en
un bloque PL/SQL:
- Las instrucciones terminan con un ; ( Punto y coma)
- Se permite el uso de comentarios, usando para ello:
INSERT UPDATE DELETE SELECT
- - comentario
/ * comentario * /

DECLARE
....
BEGIN
.......
BEGIN
....
END;
EXCEPTION
WHEN OTHERS THEN
BEGIN
....
END;
END ;
Cualquier bloque puede
contener sub - bloques. Un
sub-bloque se puede colocar
en las sección ejecutable y
de manejo de errores de un
bloque.

DECLARE
BEGIN
.......
.......
La sección DECLARE forma parte
del bloque PL/SQL, y en ella se
declaran variables, cursores y
excepciones.
Palabras reservadas
Las palabras reservadas son los
nombres que utiliza Oracle para la
ejecución de sus procesos.
Sección de Declarativa

Sección Declarativa : Variables Tipo Escalar
NUMBER
BYNARY_INTEGER
CHAR
VARCHAR2
DATE
BOOLEAN
Tipos de datos Escalar Descripción
Enteros con o sin decimales
Únicamente enteros
Caracteres de longitud fija
Caracteres de longitud variable.
Valores de fecha
TRUE, FALSE, NULL

Nombre_variable [CONSTANT] tipo_de_dato
[NOT NULL] [ : = expresion_sql ] ;
REGLAS
- Comienzan con una letra
- Luego de la letra pueden colocarse números, letras y/o
caracteres especiales.
- Los nombres de las variables no son mas de 30 caracteres,
y no pueden incluirse espacios.
SINTAXIS

DECLARE
v_fecha DATE;
v_apellido VARCHAR2(20);
......
......
Ejemplo:

DECLARE
v_estado_civil CHAR ;
v_direccion VARCHAR2 (20);
v_nombre VARCHAR2 (10) := ‘Juan’ ;
v_apellido VARCHAR2 (10) NOT NULL := ‘Perez’;
CHAR / VARCHAR2

DECLARE
v_On_Off BOOLEAN NOT NULL := FALSE;
v_Tipo_pago BOOLEAN;
BOOLEAN
Sección de Declarativa : Variables Tipo Escalar

DECLARE
v_contador NUMBER ;
v_salario NUMBER (6,2) ;
v_minutos_diarios NUMBER := 24 * 60 ;
v_total_ingresos BINARY_INTEGER (10) := 0 ;
NUMBER / BINARY_INTEGER
Sección de Declarativa : Variables Tipo Escalar

DECLARE
v_fecha_pago DATE := ‘31-JUN-02’ ;
v_fecha_bodas DATE ;
v_fecha_inicio DATE NOT NULL := ‘01-JAN-90’ ;
DATE

DECLARE
v_nombre CONSTANT VARCHAR2 (10) := ‘Iris’;
v_minutos_diarios CONSTANT NUMBER := 24 * 60 ;
CONSTANTES

TYPE nombre_tipo IS TABLE OF tipo_dato [ NOT NULL]
INDEX BY BYNARY_INTEGER ;
TABLE
Sección Declarativa : Variables Tipo Compuesto
Es un tipo de variable definido por el usuario, que permite
personalizar la estructura de los datos que manipula un programa.
Las filas de estos no son almacenadas en orden particular, pero su
índice o número identificador permite locarlizarla y ordenarlas al
momento que se realice un recuperación de estos, igual que un
arreglo (array).
Sintaxis :

TYPE munitabla_tipo IS TABLE OF varchar2 (10);
TYPE sal IS TABLE OF number;
TYPE fec_nac IS TABLE OF date;
TYPE periodo_tipo IS TABLE OF char(5);
Ejemplo:

RECORD
Son datos relacionados almacenados en campos, c/u
de ellos tiene su propio nombre y tipo de dato.
TYPE nombre_tipo IS RECORD
(campo1 tipo_dato [ NOT NULL] ,
campo2 tipo_dato [ NOT NULL] ,
....) ;
nombre_record NOMBRE_TIPO;
Sintaxis :

DECLARE
TYPE datamuni_tipo IS RECORD
(municipalidad NUMBER(4),
nombre_muni VARCHAR2(50),
total_personas NUMBER(3));
data_muni DATAMUNI_TIPO;
RECORD
Ejemplo :

TYPE nombre_tipo IS VARRAY(tamaño_maximo)
OF tipo_elemento [NOT NULL];
VARRAY
Permiten asociar a un simple identificador toda una
colección o grupo de datos.
SINTAXIS
Donde, tipo_elemento, es cualquier tipo de datos de PL/SQL a excepción
de:
Binary_integer, Boolean, Long, Long raw, Nchar, Nvarchar2, Nclob, Table,
Ref cursor, Positive, Natural, NaturalN, String, Pls_integer, Signtype,
PositiveN

Conversión de Datos
PL/SQL soporta una conversión explícita y una implícita
(la cual es automática)
Conversión EXPLICITA
Date
Number
Char
Char
Char
Char
Date
Number
De Función
TO_DATE
TO_NUMBER
TO_CHAR
TO_CHAR
A
PL/SQL no puede convertir un varchar2 que contiene
valores caracteres alfabéticos a un tipo NUMERICO.

Conversión IMPLICITA
PL/SQL convierte automáticamente un tipo de dato de
una columna fuente al tipo de dato de la variable.
Si PL /SQL no pudiera realizar la conversión
automáticamente, se generará un error de compilación
y deberá usarse una función .

DECLARE
v_fecha_nac CHAR(5) := &que_año_naciste;
v_fecha_actual CHAR(5) ;
v_edad_hoy NUMBER(5) ;
BEGIN
SELECT TO_CHAR(SYSDATE,’YYYY’) INTO v_fecha_actual
FROM DUAL;
v_edad_hoy := v_fecha_actual - v_fecha_nac ;
END ;
Ejemplo :

SQL en Bloques PL/SQL
DECLARE
v_cod_cargo NUMBER(4) := 10;
v_nombre_cargo VARCHAR2 (25) := ‘OBRERO’;
BEGIN
INSERT INTO cargos VALUES (v_cod_cargo,
v_nombre_cargo);
END;
Ejemplo con INSERT:

DECLARE
v_prueba CHAR(1) := ‘X’;
BEGIN
UPDATE cargos SET nomb_cargo = ( v_prueba || ‘ ‘ ||
nomb_cargo ) WHERE cargoid<3;
END;
Ejemplo con UPDATE:

DECLARE
v_cod_cargo NUMBER(4) := 10;
v_nombre_cargo VARCHAR2 (25) := ‘OBRERO’;
BEGIN
DELETE FROM cargos WHERE cargoid = cod_cargo;
END;
Ejemplo con DELETE:

DECLARE
------
BEGIN
-----
SELECT col1 [ ,col2,col3,....] INTO var1 [ , var2, var3, ...........]
FROM nombre_tabla
WHERE condicion1 [ AND / OR condicion2.....] ;
END;
SELECT:
La instrucción SELECT debe regresar exactamente un registro, si
regresa 0 ó mas de 1 registro, ocurrirá un error.
Sintaxis:

IF < expresión> THEN
<secuencia de sentencias>
[ ELSIF <expresión booleana > THEN
<secuencia de sentencias> ]
[ ELSIF <expresión booleana > THEN
[ ELSE <expresión booleana >
END IF;
IF
Control Condicional e Interactivo
Sintaxis:

IF v_ingresos >= 20000 THEN
v_impuestos := 18 ;
ELSIF (v_ingresos > = 15 and v_ingresos < 20000 ) THEN
v_impuestos : = 15 ;
ELSE
v_impuestos := 10 ;
END IF ;
IF
Ejemplo:

LOOP
La sentencia LOOP se utiliza para ejecutar múltiples
veces una secuencia de instrucciones. PL/SQL provee
diferentes tipos de LOOPS:
- Basic LOOP
- WHILE loop
- FOR loop
- Cursor FOR loop

LOOP
< secuencia de sentencias >
END LOOP;
Basic LOOP
Sintaxis :
Donde:
Secuencia de sentencias es un grupo de sentencias
que se repetirá una o varias veces hasta que se
ejecute un EXIT que estará dentro del grupo de
sentencias.

a := 0;
LOOP
a := a+1 ;
IF a = 10 THEN
EXIT ;
END IF ;
END LOOP;
Basic LOOP
Ejemplo:

Basic LOOP
También se puede terminar el bucle con la sentencia EXIT
WHEN,
EXIT WHEN <condición> ;
Ejemplo:
a := 0;
LOOP
a := a+1 ;
EXIT WHEN a := 10 ;
END LOOP;

FOR LOOP
Repiten una secuencia de instrucciones una
determinada cantidad de veces:
Sintaxis:
FOR <índice> IN [ REVERSE ] <entero>..<entero> LOOP
END LOOP;

FOR LOOP
Donde:
• Índice, es un índice numérico que identifica a la variable
que será aumentada o disminuida, esta no necesita ser
declarada en la sección DECLARE.
• REVERSE, nos indica que la secuencia del índice ira
disminuyendo.
• Entero, es el rango de números de la secuencia que
índice deberá recorrer.

FOR a IN 1..10 LOOP
b := a+1 ;
END LOOP;
FOR a IN REVERSE 1..10 LOOP
b := a+10 ;
END LOOP;
FOR LOOP
Ejemplo:

DECLARE
v_a NUMBER(3) := 0 ;
v_b NUMBER(3) := 0 ;
BEGIN
FOR v_a IN 1..50 LOOP
INSERT INTO temp (a, g) VALUES ( v_a+v_b, ‘DEFECTO’) ;
END LOOP;
FOR v_b IN REVERSE 1..50 LOOP
INSERT INTO temp (a, g) VALUES ( v_a+v_b, ‘REVERSA’) ;
END LOOP;
END ;

WHILE LOOP
Repiten una secuencia de instrucciones siempre y
cuando la condición expresada inicialmente se cumpla.
SIntaxis:
WHILE <condición> LOOP
END LOOP;

WHILE LOOP
Donde:
Condición, es la condición que deberá cumplirse antes
de que se pueda ejecutar la secuencia de instrucciones
o sentencias que siguen a continuación.
NOTA:
La diferencia con el LOOP SIMPLE es que se ejecuta
aunque sea una vez, mientras que WHILE LOOP
puede que no se ejecute ni una vez ya que la condición
inicial así lo puede determinar.

WHILE v_declarada < 10 LOOP
v_declarada := v_declarada +1 ;
END LOOP;
WHILE LOOP
Ejemplo:

DECLARE
v_a NUMBER (3) : = 10 ;
v_b temp.a%TYPE : = 1 ;
BEGIN
WHILE v_a > 1 LOOP
INSERT INTO temp (a,g,h) VALUES (v_a,’ while’, ‘a’) ;
v_a : = v_a - 1 ;
END LOOP;
WHILE v_b < 10 LOOP
INSERT INTO temp (a,g,h) VALUES (v_b,’ while’, ‘b’) ;
v_b : = v_b + 1 ;
END LOOP;
END ;

Cursores
Oracle permite abrir y nombrar un area de trabajo que
guardará la información procesada.
Sintaxis:
CURSOR <nombre_cursor>
IS < Instrucción select >

Cursores
Ejemplos:
CURSOR c1 IS
SELECT empno, ename, job, sal
FROM emp WHERE sal > 2000;
CURSOR c2 IS
SELECT * FROM dept WHERE deptno = 10;

Cursores
Ejemplo:
SET SERVEROUTPUT ON;
DECLARE
CURSOR c_datos IS SELECT deptno,dname FROM DEPT;
vDEPTNO NUMBER(2);
vDNAME VARCHAR2(14);
BEGIN
OPEN c_datos;
LOOP
FETCH c_datos INTO vDEPTNO,vDNAME;
EXIT WHEN c_datos%NOTFOUND;
DBMS_OUTPUT.PUT_LINE( 'codigo: ' || vDEPTNO || ' ...
nombre: '||vDNAME) ;
END LOOP;
CLOSE c_datos;
END;

Cursores: EXPLICITOS
Son aquellos que se forman con una sentencia SELECT que
recupera múltiples renglones.
El siguiente ejemplo es un CURSOR EXPLICITO.
DECLARE
CURSOR c_1 IS SELECT ename FROM emp;
v_name varchar2(10);
BEGIN
OPEN c_1 ;
FETCH c_1 INTO v_name;
CLOSE c_1 ;
END ;

Permite recuperar los registros del cursor, uno por uno.
Sintaxis:
FECTH nombre_cursor
INTO nombre_variable1[,nombre_variable2,…];
FECTH … INTO

Este atributo es verdadero si el FETCH no regresa ninguna
fila. Sintaxis:
nombre_cursor%NOTFOUND;
ATRIBUTO: %NOTFOUND
LOOP
FETCH c_1 INTO c_periodo;
EXIT WHEN c_1%NOTFOUND;
END LOOP ;
Ejemplo:

Este atributo es verdadero si el FETCH regresa una fila,
inicialmente es NULL, y si no regresa ninguna fila es
FALSE.
Sintaxis:
nombre_cursor%FOUND ;
ATRIBUTO: %FOUND

Ejemplo:
DECLARE
vDEPTNO NUMBER(2);
BEGIN
OPEN c_datos;
WHILE c_datos%FOUND LOOP
DBMS_OUTPUT.PUT_LINE( 'codigo: ' || vDEPTNO || ' ... nombre:
'||vDNAME) ;
END LOOP;
CLOSE c_datos;
END;

Este atributo cuenta el número de registros que se han
obtenido con el FETCH. Cuando el cursor es abierto
tiene el valor de 0 (cero).
Sintaxis:
nombre_cursor%ROWCOUNT;
ATRIBUTO: %ROWCOUNT

Ejemplo:
DECLARE
vDEPTNO NUMBER(2);
BEGIN
OPEN c_datos;
DBMS_OUTPUT.PUT_LINE( c_datos%rowcount );
DBMS_OUTPUT.PUT_LINE( 'codigo: ' || vDEPTNO || ' ... nombre: '||vDNAME);
END LOOP;
CLOSE c_datos;
END;

El atributo te permite saber si el cursor esta abierto, en
cuyo caso retorna el valor de TRUE, caso contrario retorna
FALSE.
Sintaxis:
nombre_cursor%ISOPEN;
ATRIBUTO: %ISOPEN

DECLARE
vDEPTNO NUMBER(2);
BEGIN
IF c_datos%ISOPEN THEN
DBMS_OUTPUT.PUT_LINE( 'cursor abierto' );
ELSE
DBMS_OUTPUT.PUT_LINE( 'cursor cerrado' );
END IF;
OPEN c_datos;
ELSE
END IF;

DBMS_OUTPUT.PUT_LINE( 'codigo: ' || vDEPTNO || ' ...
nombre: '||vDNAME) ;
END LOOP;
CLOSE c_datos;
ELSE
END IF;
END;

Esta forma especial de FOR especifica que se ejecutará una
secuencia de instrucciones cada vez que el cursor regrese un
renglón.
Sintaxis:
FOR < nombre_registro > IN < nombre_cursor > LOOP
< secuencia de instrucciones >
END LOOP ;
Sentencia FOR para Cursores

Cuando un ciclo del cursor FOR se inicia, se ejecuta un
OPEN implícito al cursor.
Para cada registro que satisface la consulta asociada con el
cursor, se ejecuta un FETCH implícito sobre las variables
de <nombre_registro>.
Cuando ya no hay más registros que extraer se ejecuta un
CLOSE implícito sobre el cursor, y así termina el ciclo.
Sentencia FOR para Cursores

DECLARE
BEGIN
FOR v_datos IN c_datos LOOP
DBMS_OUTPUT.PUT_LINE( 'codigo: ' || v_datos.deptno || ' ...
nombre: '||v_datos.dname) ;
END LOOP;
END;
Ejemplo:

Cursores: IMPLICITOS
SQL%NOTFOUND
Solo funciona con instrucciones SQL DML. Un cursor
implícito es llamado también CURSOR SQL.
Atributos de Cursores Implícitos
SQL%FOUND
SQL%ROWCOUNT

Es verdadero si la ultima instrucción SQL ejecutada no
implicó ningún registro.
Ejemplo :
ATRIBUTO: %NOTFOUND
BEGIN
DELETE FROM emp WHERE empno=9999;
IF SQL%NOTFOUND THEN
DBMS_OUTPUT.PUT_LINE( 'No existe empleado' ) ;
END IF;
END;

Es verdadero si la última instrucción SQL ejecutada
implicó algún registro.
Ejemplo :
ATRIBUTO: %FOUND
DECLARE
v_ename varchar2(14);
BEGIN
select ename into v_ename from emp where empno=7902;
IF SQL%FOUND THEN
DBMS_OUTPUT.PUT_LINE( 'Si existe empleado' ) ;
END IF;
END;

Cuenta el total de renglones afectados por la última
instrucción SQL ejecutada.
Ejemplo :
ATRIBUTO: %ROWCOUNT
BEGIN
UPDATE emp SET hiredate=sysdate WHERE deptno='30';
DBMS_OUTPUT.PUT_LINE( 'Lineas afectadas : ' || SQL
%ROWCOUNT ) ;
COMMIT;
END;

Sección EXCEPTION
Los errores de PL/SQL son llamados excepciones, que
puede estar predefinida o puede ser definida por el usuario.
Existe una diferencia entre ambos tipos de excepciones, las
primeras se disparan sin necesidad de ser invocadas, las
segundas tienen que ser invocadas, para ello se utiliza la
sentencia RAISE.

Sección EXCEPTION
Sintaxis :
DECLARE
exception_usuario EXCEPTION ;
BEGIN
.........
.........
EXCEPTION
WHEN exception_oracle/exception_usuario/OTHERS THEN
< secuencia de sentencias >;
END ;

Sección EXCEPTION
Se dispara cuando un select retorna mas de 1 línea o registro.
TOO_MANY_ROWS
Se dispara cuando un select no retorna ninguna línea o
registro.
NO_DATA_FOUND
Se dispara cuando se ha especificado o hecho referencia a un
cursor inválido.
INVALID_CURSOR

Sección EXCEPTION
Se dispara cuando ha ocurrido un error de conversión o
validación (aritmética, numérica, cadena de caracteres).
VALUE_ERROR
Se dispara cuando se ha intentado realizar un división por 0.
ZERO_DIVIDE
Se dispara cuando se ha intentado insertar un valor
duplicado en una columna con índice único.
DUP_VAL_ON_INDEX

Sección EXCEPTION
Otras excepciones :
INVALID_NUMBER
VALUE_ERROR
LOGIN_DENIED
PROGRAM_ERROR
CURSOR_ALREADY_OPEN
TIME_OUT_RESOURCE
STORAGE_ERROR
NOT_LOGGED_ON

Sección EXCEPTION
DECLARE
v_dname varchar2(14);
BEGIN
select dname into v_dname from dept where deptno between 10 and 30;
--select dname into v_dname from dept where deptno between 80 and 90;
DBMS_OUTPUT.PUT_LINE( 'Lineas afectadas : ' || SQL
%ROWCOUNT ) ;
EXCEPTION
WHEN TOO_MANY_ROWS THEN
DBMS_OUTPUT.PUT_LINE('Hay mas de un registro!!!!!');
WHEN NO_DATA_FOUND THEN
DBMS_OUTPUT.PUT_LINE('No hay datos!!!!');
END;
Ejemplo 1:

Sección EXCEPTION
DECLARE
v_cnt varchar2(14);
mierror EXCEPTION;
BEGIN
select count(*) into v_cnt from dept;
if v_cnt>1 then
RAISE mierror;
else
DBMS_OUTPUT.PUT_LINE( '1 Departamento' );
end if;
EXCEPTION
WHEN mierror THEN
DBMS_OUTPUT.PUT_LINE('Error de usuario!!!!!');
END;
Ejemplo 2:

Sub-Programas
ANONIMOS
Existen dos tipos principales de bloques PL/SQL:
ANONIMOS y NOMINADOS
Los bloques anónimos se compilan cada vez que se
ejecutan, no se almacenan en la base de datos y no pueden
llamarse directamente desde otros bloques PL/SQL.
DECLARE
...
BEGIN
.........
END ;

Sub-Programas
NOMINADOS
Se pueden almacenar en la base de datos y ejecutarse
cuando sea conveniente.
De manera similar a otros objetos, un subprograma se crea
mediante la instrucción CREATE.
Las siguientes son estructuras nominadas :
PROCEDIMIENTOS FUNCIONES
PAQUETESDISPARADORES

Sub-Programas
PROCEDIMIENTO
La estructura de un procedimiento tiene, por tanto, la
siguiente sintaxis:
CREATE [ OR REPLACE ] PROCEDURE
nombre_procedimiento
AS
/* esta es la sección declarativa */
BEGIN
/* esta es la sección ejecutable */
EXCEPTION
/* esta es la sección de tratamiento de errores */
END;

Sub-Programas
PROCEDIMIENTO
La sintaxis básica de la instrucción CREATE [OR
REPLACE ] PROCEDURE es :
CREATE [ OR REPLACE ] PROCEDURE
nombre_procedimiento
[ ( argumento [ IN | OUT | IN OUT ] tipo,
.....
argumento [ IN | OUT | IN OUT ] tipo ) ] IS | AS
cuerpo_procedimiento

Sub-Programas
PROCEDIMIENTO
Ejemplo :
CREATE OR REPLACE PROCEDURE proc_ejemplo1
AS
CURSOR V_CURSOR IS SELECT * FROM MUNICIPIOS;
BEGIN
FOR v_datos IN v_cursor LOOP
DBMS_OUTPUT.PUT_LINE('Municipalidad:’ || v_datos.nombre );
END LOOP;
END;

Sub-Programas
PROCEDIMIENTO
Un procedimiento se puede ejecutar de varias formas :
1. Utilizando el comando EXECUTE
EXECUTE Proc_ejemplo1;
BEGIN
Proc_ejemplo1;
END ;
2. Llamándolo desde un bloque de programa o
subprograma

Sub-Programas
Consideraciones:
1. La lista de argumentos es opcional. Si no hay
parámetros, los paréntesis no aparecerían ni en la
declaración de la función ni en la llamada a la misma.
2. El tipo de valor que devuelve la función en necesario, y
es parte de la sintaxis de la declaración.
FUNCION

Sub-Programas
La instrucción RETURN se utiliza para devolver el
control, junto con un valor, al entorno que realizó la
llamada.
RETURN expresión;
- Puede haber más de una instrucción RETURN en una
función.
- La finalización de una función sin que se ejecute una
instrucción RETURN es un error.
FUNCION: Instrucción RETURN

Sub-Programas
Ejemplo 1 :
CREATE OR REPLACE FUNCTION func_ejemplo1
RETURN empleados.nombre%TYPE AS
v_dato empleados.nombre%TYPE ;
v_codigo empleados.empleadoid%TYPE := 0 ;
BEGIN
SELECT nombre INTO v_dato FROM EMPLEADOS WHERE
empleadoid=v_codigo;
RETURN v_dato;
EXCEPTION
RETURN ’ Codigo de empleado no existe!!! ’ ;
END;
FUNCION

Sub-Programas
Una función se puede ejecutar de varias formas :
1. En una sentencia SELECT
SELECT func_ejemplo1 FROM DUAL;
BEGIN
v_dato = func_ejemplo2 (5001);
END;
2. Llamándolo desde un bloque de programa o
subprograma
FUNCION

Sub-Programas
Ejemplo 2 :
CREATE OR REPLACE FUNCTION func_ejemplo2 ( p_codigo in
empleados.empleadoid%TYPE)
RETURN empleados.nombre%TYPE
AS
v_dato empleados.nombre%TYPE;
BEGIN
SELECT nombre INTO v_dato FROM EMPLEADOS WHERE
empleadoid=p_codigo;
RETURN v_dato;
EXCEPTION
RETURN 'Codigo de empleado no existe!!!';
END ;
FUNCION

Sub-Programas
Eliminación de Procedimientos y Funciones
La sintaxis para eliminar un procedimiento es:
DROP PROCEDURE nombre_procedimiento
La sintaxis para eliminar una función es:
DROP FUNCTION nombre_función

Sub-Programas
Parámetros de los subprogramas
Los parámetros tiene distintos modos :
- Dentro del procedimiento, el parámetro formal se
comporta como una constante
- Se considera de sólo lectura y no se puede cambiar.
- Cuando el procedimiento finaliza y se devuelve el
control al entorno que lo llamo, el parámetro real no se
modifica.
IN

Sub-Programas
- Se ignora cualquier valor que el parámetro real pueda
tener cuando se produce la llamada.
- Se puede escribir en ella.
control al entorno que lo llamo, se asigna el valor del
parámetro formal al parámetro real.
OUT

Sub-Programas
- Este modo es la combinación de los modos IN y OUT.
- El valor del parámetro real se pasa al procedimiento
- Se puede leer y escribirse en ella.
control al entorno que lo llamo, se asigna el valor del
parámetro formal al parámetro real.
IN OUT

Sub-Programas
Ejemplo :
CREATE OR REPLACE PROCEDURE proc_ejemplo2
( p_codigo IN number )
AS
v_nombre VARCHAR2(50) := ’ v_nombre = <VACIO>
’ ;
BEGIN
dbms_output.put_line(v_nombre) ;
proc_busca_empleado(p_codigo,v_nombre) ;
dbms_output.put_line('v_nombre = '||v_nombre) ;
END;

Sub-Programas
CREATE OR REPLACE PROCEDURE
proc_busca_empleado ( p_codigo in char,
p_nombre in out varchar2) AS
BEGIN
SELECT nombre INTO p_nombre FROM EMPLEADOS
WHERE empleadoid=p_codigo;
EXCEPTION
dbms_output.put_line (’ codigo de empleado no existe!!! ') ;
END;

Sub-Programas
PL/SQL permite agrupar toda la programación
relacionada en un objeto de base de datos,
llamado paquete.
Un paquete es una estructura de PL/SQL que
permite almacenar juntos varios objetos
relacionados.
Package

Sub-Programas
Cabecera
Incluye información acerca del contenido del
paquete.
Cuerpo
Es un objeto independiente de la cabecera.
El cuerpo no puede compilarse hasta que la
cabecera tenga estado válido.
Package : Componentes

Sub-Programas
CREATE PACKAGE mipack AS
PROCEDURE miproc ( v_dato1,v_dato2 ) ;
FUNCTION mifunc ( v_dato1) RETURN number;
END ;
CREATE PACKAGE BODY mipack AS
PROCEDURE miproc ( v_dato1,v_dato2 ) as
begin
--
end;
FUNCTION mifunc (v_dato1) RETURN number
begin
--
end;
END;

Sub-Programas
Ejemplo :
Package
CREATE OR REPLACE PACKAGE
PACK_EJEMPLO1
AS
PROCEDURE proc_municipios;
END;
/* Cabecera */

Paquetes
Package
CREATE OR REPLACE PACKAGE BODY PACK_EJEMPLO1
AS
PROCEDURE proc_municipios
AS
CURSOR V_CURSOR IS SELECT * FROM MUNICIPIOS;
BEGIN
FOR V_DATOS IN V_CURSOR LOOP
DBMS_OUTPUT.PUT_LINE('MUNICIPALIDAD : ’ ||
V_DATOS.NOMBRE);
END LOOP;
END;
END ;
/* Cuerpo */

Paquetes
Un paquete se puede ejecutar de la siguiente manera :
BEGIN
PACK_EJEMPLO1.proc_municipios;
END;
Llamándolo desde un bloque de programa o subprograma
Package
SELECT PACK_EJEMPLO1.func_numero(10)
FROM DUAL;
Utilizando una sentencia SELECT

Paquetes
Cualquier objeto que se declara en la cabecera del paquete
se encuentra dentro del ámbito y es visible fuera paquete.
Package : Ámbito
Ejemplo :
CREATE OR REPLACE PACKAGE PACK_EJEMPLO1
AS
CURSOR v_cursor IS SELECT * FROM MUNICIPIOS;
PROCEDURE proc_municipios;
END;

Paquetes
Package : Ambito
CREATE OR REPLACE PACKAGE BODY
PACK_EJEMPLO1
AS
PROCEDURE proc_municipios
AS
BEGIN
FOR V_DATOS IN V_CURSOR LOOP
DBMS_OUTPUT.PUT_LINE('MUNICIPALIDAD : ’ ||
V_DATOS.NOMBRE);
END LOOP;
END;
END;

Disparadores
DISPARADORES
Al igual que los procedimientos, funciones y
paquetes, los disparadores se almacenan en la
base de datos y no pueden ser declarados en un
bloque PL/SQL.
El disparador se ejecuta de manera implícita cada
vez que tiene lugar el suceso de disparo y no
admite argumentos.

Disparadores
DISPARADORES
Los disparadores pueden utilizarse para:
- Mantener restricciones de integridad complejas.
- Acciones de auditoria.
- Realizar otras acciones a raíz de la ejecución de
sentencias DML.

Disparadores
DISPARADORES: Restricciones
- Un disparador no puede emitir ninguna orden de
control de transacciones: COMMIT, ROLLBACK o
SAVEPOINT.
- El cuerpo del disparador no puede contener
ninguna declaración de variables LONG o LONG
RAW.

Disparadores
DISPARADORES
Sintaxis :
CREATE [OR REPLACE ] TRIGGER nombre_disparo
BEFORE | AFTER | INSTEAD OF suceso_disparo
claúsula_referencia
[ WHEN condición_disparo ]
[ FOR EACH ROW ]
cuerpo_disparo ;

Disparadores
DISPARADORES
Existen tres principales tipos de disparadores:
DML
SUSTITUCION
SISTEMA

Disparadores
DISPARADORES: DML
Un disparador DML se activa con una operación
INSERT, UPDATE o DELETE realizada sobre una
tabla de la base de datos.

Disparadores
DISPARADORES: DML
Ejemplo:
CREATE OR REPLACE TRIGGER update_municipios
AFTER INSERT OR DELETE OR UPDATE ON municipios
DECLARE
v_numero NUMBER(4);
BEGIN
SELECT count(*) INTO v_numero FROM MUNICIPIOS;
INSERT INTO TEMP (A,H) VALUES (v_numero,
'Municipalidades registradas');
END ;

Disparadores
DISPARADORES: Sistema
Un disparador del sistema se activa cuando tiene
lugar un suceso del sistema.

Disparadores
TRIGGERS SISTEMA: Manejo de Sucesos
Suceso
SHUTDOWN
SERVERRROR
LOGON
LOGOFF
CREATE
DROP
ALTER
Temporización Permitido
BEFORE
AFTER
AFTER
BEFORE
BEFORE, AFTER
BEFORE, AFTER
BEFORE, AFTER

Disparadores
Ejemplo:
CREATE OR REPLACE TRIGGER log_modifica
AFTER ALTER ON SCHEMA
BEGIN
INSERT INTO TEMP (USUARIO,DUENO,TIPO,FECHA
DATE) VALUES(USER,SYS.DICTIONARY_OBJ_OWNER,
SYS.DICTIONARY_OBJ_NAME,
SYS.DICTIONARY_OBJ_TYPE, SYSDATE);
END ;
DISPARADORES: Sistema

Disparadores
DISPARADORES: Sustitución
Un disparador por sustitución pueden definirse
únicamente sobre vistas.

Disparadores
Ejemplo:
CREATE OR REPLACE VIEW v_municipios
AS SELECT * FROM MUNICIPIOS ;
CREATE OR REPLACE TRIGGER insert_vista
INSTEAD OF INSERT ON v_municipios
BEGIN
INSERT INTO MUNICIPIOS
VALUES(:NEW.MUNIID,:NEW.NOMBRE,:NEW.DIRECCION,
:NEW.POBLACION, :NEW.EXTENSION ) ;
END ;
DISPARADORES: Sustitución

Disparadores
DISPARADORES: Habilitar - Deshabilitar
Un disparador se elimina así:
DROP TRIGGER nombre_disparador ;
A diferencia de los procedimientos, funciones y
paquetes un disparador se puede deshabilitar sin
necesidad de eliminarlo:
ALTER TRIGGER nombre_disparador
[ DISABLE | ENABLE ] ;

Disparadores
DISPARADORES: Habilitar - Deshabilitar
También se puede habilitar o deshabilitar todos los
disparadores de una tabla determinada utilizando la
orden ALTER TABLE con la cláusula ENABLE ALL
TRIGGERS o DISABLE ALL TRIGGERS.
ALTER TABLE temp
[ ENABLE | DISABLE ] ALL TRIGGERS ;

Disparadores
Utilizando :OLD y :NEW
Dentro del disparador, puede acceder a los datos
de la fila que está siendo actualmente procesada
utilizando :OLD y :NEW

Disparadores
Utilizando :OLD y :NEW
Orden
INSERT
UPDATE
DELETE
:OLD
No definido - NULL
Valores originales de
la fila, antes de la
actualización
Valores originales
antes del borrado de
la fila
:NEW
Valores que serán
insertados cuando se
complete la orden
Nuevos valores que
serán escritos cuando
se complete la orden
No definido - NULL

Disparadores
Utilizando predicados : INSERTING, UPDATING y
DELETING
En los disparadores se pueden utilizar funciones para
controlar el flujo de ejecución de las sentencias:
INSERTING retorna TRUE si se inserta una fila
UPDATING retorna TRUE si se actualiza una fila.
DELETING retorna TRUE si se elimina una fila.

ResumenResumen
En este capítulo, hemos visto como:En este capítulo, hemos visto como:
• Usar sentencias SQL para la selección de datos.Usar sentencias SQL para la selección de datos.
• Usar sentencias SQL para la manipulación deUsar sentencias SQL para la manipulación de
datos.datos.
• Crear bloques de código PL/SQL.Crear bloques de código PL/SQL.
• Usar sentencias de control de flujo.Usar sentencias de control de flujo.
• Crear unidades de programa.Crear unidades de programa.

Administración de base de datos oracle - sesion 1

Recomendados

Recomendados

Más contenido relacionado

Similar a Administración de base de datos oracle - sesion 1

Similar a Administración de base de datos oracle - sesion 1 (20)

Más de Sefira111

Más de Sefira111 (16)

Administración de base de datos oracle - sesion 1