Verwalten und Verwenden von MySQL-Datenbank-Triggern unter Ubuntu 18.04

Der Autor hat die Apache Software Foundation dazu ausgewählt, im Rahmen des Programms Write for DOnations eine Spende zu erhalten.

Einführung

In MySQL ist ein trigger ein benutzerdefinierter SQL-Befehl, der während eines INSERT-, DELETE- oder UPDATE-Vorgangs automatisch aufgerufen wird. Der Triggercode ist mit einer Tabelle verbunden und wird nach dem Verwerfen einer Tabelle zerstört. Sie können eine Triggeraktionszeit festlegen und bestimmen, ob die Triggeraktion vor oder nach dem definierten Datenbankereignis ausgelöst werden soll.

Trigger bieten verschiedene Vorteile. Sie können sie beispielsweise verwenden, um bei einer INSERT-Anweisung den Wert einer abgeleiteten Spalte zu generieren. Ein weiterer Anwendungsfall ist die Durchsetzung der referenziellen Integrität, wo Sie einen Trigger verwenden können, um einen Eintrag in mehreren verknüpften Tabellen zu speichern. Weitere Vorteile sind die Protokollierung von Benutzeraktionen in Prüftabellen sowie das Live-Kopieren von Daten in verschiedenen Datenbankschemata für Redundanzzwecke, um einzelne Ausfallpunkte (Single Points of Failure) zu verhindern.

Sie können Trigger außerdem verwenden, um Validierungsregeln auf der Datenbankebene zu pflegen. So können Sie die Datenquelle in mehreren Anwendungen freigeben, ohne die Geschäftslogik zu stören. Dadurch werden Roundtrips zum Datenbankserver stark reduziert, was die Antwortzeit Ihrer Anwendungen verbessert. Da der Datenbankserver Trigger ausführt, können Sie auch optimierte Serverressourcen wie RAM und CPU nutzen.

In diesem Tutorial erstellen, verwenden und löschen Sie verschiedene Arten von Triggern in Ihrer MySQL-Datenbank.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:

• Einen Ubuntu 18.04-Server, der gemäß Ersteinrichtung eines Servers unter Ubuntu 18.04 eingerichtet wurde, einschließlich eines sudo non-root users.
• Eine MySQL-Datenbank, die ausgeführt wird durch folgenden Schritt: Installieren von MySQL unter Ubuntu 18.04
• Erstellen Sie für Ihre MySQL-Datenbank Kontoanmeldeinformationen für einen root user.

Schritt 1 — Erstellen einer Beispieldatenbank

In diesem Schritt erstellen Sie eine exemplarische Kundendatenbank mit mehreren Tabellen, um zu sehen, wie MySQL-Trigger funktionieren.

Wenn Sie mehr über MySQL-Abfragen wissen möchten, lesen Sie unsere Einführung zu Abfragen in MySQL.

Melden Sie sich zunächst als root user bei Ihrem MySQL-Server an:

mysql -u root -p

Geben Sie auf Aufforderung Ihr MySQL-Root-Passwort ein und drücken Sie zum Fortfahren die Eingabetaste. Wenn Sie die Eingabeaufforderung mysql> sehen, führen Sie folgenden Befehl aus, um eine test_db-Datenbank zu erstellen:

Create database test_db;

Output
Query OK, 1 row affected (0.00 sec)

Wechseln Sie als Nächstes zu test_db mit:

Use test_db;

Output
Database changed

Sie erstellen zunächst eine Tabelle namens customers. Diese Tabelle wird die Datensätze von Kunden enthalten, einschließlich customer_id, customer_name und level. Es wird zwei Kundenlevel geben: BASIC und VIP.

Create table customers(customer_id BIGINT PRIMARY KEY, customer_name VARCHAR(50), level VARCHAR(50) ) ENGINE=INNODB;

Output
Query OK, 0 rows affected (0.01 sec)

Fügen Sie nun der Tabelle customers ein paar Einträge hinzu. Führen Sie dazu nacheinander folgende Befehle aus:

Insert into customers (customer_id, customer_name, level )values('1','JOHN DOE','BASIC');
Insert into customers (customer_id, customer_name, level )values('2','MARY ROE','BASIC');
Insert into customers (customer_id, customer_name, level )values('3','JOHN DOE','VIP');

Sie erhalten nach dem Ausführen der einzelnen INSERT-Befehle folgende Ausgabe:

Output
Query OK, 1 row affected (0.01 sec)

