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

Grafisches Tutorial zur Installation und Konfiguration von MySQL 8.0.15 sowie zur Kennwortänderung unter Linux

Ich habe diesen Blog geschrieben, um mich daran z...

HTML-adaptives Layout links, zentriert und rechts (mithilfe des Calc-CSS-Ausdrucks)

Im neuesten HTML-Standard gibt es einen Calc-CSS-A...

CentOS 8.0.1905 installiert ZABBIX Version 4.4 (verifiziert)

Zabbix Server-Umgebungsplattform Version: ZABBIX ...

Detaillierte Erklärung der TMPF-Mounts im Docker-Datenspeicher

Bevor Sie diesen Artikel lesen, hoffe ich, dass S...

Lösung für 1067, wenn Mysql in Windows startet

Ich habe erst vor ein paar Tagen mit der Arbeit b...

MySQL implementiert eine Beispielmethode zum Anmelden ohne Kennwort

Spezifische Methode: Schritt 1: Stoppen Sie den M...

So verwenden Sie die Verlaufsumleitung in React Router

In react-router kann der Sprung in der Komponente...

So fügen Sie schnell 10 Millionen Datensätze in MySQL ein

Ich habe gehört, dass es eine Interviewfrage gibt...

Analyse der Unfallursachen durch Unicode-Signatur BOM

Möglicherweise verwenden Sie hier Include-Dateien,...

Implementieren Sie eine MaterialUI-Button-Klickanimation auf Basis von CSS und kapseln Sie sie in eine React-Komponente ein.

Vorwort Als intensiver Benutzer von Front-End-Fra...

Erfahrung in der Gestaltung einer mehrschichtigen Benutzeroberfläche im Webdesign

Viele Internetnutzer fragen sich oft, warum ihre W...

Der Unterschied zwischen useEffect und useLayoutEffect in React

Inhaltsverzeichnis Voraussetzungen Effekt verwend...

JavaScript fügt Prototyp-Methodenimplementierung für integrierte Objekte hinzu

Die Reihenfolge, in der Objekte Methoden aufrufen...

Detaillierte Erklärung zur Verwendung von Eslint in Vue

Inhaltsverzeichnis 1. Beschreibung 2. Laden Sie d...

So bereinigen Sie schnell Milliarden von Daten in einer MySQL-Datenbank

Heute habe ich eine Festplattenalarm-Ausnahme erh...