1. BEFORE STATEMENT
Une fois, avant que l'instruction ne fasse quoi que ce soit.
Informatique · PL/pgSQL (PostgreSQL)
Une seule requête peut réveiller quatre déclencheurs. Dans quel ordre passent-ils, que voit chacun, et comment en appeler moins ?
Déjà à l'aise ? Aller au quizLe cas
Un UPDATE modifie le salaire de trois employés. Un trigger AFTER ROW lit, au passage, la somme des salaires de la table.
Après cette fiche, tu sais
Je dirais que non : les lignes passent une par une, non ?
Quatre moments, une instruction
Notion 1 · La séquence complète
Un INSERT, un UPDATE ou un DELETE sur une table qui porte des triggers suit toujours le même ordre dans PostgreSQL.1
Une fois, avant que l'instruction ne fasse quoi que ce soit.
Juste avant chaque ligne, puis la ligne est écrite. Les contraintes NOT NULL et CHECK sont vérifiées à ce moment-là : testé, un BEFORE ROW voit encore la valeur interdite, et peut la corriger avant le contrôle.
Une fois par ligne, mais à la fin de l'instruction. PostgreSQL met chaque appel en file d'attente pendant l'instruction, puis les exécute dans l'ordre des lignes.3
Une fois, tout à la fin, après tous les AFTER ROW.1
Les quatre triggers de l'exemple, sur la table exe_employe :
-- tracer() affiche TG_NAME, TG_WHEN, TG_LEVEL et NEW.emp_nom
CREATE TRIGGER trg_validate BEFORE INSERT ON exe_employe
FOR EACH STATEMENT EXECUTE FUNCTION tracer();
CREATE TRIGGER trg_before_insert BEFORE INSERT ON exe_employe
FOR EACH ROW EXECUTE FUNCTION tracer();
CREATE TRIGGER trg_log AFTER INSERT ON exe_employe
FOR EACH ROW EXECUTE FUNCTION tracer();
CREATE TRIGGER trg_audit_statement AFTER INSERT ON exe_employe
FOR EACH STATEMENT EXECUTE FUNCTION tracer();
INSERT INTO exe_employe VALUES
(1, 'Léa', 4200), (2, 'Noah', 5100), (3, 'Zoé', 6000);
NOTICE: trg_validate (BEFORE STATEMENT) NOTICE: trg_before_insert (BEFORE ROW) pour Léa NOTICE: trg_before_insert (BEFORE ROW) pour Noah NOTICE: trg_before_insert (BEFORE ROW) pour Zoé NOTICE: trg_log (AFTER ROW) pour Léa NOTICE: trg_log (AFTER ROW) pour Noah NOTICE: trg_log (AFTER ROW) pour Zoé NOTICE: trg_audit_statement (AFTER STATEMENT)
Fais défiler : les onze événements de cet INSERT s'enchaînent. Regarde la file d'attente des AFTER ROW. Touche Oracle pour voir l'autre ordre.
PostgreSQL
Donc en PostgreSQL, les AFTER ROW attendent la fin ?
Mêmes quatre triggers, deux lignes cette fois. Remets les huit étapes dans l'ordre suivi par PostgreSQL : touche une étape, puis celle avec laquelle l'échanger.
Même table, états différents
Notion 2 · Ce que voit un trigger
Une fonction de trigger peut lancer des requêtes sur la table qui l'a déclenchée. Ce qu'elle y voit dépend du moment.2
Aucune des modifications de l'instruction.
Pas la modification de sa propre ligne, qui n'a pas encore eu lieu ; mais celles des lignes déjà traitées par la même instruction. Prudence : l'ordre de visite des lignes n'est pas garanti.
Toutes les modifications de l'instruction, déjà terminées.
Ces règles valent pour une fonction VOLATILE, le cas par défaut. Une fonction déclarée STABLE ou IMMUTABLE ne voit jamais les changements de l'instruction (testé : la somme reste à 6000.00 partout).
Le code du test
CREATE OR REPLACE FUNCTION voir()
RETURNS trigger AS $$
DECLARE
total NUMERIC;
BEGIN
SELECT sum(salaire) INTO total FROM emp;
IF TG_LEVEL = 'ROW' THEN
RAISE NOTICE '% ROW (%) : somme vue %',
TG_WHEN, NEW.emp_nom, total;
IF TG_WHEN = 'BEFORE' THEN
RETURN NEW;
END IF;
ELSE
RAISE NOTICE '% STATEMENT : somme vue %', TG_WHEN, total;
END IF;
RETURN NULL;
END;
$$ LANGUAGE plpgsql;
-- quatre triggers sur emp (BEFORE et AFTER, ROW et STATEMENT)
UPDATE emp SET salaire = salaire + 100; -- 1000, 2000, 3000Fais défiler : les salaires de Léa, Noah et Zoé augmentent de 100, et chaque trigger lit la somme. Touche Oracle pour voir ce que la même idée y provoque.
PostgreSQL
Donc le moment compte plus que la ligne ?
DELETE FROM emp; supprime les trois employés. Chaque trigger exécute SELECT count(*) FROM emp avec une fonction VOLATILE. Que trouve-t-il ?
Qui passe en premier ?
Notion 3 · Plusieurs triggers au même moment
Si plusieurs triggers attendent le même événement sur la même table, au même moment, PostgreSQL les lance par ordre alphabétique de leur nom.1
La norme SQL prévoit l'ordre de création ; PostgreSQL a jugé l'ordre des noms plus commode.3
Le moment passe avant le nom : un BEFORE ROW nommé zz_ s'exécute toujours avant un AFTER ROW nommé aa_.
Pour un AFTER ROW sur plusieurs lignes, tous les triggers de la ligne 1 passent, par ordre alphabétique, avant ceux de la ligne 2 (testé).
Piège · majuscules et guillemets
Un nom écrit sans guillemets est rangé en minuscules : Ab_audit devient ab_audit.
Et les noms se comparent octet par octet : testé, "B_stats", créé entre guillemets avec sa majuscule, passe avant ab_audit, m_mail et zz_journal.
Pour garder la main, beaucoup d'équipes numérotent : t10_controle, t20_journal.
Quatre paires de triggers sur la même table et le même événement. Lequel PostgreSQL lance-t-il d'abord ?
Une fonction sans paramètre
Notion 4 · OLD, NEW et TG_
Une fonction de trigger ne déclare aucun paramètre : PL/pgSQL lui fournit des variables spéciales.4
| Opération | OLD | NEW | Modifiable ? |
|---|---|---|---|
INSERT | NULL | la nouvelle ligne | NEW, dans un BEFORE ROW |
UPDATE | la ligne avant | la ligne après | NEW, dans un BEFORE ROW |
DELETE | la ligne supprimée | NULL | non : on renvoie OLD pour que la suppression ait lieu |
| trigger STATEMENT | NULL | NULL | sans objet |
INSERT, UPDATE, DELETE ou TRUNCATE : indispensable dans un trigger qui surveille plusieurs événements.
BEFORE, AFTER ou INSTEAD OF ; ROW ou STATEMENT.
Le nom du trigger, de la table et de son schéma (testé : public).
Les arguments écrits dans CREATE TRIGGER … EXECUTE FUNCTION f('…'), numérotés à partir de 0, au format texte.4
Exemple
CREATE OR REPLACE FUNCTION universal_trigger()
RETURNS trigger AS $$
BEGIN
IF TG_OP = 'INSERT' THEN
RAISE NOTICE 'Insertion dans %', TG_TABLE_NAME;
ELSIF TG_OP = 'UPDATE' THEN
RAISE NOTICE 'Mise à jour de % dans %', OLD.emp_no, TG_TABLE_NAME;
ELSE
RAISE NOTICE 'Suppression de % dans %', OLD.emp_no, TG_TABLE_NAME;
END IF;
RETURN NULL; -- trigger AFTER : valeur ignorée
END;
$$ LANGUAGE plpgsql;
CREATE TRIGGER trg_audit
AFTER INSERT OR UPDATE OR DELETE ON exe_employe
FOR EACH ROW
EXECUTE FUNCTION universal_trigger();
NOTICE: Insertion dans exe_employe NOTICE: Mise à jour de 1 dans exe_employe NOTICE: Suppression de 1 dans exe_employe
Huit variables, chacune dans un trigger précis. Contient-elle une ligne, ou vaut-elle NULL ?
Ne déclencher que quand il faut
Notion 5 · Déclencher moins souvent
Le trigger ne part que si l'UPDATE vise au moins une des colonnes citées, même sans en changer la valeur.3
La fonction n'est appelée que si la condition est vraie ; dans un trigger ROW, elle peut lire OLD.colonne et NEW.colonne. Dans un AFTER, la condition est testée juste après chaque ligne : si elle est fausse, rien n'est mis en file d'attente, ce qui accélère les grosses instructions.3
Un trigger AFTER STATEMENT peut lire d'un coup toutes les lignes modifiées (NEW TABLE) ou leur état d'avant (OLD TABLE), comme des tables en lecture seule.4
Exemple
CREATE TRIGGER t_tout AFTER UPDATE ON emp
FOR EACH ROW EXECUTE FUNCTION noter();
CREATE TRIGGER t_col AFTER UPDATE OF salaire ON emp
FOR EACH ROW EXECUTE FUNCTION noter();
CREATE TRIGGER t_quand AFTER UPDATE ON emp
FOR EACH ROW
WHEN (OLD.salaire IS DISTINCT FROM NEW.salaire)
EXECUTE FUNCTION noter();
CREATE TRIGGER t_bilan AFTER UPDATE ON emp
REFERENCING NEW TABLE AS modifiees
FOR EACH STATEMENT EXECUTE FUNCTION bilan();IS DISTINCT FROM plutôt que <> : il traite NULL comme une valeur ordinaire, alors que NULL <> 5 donne NULL, donc faux.
Fais défiler : trois UPDATE, et pour chacun les triggers qui partent.
salaire = salaire pour Léa : t_col part, car la colonne est visée ; t_quand non, car la valeur n'a pas changé.
On renomme Léa : seul t_tout part parmi les triggers ROW, et t_bilan compte 1 ligne.
+5 % pour deux employés : les trois triggers ROW partent deux fois, t_bilan une fois, avec 2 lignes.
UPDATE OF et REFERENCING ensemble : PostgreSQL refuse de créer le trigger.
INSTEAD OF INSERT … FOR EACH ROW remplace l'insertion : c'est la fonction qui écrit dans les tables sous-jacentes.3 Testé : un INSERT dans une vue v_emp a bien créé la ligne dans emp. Sur une table, INSTEAD OF est refusé.Oracle fait de même : un INSTEAD OF s'écrit sur une vue.11
Même mot, autre moteur
Notion 6 · Et Oracle ?
Oracle reprend ces idées, mais ses règles diffèrent sur quelques points. Le plus visible : quand un AFTER ROW s'exécute.7
| PostgreSQL | Oracle | |
|---|---|---|
| AFTER ROW | en file d'attente, exécutés à la fin de l'instruction | juste après chaque ligne, avant la ligne suivante7 |
| Même moment | ordre alphabétique des noms | non garanti, sauf avec FOLLOWS ou PRECEDES6 |
| Lire sa table dans un trigger ROW | permis, avec les règles de visibilité | ORA-04091 : table en mutation, instruction annulée6 |
| Écrire OLD et NEW | NEW.salaire | :NEW.salaire dans le corps, NEW.salaire dans WHEN6 |
| Modifier NEW dans un AFTER | sans effet, valeur ignorée | erreur ORA-040846 |
Table en mutation · ORA-04091
La restriction de la table en mutation ne touche que les triggers ROW : un trigger STATEMENT peut lire la table. Oracle propose aussi des triggers composés pour contourner l'erreur.6
Oracle · déclencheur composé
Un déclencheur composé (COMPOUND TRIGGER) regroupe les quatre moments dans un seul bloc. Ses variables vivent pendant toute l'instruction : on compte pendant les lignes, puis on lit la table à la fin.9
CREATE OR REPLACE TRIGGER trg_masse
FOR UPDATE OF salaire ON emp
COMPOUND TRIGGER
v_nb PLS_INTEGER := 0;
v_tot NUMBER;
AFTER EACH ROW IS
BEGIN
-- on compte, sans lire emp
v_nb := v_nb + 1;
END AFTER EACH ROW;
AFTER STATEMENT IS
BEGIN
-- emp n'est plus en mutation
SELECT SUM(salaire)
INTO v_tot
FROM emp;
DBMS_OUTPUT.PUT_LINE(v_nb);
DBMS_OUTPUT.PUT_LINE(v_tot);
END AFTER STATEMENT;
END trg_masse;Oracle · transaction autonome
PRAGMA AUTONOMOUS_TRANSACTION donne au bloc du trigger sa propre transaction. Son COMMIT ne dépend plus de celui de l'instruction : le journal reste même si le DELETE est annulé.10
CREATE OR REPLACE TRIGGER trg_journal
BEFORE DELETE ON emp
FOR EACH ROW
DECLARE
PRAGMA AUTONOMOUS_TRANSACTION;
BEGIN
INSERT INTO journal_suppr
(emp_no, quand)
VALUES
(:OLD.emp_no, SYSTIMESTAMP);
COMMIT; -- sinon : ORA-06519
END;Attention : le bloc autonome ne voit pas les modifications non validées de l'instruction, et il peut attendre une ligne que celle-ci a verrouillée. Sans COMMIT ni ROLLBACK avant la fin, Oracle annule le bloc et lève ORA-06519.12
Oracle · système et DDL
Un déclencheur ON SCHEMA réagit aux ordres DDL du schéma (CREATE, ALTER, DROP…). Un déclencheur ON DATABASE réagit aux événements de la base, comme LOGON ou STARTUP.11
-- table journal_ddl déjà créée
CREATE OR REPLACE TRIGGER trg_ddl
AFTER CREATE OR ALTER OR DROP
ON SCHEMA
BEGIN
INSERT INTO journal_ddl
(evt, objet, nom, qui, quand)
VALUES
(ora_sysevent, ora_dict_obj_type,
ora_dict_obj_name, ora_login_user,
SYSTIMESTAMP);
END;Les fonctions ora_sysevent, ora_dict_obj_type, ora_dict_obj_name et ora_login_user donnent le détail de chaque événement.9
Cinq habitudes de pro
Habitudes de pro
Cinq réflexes pour éviter les surprises vues dans cette fiche.
PostgreSQL peut visiter les lignes dans n'importe quel ordre (testé : après un premier UPDATE, Léa passe en dernier).
Si l'ordre entre triggers compte, écris-le dans les noms : t10_, t20_.
Pour un contrôle qui porte sur toutes les lignes, préfère un AFTER STATEMENT avec table de transition à un trigger ROW qui relit la table à chaque ligne.
Filtre avec WHEN plutôt qu'avec un IF au début d'un AFTER : les lignes écartées ne sont même pas mises en file.
Pour une maintenance, ALTER TABLE … DISABLE TRIGGER nom garde le trigger, qui ne s'exécute plus, jusqu'à ENABLE TRIGGER.5
Maintenant, à toi
Entraînement
Table emp(emp_no, emp_nom, salaire) avec Léa 1000, Noah 2000 et Zoé 3000. Tous les corrigés ont été exécutés dans PostgreSQL 18.
journal_salaires chaque changement de salaire, mais seulement les vrais changements.Voir le corrigéCREATE OR REPLACE FUNCTION noter_salaire()
RETURNS trigger AS $$
BEGIN
INSERT INTO journal_salaires (emp_no, ancien, nouveau)
VALUES (NEW.emp_no, OLD.salaire, NEW.salaire);
RETURN NULL;
END;
$$ LANGUAGE plpgsql;
CREATE TRIGGER trg_vrais_changements
AFTER UPDATE OF salaire ON emp
FOR EACH ROW
WHEN (OLD.salaire IS DISTINCT FROM NEW.salaire)
EXECUTE FUNCTION noter_salaire();
UPDATE emp SET salaire = salaire; -- rien
UPDATE emp SET salaire = 2200 WHERE emp_no = 2; -- une ligne
UPDATE emp SET emp_nom = 'Zoé R.' WHERE emp_no = 3; -- rien
Une seule ligne au journal : (2, 2000.00, 2200.00). UPDATE OF salaire écarte les UPDATE qui ne visent pas la colonne, WHEN ceux qui la visent sans la changer.
CREATE OR REPLACE FUNCTION verifier_masse()
RETURNS trigger AS $$
DECLARE
v_apres NUMERIC;
v_avant NUMERIC;
BEGIN
SELECT sum(salaire) INTO v_apres FROM emp; -- AFTER STATEMENT : voit tout
v_avant := v_apres - (SELECT sum(salaire) FROM nouvelles)
+ (SELECT sum(salaire) FROM anciennes);
IF v_apres < v_avant * 0.9 THEN
RAISE EXCEPTION 'Baisse de la masse salariale refusée : % → %',
v_avant, v_apres;
END IF;
RETURN NULL;
END;
$$ LANGUAGE plpgsql;
CREATE TRIGGER trg_masse
AFTER UPDATE ON emp
REFERENCING OLD TABLE AS anciennes NEW TABLE AS nouvelles
FOR EACH STATEMENT
EXECUTE FUNCTION verifier_masse();
UPDATE emp SET salaire = salaire * 0.95; -- accepté : 6000.00 → 5700.00
UPDATE emp SET salaire = salaire * 0.8; -- refusé : 5700.00 → 4560.00
UPDATE emp SET salaire = salaire * 0.8 WHERE emp_no = 1; -- accepté : 5510.00
Un AFTER STATEMENT voit la table après toute l'instruction ; les tables de transition donnent ce qui a changé, d'où le total d'avant. Le dernier UPDATE ne baisse le total que de 3,3 %. Attention : AFTER UPDATE OF salaire serait refusé ici, car les tables de transition sont interdites avec une liste de colonnes (testé).
UPDATE emp SET salaire = salaire + 1 WHERE emp_no <= 2; (Léa puis Noah).Voir le corrigéCREATE TRIGGER c_fin AFTER UPDATE ON emp FOR EACH STATEMENT EXECUTE FUNCTION dire(); CREATE TRIGGER b_verif BEFORE UPDATE ON emp FOR EACH ROW EXECUTE FUNCTION dire(); CREATE TRIGGER a_trace AFTER UPDATE ON emp FOR EACH ROW EXECUTE FUNCTION dire(); CREATE TRIGGER d_debut BEFORE UPDATE ON emp FOR EACH STATEMENT EXECUTE FUNCTION dire(); CREATE TRIGGER a_controle BEFORE UPDATE ON emp FOR EACH ROW EXECUTE FUNCTION dire();
NOTICE: d_debut NOTICE: a_controle (Léa) NOTICE: b_verif (Léa) NOTICE: a_controle (Noah) NOTICE: b_verif (Noah) NOTICE: a_trace (Léa) NOTICE: a_trace (Noah) NOTICE: c_fin
Le moment d'abord (BEFORE STATEMENT, puis les BEFORE ROW de chaque ligne, puis les AFTER ROW, puis AFTER STATEMENT), et l'alphabet seulement entre triggers du même moment : a_controle avant b_verif. L'ordre de création ne joue aucun rôle.
Tout retenir en huit lignes
À retenir
Quiz final
ora_sysevent, ora_dict_obj_name, ora_login_user). docs.oracle.comFiche relue et sourcée en octobre 2026, refaite en récit en octobre 2026. Tout le code PL/pgSQL a été exécuté dans PostgreSQL 18 ; le code Oracle n'a pas été exécuté, il sert de comparaison.