Está en la página 1de 12

Creación de triggers.

Un trigger es un fragmento de código que uno le dice a PostgreSQL que corra


antes de o después de que una tabla sea modificada. Un trigger tiene el poder
de:
 Asegurar que una columna contiene valores predefinidos
 Asegurar que una fila de auditoria sea insertada en otra tabla
 Luego de encontrar que la nueva información es inconsistente con otras
cosas en la base de datos, levanta un error que causará que toda la
transacción se aborte

La sintaxis para la creación de triggers es la siguiente:

CREATE TRIGGER <trigger name> <BEFORE|AFTER> <INSERT|DELETE|


UPDATE>
ON <relation name> FOR EACH <ROW|STATEMENT>
EXECUTE PROCEDURE <procedure name> (<function args>);

 El nombre del trigger se usará si se desea eliminar el trigger. Se usa


como argumento del comando DROP TRIGGER.

 La palabra siguiente determina si la función debe ser llamada antes


(BEFORE) o después (AFTER) del evento.

 El siguiente elemento del comando determina en que evento/s será


llamada la función. Es posible especificar múltiples eventos utilizado el
operador OR.

 El nombre de la relación (relation name) determinará la tabla afectada


por el evento.

 La instrucción FOR EACH determina si el trigger se ejecutará para cada


fila afectada o bien antes (o después) de que la secuencia se haya
completado.

 El nombre del procedimiento (procedure name) es la función llamada.

Ahora crearemos las Tablas necesaria para la demostración

Creación de tablas:
Obs.:Primero verificamos si las tablas existen, si es así, las eliminamos.

drop table alumnos;


drop table cursos;
drop table alumno_curso;
drop table notas;
drop table promedio;
1) Ahora creamos la tabla alumnos, la cual tiene como clave primaria el
id_alumno.

create table alumnos (


id_alumno integer NOT NULL,
nombre varchar(40) NOT NULL,
direccion varchar(80) NOT NULL,
ciudad varchar(30) NOT NULL,
constraint PK_id_alumno PRIMARY KEY(id_alumno));

2) Ahora creamos la tabla cursos, la cual tiene como clave primaria el


id_curso.

create table cursos (


id_curso integer NOT NULL,
nombre_curso varchar(50) NOT NULL,
constraint PK_id_curso PRIMARY KEY(id_curso));

3-)Ahora creamos la tabla alumno_curso en la que se mostraran los


cursos que tienen los distintos alumnos. Cabe señalar que algunos alumnos
tienen todos los ramos y otros no los tienen todos.

La clave primaria es id_alumno_curso, la cual se forma por las claves


foráneas id_alumno e id_curso las que se referencian por sus respectivas
tablas.

create table alumno_curso (


id_alumno decimal(5,0) NOT NULL,
id_curso decimal(5,0) NOT NULL,
constraint PK_id_alumno_curso PRIMARY KEY(id_alumno,id_curso),
constraint FK_id_alumno FOREIGN KEY(id_alumno) REFERENCES
alumnos(id_alumno),
constraint FK_id_curso FOREIGN KEY(id_curso) REFERENCES
cursos(id_curso));

4-) Ahora creamos la tabla notas, la cual tiene como clave primaria
promedio, la que se forma por los atributos id_alumno e id_curso las que
se referencian por sus respectivas tablas.

Todos los alumnos deben tener las notas puestas. El atributo promedio no
debe llenarse, ya que este se colocara automáticamente a través de un
procedimiento. El promedio que se colocará en la tupla será solamente el
promedio de un ramo que el alumno tiene. Para calcular el promedio de otro
ramo, se debe poner el mismo id del alumno (id_alumno) y el otro id del
curso (id_curso) al cual queremos calcularle el promedio. Recordemos que
todos los alumnos no tienen la misma cantidad de ramos.
CREATE TABLE notas (
id_alumno integer NOT NULL,
id_curso integer NOT NUll,
nota1 integer NOT NULL,
nota2 integer NOT NULL,
nota3 integer NOT NULL,
nota4 integer NOT NULL,
promedio integer NULL,
CONSTRAINT pk_promedio PRIMARY KEY (id_alumno,id_curso),
CONSTRAINT fk_id_alumno FOREIGN KEY (id_alumno)
references alumnos(id_alumno),
CONSTRAINT fk_id_curso FOREIGN KEY (id_curso)
references cursos(id_curso));

