crear un procedimiento en mysql
DESCRIPTION
MySQLTRANSCRIPT
Crear un Procedimiento en MySQL
La creación de un procedimiento se inicia con las clausulas CREATE PROCEDURE. Luego
definimos un nombre y los parámetros que necesita para funcionar adecuadamente. Veamos
su sintaxis:
CREATE PROCEDURE nombre ([parámetro1,parámetro2,...])
[Atributos de la rutina]
BEGIN instrucciones
END
Un procedimiento puede tener uno o mas parámetros o también no tener ninguno. Puede
carecer de atributos o puede poseer varios. Y como ves, el cuerpo del procedimiento es un
bloque de instrucciones definido.
Parámetros de Entrada y Salida en un Procedimiento
Un parámetro es un dato necesario para el funcionamiento del procedimiento, ya que
contribuyen al correcto desarrollo de las instrucciones del bloque de instrucciones.
Los parámetros pueden ser de entrada (IN), salida (OUT) o entrada/salida (INOUT) y deben
tener definido un tipo. Un parámetro de entrada en un dato que debe ser introducido en la
llamada del procedimiento para definir alguna acción del bloque de instrucciones.
Un parámetro de salida es un espacio de memoria en el cual el procedimiento devolverá
almacenado su resultado. Y un parámetro de entrada/salida contribuye tanto como a
ingresar información útil como para almacenar los resultados del procedimiento. Por
defecto, si no indicas el tipo de parámetro MySQL asigna IN.
Para especificar el tipo de parámetro seguimos la siguiente sintaxis:
[{IN|OUT|INOUT} ] nombre TipoDeDato
Ejemplo de un Procedimiento con un parámetro IN
En el siguiente ejemplo desarrollemos un procedimiento para el siguiente requerimiento:
Imprima los números 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 impresión.
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 carácter de terminación ';' por cualquier otro carácter,
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 parámetros,
entonces se ingresan sus parámetros. 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 parámetros que implementará, también 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 [#|##] [(
parámetro1,parámetro2,... )]
[{FOR REPLICATION|WITH RECOMPILE}][WITH ENCRYPTION]
AS<bloque de sentencias>
Fíjate 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 acción del procedimiento.
[#|##]: El signo número individual indica que el procedimiento será temporal local. Los dos
símbolos numero indica que será temporal global.
[( parámetro1,parámetro2,… )]:Se refiere a los parámetros del procedimiento. Si el
procedimiento tienen parámetros deben encerrarse en paréntesis y declararlos con la
siguiente definición:
@nombre_parametro TIPO [VARYING] [= valor_por_defecto][OUTPUT]
donde VARYING especifica que un parámetro de tipo CURSOR será de salida y OUTPUT
para indicar que un parámetro será de salida.
FOR REPLICATION: Se usa para especificar que el procedimiento será para replicación.
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 continuación construiremos un procedimiento con respecto al siguiente enunciado:
Cree un procedimiento que imprima el total de una factura al ingresar el código de la
factura.
Normalmente en un sistema de facturación hay una tabla FACTURA y RENGLON. Donde
renglón 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 renglón en la factura con
respecto al parámetro 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 más sobre esta sentencia) hemos hecho
una comparación del ID de la factura con el parámetro 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 parámetros entonces los pones
separados por comas en seguida del nombre. Así ejecutaríamos 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 características de un procedimiento ya
creado:
ALTER PROCEDURE nombre_procedimiento
<nuevas características>
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
modificación 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 pequeño ejemplo. Borraremos un procedimiento llamado retiro_fondos:
DROP PROCEDURE retiro_fondos
Una buena práctica antes de crear un procedimiento es comprobar si ya existe en la base de
datos. Para ello usaremos la función OBJECT_ID de SQL Server. Esta función comprueba
la existencia de cualquier tipo de objeto dentro de la base de datos, ya sea una tabla,
procedimiento, restricción, función, etc.
OBJECT_ID recibe como primer parámetro el nombre del objeto en tipo varchar, y en el
segundo parámetro recibe el tipo de objeto. Por ejemplo, para referirnos a un procedimiento
se usa el carácter ‘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 opción de utilizar
distintos tipos de bucles y de condicionales, lo que nos dotará de la capacidad de llevar a
cabo acciones más complejas dentro de nuestros procedimientos.
Para esto disponemos de las estructuras de control IF THEN ELSE, CASE, WHILE y
REPEAT, además 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:
1
2
DEFINE varprueba INT; #definimos la variable y su tipo
SET varpruebra = 10; #le damos un valor concordante con el tipo
IF THEN ELSE: El condicional simple IF que tenemos en la mayoría de los lenguajes de programación, que
puede ser complementado o no con un ELSE para el caso de que no se cumpla. La sintaxis
es IF condición THEN (el ELSE si hace falta) END IF. Podéis ver un ejemplo:
1
2
3
4
5
6
7
8
9
10
delimiter $$
CREATE procedure ej(IN val int) /* Parámetro de entrada */
begin
IF val = 0 then
INSERT INTO tbejemplo VALUES('No disponible');
else
INSERT INTO tbejemplo VALUES(val);
end IF;
end$$
delimiter ;
CASE: Condicional que nos permite evaluar el valor de una variable y realizar diversas acciones
según varias posibilidades. Es una forma de abreviar un montón 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
3
4
5
6
7
8
9
10
delimiter $$
CREATE procedure ej(IN val int) /* Parámetro 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;
WHILE:
Un bucle que hace que un procedimiento se repita mientras se de una condición. Si la
condición ya no se da antes de entrar al bucle, no entra.
1
2
3
4
5
6
7
8
9
10
11
delimiter $$
CREATE procedure ej(IN val int) /* Parámetro de entrada */
begin
define i int;
set i = 0;
while i<5 do
INSERT INTO prueba VALUES (i);
set i=i+1;
end while;
end$$
delimiter ;
REPEAT: Lo contratio que WHILE, repeat es un bucle UNTIL, se realiza hasta que se de una
condición. Si bien también comparte con el DO…WHILE de C (y Java, y PHP…) que
siempre se ejecuta al menos una vez.
1
2
3
4
5
6
7
8
9
10
11
12
delimiter $$
CREATE procedure ej(IN val int) /* Parámetro de entrada */
begin
define i int;
set i = 0;
repeat
INSERT INTO prueba VALUES (i);
set i=i+1;
until i <= 5;
end repeat;
end$$
delimiter ;
Con esto ya podéis empezar a programar un poco más en serio dentro de MySQL.
Procedimientos almacenados con parámetros variables en
el WHERE
Me excusaba ayer en Twitter, tengo un nuevo empleo y menos tiempo para escribir en el
blog. No os preocupéis, 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 artículo sobre programación (aparte
de lo de cobrar regularmente a fin de mes y hacer currículum).
Y una cosa con la que estoy trabajando estos días mucho es con procedimientos
almacenados en MySQL. Hoy se me planteada una cuestión, que era un procedimiento
que recibe varios parámetros desde un formulario en PHP (para otro día dejo “Llamar a
procedimientos almacenados desde PHP”) para realizar una búsqueda. El problema: hay
parámetros que pueden ir vacíos, ya que el usuario puede estar buscando por todos o
por uno. Y el procedimiento almacenado no permite definir parámetros opcionales,
como sí podría hacer en una función de PHP. ¿Solución? Simple y fácil.
Lo primero es pasar todos los parámetros que no están definidos al procedimiento con
valor NULL. Lo siguiente es que cada comparación que se haría en el WHERE ahora
formará parte de un OR donde también comprobamos si el parámetro enviado es
nulo. Esto que suena a churro se explica fácilmente con un supuesto y un ejemplo de
código:
Imaginemos que queremos hacer una búsqueda en una lista de, por ejemplo, alumnos de un
centro. Podemos buscar por nombre, apellidos y un máximo y un mínimo de edad. Bueno,
pues el procedimiento sería algo así:
1
2
3
4
5
6
DELIMITER $$ --esto para no tener conflicto con el punto y coma, puede
valer otra opción
CREATE PROCEDURE ps_BusquedaVarParam(IN nombre_in varchar(30), apellidos_in varchar(50), minEdad int, maxEdad int)
BEGIN
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 Edad>=minEdad) and (maxEdad is null or Edad<=maxEdad);
END $$
DELIMITER;
La idea de hacer así este tipo de comparación es que si le pasamos un nulo la comparación
con null devolverá TRUE. De esa forma si es NULL devuelve TRUE, si se da la
condición también 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 parámetro no te jode que se
cumple el AND de la comparativa. Así logramos que no haya problema para hacer la
búsqueda sin mandar todos los parámetros.
Y listo, tranquilos, irán más espaciados, pero seguirá habiendo movimientos en este blog. Y
de calidad, como siempre.
Ojo a los nombres de variables, por cierto. Si el parámetro tiene el mismo nombre que el
campo, aunque uno esté en mayúsculas y otro en minúsculas, fallará. En teoría debería no
dar problemas, pero dependiendo de la configuración 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 añadís a las variables un prefijo o sufijo y vía (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. También es interesante observar el uso de las
variables dentro de los procedimientos. Si se declara una variable dentro de un
procedimiento mediante el código :
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 finalización de un procedimiento se tiene que usar
parámetros de salida.
Vamos a ver unos ejemplos para comprobar lo sencillo que es :
IF THEN ELSE
delimiter //
create procedure miProc(in p1 int) /* Parámetro 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 (in p1 int)
begin
declare var int ;
set var = p1 +2 ;
case var
when 2 then insert into lista values (66666);
when 3 then insert into lista values (4545665);
else insert into lista values (77777777);
end case;
end;
//
Creo que no hacen falta explicaciones.
COMPARACIÓN 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 función 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
aplicación para usar este tipo de loop, pero es bueno saber que existe por si algún día te
encuentras algún procedimiento muy antiguo que lo use. El código 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 condición, 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.
Cómo 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 algún
lenguaje del lado del servidor, como PHP , tiene la ventaja de que viaja menos información
de la base de datos al servidor web , con el consiguiente aumento del rendimiento y que
estas funciones harán 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 más especializadas…
Vamos a ver cómo 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 función 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 función. Cabe destacar
el uso de la sentencia DEFAULT en conjunto con DECLARE, que asigna un valor por
defecto al declarar la variable.
Uso de parámetros 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 función que devuelve el mismo valor que le pasamos como
parámetro.
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 párametro, en este caso
“nosolocodigo”
Para finalizar, algo un poco más complejo, vamos a crear una función que acepte un
dividendo y un divisor y haga una división sin usar el operador división:
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 llamaríamos a la función así:
SELECT divide(20,2)
Lo que devolvería 10.
Cómo crear triggers en MySQL 5
27/03/2008 by David
Otra de las nuevas características incluidas en MySQL, además de los procedimientos
almacenados, son los triggers, que traducido sería 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 código antes (before) o después (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 después 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 convención que hará más fácil
identificar sobre que evento y tabla actúa el trigger. Esta sería 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 después de un update lo
haríamos de la siguiente forma si seguimos esta convención:
“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 haríamos 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 después 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á después 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 ocasión, 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 modificación 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.