Les déclencheurs MySQL, comme les procédures stockées, sont des programmes intégrés dans MySQL et constituent des outils puissants pour la gestion des données dans MySQL. La différence est que l'exécution de la procédure stockée nécessite l'utilisation de l'instruction CALL, tandis que l'exécution du déclencheur ne nécessite pas l'utilisation de l'instruction CALL ni ne doit être démarré manuellement. Au lieu de cela, il est déclenché et activé. via des opérations associées sur la table de données pour réaliser l'exécution. Par exemple, il sera activé lorsqu'une opération (INSERT, DELETE ou UPDATE) est effectuée sur la table étudiant.
Les déclencheurs sont étroitement liés aux tables de données et sont principalement utilisés pour protéger les données des tables. En particulier lorsqu'il existe plusieurs tables liées les unes aux autres, les déclencheurs peuvent maintenir la cohérence des données dans les différentes tables.
Dans MySQL, les déclencheurs ne peuvent être activés que lors de l'exécution d'opérations INSERT, UPDATE et DELETE, et les autres instructions SQL n'activeront pas les déclencheurs.
Alors pourquoi utiliser des déclencheurs ? Par exemple, lors du développement de projets, nous rencontrons souvent les situations suivantes :
- Lorsqu'un enregistrement concernant un étudiant est ajouté à la table des étudiants, le nombre total d'étudiants doit également changer.
- Lors de l'ajout d'un dossier étudiant, vous devez vérifier si l'âge répond aux exigences de plage.
- Lors de la suppression des informations d'un élève, l'enregistrement correspondant sur la feuille de notes doit être supprimé.
- Lorsqu'une donnée est supprimée, une copie de sauvegarde doit être conservée dans la table d'archive de la base de données.
Bien que la logique métier mise en œuvre dans les situations ci-dessus soit différente, elles doivent toutes effectuer automatiquement un certain traitement lorsque la table de données change. À ce stade, le traitement de déclenchement peut être utilisé. Par exemple, pour le premier cas, vous pouvez créer un objet déclencheur et effectuer une opération pour calculer le nombre total d'élèves à chaque fois qu'un dossier d'élève est ajouté. Cela garantit qu'à chaque fois qu'un dossier d'élève est ajouté, le nombre total d'élèves et Le nombre de dossiers d'élèves est calculé et cohérent.
Avantages et inconvénients des déclencheurs
Les avantages des déclencheurs sont les suivants :
- L'exécution du déclencheur est automatique et est exécutée immédiatement après que les modifications correspondantes ont été apportées aux données dans la table relative au déclencheur.
- Les déclencheurs peuvent implémenter des vérifications et des opérations plus complexes que les contraintes FOREIGN KEY et les contraintes CHECK.
- Les déclencheurs peuvent implémenter des modifications en cascade sur les données des tables, garantissant ainsi l'intégrité des données dans une certaine mesure.
Les inconvénients des déclencheurs sont les suivants :
- La logique métier mise en œuvre à l'aide de déclencheurs est difficile à localiser lorsque des problèmes surviennent, en particulier lorsque plusieurs déclencheurs sont impliqués, ce qui rend la maintenance ultérieure difficile.
- Une utilisation intensive de déclencheurs peut facilement perturber la structure du code et augmenter la complexité du programme.
- Si la quantité de données à modifier est importante, l'efficacité d'exécution du déclencheur sera très faible.
Déclencheurs pris en charge par MySQL
En utilisation réelle, MySQL prend en charge trois déclencheurs : le déclencheur INSERT, le déclencheur UPDATE et le déclencheur DELETE.
1) INSÉRER le déclencheur
Un déclencheur qui répond avant ou après l'exécution d'une instruction INSERT.
Lorsque vous utilisez des déclencheurs INSERT, vous devez faire attention aux points suivants :
- Dans le code de déclenchement INSERT, une table virtuelle nommée NEW (insensible à la casse) peut être référencée pour accéder à la ligne insérée.
- Dans le déclencheur BEFORE INSERT, la valeur dans NEW peut également être mise à jour, ce qui permet de modifier la valeur insérée (à condition qu'elle dispose des autorisations d'opération correspondantes).
- Pour la colonne AUTO_INCREMENT, NEW contient la valeur 0 avant l'exécution de INSERT et contiendra la nouvelle valeur générée automatiquement après l'exécution de INSERT.
2) Déclencheur MISE À JOUR
Un déclencheur qui répond avant ou après l'exécution d'une instruction UPDATE.
Lorsque vous utilisez des déclencheurs UPDATE, vous devez faire attention aux points suivants :
- Dans le code de déclenchement UPDATE, une table virtuelle nommée NEW (insensible à la casse) peut être référencée pour accéder à la valeur mise à jour.
- Dans le code du déclencheur UPDATE, une table virtuelle nommée OLD (insensible à la casse) peut être référencée pour accéder à la valeur avant l'exécution de l'instruction UPDATE.
- Dans un déclencheur BEFORE UPDATE, la valeur dans NEW peut également être mise à jour, ce qui permet d'utiliser les modifications apportées à la valeur dans l'instruction UPDATE (à condition que vous disposiez des autorisations d'opération correspondantes).
- Toutes les valeurs dans OLD sont en lecture seule et ne peuvent pas être mises à jour.
Remarque : Lorsque le déclencheur est conçu pour déclencher l'opération de mise à jour de la table elle-même, seuls les déclencheurs de type AVANT peuvent être utilisés et les déclencheurs de type APRÈS ne seront pas autorisés.
3) Déclencheur SUPPRIMER
Un déclencheur qui répond avant ou après l'exécution d'une instruction DELETE.
Lorsque vous utilisez le déclencheur DELETE, vous devez faire attention aux points suivants :
- Dans le code déclencheur DELETE, une table virtuelle nommée OLD (insensible à la casse) peut être référencée pour accéder aux lignes supprimées.
- Toutes les valeurs dans OLD sont en lecture seule et ne peuvent pas être mises à jour.
De manière générale, MySQL gérera les erreurs de la manière suivante lors de l'utilisation du déclencheur.
Pour les tables transactionnelles, si le déclencheur échoue et que l'instruction entière échoue en conséquence, toutes les modifications effectuées par l'instruction seront annulées ; pour les tables non transactionnelles, une telle annulation ne peut pas être effectuée même si l'instruction échoue. Toutes les modifications précédentes seront toujours être en vigueur.
Si le déclencheur BEFORE échoue, MySQL n'effectuera pas l'opération sur la ligne correspondante.
Si une erreur se produit lors de l'exécution d'un déclencheur BEFORE ou AFTER, l'intégralité de l'instruction qui appelle le déclencheur échouera.
MySQL exécutera le déclencheur AFTER uniquement si le déclencheur BEFORE et l'opération sur la ligne ont été exécutés avec succès.
MySQL crée un déclencheur (CREATE TRIGGER)
Les déclencheurs sont des objets de base de données liés aux tables de données MySQL . Ils sont déclenchés lorsque les conditions définies sont remplies et exécutent l'ensemble d'instructions défini dans le déclencheur. Cette fonctionnalité des déclencheurs peut aider les applications à garantir l’intégrité des données côté base de données.
https://edu.csdn.net/course/detail/36210grammaire de base
Dans MySQL 5.7, les déclencheurs peuvent être créés à l'aide de l'instruction CREATE TRIGGER.
Le format de syntaxe est le suivant :
CREATE <触发器名> < BEFORE | AFTER >
<INSERT | UPDATE | DELETE >
ON <表名> FOR EACH Row<触发器主体>La syntaxe est expliquée ci-dessous.
1) Nom du déclencheur
Nom du déclencheur. Le déclencheur doit avoir un nom unique dans la base de données actuelle. Si vous créez dans une base de données spécifique, le nom doit être précédé du nom de la base de données.
2) INSÉRER | MISE À JOUR | SUPPRIMER
Événement déclencheur, utilisé pour spécifier le type d'instruction qui active le déclencheur.
Remarque : Les temps d'exécution des trois déclencheurs sont les suivants.
- INSERT : Déclencheur activé lorsqu'une nouvelle ligne est insérée dans le tableau. Par exemple, le déclencheur BEFORE de INSERT peut être activé non seulement par l'instruction INSERT de MySQL, mais également par l'instruction LOAD DATA.
- DELETE : les déclencheurs sont activés lorsqu'une ligne de données est supprimée de la table, telles que les instructions DELETE et REPLACE.
- UPDATE : un déclencheur est activé lorsqu'une ligne de données dans la table est modifiée, comme une instruction UPDATE.
3) AVANT | APRÈS
AVANT et APRÈS, le moment où le déclencheur est déclenché, indiquent si le déclencheur est déclenché avant ou après l'instruction qui l'active. Si vous souhaitez vérifier si les nouvelles données remplissent les conditions, utilisez l'option AVANT ; si vous souhaitez effectuer plusieurs ou plusieurs modifications après l'exécution de l'instruction qui active le déclencheur, vous utilisez généralement l'option APRÈS.
4) Nom du tableau
Nom de la table à laquelle le déclencheur est associé. Cette table doit être une table permanente. Le déclencheur ne peut pas être associé à une table ou une vue temporaire. Le déclencheur est activé lorsqu'un événement déclencheur se produit sur la table. La même table ne peut pas avoir deux déclencheurs avec le même temps de déclenchement et le même événement. Par exemple, pour une table de données, il ne peut pas y avoir deux déclencheurs BEFORE UPDATE en même temps, mais il peut y avoir un déclencheur BEFORE UPDATE et un déclencheur BEFORE INSERT, ou un déclencheur BEFORE UPDATE et un déclencheur AFTER UPDATE.
5) Corps de déclenchement
Le corps de l'action du déclencheur contient l'instruction MySQL qui sera exécutée lorsque le déclencheur est activé. Si vous souhaitez exécuter plusieurs instructions, vous pouvez utiliser la structure d'instruction composée BEGIN…END.
6) POUR CHAQUE RANGÉE
Fait généralement référence au déclenchement au niveau de la ligne, où l'action de déclenchement doit être activée pour chaque ligne affectée par l'événement déclencheur. Par exemple, lorsque vous utilisez l'instruction INSERT pour insérer plusieurs lignes de données dans une table, le déclencheur effectuera les actions de déclenchement correspondantes pour chaque ligne de données insérée.
注意：每个表都支持 INSERT、UPDATE 和 DELETE 的 BEFORE 与 AFTER，因此每个表最多支持 6 个触发器。每个表的每个事件每次只允许有一个触发器。单一触发器不能与多个事件或多个表关联。De plus, dans MySQL, si vous avez besoin d'afficher les déclencheurs existants dans la base de données, vous pouvez utiliser l'instruction SHOW TRIGGERS.
Créer un déclencheur de type AVANT
Dans la base de données test_db, la table de données tb_emp8 est une table d'informations sur les employés, comprenant les champs id, nom, deptId et salaire. La structure de la table de données tb_emp8 est la suivante.
mysql> SELECT * FROM tb_emp8;
Empty set (0.07 sec)
mysql> DESC tb_emp8;
+--------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+-------+
| id | int(11) | NO | PRI | NULL | |
| name | varchar(22) | YES | UNI | NULL | |
| deptId | int(11) | NO | MUL | NULL | |
| salary | float | YES | | 0 | |
+--------+-------------+------+-----+---------+-------+
4 rows in set (0.05 sec)[Exemple 1] Créez un déclencheur nommé SumOfSalary. La condition du déclencheur est de résumer les valeurs du champ de salaire nouvellement insérées avant d'insérer les données dans la table de données tb_emp8. L'instruction SQL d'entrée et le processus d'exécution sont les suivants.
mysql> CREATE TRIGGER SumOfSalary
-> BEFORE INSERT ON tb_emp8
-> FOR EACH ROW
-> SET @sum=@sum+NEW.salary;
Query OK, 0 rows affected (0.35 sec)Après la création du déclencheur SumOfSalary, lorsqu'un enregistrement est inséré dans la table tb_emp8, la valeur de somme définie passe de 0 à 1500, c'est-à-dire la somme des valeurs insérées 1000 et 500, comme indiqué ci-dessous.
SET @sum=0;
Query OK, 0 rows affected (0.05 sec)
mysql> INSERT INTO tb_emp8
-> VALUES(1,'A',1,1000),(2,'B',1,500);
Query OK, 2 rows affected (0.09 sec)
Records: 2 Duplicates: 0 Warnings: 0
mysql> SELECT @sum;
+------+
| @sum |
+------+
| 1500 |
+------+
1 row in set (0.03 sec)Créer un déclencheur de type APRÈS
Dans la base de données test_db, les tables de données tb_emp6 et tb_emp7 sont toutes deux des tables d'informations sur les employés, comprenant les champs id, name, deptId et salaires. Les structures des tables de données tb_emp6 et tb_emp7 sont les suivantes.
mysql> SELECT * FROM tb_emp6;
Empty set (0.07 sec)
mysql> SELECT * FROM tb_emp7;
Empty set (0.03 sec)
mysql> DESC tb_emp6;
+--------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+-------+
| id | int(11) | NO | PRI | NULL | |
| name | varchar(25) | YES | | NULL | |
| deptId | int(11) | YES | MUL | NULL | |
| salary | float | YES | | NULL | |
+--------+-------------+------+-----+---------+-------+
4 rows in set (0.00 sec)
mysql> DESC tb_emp7;
+--------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+-------+
| id | int(11) | NO | PRI | NULL | |
| name | varchar(25) | YES | | NULL | |
| deptId | int(11) | YES | | NULL | |
| salary | float | YES | | 0 | |
+--------+-------------+------+-----+---------+-------+
4 rows in set (0.04 sec)[Exemple 2] Créez un déclencheur nommé double_salary. La condition du déclencheur est qu'après l'insertion des données dans la table de données tb_emp6, les mêmes données sont insérées dans la table de données tb_emp7 et le salaire est égal à 2 de la valeur du champ de salaire nouvellement inséré dans tb_emp6. fois. L'instruction SQL d'entrée et le processus d'exécution sont les suivants.
mysql> CREATE TRIGGER double_salary
-> AFTER INSERT ON tb_emp6
-> FOR EACH ROW
-> INSERT INTO tb_emp7
-> VALUES (NEW.id,NEW.name,deptId,2*NEW.salary);
Query OK, 0 rows affected (0.25 sec)Après la création du déclencheur double_salary, lorsqu'un enregistrement est inséré dans la table tb_emp6, le même enregistrement est inséré dans la table tb_emp7 en même temps et le champ salaire est le double de la valeur du champ salaire dans tb_emp6, comme indiqué ci-dessous.
mysql> INSERT INTO tb_emp6
-> VALUES (1,'A',1,1000),(2,'B',1,500);
Query OK, 2 rows affected (0.09 sec)
Records: 2 Duplicates: 0 Warnings: 0
mysql> SELECT * FROM tb_emp6;
+----+------+--------+--------+
| id | name | deptId | salary |
+----+------+--------+--------+
| 1 | A | 1 | 1000 |
| 2 | B | 1 | 500 |
+----+------+--------+--------+
3 rows in set (0.04 sec)
mysql> SELECT * FROM tb_emp7;
+----+------+--------+--------+
| id | name | deptId | salary |
+----+------+--------+--------+
| 1 | A | 1 | 2000 |
| 2 | B | 1 | 1000 |
+----+------+--------+--------+
2 rows in set (0.06 sec)