SQL-Trigger: Das wesentliche Handbuch

Auslöser sind Datenbankentitäten in SQL Server. Technisch gesehen sind sie eine besondere Klasse von Funktionsaufrufen, die auf bestimmte Datenbankoperationen reagieren.

In diesem grundlegenden Leitfaden erhalten Sie ausführliche Informationen über SQL Triggers, die Ihnen in Ihrem Beruf sehr nützlich sein können. Fangen wir an!

Was sind SQL-Trigger?

Das Wort “Trigger” beschreibt eine Anweisung, die ein Server jedes Mal automatisch ausführt, wenn der Inhalt der Datenbank geändert wird.

Ein Trigger ist eine Gruppe von speziell benannten SQL-Abfragen, die im Speicher abgelegt werden. Es handelt sich um eine bestimmte Art von Funktionsaufruf, der sofort aufgerufen wird, sobald ein Datenbankereignis eintritt. Jedem Trigger ist eine Tabelle zugewiesen.

So kann ein Trigger beispielsweise immer dann aktiviert werden, wenn einer bestimmten Tabelle eine neue Spalte hinzugefügt wird oder wenn bestimmte Datensätze geändert werden.

Laut Microsoft Developer Network sind Trigger eine besondere Klasse von Stored Procedures. In einer Trigger-Anweisung legen wir zunächst fest, wann der Trigger ausgeführt werden soll, und dann geben wir die Aktion an, die nach der Aktivierung des Triggers ausgeführt werden soll.

Syntax:

CREATE TRIGGER trigger_name
VORHER/NACHHER
EINFÜGEN/AKTUALISIEREN/LÖSCHEN
ON tabellenname
FOR EACH ROW SET operation [trigger_body];

Erläuterung der einzelnen Parameter

• CREATE TRIGGER trigger_name – Wird verwendet, um einen Trigger zu erstellen oder um den Namen eines bestehenden Triggers zu ändern.
• BEFORE/AFTER – Diese Abfrage wird verwendet, um den Ausführungszeitpunkt des Triggers zu definieren (vor oder nach einem bestimmten Ereignis).
• INSERT/UPDATE/DELETE – Hier wird die Aktion beschrieben, die wir mit den Tabellen durchführen möchten.
• ON tableName – Hier definieren wir den Tabellennamen, um einen Trigger einzurichten.
• FOR EACH ROW – Diese Anweisung bezieht sich auf den Zeilentrigger, was bedeutet, dass der Trigger immer dann ausgeführt wird, wenn eine Zeile geändert wird.
• trigger_body – Hier wird die Aktion angegeben, die ausgeführt werden soll, wenn der Trigger aktiviert wird.

Trigger sind gespeicherte Funktionen mit eindeutigen Identitäten, die es uns ermöglichen, bereits ausgeführte und sicher im Speicher abgelegte Abfragen wiederzuverwenden. Lassen Sie uns nun versuchen zu verstehen, warum SQL sie braucht.

Trigger werden meist verwendet, um die Ausführung von Code zu steuern, wenn ein Ereignis eintritt. Anders ausgedrückt: Die Verwendung von Triggern ist die ideale Wahl, wenn Sie möchten, dass ein bestimmtes Codefragment ständig als Reaktion auf ein bestimmtes Ereignis ausgeführt wird.

Im Folgenden finden Sie einige Vorteile der Verwendung von Triggern bei SQL-Datenbankoperationen.

1. Führt zusätzliche Überprüfungen durch, wenn Sie Daten in die betroffene Tabelle einfügen, aktualisieren oder aus ihr löschen.
2. Verringert die Antwortzeiten, was zu einer Erhöhung des Rechenaufwands beiträgt.
3. Ermöglicht die Kodierung von anspruchsvollen Standardparametern, die durch anfängliche Einschränkungen unzugänglich sind.

Die referentielle Integrität ist eine wichtige Kerneigenschaft relationaler Datenbanksysteme. Das bedeutet, dass die im Datenbanksystem gespeicherten Daten für jede Transaktion und jeden Vorgang immer korrekt sein müssen.

Wenn sich zwei Tabellen in verschiedenen Datenbanken oder Systemen befinden, gibt es keine Möglichkeit, die Datenvalidierung innerhalb dieser Tabellen mit Hilfe von Constraint-Werten sicherzustellen. In einer solchen Situation sind Trigger die einzige Möglichkeit zur Ausführung.

Kombination von Trigger-Argumenten

