Der Einsatz von MySQL Triggern und worauf zu achten ist

Der Einsatz von MySQL Triggern und worauf zu achten ist

Über Trigger

In der realen Entwicklung begegnen wir dieser Situation häufig. Wenn wir beispielsweise Informationen hinzufügen, löschen oder ändern, müssen wir Protokolle aufzeichnen. Wir müssen nach Abschluss der regulären Datenbanklogikoperationen in die Protokolltabelle schreiben, was zu einer zweistufigen Operation wird und komplizierter ist.

Wenn Sie beispielsweise die Informationen einer Person löschen, müssen Sie auch deren Einkaufsaufzeichnungen, Lieferadresse, Favoriten usw. löschen. Dieser fortlaufende Vorgang ist fehleranfällig und Konsistenz und Integrität können nicht garantiert werden. Zu diesem Zeitpunkt sollten Trigger verwendet werden, wodurch nicht nur viel Geschäftslogikcode vermieden, sondern auch die Datenintegrität besser gewährleistet werden kann.

Ein Trigger ist ein Datenbankobjekt, das sich auf eine Tabelle bezieht: Es löst eine Aktion aus, wenn die definierten Bedingungen erfüllt sind, und führt die im Trigger definierte Anweisungsgruppe aus. Diese Triggerfunktion kann Anwendungen dabei helfen, die Datenintegrität auf der Datenbankseite sicherzustellen.

Es handelt sich um eine spezielle gespeicherte Prozedur, die mit einem Tabellenereignis verknüpft ist und aktiviert und ausgeführt wird, wenn ein Vorgang (Einfügen, Löschen, Aktualisieren) für eine Tabelle ausgeführt wird.

Verwendung von Triggern

Erstellen eines Triggers

Die Syntax zum Erstellen eines Triggers lautet wie folgt:

TRIGGER ERSTELLEN trigger_name trigger_time trigger_event ON t_name FÜR JEDE ZEILE trigger_stmt

veranschaulichen:

trigger_name: Name des Auslösers

tirgger_time: Zeitpunkt der Trigger-Ausführung, vor der Datenoperation (BEFORE) oder nach der Datenoperation (AFTER)

trigger_event: Ereignis auslösen, hinzufügen (INSERT), löschen (DELETE), ändern (UPDATE)

t_name: bezieht sich auf das Erstellen eines Triggers in der Tabelle t_name

trigger_stmt: Der Hauptteil des Triggers, der eine SQL-Anweisung oder mehrere Anweisungen sein kann, die von BEGIN und END umschlossen sind.

Trigger können nur auf permanenten Tabellen (Permanent) erstellt werden, nicht auf temporären Tabellen (Temporary)

FOR EACH ROW fester Ausdruck, der angibt, dass jede Operation an einem Datensatz, der das Triggerereignis erfüllt, den Trigger auslöst

Es gibt zwei Arten von Trigger_Time und drei Arten von Trigger_Event, also insgesamt 6 Kombinationen: BEFORE INSERT, BEFORE DELETE, BEFORE UPDATE, AFTER INSERT, AFTER DELETE, AFTER UPDATE

Beispiel (erstellen Sie zuerst eine Protokolltabelle, um den Wert einzutragen, wenn der Trigger ausgelöst wird):

/*Erstellen Sie zuerst eine Protokolltabelle, um den Wert einzutragen, wenn der Trigger ausgelöst wird*/
mysql> TABELLE DROP, WENN `TriggerLog` EXISTIERT;
Abfrage OK, 0 Zeilen betroffen

mysql> Tabelle „TriggerLog“ erstellen
(
  `id` INT auto_increment PRIMÄRSCHLÜSSEL,
  `trigger_time` VARCHAR(30),
  `trigger_event` VARCHAR(30),
  `memo` VARCHAR(200)
);
Abfrage OK, 0 Zeilen betroffen

Triggertyp einfügen:

