Was genau sind MySQL-Trigger? MySQL erstellt einen Trigger (CREATE TRIGGER)

MySQL-Trigger sind wie gespeicherte Prozeduren in MySQL eingebettete Programme und leistungsstarke Tools für die Datenverwaltung in MySQL. Der Unterschied besteht darin, dass die Ausführung der gespeicherten Prozedur die Verwendung der CALL-Anweisung erfordert, während die Ausführung des Triggers weder die Verwendung der CALL-Anweisung erfordert noch manuell gestartet werden muss. Stattdessen wird er ausgelöst und aktiviert Durch verwandte Vorgänge in der Datentabelle wird eine Ausführung erreicht. Es wird beispielsweise aktiviert, wenn eine Operation (INSERT, DELETE oder UPDATE) für die Schülertabelle ausgeführt wird.

Trigger stehen in engem Zusammenhang mit Datentabellen und werden hauptsächlich zum Schutz der Daten in den Tabellen verwendet. Insbesondere wenn mehrere Tabellen miteinander in Beziehung stehen, können Trigger die Datenkonsistenz in verschiedenen Tabellen aufrechterhalten.

In MySQL können Trigger nur aktiviert werden, wenn INSERT-, UPDATE- und DELETE-Vorgänge ausgeführt werden, und andere SQL-Anweisungen aktivieren keine Trigger.

Warum also Trigger verwenden? Bei der eigentlichen Entwicklung von Projekten stoßen wir beispielsweise häufig auf folgende Situationen:

Wenn der Studententabelle ein Datensatz über einen Studenten hinzugefügt wird, muss sich auch die Gesamtzahl der Studenten ändern.
Beim Hinzufügen eines Schülerdatensatzes müssen Sie prüfen, ob das Alter den Bereichsanforderungen entspricht.
Wenn Sie die Informationen eines Schülers löschen, muss der entsprechende Datensatz im Notenblatt gelöscht werden.
Wenn ein Datenelement gelöscht wird, muss eine Sicherungskopie in der Datenbankarchivtabelle aufbewahrt werden.

Obwohl die in den oben genannten Situationen implementierte Geschäftslogik unterschiedlich ist, müssen sie alle automatisch eine gewisse Verarbeitung durchführen, wenn sich die Datentabelle ändert. Zu diesem Zeitpunkt kann die Triggerverarbeitung verwendet werden. Für den ersten Fall können Sie beispielsweise ein Triggerobjekt erstellen und eine Operation ausführen, um die Gesamtzahl der Schüler jedes Mal zu berechnen, wenn ein Schülerdatensatz hinzugefügt wird. Dadurch wird sichergestellt, dass jedes Mal, wenn ein Schülerdatensatz hinzugefügt wird, die Gesamtzahl der Schüler und Studenten berechnet wird Die Anzahl der Studentendatensätze wird berechnet. sind konsistent.

Vor- und Nachteile von Triggern

Die Vorteile von Triggern sind wie folgt:

Die Ausführung des Triggers erfolgt automatisch und wird sofort ausgeführt, nachdem die entsprechenden Änderungen an den Daten in der Trigger-bezogenen Tabelle vorgenommen wurden.
Trigger können komplexere Prüfungen und Operationen implementieren als FOREIGN KEY-Einschränkungen und CHECK-Einschränkungen.
Trigger können kaskadierende Änderungen an Tabellendaten implementieren und so die Datenintegrität bis zu einem gewissen Grad gewährleisten.

Die Nachteile von Triggern sind wie folgt:

Mithilfe von Triggern implementierte Geschäftslogik ist beim Auftreten von Problemen schwer zu finden, insbesondere wenn mehrere Trigger beteiligt sind, was eine spätere Wartung erschwert.
Der umfangreiche Einsatz von Triggern kann leicht die Codestruktur stören und die Komplexität des Programms erhöhen.
Wenn die zu ändernde Datenmenge groß ist, ist die Ausführungseffizienz des Triggers sehr gering.

Von MySQL unterstützte Trigger

Im tatsächlichen Einsatz unterstützt MySQL drei Trigger: INSERT-Trigger, UPDATE-Trigger und DELETE-Trigger.

1) INSERT-Trigger

Ein Trigger, der vor oder nach der Ausführung einer INSERT-Anweisung reagiert.

Bei der Verwendung von INSERT-Triggern müssen Sie die folgenden Punkte beachten:

Im INSERT-Triggercode kann auf eine virtuelle Tabelle mit dem Namen NEW (ohne Berücksichtigung der Groß-/Kleinschreibung) verwiesen werden, um auf die eingefügte Zeile zuzugreifen.
Im BEFORE INSERT-Trigger kann auch der Wert in NEW aktualisiert werden, wodurch der eingefügte Wert geändert werden kann (sofern er über die entsprechenden Betriebsberechtigungen verfügt).
Für die Spalte AUTO_INCREMENT enthält NEW den Wert 0, bevor INSERT ausgeführt wird, und enthält den neuen automatisch generierten Wert, nachdem INSERT ausgeführt wird.