Für jede Tabelle können wir sechs verschiedene Trigger-Typen angeben. Dies sind die Kombinationen der Trigger-Argumente, die in SQL-Triggern auf Zeilenebene enthalten sind.

BEFORE INSERT: Diese Trigger führen die Aktion an den Zeilen aus, bevor INSERT-Operationen in der angegebenen Tabelle oder in der Datenbank durchgeführt werden.

NACH INSERT: Er führt die Aktion für die Zeilen unmittelbar nach einer INSERT-Aktivität in der Datenbank aus.

BEFORE UPDATE: Mit diesen Triggern wird eine Funktion auf den Zeilen ausgeführt, bevor eine UPDATE-Aktion auf der Datenbank durchgeführt wird.

AFTER UPDATE: Er führt die Aktion für die Zeilen unmittelbar nach einer UPDATE-Aktivität in der Datenbank oder einer bestimmten Tabelle aus.

BEFORE DELETE: Er führt eine bestimmte Operation an Zeilen aus, noch bevor die Datenbank oder Tabelle einer DELETE-Aktion unterzogen wird.

NACH DELETE: Diese Trigger führen die Aktion für die Zeilen nach jeder DELETE-Transaktion aus.

Arten von SQL-Triggern

SQL-Trigger sind gespeicherte Funktionen, die sofort ausgeführt werden, wenn bestimmte Ereignisse eintreten. Sie ähneln dem ereignisgesteuerten Scheduling. Die folgenden Situationen können die Ausführung von Triggern auslösen.

DML-Trigger – DML steht für Data Manipulation Language. Die Ausführung von Code als Reaktion auf eine Datenänderung wird durch DML-Trigger ermöglicht. Dieser Trigger wird aktiviert, wenn DML-Befehle wie INSERT, UPDATE und DELETE ausgeführt werden. Diese werden auch “Table Level Triggers” genannt.

DDL-Trigger – DDL steht für Data Definition Language. Mit DDL-Triggern können wir Code als Reaktion auf Änderungen des Datenbankschemas, wie das Hinzufügen oder Löschen von Tabellen, oder auf Serverereignisse, wie das Einchecken eines Benutzers, ausführen. Diese Trigger werden als “Trigger auf Datenbankebene” bezeichnet.

Diese Trigger können aktiviert werden, wenn bestimmte DDL-Anweisungen wie CREATE, ALTER oder DROP in der aktiven Datenbank ausgeführt werden. Sie können auch verwendet werden, um die ausgeführten Aktivitäten im Auge zu behalten und zu verwalten.

LOGON-Trigger – Wann immer ein LOGON-Ereignis (Start, Anmeldung, Abmeldung, Herunterfahren) eintritt, werden sofort Logon-Trigger ausgelöst. Sie werden erst nach einem Benutzerauthentifizierungsprozess ausgeführt, noch bevor die Benutzertransaktion eingeleitet wird. Die LOGON-Trigger werden nicht ausgelöst, wenn die Autorisierung fehlschlägt.

Diese Trigger können verwendet werden, um den Anmeldeverlauf aufzuzeichnen oder eine Ereignisbeschränkung für eine bestimmte Anmeldung einzurichten, neben anderen Auditing- und Identitätsmanagementfunktionen für Serververbindungen.

CLR-Trigger – CLR steht für Common Language Runtime. CLR-Trigger sind in der Tat eine einzigartige Untergruppe von Triggern, die hauptsächlich auf CLR innerhalb der .NET-Technologie basieren. Diese Trigger sind hilfreich, wenn der Trigger viele Berechnungen durchführen muss oder sich auf eine andere Entität als SQL beziehen muss.

DML- und DDL-Trigger können in der Tat erstellt werden, indem Sie die Codierung von unterstützten CLR-Triggern in .NET-Technologien wie Visual Basic, C# und F-sharp ermöglichen.

Beispiel eines SQL Server-Triggers

Lassen Sie uns diese Trigger-Konzepte anhand eines Beispiels verstehen.

Lassen Sie uns zunächst eine Datenbank mit SQL-Anweisungen erstellen.

CREATE DATABASE testdb;
verwenden Sie testdb;

Hier habe ich “testdb” als Namen für die Datenbank angegeben. Der nächste Schritt ist die Erstellung einer Tabelle.

CREATE TABLE student(
  name varchar(25),
  id int(2),
  maths int(2),
  physik int(2),
  biologie int(2),
  soziales int(2),
  gesamt int(2)
 );

Ich habe eine Tabelle zum Speichern der Schülerdaten erstellt. Und hier ist der Befehl, um die Struktur der Tabelle zu beschreiben. Hier ist “student” der Name der Tabelle, den ich vergeben habe.