MySQL>
/*Hier wird das Ende des SQL-Skripts als // */ deklariert.
TRENNUNGSZEICHEN //
TRIGGER LÖSCHEN, WENN EXISTIERT trig_after_insert;
Erstellen Sie einen Trigger „trig_after_insert“ nach dem Einfügen für Studenten für jede Zeile.
BEGINNEN
 in `TriggerLog`(`trigger_time`,`trigger_event`,`memo`) Werte einfügen ('nach','einfügen',concat('neue Studenteninfo,id:',cast(new.studentid as char)));
ENDE //
Abfrage OK, 0 Zeilen betroffen

MySQL>
/*Setzt das Ende des SQL-Skripts zurück auf; */
TRENNUNGSZEICHEN ;
Abfrage OK, 0 Zeilen betroffen

MySQL>
/*Fügen Sie ein Datenelement ein*/
in Studenten einfügen (Studentenname, Punktzahl, Klassen-ID) Werte ('Trigger1', 100,0);
Abfrage OK, 1 Zeile betroffen


MySQL>
/*Fragen Sie die Protokolltabelle ab, um zu sehen, ob ein Trigger-Schreibvorgang vorliegt*/
Wählen Sie * aus „TriggerLog“;
+----+--------------+------------------+------------------------+
| ID | Auslösezeit | Auslöseereignis | Memo |
+----+--------------+------------------+------------------------+
| 1 | nach | einfügen | Informationen zum neuen Studenten, ID:21 |
+----+--------------+------------------+------------------------+
1 Reihe im Set

Auslöser vom Aktualisierungstyp:

MySQL>
/*Hier wird das Ende des SQL-Skripts als // */ deklariert.
TRENNUNGSZEICHEN //
TRIGGER LÖSCHEN, WENN EXISTIERT, trig_after_update;
Erstellen Sie den Trigger „trig_after_update“ nach dem Update für Studenten für jede Zeile.
BEGINNEN
 in `TriggerLog`(`trigger_time`,`trigger_event`,`memo`) Werte einfügen ('nach', 'aktualisieren', concat('Studenteninfo aktualisieren, ID:', cast(new.studentid as char)));
ENDE //
Abfrage OK, 0 Zeilen betroffen

MySQL>
/*Setzt das Ende des SQL-Skripts zurück auf; */
TRENNUNGSZEICHEN ;
Abfrage OK, 0 Zeilen betroffen

MySQL>
/*Daten aktualisieren*/
Aktualisiere die Schüler, setze Punktzahl=99, wobei Schülername='Trigger1';
Abfrage OK, 1 Zeile betroffen
Übereinstimmende Zeilen: 1 Geändert: 1 Warnungen: 0

MySQL>
/*Frage die Protokolltabelle ab, um zu sehen, ob beim Aktualisieren ein Schreibtrigger vorliegt*/
Wählen Sie * aus „TriggerLog“;
+----+--------------+------------------+---------------------------+
| ID | Auslösezeit | Auslöseereignis | Memo |
+----+--------------+------------------+---------------------------+
| 1 | nach | einfügen | Informationen zum neuen Studenten, ID:21 |
| 2 | nach | aktualisieren | Studenteninfo aktualisieren, ID:21 |
+----+--------------+------------------+---------------------------+
2 Reihen im Set

Auslöser vom Typ „Löschen“:

MySQL>
/*Hier wird das Ende des SQL-Skripts als // */ deklariert.
TRENNUNGSZEICHEN //
TRIGGER LÖSCHEN, WENN EXISTIERT, trig_after_delete;
Erstellen Sie den Trigger „trig_after_delete“ nach dem Löschen für Studenten für jede Zeile.
BEGINNEN
 in `TriggerLog`(`trigger_time`,`trigger_event`,`memo`) Werte einfügen ('nach','aktualisieren',concat('Studenteninfo löschen,id:',cast(old.studentid as char)));