Um zu überprüfen, ob die Beispieleinträge erfolgreich eingefügt wurden, führen Sie den Befehl SELECT aus:

Select * from customers;

Output
+-------------+---------------+-------+
| customer_id | customer_name | level |
+-------------+---------------+-------+
|           1 | JOHN DOE      | BASIC |
|           2 | MARY ROE      | BASIC |
|           3 | JOHN DOE      | VIP   |
+-------------+---------------+-------+
3 rows in set (0.00 sec)

Außerdem erstellen Sie eine weitere Tabelle, um entsprechende Informationen über das Konto customers zu speichern. Die Tabelle wird über die Felder customer_id und status_notes verfügen.

Führen Sie den folgenden Befehl aus:

Create table customer_status(customer_id BIGINT PRIMARY KEY, status_notes VARCHAR(50)) ENGINE=INNODB;

Als Nächstes erstellen Sie eine Tabelle namens sales (Verkäufe). In dieser Tabelle werden über die Spalte customer_id Verkaufsdaten für die verschiedenen Kunden gespeichert:

Create table sales(sales_id BIGINT PRIMARY KEY, customer_id BIGINT, sales_amount DOUBLE ) ENGINE=INNODB;

Output
Query OK, 0 rows affected (0.01 sec)

In den nächsten Schritten fügen Sie den sales-Daten beim Testen der Trigger Beispieldaten hinzu. Als Nächstes erstellen Sie eine Tabelle namens audit_log, um an der Tabelle sales vorgenommene Aktualisierungen zu protokollieren, wenn Sie den Trigger AFTER UPDATE in Schritt 5 implementieren:

Create table audit_log(log_id BIGINT PRIMARY KEY AUTO_INCREMENT, sales_id BIGINT, previous_amount DOUBLE, new_amount DOUBLE, updated_by VARCHAR(50), updated_on DATETIME ) ENGINE=INNODB;

Output
Query OK, 0 rows affected (0.02 sec)

Nachdem Sie über die Datenbank test_db und die vier Tabellen verfügen, fahren Sie nun mit den verschiedenen MySQL-Triggern in Ihrer Datenbank fort.

Schritt 2 — Erstellen eines Before Insert-Triggers

In diesem Schritt prüfen Sie die Syntax eines MySQL-Triggers, bevor Sie diese Logik anwenden, um einen BEFORE INSERT-Trigger zu erstellen, der das Feld sales_amount beim Einfügen von Daten in die Tabelle sales validiert.

Die allgemeine Syntax zum Erstellen eines MySQL-Triggers wird im folgenden Beispiel gezeigt:

DELIMITER //
CREATE TRIGGER [TRIGGER_NAME]
[TRIGGER TIME] [TRIGGER EVENT]
ON [TABLE]
FOR EACH ROW
[TRIGGER BODY]//
DELIMITER ;

Die Struktur des Triggers umfasst:

DELIMITER //: Das Standardtrennzeichen von MySQL ist ; – es ist notwendig, das Zeichen zu ändern, wenn MySQL folgende Zeilen als einen Befehl behandeln soll, bis er auf Ihr benutzerdefiniertes Trennzeichen trifft. In diesem Beispiel wird das Trennzeichen in // geändert und das Trennzeichen ; wird am Ende neu definiert.

[TRIGGER_NAME]: Ein Trigger muss einen Namen haben; hier schließen Sie den Wert ein.

[TRIGGER TIME]: Ein Trigger kann zu verschiedenen Zeitpunkten aufgerufen werden. Mit MySQL können Sie definieren, ob der Trigger vor oder nach der Datenbankoperation gestartet werden soll.

[TRIGGER EVENT]: Trigger werden nur von INSERT-, UPDATE- und DELETE-Operationen aufgerufen. Sie können hier einen beliebigen Wert verwenden, je nach dem, was Sie erreichen möchten.

[TABLE]: Jeder Trigger, den Sie in der MySQL-Datenbank erstellen, muss mit einer Tabelle verknüpft werden.

FOR EACH ROW: Diese Anweisung informiert MySQL, dass der Triggercode für jede Zeile ausgeführt werden soll, auf die sich der Trigger auswirkt.

[TRIGGER BODY]: Der Code, der beim Aufruf des Triggers ausgeführt wird, wird als Trigger Body bezeichnet. Dabei kann es sich um eine einzelne SQL-Anweisung oder mehrere Befehle handeln. Hinweis: Wenn Sie mehrere SQL-Anweisungen auf den Trigger Body ausführen, müssen Sie diese zwischen einem BEGIN... END-Block einschließen.