DESC Student;

Nachfolgend sehen Sie die Struktur der Tabelle, die ich erstellt habe.

 --------- ------------- ------ ----- --------- ------- 
| Feld | Typ | Null | Schlüssel | Standard | Extra |
 --------- ------------- ------ ----- --------- ------- 
| name | varchar(25) | YES | | NULL | |
| id | int | YES | | NULL | | |
| maths | int | YES | | | NULL | |
| Physik | int | YES | | NULL | | |
| Biologie | int | YES | | NULL | | |
| Soziales | int | YES | | NULL | | |
| gesamt | int | YES | | NULL | | |
 --------- ------------- ------ ----- --------- ------- 
7 Zeilen im Satz (0.00 sec)

Nachdem Sie eine Tabelle erstellt haben, ist der nächste Schritt die Einrichtung eines Triggers. Lassen Sie uns das Argument BEFORE INSERT verwenden.

Der Name des Triggers, den ich erstellt habe, lautet “marks”. Sobald die Tabelle mit den Noten der Schüler geändert wird, versucht der folgende Trigger, die Gesamtnote des Schülers automatisch zu ermitteln.

CREATE TRIGGER marks
BEFORE INSERT
ON
student
FOR EACH ROW
set new.total=new.maths new.physics new.biology new.social;

Da wir die Daten in den Zeilen ersetzen müssen, anstatt mit den alten Daten zu arbeiten, haben wir “total” mit einem neuen Klassennamen definiert und allen nachfolgenden Ausdrücken neue Schlüsselwörter mit dem Punkt-Operator nach total vorangestellt. Jetzt fügen wir jeder Zeile Werte hinzu und sehen uns die Ergebnisse an. Zu Beginn ist die Gesamtnote für jeden Schüler 0.

INSERT INTO student VALUES("George",02,99,87,92,91,0);
INSERT INTO student VALUES("James",03,91,81,94,90,0);
INSERT INTO student VALUES("Harry",04,86,70,73,88,0);
INSERT INTO student VALUES("John",05,73,89,78,92,0);
INSERT INTO student VALUES("Lisa",01,94,75,69,79,0);

Die Trigger-Anweisung wird in diesem Fall automatisch ausgelöst, wenn Daten in die Tabelle Schüler eingefügt werden. Die Gesamtnote jedes Schülers wird durch den Trigger berechnet. Lassen Sie uns nun sehen, ob der Trigger mit einer SELECT-Anweisung aufgerufen wird oder nicht.

SELECT * FROM tabelle_name;

Und hier ist die endgültige Ausgabe.

mysql> select * from student;
 -------- ------ ------- --------- --------- -------- ------- 
| name | id | maths | physics | biology | social | total |
 -------- ------ ------- --------- --------- -------- ------- 
| George | 2 | 91 | 81 | 94 | 90 | 356 |
| James | 3 | 86 | 70 | 73 | 88 | 317 |
| Harry | 4 | 73 | 89 | 78 | 92 | 332 |
| John | 5 | 94 | 75 | 69 | 79 | 317 |
| Lisa | 1 | 99 | 87 | 92 | 91 | 369 |
 -------- ------ ------- --------- --------- -------- ------- 
5 Zeilen im Satz (0.00 sec)

Im obigen Ergebnis können Sie sehen, dass alle Fachnoten für jeden Schüler automatisch hinzugefügt werden. Daraus können wir schließen, dass der Trigger erfolgreich aufgerufen wurde.

Zusätzliche Trigger-Operationen

Wir können viele Operationen mit Triggern durchführen. Einige mögen einfach und andere etwas komplex sein, aber wenn wir die Abfragen durchgehen, ist es leicht zu verstehen. Mit Hilfe von Transact-SQL-Anweisungen können Sie die Trigger mit den folgenden Befehlen aktivieren, deaktivieren oder löschen.

Abfrage, um zu prüfen, ob ein bestimmter Trigger vorhanden ist oder nicht

Dieser Befehl prüft, ob der angegebene Trigger in der gesamten Datenbank vorhanden ist.

SELECT * FROM [sys].[triggers] WHERE [name] = 'Trigger_name'

Abfrage zum Anzeigen von Triggern

Alle Trigger, die in der aktiven Datenbank verfügbar sind, werden durch die folgende Anweisung angezeigt.

SHOW TRIGGERS;

Abfrage zum Deaktivieren von Triggern

Der folgende Befehl deaktiviert den Trigger in der Arbeitsdatenbank.

