FUNCIONAMIENTO

DE LA BASE DE
DATOS
primaria

CREATE DATABASE primaria;

CREATE USER admonprimaria WITH PASSWORD '#DOLBY@TM' SUPERUSER CREATEDB
CREATEROLE LOGIN;
CREATE DOMAIN tipo_genero AS CHARACTER(1)
CHECK (VALUE IN('F','M'));
CREATE DOMAIN tipo_baja AS CHARACTER(10)
CHECK (VALUE IN('DEFINITIVA','TEMPORAL'));
CREATE DOMAIN calificacion AS INT4
CHECK (VALUE>=0 AND VALUE<=10);
CREATE TABLE personal_academico(
id_personal INT4 NOT NULL,
curp VARCHAR(20) NOT NULL UNIQUE,
nombre VARCHAR(30),
appaterno VARCHAR(30),
apmaterno VARCHAR(30),
direccion VARCHAR(150),
genero tipo_genero,
tel_casa VARCHAR(30),
tel_celular VARCHAR(20),
CONSTRAINT pkPersonal PRIMARY KEY(id_personal));
CREATE TABLE usuarios (
id_usuario INT4 NOT NULL,
cuenta VARCHAR(20) NOT NULL UNIQUE,
nombre VARCHAR(90),
contrasenia VARCHAR(46),
fecha_registro TIMESTAMP,
fecha_vencimiento DATE,
tipo_user INT4,
CONSTRAINT pkusuarios PRIMARY KEY(id_usuario));
CREATE FUNCTION concatena()
RETURNS TRIGGER
AS $$
DECLARE
completo VARCHAR(90);
BEGIN
SELECT CONCAT(nombre,' ',appaterno,' ',apmaterno)
FROM personal_academico INTO completo WHERE id_personal=new.id_personal;
IF(TG_OP='INSERT') THEN
INSERT INTO usuarios(id_usuario,cuenta,nombre,fecha_registro)
VALUES(new.id_personal,new.curp,completo,now());
END IF;
RETURN NULL;
END;

$$
LANGUAGE 'plpgsql';
CREATE TRIGGER copiausuario
AFTER INSERT
ON personal_academico
FOR EACH ROW
EXECUTE PROCEDURE concatena();
Nos conectamos con el usuario admonprimaria

Tecleamos la contrasea

Una vez conectados hacemos lo siguiente:

