Laboratorio 13Presentado 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 | +-----------------+--------------+------------------+----------+ 098.678 | Carlos | 2011-01-02 | | 250067 | 63.720 | María | 2011-01-03 | | 289011 | 1.502.4 Tabla estudiantexcurso mysql> select cod_curso. nom_est.097 | Jonatan | 2011-01-02 | | 345671 | 63.1.098.502.720 | María | 2011-01-04 | | 172943 | 72240535 | Jhon | 2014-02-06 | +------------+------------------+----------+------------------+ .765. doc_est.098. fec_ini_estcur -> from curso join estudiante join estudiantexcurso -> on doc_est = doc_est_estcur and cod_curso = cod_curso_estcur. +------------+-----------------+-----------+-----------------+ | cod_curso | doc_est | nom_est | fec_ini_estcur | +------------+-----------------+-----------+-----------------+ | 289011 | 1. 1. . artículo y pedido la realizaremos usando la interfaz web de Oracle.5 Tabla artículo: Las tablas cliente. Ejecutamos en terminal el procedure: SQL> execute ins_articulo('laboratorio 13'. PL/SQL procedure successfully completed. 'Jhon Barcasnegras'. . 'AlphaomegaRama'. 22000). 1.6 Tabla cliente . La ejecución del procedimiento desde una IDE es algo distinta. no se puede usar execute: . 7 Tabla pedido .1. . 1.8 Tabla compañía . 9 Tabla tiposautomotores . +----------------+-------------------------+---------------+-----------------------------+ | 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. mysql> select *from tiposautomotores.10 Tabla automotores .----+----------------+ | autotipo | autnombre | +-----------+----------------+ | 1 | Automóviles | | 2 | Camperos | | 3 | Camiones | | 4 | Autobuses | +----------+-----------------+ 4 rows in set (0.00 sec) 1. +------. mysql> select *from automotores. +-----------+-----------------+----------+------------+------------------+---------------+-------------------+ | 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 | +-----------+-----------------+----------+------------+------------------+---------------+-------------------+ . '2014-08-12'. +-----------+----------------+--------------------+-------------------+-----------+---------+----------+ | 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 .1. 1200000). 'Vigente'.11 Tabla aseguramientos Llamamos al procedimiento: call ins_asegura('2013-08-12'. comprobamos que se inserten los datos correctamente. 'FDT650'. mysql> select *from aseguramientos. 60000000. | 800000 | | 4 | 2013-08-12 | 2014-08-12 | 60000000 | Vigente | FDT650 | 1200000 | +-----------+----------------+--------------------+-------------------+----------+------------------+----------+ 1. 'FDT650'. 1. 0. mysql> select *from incidentes. 'Barranquilla'. +------------+---------------+-----------+--------------+-----------------+--------------------+--------------------------+ | incicodigo | incifecha | inciplaca | incilugar | incicantheridos | incicantfatalidades | incicanautosinvolucrados | +------------+---------------+-----------+--------------+-----------------+--------------------- . 2).12 Tabla incidentes call ins_incidente('2013-09-15'. sino que al investigar veo que debo crear un cursor.+--------------------------+ | 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.1 Proceso ordenar salarios: Este ejercicio solicita presentar los salarios de los profesores organizados por categorías. El código del cursor en el procedimiento sería así: . Oracle no me permite crear un procedimiento que simplemente lleve el select en su interior. Ejecutamos el procedimiento y obtenemos el resultado en pantalla: . 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.2. 2. . can_art_artped.val_ven_art_artped).4 Mostrar todos los pedidos: create or replace procedure "LISTA_PEDIDOS" is cursor curs is select tit_art.automarca). automarca from automotores join aseguramientos on autoplaca = aseplaca and asefechaexpiracion = '09-30-2013'. 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. begin for resultado in curs loop dbms_output. end loop.asefechaexpiracion ||' Marca: '|| resultado. val_ven_art_artped from articuloxpedido join articulo on id_art = id_art_artped. end.can_art_artped ||' Valor: '|| resultado.put_line ('Placa: '|| resultado. begin for resultado in curs loop dbms_output.autoplaca ||' Expiración: '|| resultado.put_line ('Artículo: '|| resultado. create or replace procedure "vsept2013" is cursor curs is select autoplaca.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). asefechaexpiracion.tit_art ||' Cantidad: '|| resultado. 2. 3. +-----------+-------------------------------------+-----------+-----------+ | 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 | . 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. END$$ DELIMITER . DROP procedure IF EXISTS `mostrar_cursos`. Muestra el resultado: Placa: FLL420 Expiración: 09/30/2013 Marca: Chevrolet corsa Statement processed. Mysql> call mostrar_cursos. USE `laboratoriosql`. Llamamos el procedimiento y obtenemos los datos que queremos. end. DELIMITER $$ USE `laboratoriosql`$$ CREATE PROCEDURE mostrar_cursos () BEGIN select *from curso order by valor_cur.end loop.1 Proceso mostrar cursos Vamos a mostrar todos los cursos ordenados por valor. DELIMITER $$ USE `laboratoriosql`$$ CREATE PROCEDURE mostrar_pedidos () BEGIN select id_pedido.2 Mostrar pedidos USE `laboratoriosql`.| 250067 | Fundamentos de SQL | 20 | 700000 | | 345671 | Fundamentos de Oracle | 60 | 3000000 | 3. END$$ DELIMITER . can_art_artped. DROP procedure IF EXISTS `mostrar_pedidos`. val_ven_art_artped from pedido join articulo join articuloxpedido on id_pedido = id_ped_artped and id_art_artped = id_art. tit_art. id_art. +-----------+--------+----------------------------------------+---------------+--------------------+ | 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 | | +-----------+--------+----------------------------------------+---------------+--------------------+ . Llamamos el proceso y obtenemos los valores: mysql> call mostrar_pedidos. Llamamos el procedimiento: mysql> call mostrar_empresas.3 Empresas fundadas entre 1991 y 1998 USE `laboratoriosql`. DELIMITER $$ USE `laboratoriosql`$$ CREATE PROCEDURE clientesxapellido () BEGIN select *from cliente order by ape_cli desc. DELIMITER $$ USE `laboratoriosql`$$ CREATE PROCEDURE mostrar_empresas() BEGIN select *from compañia where comañofun >= 1991 and comañofun <= 1998. END$$ DELIMITER . DROP procedure IF EXISTS `clientesxapellido`.3. .4 Clientes ordenados por apellidos: USE `laboratoriosql`. DROP procedure IF EXISTS `mostrar_empresas`. +----------------+----------------------+---------------+------------------------+ | comnit | comnombre | comañofun | comreplegal | +----------------+-----------------------+---------------+------------------------+ | 800890890-2 | Seguros Atlantida | 1998 | Carlos López | | 899999999-1 | Aseguradora Rojas | 1991 | Luis Fernando Rojas | +----------------+------------------------+--------------+--------------------------+ 3. END$$ DELIMITER . DROP procedure IF EXISTS `incifll420`. aseestado. END$$ DELIMITER .Llamamos el procedure: 3. DELIMITER $$ USE `laboratoriosql`$$ CREATE PROCEDURE incidentes1herido () BEGIN select incifecha. asevalorasegurado from incidentes join aseguramientos on inciplaca = aseplaca and incicantheridos = 1. Llamamos el proceso: 3. DROP procedure IF EXISTS `incidentes1herido`. aseestado.6 Incidentes del vehículo FLL420 USE `laboratoriosql`. asefechainicio. asefechaexpiracion. asefechainicio. DELIMITER $$ USE `laboratoriosql`$$ CREATE PROCEDURE incifll420 () BEGIN select incifecha. inciplaca.5 Incidentes con un herido USE `laboratoriosql`. asevalorasegurado from incidentes join aseguramientos . inciplaca. +------------+ | contar22() | +------------+ | 3 | +------------+ . DELIMITER $$ USE `laboratoriosql`$$ CREATE FUNCTION contar22 () RETURNS INTEGER BEGIN DECLARE cantidad int. Funciones 4. select count(*) into cantidad from estudiante where edad_est > 22.1 Contar estudiantes mayores de 22 USE `laboratoriosql`.on inciplaca = aseplaca and inciplaca = 'FLL420'. Llamamos la función y visualizamos el resultado: mysql> select contar22(). END$$ DELIMITER . END$$ DELIMITER . RETURN cantidad. DROP function IF EXISTS `contar22`. Llamamos el procedimiento: 4. DROP function IF EXISTS `masJoven`. así: mysql> select nom_est.$$ DELIMITER . DELIMITER $$ USE `laboratoriosql`$$ CREATE FUNCTION masJoven () RETURNS int BEGIN DECLARE masJoven int. Y luego la he combinado con un select. RETURN var_promedio. DROP function IF EXISTS `promediocursos`. select avg(valor_cur) into var_promedio from curso where horas_cur > 40. edad_est from estudiante where edad_est = masJoven(). RETURN masJoven.3 Valor promedio de los cursos con más de 40 horas USE `laboratoriosql`. DELIMITER $$ USE `laboratoriosql`$$ CREATE FUNCTION promediocursos () RETURNS INTEGER BEGIN declare var_promedio int. SELECT edad_est into masJoven from estudiante order by edad_est asc limit 1. END.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`. END$$ . +---------+------------+ | nom_est | edad_est | +---------+------------+ | Jonatan | 17 | +---------+------------+ 4.4. RETURN avgsueldo. Probamos la función: 4.4 Sueldo promedio de profesores categoría 1 USE `laboratoriosql`. DROP function IF EXISTS `promediosueldo`. END$$ DELIMITER . DELIMITER $$ USE `laboratoriosql`$$ CREATE FUNCTION promediosueldo () RETURNS INTEGER BEGIN DECLARE avgsueldo int. +---------------------+ | promediosueldo() | +---------------------+ | 550000 | +---------------------+ 1 row in set (0.DELIMITER .00 sec) . SELECT AVG(sal_prof) INTO avgsueldo FROM profesor WHERE cate_prof = 1. Probamos la función con select: mysql> select promediosueldo(). 4.5 Nombre del profesor con el menor sueldo USE `laboratoriosql`. RETURN nombre. +-----------------+ | menorsueldo() | +-----------------+ | Maritza | +-----------------+ 1 row in set (0. END$$ DELIMITER . SELECT nom_profesor INTO nombre FROM profesor ORDER BY sal_prof ASC LIMIT 1. DELIMITER $$ USE `laboratoriosql`$$ CREATE FUNCTION menorSueldo () RETURNS VARCHAR(30) BEGIN DECLARE nombre VARCHAR(30).00 sec) . mysql> select menorsueldo(). DROP function IF EXISTS `menorSueldo`. END. 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).5 Funciones con Oracle 5.1 Nombre. 5. 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. RETURN var_datos.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: . Para conseguir el valor más alto realice una subconsulta. utilice una concatenación. fecha y valor del pedido más costoso Para resolver esta función ya que hay que devolver varios valores en una variable. 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). END. 5.put_line (valores. RETURN var_datos. Y nos regresa los valores que buscamos: Alphaomega-Rama 4 Alphaomega-rama 1 Oveja negra 1 Statement processed. end loop. begin for valores in curs loop dbms_output. end. Probamos el funcionamiento ejecutándolo en la interfaz web: begin pa_editoriales. end.create or replace procedure "PA_EDITORIALES" is cursor curs is select edi_art ||' '||count(*) edi_art from articulo group by edi_art.edi_art). . 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). 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). END. Probamos la función y obtenemos: .5. 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). 5 Datos de la póliza de mayor valor create or replace FUNCTION fn_autopolizamasval RETURN VARCHAR2 IS var_datos VARCHAR2(700).5. END. 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). . RETURN var_datos. 1.1 Disparador para profesor en MySQL 6. Para esto último se utiliza la función current_user() que ya viene definida en MySQL. 6. 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.6. Esta acción puede ser Update.1 Actualizar Creamos una tabla para auditoria llamada “auditoria_profesor” la cual incluirá los viejos y nuevos valores de las columnas afectadas. Pueden ejecutarse antes (Before) o después (After). 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: . insert y delete. audi_apellidoNuevo. audi_salarioNuevo. audi_fechaModificacion.nom_profesor. update profesor set sal_prof = 1100000 where doc_profesor = '73542983'.ape_profesor.cate_prof. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql.ape_profesor. new. current_user(). new. old.sal_prof. .profesor_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`.doc_profesor. new.sal_prof.La aplicación genera el código adecuado: USE `laboratoriosql`. END$$ DELIMITER . audi_nombreNuevo. audi_apellidoAnterior. audi_categoriaNuevo.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. audi_accion) values (old. now(). old.nom_profesor. update profesor set cate_prof = 4 where doc_profesor = '73542983'. audi_categoriaAnterior. 'Actualización'). old. new.`profesor_BEFORE_UPDATE` BEFORE UPDATE ON `profesor` FOR EACH ROW BEGIN insert into auditoria_profesor(audi_nombreAnterior. audi_usuario. audi_salarioAnterior. new. audi_docProfesor. . audi_usuario. audi_categoriaAnterior.2 Eliminando registros Vamos a borrar un registro en la tabla profesor con el nuevo usuario. audi_salarioAnterior. now(). old.sal_prof. Cerrando mi conexión y regresando con mi nuevo usuario y contraseña.ape_profesor. Pero primero vamos a crear un trigger para ese evento: USE `laboratoriosql`.nom_profesor. audi_fechaModificacion.doc_profesor.`profesor_AFTER_DELETE` AFTER DELETE ON `profesor` FOR EACH ROW BEGIN INSERT INTO auditoria_profesor(audi_nombreAnterior. old. audi_accion) VALUES(old. he creado un usuario nuevo: CREATE USER 'jhonBarc'@'localhost' IDENTIFIED BY 'jhon12345'. * TO 'jhonBarc'@'localhost'. audi_docProfesor.profesor_AFTER_DELETE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql. old. current_user(). 6. old. 'Registro eliminado'). END$$ DELIMITER . Y luego refrescamos los privilegios: Ahora voy a usar ese nuevo usuario para los ejercicios. audi_apellidoAnterior.cate_prof. le he dado privilegios de acceso: GRANT ALL PRIVILEGES ON * . Ahora la función current_user() devuelve el valor [email protected] 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. 2. `audi_fechaModificacion` DATE NULL. `audi_nombreAnterior` VARCHAR(100) NULL. `audi_horasNuevo` INT NULL. `audi_usuario` VARCHAR(45) NULL DEFAULT 'current_user()'. `audi_horasAnterior` INT NULL. .1 Actualizar Curso CREATE TABLE `laboratoriosql`. `audi_nombreNuevo` VARCHAR(100) NULL. `audi_codCurso` INT NULL. `audi_valorAnterior` INT NULL.`auditoria_curso` ( `idaudi` INT NOT NULL AUTO_INCREMENT.Eliminamos el registro: delete from profesor where doc_profesor = 'Rafael'. `audi_accion` VARCHAR(45) 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_valorNuevo` INT NULL.2 Disparador para la tabla curso en MySQL 6. audi_horasAnterior.`curso_BEFORE_UPDATE` BEFORE UPDATE ON `curso` FOR EACH ROW BEGIN insert into auditoria_curso(audi_nombreAnterior. audi_accion) values( old. new. new.nom_curs. USE `laboratoriosql`. audi_nombreNuevo. old.cod_curso.nom_curs.valor_cur. END$$ DELIMITER . . audi_usuario. audi_valorAnterior. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql. Probamos el disparador: update curso set nom_curs= 'Procedimientos almacenados MySQL' where cod_curso = 172943. audi_fechaModificacion. now(). audi_horasAnterior.curso_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. audi_nombreNuevo.PRIMARY KEY (`idaudi`)). audi_codCurso.valor_cur.`curso_BEFORE_UPDATE` BEFORE UPDATE ON `curso` FOR EACH ROW BEGIN insert into auditoria_curso(audi_nombreAnterior. audi_valorNuevo. audi_horasNuevo.2 Eliminar registros curso USE `laboratoriosql`. audi_valorAnterior. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql.curso_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. current_user(). new. 6. old.horas_cur. audi_horasNuevo.horas_cur.2. new. 'Actualización'). audi_valorNuevo. 6.3 Disparadores para estudiante Creamos la tabla para la auditoría: CREATE TABLE `laboratoriosql`.curso_AFTER_DELETE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. now(). old. new. `audi_docest` VARCHAR(20) NULL. old. DELIMITER $$ . audi_fechaModificacion. `audi_fechaModificacion` DATETIME NULL DEFAULT CURRENT_TIMESTAMP.valor_cur. now(). old.`auditoria_estudiantes` ( `idaudi` INT NOT NULL AUTO_INCREMENT. old. `audi_accion` VARCHAR(45) NULL. current_user().horas_cur. new. 'Registro eliminado'). `audi_apeNuevo` VARCHAR(30) NULL.1 Disparador para actualizaciones de registros USE `laboratoriosql`. new. current_user().valor_cur. audi_codCurso. USE `laboratoriosql`. audi_codCurso. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql.nom_curs.cod_curso. END$$ DELIMITER . 6. audi_valorAnterior.audi_fechaModificacion. audi_accion) values( old.cod_curso. `audi_nomAnterior` VARCHAR(30) NULL. `audi_edadNuevo` INT NULL.horas_cur. PRIMARY KEY (`idaudi`)). END$$ DELIMITER . `audi_nomNuevo` VARCHAR(30) NULL.nom_curs.horas_cur. `audi_apeAnterior` VARCHAR(30) NULL. audi_horasAnterior. `audi_edadAnterior` INT NULL. old. audi_usuario. audi_usuario.`curso_AFTER_DELETE` AFTER DELETE ON `curso` FOR EACH ROW BEGIN insert into auditoria_curso(audi_nombreAnterior.valor_cur.3. new.nom_curs. audi_accion) values(old. 'Actualización'). `audi_usuario` VARCHAR(45) NULL DEFAULT 'CURRENT_USER()'. audi_docest. audi_usuario.ape_est. audi_accion) values(old.`estudiante_AFTER_DELETE` AFTER DELETE ON `estudiante` FOR EACH ROW BEGIN insert into auditoria_estudiante(audi_nomAnterior.estudiante_AFTER_DELETE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`.`automotores_BEFORE_UPDATE` BEFORE UPDATE ON `automotores` FOR EACH ROW BEGIN . audi_usuario.DROP TRIGGER IF EXISTS laboratoriosql. audi_edadAnterior. 'Registro eliminado'). current_user().nom_est.doc_est. audi_docest.`estudiante_BEFORE_UPDATE` BEFORE UPDATE ON `estudiante` FOR EACH ROW BEGIN insert into auditoria_estudiantes(audi_nomAnterior. new.nom_est. audi_edadNuevo. current_user(). new.ape_est. new. END$$ DELIMITER . audi_apeNuevo. now(). audi_fechaModificacion. old. old. END$$ DELIMITER . audi_fechaModificacion.2 Disparador para eliminación de registros USE `laboratoriosql`.automotores_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`.4.nom_est. old. audi_nomNuevo.edad_est. audi_edadAnterior. 'Actualización').estudiante_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. 6.edad_est. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql. audi_apeAnterior. old. old.edad_est. 6. now(). DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql.4 Disparadores para automotores 6.3.doc_est. old.1 Disparador de actualización USE `laboratoriosql`.ape_est. audi_apeAnterior. audi_accion) values(old. autonumchasis.autotipo. old.autocilindraje. audi_modeloAnterior. audi_tipoAnterior. 'Registro eliminado'). old.autocilindraje. audi_placa. now(). old. audi_modeloAnterior. audi_numAnterior. audi_numNuevo. `audi_placaAnterior` VARCHAR(6) NULL. audi_accion) values(old.5 Disparadores para aseguramientos en MySQL CREATE TABLE `laboratoriosql`. audi_tipoNuevo. `audi_costoAnterior` INT NULL.automarca.automarca. old. `audi_estadoAnterior` VARCHAR(11) NULL. audi_fechaModificacion. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql.autoplaca. END$$ DELIMITER . audi_cilinNuevo. new.autonumpasajeros.automarca.4.autotipo. current_user().automodelo. old.autonumchasis.automodelo. `audi_aseFinNuevo` DATE NULL. USE `laboratoriosql`.`auditoria_aseguramientos` ( `audi_aseIniAnterior` DATE NOT NULL. `audi_aseFinAnterior` DATE NULL.automodelo.automotores_AFTER_DELETE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`.autotipo. old. audi_accion) values(old. now(). old. audi_cilinAnterior. audi_usuario.`automotores_AFTER_DELETE` AFTER DELETE ON `automotores` FOR EACH ROW BEGIN insert into auditoria_automotores(audi_marcaAnterior. old. `audi_aseIniNuevo` DATE NOT NULL. old. audi_chasisAnterior. 'Actualización').autoplaca. old. audi_modeloNuevo. `audi_valorNuevo` INT NULL. old. new. new. audi_placa. audi_chasisNuevo.insert into auditoria_automotores(audi_marcaAnterior.autonumchasis.autonumpasajeros. END$$ DELIMITER . current_user(). audi_tipoAnterior. old. audi_usuario. new. audi_numAnterior.2 Disparador eliminación registros DELIMITER .autocilindraje. audi_chasisAnterior. audi_fechaModificacion. . 6.autonumpasajeros. new. new. audi_cilinAnterior. `audi_valorAseAnterior` INT NULL. 6. audi_marcaNuevo. new. `audi_placaNuevo` VARCHAR(6) NULL. audi_aseFinNuevo. now(). audi_aseFinAnterior.asefechainicio.aseestado. audi_valorNuevo.aseplaca. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql. audi_placaAnterior. `audi_fechaModificacion` DATETIME NULL. audi_usuario. PRIMARY KEY (`audi_aseIniAnterior`)).`audi_estadoNuevo` VARCHAR(11) NULL. old. current_user(). `audi_usuario` VARCHAR(45) NULL DEFAULT 'current_user()'. old. audi_aseFinAnterior.aseestado.asecodigo. audi_estadoAnterior. old.`aseguramientos_BEFORE_UPDATE` BEFORE UPDATE ON `aseguramientos` FOR EACH ROW BEGIN insert into auditoria_aseguramientos(audi_aseIniAnterior. audi_valorAseAnterior. audi_placaAnterior. 'Actualización').asefechaexpiracion. 6. old. audi_estadoNuevo.aseguramientos_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. audi_costoNuevo.`aseguramientos_AFTER_DELETE` AFTER DELETE ON `aseguramientos` FOR EACH ROW BEGIN insert into auditoria_aseguramientos(audi_aseIniAnterior. `audi_accion` VARCHAR(45) NULL. `audi_asecodigo` INT NULL.2 Trigger para eliminación USE `laboratoriosql`. audi_fechaModificacion. old.5. 6. `audi_costoNuevo` INT NULL. audi_estadoAnterior. END$$ DELIMITER . new.asevalorasegurado. audi_costoAnterior. . audi_placaNuevo.asevalorasegurado.asecosto. new. new. new.aseguramientos_AFTER_DELETE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`.asefechainicio.1 Trigger para actualización USE `laboratoriosql`. new. audi_asecodigo.asecosto.5.aseplaca. old. audi_valorAseAnterior. audi_accion) values(old. audi_aseIniNuevo. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql.asefechaexpiracion. `audi_lugarAnterior` VARCHAR(40) NOT NULL. audi_fatalidadesNuevo. `audi_heridosAnterior` INT(11) NULL. `audi_fechaModificacion` DATETIME NULL. audi_fechaModificacion.incidentes_BEFORE_UPDATE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. audi_involucradosAnterior. PRIMARY KEY (`idaudi`)). now().6 Disparadores para la tabla incidentes CREATE TABLE `laboratoriosql`. `audi_fechaNuevo` DATE NOT NULL. END$$ DELIMITER . audi_fatalidadesAnterior. old. `audi_incicodigo` INT NULL.asefechaexpiracion. `audi_heridosNuevo` INT(11) NULL. old. audi_fechaModificacion.audi_costoAnterior.asecosto. audi_asecodigo. `audi_involucradosAnterior` INT(11) NULL DEFAULT NULL. audi_placaNuevo. `audi_lugarNuevo` VARCHAR(40) NOT NULL. `audi_usuario` VARCHAR(45) NULL. 6. `audi_accion` VARCHAR(45) NULL.asevalorasegurado. audi_incicodigo. `audi_fatalidadesNuevo` INT(11) NULL DEFAULT NULL. audi_lugarNuevo. audi_lugarAnterior. audi_fechaNuevo.1 Actualización USE `laboratoriosql`.aseestado.asecodigo. audi_heridosAnterior. audi_accion) values(old. audi_placaAnterior. audi_usuario. audi_usuario. audi_heridosNuevo.aseplaca. old. old. `audi_placaAnterior` VARCHAR(6) NOT NULL. audi_involucradosNuevo.6. `audi_involucradosNuevo` INT(11) NULL DEFAULT NULL. `audi_placaNuevo` VARCHAR(6) NOT NULL. `audi_fatalidadesAnterior` INT(11) NULL DEFAULT NULL. current_user().`incidentes_BEFORE_UPDATE` BEFORE UPDATE ON `incidentes` FOR EACH ROW BEGIN insert into auditoria_incidentes(audi_fechaAnterior. old. `audi_fechaAnterior` DATE NOT NULL. old.asefechainicio. audi_accion) . DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql.`auditoria_incidentes` ( `idaudi` INT NOT NULL AUTO_INCREMENT. 6. 'Eliminación registro'). 6. old. old.incicantfatalidades. incicodigo. old. 'Actualización'). incicodigo. now(). old. audi_incicodigo. old. audi_fatalidadesAnterior.inciplaca. audi_accion) values(old. audi_lugarAnterior. audi_fechaModificacion.incifecha. old.incilugar.inciplaca. current_user().incicanautosinvolucrados.incicantfatalidades. now().incicantfatalidades. new.incicantheridos.incilugar. audi_heridosAnterior. new. END$$ DELIMITER .values(old.`incidentes_AFTER_DELETE` AFTER DELETE ON `incidentes` FOR EACH ROW BEGIN insert into auditoria_incidentes(audi_fechaAnterior. 6.inciplaca.incilugar. old. old. audi_placaAnterior. END$$ DELIMITER .incicantheridos.incifecha.2 Eliminación de registros USE `laboratoriosql`.incicanautosinvolucrados. new. new. old. old. current_user(). new.incicanautosinvolucrados. audi_involucradosAnterior.incidentes_AFTER_DELETE$$ USE `laboratoriosql`$$ CREATE DEFINER = CURRENT_USER TRIGGER `laboratoriosql`. . audi_usuario. DELIMITER $$ DROP TRIGGER IF EXISTS laboratoriosql. new. 'Registro eliminado').incifecha.incicantheridos. id_art.edi_art. :new. :old.7 Disparador de actualización con Oracle (Tabla artículo) Primero creamos la tabla auditoria_articulos: 6.6. user. :old.tit_art. FECHAMODIFICACION. :old.tit_art. sysdate. 'Actualización').7. AUTARTNUEVO. Al editar un registro de la tabla artículo se crea el registro correspondiente en la tabla de auditoría. :new. :new.1 Actualización create or replace trigger "ACTUALIZAR_ARTICULO" BEFORE update on "ARTICULO" for each row begin insert into auditoria_articulo(TITARTANTERIOR. end. EDIARTNUEVO. :new. AUTARTANTERIOR. ACCION) values(:old.aut_art.prec_art.aut_art.edi_art.prec_art. :old. TITARTNUEVO. USUARIO. PRECARTNUEVO. . EDIARTANTERIOR. IDART. PRECARTANTERIOR. EDIARTANTERIOR.NOM_CLI.NOM_CLI. :old. MESNUE.ID_CLI. "DIRCLIANT" VARCHAR2(100). sysdate. :old. 6. ACCION) values(:old. FECHAMODIFICACION. :old. NOMCLINUE.edi_art. "DEPCLIANT" VARCHAR2(20). AUTARTANTERIOR.DIR_CLI.8. end. :old. 'Actualizacion').MES_CUM_CLI. :new. :old. :new. end. "ACCION" VARCHAR2(45) ) . :new. :new. DIRCLIANT. USUARIO. "MESANT" VARCHAR2(10).tit_art. :old.DIR_CLI.6. :old. :old. 'Eliminación de registro'). . DEPCLIANT. MESANT.8 Disparadores para la tabla cliente CREATE TABLE "AUDITORIA_CLIENTE" ( "NOMCLIANT" VARCHAR2(30). sysdate.1 Actualizar create or replace trigger "ACTUALIZAR_CLIENTE" BEFORE update on "CLIENTE" for each row begin insert into auditoria_cliente(NOMCLIANT.APE_CLI. "APECLIANT" VARCHAR2(30). "IDCLI" VARCHAR2(20). :new.MES_CUM_CLI.prec_art. USUARIO. 6. APECLIANT.FECHAMOD. ACCION) values(:old. DIRCLINUE.id_art.APE_CLI. IDART. user. PRECARTANTERIOR. "DIRCLINUE" VARCHAR2(100).2 Eliminar registros create or replace trigger "ELIMINAR_ARTICULO" AFTER delete on "ARTICULO" for each row begin insert into auditoria_articulo(TITARTANTERIOR.DEP_CLI. "NOMCLINUE" VARCHAR2(30). :old.7. user. DEPCLINUE. APECLINUE. IDCLI.DEP_CLI. "USUARIO" VARCHAR2(45). "FECHAMOD" DATE. "MESNUE" VARCHAR2(10). "DEPCLINUE" VARCHAR2(20).aut_art. "APECLINUE" VARCHAR2(30). NOM_CLI.9. ACCION) values(:old. "IDCLIPEDN" VARCHAR2(20). DEPCLIANT. user. USUARIO. :OLD. ACCION) VALUES(:OLD.ID_CLI. "FECPEDN" DATE.DIR_CLI. sysdate. 'Actualizacion'). FECPEDN. SYSDATE. 6.ID_CLI_PED. end.1 Actualizar create or replace trigger "ACTUALIZAR_PEDIDO" BEFORE update on "PEDIDO" for each row begin INSERT INTO AUDITORIA_PEDIDO(IDCLIPEDA. "IDPED" NUMBER.APE_CLI. VALPEDN. 6.8.VAL_PED. MESANT.:OLD. :old. :old. :old. IDPED. :old.ID_PED. . "VALPEDA" NUMBER.9 Disparadores para la tabla pedido CREATE TABLE "AUDITORIA_PEDIDO" ( "IDCLIPEDA" VARCHAR2(20).DEP_CLI. USUARIO. IDCLI. "VALPEDN" NUMBER. "FECMOD" DATE. "ACCION" VARCHAR2(45) ). :OLD.:NEW. FECPEDA. 'Actualización').FEC_PED.FEC_PED. :NEW.MES_CUM_CLI. FECMOD. :NEW.VAL_PED. USER. end.2 Eliminar registros create or replace trigger "ELIMINAR_CLIENTE" AFTER delete on "CLIENTE" for each row begin insert into auditoria_cliente(NOMCLIANT. "FECPEDA" DATE. DIRCLIANT.FECHAMOD. :old. APECLIANT. IDCLIPEDN. "USUARIO" VARCHAR2(45). VALPEDA.ID_CLI_PED.6. :OLD.ID_PED. FECPEDA. FECMOD. SYSDATE.9.FEC_PED. .2 Eliminar registros create or replace trigger "ELIMINAR_PEDIDO" AFTER delete on "PEDIDO" for each row begin INSERT INTO AUDITORIA_PEDIDO(IDCLIPEDA. ACCION) VALUES(:OLD.:OLD.ID_CLI_PED.6. 'ELiminación registro'). VALPEDA. :OLD.VAL_PED. USER. end. USUARIO. IDPED. techonthenet.stackoverflow.com www.com www.elbauldelprogramador. Se utilizó información de las páginas: www.desarrolloweb.com www.Referencias Las bases de datos fueron creadas con las herramientas MySQL Workbench y la interfaz web de Oracle.oracleya.com www.com El resto de la información pertenece a los objetos de aprendizaje del Sena.com www. .mysqlconclase.