Triggere er databaseenheder i SQL Server. Teknisk set er de en særlig klasse af funktionskald, der reagerer på specifikke databaseoperationer.
Denne essentielle guide vil give dig dybdegående information om SQL Triggers, som kan være ret nyttige i dit erhverv. Lad os komme igang!
Indholdsfortegnelse
Hvad er SQL-triggere?
Ordet “trigger” beskriver en erklæring om, at en server automatisk udfører forespørgslen, hver gang indholdet i databasen ændres.
En trigger er en gruppe af specielt navngivne SQL-forespørgsler, der er gemt i hukommelsespladsen. Det er en specifik type funktionskald, der straks påkaldes, hver gang en databasehændelse finder sted. Hver trigger har en tabel tildelt.
For eksempel kan en trigger aktiveres, når en ny kolonne føjes til en bestemt tabel, eller hvis specifikke poster ændres.
Ifølge Microsoft Developer Network er triggere en særlig klasse af lagrede procedurer. I en trigger-sætning definerer vi til at begynde med, hvornår triggeren skal køres, og derefter angiver vi den handling, der skal udføres, efter at triggeren er blevet aktiveret.
Syntaks:
CREATE TRIGGER trigger_name BEFORE/AFTER INSERT/UPDATE/DELETE ON tableName FOR EACH ROW SET operation [trigger_body];
Forklaring af hver parameter
- CREATE TRIGGER trigger_name – Det bruges til at konstruere en trigger eller til at ændre navnet på en eksisterende trigger.
- FØR/EFTER – Denne forespørgsel bruges til at definere triggerens eksekveringstid (før eller efter en bestemt hændelse).
- INSERT/UPDATE/DELETE – Dette beskriver den handling, vi ønsker at udføre på tabellerne.
- ON tableName – Her definerer vi tabelnavnet for at opsætte en trigger.
- FOR HVER RÆKKE – Denne erklæring relaterer sig til rækkeudløser, hvilket betyder, at udløsere vil blive udført, hver gang en række ændres.
- trigger_body – Det specificerer den handling, der skal udføres, når triggeren aktiveres.
Triggere er lagrede funktioner med karakteristiske identiteter, der gør os i stand til at genbruge forespørgsler, der allerede er blevet udført og gemt sikkert i hukommelsen. Lad os nu prøve at forstå, hvorfor SQL har brug for dem.
Triggere bruges for det meste til at regulere implementeringen af kode, når en hændelse finder sted. For at sige det på en anden måde er brug af triggere det ideelle valg, hvis du kræver, at et specifikt kodefragment konstant køres som svar på en specificeret hændelse.
Følgende er nogle fordele ved at bruge triggere i SQL-databaseoperationer.
Referenceintegritet er en central kerneegenskab ved relationelle databasesystemer. Dette betyder, at de data, der opbevares i databasesystemet, altid skal være nøjagtige for hver transaktion og hver operation.
Hvis to tabeller er placeret på separate databaser eller systemer, er der ikke en måde at sikre datavalidering i dem ved hjælp af begrænsningsværdier. I en sådan situation er triggere den eneste mulighed for udførelse.
Kombination af triggerargumenter
For hver tabel kan vi specificere seks forskellige triggertyper. Disse er kombinationen af Trigger-argumenter inkluderet i SQL-udløsere på rækkeniveau.
FØR INSERT: Disse triggere udfører handlingen på rækkerne, før der udføres nogen INSERT-handlinger i den angivne tabel eller i databasen.
EFTER INSERT: Den udfører handlingen på rækker umiddelbart efter enhver database INSERT-aktivitet.
FØR OPDATERING: Med disse triggere udføres en funktion på rækkerne før en OPDATERING udføres på databasen.
EFTER OPDATERING: Den udfører handlingen på rækker umiddelbart efter enhver database eller specifik tabel OPDATERING aktivitet.
FØR SLET: Den udfører en bestemt handling på rækker, selv før databasen eller tabellen udsættes for en SLET-handling.
EFTER SLETNING: Disse udløsere udfører handlingen på rækkerne efter hver SLET-transaktion.
Typer af SQL-triggere
SQL-triggere er lagrede funktioner, der kører med det samme, når specifikke hændelser opstår. Det ligner begivenhedsdrevet planlægning. De efterfølgende situationer kan starte udførelsen af triggere.
DML Triggers – DML står for Data Manipulation Language. Kodeeksekvering som reaktion på dataændringer er muliggjort ved hjælp af DML Triggers. Denne trigger aktiveres, når DML-kommandoer som INSERT, UPDATE og DELETE udføres. Disse kaldes også “Table Level Triggers”.
DDL Triggers – DDL står for Data Definition Language. DDL Triggers gør det muligt for os at køre kode som reaktion på databaseskemaændringer, såsom tilføjelse eller sletning af tabeller, eller serverhændelser, såsom når en bruger tjekker ind. Disse kaldes “Database Level Triggers”.
Disse triggere kan aktiveres, når visse DDL-sætninger som CREATE, ALTER eller DROP udføres i den aktive database. Disse kan også bruges til at holde øje med og styre de aktiviteter, der udføres.
LOGON-triggere – Når en LOGON-hændelse (start, login, logout, shutdown) opstår, aktiveres logon-triggere med det samme. De udføres kun efter en brugergodkendelsesproces, selv før brugertransaktionen påbegyndes. LOGON-triggerne udløses ikke, hvis godkendelsen mislykkes.
Disse udløsere kan bruges til at registrere loginhistorik eller etablere en hændelsesbegrænsning for et bestemt login, blandt andre revisions- og identitetsstyringsfunktioner for serverforbindelser.
CLR Triggers – CLR står for Common Language Runtime. CLR-triggere er faktisk en unik undergruppe af triggere, der hovedsagelig er bygget på CLR inden for .NET-teknologien. Disse triggere er nyttige, hvis triggeren skal udføre mange beregninger eller skal relatere til en anden enhed end SQL.
DML- og DDL-triggere kan faktisk konstrueres ved at aktivere kodning af understøttede CLR-triggere i .NET-teknologier, herunder Visual Basic, C# og F-sharp.
Eksempel på SQL Server Trigger
Lad os forstå disse triggerkoncepter med et eksempel.
Lad os først oprette en database ved hjælp af SQL-sætninger.
CREATE DATABASE testdb; use testdb;
Her har jeg givet en “testdb” som navn på databasen. Og næste skridt er at lave en tabel.
CREATE TABLE student( name varchar(25), id int(2), maths int(2), physics int(2), biology int(2), social int(2), total int(2) );
Jeg har lavet en tabel til opbevaring af elevoplysninger. Og her er kommandoen til at beskrive tabellens struktur. Her er “elev” det bordnavn, jeg har givet.
DESC student;
Nedenfor er strukturen på den tabel, jeg har lavet.
+---------+-------------+------+-----+---------+-------+ | 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 oprettet en tabel, er næste trin at konfigurere en trigger. Lad os prøve at bruge BEFORE INSERT argumentet.
Navnet på den udløser, jeg har oprettet, er “mærker”. Så snart tabellen er ændret med elevens karakterer, forsøger triggeren nedenfor automatisk at bestemme elevens samlede karakter.
CREATE TRIGGER marks BEFORE INSERT ON student FOR EACH ROW set new.total=new.maths+new.physics+new.biology+new.social;
Da vi er forpligtet til at erstatte rækkedata i stedet for at arbejde med de gamle, har vi defineret “total” ved hjælp af et nyt klassenavn, og alle efterfølgende udtryk er præfikset med nye nøgleord efter total ved hjælp af prikoperatoren. Nu vil vi tilføje værdier til hver række og se resultaterne. I første omgang er den samlede karakter 0 for hver 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);
Trigger-sætningen udløses automatisk, når data indsættes i elevtabellen i dette tilfælde. Hver elevs samlede karakterer vil blive beregnet af triggeren. Lad os nu se, om triggeren aktiveres eller ej ved hjælp af en SELECT-sætning.
SELECT * FROM table_name;
Og her er det endelige output.
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 ovenstående resultat kan du se, at alle fagkarakterer automatisk tilføjes for hver elev. Så vi kan konkludere, at triggeren blev aktiveret med succes.
Yderligere triggeroperationer
Vi kan udføre mange operationer ved hjælp af triggere. Nogle kan være enkle og nogle kan være lidt komplekse, men når vi har gennemgået forespørgslerne, er det let at forstå. Ved at bruge Transact-SQL-sætninger kan du aktivere, deaktivere eller slette triggerne ved hjælp af følgende kommandoer.
Forespørgsel for at kontrollere, om en specifik trigger er der eller ej
Denne kommando søger efter den angivne trigger i hele databasen.
SELECT * FROM [sys].[triggers] WHERE [name] = 'Trigger_name'
Forespørgsel for at vise triggere
Alle de triggere, der er tilgængelige i den aktive database, vil blive vist med følgende sætning.
SHOW TRIGGERS;
Forespørgsel om at deaktivere trigger
Nedenstående kommando deaktiverer triggeren i arbejdsdatabasen.
DISABLE TRIGGER trigger_name ON DATABASE;
Du kan også angive et bestemt tabelnavn for at deaktivere en trigger.
DISABLE TRIGGER trigger_name ON table_name;
Forespørgsel om at aktivere trigger
Følgende kommando deaktiverer først en specifik trigger, der blev defineret på den angivne tabel i den aktive database, før den genaktiveres.
ALTER TABLE table_name DISABLE TRIGGER trigger_name ALTER TABLE table_name ENABLE TRIGGER trigger_name
Udløseren skal deaktiveres, før du forsøger at aktivere den,
Forespørgsel om at aktivere eller deaktivere alle udløsere i en tabel
Ved at bruge ovenstående SQL-sætning kan vi deaktivere eller aktivere alle tabeltriggere ad gangen ved at erstatte “ALL” i stedet for et specifikt triggernavn.
ALTER TABLE table_name DISABLE TRIGGER ALL ALTER TABLE table_name ENABLE TRIGGER ALL
Forespørgsel om at slette eller slippe udløser
En trigger kan elimineres ved at slette den eller hele tabellen. Hver relaterede trigger slettes også, når en tabel slettes.
DROP TRIGGER [trigger_name];
Når en trigger slettes, fjernes de relaterede data fra sys.objects-datatabellen.
Fordele ved triggere
- Det er nemt at bygge triggere, og selve triggeren kan påkalde gemte funktioner og metoder.
- Brugere kan implementere simpel revision ved hjælp af triggere.
- Tragisk nok kan du ikke oprette begrænsninger på tværs af enheder i databasesystemer med SQL Server, selvom du kan efterligne driften af begrænsninger ved at bruge triggere.
- Integritetsbegrænsninger kan implementeres på tværs af databaser ved hjælp af triggere.
- Når gruppevalidering er påkrævet i stedet for række-for-række-bekræftelse af nyligt indtastede eller ændrede data, kan triggere være nyttige.
Ulemper ved triggere
SQL Triggere er muligvis ikke det bedste valg i nogle situationer på grund af deres begrænsninger.
- Udløsere skal dokumenteres nøjagtigt.
- På grund af samtidig databasekørsel, som muligvis ikke er tilgængelig for applikationskomponenter, kan triggere være udfordrende at fejlfinde.
- DML-sætninger bliver mere komplekse, når der bruges triggere.
- Selv et mindre udløsende problem har potentiale til at føre til logiske fejl i erklæringen.
Konklusion
Triggere er meget nyttige komponenter i Transact-SQL og SQL, og du kan også bruge dem i Oracle. Brugen af triggere er afgørende, når du kalder lagrede metoder. Disse SQL-triggere giver os mulighed for at analysere aktivitetstidslinjerne og bestemme, hvordan vi skal reagere på dem, hvis det er nødvendigt. Vi kan også tjekke for en bestemt tabel, der er forbundet med en trigger for at hente data.
Rekursion kan aktiveres af triggere. Når en trigger på en tabel udfører en kommando på den overordnede tabel, aktiveres den anden iteration af triggeren, og dette er kendt som en rekursiv trigger. Dette hjælper, mens man forsøger at løse en identitetskorrelation.
Derudover regulerer triggere det opdateringsmønster, som databasen har tilladelse til at acceptere. Det er meget fordelagtigt at beholde dataintegritetsbegrænsningerne i databasesystemet, hvis SQL-begrænsningsnøgler ikke eksisterer, primært primærnøglen og fremmednøglen.
Jeg håber, du fandt denne artikel nyttig til at lære om SQL Triggers.
Hvis du ønsker at lære databaser i dybden, er her nogle fremragende ressourcer til at lære SQL og NoSQL.