Nun erstellen Sie Ihren ersten BEFORE INSERT-Trigger. Dieser Trigger wird mit der Tabelle sales verbunden und aufgerufen, bevor ein Eintrag eingefügt wird, um die Verkaufssumme (sales_amount) zu validieren. Aufgabe des Triggers ist es zu prüfen, ob die in die Umsatztabelle eingefügte Verkaufssumme (sales_amount) höher als 10000 ist und einen Fehler ergeben soll, wenn zu true ausgewertet wird.

Stellen Sie sicher, dass Sie beim MySQL-Server angemeldet sind. Geben Sie dann nacheinander folgende MySQL-Befehle ein:

DELIMITER //
CREATE TRIGGER validate_sales_amount
BEFORE INSERT
ON sales
FOR EACH ROW
IF NEW.sales_amount>10000 THEN
SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'Sale has exceeded the allowed amount of 10000.';
END IF//
DELIMITER ;

Sie verwenden die IF... THEN... END IF-Anweisung, um auszuwerten, ob die bei der INSERT-Anweisung bereitgestellte Summe innerhalb Ihres Bereichs liegt. Der Trigger kann den neu bereitgestellten Wert von sales_amount durch Verwendung des Schlüsselworts NEW extrahieren.

Zum Ausgeben einer generischen Fehlermeldung verwenden Sie folgende Zeilen, um den Benutzer über den Fehler zu informieren:

SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'Sale has exceeded the allowed amount of 10000.';

Als Nächstes fügen Sie einen Eintrag mit der Verkaufssumme (sales_amount) 11000 zur Tabelle sales hinzu, um zu überprüfen, ob der Trigger die Operation stoppen wird:

Insert into sales(sales_id, customer_id, sales_amount) values('1','1','11000');

Output
ERROR 1644 (45000): Sale has exceeded the allowed amount of 10000.

Dieser Fehler zeigt, dass der Triggercode wie erwartet funktioniert.

Probieren Sie es nun mit einem neuen Eintrag, der den Wert 7500 hat, um zu überprüfen, ob der Befehl erfolgreich ausgeführt wird:

Insert into  sales(sales_id, customer_id, sales_amount) values('1','1','7500');

Da der Wert im empfohlenen Bereich liegt, sehen Sie die folgende Ausgabe:

Output
Query OK, 1 row affected (0.01 sec)

Um zu überprüfen, ob die Daten eingefügt wurden, führen Sie folgenden Befehl aus:

Select * from sales;

Die Ausgabe zeigt, dass sich die Daten in der Tabelle befinden:

Output
+----------+-------------+--------------+
| sales_id | customer_id | sales_amount |
+----------+-------------+--------------+
|        1 |           1 |         7500 |
+----------+-------------+--------------+
1 row in set (0.00 sec)

In diesem Schritt haben Sie Trigger getestet, um Daten zu validieren, bevor sie in eine Datenbank eingefügt werden.

Als Nächstes verwenden Sie den AFTER INSERT-Trigger, um verwandte Daten in verschiedene Tabellen zu speichern.

Schritt 3 — Erstellen eines After Insert-Triggers

AFTER INSERT-Trigger werden ausgeführt, wenn Einträge erfolgreich in eine Tabelle eingefügt werden. Diese Funktion kann dazu dienen, andere geschäftliche Logiken automatisch auszuführen. In einer Bankanwendung kann beispielsweise ein AFTER INSERT-Trigger ein Kreditkonto schließen, sobald ein Kunde seinen Kredit abbezahlt hat. Der Trigger kann alle in eine Transaktionstabelle eingefügten Zahlungen überwachen und den Kredit automatisch schließen, sobald das Kreditsaldo null beträgt.

In diesem Schritt arbeiten Sie mit der Tabelle customer_status und verwenden einen AFTER INSERT-Trigger, um verwandte Kundeneinträge einzugeben.

Um den AFTER INSERT-Trigger zu erstellen, geben Sie folgende Befehle ein:

DELIMITER //
CREATE TRIGGER customer_status_records
AFTER INSERT
ON customers
FOR EACH ROW
Insert into customer_status(customer_id, status_notes) VALUES(NEW.customer_id, 'ACCOUNT OPENED SUCCESSFULLY')//
DELIMITER ;

Output
Query OK, 0 rows affected (0.00 sec)

Hier weisen Sie MySQL an, einen weiteren Eintrag in der Tabelle customer_status zu speichern, sobald ein neuer Kundendateneintrag in die Tabelle customers eingefügt wird.

