Trigger sind Datenbankentitäten in SQL Server. Technisch gesehen handelt es sich um eine bestimmte Klasse von Funktionsaufrufen, die auf bestimmte Datenbankoperationen reagieren.
Dieser wichtige Leitfaden gibt Ihnen detaillierte Informationen zu SQL-Triggern, die in Ihrem Beruf sehr nützlich sein können. Lass uns anfangen!
Inhaltsverzeichnis
Was sind SQL-Trigger?
Das Wort „Trigger“ beschreibt eine Aussage, dass ein Server die Abfrage jedes Mal automatisch ausführt, wenn der Inhalt in der Datenbank geändert wird.
Ein Trigger ist eine Gruppe speziell benannter SQL-Abfragen, die im Speicherbereich gespeichert werden. Es handelt sich um eine bestimmte Art von Funktionsaufruf, der sofort aufgerufen wird, wenn ein Datenbankereignis eintritt. Jedem Trigger ist eine Tabelle zugeordnet.
Beispielsweise könnte ein Trigger immer dann aktiviert werden, wenn einer bestimmten Tabelle eine neue Spalte hinzugefügt oder bestimmte Datensätze geändert werden.
Laut Microsoft Developer Network sind Trigger eine bestimmte Klasse gespeicherter Prozeduren. In einer Trigger-Anweisung definieren wir zunächst, wann der Trigger ausgeführt werden soll, und stellen dann die Aktion bereit, die ausgeführt werden soll, nachdem der Trigger aktiviert wurde.
Syntax:
CREATE TRIGGER trigger_name BEFORE/AFTER INSERT/UPDATE/DELETE ON tableName FOR EACH ROW SET operation [trigger_body];
Erläuterung der einzelnen Parameter
- CREATE TRIGGER trigger_name – Wird verwendet, um einen Trigger zu erstellen oder den Namen eines vorhandenen Triggers zu ändern.
- BEFORE/AFTER – Diese Abfrage wird verwendet, um die Ausführungszeit des Triggers (vor oder nach einem bestimmten Ereignis) zu definieren.
- EINFÜGEN/AKTUALISIEREN/LÖSCHEN – Dies beschreibt die Aktion, die wir an den Tabellen vornehmen möchten.
- ON tableName – Hier definieren wir den Tabellennamen, um einen Trigger einzurichten.
- FOR EACH ROW – Diese Anweisung bezieht sich auf Zeilentrigger, was bedeutet, dass Trigger ausgeführt werden, wenn eine Zeile geändert wird.
- trigger_body – Gibt die Aktion an, die ausgeführt werden soll, wenn der Trigger aktiviert wird.
Auslöser sind gespeicherte Funktionen mit eindeutigen Identitäten, die es uns ermöglichen, bereits ausgeführte und sicher gespeicherte Abfragen wiederzuverwenden. Versuchen wir nun zu verstehen, warum SQL sie benötigt.
Trigger werden meistens verwendet, um die Bereitstellung von Code zu regulieren, wann immer ein Ereignis stattfindet. Anders ausgedrückt ist die Verwendung von Triggern die ideale Wahl, wenn ein bestimmtes Codefragment ständig als Reaktion auf ein bestimmtes Ereignis ausgeführt werden soll.
Im Folgenden sind einige Vorteile der Verwendung von Triggern in SQL-Datenbankoperationen aufgeführt.
Referentielle Integrität ist eine Schlüsseleigenschaft relationaler Datenbanksysteme. Dies bedeutet, dass die im Datenbanksystem gehaltenen Daten für jede Transaktion und jede Operation immer genau sein müssen.
Wenn sich zwei Tabellen in separaten Datenbanken oder Systemen befinden, gibt es keine Möglichkeit, die Datenvalidierung in ihnen mithilfe von Einschränkungswerten 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 Triggertypen angeben. Dies ist die Kombination von Trigger-Argumenten, die in SQL-Triggern auf Zeilenebene enthalten sind.
BEFORE INSERT: Diese Trigger führen die Aktion für die Zeilen aus, bevor irgendwelche INSERT-Operationen in der angegebenen Tabelle oder in der Datenbank ausgeführt werden.
AFTER INSERT: Es führt die Aktion für Zeilen unmittelbar nach jeder Datenbank-INSERT-Aktivität aus.
BEFORE UPDATE: Bei diesen Triggern wird eine Funktion für die Zeilen ausgeführt, bevor eine UPDATE-Aktion für die Datenbank ausgeführt wird.
NACH UPDATE: Es führt die Aktion für Zeilen aus, die unmittelbar auf eine UPDATE-Aktivität der Datenbank oder einer bestimmten Tabelle folgen.
BEFORE DELETE: Es führt eine bestimmte Operation für Zeilen aus, noch bevor die Datenbank oder Tabelle einer DELETE-Aktion unterzogen wird.
AFTER 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. Es ähnelt der ereignisgesteuerten Planung. Die nachfolgenden Situationen können die Ausführung von Triggern starten.
DML-Trigger – DML steht für Data Manipulation Language. Die Codeausführung als Reaktion auf Datenänderungen wird mithilfe von DML-Triggern ermöglicht. Dieser Trigger wird aktiviert, wenn DML-Befehle wie INSERT, UPDATE und DELETE ausgeführt werden. Diese werden auch als „Table Level Trigger“ bezeichnet.
DDL-Trigger – DDL steht für Data Definition Language. DDL-Trigger ermöglichen es uns, Code als Reaktion auf Datenbankschemaänderungen auszuführen, z. B. das Hinzufügen oder Löschen von Tabellen, oder Serverereignisse, z. B. wenn sich ein Benutzer anmeldet. Diese werden als „Datenbankebenen-Trigger“ bezeichnet.
Diese Trigger können aktiviert werden, wenn bestimmte DDL-Anweisungen wie CREATE, ALTER oder DROP in der aktiven Datenbank ausgeführt werden. Diese können auch verwendet werden, um die ausgeführten Aktivitäten im Auge zu behalten und zu verwalten.
LOGON-Trigger – Jedes Mal, wenn ein LOGON-Ereignis (Startup, Login, Logout, Shutdown) eintritt, werden Logon-Trigger sofort aufgerufen. Sie werden nur nach einem Benutzerauthentifizierungsprozess durchgeführt, noch bevor die Benutzertransaktion initiiert wird. Die LOGON-Trigger werden nicht ausgelöst, wenn die Autorisierung fehlschlägt.
Diese Auslöser können neben anderen Überwachungs- und Identitätsverwaltungsfunktionen für Serververbindungen verwendet werden, um den Anmeldeverlauf aufzuzeichnen oder eine Ereignisbeschränkung für eine bestimmte Anmeldung festzulegen.
CLR-Trigger – CLR steht für Common Language Runtime. CLR-Trigger sind in der Tat eine einzigartige Teilmenge von Triggern, die hauptsächlich auf CLR innerhalb der .NET-Technologie basieren. Diese Trigger sind hilfreich, wenn der Trigger viele Berechnungen ausführen oder sich auf eine andere Entität als SQL beziehen muss.
DML- und DDL-Trigger können tatsächlich erstellt werden, indem die Codierung von unterstützten CLR-Triggern in .NET-Technologien, einschließlich Visual Basic, C# und Fis, ermöglicht wird.
Beispiel für einen SQL Server-Trigger
Lassen Sie uns diese Auslöserkonzepte anhand eines Beispiels verstehen.
Lassen Sie uns zunächst eine Datenbank mit SQL-Anweisungen erstellen.
CREATE DATABASE testdb; use testdb;
Hier habe ich als Namen der Datenbank „testdb“ angegeben. Und der nächste Schritt besteht darin, eine Tabelle zu erstellen.
CREATE TABLE student( name varchar(25), id int(2), maths int(2), physics int(2), biology int(2), social int(2), total 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 Tabellenname, den ich gegeben habe.
DESC student;
Unten ist die Struktur der Tabelle, die ich erstellt habe.
+---------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +---------+-------------+------+-----+---------+-------+ | name | varchar(25) | YES | | NULL | | | id | int | YES | | NULL | | | maths | int | YES | | NULL | | | physics | int | YES | | NULL | | | biology | int | YES | | NULL | | | social | int | YES | | NULL | | | total | int | YES | | NULL | | +---------+-------------+------+-----+---------+-------+ 7 rows in set (0.00 sec)
Nach dem Erstellen einer Tabelle besteht der nächste Schritt darin, einen Trigger einzurichten. Lassen Sie uns versuchen, das BEFORE INSERT-Argument zu verwenden.
Der Name des Triggers, den ich erstellt habe, ist „marks“. Sobald die Tabelle mit den Noten des Schülers geändert wird, versucht der unten stehende 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 Zeilendaten ersetzen müssen, anstatt mit den alten zu arbeiten, haben wir „total“ mit einem neuen Klassennamen definiert, und allen nachfolgenden Ausdrücken werden mit dem Punktoperator nach total neue Schlüsselwörter vorangestellt. Jetzt fügen wir jeder Zeile Werte hinzu und sehen uns die Ergebnisse an. Zunächst 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 Schülertabelle eingefügt werden. Die Gesamtpunktzahl jedes Schülers wird vom Trigger berechnet. Sehen wir uns nun an, ob der Trigger mit einer SELECT-Anweisung aufgerufen wird oder nicht.
SELECT * FROM table_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 rows in set (0.00 sec)
Im obigen Ergebnis sehen Sie, dass alle Fachnoten automatisch für jeden Schüler hinzugefügt werden. Wir können also schließen, dass der Trigger erfolgreich aufgerufen wurde.
Zusätzliche Triggeroperationen
Wir können viele Operationen mit Triggern ausführen. Einige mögen einfach und andere etwas komplex sein, aber sobald wir die Abfragen durchgegangen sind, ist es leicht zu verstehen. Durch den Einsatz von Transact-SQL-Anweisungen können Sie die Trigger mit den folgenden Befehlen aktivieren, deaktivieren oder löschen.
Abfrage, ob ein bestimmter Trigger vorhanden ist oder nicht
Dieser Befehl sucht in der gesamten Datenbank nach dem angegebenen Trigger.
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 des Triggers
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 des Triggers
Der folgende Befehl deaktiviert zuerst einen bestimmten Trigger, der für die angegebene Tabelle in der aktiven Datenbank definiert wurde, bevor er wieder aktiviert wird.
ALTER TABLE table_name DISABLE TRIGGER trigger_name ALTER TABLE table_name ENABLE TRIGGER trigger_name
Der Trigger muss deaktiviert werden, bevor versucht wird, ihn zu aktivieren.
Abfrage zum Aktivieren oder Deaktivieren aller Trigger in einer Tabelle
Mit der obigen SQL-Anweisung können wir alle Tabellentrigger gleichzeitig deaktivieren oder aktivieren, indem wir „ALL“ anstelle eines bestimmten Triggernamens einsetzen.
ALTER TABLE table_name DISABLE TRIGGER ALL ALTER TABLE table_name ENABLE TRIGGER ALL
Abfrage zum Löschen oder Löschen des Triggers
Ein Trigger kann eliminiert werden, indem er oder die gesamte Tabelle gelöscht wird. Beim Löschen einer Tabelle werden auch alle zugehörigen Trigger gelöscht.
DROP TRIGGER [trigger_name];
Immer wenn ein Trigger gelöscht wird, werden die zugehörigen Daten aus der Datentabelle sys.objects gelöscht.
Vorteile von Triggern
- Es ist einfach, Trigger zu erstellen, und der Trigger selbst kann gespeicherte Funktionen und Methoden aufrufen.
- Benutzer können einfache Audits mithilfe von Triggern implementieren.
- Tragischerweise können Sie in Datenbanksystemen mit SQL Server keine Beschränkungen über Entitäten hinweg erstellen, obwohl Sie die Operation von Beschränkungen emulieren können, indem Sie Trigger verwenden.
- Integritätsbedingungen können mithilfe von Triggern datenbankübergreifend implementiert werden.
- Wenn eine Gruppenvalidierung anstelle einer zeilenweisen Überprüfung neu eingegebener oder geänderter Daten erforderlich ist, können Trigger hilfreich sein.
Nachteile von Triggern
SQL-Trigger sind aufgrund ihrer Einschränkungen in manchen Situationen möglicherweise nicht die beste Wahl.
- Auslöser müssen genau dokumentiert werden.
- Aufgrund der gleichzeitigen Datenbankausführung, auf die Anwendungskomponenten möglicherweise nicht zugreifen können, kann das Debuggen von Triggern schwierig sein.
- DML-Anweisungen werden komplexer, wenn Trigger verwendet werden.
- Selbst ein geringfügiges Triggerproblem 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 entscheidend, wenn gespeicherte Methoden aufgerufen werden. Diese SQL-Trigger ermöglichen es uns, die Aktivitätszeitpläne zu analysieren und zu bestimmen, wie wir gegebenenfalls darauf reagieren. Wir können auch nach einer bestimmten Tabelle suchen, die mit einem Trigger zum Erfassen von Daten verbunden ist.
Rekursion kann durch Trigger aktiviert werden. Immer wenn ein Trigger für eine Tabelle einen Befehl für die übergeordnete Tabelle ausführt, wird die zweite Iteration des Triggers ausgelöst, und dies wird als rekursiver Trigger bezeichnet. Dies hilft beim Versuch, eine Identitätskorrelation zu lösen.
Zusätzlich regeln Trigger das Aktualisierungsmuster, das die Datenbank akzeptieren darf. Es ist sehr vorteilhaft, die Datenintegritätseinschränkungen im Datenbanksystem beizubehalten, wenn SQL-Einschränkungsschlüssel nicht vorhanden sind, hauptsächlich der Primärschlüssel und der Fremdschlüssel.
Ich hoffe, Sie fanden diesen Artikel hilfreich, um mehr über SQL-Trigger zu erfahren.
Wenn Sie sich eingehend mit Datenbanken vertraut machen möchten, finden Sie hier einige hervorragende Ressourcen zum Erlernen von SQL und NoSQL.