PostgreSQL - TRIGGER

PostgreSQL Triggers sono funzioni di callback del database, che vengono eseguite / invocate automaticamente quando si verifica un evento di database specificato.

I seguenti sono punti importanti sui trigger di PostgreSQL:

• È possibile specificare il trigger di PostgreSQL per l'attivazione

  • Prima che l'operazione venga tentata su una riga (prima che i vincoli vengano controllati e che venga tentato INSERT, UPDATE o DELETE)

  • Dopo che l'operazione è stata completata (dopo che i vincoli sono stati controllati e INSERT, UPDATE o DELETE è stato completato)

  • Al posto dell'operazione (nel caso di inserimenti, aggiornamenti o cancellazioni su una vista)

• Un trigger contrassegnato FOR EACH ROW viene chiamato una volta per ogni riga modificata dall'operazione. Al contrario, un trigger contrassegnato come FOR EACH STATEMENT viene eseguito solo una volta per una determinata operazione, indipendentemente dal numero di righe modificate.

• Entrambe, la clausola WHEN e le azioni trigger, possono accedere agli elementi della riga che viene inserita, eliminata o aggiornata utilizzando i riferimenti del modulo NEW.column-name e OLD.column-name, dove nome-colonna è il nome di una colonna della tabella a cui è associato il trigger.

• Se viene fornita una clausola WHEN, le istruzioni PostgreSQL specificate vengono eseguite solo per le righe per le quali la clausola WHEN è vera. Se non viene fornita alcuna clausola WHEN, le istruzioni PostgreSQL vengono eseguite per tutte le righe.

• Se per lo stesso evento sono definiti più trigger dello stesso tipo, verranno attivati ​​in ordine alfabetico per nome.

• La parola chiave BEFORE, AFTER o INSTEAD OF determina quando verranno eseguite le azioni trigger relative all'inserimento, modifica o rimozione della riga associata.

• I trigger vengono eliminati automaticamente quando viene eliminata la tabella a cui sono associati.

• La tabella da modificare deve esistere nello stesso database della tabella o della vista a cui è collegato il trigger e si deve utilizzare solo tablename, no database.tablename.

• Un'opzione CONSTRAINT, se specificata, crea un trigger di vincolo . È lo stesso di un trigger normale, tranne per il fatto che il tempo di attivazione del grilletto può essere regolato utilizzando SET CONSTRAINTS. I trigger di vincolo dovrebbero generare un'eccezione quando i vincoli che implementano vengono violati.

Sintassi

La sintassi di base della creazione di un file trigger è il seguente -

CREATE  TRIGGER trigger_name [BEFORE|AFTER|INSTEAD OF] event_name
ON table_name
[
 -- Trigger logic goes here....
];

Qui, event_namepotrebbe essere un'operazione di database INSERT, DELETE, UPDATE e TRUNCATE sulla tabella menzionatatable_name. Facoltativamente, è possibile specificare FOR EACH ROW dopo il nome della tabella.

Quanto segue è la sintassi per creare un trigger su un'operazione UPDATE su una o più colonne specificate di una tabella come segue:

CREATE  TRIGGER trigger_name [BEFORE|AFTER] UPDATE OF column_name
ON table_name
[
 -- Trigger logic goes here....
];

Esempio

Consideriamo un caso in cui vogliamo mantenere la prova di audit per ogni record inserito nella tabella AZIENDA, che creeremo di nuovo come segue (Elimina tabella AZIENDA se già ce l'hai).

testdb=# CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

Per mantenere la prova di audit, creeremo una nuova tabella chiamata AUDIT in cui verranno inseriti i messaggi di registro ogni volta che c'è una voce nella tabella AZIENDA per un nuovo record -

testdb=# CREATE TABLE AUDIT(
   EMP_ID INT NOT NULL,
   ENTRY_DATE TEXT NOT NULL
);

Qui, ID è l'ID del record AUDIT e EMP_ID è l'ID, che verrà dalla tabella COMPANY e DATE manterrà il timestamp quando il record verrà creato nella tabella COMPANY. Quindi ora, creiamo un trigger sulla tabella AZIENDA come segue:

testdb=# CREATE TRIGGER example_trigger AFTER INSERT ON COMPANY
FOR EACH ROW EXECUTE PROCEDURE auditlogfunc();

Dove auditlogfunc () è un PostgreSQL procedure e ha la seguente definizione:

CREATE OR REPLACE FUNCTION auditlogfunc() RETURNS TRIGGER AS $example_table$
   BEGIN
      INSERT INTO AUDIT(EMP_ID, ENTRY_DATE) VALUES (new.ID, current_timestamp);
      RETURN NEW;
   END;
$example_table$ LANGUAGE plpgsql;

Ora inizieremo il lavoro vero e proprio. Cominciamo a inserire il record nella tabella AZIENDA che dovrebbe comportare la creazione di un record del registro di controllo nella tabella AUDIT. Quindi creiamo un record nella tabella AZIENDA come segue:

testdb=# INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );

Questo creerà un record nella tabella AZIENDA, che è il seguente:

id | name | age | address      | salary
----+------+-----+--------------+--------
  1 | Paul |  32 | California   |  20000

Allo stesso tempo, verrà creato un record nella tabella AUDIT. Questo record è il risultato di un trigger, che abbiamo creato durante l'operazione INSERT nella tabella COMPANY. Allo stesso modo, puoi creare i tuoi trigger nelle operazioni UPDATE e DELETE in base alle tue esigenze.

emp_id |          entry_date
--------+-------------------------------
      1 | 2013-05-05 15:49:59.968+05:30
(1 row)

Elenco TRIGGERS

È possibile elencare tutti i trigger nel database corrente da pg_trigger tabella come segue -

testdb=# SELECT * FROM pg_trigger;

L'istruzione PostgreSQL sopra indicata elencherà tutti i trigger.

Se vuoi elencare i trigger su una particolare tabella, usa la clausola AND con il nome della tabella come segue:

testdb=# SELECT tgname FROM pg_trigger, pg_class WHERE tgrelid=pg_class.oid AND relname='company';

L'istruzione PostgreSQL sopra indicata elencherà anche solo una voce come segue:

tgname
-----------------
 example_trigger
(1 row)

GRILLETTI IN CADUTA

Di seguito è riportato il comando DROP, che può essere utilizzato per rilasciare un trigger esistente:

testdb=# DROP TRIGGER trigger_name;