6-) Por ultimo se crea la tabla promedio, en donde no existe clave primaria ya
que si ponemos una clave primaria, postgresql nos obligara a ingresar datos a
esta.

En esta tabla se registraran los promedios finales de los alumnos a partir de la


cantidad de ramos que este tiene.

create table promedio(


alumno varchar(20),
promedio_final integer);
Creación del procedimiento:

1) El procedimiento presentado a continuación, calcula el promedio de los


alumnos a partir de sus notas. A continuación se explicara como funciona.

Primero se comprueba si la función existe, se es así, la eliminamos y además


eliminamos en forma de cascada todo lo que dependa de ella .

DROP FUNCTION promedio() CASCADE;

Ahora creamos la función promedio(), la cual retornara un trigger, que es


declarado mas abajo.

Se declaran tres variables:

r: que es de tipo record, la cual nos sirve para tomar los datos de una tupla o
registro en una tabla.

p: de tipo flotante, para guardar el promedio calculado de un alumno en


particular una vez insertada sus notas, este será insertado en la tabla
promedio.

n: de tipo entero, la cual nos sirve para tener la cantidad de promedios de un


alumno en particular

Cada vez que se calcula uno, va incrementando cada vez que un promedio es
calculado.

El promedio que se calculará (NEW.promedio), saldrá de las notas que


insertemos (NEW.nota_n). Donde n es una de las notas, desde la 1 a la 4.

raise notice, es para imprimir por pantalla, es este caso en la terminal, el


promedio del alumno al que se le insertaron las notas.

Luego con select into, se selecciona las tuplas en donde el id del alumno debe
ser igual al id del alumno insertado.

Se cuentan sus promedios y se suman, luego esta suma de los promedio se


dividen por n, con la cual obtenemos el promedio final del alumno. Cada vez
que se calcula un promedio este se suma a la suma (sum(promedio)) y se
vuelve dividir por n (numero de promedios).

Después se imprime por pantalla el promedio final del alumno con sus
respectivo id.
Por ultimo insertamos en la tabla promedio los valores id del alumno y el
promedio final calculado hasta ese entonces, porque recordemos que si
insertamos las notas de otro ramo, el promedio va a sufrir cambios.
CREATE FUNCTION promedio() RETURNS trigger AS'
declare
r record;
p float;
n integer;
BEGIN

NEW.promedio := (NEW.nota1 + NEW.nota2 + NEW.nota3 + NEW.nota4) / 4;


raise notice '' % promedio : %'', new.id_alumno, new.promedio;
select into r sum(promedio) as suma, count(*) as num
from notas
where id_alumno = new.id_alumno;

n := r.num + 1;
p := (r.suma + new.promedio) / n;

raise notice '' % promedio : % %'', new.id_alumno, n, p;

INSERT INTO promedio values (NEW.id_alumno,p);


RETURN NEW;
END;

2-) Creación del Trigger


Ahora creamos el trigger llamado promedio2, el cual se ejecutara entes de
insertar en la tabla notas, en donde para cada tupla ejecutara la función
promedio antes explicada.

CREATE TRIGGER promedio2 BEFORE insert ON notas


FOR EACH ROW EXECUTE PROCEDURE promedio();

2) Ingreso de datos a las tablas


