A triggerek az SQL Server adatbázis-entitásai. Technikailag ezek a függvényhívások egy bizonyos osztálya, amely adott adatbázis-műveletekre válaszol.
Ez az alapvető útmutató alapos információkat nyújt az SQL Triggerekről, amelyek nagyon hasznosak lehetnek az Ön szakmájában. Kezdjük el!
Tartalomjegyzék
Mik azok az SQL triggerek?
A „trigger” szó azt az utasítást írja le, hogy a szerver automatikusan végrehajtja a lekérdezést minden alkalommal, amikor az adatbázis tartalma megváltozik.
A trigger speciálisan elnevezett SQL-lekérdezések csoportja, amelyek a memóriaterületen vannak tárolva. Ez egy speciális típusú függvényhívás, amely azonnal meghívásra kerül, amikor bármilyen adatbázis-esemény megtörténik. Minden triggerhez tartozik egy táblázat.
Például egy trigger aktiválható, amikor új oszlopot adnak hozzá egy adott táblához, vagy ha bizonyos rekordokat módosítanak.
A Microsoft Developer Network szerint a triggerek a tárolt eljárások egy bizonyos osztályát jelentik. A trigger utasításban először meghatározzuk, hogy az eseményindítót mikor kell futtatni, majd megadjuk azt a műveletet, amelyet a trigger aktiválása után kell végrehajtani.
Szintaxis:
CREATE TRIGGER trigger_name BEFORE/AFTER INSERT/UPDATE/DELETE ON tableName FOR EACH ROW SET operation [trigger_body];
Az egyes paraméterek magyarázata
- CREATE TRIGGER trigger_name – trigger létrehozására vagy egy meglévő trigger nevének megváltoztatására szolgál.
- ELŐTT/UTÁNA – Ez a lekérdezés a trigger végrehajtási idejének meghatározására szolgál (egy bizonyos esemény előtt vagy után).
- BESZÚRÁS/FRISSÍTÉS/TÖRLÉS – Ez leírja a táblákon végrehajtani kívánt műveletet.
- ON tableName – Itt adjuk meg a tábla nevét a trigger beállításához.
- FOR EACH ROW – Ez az utasítás a sor triggerére vonatkozik, ami azt jelenti, hogy a triggerek végrehajtásra kerülnek, amikor egy sor megváltozik.
- trigger_body – Meghatározza a trigger aktiválásakor végrehajtandó műveletet.
A triggerek olyan tárolt függvények, amelyek megkülönböztető identitással rendelkeznek, és lehetővé teszik számunkra a már végrehajtott és biztonságosan a memóriában tárolt lekérdezések újrafelhasználását. Most próbáljuk megérteni, miért van szüksége rájuk az SQL-nek.
A triggereket többnyire a kód telepítésének szabályozására használják, amikor egy esemény bekövetkezik. Másképpen fogalmazva, a triggerek használata az ideális választás, ha egy adott kódrészletet folyamatosan futtatni kell egy adott eseményre válaszul.
Az alábbiakban bemutatunk néhány előnyt az SQL-adatbázis műveletekben való triggerek használatából.
A hivatkozási integritás a relációs adatbázis-rendszerek alapvető tulajdonsága. Ez azt jelenti, hogy az adatbázisrendszerben tárolt adatoknak minden tranzakciónál és műveletnél mindig pontosnak kell lenniük.
Ha két tábla különálló adatbázisokban vagy rendszereken található, nem biztosítható az adatok érvényesítése bennük a kényszerértékek használatával. Ilyen helyzetben a triggerek az egyetlen végrehajtási lehetőség.
Trigger argumentumok kombinációja
Minden táblához hat különböző triggertípust adhatunk meg. Ezek az SQL sorszintű triggerekben található Trigger argumentumok kombinációja.
BEFORE INSERT: Ezek a triggerek végrehajtják a műveletet a sorokon, mielőtt bármilyen INSERT műveletet végrehajtanának a megadott táblában vagy az adatbázisban.
AFTER INSERT: A műveletet közvetlenül az adatbázis INSERT tevékenységét követő sorokon hajtja végre.
FRISSÍTÉS ELŐTT: Ezekkel az eseményindítókkal a sorokban egy funkció végrehajtásra kerül, mielőtt egy FRISSÍTÉS műveletet hajtanának végre az adatbázison.
FRISSÍTÉS UTÁN: Azon a sorokon hajtja végre a műveletet, amelyek közvetlenül az adatbázis vagy adott tábla UPDATE tevékenységét követik.
TÖRLÉS ELŐTT: Egy bizonyos műveletet végrehajt a sorokon, még azelőtt, hogy az adatbázist vagy a táblát TÖRLÉS műveletnek vetnék alá.
TÖRLÉS UTÁN: Ezek a triggerek minden TÖRLÉS tranzakciót követő sorokon hajtják végre a műveletet.
Az SQL triggerek típusai
Az SQL triggerek olyan tárolt függvények, amelyek adott események bekövetkezésekor azonnal futnak. Az eseményvezérelt ütemezéshez hasonlít. A következő helyzetek elindíthatják a triggerek végrehajtását.
DML triggerek – A DML az adatmanipulációs nyelv rövidítése. Az adatmódosításokra reagáló kódvégrehajtás a DML triggerek segítségével lehetséges. Ez a trigger akkor aktiválódik, amikor olyan DML-parancsokat hajtanak végre, mint az INSERT, UPDATE és DELETE. Ezeket „táblaszintű triggereknek” is nevezik.
DDL triggerek – A DDL az adatdefiníciós nyelv rövidítése. A DDL triggerek lehetővé teszik számunkra, hogy kódot futtassunk az adatbázisséma változásaira, például táblák hozzáadására vagy törlésére, vagy szervereseményekre, például amikor a felhasználó bejelentkezik. Ezeket „adatbázisszintű triggereknek” nevezik.
Ezek a triggerek akkor aktiválhatók, amikor bizonyos DDL utasítások, például CREATE, ALTER vagy DROP végrehajtásra kerülnek az aktív adatbázisban. Ezek arra is használhatók, hogy szemmel tartsák és kezeljék a végrehajtott tevékenységeket.
LOGON triggerek – Bármilyen LOGON (indítás, bejelentkezés, kijelentkezés, leállítás) esemény bekövetkezik, a bejelentkezési triggerek azonnal meghívásra kerülnek. Ezeket csak a felhasználói hitelesítési folyamatot követően hajtják végre, még a felhasználói tranzakció kezdeményezése előtt is. A LOGON triggerek nem indulnak el, ha az engedélyezés sikertelen.
Ezek a triggerek használhatók a bejelentkezési előzmények rögzítésére vagy egy adott bejelentkezés eseménykorlátozásának megállapítására, többek között a kiszolgálókapcsolatok egyéb auditálási és identitáskezelési funkciói között.
CLR triggerek – A CLR a Common Language Runtime rövidítése. A CLR triggerek valóban a triggerek egy egyedülálló részhalmazát alkotják, amelyek többnyire a CLR-re épülnek a .NET technológián belül. Ezek a triggerek hasznosak, ha az eseményindítónak sok számítást kell végrehajtania, vagy az SQL-től eltérő entitáshoz kell kapcsolódnia.
A DML és DDL triggerek valóban létrehozhatók a támogatott CLR triggerek kódolásának engedélyezésével a .NET technológiákban, beleértve a Visual Basic-et, a C#-ot és az F-sharpet.
Minta SQL Server Trigger
Értsük meg ezeket a trigger fogalmakat egy példán keresztül.
Először hozzunk létre egy adatbázist SQL utasítások segítségével.
CREATE DATABASE testdb; use testdb;
Itt egy „testdb”-t adtam meg az adatbázis neveként. És a következő lépés egy táblázat létrehozása.
CREATE TABLE student( name varchar(25), id int(2), maths int(2), physics int(2), biology int(2), social int(2), total int(2) );
Létrehoztam egy táblázatot a tanulói adatok tárolására. És itt van a parancs a táblázat szerkezetének leírására. Itt a „tanuló” az általam megadott táblázatnév.
DESC student;
Alább látható az általam készített táblázat szerkezete.
+---------+-------------+------+-----+---------+-------+ | 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)
A táblázat létrehozása után a következő lépés egy trigger beállítása. Próbáljuk meg a BEFORE INSERT argumentumot használni.
Az általam létrehozott trigger neve „marks”. Amint a táblázat módosul a tanuló érdemjegyeivel, az alábbi trigger automatikusan megpróbálja meghatározni a tanuló általános osztályzatát.
CREATE TRIGGER marks BEFORE INSERT ON student FOR EACH ROW set new.total=new.maths+new.physics+new.biology+new.social;
Mivel a sorok adatait le kell cserélnünk ahelyett, hogy a régiekkel dolgoznánk, új osztálynévvel definiáltuk az „összes” kifejezést, és minden további kifejezést a pont operátor segítségével új kulcsszavakkal látunk el a total után. Most minden sorhoz hozzáadunk értékeket, és látni fogjuk az eredményeket. Kezdetben az összpontszám minden tanulónál 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);
Ebben az esetben a trigger utasítás automatikusan aktiválódik, amikor adatokat szúr be a tanulói táblába. Minden tanuló összpontszámát a trigger számítja ki. Most nézzük meg, hogy a trigger meghívva van-e vagy sem a SELECT utasítás használatával.
SELECT * FROM table_name;
És itt a végső kimenet.
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)
A fenti eredményben látható, hogy az összes tantárgyi jegy automatikusan hozzáadódik minden tanulóhoz. Megállapíthatjuk tehát, hogy a trigger sikeresen meg lett hívva.
További trigger műveletek
A triggerek segítségével számos műveletet végrehajthatunk. Lehet, hogy egyesek egyszerűek, mások kissé bonyolultak, de ha végigmegyünk a lekérdezéseken, könnyen érthető. A Transact-SQL utasítások használatával engedélyezheti, letilthatja vagy törölheti a triggereket a következő parancsokkal.
Lekérdezés annak ellenőrzésére, hogy van-e adott trigger vagy sem
Ez a parancs ellenőrzi a megadott triggert a teljes adatbázisban.
SELECT * FROM [sys].[triggers] WHERE [name] = 'Trigger_name'
Lekérdezés a triggerek megjelenítéséhez
Az aktív adatbázisban elérhető összes triggert a következő utasítás mutatja.
SHOW TRIGGERS;
Lekérdezés a trigger letiltásához
Az alábbi parancs deaktiválja a triggert a működő adatbázisban.
DISABLE TRIGGER trigger_name ON DATABASE;
A trigger letiltásához megadhat egy bizonyos táblanevet is.
DISABLE TRIGGER trigger_name ON table_name;
Lekérdezés a trigger engedélyezéséhez
A következő parancs először deaktivál egy adott triggert, amely az aktív adatbázis megadott tábláján volt definiálva, mielőtt újra engedélyezné.
ALTER TABLE table_name DISABLE TRIGGER trigger_name ALTER TABLE table_name ENABLE TRIGGER trigger_name
A triggert le kell tiltani, mielőtt megpróbálná engedélyezni,
Lekérdezés a táblázat összes triggerének engedélyezéséhez vagy letiltásához
A fenti SQL utasítás használatával egyszerre deaktiválhatjuk vagy aktiválhatjuk az összes tábla triggert úgy, hogy egy adott triggernév helyett „ALL”-t cserélünk.
ALTER TABLE table_name DISABLE TRIGGER ALL ALTER TABLE table_name ENABLE TRIGGER ALL
Lekérdezés a trigger törléséhez vagy eldobásához
Egy trigger kiküszöbölhető annak vagy az egész tábla törlésével. A tábla törlésekor minden kapcsolódó trigger is törlődik.
DROP TRIGGER [trigger_name];
Az eseményindító törlésekor a kapcsolódó adatok törlődnek a sys.objects adattáblából.
A triggerek előnyei
- A triggerek létrehozása egyszerű, és maga a trigger is meghívhat tárolt függvényeket és metódusokat.
- A felhasználók egyszerű auditálást hajthatnak végre triggerek segítségével.
- Tragikus módon nem hozhat létre megszorításokat az adatbázisrendszerek entitásai között az SQL Serverrel, bár a megszorítások működését emulálhatja triggerek használatával.
- Az integritási megszorítások több adatbázisban is megvalósíthatók triggerek segítségével.
- Ha az újonnan bevitt vagy módosított adatok soronkénti ellenőrzése helyett csoportos érvényesítésre van szükség, az aktiválók hasznosak lehetnek.
A triggerek hátrányai
Az SQL Triggerek bizonyos helyzetekben korlátaik miatt nem a legjobb választás.
- A triggereket pontosan dokumentálni kell.
- Az egyidejű adatbázis-végrehajtás miatt, amelyhez nem férhetnek hozzá az alkalmazás-összetevők, a triggerek hibakeresése kihívást jelenthet.
- A DML utasítások összetettebbé válnak, ha triggereket használnak.
- Még egy kisebb kiváltó probléma is logikai hibákhoz vezethet a nyilatkozatban.
Következtetés
A triggerek nagyon hasznos összetevői a Transact-SQL-nek és az SQL-nek, és az Oracle-ben is használhatod őket. A triggerek használata kulcsfontosságú a tárolt metódusok hívásakor. Ezek az SQL-triggerek lehetővé teszik számunkra, hogy elemezzük a tevékenységi idővonalakat, és szükség esetén meghatározzuk, hogyan reagáljunk rájuk. Azt is ellenőrizhetjük, hogy van-e egy bizonyos tábla, amely egy triggerhez csatlakozik az adatok beszerzéséhez.
A rekurzió triggerekkel engedélyezhető. Amikor egy tábla triggerje végrehajt egy parancsot a szülőtáblán, a trigger második iterációja elindul, és ezt rekurzív triggernek nevezik. Ez segít az identitás-korreláció megoldásában.
Ezenkívül az eseményindítók szabályozzák azt a frissítési mintát, amelyet az adatbázis elfogadhat. Nagyon előnyös az adatintegritási megszorítások megtartása az adatbázisrendszerben, ha az SQL kényszerkulcsok nem léteznek, főleg az elsődleges kulcs és az idegen kulcs.
Remélem, hasznosnak találta ezt a cikket az SQL Triggerek megismerésében.
Ha mélyrehatóan szeretné megtanulni az adatbázisokat, itt van néhány kiváló forrás az SQL és a NoSQL megtanulásához.