Trigger (basi di dati)
Il trigger, nelle basi di dati, è una procedura che viene eseguita in maniera automatica in coincidenza di un determinato evento, come ad esempio la cancellazione di un record di una tabella. In questo modo si ha a disposizione una tecnica per specificare e mantenere vincoli di integrità anche complessi. I trigger permettono agli utenti di specificare vincoli di integrità più complessi dato che un trigger è essenzialmente una procedura PL/SQL (Oracle),[1] Transact-SQL (Microsoft),[2] PL/pgSQL (PostgreSQL),[3] ecc.
Tale procedura è quindi associata ad una tabella e viene automaticamente richiamata dal motore del database quando una certa modifica (o evento) avviene all'interno della tabella. Le modifiche sulla tabella possono includere operazioni insert, update, e delete.[1]
Definizione[modifica | modifica wikitesto]
La specifica di una regola è generalmente effettuata attraverso il modello ECA (Event-Condition-Action):
L'evento (Event) può essere:
- un'operazione di aggiornamento del database
- un evento sistematico
- un evento esterno
La condizione (Condition), definisce la condizione da verificarsi prima di procedere all'esecuzione della regola. La condizione è facoltativa:
- se non viene specificata, la regola viene eseguita ogni volta che si verifica l'evento.
- se è specificata, la regola viene eseguita solo se la condizione risulta verificata.
L'azione (Action), di solito è una sequenza di comandi SQL e/o di codice scritto con linguaggi di programmazione proprietari (ad esempio PL/SQL nei database Oracle, o Transact-SQL su database Microsoft e Sybase), ma può essere anche una transazione sul database o un programma esterno.
La definizione di un trigger consiste nei seguenti componenti:
- nome trigger
CREATE [OR REPLACE] TRIGGER <nome trigger>
- collocazione temporale del trigger
BEFORE | AFTER | INSTEAD OF
- azione(i) del trigger
INSERT OR UPDATE [OF <colonna(e)>] OR DELETE ON <tabella>
- tipo di trigger (opzionale)
FOR EACH ROW
- restrizioni trigger (solo per triggers for each row)
WHEN (<condizione>)
- corpo del trigger
<blocco PL/SQL>
La clausola or replace ri-crea una precedente definizione del trigger qualora questo esista e abbia lo stesso <nome trigger>. Il nome di un trigger può essere scelto arbitrariamente, ma è convenzione comune utilizzare un nome che rifletta la tabella e l'evento(i) (nell'esempio, upd_ins_EMP). Un trigger può essere richiamato prima (before) o dopo (after) l'evento che causa l'attivazione del trigger.[1] L'evento che causa l'attivazione del trigger specifica prima (o dopo) quale operazione nella tabella <tabella> il trigger debba essere eseguito. Un singolo evento è un inserimento (insert), un aggiornamento (update) o una cancellazione (delete); gli eventi possono essere combinati usando la logica or.[1] Se il trigger deve essere eseguito soltanto quando certe colonne vengono aggiornate, queste colonne devono essere specificate dopo l'evento update.[1]
Trigger a livello di riga/istruzione[modifica | modifica wikitesto]
Al fine di programmare i trigger efficientemente (e correttamente), è essenziale capire la differenza tra trigger a livello di riga e trigger a livello di istruzione. Un trigger a livello di riga viene definito utilizzando la clausola for each row. Se questa clausola viene omessa, si assume che il trigger sia un trigger a livello di istruzione.
Esecuzione[modifica | modifica wikitesto]
Un trigger a livello di riga viene eseguito una volta per ogni riga dopo (o prima) l'evento che lo ha causato. Al contrario, un trigger a livello di istruzione viene eseguito una volta dopo (o prima) dell'evento, indipendentemente da quante righe sono state interessate dall'evento. Per esempio, un trigger di riga con la specifica di evento after update viene eseguito una volta per ogni riga che viene interessata dall'aggiornamento (o noto come update). Quindi, se l'aggiornamento interessa venti tuple, il trigger viene eseguito venti volte, una volta per ogni riga. Al contrario, un trigger di istruzione viene eseguito una sola volta.
Caratteristiche dei trigger a livello riga[modifica | modifica wikitesto]
I trigger di riga hanno alcune speciali caratteristiche che non sono fornite con i trigger di istruzione: solo con un trigger di riga è possibile accedere ai valori degli attributi di una tupla (riga) prima e dopo la modifica, perché il trigger viene eseguito una volta per ogni tupla (riga).
Per un update trigger, si può accedere al vecchio valore di attributo utilizzando:
:OLD.<colonna>
e si può accedere al nuovo attributo utilizzando
:NEW.<colonna>
Per un insert trigger, solo
:NEW.<colonna>
può essere utilizzato, e per un delete trigger solo
:OLD.<colonna>
è valido (e si riferisce al valore dell'attributo della <colonna> della tupla cancellata). In un trigger di riga quindi è possibile specificare confronti tra il vecchio e il nuovo valore di attributo nel blocco PL/SQL, per esempio:
IF :OLD.SAL < :new.SAL then …
Se per un trigger di riga il contesto temporale before viene specificato, è anche possibile modificare il nuovo valore della riga, per es.,
:NEW.SAL:= :NEW.SAL*1.05 oppure :NEW.SAL:=:OLD.SAL.
Tali modifiche non sono possibili con i trigger di riga after. In generale, è raccomandabile utilizzare un trigger di riga after se la nuova riga non viene modificata nel blocco PL/SQL. I trigger a livello di istruzione sono usati in generale solo in combinazione con il trigger after.
Clausola when[modifica | modifica wikitesto]
In una definizione di trigger la clausola when può essere usata solo in combinazione con un trigger for each row. La clausola è utilizzata per restringere ulteriormente l'attivazione del trigger. Per la specifica della condizione nella clausola when, vengono mantenute le stesse restrizioni della clausola check. Le uniche eccezioni sono che le funzioni sysdate e user possono essere utilizzate, e che è possibile far riferimento ai vecchi/nuovi valori degli attributi della riga attuale. In quest'ultimo caso, i due punti “:” non devono essere utilizzati, per esempio solo:
OLD.<attributo>
e
NEW.<attributo>
Corpo del trigger[modifica | modifica wikitesto]
Il corpo del trigger consiste in un blocco PL/SQL. Tutti i comandi SQL e PL/SQL eccetto le due istruzioni commit e rollback possono essere utilizzati in un blocco PL/SQL di un trigger. Inoltre, costrutti addizionali if permettono l'esecuzione di certe parti del blocco PL/SQL a seconda dell'evento che aziona il trigger. A questo scopo esistono tre costrutti: if inserting, if updating[(‘<colonna>')], e if deleting. Possono essere utilizzati come mostrato nel seguente esempio:
CREATE OR REPLACE TRIGGER emp_check
AFTER INSERT OR DELETE OR UPDATE ON EMP
FOR EACH ROW
BEGIN
IF INSERTING THEN
<blocco PL/SQL>
END IF;
IF UPDATING THEN
<blocco PL/SQL>
END IF;
IF DELETING THEN
<blocco PL/SQL>
END IF;
END;
È importante comprendere che l'esecuzione di un blocco PL/SQL di un trigger costituisce una parte di transazione che può contenere eventi che provocano l'attivazione di altri trigger. Quindi, per esempio, un'istruzione insert in un blocco PL/SQL può causare l'attivazione di un altro trigger. Più trigger e modifiche quindi possono innescare un'esecuzione a cascata di triggers. Una tale sequenza di trigger termina con successo se
- nessuna eccezione viene rilevata all'interno del blocco PL/SQL, e
- nessuna dichiarazione di vincolo di integrità è stata violata.
Se un trigger rileva un'eccezione in un blocco PL/SQL, tutte le modifiche fino all'inizio della transazione vengono annullate (rollback). Nel blocco PL/SQL di un trigger, un'eccezione può essere provocata utilizzando l'istruzione raise_application_error. Questa istruzione provoca un rollback implicito. In combinazione con un trigger di riga, raise_application_error può far riferimento a vecchi/nuovi valori della riga modificata:
raise_application_error(-20020,"L'incremento dello stipendio da "||to_char(:OLD.SAL)||" a "||to_char(:NEW.SAL)||" è troppo alto");
oppure
raise_application_error(-20030,"L'impiegato con Id "||to_char(:NEW.EMPNO)||" non esiste.");
Altri contesti[modifica | modifica wikitesto]
All'infuori del contesto dei database, in informatica il trigger è un meccanismo software che esegue automaticamente determinate operazioni su un sistema.
Anche nel management si usa il termine trigger per intendere un controllo che fa scattare un'attività sui processi.
Note[modifica | modifica wikitesto]
- ^ a b c d e (EN) PL/SQL Triggers, su docs.oracle.com, Oracle. URL consultato il 1º ottobre 2014.
- ^ CREATE TRIGGER (Transact-SQL), su msdn.microsoft.com, MSDN. URL consultato il 1º ottobre 2014.
- ^ (EN) Trigger Procedures, su postgresql.org, PostgreSQL Global Development Group. URL consultato il 1º ottobre 2014.