2) UPDATE-Trigger

Ein Trigger, der vor oder nach der Ausführung einer UPDATE-Anweisung reagiert.

Bei der Verwendung von UPDATE-Triggern müssen Sie folgende Punkte beachten:

Im UPDATE-Triggercode kann auf eine virtuelle Tabelle mit dem Namen NEW (ohne Berücksichtigung der Groß-/Kleinschreibung) verwiesen werden, um auf den aktualisierten Wert zuzugreifen.
Im UPDATE-Triggercode kann auf eine virtuelle Tabelle mit dem Namen OLD (ohne Berücksichtigung der Groß-/Kleinschreibung) verwiesen werden, um auf den Wert zuzugreifen, bevor die UPDATE-Anweisung ausgeführt wurde.
In einem BEFORE UPDATE-Trigger kann auch der Wert in NEW aktualisiert werden, wodurch Änderungen am Wert in der UPDATE-Anweisung verwendet werden können (sofern Sie über die entsprechenden Betriebsberechtigungen verfügen).
Alle Werte in OLD sind schreibgeschützt und können nicht aktualisiert werden.

Hinweis: Wenn der Trigger so konzipiert ist, dass er den Aktualisierungsvorgang der Tabelle selbst auslöst, können nur Trigger vom Typ BEFORE verwendet werden. Trigger vom Typ AFTER sind nicht zulässig.

3) DELETE-Trigger

Ein Trigger, der vor oder nach der Ausführung einer DELETE-Anweisung reagiert.

Bei der Verwendung des DELETE-Triggers müssen Sie die folgenden Punkte beachten:

Im DELETE-Triggercode kann auf eine virtuelle Tabelle mit dem Namen OLD (ohne Berücksichtigung der Groß-/Kleinschreibung) verwiesen werden, um auf die gelöschten Zeilen zuzugreifen.
Alle Werte in OLD sind schreibgeschützt und können nicht aktualisiert werden.

Im Allgemeinen behandelt MySQL Fehler während der Triggerverwendung wie folgt.

Wenn bei Transaktionstabellen der Trigger fehlschlägt und infolgedessen die gesamte Anweisung fehlschlägt, werden alle von der Anweisung vorgenommenen Änderungen rückgängig gemacht; bei nicht transaktionalen Tabellen kann ein solches Rollback nicht durchgeführt werden, selbst wenn die Anweisung fehlschlägt. Alle vorherigen Änderungen werden weiterhin durchgeführt in Kraft sein.

Wenn der BEFORE-Trigger fehlschlägt, führt MySQL den Vorgang nicht für die entsprechende Zeile aus.

Wenn während der Ausführung eines BEFORE- oder AFTER-Triggers ein Fehler auftritt, schlägt die gesamte Anweisung, die den Trigger aufruft, fehl.

MySQL führt den AFTER-Trigger nur aus, wenn sowohl der BEFORE-Trigger als auch die Zeilenoperation erfolgreich ausgeführt wurden.

MySQL erstellt einen Trigger (CREATE TRIGGER)

Trigger sind Datenbankobjekte, die sich auf MySQL- Datentabellen beziehen. Sie werden ausgelöst, wenn definierte Bedingungen erfüllt sind, und führen die im Trigger definierten Anweisungen aus. Diese Funktion von Triggern kann Anwendungen dabei helfen, die Datenintegrität auf der Datenbankseite sicherzustellen.

Grundkenntnisse der MySQL-Datenbank, vollständige Übung https://edu.csdn.net/course/detail/36210

Grundgrammatik

In MySQL 5.7 können Trigger mit der CREATE TRIGGER-Anweisung erstellt werden.

Das Syntaxformat ist wie folgt:

CREATE <触发器名> < BEFORE | AFTER >
<INSERT | UPDATE | DELETE >
ON <表名> FOR EACH Row<触发器主体>

Die Syntax wird unten erklärt.

1) Triggername

Der Name des Triggers. Der Trigger muss in der aktuellen Datenbank einen eindeutigen Namen haben. Wenn Sie in einer bestimmten Datenbank erstellen, sollte dem Namen der Name der Datenbank vorangestellt werden.

2) EINFÜGEN | UPDATE | LÖSCHEN

Triggerereignis, das verwendet wird, um den Anweisungstyp anzugeben, der den Trigger aktiviert.

Hinweis: Die Ausführungszeiten der drei Trigger sind wie folgt.

INSERT: Trigger wird aktiviert, wenn eine neue Zeile in die Tabelle eingefügt wird. Beispielsweise kann der BEFORE-Trigger von INSERT nicht nur durch die INSERT-Anweisung von MySQL, sondern auch durch die LOAD DATA-Anweisung aktiviert werden.
DELETE: Trigger werden aktiviert, wenn eine Datenzeile aus der Tabelle gelöscht wird, z. B. DELETE- und REPLACE-Anweisungen.
UPDATE: Ein Trigger wird aktiviert, wenn eine Datenzeile in der Tabelle geändert wird, beispielsweise eine UPDATE-Anweisung.

