Laboratorio 13

Presentado por: Jhon Barcasnegras
A la profesora: Claudia Casas

Análisis y desarrollo de sistemas de información
Servicio nacional de aprendizaje
2015

Laboratorio 13
1. Procedimientos almacenados para inserción de registros
Un procedimiento almacenado es similar a una función pero no retorna un valor.
Reciben sui nombre porque las instrucciones quedan almacenadas en el servidor. Su
función es facilitar la ejecución de una tarea en la base de datos ya que ahorra
ejecutar toda la sintaxis habitualmente necesaria para ello.
Vamos a crear procedimientos almacenados para inserción de datos. Para ello
utilizaremos la base de datos laboratorio.sql que desarrollamos en el laboratorio 12.
Para esto hemos aprovechado la base de datos creada en MySQL y además la hemos
creado nuevamente en Oracle.
Los primeros ejercicios serán ejecutados en MySQL y aplican para las tablas
profesor, curso, estudiante y estudiantexcurso.
1.1 Tabla profesor
La tabla profesor tiene esta estructura:
mysql> describe profesor;
+---------------+---------------+-------+-----+---------+-------+
| Field
| Type
| Null | Key | Default | Extra |
+----------------+---------------+------+-----+---------+-------+
| doc_profesor | varchar(20) | NO | PRI | NULL |
|
| nom_profesor | varchar(30) | NO |
| NULL |
|
| ape_profesor | varchar(30) | NO |
| NULL |
|
| cate_prof
| int(11)
| YES |
| NULL |
|
| sal_prof
| int(11)
| YES |
| NULL |
|
+----------------+---------------+-------+-----+---------+-------+
Tiene almacenados los siguientes datos:
mysql> select * from profesor;
+-----------------+------------------+----------------+-----------+----------+
| doc_profesor | nom_profesor | ape_profesor | cate_prof | sal_prof |
+-----------------+------------------+----------------+-----------+----------+
| 1.098.765.789 | Alejandra
| Torres
|
4
| 1100000 |
| 13.826.789
| Maritza
| Angarita
|
1
| 550000 |
| 63.502.720
| Martha
| Rojas
|
2
| 690000 |
| 91.216.904
| Carlos
| Pérez
|
3
| 950000 |
+-----------------+-----------------+----------------+------------+----------+
Primero creamos un delimitador, este puede ser cualquier símbolo aunque los más
habituales son // y $$. Dentro se establecen los parámetros y el procedimiento a
ejecutar.
Para mayor comodidad, en esta ocasión no he utilizado la terminal de MySQL sino la
aplicación gráfica MySQL Workbench ya que me permite editar una línea si cometo

algún error y luego ejecutar todo el bloque de instrucciones.

**Procedimiento almacenado para la tabla ins_profesor (nota: dice tabla profesor
porque no tengo captura de la corrección. Cambié el nombre para que no se llamara
igual que la tabla).
Ahora hay que ponerlo a prueba llamando al método e introduciendo información
válida de acuerdo a los parámetros:

Verificamos que se hayan insertado los datos correctamente:
mysql> select * from profesor;
+-----------------+------------------+--------------+-------------+----------+
| doc_profesor | nom_profesor | ape_profesor | cate_prof | sal_prof |
+-----------------+------------------+----------------+-----------+----------+
| 1.098.765.789 | Alejandra
| Torres
|
4 | 1100000 |
| 13.826.789
| Maritza
| Angarita
|
1 | 550000 |
| 63.502.720
| Martha
| Rojas
|
2 | 690000 |
| 73542983
| Rafael
| Conde
|
3 | 950000 |
| 91.216.904
| Carlos
| Pérez
|
3 | 950000 |
+-----------------+------------------+----------------+-----------+----------+

1.2 Tabla curso

mysql> select * from curso;
+------------+-------------------------------------+-------------+-----------+
| cod_curso | nom_curs
| horas_cur | valor_cur |
+------------+--------------------------------------+-------------+-----------+
| 149842 | Fundamentos de bases de datos |
40 | 500000 |
| 172943 | Procedmientos almacenados
|
20 | 500000 |
| 250067 | Fundamentos de SQL
|
20 | 700000 |
| 289011 | Manejo de MySQL
|
45 | 550000 |
| 345671 | Fundamentos de Oracle
|
60 | 3000000 |
+------------+--------------------------------------+------------+-----------+

1.3 Tabla estudiantes

mysql> select* from estudiante;
+-----------------+--------------+-----------------+----------+
| doc_est
| nom_est | ape_est
| edad_est |
+-----------------+--------------+-----------------+----------+
| 1.098.098.097 | Jonatan
| Ardila
|
17 |
| 1.098.765.678 | Carlos
| Martinez
|
19 |
| 63.502.720
| María
| Perez
|
23 |
| 72240535
| Jhon
| Barcasnegras |
37 |
| 91.245.678
| Carlos Jose | Lopez
|
25 |
+-----------------+--------------+------------------+----------+

fec_ini_estcur -> from curso join estudiante join estudiantexcurso -> on doc_est = doc_est_estcur and cod_curso = cod_curso_estcur.098.098. doc_est.098. nom_est.502.097 | Jonatan | 2011-01-02 | | 345671 | 63.4 Tabla estudiantexcurso mysql> select cod_curso.720 | María | 2011-01-03 | | 289011 | 1.678 | Carlos | 2011-01-02 | | 250067 | 63.502.765.720 | María | 2011-01-04 | | 172943 | 72240535 | Jhon | 2014-02-06 | +------------+------------------+----------+------------------+ . +------------+-----------------+-----------+-----------------+ | cod_curso | doc_est | nom_est | fec_ini_estcur | +------------+-----------------+-----------+-----------------+ | 289011 | 1.1.

