Un "trigger" (disparador o desencadenador) es un bloque de código que se ejecuta

automáticamente cuando ocurre algún evento (como inserción, actualización o borrado) sobre
una determinada tabla (o vista); es decir, cuando se intenta modificar los datos de una tabla (o
vista) asociada al disparador.

Se crean para conservar la integridad referencial y la coherencia entre los datos entre distintas
tablas; para registrar los cambios que se efectúan sobre las tablas y la identidad de quien los
realizó; para realizar cualquier acción cuando una tabla es modificada; etc.

Si se intenta modificar (agregar, actualizar o eliminar) datos de una tabla asociada a un disparador,
el disparador se ejecuta (se dispara) en forma automática.

La diferencia con los procedimientos almacenados del sistema es que los triggers:

- no pueden ser invocados directamente; al intentar modificar los datos de una tabla asociada a
un disparador, el disparador se ejecuta automáticamente.

- no reciben y retornan parámetros.

- son apropiados para mantener la integridad de los datos, no para obtener resultados de
consultas.

Sintaxis general para crear un disparador:

create or replace trigger NOMBREDISPARADOR

MOMENTO-- before, after o instead of

EVENTO-- insert, update o delete

of CAMPOS-- solo para update

on NOMBRETABLA

NIVEL--puede ser a nivel de sentencia (statement) o de fila (for each row)

when CONDICION--opcional

begin

CUERPO DEL DISPARADOR--sentencias

end NOMBREDISPARADOR;

Los triggers se crean con la instrucción "create trigger" seguido del nombre del disparador. Si se
agrega "or replace" al momento de crearlo y ya existe un trigger con el mismo nombre, tal
disparador será borrado y vuelto a crear.

"MOMENTO" indica cuando se disparará el trigger en relación al evento, puede ser BEFORE
(antes), AFTER (después) o INSTEAD OF (en lugar de). "before" significa que el disparador se
activará antes que se ejecute la operación (insert, update o delete) sobre la tabla, que causó el
disparo del mismo. "after" significa que el trigger se activará después que se ejecute la operación
que causó el disparo. "instead of" sólo puede definirse sobre vistas, anula la sentencia
disparadora, se ejecuta en lugar de tal sentencia (ni antes ni después).

"EVENTO" especifica la operación (acción, tipo de modificación) que causa que el trigger se
dispare (se active), puede ser "insert", "update" o "delete"; DEBE colocarse al menos una acción,
puede ser más de una, en tal caso se separan con "or". Si "update" lleva una lista de atributos, el
trigger sólo se ejecuta si se actualiza algún atributo de la lista.

"on NOMBRETABLA" indica la tabla (o vista) asociada al disparador;

"NIVEL" puede ser a nivel de sentencia o de fila. "for each row" indica que el trigger es a nivel de
fila, es decir, se activa una vez por cada registro afectado por la operación sobre la tabla, cuando
una sola operación afecta a varios registros. Los triggers a nivel de sentencia, se activan una sola
vez (antes o después de ejecutar la operación sobre la tabla). Si no se especifica, o se especifica
"statement", es a nivel de sentencia.

"CUERPO DEL DISPARADOR" son las acciones que se ejecutan al dispararse el trigger, las
condiciones que determinan cuando un intento de inserción, actualización o borrado provoca las
acciones que el trigger realizará. El bloque se delimita con "begin... end".

Entonces, un disparador es un bloque de código asociado a una tabla que se dispara

automáticamente antes o después de una sentencia "insert", "update" o "delete" sobre la tabla.

Se crean con la instrucción "create trigger" especificando el momento en que se disparará, qué
evento lo desencadenará (inserción, actualización o borrado), sobre qué tabla (o vista) y las
instrucciones que se ejecutarán.

Los disparadores pueden clasificarse según tres parámetros:

- el momento en que se dispara: si se ejecutan antes (before) o después (after) de la sentencia.

- el evento que los dispara: insert, update o delete, según se ejecute una de estas sentencias sobre
la tabla.

- nivel: dependiendo si se ejecuta para cada fila afectada en la sentencia (por cada fila) o bien una
única vez por sentencia independientemente de la filas afectadas (nivel de sentencia).

Consideraciones generales:

- Las siguientes instrucciones no están permitidas en un desencadenador: create database, alter

database, drop database, load database, restore database, load log, reconfigure, restore log, disk
init, disk resize.

- Se pueden crear varios triggers para cada evento, es decir, para cada tipo de modificación
(inserción, actualización o borrado) para una misma tabla. Por ejemplo, se puede crear un "insert
trigger" para una tabla que ya tiene otro "insert trigger".

