Triggers, en central del av SQL Server, fungerar som specialiserade funktionsanrop som aktiveras av specifika händelser inom databasen.
Denna guide ger dig en grundlig genomgång av SQL-triggers, kunskap som kan vara ovärderlig i ditt arbete. Låt oss börja utforska detta område!
Vad är SQL-triggers?
En ”trigger” fungerar som en instruktion som säger till servern att automatiskt utföra en SQL-fråga varje gång data i databasen ändras.
En trigger är alltså en samling SQL-kommandon som har fått ett namn och sparas i minnet. Det är en typ av funktionsanrop som omedelbart aktiveras när en databashändelse inträffar. Varje trigger är kopplad till en specifik tabell.
Till exempel kan en trigger starta när en ny kolumn läggs till i en tabell eller när data i specifika rader ändras.
Enligt Microsoft Developer Network betraktas triggers som en speciell typ av lagrade procedurer. I en triggersats definierar vi först när triggern ska köras, och sedan specificerar vi vilken åtgärd som ska utföras när triggern har aktiverats.
Syntax:
CREATE TRIGGER trigger_namn BEFORE/AFTER INSERT/UPDATE/DELETE ON tabellnamn FOR EACH ROW SET operation [trigger_body];
Förklaring av parametrarna:
- CREATE TRIGGER trigger_namn – Används för att skapa en ny trigger eller ändra namnet på en befintlig.
- FÖRE/EFTER – Bestämmer när triggern ska köras, antingen före eller efter en specifik händelse.
- INSERT/UPDATE/DELETE – Anger vilken typ av operation som ska aktivera triggern på tabellen.
- ON tabellnamn – Specificerar tabellen som triggern är kopplad till.
- FÖR VARJE RAD – Anger att triggern ska köras för varje rad som påverkas av en databasoperation.
- trigger_body – Definierar den åtgärd som triggern ska utföra när den aktiveras.
Triggers är lagrade funktioner med egna identiteter som gör det möjligt att återanvända SQL-frågor som redan har körts och lagrats säkert i minnet. Låt oss se varför SQL behöver triggers.
Triggers används ofta för att styra utförandet av kod när en viss händelse sker. Det är ett utmärkt val om du behöver ett specifikt kodavsnitt att köras automatiskt som svar på en definierad händelse.
Här är några fördelar med att använda triggers i SQL:
Referensintegritet är en grundläggande egenskap i relationsdatabassystem. Det innebär att data i databasen alltid måste vara korrekta under varje transaktion och operation.
Om två tabeller finns i olika databaser eller system, finns det inget sätt att säkerställa datavalidering med begränsningsvärden. I sådana situationer är triggers den enda lösningen för att uppnå detta.
Kombinationer av triggerargument
För varje tabell kan vi specificera sex olika triggertyper. Dessa är kombinationerna av triggerargument som ingår i SQL-triggers på radnivå.
FÖRE INSERT: Dessa triggers körs på rader innan en INSERT-operation utförs i den angivna tabellen.
EFTER INSERT: Dessa triggers körs direkt efter att en INSERT-operation har utförts på databasen.
FÖRE UPPDATERING: Dessa triggers kör en funktion på raderna innan en UPPDATERING utförs.
EFTER UPPDATERING: Dessa triggers körs direkt efter att en UPPDATERING-operation har utförts på tabellen eller databasen.
FÖRE DELETE: Dessa triggers körs innan en DELETE-operation utförs på tabellen eller databasen.
EFTER DELETE: Dessa triggers körs efter en DELETE-transaktion.
Typer av SQL-triggers
SQL-triggers är lagrade funktioner som körs automatiskt när specifika händelser sker, liknande händelsestyrd schemaläggning. Följande situationer kan starta triggerns exekvering:
DML Triggers – DML står för Data Manipulation Language. DML-triggers möjliggör kodexekvering som svar på dataändringar. Denna typ av trigger aktiveras när DML-kommandon som INSERT, UPDATE och DELETE körs. De kallas även för ”Tabellnivåtriggers”.
DDL Triggers – DDL står för Data Definition Language. DDL-triggers låter oss köra kod som svar på ändringar i databasschemat, som att lägga till eller ta bort tabeller. De kan även användas för serverhändelser, som när en användare checkar in. Dessa kallas ”Databasnivåtriggers”.
Dessa triggers kan aktiveras när DDL-satser som CREATE, ALTER eller DROP utförs i den aktiva databasen. De kan användas för att övervaka och hantera de åtgärder som utförs.
LOGON Triggers – LOGON-triggers anropas omedelbart när en LOGON-händelse (start, inloggning, utloggning, avstängning) inträffar. De körs endast efter en användarautentiseringsprocess, innan själva användartransaktionen initieras. LOGON-triggers aktiveras inte om auktoriseringen misslyckas.
Dessa triggers kan användas för att registrera inloggningshistorik eller skapa händelsebegränsningar för specifika inloggningar, bland andra funktioner för revision och identitetshantering av serveranslutningar.
CLR Triggers – CLR står för Common Language Runtime. CLR-triggers är en speciell undergrupp av triggers som bygger på CLR inom .NET-tekniken. Dessa triggers är användbara om triggern behöver utföra många beräkningar eller behöver hantera andra enheter än SQL-data.
DML- och DDL-triggers kan skapas med hjälp av CLR-kodning som stöds i .NET-tekniker som Visual Basic, C# och F-sharp.
Exempel på SQL Server Trigger
Låt oss illustrera dessa triggerkoncept med ett exempel.
Först skapar vi en databas med SQL-satser:
CREATE DATABASE testdb; use testdb;
Här har vi angett ”testdb” som namn på databasen. Nästa steg är att skapa en tabell:
CREATE TABLE student( name varchar(25), id int(2), maths int(2), physics int(2), biology int(2), social int(2), total int(2) );
Jag har skapat en tabell för att lagra elevinformation. Här är kommandot för att visa tabellens struktur. ”student” är tabellnamnet jag har angett:
DESC student;
Här är strukturen på tabellen vi skapade:
+---------+-------------+------+-----+---------+-------+ | 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)
Efter att tabellen är skapad är nästa steg att skapa en trigger. Låt oss använda argumentet BEFORE INSERT.
Namnet på triggern jag skapat är ”marks”. Så fort tabellen ändras med elevens betyg kommer triggern att automatiskt beräkna den totala betygspoängen.
CREATE TRIGGER marks BEFORE INSERT ON student FOR EACH ROW set new.total=new.maths+new.physics+new.biology+new.social;
Eftersom vi måste ändra radinformation snarare än att arbeta med den gamla har vi definierat ”total” med ett nytt klassnamn. Alla efterföljande uttryck har prefixet new, med hjälp av punktoperatorn. Nu lägger vi till värden för varje rad och ser resultatet. Inledningsvis är det totala betyget 0 för varje elev.
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);
Triggersatsen aktiveras automatiskt när data infogas i elevtabellen. Varje elevs totala betyg beräknas av triggern. Låt oss se om triggern har anropats med hjälp av en SELECT-sats.
SELECT * FROM table_name;
Och här är det slutliga resultatet:
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)
I resultatet ovan ser du att alla ämnesbetyg har adderats automatiskt för varje elev. Vi kan därmed konstatera att triggern har aktiverats framgångsrikt.
Ytterligare triggeroperationer
Vi kan utföra många operationer med hjälp av triggers. Vissa operationer är enkla medan andra är mer komplexa, men när man väl förstår frågeställningarna blir det lätt att följa med. Med hjälp av Transact-SQL-satser kan du aktivera, inaktivera eller ta bort triggers med följande kommandon:
Fråga för att kontrollera om en specifik trigger finns
Detta kommando söker efter en specifik trigger i hela databasen.
SELECT * FROM [sys].[triggers] WHERE [name] = 'Trigger_name'
Fråga för att visa triggers
Alla triggers som finns i den aktiva databasen visas med hjälp av följande uttalande.
SHOW TRIGGERS;
Fråga för att inaktivera trigger
Kommandot nedan inaktiverar triggern i den aktuella databasen.
DISABLE TRIGGER trigger_name ON DATABASE;
Du kan också ange ett visst tabellnamn för att inaktivera en trigger.
DISABLE TRIGGER trigger_name ON table_name;
Fråga för att aktivera trigger
Följande kommando avaktiverar först en specifik trigger som definierats i den angivna tabellen i den aktiva databasen, innan den återaktiveras.
ALTER TABLE table_name DISABLE TRIGGER trigger_name ALTER TABLE table_name ENABLE TRIGGER trigger_name
Triggern måste inaktiveras innan du försöker aktivera den.
Fråga för att aktivera eller inaktivera alla triggers i en tabell
Med hjälp av SQL-satsen ovan kan vi avaktivera eller aktivera alla tabelltriggers samtidigt genom att ersätta ”ALL” istället för ett specifikt triggernamn.
ALTER TABLE table_name DISABLE TRIGGER ALL ALTER TABLE table_name ENABLE TRIGGER ALL
Fråga för att ta bort eller släppa triggern
En trigger kan tas bort genom att ta bort den eller hela tabellen. Varje relaterad trigger tas också bort när en tabell tas bort.
DROP TRIGGER [trigger_name];
Närhelst en trigger tas bort, elimineras relaterad data från sys.objects datatabell.
Fördelar med triggers
- Det är lätt att skapa triggers. Själva triggern kan anropa lagrade funktioner och metoder.
- Användare kan implementera enkel revision med hjälp av triggers.
- Det går inte att skapa begränsningar över entiteter i SQL Server-databaser, men du kan emulera hur begränsningar fungerar genom att använda triggers.
- Integritetsbegränsningar kan implementeras över databaser med hjälp av triggers.
- Triggers kan vara användbara när gruppvalidering krävs istället för rad-för-rad-verifiering av ny data eller ändrade data.
Nackdelar med triggers
SQL-triggers är inte alltid det bästa valet på grund av begränsningar.
- Triggers måste dokumenteras noggrant.
- Triggers kan vara svåra att felsöka på grund av den samtidiga databaskörningen som inte alltid är tillgänglig för programkomponenter.
- DML-satser blir mer komplexa när triggers används.
- Även ett mindre problem med en trigger kan potentiellt leda till logiska fel i koden.
Slutsats
Triggers är mycket användbara komponenter i Transact-SQL och SQL, och du kan även använda dem i Oracle. Användningen av triggers är avgörande när man anropar lagrade metoder. Dessa SQL-triggers gör det möjligt att analysera aktivitetslinjer och bestämma hur man ska agera om det behövs. Du kan också söka efter en specifik tabell som är kopplad till en trigger för att hämta data.
Rekursion kan aktiveras av triggers. När en trigger i en tabell kör ett kommando på den överordnade tabellen aktiveras den andra iterationen av triggern, vilket kallas en rekursiv trigger. Detta är användbart för att hantera identitetskorrelation.
Dessutom styr triggers det uppdateringsmönster som databasen får acceptera. Det är mycket värdefullt för att upprätthålla dataintegritetsbegränsningar i ett databassystem om SQL-begränsningsnycklar som primärnyckel och främmande nyckel inte finns.
Jag hoppas att den här artikeln har hjälpt dig att lära dig mer om SQL-triggers.
Om du vill lära dig mer om databaser på djupet finns det bra resurser för att lära dig SQL och NoSQL: länk till resurserna.