ENDE //
Abfrage OK, 0 Zeilen betroffen

MySQL>
/*Setzt das Ende des SQL-Skripts zurück auf; */
TRENNUNGSZEICHEN ;
Abfrage OK, 0 Zeilen betroffen

MySQL>
/* Daten löschen */
Löschen aus Studenten, bei denen Student-ID=21 ist;
Abfrage OK, 1 Zeile betroffen

MySQL>
/*Fragen Sie das Protokoll ab, um zu sehen, ob das Löschen einen Schreibvorgang auslöst*/
Wählen Sie * aus „TriggerLog“;
+----+--------------+------------------+---------------------------+
| ID | Auslösezeit | Auslöseereignis | Memo |
+----+--------------+------------------+---------------------------+
| 1 | nach | einfügen | Informationen zum neuen Studenten, ID:21 |
| 2 | nach | aktualisieren | Studenteninfo aktualisieren, ID:21 |
| 3 | nach | aktualisieren | löschen Studenteninfo,ID:21 |
+----+--------------+------------------+---------------------------+
3 Reihen im Set

Trigger anzeigen

Alle Trigger anzeigen

Auslöser anzeigen; --Syntax
mysql> Trigger anzeigen;
+-------------------+--------+----------+-------------------------------------------------------------------------------------------------------------------------------------------+--------+---------+--------------------------------------------+----------------+----------------------+---------------------+
| Auslöser | Ereignis | Tabelle | Anweisung | Zeitpunkt | Erstellt | SQL-Modus | Definierer | Zeichensatzclient | Sortierverbindung | Datenbanksortierung |
+-------------------+--------+----------+-------------------------------------------------------------------------------------------------------------------------------------------+--------+---------+--------------------------------------------+----------------+----------------------+---------------------+
| trig_after_insert | EINFÜGEN | Studenten | BEGINNEN
 in `TriggerLog`(`trigger_time`,`trigger_event`,`memo`) Werte einfügen ('nach','einfügen',concat('neue Studenteninfo,id:',cast(new.studentid as char)));
ENDE | NACH | NULL | STRICT_TRANS_TABLES,NO_ENGINE_SUBSTITUTION | root@localhost | utf8 | utf8_general_ci | latin1_swedish_ci |
| trig_after_update | UPDATE | Studenten | BEGINNEN
 in `TriggerLog`(`trigger_time`,`trigger_event`,`memo`) Werte einfügen ('nach', 'aktualisieren', concat('Studenteninfo aktualisieren, ID:', cast(new.studentid as char)));
ENDE | NACH | NULL | STRICT_TRANS_TABLES,NO_ENGINE_SUBSTITUTION | root@localhost | utf8 | utf8_general_ci | latin1_swedish_ci |
| trig_after_delete | LÖSCHEN | Studenten | BEGINNEN
 in `TriggerLog`(`trigger_time`,`trigger_event`,`memo`) Werte einfügen ('nach','aktualisieren',concat('Studenteninfo löschen,id:',cast(old.studentid as char)));
ENDE | NACH | NULL | STRICT_TRANS_TABLES,NO_ENGINE_SUBSTITUTION | root@localhost | utf8 | utf8_general_ci | latin1_swedish_ci |
+-------------------+--------+----------+-------------------------------------------------------------------------------------------------------------------------------------------+--------+---------+--------------------------------------------+----------------+----------------------+---------------------+
3 Reihen im Set

Zeigen Sie die Erstellungsanweisung des Triggers an

Trigger „Triggername“ erstellen anzeigen; --Syntax
mysql> Trigger „trig_after_insert“ anzeigen;
+-------------------+--------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------+----------------------+
| Trigger | SQL-Modus | Ursprüngliche SQL-Anweisung | Zeichensatzclient | Sortierverbindung | Datenbanksortierung |
+-------------------+--------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------+----------------------+
| trig_after_insert | STRICT_TRANS_TABLES,NO_ENGINE_SUBSTITUTION | CREATE DEFINER=`root`@`localhost` TRIGGER trig_after_insert NACH INSERT ON students FÜR JEDE ZEILE
BEGINNEN
 in `TriggerLog`(`trigger_time`,`trigger_event`,`memo`) Werte einfügen ('nach','einfügen',concat('neue Studenteninfo,id:',cast(new.studentid as char)));