A continuación veremos la creación de disparadores para los distintos sucesos (inserción, borrado,
actualización) y todas las cláusulas adicionales.
Los triggers son objetos, así que para obtener información de ellos pueden consultarse los
siguientes diccionarios:

- "user_objects": nos muestra todos los objetos de la base de datos seleccionada, incluidos los
triggers. En la columna "object_type" aparece "trigger" si es un disparador. En el siguiente ejemplo
solicitamos todos los objetos que son disparadores:

select *from user_objects where object_type='TRIGGER';

- "user_triggers": nos muestra todos los triggers de la base de datos actual. Muestra el nombre del
desencadenador (trigger_name), si es before o after y si es a nivel de sentencia o por fila
(trigger_type), el evento que lo desencadena (triggering_event), a qué objeto está asociado, si
tabla o vista (base_object_type), el nombre de la tabla al que está asociado (table_name), los
campos, si hay referencias, el estado, la descripción, el cuerpo (trigger_body), etc. En el siguiente
ejemplo solicitamos información de todos los disparadores que comienzan con "TR":

select trigger_name, triggering_event from user_triggers where trigger_name like 'TR%';

- "user_source": se puede visualizar el código fuente almacenado en un disparador consultando

este diccionario: En el siguiente ejemplo solicitamos el código fuente del objeto
"TR_insertar_libros":

select *from user_source where name='TR_INSERTAR_LIBROS';

A continuación veremos la creación de un disparador para el evento de inserción: "insert triger".

La siguiente es la sintaxis para crear un trigger de inserción que se dispare cada vez que se ejecute
una sentencia "insert" sobre la tabla especificada, es decir, cada vez que se intenten ingresar datos
en la tabla:

create or replace trigger NOMBREDISPARADOR

MOMENTO insert

on NOMBRETABLA

begin

CUERPO DEL TRIGGER;

end NOMBREDISPARADOR;

Analizamos la sintaxis:

Luego de la instrucción "create trigger" se coloca el nombre del disparador. Si se agrega "or
replace" al momento de crearlo y ya existe un trigger con el mismo nombre, tal disparador será
borrado y vuelto a crear.

"MOMENTO" indica cuando se disparará el trigger en relación al evento, puede se BEFORE (antes)
o AFTER (después). Se especifica el evento que causa que el trigger se dispare, en este caso
"insert", ya que el trigger se activará cada vez que se ejecute la sentencia "insert" sobre la tabla
especificada luego de "on".

Es un trigger a nivel de sentencia, es decir, se dispara una sola vez por cada sentencia "insert",
aunque la sentencia ingrese varios registros. Es el valor por defecto si no se especifica.

Finalmente se coloca el cuerpo del trigger dentro del bloque "begin.. end".

Las siguientes sentencias disparan un trigger de inserción:

insert into TABLA values ...;

insert into TABLA select ... from...;

Ejemplo: Creamos un desencadenador que se dispara cada vez que se ejecuta un "insert" sobre la
tabla "libros":

create or replace trigger tr_ingresar_libros

before insert

on libros

begin

insert into Control values(user,sysdate);

end tr_ingresar_libros;

Analizamos el trigger anterior:

"create or replace trigger" junto al nombre del disparador que tiene un prefijo "tr" para reconocer
que es un trigger, referencia el evento que lo disparará y la tabla asociada.

Para identificar fácilmente los disparadores de otros objetos se recomienda usar un prefijo y darles
el nombre de la tabla para la cual se crean junto al tipo de acción.

El disparador se activará antes ("before") del evento "insert" sobre la tabla "libros", es decir, se
disparará ANTES que se realice una inserción en "libros". El trigger está definido a nivel de
sentencia, se activa una vez por cada instrucción "insert" sobre "libros". El cuerpo del disparador
se delimita con "begin... end", allí se especifican las acciones que se realizarán al ocurrir el evento
de inserción, en este caso, ingresar en la tabla "control" el nombre del usuario que alteró la tabla
"libros" (obtenida mediante la función "user") y la fecha en que lo hizo (mediante la función
"sysdate").

Problema:

Una librería almacena los datos de sus libros en una tabla denominada "libros" y controla las
acciones que los empleados realizan sobre dicha tabla almacenando en la tabla "control" el
nombre del usuario y la fecha, cada vez que se ingresa un registro en la tabla "libros".

Eliminamos la tabla:

drop table libros;

Creamos la tabla con la siguiente estructura:

create table libros(

codigo number(6),

titulo varchar2(40),

autor varchar2(30),

precio number(6,2)

);

Creamos la tabla "control", antes la eliminamos:

drop table control;

