MySQL-Trigger: Beispielanalyse zum Erstellen mehrerer Trigger

Dieser Artikel beschreibt anhand eines Beispiels die Erstellung mehrerer Triggeroperationen in MySQL. Teilen Sie uns die Einzelheiten zu Ihrer Information mit:

Die diesmal aufgezeichnete MySQL-Version muss 5.7.2+ sein, frühere Versionen funktionieren nicht. Lassen Sie uns ohne weitere Umschweife loslegen.

Vor MySQL 5.7.2+ konnten wir nur einen Trigger für ein Ereignis in einer Tabelle erstellen, beispielsweise konnten wir nur einen Trigger für ein BEFORE UPDATE- oder AFTER UPDATE-Ereignis erstellen. MySQL-Versionen ab 5.7.2 beheben diese Einschränkung und ermöglichen uns, mehrere Trigger für dasselbe Ereignis und denselben Aktionszeitpunkt in einer Tabelle zu erstellen. Wenn Ereignisse eintreten, werden Auslöser nacheinander aktiviert. Sehen wir uns die Syntax beim Erstellen des ersten Triggers an. Wenn es für eine Tabelle mehrere Trigger für dasselbe Ereignis gibt, ruft MySQL die Trigger in der Reihenfolge auf, in der sie erstellt werden. Um die Reihenfolge der Auslöser zu ändern, geben Sie nach der FOR EACH ROW-Klausel FOLLOWS oder PRECEDES an. Schauen wir uns die Erklärung dieser beiden Wörter an:

• Mit der Option FOLLOWS können neue Trigger nach vorhandenen Triggern aktiviert werden.
• Mit der Option PRECEDES können neue Trigger vor vorhandenen Triggern aktiviert werden.

Schauen wir uns abschließend die Syntax zum Erstellen eines neuen zusätzlichen Triggers mit einem expliziten Befehl an:

TRENNUNGSZEICHEN $$
CREATE TRIGGER Triggername
[VORHER|NACHHER] [EINFÜGEN|AKTUALISIEREN|LÖSCHEN] ON Tabellenname
FÜR JEDE ZEILE [FOLGT | GEHT VORHER] vorhandener_Triggername
BEGINNEN
…
ENDE$$
TRENNUNGSZEICHEN ;

Sehen wir uns als Nächstes ein Beispiel für die Erstellung mehrerer Trigger für dasselbe Ereignis und dieselbe Aktion in einer Tabelle an. Lassen Sie uns dies anhand der Produkttabelle demonstrieren. Erstellen Sie zunächst eine neue Tabelle „price_logs“. Wenn der Preis eines Produkts (Spalte „MSRP“) geändert wird, sollte der alte Preis in einer Tabelle namens „price_logs“ aufgezeichnet werden. Werfen wir einen Blick auf das SQL:

Tabelle Preisprotokolle erstellen (
 id INT(11) NOT NULL AUTO_INCREMENT,
 Produktcode VARCHAR (15) NICHT NULL,
 Preis DOUBLE NOT NULL,
 updated_at ZEITSTEMPEL NICHT NULL STANDARD 
       AKTUELLER ZEITSTEMPEL 
       BEIM UPDATE CURRENT_TIMESTAMP,
 Primärschlüssel (ID),
 SCHLÜSSEL Produktcode (Produktcode),
 CONSTRAINT price_logs_ibfk_1 Fremdschlüssel (Produktcode) 
 REFERENZEN Produkte (Produktcode) 
 BEIM LÖSCHEN KASKADE 
 Bei Update-Kaskade
);

Das ist alles. Erstellen Sie einen neuen Trigger, wenn das BEFORE UPDATE-Ereignis der Tabelle eintritt. Der Triggername lautet before_products_update und die konkrete Implementierung ist wie folgt:

TRENNUNGSZEICHEN $$
TRIGGER ERSTELLEN vor_Produktaktualisierung 
  VOR DEM UPDATE ZU PRODUKTEN 
  FÜR JEDE REIHE 
BEGINNEN
   INSERT INTO Preisprotokolle(Produktcode, Preis)
   WERTE(alter.Produktcode,alter.UVP);
ENDE$$
TRENNUNGSZEICHEN ;

Wenn wir dann den Preis eines Produkts ändern, verwenden wir die folgende Update-Anweisung und fragen abschließend die Tabelle price_logs ab:

UPDATE Produkte
SET UVP = 95,1
WO Produktcode = 'S10_1678';
--Abfrageergebnis-Preisdatensätze SELECT * FROM price_logs;

Nach der Ausführung der obigen Abfrageanweisung werden die folgenden Ergebnisse erhalten:

+----+--------------+----------+---------------------+
| ID | Produktcode | Preis | aktualisiert am |
+----+--------------+----------+---------------------+
| 1 | S10_1678 | 95,7 | 03.08.2017 02:46:42 |
+----+--------------+----------+---------------------+
1 Reihe im Set