5 Tabla artículo: Las tablas cliente. artículo y pedido la realizaremos usando la interfaz web de Oracle. .1.

. PL/SQL procedure successfully completed. 22000). 'Jhon Barcasnegras'. 'AlphaomegaRama'.Ejecutamos en terminal el procedure: SQL> execute ins_articulo('laboratorio 13'.

6 Tabla cliente .1.

no se puede usar execute: .La ejecución del procedimiento desde una IDE es algo distinta.

7 Tabla pedido .1.

.

1.8 Tabla compañía .

+----------------+-------------------------+---------------+-----------------------------+ | comnit | comnombre | comañofun | comreplegal | +----------------+-------------------------+---------------+-----------------------------+ | 800890890-2 | Seguros Atlantida | 1998 | Carlos López | | 899999999-1 | Aseguradora Rojas | 1991 | Luis Fernando Rojas | | 899999999-5 | Seguros del Estadio | 2001 | Maria Margarita Pérez | | 899999999-7 | Seguros del caribe | 2005 | Luis Arrieta | +----------------+-------------------------+---------------+-----------------------------+ 1.mysql> select *from compañia.9 Tabla tiposautomotores .

10 Tabla automotores . +------.mysql> select *from tiposautomotores.----+----------------+ | autotipo | autnombre | +-----------+----------------+ | 1 | Automóviles | | 2 | Camperos | | 3 | Camiones | | 4 | Autobuses | +----------+-----------------+ 4 rows in set (0.00 sec) 1.

+-----------+-----------------+----------+------------+------------------+---------------+-------------------+ | autoplaca | automarca | autotipo | automodelo | autonumpasajeros | autocilindraje|autonumchasis | +-----------+-----------------+----------+------------+------------------+---------------+-------------------+ | DKZ820 | Reanult stepway | 1| 2008 | 5| 1600 | wywzzz157kk009d45 | | FDT650 | Mercedes | 4| 2010 | 45 | 12300 | wywzzz127kk009f95 | | FLL420 | Chevrolet corsa | 1| 2003 | 5| 1400 | wywzzz167kk009d25 | | KJQ920 | Kia sportage | 2| 2009 | 7| 2000 | wywzzz157kk009d25 | +-----------+-----------------+----------+------------+------------------+---------------+-------------------+ .mysql> select *from automotores.

11 Tabla aseguramientos Llamamos al procedimiento: call ins_asegura('2013-08-12'. 'Vigente'. '2014-08-12'. 1200000). 60000000. 'FDT650'. comprobamos que se inserten los datos correctamente.1. +-----------+----------------+--------------------+-------------------+-----------+---------+----------+ | asecodigo | asefechainicio | asefechaexpiracion | asevalorasegurado | aseestado | aseplaca | asecosto | +-----------+----------------+--------------------+-------------------+----------+-------------------+----------+ | 1 | 2012-09-30 | 2013-09-30 | 30000000 | Vigente | FLL420 | 500000 | | 2 | 2012-09-27 | 2013-09-27 | 35000000 | Vigente | DKZ820 | 600000 | | 3 | 2011-09-28 | 2012-09-28 | 50000000 | Vencido | KJQ920 . mysql> select *from aseguramientos.

'FDT650'. 2). +------------+---------------+-----------+--------------+-----------------+--------------------+--------------------------+ | incicodigo | incifecha | inciplaca | incilugar | incicantheridos | incicantfatalidades | incicanautosinvolucrados | +------------+---------------+-----------+--------------+-----------------+--------------------- . 0. 'Barranquilla'.12 Tabla incidentes call ins_incidente('2013-09-15'. mysql> select *from incidentes. 1.| 800000 | | 4 | 2013-08-12 | 2014-08-12 | 60000000 | Vigente | FDT650 | 1200000 | +-----------+----------------+--------------------+-------------------+----------+------------------+----------+ 1.

Oracle no me permite crear un procedimiento que simplemente lleve el select en su interior. El código del cursor en el procedimiento sería así: .1 Proceso ordenar salarios: Este ejercicio solicita presentar los salarios de los profesores organizados por categorías.+--------------------------+ | 1 | 2012-09-30 | DKZ820 | Bucaramanga | 2| | 2 | 2012-09-27 | FLL420 | Girón | 1| | 3 | 2011-09-28 | FLL420 | Bucaramanga | 2| | 4 | 2013-09-15 | FDT650 | Barranquilla | 2| 0| 0| 1| 0| 1| 0| 1| 0| 2 Procedimientos almacenados para procesos en Oracle 2. sino que al investigar veo que debo crear un cursor.

Ejecutamos el procedimiento y obtenemos el resultado en pantalla: .

2.2 Proceso cursos: Mostrar los cursos cuyo valor sea mayor a $500000: .

2.3 Proceso clientes: Muestra los datos de los clientes que realizaron pedidos el día 25 de febrero del 2012. .

Muestra el resultado: Artículo: Artículo: Artículo: Artículo: Artículo: Artículo: Facebook y Twitter para adultos Cantidad: 10 Valor: 55000 Creación de un portal con PHP y MySQL Cantidad: 12 Valor: 45000 Creación de un portal con PHP y MySQL Cantidad: 5 Valor: 40000 Administración de sistemas operativos Cantidad: 12 Valor: 55000 Redes Cisco Cantidad: 20 Valor: 65000 Redes Cisco Cantidad: 5 Valor: 65000 Statement processed.asefechaexpiracion ||' Marca: '|| resultado.tit_art ||' Cantidad: '|| resultado. . 2.2.4 Mostrar todos los pedidos: create or replace procedure "LISTA_PEDIDOS" is cursor curs is select tit_art.automarca).val_ven_art_artped). end. begin for resultado in curs loop dbms_output. end loop.autoplaca ||' Expiración: '|| resultado. can_art_artped.5 Mostrar vehículos: Mostrar vehículos cuya póliza vence el 30 de septiembre de 2013 (El ejercicio decía octubre pero no hay datos con esa fecha).put_line ('Artículo: '|| resultado. automarca from automotores join aseguramientos on autoplaca = aseplaca and asefechaexpiracion = '09-30-2013'. create or replace procedure "vsept2013" is cursor curs is select autoplaca. val_ven_art_artped from articuloxpedido join articulo on id_art = id_art_artped. begin for resultado in curs loop dbms_output.can_art_artped ||' Valor: '|| resultado.put_line ('Placa: '|| resultado. asefechaexpiracion.

3 Procedimientos almacenados para procesos con MySQL En MySQL los procedimientos con select no son distintos de los insert y requieren mucho menos trabajo que con Oracle. Llamamos el procedimiento y obtenemos los datos que queremos.1 Proceso mostrar cursos Vamos a mostrar todos los cursos ordenados por valor. DELIMITER $$ USE `laboratoriosql`$$ CREATE PROCEDURE mostrar_cursos () BEGIN select *from curso order by valor_cur. DROP procedure IF EXISTS `mostrar_cursos`. Mysql> call mostrar_cursos. +-----------+-------------------------------------+-----------+-----------+ | cod_curso | nom_curs | horas_cur | valor_cur | +-----------+--------------------------------------+-----------+-----------+ | 149842 | Fundamentos de bases de datos | 40 | 500000 | | 172943 | Procedimientos almacenados | 20 | 500000 | | 289011 | Manejo de MySQL | 45 | 550000 | . end. 3.end loop. USE `laboratoriosql`. Muestra el resultado: Placa: FLL420 Expiración: 09/30/2013 Marca: Chevrolet corsa Statement processed. END$$ DELIMITER .

can_art_artped. +-----------+--------+----------------------------------------+---------------+--------------------+ | id_pedido | id_art | tit_art | can_art_artped | val_ven_art_artped | +-----------+--------+----------------------------------------+---------------+--------------------+ | 1| 3 | Creación de un portal con php y mysql | 5| 40000 | | 1| 4 | Administración de sistemas operativos | 12 | 55000 | | 2| 1 | Redes cisco | 5| 65000 | | 3| 2 | Facebook y twitter para adultos | 10 | 55000 | | 3| 3 | Creación de un portal con php y mysql | 12 | 45000 | | 4| 1 | Redes cisco 20 | 65000 | | +-----------+--------+----------------------------------------+---------------+--------------------+ .| 250067 | Fundamentos de SQL | 20 | 700000 | | 345671 | Fundamentos de Oracle | 60 | 3000000 | 3. tit_art. DROP procedure IF EXISTS `mostrar_pedidos`. Llamamos el proceso y obtenemos los valores: mysql> call mostrar_pedidos. END$$ DELIMITER . val_ven_art_artped from pedido join articulo join articuloxpedido on id_pedido = id_ped_artped and id_art_artped = id_art.2 Mostrar pedidos USE `laboratoriosql`. id_art. DELIMITER $$ USE `laboratoriosql`$$ CREATE PROCEDURE mostrar_pedidos () BEGIN select id_pedido.

4 Clientes ordenados por apellidos: USE `laboratoriosql`.3. . DROP procedure IF EXISTS `mostrar_empresas`.3 Empresas fundadas entre 1991 y 1998 USE `laboratoriosql`. Llamamos el procedimiento: mysql> call mostrar_empresas. DELIMITER $$ USE `laboratoriosql`$$ CREATE PROCEDURE mostrar_empresas() BEGIN select *from compañia where comañofun >= 1991 and comañofun <= 1998. DROP procedure IF EXISTS `clientesxapellido`. DELIMITER $$ USE `laboratoriosql`$$ CREATE PROCEDURE clientesxapellido () BEGIN select *from cliente order by ape_cli desc. END$$ DELIMITER . +----------------+----------------------+---------------+------------------------+ | comnit | comnombre | comañofun | comreplegal | +----------------+-----------------------+---------------+------------------------+ | 800890890-2 | Seguros Atlantida | 1998 | Carlos López | | 899999999-1 | Aseguradora Rojas | 1991 | Luis Fernando Rojas | +----------------+------------------------+--------------+--------------------------+ 3. END$$ DELIMITER .

6 Incidentes del vehículo FLL420 USE `laboratoriosql`. Llamamos el proceso: 3. DROP procedure IF EXISTS `incidentes1herido`. END$$ DELIMITER .Llamamos el procedure: 3. asevalorasegurado from incidentes join aseguramientos on inciplaca = aseplaca and incicantheridos = 1. aseestado. aseestado. DELIMITER $$ USE `laboratoriosql`$$ CREATE PROCEDURE incidentes1herido () BEGIN select incifecha. asevalorasegurado from incidentes join aseguramientos . asefechaexpiracion. DROP procedure IF EXISTS `incifll420`. inciplaca. inciplaca.5 Incidentes con un herido USE `laboratoriosql`. DELIMITER $$ USE `laboratoriosql`$$ CREATE PROCEDURE incifll420 () BEGIN select incifecha. asefechainicio. asefechainicio.

Llamamos el procedimiento: 4. DELIMITER $$ USE `laboratoriosql`$$ CREATE FUNCTION contar22 () RETURNS INTEGER BEGIN DECLARE cantidad int. select count(*) into cantidad from estudiante where edad_est > 22.on inciplaca = aseplaca and inciplaca = 'FLL420'. END$$ DELIMITER . Funciones 4. +------------+ | contar22() | +------------+ | 3 | +------------+ .1 Contar estudiantes mayores de 22 USE `laboratoriosql`. END$$ DELIMITER . RETURN cantidad. Llamamos la función y visualizamos el resultado: mysql> select contar22(). DROP function IF EXISTS `contar22`.

+---------+------------+ | nom_est | edad_est | +---------+------------+ | Jonatan | 17 | +---------+------------+ 4. DROP function IF EXISTS `masJoven`. RETURN masJoven. END.4. SELECT edad_est into masJoven from estudiante order by edad_est asc limit 1.2 Mostrar el nombre del más estudiante más joven Primero he creado una función que devuelve como valor la edad del alumno más joven: USE `laboratoriosql`. DELIMITER $$ USE `laboratoriosql`$$ CREATE FUNCTION masJoven () RETURNS int BEGIN DECLARE masJoven int. DROP function IF EXISTS `promediocursos`. RETURN var_promedio. DELIMITER $$ USE `laboratoriosql`$$ CREATE FUNCTION promediocursos () RETURNS INTEGER BEGIN declare var_promedio int. edad_est from estudiante where edad_est = masJoven().3 Valor promedio de los cursos con más de 40 horas USE `laboratoriosql`. END$$ .$$ DELIMITER . así: mysql> select nom_est. select avg(valor_cur) into var_promedio from curso where horas_cur > 40. Y luego la he combinado con un select.

4 Sueldo promedio de profesores categoría 1 USE `laboratoriosql`. DROP function IF EXISTS `promediosueldo`. Probamos la función: 4. SELECT AVG(sal_prof) INTO avgsueldo FROM profesor WHERE cate_prof = 1.DELIMITER . Probamos la función con select: mysql> select promediosueldo(). END$$ DELIMITER . RETURN avgsueldo.00 sec) . DELIMITER $$ USE `laboratoriosql`$$ CREATE FUNCTION promediosueldo () RETURNS INTEGER BEGIN DECLARE avgsueldo int. +---------------------+ | promediosueldo() | +---------------------+ | 550000 | +---------------------+ 1 row in set (0.

DELIMITER $$ USE `laboratoriosql`$$ CREATE FUNCTION menorSueldo () RETURNS VARCHAR(30) BEGIN DECLARE nombre VARCHAR(30). SELECT nom_profesor INTO nombre FROM profesor ORDER BY sal_prof ASC LIMIT 1. RETURN nombre. mysql> select menorsueldo().5 Nombre del profesor con el menor sueldo USE `laboratoriosql`.00 sec) .4. END$$ DELIMITER . +-----------------+ | menorsueldo() | +-----------------+ | Maritza | +-----------------+ 1 row in set (0. DROP function IF EXISTS `menorSueldo`.

fecha y valor del pedido más costoso Para resolver esta función ya que hay que devolver varios valores en una variable.2 Devolver la cantidad de artículos por cada editorial El ejercicio me pide realizarlo con una función pero en los ejercicios anteriores realicé inserciones de datos en la tabla artículos y ahora mi tabla tiene este aspecto: Para retornar las distintas editoriales con las cantidades de artículos correspondientes tuve que usar no una función sino un procedimiento con un cursor: . BEGIN SELECT 'Nombre: '|| nom_cli ||' Fecha: '|| fec_ped || ' Valor: '|| val_ped INTO var_datos FROM cliente JOIN pedido ON id_cli = id_cli_ped and val_ped = (SELECT MAX(val_ped) from pedido). utilice una concatenación. END. RETURN var_datos.5 Funciones con Oracle 5. Para conseguir el valor más alto realice una subconsulta. CREATE OR REPLACE FUNCTION fn_valPed RETURN VARCHAR2 IS var_datos VARCHAR2(500). Ejecutamos la función y obtenemos el valor deseado: select fn_valped from dual.1 Nombre. 5.

end. begin for valores in curs loop dbms_output. Y nos regresa los valores que buscamos: Alphaomega-Rama 4 Alphaomega-rama 1 Oveja negra 1 Statement processed. 5.put_line (valores. end loop. END. .create or replace procedure "PA_EDITORIALES" is cursor curs is select edi_art ||' '||count(*) edi_art from articulo group by edi_art. end. RETURN var_datos.3 Datos de la póliza más costosa Esta función es similar a la que solicitaba el valor del pedido más costoso: create or replace FUNCTION fn_valpoliza RETURN VARCHAR2 IS var_datos VARCHAR2(500). BEGIN SELECT 'Código: '|| asecod ||' Fecha expiración: '|| asefechaexpiracion || ' Valor asegurado: '|| asevalorasegurado INTO var_datos FROM aseguramientos WHERE asevalorasegurado = (SELECT MAX(asevalorasegurado) from aseguramie ntos).edi_art). Probamos el funcionamiento ejecutándolo en la interfaz web: begin pa_editoriales.

RETURN var_datos.4 Incidentes con el mínimo de autos involucrados CREATE OR REPLACE FUNCTION fn_incidentes RETURN VARCHAR2 IS var_datos VARCHAR2(500). BEGIN SELECT 'Código incidente: '|| incicod ||' Fecha: '|| incifecha || ' Lugar: '|| incilugar || ' Placa: '|| inciplaca|| ' Valor póliza: '|| asevalorasegurado || ' Vehículos implicados: '|| incicanautosinvolucrados INTO var_datos FROM incidentes JOIN aseguramientos ON inciplaca = aseplaca and incicanautosinvolucrados = (SELECT MIN(incicanautosinvolucrados) from incidentes).5. Probamos la función y obtenemos: . END.

RETURN var_datos.5. END.5 Datos de la póliza de mayor valor create or replace FUNCTION fn_autopolizamasval RETURN VARCHAR2 IS var_datos VARCHAR2(700). BEGIN SELECT 'Placa: '|| autoplaca ||' Marca: '|| automarca || ' Tipo: '|| autotipo ||' Modelo: '|| automodelo ||' Inicio póliza:' || asefechainicio|| 'Expiración: '|| asefechaexpiracion ||' Estado: '|| aseestado || ' Valor: '|| asevalorasegurado INTO var_datos FROM aseguramientos JOIN automotores ON aseplaca = autoplaca AND asevalorasegurado = (SELECT MAX(asevalorasegurado) from aseguramientos). .

Pueden ejecutarse antes (Before) o después (After). Esta acción puede ser Update. 6. insert y delete. Disparadores o Triggers Los disparadores son funciones útiles en auditoría que se programan para ejecutarse automáticamente cuando se efectúa el tipo de acción que los dispara. y el usuario del sistema que realizó los cambios.1.1 Disparador para profesor en MySQL 6.6.1 Actualizar Creamos una tabla para auditoria llamada “auditoria_profesor” la cual incluirá los viejos y nuevos valores de las columnas afectadas. Para esto último se utiliza la función current_user() que ya viene definida en MySQL. la cual se colocará como valor por defecto para la columna audi_usuario: Una forma de crear el disparador es ir a la tabla profesor en mysql Workbench y editar la opción triggers: .

audi_usuario. current_user().sal_prof. new. audi_categoriaAnterior.nom_profesor. update profesor set cate_prof = 4 where doc_profesor = '73542983'. old.sal_prof. audi_accion) values (old.ape_profesor. new. audi_docProfesor.ape_profesor. END$$ DELIMITER . now().profesor_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. new. audi_categoriaNuevo. audi_apellidoNuevo.cate_prof. Voy a editar la categoría y salario del profesor Rafael Conde quien tiene categoría 3 y pasará a 4 con el mismo sueldo que el otro profesor que ostenta esa categoría. new.doc_profesor. old. audi_apellidoAnterior. audi_salarioAnterior. . DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql.`profesor_BEFORE_UPDATE` BEFORE UPDATE ON `profesor` FOR EACH ROW BEGIN insert into auditoria_profesor(audi_nombreAnterior. old. update profesor set sal_prof = 1100000 where doc_profesor = '73542983'.nom_profesor. audi_salarioNuevo.La aplicación genera el código adecuado: USE `laboratoriosql`. 'Actualización'). audi_fechaModificacion.cate_prof. audi_nombreNuevo. new.

audi_docProfesor. audi_accion) VALUES(old. Ahora la función current_user() devuelve el valor jhonbarc@localhost. audi_salarioAnterior. current_user(). audi_usuario. * TO 'jhonBarc'@'localhost'.nom_profesor. 6. audi_apellidoAnterior. audi_categoriaAnterior. old. Pero primero vamos a crear un trigger para ese evento: USE `laboratoriosql`. old. le he dado privilegios de acceso: GRANT ALL PRIVILEGES ON * .2 Eliminando registros Vamos a borrar un registro en la tabla profesor con el nuevo usuario.doc_profesor. old. he creado un usuario nuevo: CREATE USER 'jhonBarc'@'localhost' IDENTIFIED BY 'jhon12345'. Y luego refrescamos los privilegios: Ahora voy a usar ese nuevo usuario para los ejercicios.Y ahora miramos cómo quedó la tabla profesor y la tabla auditoria_profesor (La resolución no es la mejor pero tuve que editar la captura para poder mostrar todos lo contenidos): Para que current_user() no me de siempre root.`profesor_AFTER_DELETE` AFTER DELETE ON `profesor` FOR EACH ROW BEGIN INSERT INTO auditoria_profesor(audi_nombreAnterior.profesor_AFTER_DELETE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`.ape_profesor. now().1. 'Registro eliminado').sal_prof. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql. old. audi_fechaModificacion. END$$ DELIMITER . .cate_prof. Cerrando mi conexión y regresando con mi nuevo usuario y contraseña.

`audi_codCurso` INT NULL.1 Actualizar Curso CREATE TABLE `laboratoriosql`. `audi_usuario` VARCHAR(45) NULL DEFAULT 'current_user()'. `audi_fechaModificacion` DATE NULL.Eliminamos el registro: delete from profesor where doc_profesor = 'Rafael'.`auditoria_curso` ( `idaudi` INT NOT NULL AUTO_INCREMENT. `audi_accion` VARCHAR(45) NULL. `audi_horasNuevo` INT NULL. `audi_nombreAnterior` VARCHAR(100) NULL. `audi_valorNuevo` INT NULL. . `audi_horasAnterior` INT NULL.2.2 Disparador para la tabla curso en MySQL 6. `audi_nombreNuevo` VARCHAR(100) NULL. Y ahora miramos que ha ocurrido con nuestras tablas profesor y auditoría profesor: Se ha borrado el registro del profesor Rafael Conde y ahora sí aparece que el evento lo realizó el usuario jhonBarc tal como se ve en la siguiente imagen: 6. `audi_valorAnterior` INT NULL.

nom_curs. old. new.curso_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`.`curso_BEFORE_UPDATE` BEFORE UPDATE ON `curso` FOR EACH ROW BEGIN insert into auditoria_curso(audi_nombreAnterior. . old. audi_valorNuevo.valor_cur. USE `laboratoriosql`.nom_curs. audi_horasNuevo. audi_horasAnterior. current_user(). 'Actualización'). audi_nombreNuevo. audi_valorAnterior.valor_cur. audi_valorNuevo. audi_horasAnterior. audi_fechaModificacion. audi_codCurso.2. audi_horasNuevo. now().`curso_BEFORE_UPDATE` BEFORE UPDATE ON `curso` FOR EACH ROW BEGIN insert into auditoria_curso(audi_nombreAnterior. audi_usuario.curso_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`.cod_curso.horas_cur. Probamos el disparador: update curso set nom_curs= 'Procedimientos almacenados MySQL' where cod_curso = 172943. END$$ DELIMITER . 6. audi_valorAnterior.PRIMARY KEY (`idaudi`)). new. audi_accion) values( old. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql. new. audi_nombreNuevo.horas_cur.2 Eliminar registros curso USE `laboratoriosql`. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql. new.

audi_fechaModificacion.nom_curs.horas_cur. audi_codCurso. 'Registro eliminado'). old. new. DELIMITER $$ . `audi_accion` VARCHAR(45) NULL. END$$ DELIMITER .cod_curso. 6.cod_curso. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql.nom_curs. audi_usuario. `audi_fechaModificacion` DATETIME NULL DEFAULT CURRENT_TIMESTAMP. `audi_apeNuevo` VARCHAR(30) NULL. `audi_edadAnterior` INT NULL. audi_horasAnterior. now().valor_cur.curso_AFTER_DELETE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. audi_accion) values( old. audi_valorAnterior. `audi_nomNuevo` VARCHAR(30) NULL. audi_fechaModificacion.`curso_AFTER_DELETE` AFTER DELETE ON `curso` FOR EACH ROW BEGIN insert into auditoria_curso(audi_nombreAnterior. USE `laboratoriosql`. audi_usuario. 'Actualización'). now(). old. old. `audi_usuario` VARCHAR(45) NULL DEFAULT 'CURRENT_USER()'. `audi_docest` VARCHAR(20) NULL. PRIMARY KEY (`idaudi`)). current_user().valor_cur.valor_cur.3 Disparadores para estudiante Creamos la tabla para la auditoría: CREATE TABLE `laboratoriosql`. old.1 Disparador para actualizaciones de registros USE `laboratoriosql`. `audi_apeAnterior` VARCHAR(30) NULL.horas_cur. `audi_nomAnterior` VARCHAR(30) NULL. new. old. `audi_edadNuevo` INT NULL. END$$ DELIMITER .`auditoria_estudiantes` ( `idaudi` INT NOT NULL AUTO_INCREMENT. 6.3. current_user().nom_curs.horas_cur. new. audi_accion) values(old. audi_codCurso. new.

2 Disparador para eliminación de registros USE `laboratoriosql`.ape_est. now(). audi_fechaModificacion.4.doc_est. audi_apeAnterior. audi_apeAnterior. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql.`automotores_BEFORE_UPDATE` BEFORE UPDATE ON `automotores` FOR EACH ROW BEGIN . new. END$$ DELIMITER .nom_est.automotores_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. audi_docest. old.4 Disparadores para automotores 6.ape_est. audi_edadAnterior. now(). 6.`estudiante_AFTER_DELETE` AFTER DELETE ON `estudiante` FOR EACH ROW BEGIN insert into auditoria_estudiante(audi_nomAnterior.ape_est.nom_est. new. END$$ DELIMITER .edad_est. old.1 Disparador de actualización USE `laboratoriosql`.`estudiante_BEFORE_UPDATE` BEFORE UPDATE ON `estudiante` FOR EACH ROW BEGIN insert into auditoria_estudiantes(audi_nomAnterior. old. 'Actualización'). audi_edadNuevo. audi_edadAnterior. audi_usuario. old.DROP TRIGGER IF EXISTS laboratoriosql. old.edad_est. current_user(). 6. 'Registro eliminado'). audi_apeNuevo.nom_est. audi_accion) values(old. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql. audi_nomNuevo.edad_est. audi_docest. audi_fechaModificacion.estudiante_AFTER_DELETE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. audi_usuario. old.estudiante_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. new. audi_accion) values(old.doc_est. current_user().3.

automodelo. audi_numNuevo. `audi_aseFinNuevo` DATE NULL.autotipo. now(). 'Actualización'). END$$ DELIMITER . END$$ DELIMITER . `audi_placaAnterior` VARCHAR(6) NULL. audi_modeloAnterior. audi_numAnterior. current_user().automodelo.autocilindraje.autonumpasajeros.autocilindraje. now().autonumpasajeros. current_user(). audi_placa.autonumchasis. `audi_aseIniNuevo` DATE NOT NULL. old. audi_tipoAnterior.automarca. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql. audi_cilinNuevo. `audi_costoAnterior` INT NULL. audi_tipoNuevo.2 Disparador eliminación registros DELIMITER . old. 6. 'Registro eliminado').5 Disparadores para aseguramientos en MySQL CREATE TABLE `laboratoriosql`. `audi_aseFinAnterior` DATE NULL. audi_cilinAnterior.automotores_AFTER_DELETE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`.automarca. `audi_valorNuevo` INT NULL. audi_cilinAnterior. old. new. audi_accion) values(old. `audi_valorAseAnterior` INT NULL. audi_fechaModificacion.autoplaca. audi_tipoAnterior.autonumpasajeros. old.autotipo. old. audi_numAnterior. audi_chasisNuevo.autocilindraje.automarca. old. . old. audi_marcaNuevo.autonumchasis. old.`auditoria_aseguramientos` ( `audi_aseIniAnterior` DATE NOT NULL.insert into auditoria_automotores(audi_marcaAnterior. USE `laboratoriosql`. old. new.4.automodelo.`automotores_AFTER_DELETE` AFTER DELETE ON `automotores` FOR EACH ROW BEGIN insert into auditoria_automotores(audi_marcaAnterior. 6. new. new. audi_chasisAnterior. audi_placa. old. old.autonumchasis. audi_fechaModificacion. old. audi_chasisAnterior. audi_accion) values(old. audi_usuario. new. `audi_estadoAnterior` VARCHAR(11) NULL.autoplaca. new.autotipo. audi_modeloNuevo. audi_usuario. audi_modeloAnterior.

aseestado.asefechainicio.aseplaca. audi_estadoNuevo. current_user(). audi_costoAnterior. audi_aseFinAnterior. audi_aseIniNuevo.asecodigo.5.`audi_estadoNuevo` VARCHAR(11) NULL. new. new. audi_placaAnterior. old. audi_placaAnterior. audi_aseFinAnterior. old.aseplaca. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql. audi_accion) values(old.aseguramientos_AFTER_DELETE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql.asefechaexpiracion.1 Trigger para actualización USE `laboratoriosql`. new.aseestado. now(). audi_estadoAnterior. audi_valorNuevo. old.asevalorasegurado. new. audi_aseFinNuevo.asecosto. `audi_costoNuevo` INT NULL. `audi_placaNuevo` VARCHAR(6) NULL. audi_valorAseAnterior.2 Trigger para eliminación USE `laboratoriosql`. `audi_accion` VARCHAR(45) NULL. audi_asecodigo. END$$ DELIMITER . old. `audi_fechaModificacion` DATETIME NULL. `audi_usuario` VARCHAR(45) NULL DEFAULT 'current_user()'. audi_fechaModificacion.aseguramientos_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`.asefechaexpiracion.5.`aseguramientos_AFTER_DELETE` AFTER DELETE ON `aseguramientos` FOR EACH ROW BEGIN insert into auditoria_aseguramientos(audi_aseIniAnterior. 6. . PRIMARY KEY (`audi_aseIniAnterior`)). 6. old. `audi_asecodigo` INT NULL. audi_placaNuevo.asecosto.`aseguramientos_BEFORE_UPDATE` BEFORE UPDATE ON `aseguramientos` FOR EACH ROW BEGIN insert into auditoria_aseguramientos(audi_aseIniAnterior. new. audi_usuario. 'Actualización'). audi_valorAseAnterior. audi_estadoAnterior.asevalorasegurado. old. new. audi_costoNuevo.asefechainicio.

`audi_placaAnterior` VARCHAR(6) NOT NULL. audi_lugarAnterior. audi_accion) . `audi_fechaModificacion` DATETIME NULL. `audi_involucradosAnterior` INT(11) NULL DEFAULT NULL.asecodigo. old.audi_costoAnterior. 6. `audi_fatalidadesAnterior` INT(11) NULL DEFAULT NULL. audi_accion) values(old. `audi_fatalidadesNuevo` INT(11) NULL DEFAULT NULL. `audi_incicodigo` INT NULL. old. current_user(). now().incidentes_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. `audi_fechaNuevo` DATE NOT NULL.asefechaexpiracion. audi_heridosNuevo. `audi_fechaAnterior` DATE NOT NULL. old.aseplaca.asevalorasegurado.aseestado. 'Eliminación registro').6 Disparadores para la tabla incidentes CREATE TABLE `laboratoriosql`. PRIMARY KEY (`idaudi`)). audi_usuario.1 Actualización USE `laboratoriosql`. audi_lugarNuevo.`incidentes_BEFORE_UPDATE` BEFORE UPDATE ON `incidentes` FOR EACH ROW BEGIN insert into auditoria_incidentes(audi_fechaAnterior. audi_fechaModificacion.asecosto. `audi_heridosAnterior` INT(11) NULL. old. audi_usuario. audi_fechaModificacion. audi_involucradosNuevo.asefechainicio. audi_placaNuevo.6. audi_fechaNuevo. audi_fatalidadesNuevo. audi_involucradosAnterior. `audi_lugarAnterior` VARCHAR(40) NOT NULL. audi_heridosAnterior.`auditoria_incidentes` ( `idaudi` INT NOT NULL AUTO_INCREMENT. `audi_involucradosNuevo` INT(11) NULL DEFAULT NULL. audi_fatalidadesAnterior. `audi_accion` VARCHAR(45) NULL. audi_incicodigo. audi_asecodigo. old. 6. END$$ DELIMITER . `audi_usuario` VARCHAR(45) NULL. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql. old. audi_placaAnterior. `audi_lugarNuevo` VARCHAR(40) NOT NULL. `audi_heridosNuevo` INT(11) NULL. `audi_placaNuevo` VARCHAR(6) NOT NULL.

'Actualización'). current_user(). DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql.values(old. new. 6.inciplaca. old.incifecha. incicodigo. new.incicanautosinvolucrados. audi_involucradosAnterior.incicanautosinvolucrados. new.incicantheridos. new. audi_heridosAnterior. END$$ DELIMITER . audi_accion) values(old. .incilugar. audi_incicodigo. old. new. END$$ DELIMITER .incifecha. audi_usuario. audi_placaAnterior.incicantfatalidades. audi_lugarAnterior.incicantheridos. old.incilugar. 'Registro eliminado').2 Eliminación de registros USE `laboratoriosql`. old. old.incicantheridos. old.`incidentes_AFTER_DELETE` AFTER DELETE ON `incidentes` FOR EACH ROW BEGIN insert into auditoria_incidentes(audi_fechaAnterior. now(). old. now().inciplaca. new.incicanautosinvolucrados. old.incicantfatalidades. old. incicodigo.incilugar.incifecha. current_user().inciplaca. audi_fatalidadesAnterior. old.incicantfatalidades. audi_fechaModificacion.6.incidentes_AFTER_DELETE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`.

:new.id_art.tit_art. :new. sysdate.7 Disparador de actualización con Oracle (Tabla artículo) Primero creamos la tabla auditoria_articulos: 6. :new. FECHAMODIFICACION. :old. PRECARTNUEVO. IDART. PRECARTANTERIOR. ACCION) values(:old. EDIARTANTERIOR. .tit_art. :new.7.edi_art. :old. :old.1 Actualización create or replace trigger "ACTUALIZAR_ARTICULO" BEFORE update on "ARTICULO" for each row begin insert into auditoria_articulo(TITARTANTERIOR. AUTARTANTERIOR.aut_art. AUTARTNUEVO.edi_art. :old. EDIARTNUEVO.aut_art. TITARTNUEVO.6. Al editar un registro de la tabla artículo se crea el registro correspondiente en la tabla de auditoría. user.prec_art.prec_art. USUARIO. 'Actualización'). end.

DIR_CLI. "APECLINUE" VARCHAR2(30). :new. user. :old. "MESNUE" VARCHAR2(10). "MESANT" VARCHAR2(10). "FECHAMOD" DATE. :old.DIR_CLI. :old. DIRCLINUE. FECHAMODIFICACION. APECLIANT. MESANT. MESNUE.APE_CLI. :new. :old. sysdate. 6. "DIRCLINUE" VARCHAR2(100). ACCION) values(:old.prec_art.1 Actualizar create or replace trigger "ACTUALIZAR_CLIENTE" BEFORE update on "CLIENTE" for each row begin insert into auditoria_cliente(NOMCLIANT. DIRCLIANT. "NOMCLINUE" VARCHAR2(30).7. end. USUARIO. APECLINUE. DEPCLINUE. AUTARTANTERIOR.DEP_CLI. NOMCLINUE. EDIARTANTERIOR.NOM_CLI.8 Disparadores para la tabla cliente CREATE TABLE "AUDITORIA_CLIENTE" ( "NOMCLIANT" VARCHAR2(30). IDCLI.FECHAMOD.tit_art. :new.DEP_CLI. "IDCLI" VARCHAR2(20). "APECLIANT" VARCHAR2(30).MES_CUM_CLI.id_art. user. :new. :old. DEPCLIANT. 'Eliminación de registro'). "DEPCLINUE" VARCHAR2(20). :old. "DEPCLIANT" VARCHAR2(20). "ACCION" VARCHAR2(45) ) . :old. end.ID_CLI. "DIRCLIANT" VARCHAR2(100).aut_art.2 Eliminar registros create or replace trigger "ELIMINAR_ARTICULO" AFTER delete on "ARTICULO" for each row begin insert into auditoria_articulo(TITARTANTERIOR.APE_CLI. IDART.MES_CUM_CLI. :old. "USUARIO" VARCHAR2(45). 6. 'Actualizacion'). :new. PRECARTANTERIOR.6. ACCION) values(:old.edi_art. USUARIO. :old. sysdate.8. .NOM_CLI.

VAL_PED.9 Disparadores para la tabla pedido CREATE TABLE "AUDITORIA_PEDIDO" ( "IDCLIPEDA" VARCHAR2(20).MES_CUM_CLI.ID_CLI_PED. "VALPEDA" NUMBER. DIRCLIANT.FECHAMOD. USUARIO. MESANT. ACCION) VALUES(:OLD. 6. "USUARIO" VARCHAR2(45). end. SYSDATE.APE_CLI. USUARIO.FEC_PED. ACCION) values(:old. IDCLIPEDN. :NEW. :NEW.6. "IDPED" NUMBER.VAL_PED.FEC_PED. IDCLI. .:NEW. "FECPEDA" DATE.NOM_CLI. user. 'Actualizacion'). VALPEDN. "FECPEDN" DATE. "VALPEDN" NUMBER.DIR_CLI. 'Actualización').ID_PED. FECPEDN. "ACCION" VARCHAR2(45) ). :OLD. :old.8.1 Actualizar create or replace trigger "ACTUALIZAR_PEDIDO" BEFORE update on "PEDIDO" for each row begin INSERT INTO AUDITORIA_PEDIDO(IDCLIPEDA. DEPCLIANT. :old.DEP_CLI.:OLD.2 Eliminar registros create or replace trigger "ELIMINAR_CLIENTE" AFTER delete on "CLIENTE" for each row begin insert into auditoria_cliente(NOMCLIANT.9. :old. :OLD. :old. USER. "FECMOD" DATE. :old. sysdate. "IDCLIPEDN" VARCHAR2(20). end. IDPED. FECPEDA.ID_CLI. APECLIANT.ID_CLI_PED. 6. VALPEDA. FECMOD.

:OLD. :OLD. ACCION) VALUES(:OLD. FECMOD.FEC_PED.2 Eliminar registros create or replace trigger "ELIMINAR_PEDIDO" AFTER delete on "PEDIDO" for each row begin INSERT INTO AUDITORIA_PEDIDO(IDCLIPEDA. 'ELiminación registro').ID_CLI_PED.ID_PED.6.9. USER.VAL_PED. IDPED. :OLD. USUARIO. . SYSDATE. VALPEDA. FECPEDA. end.

com www.com www.techonthenet.Referencias Las bases de datos fueron creadas con las herramientas MySQL Workbench y la interfaz web de Oracle.mysqlconclase. .com El resto de la información pertenece a los objetos de aprendizaje del Sena.com www.desarrolloweb.com www.stackoverflow.elbauldelprogramador.com www.oracleya. Se utilizó información de las páginas: www.