Crear un Procedimiento en MySQL

La creacin de un procedimiento se inicia con las clausulas CREATE PROCEDURE. Luego

definimos un nombre y los parmetros que necesita para funcionar adecuadamente. Veamos
su sintaxis:
CREATE PROCEDURE nombre ([parmetro1,parmetro2,...])
[Atributos de la rutina]
BEGIN instrucciones
END

Un procedimiento puede tener uno o mas parmetros o tambin no tener ninguno. Puede
carecer de atributos o puede poseer varios. Y como ves, el cuerpo del procedimiento es un
bloque de instrucciones definido.

Parmetros de Entrada y Salida en un Procedimiento

Un parmetro es un dato necesario para el funcionamiento del procedimiento, ya que
contribuyen al correcto desarrollo de las instrucciones del bloque de instrucciones.
Los parmetros pueden ser de entrada (IN), salida (OUT) o entrada/salida (INOUT) y deben
tener definido un tipo. Un parmetro de entrada en un dato que debe ser introducido en la
llamada del procedimiento para definir alguna accin del bloque de instrucciones.
Un parmetro de salida es un espacio de memoria en el cual el procedimiento devolver
almacenado su resultado. Y un parmetro de entrada/salida contribuye tanto como a
ingresar informacin til como para almacenar los resultados del procedimiento. Por
defecto, si no indicas el tipo de parmetro MySQL asigna IN.
Para especificar el tipo de parmetro seguimos la siguiente sintaxis:
[{IN|OUT|INOUT} ] nombre TipoDeDato

Ejemplo de un Procedimiento con un parmetro IN

En el siguiente ejemplo desarrollemos un procedimiento para el siguiente requerimiento:
Imprima los nmeros del 1 hasta n, donde n esta dado por el usuario.
Usaremos un procedimiento para capturar el numero n del usuario. Incorporaremos una
variable contadora que comience en 1 y un WHILE para el incremento e impresin.
Veamos:
DELIMITER //

CREATE PROCEDURE numeros_1_hasta_n (IN n INT)

BEGIN
DECLARE contador INT DEFAULT 1;
WHILE contador<=n DO
SELECT contador;
SET contador = contador + 1 ;
END WHILE;
END//
DELIMITER ;

La sentencia DELIMITER cambia el carcter de terminacin ';' por cualquier otro carcter,
en este caso elegimos '//'. Se hace con el fin de que MySQL no termine el procedimiento
al encontrar el primer punto y coma. Al final restablecemos el valor original del caracter de
escape.

Como ejecuto un procedimiento ya almacenado?

Usaremos el comando CALL enseguida del nombre del procedimiento y si tiene parmetros,
entonces se ingresan sus parmetros. Ahora veamos como llamar al anterior procedimiento:
CALL numeros_1_hasta_n(5)

DELIMITER //
CREATE PROCEDURE insertar(id_cliente INT, nombre_cliente VARCHAR(100),
apellido_cliente VARCHAR(100))
COMMENT 'Procedimiento que inserta un cliente a la base de datos'
BEGIN
IF NOT EXISTS ( SELECT C.ID
FROM CLIENTE AS C
WHERE C.ID = id_cliente) THEN
INSERT INTO CLIENTE(ID, NOMBRE, APELLIDO)
VALUES ( id_cliente,nombre_cliente,apellido_cliente);
ELSE
SELECT 'Este cliente ya existe en la base de datos!';
END IF;
END//
DELIMITER ;

Crear Procedimientos Almacenados en SQL Server

Como crear un Procedimiento?

Con la sentencia CREATE PROCEDURE. Debemos especificar el nombre del
procedimiento, los parmetros que implementar, tambin podemos establecer si el
procedimiento es temporal local(solo lo ejecuta el usuario que lo cre) o temporal
global(lo ejecutan todos los usuarios). Veamos la sintaxis:

Sintaxis de un Procedimiento
CREATE [PROCEDURE|PROC] nombre_procedimiento [#|##] [(
parmetro1,parmetro2,... )]
[{FOR REPLICATION|WITH RECOMPILE}][WITH ENCRYPTION]
AS<bloque de sentencias>

Fjate en el detalle de cada parte de la sintaxis:

CREATE [PROCEDURE|PROC]: Con esta sentencia indicamos que queremos crear un
procedimiento. Podemos usar CREATE PROC o CREATE PROCEDURE, las dos son
equivalentes.
nombre_procedimiento: Es el nombre que le pondremos a nuestro procedimiento. Es
recomendable ponerle un nombre alusivo a la accin del procedimiento.
[#|##]: El signo nmero individual indica que el procedimiento ser temporal local. Los dos
smbolos numero indica que ser temporal global.
[( parmetro1,parmetro2, )]:Se refiere a los parmetros del procedimiento. Si el
procedimiento tienen parmetros deben encerrarse en parntesis y declararlos con la
siguiente definicin:
@nombre_parametro TIPO [VARYING] [= valor_por_defecto][OUTPUT]
donde VARYING especifica que un parmetro de tipo CURSOR ser de salida y OUTPUT
para indicar que un parmetro ser de salida.
FOR REPLICATION: Se usa para especificar que el procedimiento ser para replicacin.
WITH RECOMPILE: Indica que el procedimiento se va a compilar cada vez que se
ejecuta. Normalmente un procedimiento se guarda compilado en cache para no tener que
compilar de nuevo.
WITH ENCRYPTION:Encripta el las instrucciones del procedimiento para protegerlo.

Ejemplo de Procedimientos
A continuacin construiremos un procedimiento con respecto al siguiente enunciado:
Cree un procedimiento que imprima el total de una factura al ingresar el cdigo de la
factura.
Normalmente en un sistema de facturacin hay una tabla FACTURA y RENGLON. Donde
rengln es el detalle de cada articulo comprado y su precio. Por lo tanto una factura es
especificada por muchos renglones. Teniendo esto claro vamos a escribir nuestro
procedimiento, en el cual sumaremos el resultado de cada rengln en la factura con
respecto al parmetro de entrada.
CREATE PROCEDURE total_factura (@id_factura INT)
AS
BEGIN
SELECT SUM(UNIDADES*PRECIO) FROM RENGLON
WHERE RENGLON.IDFACTURA = @id_factura;
END;

Como ves, hemos hecho una sencilla consulta en la tabla RENGLON para sumar el subtotal
de cada producto en la factura. En el WHERE (Ver ms sobre esta sentencia) hemos hecho
una comparacin del ID de la factura con el parmetro ingresado al procedimiento.

Como ejecutar un Procedimiento?

Debes usar el comando EXEC su equivalente EXECUTE. Seguido a este ubicas el
nombre del procedimiento. Si el procedimiento tiene parmetros entonces los pones
separados por comas en seguida del nombre. As ejecutaramos nuestro procedimiento
total_factura:
EXEC total_factura 1;

Modificar un Procedimiento
Usaremos ALTER PROCEDURE para modificar procedimientos en SQL Server. Con
esta sentencia se busca cambiar el cuerpo y las caractersticas de un procedimiento ya
creado:
ALTER PROCEDURE nombre_procedimiento
<nuevas caractersticas>
AS
<nuevo bloque de instrucciones>

Vamos a, modificar un procedimiento llamado modificar_cliente, el cual actualiza los datos

de los registros de una tabla llamada CLIENTE. Lo que haremos ser agregarle la clausula

WITH ENCRYPTION para que el procedimiento sea encriptado, ya que no lo est.

Veamos:
ALTER PROCEDURE modificar_cliente
(@id_cliente INT, @nombre_cliente VARCHAR(20),@apellido_cliente
VARCHAR(20))
WITH ENCRYPTION
AS
UPDATE CLIENTE
SET NOMBRE=@nombre_cliente,APELLIDO=@apellido_cliente
WHERE IDCLIENTE=@id_cliente;

Una vez modificado veremos si podemos consultar el cuerpo de modificar_cliente con el

procedimiento del sistema sp_helptext.

Como ves, no es posible visualizar el cuerpo del procedimiento, lo que indica que la
modificacin fue exitosa.

Borrar un Procedimiento
Para borrar un procedimiento en SQL Server se usa la sentencia DROP PROCEDURE:
DROP PROCEDURE nombre_procedimiento

Sencillo no?
Miremos un pequeo ejemplo. Borraremos un procedimiento llamado retiro_fondos:
DROP PROCEDURE retiro_fondos

Una buena prctica antes de crear un procedimiento es comprobar si ya existe en la base de

datos. Para ello usaremos la funcin OBJECT_ID de SQL Server. Esta funcin comprueba
la existencia de cualquier tipo de objeto dentro de la base de datos, ya sea una tabla,
procedimiento, restriccin, funcin, etc.
OBJECT_ID recibe como primer parmetro el nombre del objeto en tipo varchar, y en el
segundo parmetro recibe el tipo de objeto. Por ejemplo, para referirnos a un procedimiento
se usa el carcter P.
Ahora extendamos el ejemplo visto con anterioridad con el siguiente condicional de
existencia:
IF(OBJECT_ID('retiro_fondos','P') IS NOT NULL)
DROP PROCEDURE retiro_fondos;
ELSE
PRINT 'El procedimiento no existe';

Bucles y condicionales en procedimientos almacenados de MySQL

A la hora de crear procedimientos almacenados en MySQL tenemos la opcin de utilizar
distintos tipos de bucles y de condicionales, lo que nos dotar de la capacidad de llevar a
cabo acciones ms complejas dentro de nuestros procedimientos.
Para esto disponemos de las estructuras de control IF THEN ELSE, CASE, WHILE y
REPEAT, adems de poder definir y declarar variables locales dentro de los
procedimientos.
Variables:
Para declarar una variable la definimos con DEFINE y la inicializamos con SET:
1DEFINE varprueba INT; #definimos la variable y su tipo
2SET varpruebra = 10; #le damos un valor concordante con el tipo

IF THEN ELSE:
El condicional simple IF que tenemos en la mayora de los lenguajes de programacin, que
puede ser complementado o no con un ELSE para el caso de que no se cumpla. La sintaxis
es IF condicin THEN (el ELSE si hace falta) END IF. Podis ver un ejemplo:
1
2

delimiter $$
CREATE procedure ej(IN val int)

/* Parmetro de entrada */

begin

IF val = 0 then

INSERT INTO tbejemplo VALUES('No disponible');

else

INSERT INTO tbejemplo VALUES(val);

end IF;

end$$

delimiter ;

10

CASE:
Condicional que nos permite evaluar el valor de una variable y realizar diversas acciones
segn varias posibilidades. Es una forma de abreviar un montn de IF anidados. En

este caso el ELSE nos permite definir un valor por defecto (como el default en un
switch/case de C, Java o PHP):
1
2

delimiter $$
CREATE procedure ej(IN val int)

/* Parmetro de entrada */

begin

case val

when 5 then INSERT INTO prueba VALUES('Suficientes');

when 4 then INSERT INTO prueba VALUES('Reserva');

else INSERT INTO prueba VALUES ('Insuficientes);

end case;

end$$

delimiter;

10

WHILE:
Un bucle que hace que un procedimiento se repita mientras se de una condicin. Si la
condicin ya no se da antes de entrar al bucle, no entra.
1
delimiter $$

CREATE procedure ej(IN val int)

begin

define i int;

set i = 0;

while i<5 do
INSERT INTO prueba VALUES (i);

set i=i+1;

end while;

end$$

10
delimiter ;

11

/* Parmetro de entrada */

REPEAT:
Lo contratio que WHILE, repeat es un bucle UNTIL, se realiza hasta que se de una
condicin. Si bien tambin comparte con el DOWHILE de C (y Java, y PHP) que
siempre se ejecuta al menos una vez.
1
delimiter $$

CREATE procedure ej(IN val int)

/* Parmetro de entrada */

begin

define i int;

set i = 0;

repeat

INSERT INTO prueba VALUES (i);

set i=i+1;
until i <= 5;

9
10

end repeat;
end$$

11
delimiter ;

12

Con esto ya podis empezar a programar un poco ms en serio dentro de MySQL.

Procedimientos almacenados con parmetros variables en

el WHERE
Me excusaba ayer en Twitter, tengo un nuevo empleo y menos tiempo para escribir en el
blog. No os preocupis, que no lo dejar de lado pero s es cierto que el ritmo de
publicaciones bajar un poquillo. Pero lo bueno de tener un nuevo trabajo es que al
afrontar nuevos retos tengo material para nuevos artculo sobre programacin (aparte
de lo de cobrar regularmente a fin de mes y hacer currculum).
Y una cosa con la que estoy trabajando estos das mucho es con procedimientos
almacenados en MySQL. Hoy se me planteada una cuestin, que era un procedimiento
que recibe varios parmetros desde un formulario en PHP (para otro da dejo Llamar a
procedimientos almacenados desde PHP) para realizar una bsqueda. El problema: hay
parmetros que pueden ir vacos, ya que el usuario puede estar buscando por todos o

por uno. Y el procedimiento almacenado no permite definir parmetros opcionales,

como s podra hacer en una funcin de PHP. Solucin? Simple y fcil.
Lo primero es pasar todos los parmetros que no estn definidos al procedimiento con
valor NULL. Lo siguiente es que cada comparacin que se hara en el WHERE ahora
formar parte de un OR donde tambin comprobamos si el parmetro enviado es
nulo. Esto que suena a churro se explica fcilmente con un supuesto y un ejemplo de
cdigo:
Imaginemos que queremos hacer una bsqueda en una lista de, por ejemplo, alumnos de un
centro. Podemos buscar por nombre, apellidos y un mximo y un mnimo de edad. Bueno,
pues el procedimiento sera algo as:
DELIMITER $$ --esto para no tener conflicto con el punto y coma, puede
valer otra opcin

CREATE PROCEDURE ps_BusquedaVarParam(IN nombre_in varchar(30),

2apellidos_in varchar(50), minEdad int, maxEdad int)

3BEGIN

SELECT * FROM alumnos WHERE (nombre_in is null or Nombre = nombre_in) and

(apellidos_in is null or Apellidos = apellidos_in) and (minEdad is null or
5Edad>=minEdad) and (maxEdad is null or Edad<=maxEdad);

6END $$
DELIMITER;

La idea de hacer as este tipo de comparacin es que si le pasamos un nulo la comparacin

con null devolver TRUE. De esa forma si es NULL devuelve TRUE, si se da la
condicin tambin devuelve TRUE y si no es nulo pero no comple devuelve FALSE. O
lo que es lo mismo, si va un NULL te devuelve TRUE y as ese parmetro no te jode que se
cumple el AND de la comparativa. As logramos que no haya problema para hacer la
bsqueda sin mandar todos los parmetros.
Y listo, tranquilos, irn ms espaciados, pero seguir habiendo movimientos en este blog. Y
de calidad, como siempre.
Ojo a los nombres de variables, por cierto. Si el parmetro tiene el mismo nombre que el
campo, aunque uno est en maysculas y otro en minsculas, fallar. En teora debera no
dar problemas, pero dependiendo de la configuracin de MySQL puede fallar o no (de
hecho tuve que modificar la consulta, porque en una base de datos me funcionaba pero en
otra fallaba), as que mejor les aads a las variables un prefijo o sufijo y va (en este caso le
puse _in)

Control de flujo en procedimientos almacenados para MySQL 5

18/03/2008 by David
Seguimos con los procedimientos almacenados. Vamos a ver como llevar a cabo el
control de flujo de nuestro procedimiento. Tambin es interesante observar el uso de las
variables dentro de los procedimientos. Si se declara una variable dentro de un
procedimiento mediante el cdigo :
declare miVar int;

Esta tendr un mbito local y cuando se acabe el procedimiento no podr ser accedida. Una
vez la variable es declarada, para cambiar su valor usaremos la sentencia SET de este modo
:
set miVar = 56 ;

Para poder acceder a una variable a la finalizacin de un procedimiento se tiene que usar
parmetros de salida.
Vamos a ver unos ejemplos para comprobar lo sencillo que es :
IF THEN ELSE
delimiter //
create procedure miProc(in p1 int)
/* Parmetro de entrada */
begin
declare miVar int;
/* se declara variable local */
set miVar = p1 +1 ;
/* se establece la variable */
if miVar = 12 then
insert into lista values(55555);
else
insert into lista values(7665);
end if;
end;
//

SWITCH
delimiter //
create procedure miProc
begin
declare var int
set var = p1 +2
case var
when 2 then
when 3 then
else insert
end case;
end;
//

(in p1 int)
;
;
insert into lista values (66666);
insert into lista values (4545665);
into lista values (77777777);

Creo que no hacen falta explicaciones.

COMPARACIN DE CADENAS
delimiter //
create procedure compara(in cadena varchar(25), in cadena2 varchar(25))
begin
if strcmp(cadena, cadena2) = 0 then
select "son iguales!";
else
select "son diferentes!!";
end if;
end;
//

La funcin strcmp devuelve 0 si las cadenas son iguales, si no devuelve 0 es que son
diferentes.
USO DE WHILE
delimiter //
create procedure p14()
begin
declare v int;
set v = 0;
while v < 5 do
insert into lista values (v);
set v = v +1 ;
end while;
end;
//

Un while de toda la vida.

USO DEL REPEAT
delimiter //
create procedure p15()
begin
declare v int;
set v = 20;
repeat
insert into lista values(v);
set v = v + 1;
until v >= 1
end repeat;
end;
//

El repeat es similar a un do while de toda la vida.

LOOP LABEL

delimiter //
create procedure p16()
begin
declare v int;
set v = 0;
loop_label : loop
insert into lista values (v);
set v = v + 1;
if v >= 5 then
leave loop_label;
end if;
end loop;
end;
//

Este es otro tipo de loop, la verdad es que teniendo los anteriores no se me ocurre
aplicacin para usar este tipo de loop, pero es bueno saber que existe por si algn da te
encuentras algn procedimiento muy antiguo que lo use. El cdigo que haya entre
loop_label : loop y end loop; se ejecutara hasta que se encuentre la sentencia leave
loop_label; que hemos puesto en la condicin, por lo tanto el loop se repetir hasta que la
variable v sea >= que 5.
El loop puede tomar cualquier nombre, es decir puede llamarse miLoop: loop, en cuyo caso
se repetir hasta que se ejecute la sentencia leave miLoop.
Con esto ya podemos empezar a crear procedimientos medianamente complejos y
tiles.

Cmo crear funciones en MySQL

20/03/2008 by David
Como hemos comentado en el post de procedimientos almacenados, tener nuestras
funciones y procedimientos en MySQL en lugar de de procesar los datos con algn
lenguaje del lado del servidor, como PHP , tiene la ventaja de que viaja menos informacin
de la base de datos al servidor web , con el consiguiente aumento del rendimiento y que
estas funciones harn que podamos atacar la base de datos desde cualquier otro
lenguaje, como Java o ASP.NET sin tener que volver a procesar los datos otra vez.
MySQL tiene muchas funciones que podemos usar en nuestro procedimientos almacenados
y consultas, pero en ocasiones podemos necesitar crear nuestras propias funciones para
hacer cosas ms especializadas
Vamos a ver cmo crear funciones en MySQL:
DELIMITER //
CREATE FUCNTION holaMundo() RETURNS VARCHAR(20)
BEGIN

RETURN HolaMundo;
END
//

Para comprobar que funciona tecleamos lo siguiente en la consola de MySQL :

Select holaMundo();

Lo que devuelve el siguiente resultado :

mysql> select holaMundo()//
+--------------+
| holaMundo() |
+--------------+
| Hola Mundo!! |
+--------------+
1 row in set (0.00 sec)

Para borrar la funcin que acabamos de crear :

DROP FUNCTION IF EXISTS holaMundo

Uso de las variables en funciones:

Las variables en las funciones se usan de igual manera que en los procedimientos
almacenados, se declaran con la sentencia DECLARE, y se asignan valores con la
sentencia SET.
DELIMITER //
CREATE FUNCTION holaMundo() RETURNS VARCHAR(30)
BEGIN
DECLARE salida VARCHAR(30) DEFAULT 'Hola mundo';
;
SET salida = Hola mundo con variables;
RETURN salida;
END
//

Esta variable es de mbito local, y ser destruida una vez finalice la funcin. Cabe destacar
el uso de la sentencia DEFAULT en conjunto con DECLARE, que asigna un valor por
defecto al declarar la variable.

Uso de parmetros en funciones:

DROP FUNCTION IF EXISTS holaMundo
CREATE FUNCTION holaMundo(entrada VARCHAR(20)) RETURNS VARCHAR(20)
BEGIN

DECLARE salida VARCHAR(20);

SET salida = entrada;
RETURN salida;
END

Ahora hemos creado una funcin que devuelve el mismo valor que le pasamos como
parmetro.
Si tecleamos :
mysql> select holaMundo("nosolocodigo")//
+---------------------------+
| holaMundo("nosolocodigo") |
+---------------------------+
| nosolocodigo
|
+---------------------------+
1 row in set (0.00 sec)

Obtenemos como resultado lo mismo que le hemos pasado como prametro, en este caso
nosolocodigo
Para finalizar, algo un poco ms complejo, vamos a crear una funcin que acepte un
dividendo y un divisor y haga una divisin sin usar el operador divisin:
create function divide(dividendo int,divisor int) returns int
begin
declare aux int;
declare contador int;
declare resto int;
set contador = 0;
set aux = 0;
while (aux + divisor) <= dividendo do
set aux = aux + divisor ;
set contador = contador + 1;
end while;
set resto = dividendo - aux ;
return contador;
end;
//

Para usarlo, simplemente llamaramos a la funcin as:

SELECT divide(20,2)

Lo que devolvera 10.

Cmo crear triggers en MySQL 5

27/03/2008 by David
Otra de las nuevas caractersticas incluidas en MySQL, adems de los procedimientos
almacenados, son los triggers, que traducido sera algo as como disparadores, son
oyentes, que se mantienen a la escucha de los eventos que puedan producirse en una tabla
(insert , update y delete) y ejecutan un cdigo antes (before) o despus (after) de que se
produzca este evento.
Con los triggers podemos hacer cosas tan interesantes como mantener un log de que
usuarios hace modificaciones en una tabla, que usuarios borran registros, o insertan, o lo
que se te ocurra.
Para referenciar las columnas de antes y despus de que el vento se haya disparado, se usan
las palabras clave OLD y NEW. Con la sentencia insert solo se permite NEW, con update
se permiten ambas y con delete solo OLD.
Sintaxis necesaria para crear un trigger
CREATE TRIGGER
{BEFORE|AFTER}
{INSERT|UPDATE|DELETE}
ON
FOR EACH ROW
BEGIN
END;

Para poner nombre a los triggers es conveniente seguir una convencin que har ms fcil
identificar sobre que evento y tabla acta el trigger. Esta sera una buena forma de nombrar
nuestros triggers:
NombreTabla + _ + abreviatura_tipo_tigger
Por lo tanto para nombrar un triger que se ejecuta sobre la tabla T1 despus de un update lo
haramos de la siguiente forma si seguimos esta convencin:
T1_BU
Esto puede ser til, pero no es necesario, puedes poner el nombre que quieras a tu trigger.

Para crear triggers en una tabla es necesario hacerlo desde un usuario con permisos para
ello. Para dar permiso a un usuario en una tabla para crear un trigger lo haramos de la
siguiente forma:
GRANT CREATE TRIGGER ON nombreTabla TO Usuario

Vamos a ver un ejemplo sencillo:

Creamos la tabla miTabla
create table miTabla( id int , nombre varchar(50) );

Y despus creamos un trigger que va a crear una variable global con el nombre antiguo
antes de ejecutar el update y otra con el nombre nuevo que habr despus de ejecutar el
update.
delimiter //
create trigger miTabla_bu before update
on miTabla
for each row
begin
set @nombreViejo = OLD.nombre;
set @nombreNuevo = NEW.nombre;
end//

Vamos a ver otro tigger :

create trigger miTabla_bi
before insert on miTabla
for each row
begin
set @x = 'Trigger activado';
set NEW.nombre = Valor introducido desde el trigger;
end//

En esta ocasin, cada vez que se haga un insert sobre la tabla miTabla, se crear una
variable global con el valor Trigger activado y modificar el valor que se insertar en la
columna nombre, por lo que siempre se insertar el valor Valor introducido desde el
trigger.
Si lo que queremos es mantener el control de una tabla para ver quien la modifica y a que
hora, podemos crear una tabla donde iremos anotando quien hace cada modificacin y
anotar los cambios.
Creamos la tabla auxiliar
CREATE TABLE controlMiTabla
(
id int not null auto_increment,
id_registro int,

anterior_nombre varchar(50),
nuevo_nombre varchar(50),
usuario varchar(40),
modificado datetime,
primary key(id)
) ENGINE = InnoDB;

Y ahora vamos a crear un trigger que se encargue de llevar un log de quien actualiza la
tabla, que valores modifica y a que hora:
delimiter //
create trigger MiTabla_BU after update on miTabla
for each row
begin
insert into controlMiTabla (id_registro, anterior_nombre ,
nuevo_nombre, usuario , modificado ) values(OLD.id , OLD.nombre ,
NEW.nombre, CURRENT_USER(), NOW() );
end//

Y ya tenemos nuestro trigger creado, con el cual llevaremos el control de la tabla.

Esto es recomendable hacerlo solo en las tablas de importancia critica, ya que si no nuestra
base de datos crecer de forma innecesaria.