Inserta en la tabla cursos.
insert into cursos values (112,'MATEMATICAS');
insert into cursos values (122,'BASE DE DATOS');
insert into cursos values (123,'REDES');
insert into cursos values (124,'PROGRAMACION');
insert into cursos values (125,'SISTEMAS DE INFORMACION');
insert into cursos values (126,'ELECTRICIDAD');
1) Inserta en la tabla alumnos.
insert into alumnos values (1,'LUIS VERA','BRASIL 123','ASUNCION');
insert into alumnos values (2,'JULIO RAMIREZ','2 EUSEBIO AYALA
1232','ASUNCION');
insert into alumnos values (3,'PAULO
NUNEZ','AVDA.ESPAÑA',ASUNCION');
insert into alumnos values (4,'JUAN ORTEGA','SAN MARTIN
512','ASUNCION');
insert into alumnos values (5,'CRISTIAN MENA','AVDA.
ESPAÑA','ASUNCION');
insert into alumnos values (6,'ROBERTO CASTRO',' FLORIDA','ITALIA');
2) Inserta en la tabla alumno_curso los alumnos con codigo n.

Alumno 1, tiene todos los ramos.

insert into alumno_curso values (1,112);


insert into alumno_curso values (1,122);
insert into alumno_curso values (1,123);
insert into alumno_curso values (1,124);
insert into alumno_curso values (1,125);
insert into alumno_curso values (1,126);

Alumno 2, tiene todo los ramos.

insert into alumno_curso values (2,112);


insert into alumno_curso values (2,122);
insert into alumno_curso values (2,123);
insert into alumno_curso values (2,124);
insert into alumno_curso values (2,125);
insert into alumno_curso values (2,126);

Alumno 3, tiene todos los ramos.

insert into alumno_curso values (3,112);


insert into alumno_curso values (3,122);
insert into alumno_curso values (3,123);
insert into alumno_curso values (3,124);
insert into alumno_curso values (3,125);
insert into alumno_curso values (3,126);

Alumno 4, no tiene REDES y ELECTRICIDAD.

insert into alumno_curso values (4,112);


insert into alumno_curso values (4,122);
insert into alumno_curso values (4,124);
insert into alumno_curso values (4,125);

Alumno 5, no tiene SISTEMAS DE INFORMACIÓN.

insert into alumno_curso values (5,112);


insert into alumno_curso values (5,122);
insert into alumno_curso values (5,123);
insert into alumno_curso values (5,124);
insert into alumno_curso values (5,126);

Alumno 6, no tiene MATEMÁTICAS y ELECTRICIDAD.

insert into alumno_curso values (6,122);


insert into alumno_curso values (6,123);
insert into alumno_curso values (6,124);
insert into alumno_curso values (6,125);
Inserta las notas del alumno 1 en cada ramo en la tabla notas. El promedio se calcula
a través de un procedimiento y el promedio final se insertará en la tabla promedio a
través de este mismo procedimiento.

insert into notas values (1,112,45,45,65,43);


insert into notas values (1,122,56,61,45,43);
insert into notas values (1,123,67,32,21,54);
insert into notas values (1,124,70,49,35,65);
insert into notas values (1,125,21,45,59,65);

Inserta las notas del alumno 2.

insert into notas values (2,112,50,50,50,50);


insert into notas values (2,122,70,70,70,70);
insert into notas values (2,123,10,10,10,10);
insert into notas values (2,124,20,20,20,20);
insert into notas values (2,125,60,60,60,60);
insert into notas values (2,126,30,30,30,30);

Inserta las notas del alumno 3.

insert into notas values (3,112,50,50,50,50);


insert into notas values (3,122,70,70,70,70);
insert into notas values (3,123,10,10,10,10);
insert into notas values (3,124,20,20,20,20);
insert into notas values (3,125,60,60,60,60);
insert into notas values (3,126,30,30,30,30);

Inserta las notas del alumno 4.

insert into notas values (4,112,10,10,11,70);


insert into notas values (4,122,20,20,20,70);
insert into notas values (4,124,67,10,20,70);
insert into notas values (4,125,64,60,60,70);

Inserta las notas del alumno 5.

insert into notas values (5,112,10,10,10,30);


insert into notas values (5,122,20,10,10,65);
insert into notas values (5,123,30,50,10,50);
insert into notas values (5,124,40,10,10,10);
insert into notas values (5,126,50,10,10,10);
Inserta las notas del alumno 6.

insert into notas values (6,122,60,60,60,60);


insert into notas values (6,123,10,20,30,40);
insert into notas values (6,124,30,30,30,30);
insert into notas values (6,125,61,62,63,64);
Aquí mostramos algunas imágenes de consulta que se hicieron a las
tablas:
Con esto concluye la explicación de nuestro TRIGGER, a lo mejor un poco
complicado en un principio, pero que si observa con atención se podrá
entender bien, ahora, quizás faltaron algunas especificaciones mínimas, lo cual
nosotros lo tomamos por sabido ya que la mayoría de los alumnos hicimos el
curso de base de datos el semestre pasado.