Fügen Sie nun einen neuen Eintrag in die Tabelle customers ein, um zu bestätigen, dass Ihr Triggercode aufgerufen wird:

Insert into customers (customer_id, customer_name, level )values('4','DAVID DOE','VIP');

Output
Query OK, 1 row affected (0.01 sec)

Nachdem der Eintrag erfolgreich eingefügt wurde, überprüfen Sie, ob in die Tabelle customer_status ein neuer Statuseintrag eingefügt wurde:

Select * from customer_status;

Output
+-------------+-----------------------------+
| customer_id | status_notes                |
+-------------+-----------------------------+
|           4 | ACCOUNT OPENED SUCCESSFULLY |
+-------------+-----------------------------+
1 row in set (0.00 sec)

Die Ausgabe zeigt, dass der Trigger erfolgreich ausgeführt wurde.

Der AFTER INSERT-Trigger hilft dabei, den Lebenszyklus eines Kunden zu überwachen. In einer Produktionsumgebung können Konten von Kunden verschiedene Stufen durchlaufen, wie Eröffnen, Suspendieren und Schließen.

In den folgenden Schritten arbeiten Sie mit UPDATE-Triggern.

Schritt 4 — Erstellen eines Before Update-Triggers

Ein BEFORE UPDATE-Trigger ähnelt dem BEFORE INSERT-Trigger – er wird jedoch zu einem anderen Zeitpunkt aufgerufen. Sie können den BEFORE UPDATE-Trigger verwenden, um eine Geschäftslogik zu überprüfen, bevor ein Eintrag aktualisiert wird. Verwenden Sie zum Testen die Tabelle customers, in der Sie bereits Daten eingefügt haben.

Sie verfügen in der Datenbank über zwei verschiedene Level für Ihre Kunden. In diesem Beispiel kann ein Kundenkonto nach dem Hochstufen auf das Level VIP nicht mehr auf das Level BASIC herabgestuft werden. Um eine solche Regel durchzusetzen, erstellen Sie einen BEFORE UPDATE-Trigger, der vor der UPDATE-Anweisung ausgeführt wird (wie nachfolgend gezeigt). Wenn ein Datenbankbenutzer einen Kunden auf das Level BASIC herunterstufen will (vom Level VIP aus), wird eine benutzerdefinierte Ausnahme ausgelöst.

Geben Sie nacheinander folgende SQL-Befehle ein, um den BEFORE UPDATE-Trigger zu erstellen:

DELIMITER //
CREATE TRIGGER validate_customer_level
BEFORE UPDATE
ON customers
FOR EACH ROW
IF OLD.level='VIP' THEN
SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'A VIP customer can not be downgraded.';
END IF //
DELIMITER ;

Verwenden Sie das Schlüsselwort OLD, um das Level zu erfassen, das der Benutzer beim Ausführen des Befehls UPDATE bereitstellt. Auch hier verwenden Sie die IF... THEN... END IF-Anweisung, um dem Benutzer eine generische Fehlermeldung anzuzeigen.

Führen Sie als Nächstes den folgenden SQL-Befehl aus, der versucht, ein mit der customer_id 3 verbundenes Kundenkonto herabzustufen:

Update customers set level='BASIC' where customer_id='3';

Sie sehen die folgende Ausgabe, die den SET MESSAGE_TEXT bereitstellt:

Output
ERROR 1644 (45000): A VIP customer can not be downgraded.

Wenn Sie den gleichen Befehl für einen BASIC-Kunden ausführen und versuchen, das Konto auf das Level VIP hochzustufen, wird der Befehl erfolgreich ausgeführt:

Update customers set level='VIP' where customer_id='1';

Output
Rows matched: 1  Changed: 1  Warnings: 0

Sie haben den BEFORE UPDATE-Trigger verwendet, um eine Geschäftsregel durchzusetzen. Jetzt fahren Sie mit der Verwendung eines AFTER UPDATE-Triggers zur Überwachungsprotokollierung fort.

Schritt 3 — Erstellen eines After Update-Triggers

Ein AFTER UPDATE-Trigger wird aufgerufen, sobald ein Datenbankeintrag erfolgreich aktualisiert wurde. Dieses Verhalten sorgt dafür, dass sich der Trigger für die Überwachungsprotokollierung eignet. In einer Umgebung mit mehreren Benutzern möchte der Administrator aus Auditgründen möglicherweise einen Verlauf der Benutzer anzeigen, die Einträge in einer bestimmten Tabelle aktualisiert haben.