create table control(

usuario varchar2(30),

fecha date );
Creamos un disparador que se dispare cada vez que se ingrese un registro en "libros"; el trigger
debe ingresar en la tabla "control", el nombre del usuario, la fecha y la hora en la cual se realizó un
"insert" sobre "libros":

create or replace trigger tr_ingresar_libros

before insert

on libros

begin

insert into Control values(user,sysdate);

end tr_ingresar_libros;

Establecemos el formato de fecha para que muestre "DD/MM/YYYY HH24:MI":

alter session set NLS_DATE_FORMAT = 'DD/MM/YYYY HH24:MI';

Veamos qué nos informa el diccionario "user_triggers" respecto del trigger anteriormente creado:

select *from user_triggers where trigger_name ='TR_INGRESAR_LIBROS';

obtenemos la siguiente información:

- trigger_name: nombre del disparador;

- trigger_type: momento y nivel, en este caso es un desencadenador "before" y a nivel de

sentencia (statement);

- triggering_event: evento que lo dispara, en este caso, "insert";

- base_object_type: a qué objeto está asociado, puede ser una tabla o una vista, en este caso, una
tabla (table);

- table_name: nombre de la tabla al que está asociado (libros);

- y otras columnas que no analizaremos por el momento.

Ingresamos un registro en "libros":

insert into libros values(100,'Uno','Richard Bach',25);

Verificamos que el trigger se disparó consultando la tabla "control" para ver si tiene un nuevo
registro:

select *from control;

Ingresamos dos registros más en "libros":

insert into libros values(150,'Matematica estas ahi','Paenza',12);

insert into libros values(185,'El aleph','Borges',42);

Verificamos que el trigger se disparó consultando la tabla "control" para ver si tiene dos nuevos
registros:

select *from control;

Primer problema:

Una librería almacena los datos de sus libros en una tabla denominada "libros" y en una tabla
"ofertas", algunos datos de los libros cuyo precio no supera los $30. Además, controla las
inserciones que los empleados realizan sobre "ofertas", almacenando en la tabla "control" el
nombre del usuario, la fecha y hora, cada vez que se ingresa un nuevo registro en la tabla
"ofertas".

1- Elimine las tres tablas:

drop table libros;

drop table ofertas;

drop table control;

2- Cree las tablas con las siguientes estructuras:

create table libros(

codigo number(6),

titulo varchar2(40),

autor varchar2(30),

editorial varchar2(20),

precio number(6,2)

);

create table ofertas(

titulo varchar2(40),

autor varchar2(30),

precio number(6,2)

);

create table control(

usuario varchar2(30),

fecha date

);

3- Establezca el formato de fecha para que muestre "DD/MM/YYYY HH24:MI":

4- Cree un disparador que se dispare cuando se ingrese un nuevo registro en "ofertas"; el trigger
debe ingresar en la tabla "control", el nombre del usuario, la fecha y la hora en la cual se realizó un
"insert" sobre "ofertas"
5- Vea qué informa el diccionario "user_triggers" respecto del trigger anteriormente creado

6- Ingrese algunos registros en "libros"

insert into libros values(100,'Uno','Richard Bach','Planeta',25); insert into libros

values(102,'Matematica estas ahi','Paenza','Nuevo siglo',12); insert into libros values(105,'El
aleph','Borges','Emece',32); insert into libros values(120,'Aprenda PHP','Molina Mario','Nuevo
siglo',55);

7- Ingrese en "ofertas" los libros de "libros" cuyo precio no superen los $30, utilizando la siguiente
sentencia:

insert into ofertas select titulo,autor,precio from libros where precio<30;

8- Verifique que el trigger se disparó consultando la tabla "control"

drop table libros;

drop table ofertas;

drop table control;

create table libros(

codigo number(6),

titulo varchar2(40),

autor varchar2(30),

editorial varchar2(20),

precio number(6,2)

);

create table ofertas(

titulo varchar2(40),

autor varchar2(30),

precio number(6,2)

);

create table control(

usuario varchar2(30),

fecha date

);

alter session set NLS_DATE_FORMAT = 'DD/MM/YYYY HH24:MI';

create or replace trigger tr_ingresar_ofertas

before insert

on ofertas

begin

insert into Control values(user,sysdate);

end tr_ingresar_ofertas;

select *from user_triggers where trigger_name ='TR_INGRESAR_OFERTAS';

insert into libros values(100,'Uno','Richard Bach','Planeta',25);

insert into libros values(102,'Matematica estas ahi','Paenza','Nuevo siglo',12);

insert into libros values(105,'El aleph','Borges','Emece',32);

insert into libros values(120,'Aprenda PHP','Molina Mario','Nuevo siglo',55);

insert into ofertas select titulo,autor,precio from libros where precio<30;

select *from control;