ENDE | utf8 | utf8_general_ci | latin1_swedish_ci |
+-------------------+--------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------+----------------------+
1 Reihe im Set

Löschen eines Triggers

Auslöser löschen Auslösername; --Syntax
mysql> Trigger „trig_after_insert“ löschen;
Abfrage OK, 0 Zeilen betroffen
 
mysql> Trigger „trig_after_insert“ anzeigen;
1360 - Auslöser existiert nicht

Verwendungshinweise

Der Unterschied zwischen NEU und ALT

Der Trigger zielt auf jede Datensatzzeile in der Datenbank. Jede Datenzeile hat vor und nach der Operation einen entsprechenden Status. Der Trigger speichert den Status vor der Operation unter dem alten Schlüsselwort und den Status nach der Operation unter dem neuen Schlüsselwort.

 new.cname – eine Datenspalte in der neu hinzugefügten Zeile (oder der Zeile vor der Änderung) old.cname – eine Datenspalte in der gelöschten Zeile (oder der Zeile nach der Änderung)

Dabei ist zu beachten, dass nicht alle Trigger alt und neu sind.

Trigger-Typ Einsatz von Neuem und Altem
INSERT-Trigger Es gibt kein alt, nur neu, wobei neu die Daten sind, die hinzugefügt werden (vor dem Einfügen) oder hinzugefügt wurden (nach dem Einfügen).
UPDATE-Trigger Es gibt sowohl alt als auch neu. Alt stellt die Daten vor dem Update dar und neu stellt die Daten nach dem Update dar.
DELETE-Trigger Es gibt kein neu, nur alt. Alt kennzeichnet Daten, die demnächst gelöscht werden (vor dem Löschen) oder gelöscht wurden (nach dem Löschen).

Tatsächlich haben wir bereits new/old verwendet, um Trigger zu erstellen und Daten abzurufen. Lassen Sie uns den Update-Trigger (trig_after_update) basierend auf dieser Tabelle ändern und die Ausgabe vor und nach der Änderung vergleichen:

MySQL>
/*Hier wird das Ende des SQL-Skripts als // */ deklariert.
TRENNUNGSZEICHEN //
TRIGGER LÖSCHEN, WENN EXISTIERT, trig_after_update;
Erstellen Sie den Trigger „trig_after_update“ nach dem Update für Studenten für jede Zeile.
BEGINNEN
 in `TriggerLog`(`trigger_time`,`trigger_event`,`memo`) Werte einfügen ('nach','aktualisieren',concat('von:',alter.Studentenname',',',alter.Score' ','bis:',neuer.Studentenname',',',neuer.Score));
ENDE //
Abfrage OK, 0 Zeilen betroffen

MySQL>
/*Setzt das Ende des SQL-Skripts zurück auf; */
TRENNUNGSZEICHEN ;
Abfrage OK, 0 Zeilen betroffen

MySQL>
/*Noten und Namen aktualisieren*/
Aktualisiere die Studenten, setze Punktzahl=106,Studentenname='Trigger2', wobei Studenten-ID=17 ist;
Abfrage OK, 1 Zeile betroffen
Übereinstimmende Zeilen: 1 Geändert: 1 Warnungen: 0