Insertamos datos en la tabla personal_academico.
INSERT INTO personal_academico
VALUES(1,'HEMC900513','Cecilia','Hernandez','Martinez','calle independencia #3,
centro', 'F','019585390013','9511538533');
INSERT INTO personal_academico VALUES(2,'FECJ910317','Jessica','Felix','Calvo','calle
del ninio s/n','F',null,'9515571150');
INSERT INTO personal_academico VALUES(3,'GAJE910823','Erick
David','Garcia','Juarez','Potrerillo s/n sola de vega','M',null,'9511002907');

Consultamos la tabla personal_academico.

Consultamos la tabla usuarios, para ver el comportamiento de los triggers.

Comprobamos el Funcionamiento de los dominios.

INSERT INTO personal_academico
VALUES(4,'GAGA900511','Alheli','Garcia','Gaytan','Potrerillo s/n sola de
vega','K','9585335836','9511002907');

Comprobamos el funcionamiento del comando UNIQUE

INSERT INTO personal_academico
VALUES(4,'GAGA900511','Alheli','Garcia','Gaytan','Potrerillo s/n sola de
vega','K','9585335836','9511002907');
INSERT INTO personal_academico
VALUES(5,'GAGA900511','Alheli','Garcia','Gaytan','Potrerillo s/n sola de
vega','K','9585335836','9511002907');

Creamos las siguientes tablas.

CREATE TABLE materias (
id_materia INT4 NOT NULL,
nombre VARCHAR (50),
grado INT4 NOT NULL,
CONSTRAINT pkmaterias PRIMARY KEY(id_materia));
INSERT INTO materias VALUES(1,'Espaniol primer grado',1);
INSERT INTO materias VALUES(2,'Matematicas primer grado',1);
INSERT INTO materias VALUES(3,'Ciencias Naturales primer grado',1);
INSERT INTO materias VALUES(4,'Historia y Geografia tercer grado',3);
INSERT INTO materias VALUES(5,'Historia de Mexico tercer grado',3);
INSERT INTO materias VALUES(6,'Geografia Universal para quinto',5);
INSERT INTO materias VALUES(7,'Aprendamos a conocernos',2);
INSERT INTO materias VALUES(8,'Matematicas segundo grado',2);
INSERT INTO materias VALUES(9,'Ciencias Naturales primer grado',3);
INSERT INTO materias VALUES(10,'Historia para cuarto grado',4);
INSERT INTO materias VALUES(11,'Historia de Mexico',4);
INSERT INTO materias VALUES(12,'Atlas para quinto',5);
CREATE TABLE grupos (
id_grupo INT4 NOT NULL,
nombre VARCHAR (20),
ciclo_escolar VARCHAR (10),
CONSTRAINT pkgrupos PRIMARY KEY(id_grupo));
INSERT INTO grupos VALUES(1,'primero B','2011-2012');
INSERT INTO grupos VALUES(2,'primero C','2011-2012');
INSERT INTO grupos VALUES(3,'primero A','2011-2012');
INSERT INTO grupos VALUES(4,'tercero A','2011-2012');
INSERT INTO grupos VALUES(5,'quinto A','2011-2012');
INSERT INTO grupos VALUES(6,'quinto B','2011-2012');
CREATE TABLE docente_grupo(
id_personal INT4 NOT NULL,
id_grupo INT4,
aula VARCHAR (10),
CONSTRAINT pkdocente_grupo PRIMARY KEY(id_personal,id_grupo),
CONSTRAINT fkdoc_grupo FOREIGN KEY(id_personal) REFERENCES
personal_academico(id_personal)
ON UPDATE CASCADE ON DELETE CASCADE,
CONSTRAINT fkgrupo_docente FOREIGN KEY(id_grupo) REFERENCES grupos(id_grupo)
ON UPDATE CASCADE ON DELETE CASCADE);

INSERT INTO docente_grupo VALUES(1,2,'F01');

INSERT INTO docente_grupo VALUES(2,4,'F02');
INSERT INTO docente_grupo VALUES(3,5,'F03');
CREATE VIEW vdocente_grupo AS SELECT
personal_academico.curp,personal_academico.nombre,personal_academico.appaterno,
personal_academico.apmaterno,grupos.nombre Imparte_Grupo,docente_grupo.aula
Aula,grupos.ciclo_escolar
FROM personal_academico, grupos, docente_grupo WHERE
docente_grupo.id_personal=personal_academico.id_personal AND
docente_grupo.id_grupo=grupos.id_grupo ORDER BY personal_academico.curp;
CREATE TABLE alumnos(
id_alumno INT NOT NULL,
curp VARCHAR (20) UNIQUE,
nombre VARCHAR (30),
appaterno VARCHAR (30),
apmaterno VARCHAR (30),
direccion VARCHAR (150),
fecha_nacimiento DATE,
genero tipo_genero,
fecha_ingreso DATE,
tutor VARCHAR (120),
CONSTRAINT pkalumno PRIMARY KEY(id_alumno));
INSERT INTO alumnos VALUES(1,'MARA950917','Martinez','Reyes','Aniceto','calle 20 de
noviembre #10','1995-09-17','M',CURRENT_DATE,'Felisa Martinez Antonio');
INSERT INTO alumnos VALUES(2,'HEMF940808','Filomena
Severa','Hernandez','Martinez','calle independencia #3','1994-0808','F',CURRENT_DATE,'Leon Hernandez Pedro');
INSERT INTO alumnos VALUES(3,'AAJE890711','Elizabeth','Alvarez','Juarez','calle
independencia #7','1989-07-11','F',CURRENT_DATE,'Sergio Alvarez Carrasco');
INSERT INTO alumnos VALUES(4,'FECM880423',' Mayra','Felix','Calvo','calle 20 de
noviembre #2','1988-04-23','F',CURRENT_DATE,'Sergio Felix Avendanio');
INSERT INTO alumnos VALUES(5,'OOCE951210','Edgar Ezequiel','Orozco','Cosme','Barrio
Rancho Pina S/N','1995-12-10','F',CURRENT_DATE,'Cristina Cosme Chavez');
CREATE TABLE alumno_actualizado(
id SERIAL NOT NULL,
id_alumno INT NOT NULL,
curp VARCHAR(20),
direccion_anterior VARCHAR(150),
direccion_actualizado VARCHAR(150),
tutor_anterior VARCHAR(120),
tutor_nuevo VARCHAR(120),
usuario VARCHAR(50),
fecha_cambio DATE,
CONSTRAINT pkalumno_actual PRIMARY KEY(id),

CONSTRAINT fkalum_actual FOREIGN KEY(id_alumno) REFERENCES alumnos(id_alumno)

ON DELETE CASCADE ON UPDATE CASCADE);
CREATE FUNCTION actualizar_alumno()
RETURNS TRIGGER
AS $$
BEGIN
IF(TG_OP='UPDATE') THEN
IF(old.direccion!=new.direccion OR old.tutor!=new.tutor) THEN
INSERT INTO
alumno_actualizado(id_alumno,curp,direccion_anterior,direccion_actualizado,tutor_anter
ior,tutor_nuevo,usuario,fecha_cambio)
VALUES( OLD.id_alumno,
OLD.curp,OLD.direccion,new.direccion,OLD.tutor,new.tutor,CURRENT_USER,CURRENT_DA
TE);
END IF;
END IF;
RETURN NULL;
END;
$$
LANGUAGE 'plpgsql';
CREATE TRIGGER actualiza_alumno
AFTER UPDATE
ON alumnos
FOR EACH ROW
EXECUTE PROCEDURE actualizar_alumno();
CREATE TABLE alumno_eliminado(
id_alumno INT NOT NULL,
curp VARCHAR(20)NOT NULL,
nombre VARCHAR(30),
appaterno VARCHAR(30),
apmaterno VARCHAR(30),
baja tipo_baja,
direccion VARCHAR(150),
genero tipo_genero,
tutor VARCHAR(120),
usuario VARCHAR(50),
fecha_eliminacion DATE,
CONSTRAINT pkalumno_eliminado PRIMARY KEY(id_alumno));
CREATE FUNCTION eliminar_alumno()
RETURNS TRIGGER
AS $$
BEGIN
IF(TG_OP='DELETE') THEN
INSERT INTO
alumno_eliminado(id_alumno,curp,nombre,appaterno,apmaterno,baja,direccion,genero,t
utor,usuario,fecha_eliminacion)

VALUES( OLD.id_alumno,
OLD.curp,OLD.nombre,OLD.appaterno,OLD.apmaterno,OLD.direccion,OLD.genero,
OLD.tutor,CURRENT_USER,CURRENT_DATE);
END IF;
RETURN NULL;
END;
$$
LANGUAGE 'plpgsql';
CREATE TRIGGER elimina_alumno
AFTER DELETE
ON alumnos
FOR EACH ROW
EXECUTE PROCEDURE eliminar_alumno();
CREATE TABLE alumno_grupo(
id SERIAL NOT NULL,
id_alumno INT NOT NULL,
id_grupo INT4 NOT NULL,
CONSTRAINT pkalumno_grupo PRIMARY KEY(id),
CONSTRAINT fkag_alumno FOREIGN KEY(id_alumno) REFERENCES alumnos(id_alumno)
ON DELETE CASCADE ON UPDATE CASCADE,
CONSTRAINT fkag_grupos FOREIGN KEY(id_grupo) REFERENCES grupos(id_grupo) ON
DELETE CASCADE ON UPDATE CASCADE);
INSERT INTO alumno_grupo(id_alumno,id_grupo) VALUES(1,4);
INSERT INTO alumno_grupo(id_alumno,id_grupo) VALUES(2,4);
INSERT INTO alumno_grupo(id_alumno,id_grupo) VALUES(3,1);
INSERT INTO alumno_grupo(id_alumno,id_grupo) VALUES(4,2);
CREATE TABLE calificaciones(
id_cal SERIAL NOT NULL,
id_alumno INT NOT NULL,
id_materia INT4 NOT NULL,
id_grupo INT4 NOT NULL,
bimestrei calificacion,
bimestreii calificacion,
bimestreiii calificacion,
bimestreiv calificacion,
bimestrev calificacion,
CONSTRAINT pkcalificaciones PRIMARY KEY(id_cal),
CONSTRAINT fkcal_alumno FOREIGN KEY(id_alumno) REFERENCES alumnos(id_alumno)
ON DELETE CASCADE ON UPDATE CASCADE,
CONSTRAINT fkcal_materia FOREIGN KEY(id_materia) REFERENCES materias(id_materia)
ON DELETE CASCADE ON UPDATE CASCADE,
CONSTRAINT fkcal_grupos FOREIGN KEY(id_grupo) REFERENCES grupos(id_grupo) ON
DELETE CASCADE ON UPDATE CASCADE
);

INSERT INTO calificaciones(id_alumno,id_materia, id_grupo,bimestrei) VALUES(1,2,2,8);

INSERT INTO calificaciones(id_alumno,id_materia, id_grupo,bimestrei) VALUES(1,1,2,9);
INSERT INTO calificaciones(id_alumno,id_materia, id_grupo,bimestrei) VALUES(1,3,2,7);
INSERT INTO calificaciones(id_alumno,id_materia, id_grupo,bimestrei) VALUES(2,2,4,8);
INSERT INTO calificaciones(id_alumno,id_materia, id_grupo,bimestrei) VALUES(3,4,5,9);
INSERT INTO calificaciones(id_alumno,id_materia, id_grupo,bimestrei) VALUES(4,6,6,7);
CREATE VIEW valumno_cal AS SELECT grupos.ciclo_escolar, alumnos.nombre,
alumnos.appaterno, alumnos.apmaterno,materias.nombre AS materia,
calificaciones.bimestrei,calificaciones.bimestreii,calificaciones.bimestreiii,calificaciones.
bimestreiv,calificaciones.bimestrev FROM alumnos,materias,grupos,calificaciones
WHERE calificaciones.id_alumno=alumnos.id_alumno AND
calificaciones.id_materia=materias.id_materia AND
calificaciones.id_grupo=grupos.id_grupo AND alumnos.curp='MARA950917';
CREATE TABLE calificacion_actualizado(
id SERIAL NOT NULL,
id_alumno INT NOT NULL,
id_materia INT4 NOT NULL,
id_grupo INT4 NOT NULL,
bimestrei_ant calificacion,
bimestrei_nuevo calificacion,
bimestreii_ant calificacion,
bimestreii_nuevo calificacion,
bimestreiii_ant calificacion,
bimestreiii_nuevo calificacion,
bimestreiv_ant calificacion,
bimestreiv_nuevo calificacion,
bimestrev_ant calificacion,
bimestrev_nuevo calificacion,
usuario VARCHAR(30),
fecha_cambio DATE,
hora_cambio TIME,
CONSTRAINT pkcalificacion_actualizado PRIMARY KEY(id),
CONSTRAINT fkcal_alumnoact FOREIGN KEY(id_alumno) REFERENCES
alumnos(id_alumno)ON DELETE CASCADE ON UPDATE CASCADE,
CONSTRAINT fkcal_materiaact FOREIGN KEY(id_materia) REFERENCES
materias(id_materia) ON DELETE CASCADE ON UPDATE CASCADE,
CONSTRAINT fkcal_gruposact FOREIGN KEY(id_grupo) REFERENCES grupos(id_grupo) ON
DELETE CASCADE ON UPDATE CASCADE
);
CREATE OR REPLACE FUNCTION tri_calificacion_actualizado()
RETURNS trigger
AS $$
BEGIN
IF( OLD.bimestrei!=NEW.bimestrei OR OLD.bimestreii!=NEW.bimestreii OR
OLD.bimestreiii!=NEW.bimestreiii OR OLD.bimestreiv!=NEW.bimestreiv OR
OLD.bimestrev!=NEW.bimestrev)THEN

INSERT INTO calificacion_actualizado (id_alumno, id_materia,

id_grupo,bimestrei_ant,bimestrei_nuevo, bimestreii_ant, bimestreii_nuevo,
bimestreiii_ant, bimestreiii_nuevo,bimestreiv_ant,bimestreiv_nuevo,
bimestrev_ant,bimestrev_nuevo,usuario,fecha_cambio,hora_cambio)
VALUES(OLD.id_alumno, OLD.id_materia,
OLD.id_grupo,OLD.bimestrei,NEW.bimestrei,OLD.bimestreii,
NEW.bimestreii,OLD.bimestreiii,NEW.bimestreiii,OLD.bimestreiv,
NEW.bimestreiv,OLD.bimestrev, NEW.bimestrev,CURRENT_USER, CURRENT_DATE,
CURRENT_TIME);
END IF;
RETURN NULL;
END;
$$
LANGUAGE 'plpgsql';
CREATE TRIGGER actualiza_calificacion
AFTER UPDATE
ON calificaciones
FOR EACH ROW
EXECUTE PROCEDURE tri_calificacion_actualizado();
CREATE TABLE calificacion_eliminada(
id_cal INT NOT NULL,
id_alumno INT NOT NULL,
id_materia INT4 NOT NULL,
id_grupo INT4 NOT NULL,
bimestrei_elim calificacion,
bimestreii_elim calificacion,
bimestreiii_elim calificacion,
bimestreiv_elim calificacion,
bimestrev_elim calificacion,
usuario VARCHAR(30),
fecha_eliminacion DATE,
hora_eliminacion TIME,
CONSTRAINT pkcalificacion_eliminada PRIMARY KEY(id_cal));
CREATE OR REPLACE FUNCTION tri_calificacion_eliminado()
RETURNS trigger AS $$
BEGIN
IF(TG_OP='DELETE') THEN
INSERT INTO calificacion_eliminada VALUES(OLD.id_cal,
OLD.id_alumno,OLD.id_materia,
OLD.id_grupo,OLD.bimestrei,OLD.bimestreii,OLD.bimestreiii,OLD.bimestreiv,OLD.bimestr
ev, CURRENT_USER, CURRENT_DATE,CURRENT_TIME);
END IF;
RETURN NULL;
END;
$$
LANGUAGE 'plpgsql';

CREATE TRIGGER elimina_calificacion

AFTER DELETE
ON calificaciones
FOR EACH ROW
EXECUTE PROCEDURE tri_calificacion_eliminado();
Consultamos la tabla alumnos.

Actualicemos un dato para comprobar el funcionamiento del trigger actualiza_alumno.

Eliminemos un dato para comprobar el trigger elimina_alumno.

DELETE FROM alumnos WHERE id_alumno=5;

Comprobamos el trigger actualiza_calificaciones

Comprobamos el trigger elimina calificaciones

Comprobamos los dominios de la tabla calificaciones

INSERT INTO calificaciones(id_cal,id_alumno,id_materia,id_grupo,bimestreii)
VALUES(7,2,3,4,11)