Sie erstellen einen Trigger, der die Aktualisierungsaktivität der Tabelle sales protokolliert. Die Tabelle audit_log enthält Informationen über die MySQL-Benutzer, die die Tabelle sales aktualisieren, das Datum der Aktualisierung und die neuen und alten Werte von sales_amount.

Um den Trigger zu erstellen, führen Sie folgende SQL-Befehle aus:

DELIMITER //
CREATE TRIGGER log_sales_updates
AFTER UPDATE
ON sales
FOR EACH ROW
Insert into audit_log(sales_id, previous_amount, new_amount, updated_by, updated_on) VALUES (NEW.sales_id,OLD.sales_amount, NEW.sales_amount,(SELECT USER()), NOW() )//
DELIMITER ;

Sie fügen in die Tabelle audit_log einen neuen Eintrag ein. Sie verwenden das Schlüsselwort NEW, um den Wert der sales_id und die neue Verkaufssumme (sales_amount) abzurufen. Außerdem verwenden Sie das Schlüsselwort OLD, um die vorherige Verkaufssumme (sales_amount) abzurufen, da Sie für Auditzwecke beide Beträge protokollieren möchten.

Der Befehl SELECT USER() ruft den aktuellen Benutzer ab, der die Operation ausführt; die Anweisung NOW() ruft den Wert des aktuellen Datums und der Uhrzeit vom MySQL-Server ab.

Wenn nun ein Benutzer versucht, den Wert eines beliebigen Eintrags in der Tabelle sales zu aktualisieren, wird der Trigger log_sales_updates einen neuen Eintrag in die Tabelle audit_log einfügen.

Nun erstellen wir einen neuen Verkaufseintrag mit einer zufälligen Verkaufs-ID (sales_id) von 5 und versuchen, ihn zu aktualisieren. Fügen Sie zunächst den Verkaufseintrag ein mit:

Insert into sales(sales_id, customer_id, sales_amount) values('5', '2','8000');

Output
Query OK, 1 row affected (0.00 sec)

Aktualisieren Sie als Nächstes den Eintrag:

Update sales set sales_amount='9000' where sales_id='5';

Sie sehen die folgende Ausgabe:

Output
Rows matched: 1  Changed: 1  Warnings: 0

Führen Sie nun den folgenden Befehl aus, um zu überprüfen, ob der AFTER UPDATE-Trigger einen neuen Eintrag in der Tabelle audit_log registrieren konnte:

Select * from audit_log;

Der Trigger hat die Aktualisierung protokolliert. Die Ausgabe zeigt die vorherige Verkaufssumme (sales_amount) und die neue Summe (new amount), die für den Benutzer registriert sind, der die Einträge aktualisiert hat:

Output
+--------+----------+-----------------+------------+----------------+---------------------+
| log_id | sales_id | previous_amount | new_amount | updated_by     | updated_on          |
+--------+----------+-----------------+------------+----------------+---------------------+
|      1 |        5 |            8000 |       9000 | root@localhost | 2019-11-07 09:28:36 |
+--------+----------+-----------------+------------+----------------+---------------------+
1 row in set (0.00 sec)

Außerdem verfügen Sie über Datum und Uhrzeit der vorgenommenen Aktualisierung, was für Auditzwecke nützlich ist.

Als Nächstes verwenden Sie den DELETE-Trigger, um auf der Ebene der Datenbank die referenzielle Integrität durchzusetzen.

Schritt 6 — Erstellen eines Before Delete-Triggers

BEFORE DELETE-Trigger werden aufgerufen, bevor in einer Tabelle eine DELETE-Anweisung ausgeführt wird. Diese Arten von Triggern dienen normalerweise dazu, die referenzielle Integrität verschiedener verbundener Tabellen sicherzustellen. Beispielsweise bezieht sich jeder Eintrag in der Tabelle sales auf eine customer_id aus der Tabelle customers. Wenn ein Datenbankbenutzer einen Eintrag aus der Tabelle customers gelöscht hat, der in der Tabelle sales einen verknüpften Eintrag enthält, hätten Sie keine Möglichkeit zu wissen, welcher Kunde mit diesem Eintrag verknüpft war.

Um das zu verhindern, können Sie zum Durchsetzen Ihrer Logik einen BEFORE DELETE-Trigger erstellen. Führen Sie nacheinander folgende SQL-Befehle aus:

DELIMITER //
CREATE TRIGGER validate_related_records
BEFORE DELETE
ON customers
FOR EACH ROW
IF OLD.customer_id in (select customer_id from sales) THEN
SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'The customer has a related sales record.';
END IF//
DELIMITER ;