MySQL>
/*Vergleiche die Werte vor und nach dem Update basierend auf Alt und Neu*/
Wählen Sie * aus „TriggerLog“;
+----+--------------+------------------+---------------------------------------+
| ID | Auslösezeit | Auslöseereignis | Memo |
+----+--------------+------------------+---------------------------------------+
| 1 | nach | einfügen | Informationen zum neuen Studenten, ID:21 |
| 2 | nach | aktualisieren | Studenteninfo aktualisieren, ID:21 |
| 3 | nach | aktualisieren | löschen Studenteninfo,ID:21 |
| 4 | nach | Update | von:Test2,101.00 bis:Trigger2,106.00 |
+----+--------------+------------------+---------------------------------------+
4 Reihen im Set

Änderungen an derselben Tabelle können nicht ausgelöst werden

Der MySQL-Trigger kann für diese Tabelle keine Einfüge-, Aktualisierungs- oder Löschvorgänge durchführen, andernfalls wird ein Fehler gemeldet.

MySQL>
/*Hier wird das Ende des SQL-Skripts als // */ deklariert.
TRENNUNGSZEICHEN //
TRIGGER LÖSCHEN, WENN EXISTIERT trig_after_insert;
Erstellen Sie einen Trigger „trig_after_insert“ nach dem Einfügen für Studenten für jede Zeile.
BEGINNEN
 Aktualisiere die Punktzahl der Studenten, setze sie = Punktzahl+1, wobei Studenten-ID = neue Studenten-ID;
ENDE //
Abfrage OK, 0 Zeilen betroffen

MySQL>
/*Setzt das Ende des SQL-Skripts zurück auf; */
TRENNUNGSZEICHEN ;
Abfrage OK, 0 Zeilen betroffen

MySQL>
/*Nach dem Einfügen eines Datenelements wird ein Fehler gemeldet, da die Änderung dieser Tabelle ausgelöst wird*/
in Studenten einfügen (Studentenname, Punktzahl, Klassen-ID) Werte ('Trigger2', 101,0);
1442 – Tabelle „Studenten“ kann in der gespeicherten Funktion/dem gespeicherten Trigger nicht aktualisiert werden, da sie bereits von der Anweisung verwendet wird, die diese gespeicherte Funktion/diesen gespeicherten Trigger aufgerufen hat.

Zusammenfassung

1. Trigger können kaskadierende Änderungen über zugehörige Tabellen in der Datenbank implementieren, d. h. Änderungen an den Daten in einer Tabelle wirken sich auf die Daten in anderen Tabellen aus, z. B. Datenänderungen, Datenstatistiken, Datenreplikation usw.
2. Es kann die Datensicherheit gewährleisten, Sicherheitsüberprüfungen durchführen und die Rechte der Benutzer zum Betrieb der Datenbank einschränken.
3. Bei der Implementierung komplexer Logik können Datenintegritätsprüfungen und -einschränkungen durchgeführt werden.
4. Trigger sollten nur bei Bedarf verwendet werden. Wenn Sie sich zu sehr auf Trigger verlassen, wirkt sich dies auf die Struktur der Datenbank aus und erhöht die Ausführungs- und Wartungskosten der Datenbank.
5. Trigger werden in BEFORE-Trigger und AFTER-Trigger unterteilt. Die Ausführungsschritte bestehen daher darin, zuerst den BEFORE-Trigger auszuführen, dann das Geschäftsskript auszuführen und schließlich den AFTER-Trigger auszuführen. Es ist zu beachten, dass ein fehlgeschlagener Schritt nicht mehr ausgeführt wird. Handelt es sich um eine Transaktionstabelle, wird ein Rollback durchgeführt. Handelt es sich um eine Nicht-Transaktionstabelle, kann kein Rollback durchgeführt werden und die Daten können inkonsistent sein.

Zwei Einschränkungen von Triggern