Wie Sie an den Ergebnissen sehen können, funktioniert es wie erwartet.

Nun nehmen wir an, dass wir nicht nur den alten Preis sehen möchten, sondern auch festhalten möchten, wer diesen bei der Änderung modifiziert hat. Um dies zu erreichen, könnten wir der Tabelle „price_logs“ zusätzliche Spalten hinzufügen. Um jedoch mehrere Auslöser zu demonstrieren, erstellen wir eine neue Tabelle, um Daten über den Benutzer zu speichern, der die Änderungen vorgenommen hat. Der Name dieser neuen Tabelle lautet user_change_logs und ihre Struktur ist wie folgt:

Tabelle „user_change_logs“ erstellen (
 id int(11) NICHT NULL AUTO_INCREMENT,
 Produktcode varchar (15) DEFAULT NULL,
 updated_at Zeitstempel NICHT NULL STANDARD CURRENT_TIMESTAMP 
 BEIM UPDATE CURRENT_TIMESTAMP,
 aktualisiert_durch varchar(30) NICHT NULL,
 Primärschlüssel (ID),
 SCHLÜSSEL Produktcode (Produktcode),
 CONSTRAINT user_change_logs_ibfk_1 Fremdschlüssel (Produktcode) 
 REFERENZEN Produkte (Produktcode) 
 BEIM LÖSCHEN KASKADE BEIM AKTUALISIEREN KASKADE
);

Jetzt erstellen wir einen zweiten Trigger, der beim BEFORE UPDATE-Ereignis in der Produkttabelle aktiviert wird. Dieser Trigger aktualisiert die geänderten Benutzerinformationen in der Tabelle „user_change_logs“. Es wird aktiviert, nachdem before_products_update ausgelöst wurde:

TRENNUNGSZEICHEN $$
TRIGGER ERSTELLEN before_products_update_2 
  VOR DEM UPDATE ZU PRODUKTEN 
  FÜR JEDE ZEILE FOLGT before_products_update
BEGINNEN
  INSERT INTO user_change_logs(Produktcode, aktualisiert von)
  WERTE(alter.Produktcode,Benutzer());
ENDE$$
TRENNUNGSZEICHEN ;

Anschließend verwenden wir die Update-Anweisung, um den Preis des angegebenen Produkts zu aktualisieren:

UPDATE Produkte
SET UVP = 95,3
WO Produktcode = 'S10_1678';

Als Nächstes fragen Sie Daten aus den Tabellen „price_logs“ und „user_change_logs“ ab:

mysql> AUSWÄHLEN * VON Preisprotokollen;
+----+--------------+----------+---------------------+
| ID | Produktcode | Preis | aktualisiert am |
+----+--------------+----------+---------------------+
| 1 | S10_1678 | 95,7 | 03.08.2017 02:46:42 |
| 2 | S10_1678 | 95,1 | 03.08.2017 02:47:21 |
+----+--------------+----------+---------------------+
2 Reihen im Set
mysql> AUSWÄHLEN * AUS Benutzeränderungsprotokollen;
+----+--------------+---------------------+----------------+
| ID | Produktcode | aktualisiert am | aktualisiert von |
+----+--------------+---------------------+----------------+
| 1 | S10_1678 | 03.08.2017 02:47:21 | root@localhost |
+----+--------------+---------------------+----------------+
1 Reihe im Set

Wie Sie oben sehen können, werden die beiden Auslöser in der erwarteten Reihenfolge aktiviert, um die zugehörigen Vorgänge auszuführen. Sehen wir uns nun die Spalte „action_order“ in der Tabelle „triggers“ der Datenbank „information_schema“ an, um die Reihenfolge anzuzeigen, in der dasselbe Ereignis und dieselbe Aktion ausgelöst werden:

mysql> AUSWÄHLEN 
  Triggername, Aktionsreihenfolge
AUS
  information_schema.triggers
WO
  trigger_schema = "yiibaidb"
ORDER BY Ereignisobjekttabelle, 
     Aktionszeitpunkt, 
     Ereignismanipulation;
+--------------------------+--------------+
| Auslösername | Aktionsreihenfolge |
+--------------------------+--------------+
| vor_Mitarbeiteraktualisierung | 1 |
| vor_Produktaktualisierung | 1 |
| vor_Produktupdate_2 | 2 |
+--------------------------+--------------+
3 Reihen im Set

Okay, das ist alles zu diesem Eintrag.

Leser, die an weiteren MySQL-bezogenen Inhalten interessiert sind, können sich die folgenden Themen auf dieser Site ansehen: „MySQL-Abfragekenntnisse“, „MySQL-Transaktionsoperationskenntnisse“, „MySQL-gespeicherte Prozedurkenntnisse“, „Zusammenfassung der Kenntnisse zu MySQL-Datenbanksperren“ und „Zusammenfassung der allgemeinen MySQL-Funktionen“.

Ich hoffe, dass dieser Artikel für jedermann beim Entwurf einer MySQL-Datenbank hilfreich ist.