3) VORHER | NACH

BEFORE und AFTER, der Moment, in dem der Trigger ausgelöst wird, geben an, ob der Trigger vor oder nach der Anweisung ausgelöst wird, die ihn aktiviert. Wenn Sie überprüfen möchten, ob die neuen Daten die Bedingungen erfüllen, verwenden Sie die Option BEFORE. Wenn Sie mehrere oder mehr Änderungen durchführen möchten, nachdem die Anweisung, die den Trigger aktiviert, ausgeführt wurde, verwenden Sie normalerweise die Option AFTER.

4) Tabellenname

Der Name der Tabelle, mit der der Trigger verknüpft ist. Diese Tabelle muss eine permanente Tabelle sein. Der Trigger kann keiner temporären Tabelle oder Ansicht zugeordnet werden. Der Trigger wird aktiviert, wenn ein Triggerereignis auf der Tabelle auftritt. Die gleiche Tabelle kann nicht zwei Trigger mit derselben Auslösezeit und demselben Ereignis enthalten. Beispielsweise kann es für eine Datentabelle nicht gleichzeitig zwei BEFORE UPDATE-Trigger geben, aber es kann einen BEFORE UPDATE-Trigger und einen BEFORE INSERT-Trigger oder einen BEFORE UPDATE-Trigger und einen AFTER UPDATE-Trigger geben.

5) Abzugskörper

Der Trigger-Aktionstext enthält die MySQL-Anweisung, die ausgeführt wird, wenn der Trigger aktiviert wird. Wenn Sie mehrere Anweisungen ausführen möchten, können Sie die zusammengesetzte Anweisungsstruktur BEGIN…END verwenden.

6) FÜR JEDE REIHE

Bezieht sich im Allgemeinen auf die Auslösung auf Zeilenebene, wobei die Auslöseraktion für jede vom auslösenden Ereignis betroffene Zeile aktiviert werden muss. Wenn Sie beispielsweise die INSERT-Anweisung verwenden, um mehrere Datenzeilen in eine Tabelle einzufügen, führt der Trigger entsprechende Triggeraktionen für jede eingefügte Datenzeile aus.

注意：每个表都支持 INSERT、UPDATE 和 DELETE 的 BEFORE 与 AFTER，因此每个表最多支持 6 个触发器。每个表的每个事件每次只允许有一个触发器。单一触发器不能与多个事件或多个表关联。

Wenn Sie in MySQL außerdem die vorhandenen Trigger in der Datenbank anzeigen müssen, können Sie die SHOW TRIGGERS-Anweisung verwenden.

Erstellen Sie einen Trigger vom Typ BEFORE

In der Datenbank test_db ist die Datentabelle tb_emp8 eine Mitarbeiterinformationstabelle, einschließlich der Felder „ID“, „Name“, „Abteilungs-ID“ und „Gehalt“. Die Tabellenstruktur der Datentabelle tb_emp8 ist wie folgt.

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)

[Beispiel 1] Erstellen Sie einen Trigger mit dem Namen SumOfSalary. Die Triggerbedingung besteht darin, die neu eingefügten Gehaltsfeldwerte zu summieren, bevor Daten in die Datentabelle tb_emp8 eingefügt werden. Die Eingabe-SQL-Anweisung und der Ausführungsprozess sind wie folgt.

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)

Nachdem der Trigger SumOfSalary erstellt wurde und ein Datensatz in die Tabelle tb_emp8 eingefügt wird, ändert sich der definierte Summenwert von 0 auf 1500, d. h. die Summe der eingefügten Werte 1000 und 500, wie unten gezeigt.

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)

Erstellen Sie einen Trigger vom Typ AFTER

In der test_db-Datenbank sind die Datentabellen tb_emp6 und tb_emp7 beide Mitarbeiterinformationstabellen, einschließlich der Felder „ID“, „Name“, „deptId“ und „Gehalt“. Die Tabellenstrukturen der Datentabellen tb_emp6 und tb_emp7 sind wie folgt.

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)

[Beispiel 2] Erstellen Sie einen Trigger mit dem Namen double_salary. Die Triggerbedingung besteht darin, dass nach dem Einfügen von Daten in die Datentabelle tb_emp6 dieselben Daten in die Datentabelle tb_emp7 eingefügt werden und das Gehalt 2 des neu eingefügten Gehaltsfeldwerts in tb_emp6 beträgt. mal. Die Eingabe-SQL-Anweisung und der Ausführungsprozess sind wie folgt.

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)

Nachdem der Trigger double_salary erstellt wurde und ein Datensatz in die Tabelle tb_emp6 eingefügt wird, wird derselbe Datensatz gleichzeitig in die Tabelle tb_emp7 eingefügt, und das Gehaltsfeld hat den doppelten Wert des Gehaltsfelds in tb_emp6, wie unten gezeigt.

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)

Dachang Senior Database Engineer MySQL-Datenbank-Praktikum https://edu.csdn.net/course/detail/39021