1. Trigger können weder gespeicherte Prozeduren aufrufen, die Daten an den Client zurückgeben, noch dynamische SQL-Anweisungen verwenden, die die CALL-Anweisung verwenden. Gespeicherte Prozeduren dürfen jedoch Daten über Parameter an Trigger zurückgeben. Das heißt, gespeicherte Prozeduren oder Funktionen können Daten über Parameter vom Typ OUT oder INOUT an Trigger zurückgeben, aber Prozeduren, die Daten direkt zurückgeben, können nicht aufgerufen werden.
2. Anweisungen, die Transaktionen explizit oder implizit starten oder beenden, wie etwa START TRANS-ACTION, COMMIT oder ROLLBACK, können in Triggern nicht verwendet werden.

Oben finden Sie detaillierte Informationen zur Verwendung von MySQL-Triggern und den Dingen, die beachtet werden müssen. Weitere Informationen zu MySQL-Triggern finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!

Das könnte Sie auch interessieren:
  • Detaillierte Erklärung des MySQL-Triggerbeispiels
  • Einführung und Verwendung von Triggern und Cursorn in MySQL
  • Verwendung und Verständnis von MySQL-Triggern
  • So verwenden Sie Cursor-Trigger in MySQL
  • MySQL-Trigger-Verwendungsszenarien und Methodenbeispiele
  • Detaillierte Erklärung der MySQL-Datenbank-Trigger
  • Eine kurze Diskussion über MySql-Ansichten, Trigger und gespeicherte Prozeduren
  • Beispiele für die Erstellung und Verwendung von MySQL-Triggern
  • Detaillierte Erklärung der grundlegenden Verwendung von MySQL-Triggern [Erstellen, Anzeigen, Löschen usw.]
  • Verwendung von MySQL-Triggern

<<:  Beispiel für die Verwendung von CSS zum Erzielen eines halbtransparenten Hintergrunds und undurchsichtigen Textes

>>:  js zum Implementieren von Details im Datei-Upload-Stil

Artikel empfehlen

5 grundlegende Fähigkeiten zum Design von Themenseiten (Alibaba UED Shanmu)

Bei diesem Thema handelt es sich um einen interne...

Miniprogramm zur Implementierung der Sieve-Lotterie

In diesem Artikelbeispiel wird der spezifische Co...

Was ist WML?

WML (Wireless Markup Language). Es handelt sich u...

Umfassendes Verständnis der Node-Ereignisschleife

Inhaltsverzeichnis Knoten-Ereignisschleife Ereign...

Detaillierte Erklärung der Grundkonzepte von HTML

Was ist HTML? HTML ist eine Sprache zur Beschreib...

So migrieren Sie SQLite zu einem MySQL-Skript

Ohne weitere Umschweife werde ich den Code direkt...

Implementierung des Nginx-Proxy-Ports 80 bis Port 443

Die Konfigurationsdatei nginx.conf lautet wie fol...

MySQL-Startfehlerproblem und Szenarioanalyse

1. Komplettlösung 1. Problemanalyse und -lokalisi...

So extrahieren Sie Zeichenfolgenelemente aus nicht festen Positionen in MySQL

Vorwort Hinweis: Die Testdatenbankversion ist MyS...

Docker-Containerüberwachung und Protokollverwaltung – Implementierungsprozessanalyse

Wenn der Umfang der Docker-Bereitstellung zunimmt...

Detaillierte Erklärung zur Verwendung von Docker-Compose-Befehlen

Sie können Docker-Container auf verschiedene Arte...

Web-Theorie: Bringen Sie mich nicht zum Nachdenken über Lesehinweise

Kapitel 1 <br />Das wichtigste Prinzip, um ...

Bidirektionale verknüpfte Liste der JavaScript-Datenstruktur

Eine einfach verkettete Liste kann nur vom Anfang...

Erstellen Sie ein Codebeispiel für ein Zabbix-Überwachungssystem basierend auf Dockerfile

Verwenden Sie die For-Schleife, um das Zabbix-Ima...

Teilen einiger wunderbarer Verwendungsmöglichkeiten von wxs-Dateien im WeChat-Applet

Inhaltsverzeichnis Vorwort Anwendung Filter Ziehe...