Triggere er databaseenheter i SQL Server. Teknisk sett er de en spesiell klasse funksjonskall som reagerer på spesifikke databaseoperasjoner.
Denne essensielle guiden vil gi deg grundig informasjon om SQL-utløsere som kan være ganske nyttige i ditt yrke. La oss komme i gang!
Innholdsfortegnelse
Hva er SQL-utløsere?
Ordet «trigger» beskriver en setning om at en server automatisk utfører spørringen hver gang innholdet i databasen endres.
En utløser er en gruppe spesielt navngitte SQL-spørringer som er lagret i minneplassen. Det er en spesifikk type funksjonskall som umiddelbart påkalles når en databasehendelse finner sted. Hver trigger har en tabell tilordnet.
For eksempel kan en utløser aktiveres når en ny kolonne legges til i en bestemt tabell eller hvis spesifikke poster endres.
I følge Microsoft Developer Network er triggere en spesiell klasse av lagrede prosedyrer. I en trigger-setning definerer vi først når triggeren skal kjøres, og deretter gir vi handlingen som skal utføres etter at triggeren er aktivert.
Syntaks:
CREATE TRIGGER trigger_name BEFORE/AFTER INSERT/UPDATE/DELETE ON tableName FOR EACH ROW SET operation [trigger_body];
Forklaring av hver parameter
- CREATE TRIGGER trigger_name – Den brukes til å konstruere en trigger eller endre navnet på en eksisterende trigger.
- FØR/ETTER – Denne spørringen brukes til å definere utløserens utførelsestid (før eller etter en bestemt hendelse).
- INSERT/UPDATE/DELETE – Dette beskriver handlingen vi ønsker å utføre på bordene.
- ON tableName – Her definerer vi tabellnavnet for å sette opp en trigger.
- FOR HVER RAD – Denne setningen er relatert til radutløser, noe som betyr at utløsere vil bli utført hver gang en rad endres.
- trigger_body – Den spesifiserer handlingen som skal utføres når triggeren aktiveres.
Triggere er lagrede funksjoner med særegne identiteter som gjør oss i stand til å gjenbruke spørringer som allerede er utført og lagret sikkert i minnet. La oss nå prøve å forstå hvorfor SQL trenger dem.
Triggere brukes for det meste til å regulere distribusjonen av kode når en hendelse finner sted. For å si det på en annen måte, bruk av triggere er det ideelle valget hvis du krever at et spesifikt kodefragment kjøres konstant som svar på en spesifisert hendelse.
Følgende er noen fordeler ved å bruke triggere i SQL-databaseoperasjoner.
Referensiell integritet er en sentral kjerneegenskap til relasjonsdatabasesystemer. Dette betyr at dataene som holdes i databasesystemet alltid må være nøyaktige for hver transaksjon og hver operasjon.
Hvis to tabeller er plassert i separate databaser eller systemer, er det ingen måte å sikre datavalidering i dem ved å bruke begrensningsverdier. I en slik situasjon er triggere det eneste alternativet for utførelse.
Kombinasjon av triggerargumenter
For hver tabell kan vi spesifisere seks forskjellige triggertyper. Dette er kombinasjonen av Trigger-argumenter inkludert i SQL-utløsere på radnivå.
FØR INSERT: Disse utløserne utfører handlingen på radene før noen INSERT-operasjoner utføres i den angitte tabellen eller i databasen.
ETTER INSERT: Den utfører handlingen på rader umiddelbart etter enhver database INSERT-aktivitet.
FØR OPPDATERING: Med disse triggerne utføres en funksjon på radene før en OPPDATERING utføres på databasen.
ETTER OPPDATERING: Den utfører handlingen på rader umiddelbart etter enhver database- eller spesifikk tabellOPPDATERING-aktivitet.
FØR SLETT: Den utfører en bestemt operasjon på rader selv før databasen eller tabellen blir utsatt for en SLETT-handling.
ETTER SLETT: Disse utløserne utfører handlingen på radene etter hver SLETT-transaksjon.
Typer SQL-utløsere
SQL-utløsere er lagrede funksjoner som kjører umiddelbart når bestemte hendelser inntreffer. Det ligner hendelsesdrevet planlegging. De påfølgende situasjonene kan starte utførelsen av triggere.
DML Triggers – DML står for Data Manipulation Language. Kodekjøring som reaksjon på datamodifisering er muliggjort ved hjelp av DML-utløsere. Denne utløseren aktiveres når DML-kommandoer som INSERT, UPDATE og DELETE utføres. Disse kalles også «Table Level Triggers».
DDL Triggers – DDL står for Data Definition Language. DDL-utløsere gjør det mulig for oss å kjøre kode som reaksjon på endringer i databaseskjemaer, for eksempel å legge til eller slette tabeller, eller serverhendelser, for eksempel når en bruker sjekker inn. Disse kalles «Databasenivåutløsere».
Disse triggerne kan aktiveres når visse DDL-setninger som CREATE, ALTER eller DROP kjøres i den aktive databasen. Disse kan også brukes til å holde et øye med og administrere aktivitetene som utføres.
LOGON-utløsere – Når en LOGON-hendelse (oppstart, pålogging, utlogging, avslutning) inntreffer, aktiveres påloggingsutløsere umiddelbart. De utføres kun etter en brukerautentiseringsprosess selv før brukertransaksjonen igangsettes. LOGON-utløserne vil ikke bli utløst hvis autorisasjonen mislykkes.
Disse triggerne kan brukes til å registrere påloggingshistorikk eller etablere en hendelsesbegrensning for en bestemt pålogging, blant andre revisjons- og identitetsadministrasjonsfunksjoner for servertilkoblinger.
CLR Triggers – CLR står for Common Language Runtime. CLR-triggere er faktisk en unik undergruppe av triggere som hovedsakelig er bygget på CLR innenfor .NET-teknologien. Disse utløserne er nyttige hvis utløseren trenger å utføre mange beregninger eller må forholde seg til en annen enhet enn SQL.
DML- og DDL-utløsere kan faktisk konstrueres ved å aktivere koding av støttede CLR-utløsere i .NET-teknologier, inkludert Visual Basic, C# og F-sharp.
Eksempel på SQL Server Trigger
La oss forstå disse triggerkonseptene med et eksempel.
Først, la oss lage en database ved hjelp av SQL-setninger.
CREATE DATABASE testdb; use testdb;
Her har jeg gitt en «testdb» som navn på databasen. Og neste trinn er å lage 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) );
Jeg har laget en tabell for lagring av elevdetaljer. Og her er kommandoen for å beskrive strukturen til tabellen. Her er «student» tabellnavnet jeg har gitt.
DESC student;
Nedenfor er strukturen til tabellen jeg har laget.
+---------+-------------+------+-----+---------+-------+ | 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)
Etter å ha opprettet en tabell, er neste trinn å sette opp en trigger. La oss prøve å bruke FØR INSERT-argumentet.
Navnet på utløseren jeg har laget er «merker». Så snart tabellen er modifisert med elevens karakterer, prøver utløseren nedenfor å bestemme elevens samlede karakter automatisk.
CREATE TRIGGER marks BEFORE INSERT ON student FOR EACH ROW set new.total=new.maths+new.physics+new.biology+new.social;
Siden vi er pålagt å erstatte raddata i stedet for å jobbe med de gamle, har vi definert «total» ved å bruke et nytt klassenavn, og alle påfølgende uttrykk er prefiks med nye nøkkelord etter total ved å bruke punktoperatoren. Nå vil vi legge til verdier til hver rad og se resultatene. I utgangspunktet er totalkarakteren 0 for hver student.
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);
Triggersetningen utløses automatisk når data settes inn i elevtabellen i dette tilfellet. Hver elevs totale karakterer vil bli beregnet av utløseren. La oss nå se om utløseren påkalles eller ikke ved å bruke en SELECT-setning.
SELECT * FROM table_name;
Og her er det endelige 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 ovenfor kan du se at alle fagkarakterer legges til automatisk for hver elev. Så vi kan konkludere med at utløseren ble påkalt.
Ytterligere triggeroperasjoner
Vi kan utføre mange operasjoner ved hjelp av triggere. Noen kan være enkle og noen kan være litt komplekse, men når vi har gått gjennom spørringene er det lett å forstå. Ved å bruke Transact-SQL-setninger kan du aktivere, deaktivere eller slette utløsere ved å bruke følgende kommandoer.
Spørring for å sjekke om en spesifikk utløser er der eller ikke
Denne kommandoen ser etter den angitte utløseren i hele databasen.
SELECT * FROM [sys].[triggers] WHERE [name] = 'Trigger_name'
Spørring for å vise utløsere
Alle triggere som er tilgjengelige i den aktive databasen vil vises med følgende setning.
SHOW TRIGGERS;
Spørsmål for å deaktivere utløser
Kommandoen nedenfor deaktiverer utløseren i arbeidsdatabasen.
DISABLE TRIGGER trigger_name ON DATABASE;
Du kan også angi et bestemt tabellnavn for å deaktivere en utløser.
DISABLE TRIGGER trigger_name ON table_name;
Spørring for å aktivere trigger
Følgende kommando deaktiverer først en spesifikk utløser som ble definert på den angitte tabellen i den aktive databasen før den aktiveres på nytt.
ALTER TABLE table_name DISABLE TRIGGER trigger_name ALTER TABLE table_name ENABLE TRIGGER trigger_name
Utløseren må deaktiveres før du prøver å aktivere den,
Spørring for å aktivere eller deaktivere alle utløsere i en tabell
Ved å bruke SQL-setningen ovenfor kan vi deaktivere eller aktivere alle tabellutløsere om gangen ved å erstatte «ALLE» i stedet for et spesifikt utløsernavn.
ALTER TABLE table_name DISABLE TRIGGER ALL ALTER TABLE table_name ENABLE TRIGGER ALL
Spørring for å slette eller slippe utløser
En trigger kan elimineres ved å slette den eller hele tabellen. Alle relaterte utløsere blir også slettet når en tabell slettes.
DROP TRIGGER [trigger_name];
Når en utløser slettes, elimineres de relaterte dataene fra sys.objects-datatabellen.
Fordeler med triggere
- Det er enkelt å bygge utløsere, og selve utløseren kan påkalle lagrede funksjoner og metoder.
- Brukere kan implementere enkel revisjon ved å bruke triggere.
- Tragisk nok kan du ikke opprette begrensninger på tvers av enheter i databasesystemer med SQL Server, selv om du kan emulere driften av begrensninger ved å bruke triggere.
- Integritetsbegrensninger kan implementeres på tvers av databaser ved å bruke triggere.
- Når gruppevalidering er nødvendig i stedet for rad-for-rad-verifisering av nylig innlagte eller endrede data, kan utløsere være nyttige.
Ulemper med triggere
SQL-utløsere er kanskje ikke det beste valget i enkelte situasjoner på grunn av deres begrensninger.
- Triggere må dokumenteres nøyaktig.
- På grunn av samtidig databasekjøring som kanskje ikke er tilgjengelig for applikasjonskomponenter, kan utløsere være utfordrende å feilsøke.
- DML-setninger blir mer komplekse når triggere brukes.
- Selv et mindre triggerproblem har potensial til å føre til logiske feil i uttalelsen.
Konklusjon
Triggere er svært nyttige komponenter i Transact-SQL og SQL, og du kan bruke dem i Oracle også. Bruken av triggere er avgjørende når du kaller lagrede metoder. Disse SQL-utløserne lar oss analysere aktivitetstidslinjene og bestemme hvordan vi skal svare på dem om nødvendig. Vi kan også se etter en bestemt tabell som er koblet til en trigger for å hente data.
Rekursjon kan aktiveres av triggere. Når en trigger på en tabell utfører en kommando på den overordnede tabellen, settes den andre iterasjonen av triggeren i gang, og dette er kjent som en rekursiv trigger. Dette hjelper mens du prøver å løse en identitetskorrelasjon.
I tillegg regulerer triggere oppdateringsmønsteret som databasen har tillatelse til å akseptere. Det er svært fordelaktig å beholde dataintegritetsbegrensningene i databasesystemet hvis SQL-begrensningsnøkler ikke eksisterer hovedsakelig primærnøkkelen og fremmednøkkelen.
Jeg håper du fant denne artikkelen nyttig for å lære om SQL-utløsere.
Hvis du ønsker å lære databaser i dybden, her er noen gode ressurser for å lære SQL og NoSQL.