Triggers är databasenheter i SQL Server. Tekniskt sett är de en speciell klass av funktionsanrop som svarar på specifika databasoperationer.
Denna viktiga guide kommer att ge dig djupgående information om SQL Triggers som kan vara mycket användbar i ditt yrke. Låt oss börja!
Innehållsförteckning
Vad är SQL-utlösare?
Ordet ”trigger” beskriver ett påstående om att en server automatiskt exekverar frågan varje gång innehållet i databasen ändras.
En trigger är en grupp speciellt namngivna SQL-frågor som lagras i minnesutrymmet. Det är en specifik typ av funktionsanrop som omedelbart anropas när en databashändelse äger rum. Varje trigger har en tabell tilldelad.
En trigger kan till exempel aktiveras när en ny kolumn läggs till i en viss tabell eller om specifika poster ändras.
Enligt Microsoft Developer Network är triggers en speciell klass av lagrade procedurer. I en trigger-sats definierar vi initialt när triggern ska köras, och sedan tillhandahåller vi den åtgärd som ska vidtas efter att triggern har aktiverats.
Syntax:
CREATE TRIGGER trigger_name BEFORE/AFTER INSERT/UPDATE/DELETE ON tableName FOR EACH ROW SET operation [trigger_body];
Förklaring av varje parameter
- CREATE TRIGGER trigger_name – Det används för att konstruera en trigger eller för att ändra namnet på en befintlig trigger.
- FÖRE/EFTER – Denna fråga används för att definiera utlösarens exekveringstid (före eller efter en viss händelse).
- INSERT/UPDATE/DELETE – Detta beskriver den åtgärd vi vill vidta på tabellerna.
- ON tableName – Här definierar vi tabellnamnet för att ställa in en trigger.
- FÖR VARJE RAD – Detta uttalande relaterar till radutlösare, vilket betyder att utlösare kommer att exekveras när en rad ändras.
- trigger_body – Den anger åtgärden som ska vidtas när triggern aktiveras.
Triggers är lagrade funktioner med distinkta identiteter som gör att vi kan återanvända frågor som redan har körts och lagrats säkert i minnet. Låt oss nu försöka förstå varför SQL behöver dem.
Triggers används oftast för att reglera distributionen av kod närhelst en händelse äger rum. För att uttrycka det på ett annat sätt, att använda triggers är det idealiska valet om du kräver att ett specifikt kodfragment ständigt körs som svar på en specificerad händelse.
Följande är några fördelar med att använda triggers i SQL-databasoperationer.
Referensintegritet är en viktig kärnegenskap hos relationsdatabassystem. Detta betyder att data som lagras i databassystemet alltid måste vara korrekta för varje transaktion och varje operation.
Om två tabeller finns i separata databaser eller system, finns det inget sätt att säkerställa datavalidering inom dem med hjälp av begränsningsvärden. I en sådan situation är triggers det enda alternativet för utförande.
Kombination av triggerargument
För varje tabell kan vi specificera sex olika triggertyper. Dessa är kombinationen av Trigger-argument som ingår i SQL-utlösare på radnivå.
FÖRE INSERT: Dessa utlösare utför åtgärden på raderna innan några INSERT-operationer utförs i den angivna tabellen eller i databasen.
EFTER INSERT: Den utför åtgärden på rader omedelbart efter någon databas INSERT-aktivitet.
FÖRE UPPDATERING: Med dessa utlösare utförs en funktion på raderna innan en UPPDATERING utförs på databasen.
EFTER UPPDATERING: Den utför åtgärden på rader omedelbart efter en databas eller specifik tabell UPPDATERING aktivitet.
FÖRE DELETE: Den utför en viss operation på rader även innan databasen eller tabellen utsätts för en DELETE-åtgärd.
EFTER DELETE: Dessa utlösare utför åtgärden på raderna efter varje DELETE-transaktion.
Typer av SQL-utlösare
SQL-utlösare är lagrade funktioner som körs omedelbart när specifika händelser inträffar. Det liknar händelsestyrd schemaläggning. De efterföljande situationerna kan starta exekveringen av triggers.
DML Triggers – DML står för Data Manipulation Language. Kodexekvering som reaktion på datamodifiering är möjlig med hjälp av DML Triggers. Denna utlösare aktiveras när DML-kommandon som INSERT, UPDATE och DELETE exekveras. Dessa kallas även ”Table Level Triggers”.
DDL Triggers – DDL står för Data Definition Language. DDL-utlösare gör det möjligt för oss att köra kod som reaktion på databasschemaändringar, såsom att lägga till eller ta bort tabeller, eller serverhändelser, till exempel när en användare checkar in. Dessa kallas ”Databasnivåutlösare”.
Dessa utlösare kan aktiveras när vissa DDL-satser som CREATE, ALTER eller DROP exekveras i den aktiva databasen. Dessa kan också användas för att hålla ett öga på och hantera de aktiviteter som utförs.
LOGON-utlösare – När någon LOGON-händelse (start, inloggning, utloggning, avstängning) inträffar, anropas inloggningsutlösare omedelbart. De utförs endast efter en användarautentiseringsprocess även innan användartransaktionen initieras. LOGON-triggarna kommer inte att utlösas om auktoriseringen misslyckas.
Dessa utlösare kan användas för att registrera inloggningshistorik eller upprätta en händelsebegränsning för en viss inloggning, bland andra revisions- och identitetshanteringsfunktioner för serveranslutningar.
CLR Triggers – CLR står för Common Language Runtime. CLR-triggare är verkligen en unik undergrupp av triggers som mestadels bygger på CLR inom .NET-tekniken. Dessa utlösare är användbara om utlösaren behöver utföra många beräkningar eller behöver relatera till en annan entitet än SQL.
DML- och DDL-utlösare kan verkligen konstrueras genom att möjliggöra kodning av CLR-utlösare som stöds i .NET-tekniker inklusive Visual Basic, C# och F-sharp.
Exempel på SQL Server Trigger
Låt oss förstå dessa triggerkoncept med ett exempel.
Låt oss först skapa en databas med SQL-satser.
CREATE DATABASE testdb; use testdb;
Här har jag angett en ”testdb” som namn på databasen. Och 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 studentuppgifterna. Och här är kommandot för att beskriva tabellens struktur. Här är ”student” det tabellnamn jag har angett.
DESC student;
Nedan är strukturen på tabellen jag har skapat.
+---------+-------------+------+-----+---------+-------+ | 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)
När du har skapat en tabell är nästa steg att ställa in en utlösare. Låt oss försöka använda argumentet BEFORE INSERT.
Namnet på utlösaren jag har skapat är ”märken”. Så snart tabellen ändras med elevens betyg, försöker triggern nedan att fastställa elevens totalbetyg automatiskt.
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 ersätta raddata snarare än att arbeta med de gamla, har vi definierat ”total” med ett nytt klassnamn, och alla efterföljande uttryck prefixeras med nya nyckelord efter total med hjälp av punktoperatorn. Nu kommer vi att lägga till värden på varje rad och se 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 utlöses automatiskt när data infogas i elevtabellen i detta fall. Varje elevs totala poäng kommer att beräknas av utlösaren. Låt oss nu se om triggern anropas eller inte med hjälp av en SELECT-sats.
SELECT * FROM table_name;
Och här är slutresultatet.
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 kan du se att alla ämnesbetyg läggs till automatiskt för varje elev. Så vi kan dra slutsatsen att utlösaren anropades framgångsrikt.
Ytterligare triggeroperationer
Vi kan utföra många operationer med hjälp av triggers. Vissa kan vara enkla och vissa kan vara lite komplexa, men när vi väl går igenom frågorna är det lätt att förstå. Genom att använda Transact-SQL-satser kan du aktivera, inaktivera eller ta bort utlösare med hjälp av följande kommandon.
Fråga för att kontrollera om en specifik trigger finns där eller inte
Detta kommando söker efter den angivna utlösaren i hela databasen.
SELECT * FROM [sys].[triggers] WHERE [name] = 'Trigger_name'
Fråga för att visa triggers
Alla triggers som är tillgängliga i den aktiva databasen kommer att visas av följande uttalande.
SHOW TRIGGERS;
Fråga för att inaktivera trigger
Kommandot nedan inaktiverar triggern i arbetsdatabasen.
DISABLE TRIGGER trigger_name ON DATABASE;
Du kan också ange ett visst tabellnamn för att inaktivera en utlösare.
DISABLE TRIGGER trigger_name ON table_name;
Fråga för att aktivera trigger
Följande kommando avaktiverar först en specifik utlösare som definierades 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
Utlösaren måste inaktiveras innan du försöker aktivera den,
Fråga för att aktivera eller inaktivera alla utlösare i en tabell
Med hjälp av ovanstående SQL-sats kan vi avaktivera eller aktivera alla tabelltriggare samtidigt genom att ersätta ”ALLA” istället för ett specifikt triggernamn.
ALTER TABLE table_name DISABLE TRIGGER ALL ALTER TABLE table_name ENABLE TRIGGER ALL
Fråga att ta bort eller släppa utlösaren
En trigger kan elimineras genom att ta bort den eller hela tabellen. Varje relaterad utlösare tas också bort när en tabell tas bort.
DROP TRIGGER [trigger_name];
Närhelst en utlösare tas bort, elimineras relaterade data från sys.objects-datatabellen.
Fördelar med triggers
- Det är enkelt att bygga utlösare och själva triggern kan anropa lagrade funktioner och metoder.
- Användare kan implementera enkel revision med hjälp av triggers.
- Tragiskt nog kan du inte skapa begränsningar över entiteter i databassystem med SQL Server, även om du kan emulera driften av begränsningar genom att använda triggers.
- Integritetsbegränsningar kan implementeras över databaser med hjälp av triggers.
- När gruppvalidering krävs snarare än rad-för-rad-verifiering av nyinmatade eller ändrade data, kan utlösare vara till hjälp.
Nackdelar med triggers
SQL-utlösare kanske inte är det bästa valet i vissa situationer på grund av deras begränsningar.
- Triggers måste dokumenteras noggrant.
- På grund av samtidig databaskörning som kanske inte är tillgänglig för programkomponenter, kan utlösare vara utmanande att felsöka.
- DML-satser blir mer komplexa när triggers används.
- Även ett mindre triggerproblem har potential att leda till logiska fel i uttalandet.
Slutsats
Triggers är mycket användbara komponenter i Transact-SQL och SQL, och du kan använda dem i Oracle också. Användningen av triggers är avgörande när man anropar lagrade metoder. Dessa SQL-utlösare låter oss analysera aktivitetens tidslinjer och bestämma hur vi ska svara på dem om det behövs. Vi kan också leta efter en viss tabell som är kopplad till en trigger för att hämta data.
Rekursion kan aktiveras av triggers. Närhelst en trigger i en tabell kör ett kommando på den överordnade tabellen, aktiveras den andra iterationen av triggern, och detta kallas en rekursiv trigger. Detta hjälper när man försöker lösa en identitetskorrelation.
Dessutom reglerar triggers det uppdateringsmönster som databasen tillåts acceptera. Det är mycket fördelaktigt att behålla dataintegritetsbegränsningarna i databassystemet om SQL-begränsningsnycklar inte finns, främst primärnyckeln och främmande nyckel.
Jag hoppas att du tyckte att den här artikeln var till hjälp för att lära dig mer om SQL-utlösare.
Om du vill lära dig databaser på djupet, här är några utmärkta resurser för att lära dig SQL och NoSQL.