breve introducción
disparador de MySQL pertenece a una función avanzada, que puede considerarse como una versión simplificada del procedimiento almacenado. Y el procedimiento real almacenado diferente es que no se está llamando llamada, pero ejecuta automáticamente después de detectar el estado de funcionamiento se satisface, similar a la relación entre la supervisión y las alarmas del sistema.
disparador de MySQL sólo es compatible con la línea de disparo, siempre se dirige a un registro. MySQL gatillo se dispara para la inserción a la fila \ operaciones de actualización \ borrado, específicamente para determinar qué acción se desencadena por real definido por el usuario. Pero cada evento para cada tabla, sólo puede definir un disparador.
tiempo de activación del gatillo MySQL se divide en dos: antes y después, es decir, antes o después de la ejecución del evento desencadenante. Por ejemplo, dice que antes de insertar gatillo antes de la operación de inserción.
Gatillo relativamente ventajosa, es posible reducir la comunicación entre el cliente y el servidor, lo que puede mejorar el rendimiento, sino que puede cubrir el servidor específico detrás del frente de trabajo, puede mejorar la confidencialidad de los datos, sino que también puede garantizar que los datos consistentes por supuesto, limitada a la mesa de operaciones innodb, el gatillo innodb tabla se realiza en la misma transacción.
Hay ventajas y desventajas serán los mismos, debido a ocultar una gran cantidad de trabajo concreto, el gatillo será más difícil Solucionar problemas; no está claro si el servidor tiene una operación de disparo, es casi imposible localizar el problema.
Teniendo en cuenta los pros y los contras de la utilización de un sistema de disparo, y luego decidir si se debe utilizar disparadores en su propio sistema.
Reglas de sintaxis
create trigger [trigger_name] [trigger_time] [trigger_event] on [table_name] for each row [trigger_operation]Nombre del gatillo está creando ;: trigger_name
momento_disp: el tiempo de ejecución del gatillo;
evento_disp: evento de activación dependiente de disparo;
nombre_tabla: el papel de la mesa de disparo;
trigger_operation: declaraciones de acción de disparo específicos;
Ejemplos
Cree dos tablas, una t_trigger_user para guardar información personal, información de salarios se utiliza para guardar un personal t_trigger_salary. Dos mesa vacía para poner a prueba la estructura de la tabla específica de la siguiente manera:
mysql> show create table t_trigger_user\G
*************************** 1. row ***************************
Table: t_trigger_user
Create Table: CREATE TABLE `t_trigger_user` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(32) DEFAULT '',
`age` int(3) unsigned DEFAULT '0',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
1 row in set (0.00 sec)
mysql> show create table t_trigger_salary\G
*************************** 1. row ***************************
Table: t_trigger_salary
Create Table: CREATE TABLE `t_trigger_salary` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`salary` int(10) unsigned DEFAULT '0',
`uid` int(10) NOT NULL,
`name` varchar(32) DEFAULT '',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
1 row in set (0.00 sec)operación de prueba de inserción del gatillo
En primer lugar, crear un inserto de mesa de operaciones t_trigger_user (por defecto todas nuestras operaciones se activan después de una operación específica) basados en el gatillo, el gatillo utilizados para completar "cuando la nueva inserción de la mesa t_trigger_user de datos, insertar una fila en la tabla de sincronización t_trigger_salary información relevante ".
Crear un disparador después de inserción
mysql> create trigger user_insert after insert on t_trigger_user for each row insert into t_trigger_salary(uid,name) values(new.id,new.name);Realizar operaciones de insertar la tabla donde el t_trigger_user gatillo, y luego ver la información en ambas tablas
mysql> insert into t_trigger_user(name,age) values('lily',21);
Query OK, 1 row affected (0.01 sec)
mysql> select * from t_trigger_user;
+----+------+------+
| id | name | age |
+----+------+------+
| 2 | lily | 21 |
+----+------+------+
1 row in set (0.00 sec)
mysql> select * from t_trigger_salary;
+----+--------+-----+------+
| id | salary | uid | name |
+----+--------+-----+------+
| 1 | 0 | 2 | lily |
+----+--------+-----+------+
1 row in set (0.00 sec)Se puede ver, mesa t_trigger_user después de crear un desencadenador de inserción operación, después de realizar la operación de inserción, inserción de datos es satisfactoria, también se disparó el gatillo para la ejecución t_trigger_salary también insertar una tabla de datos.
De la misma manera, la prueba de nuevo activador de actualización y supresión para lograr operativo.
actualizar la operación de ejemplo del activador
mysql> delimiter //
mysql> create trigger update_user after update on t_trigger_user for each row
-> begin
-> if new.name != old.name
-> then
-> update t_trigger_salary set name=new.name where uid=old.id;
-> end if;
-> end
-> //
Query OK, 0 rows affected (0.00 sec)
mysql> update t_trigger_user set name='anvil' where id=2;
-> //
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql> delimiter ;
mysql> select * from t_trigger_user;
+----+-------+------+
| id | name | age |
+----+-------+------+
| 2 | anvil | 21 |
+----+-------+------+
1 row in set (0.00 sec)
mysql> select * from t_trigger_salary;
+----+--------+-----+-------+
| id | salary | uid | name |
+----+--------+-----+-------+
| 1 | 0 | 2 | anvil |
+----+--------+-----+-------+
1 row in set (0.00 sec)operación ejemplar de eliminación del gatillo
mysql> create trigger delete_user after delete on t_trigger_user for each row delete from t_trigger_salary where uid=old.id;
Query OK, 0 rows affected (0.01 sec)
mysql> delete from t_trigger_user where id=2;
Query OK, 1 row affected (0.00 sec)
mysql> select * from t_trigger_user;
Empty set (0.00 sec)
mysql> select * from t_trigger_salary;
Empty set (0.00 sec)Sí, se dispara [trigger_operation] no sólo es compatible con una sola instrucción SQL de las operaciones, la declaración también es apoyado por una serie de operaciones comienzan ... .end empacar.
Cuando se acciona el gatillo, a continuación, se produjo el error, cuando no se ejecutará la operación del gatillo, el mismo, lo que provocó las declaraciones de acción de disparo no se lleva a cabo efectivamente.