DISABLE TRIGGER trigger_name ON DATABASE;

Sie können auch einen bestimmten Tabellennamen angeben, um einen Trigger zu deaktivieren.

DISABLE TRIGGER trigger_name ON table_name;

Abfrage zum Aktivieren eines Triggers

Der folgende Befehl deaktiviert zunächst einen bestimmten Trigger, der für die angegebene Tabelle in der aktiven Datenbank definiert wurde, bevor er wieder aktiviert wird.

ALTER TABLE tabelle_name DISABLE TRIGGER trigger_name

ALTER TABLE tabelle_name ENABLE TRIGGER trigger_name

Der Trigger muss deaktiviert sein, bevor Sie versuchen, ihn zu aktivieren,

Abfrage zum Aktivieren oder Deaktivieren aller Trigger in einer Tabelle

Mit der obigen SQL-Anweisung können wir alle Tabellen-Trigger gleichzeitig aktivieren oder deaktivieren, indem wir “ALL” anstelle eines bestimmten Triggernamens einsetzen.

ALTER TABLE tabelle_name DISABLE TRIGGER ALL 

ALTER TABLE table_name ENABLE TRIGGER ALL

Abfrage zum Löschen oder Entfernen eines Triggers

Ein Trigger kann eliminiert werden, indem er oder die gesamte Tabelle gelöscht wird. Jeder damit verbundene Trigger wird ebenfalls gelöscht, wenn eine Tabelle gelöscht wird.

DROP TRIGGER [trigger_name];

Immer wenn ein Trigger gelöscht wird, werden auch die damit verbundenen Daten aus der Datentabelle sys.objects entfernt.

Vorteile von Triggern

• Es ist einfach, Trigger zu erstellen und der Trigger selbst kann gespeicherte Funktionen und Methoden aufrufen.
• Benutzer können mit Hilfe von Triggern einfache Überprüfungen durchführen.
• Tragischerweise können Sie mit SQL Server keine Einschränkungen über Entitäten in Datenbanksystemen erstellen, obwohl Sie die Funktionsweise von Einschränkungen durch die Verwendung von Triggern emulieren können.
• Integritätseinschränkungen können mithilfe von Triggern datenbankübergreifend implementiert werden.
• Wenn eine Gruppenüberprüfung erforderlich ist und nicht eine zeilenweise Überprüfung neu eingegebener oder geänderter Daten, können Trigger hilfreich sein.

Nachteile von Triggern

SQL-Trigger sind in manchen Situationen aufgrund ihrer Einschränkungen nicht die beste Wahl.

• Trigger müssen genau dokumentiert werden.
• Aufgrund der gleichzeitigen Datenbankausführung, auf die Anwendungskomponenten möglicherweise nicht zugreifen können, kann die Fehlersuche bei Triggern schwierig sein.
• DML-Anweisungen werden komplexer, wenn Trigger verwendet werden.
• Selbst ein kleines Trigger-Problem kann zu logischen Fehlern in der Anweisung führen.

Fazit

Trigger sind sehr hilfreiche Komponenten von Transact-SQL und SQL, und Sie können sie auch in Oracle verwenden. Die Verwendung von Triggern ist beim Aufruf von gespeicherten Methoden von entscheidender Bedeutung. Mit diesen SQL-Triggern können wir die Aktivitätszeitlinien analysieren und festlegen, wie wir bei Bedarf darauf reagieren. Wir können auch nach einer bestimmten Tabelle suchen, die mit einem Trigger verbunden ist, um Daten zu erfassen.

Die Rekursion kann durch Trigger aktiviert werden. Immer wenn ein Trigger auf einer Tabelle einen Befehl auf der übergeordneten Tabelle ausführt, wird die zweite Iteration des Triggers ausgelöst, was als rekursiver Trigger bezeichnet wird. Dies ist hilfreich, wenn Sie versuchen, eine Identitätskorrelation zu lösen.

Außerdem regeln Trigger das Aktualisierungsmuster, das die Datenbank akzeptieren darf. Es ist sehr vorteilhaft, die Datenintegritätsbeschränkungen im Datenbanksystem beizubehalten, wenn es keine SQL-Einschränkungsschlüssel gibt, vor allem nicht den Primärschlüssel und den Fremdschlüssel.

Ich hoffe, dass Sie diesen Artikel hilfreich fanden, um mehr über SQL-Trigger zu erfahren.

Wenn Sie sich eingehender mit Datenbanken befassen möchten, finden Sie hier einige ausgezeichnete Ressourcen, um SQL und NoSQL zu lernen.