Versuchen Sie nun, einen Kunden zu löschen, der über einen verknüpften Verkaufseintrag verfügt:

Delete from customers where customer_id='2';

Dadurch erhalten Sie die folgende Ausgabe:

Output
ERROR 1644 (45000): The customer has a related sales record.

Der BEFORE DELETE-Trigger kann ein versehentliches Löschen verknüpfter Daten in einer Datenbank verhindern.

In bestimmten Situationen möchten Sie jedoch alle Einträge, die mit einem bestimmten Eintrag verbunden sind, aus den verschiedenen verknüpften Tabellen löschen. In diesem Fall verwenden Sie den AFTER DELETE-Trigger, den Sie im nächsten Schritt testen.

Schritt 7 — Erstellen eines After Delete-Triggers

AFTER DELETE-Trigger werden aktiviert, sobald ein Eintrag erfolgreich gelöscht wurde. Ein Beispiel dafür, wie Sie einen AFTER DELETE-Trigger verwenden können, ist eine Situation, in der die Rabattstufe, die ein bestimmter Kunde erhält, durch die Anzahl der in einem definierten Zeitraum vorgenommenen Käufe bestimmt wird. Wenn einige der Einträge des Kunden aus der Tabelle sales gelöscht werden, müsste die Rabattstufe des Kunden herabgestuft werden.

Ein weiteres Einsatzbeispiel für den AFTER DELETE-Trigger ist das Löschen verknüpfter Daten aus einer anderen Tabelle, sobald ein Eintrag aus einer Basistabelle gelöscht wird. Beispielsweise können Sie einen Trigger einrichten, der den Kundendatensatz löscht, wenn die Verkaufseinträge mit der verknüpften customer_id aus der Tabelle sales gelöscht werden. Führen Sie den folgenden Befehl aus, um Ihren Trigger zu erstellen:

DELIMITER //
CREATE TRIGGER delete_related_info
AFTER DELETE
ON sales
FOR EACH ROW
Delete from customers where customer_id=OLD.customer_id;//
DELIMITER ;

Führen Sie als Nächstes Folgendes aus, um alle mit der customer_id 2 verknüpften Verkaufseinträge zu löschen:

Delete from sales where customer_id='2';

Output
Query OK, 1 row affected (0.00 sec)

Überprüfen Sie nun, ob es Einträge für den Kunden aus der Tabelle sales gibt:

Select * from customers where customer_id='2';

Sie erhalten eine Empty Set-Ausgabe, da der Kundendatensatz, der mit der customer_id 2 verknüpft ist, durch den Trigger gelöscht wurde:

Output
Empty set (0.00 sec)

Sie haben nun alle verschiedenen Formen von Triggern verwendet, um bestimmte Funktionen auszuführen. Als Nächstes erfahren Sie, wie Sie einen Trigger aus der Datenbank entfernen können, wenn Sie ihn nicht mehr brauchen.

Schritt 8 — Löschen von Triggern

Ähnlich wie andere Datenbankobjekte können Sie auch Trigger mit dem Befehl DROP löschen. Die Syntax zum Löschen eines Triggers sieht folgendermaßen aus:

Drop trigger [TRIGGER NAME];

Um beispielsweise den letzten AFTER DELETE-Trigger zu löschen, den Sie erstellt haben, führen Sie den folgenden Befehl aus:

Drop trigger delete_related_info;

Output
Query OK, 0 rows affected (0.00 sec)

Sie müssen Trigger löschen, wenn Sie deren Struktur neu erstellen möchten. In diesem Fall können Sie den Trigger entfernen und mit den verschiedenen Triggerbefehlen einen neuen Trigger definieren.

Zusammenfassung

In diesem Tutorial haben Sie die verschiedenen Arten von Triggern einer MySQL-Datenbank erstellt, verwendet und gelöscht. Unter Verwendung einer kundenbezogenen Datenbank haben Sie Trigger für verschiedene Einsatzfälle wie Datenvalidierung, Anwendung von Geschäftslogik, Überwachungsprotokollierung und Durchsetzung der referenziellen Integrität implementiert.

Weitere Informationen zur Verwendung Ihrer MySQL-Datenbank finden Sie in folgenden Abschnitten:

• Optimieren von MySQL mit Abfrage-Cache unter Ubuntu 18.04
• Implementieren von Paginierung in MySQL mit PHP unter Ubuntu 18.04
• Beheben von Problemen in MySQL