Informatique · PL/pgSQL (PostgreSQL)

Triggers avancés : l'ordre d'exécution

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 quiz

Le cas

Un UPDATE modifie le salaire de trois employés. Un trigger AFTER ROW lit, au passage, la somme des salaires de la table.

UPDATE emp SET salaire = salaire + 100; table emp Léa 1100 Noah 2100 Zoé 3100 trigger AFTER ROW appelé pour la ligne 1 sum(salaire) ?

Après cette fiche, tu sais

  • donner l'ordre complet des triggers d'une instruction, dans PostgreSQL et dans Oracle ;
  • prévoir ce qu'un trigger voit de la table à chaque étape ;
  • ordonner plusieurs triggers du même moment, et lire OLD, NEW et les variables TG_ ;
  • déclencher moins souvent avec WHEN et UPDATE OF, et travailler sur l'ensemble des lignes avec les tables de transition.
Voit-il déjà les trois lignes modifiées, au moment où il lit la somme ?

Je dirais que non : les lignes passent une par une, non ?

Garde ta réponse : la scène 2 la vérifie.

Quatre moments, une instruction

Notion 1 · La séquence complète

Quatre temps pour une instruction

Un INSERT, un UPDATE ou un DELETE sur une table qui porte des triggers suit toujours le même ordre dans PostgreSQL.1

1 BEFORE STATEMENT une fois 2 BEFORE ROW + écriture chaque ligne 3 AFTER ROW chaque ligne, à la fin 4 AFTER STATEMENT une fois

1. BEFORE STATEMENT

Une fois, avant que l'instruction ne fasse quoi que ce soit.

2. BEFORE ROW

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.

3. AFTER ROW

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

4. AFTER STATEMENT

Une fois, tout à la fin, après tous les AFTER ROW.1

Les quatre triggers de l'exemple, sur la table exe_employe :

Un trigger par momentPL/pgSQL
-- 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)

Rejoue l'ordre de déclenchement

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.

Scène 1 · Ordre

PostgreSQL

INSERT INTO exe_employe VALUES (…), (…), (…); déroulement en cours file AFTER ROW exe_employe 1 · Léa 2 · Noah 3 · Zoé

Le point qui surprend : dans PostgreSQL, aucun AFTER ROW ne passe tant que toutes les lignes ne sont pas écrites. Oracle, lui, les intercale ligne par ligne.

Donc en PostgreSQL, les AFTER ROW attendent la fin ?

Oui. Les appels sont rangés pendant l'instruction, puis exécutés à la fin, dans l'ordre des lignes.
Exercice · remettre dans l'ordre

Un INSERT de deux employés

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

La même table, quatre états différents

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

BEFORE STATEMENT rien n'est encore modifié 6 000 BEFORE ROW, Léa sa propre ligne n'a pas encore changé 6 000 BEFORE ROW, Noah la ligne de Léa est déjà changée 6 100 AFTER ROW, Léa toutes les lignes sont changées 6 300
BEFORE STATEMENT

Aucune des modifications de l'instruction.

BEFORE ROW

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.

AFTER ROW et AFTER STATEMENT

Toutes les modifications de l'instruction, déjà terminées.

Fonction STABLE ou IMMUTABLE

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

Chaque trigger lit la somme des salairesPL/pgSQL
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, 3000

La somme vue par chaque trigger

Fais 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.

Scène 2 · Visibilité

PostgreSQL

UPDATE emp SET salaire = salaire + 100; emp nom salaire Léa Noah Zoé 1000.00 2000.00 3000.00 trigger en cours sum(salaire) vue

Réponse à ma question : oui. Quand un AFTER ROW s'exécute, toute l'instruction est déjà faite : même le trigger de la première ligne voit 6300.00. Le BEFORE ROW de Noah, lui, ne voyait que la ligne de Léa.

Donc le moment compte plus que la ligne ?

Exactement. Pour savoir ce qu'un trigger voit, regarde d'abord le moment.
Exercice · prévoir

Combien de lignes voit ce trigger ?

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

L'ordre alphabétique décide

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

créés dans cet ordre lancés par PostgreSQL zz_journal a_trace m_mail 1 · a_trace 2 · m_mail 3 · zz_journal l'ordre des noms décide, pas l'ordre de création

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é).

BEFORE ROW zz_controle AFTER ROW aa_trace le moment passe avant le nom AFTER ROW sur deux lignes : ligne 1 : aa_trace, bb_stats ligne 2 : aa_trace, bb_stats les triggers de la ligne 1 passent avant ceux de la ligne 2

Piège · majuscules et guillemets

Un nom écrit sans guillemets est rangé en minuscules : Ab_audit devient ab_audit.

écrit rangé Ab_audit ab_audit sans guillemets, tout passe en minuscules

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.

ordre de lancement 1 · "B_stats" 2 · ab_audit 3 · m_mail 4 · zz_journal la majuscule B passe avant les minuscules

Pour garder la main, beaucoup d'équipes numérotent : t10_controle, t20_journal.

Exercice · choisir

Lequel passe en premier ?

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_

Ce que la fonction reçoit

Une fonction de trigger ne déclare aucun paramètre : PL/pgSQL lui fournit des variables spéciales.4

opération OLD NEW INSERT NULL la nouvelle ligne UPDATE la ligne avant la ligne après DELETE la ligne supprimée NULL NEW ne se change que dans un BEFORE ROW
OpérationOLDNEWModifiable ?
INSERTNULLla nouvelle ligneNEW, dans un BEFORE ROW
UPDATEla ligne avantla ligne aprèsNEW, dans un BEFORE ROW
DELETEla ligne suppriméeNULLnon : on renvoie OLD pour que la suppression ait lieu
trigger STATEMENTNULLNULLsans objet
TG_OP

INSERT, UPDATE, DELETE ou TRUNCATE : indispensable dans un trigger qui surveille plusieurs événements.

TG_WHEN, TG_LEVEL

BEFORE, AFTER ou INSTEAD OF ; ROW ou STATEMENT.

TG_OP INSERT insertion UPDATE mise à jour DELETE suppression un seul bloc s'exécute, celui du type d'instruction
TG_NAME, TG_TABLE_NAME, TG_TABLE_SCHEMA

Le nom du trigger, de la table et de son schéma (testé : public).

TG_ARGV

Les arguments écrits dans CREATE TRIGGER … EXECUTE FUNCTION f('…'), numérotés à partir de 0, au format texte.4

Exemple

Un trigger, trois événementsPL/pgSQL
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
Exercice · classer

Une ligne, ou NULL ?

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

WHEN, UPDATE OF et tables de transition

UPDATE OF colonne

Le trigger ne part que si l'UPDATE vise au moins une des colonnes citées, même sans en changer la valeur.3

modification colonne WHEN résultat SET nom non (colonne) salaire inchangé non (WHEN) salaire = 2200 oui, il part UPDATE OF filtre par colonne, WHEN filtre par valeur
WHEN (condition)

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

REFERENCING NEW TABLE AS …

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

lignes touchées Léa : 1100 Noah : pas touché Zoé : 3100 AFTER STATEMENT NEW TABLE modifiees 2 lignes, un seul appel le trigger reçoit toutes les lignes modifiées d'un coup

Exemple

Quatre triggers sur empPL/pgSQL
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.

Trois UPDATE, quatre triggers

Fais défiler : trois UPDATE, et pour chacun les triggers qui partent.

Étape 1 sur 4 · rien ne change

salaire = salaire pour Léa : t_col part, car la colonne est visée ; t_quand non, car la valeur n'a pas changé.

Étape 2 sur 4 · une autre colonne

On renomme Léa : seul t_tout part parmi les triggers ROW, et t_bilan compte 1 ligne.

Étape 3 sur 4 · un vrai changement

+5 % pour deux employés : les trois triggers ROW partent deux fois, t_bilan une fois, avec 2 lignes.

Étape 4 sur 4 · le piège

UPDATE OF et REFERENCING ensemble : PostgreSQL refuse de créer le trigger.

INSTEAD OF : écrire à travers une vueSur une vue, un 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

INSERT INTO v_emp VALUES (…); vue v_emp ne stocke rien INSTEAD OF INSERT écrit table emp nouvelle ligne le trigger écrit dans les tables sous-jacentes

Même mot, autre moteur

Notion 6 · Et Oracle ?

Les mêmes mots, un autre comportement

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 : les AFTER ROW partent à la fin écriture 1 écriture 2 écriture 3 AFTER 1 AFTER 2 AFTER 3 Oracle : juste après chaque ligne écriture 1 AFTER 1 écriture 2 AFTER 2 écriture 3 AFTER 3 PostgreSQL attend la fin ; Oracle réagit après chaque ligne (schéma simplifié, pour trois lignes)
PostgreSQLOracle
AFTER ROWen file d'attente, exécutés à la fin de l'instructionjuste après chaque ligne, avant la ligne suivante7
Même momentordre alphabétique des nomsnon garanti, sauf avec FOLLOWS ou PRECEDES6
Lire sa table dans un trigger ROWpermis, avec les règles de visibilitéORA-04091 : table en mutation, instruction annulée6
Écrire OLD et NEWNEW.salaire:NEW.salaire dans le corps, NEW.salaire dans WHEN6
Modifier NEW dans un AFTERsans effet, valeur ignoréeerreur 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

trigger ROW : lit la table pendant la modification UPDATE emp SELECT … FROM emp ORA-04091 trigger STATEMENT : lit la table à la fin UPDATE emp SELECT … FROM emp lecture OK la restriction ne touche que les triggers ROW

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

Oracle, PL/SQLcompte, puis lit
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

transaction de l'instruction DELETE emp ROLLBACK : tout annulé transaction autonome du trigger INSERT journal COMMIT : journal gardé
Oracle, PL/SQLjournal autonome
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

CREATE TABLE test_ddl (…); trigger AFTER CREATE ON SCHEMA ora_sysevent = CREATE ora_dict_obj_type = TABLE ora_dict_obj_name = test_ddl
Oracle, PL/SQLjournal DDL
-- 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

Ordre et DDL, en trois cartes

FOLLOWS (Oracle)

Le trigger part juste après celui qui est nommé.6

trg_a trg_b FOLLOWS trg_a trg_b part après trg_a

PRECEDES (Oracle)

L'inverse : le trigger part juste avant celui qui est nommé.6

trg_a PRECEDES trg_b trg_b trg_a part avant trg_b

EVENT TRIGGER (PostgreSQL)

PostgreSQL n'a ni FOLLOWS ni PRECEDES. Pour le DDL, il a les déclencheurs d'événement.8

DDL EVENT TRIGGER PostgreSQL déclencheur d'événement

Cinq habitudes de pro

Habitudes de pro

Cinq bonnes pratiques

Cinq réflexes pour éviter les surprises vues dans cette fiche.

1. Ne pas compter sur l'ordre

PostgreSQL peut visiter les lignes dans n'importe quel ordre (testé : après un premier UPDATE, Léa passe en dernier).

2. Dire l'ordre dans les noms

Si l'ordre entre triggers compte, écris-le dans les noms : t10_, t20_.

3. Un AFTER STATEMENT pour l'ensemble

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.

4. Filtrer avec WHEN

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.

5. Désactiver sans supprimer

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

Trois exercices corrigés

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.

1Journalise dans 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.

2Refuse tout UPDATE qui ferait baisser la masse salariale totale de plus de 10 %.Voir le corrigé
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é).

3Cinq triggers sur emp. Prévois les messages de 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

La fiche en huit lignes

SéquenceBEFORE STATEMENT, puis BEFORE ROW et écriture ligne par ligne, puis les AFTER ROW, puis AFTER STATEMENT.
AFTER ROWen file d'attente, exécutés à la fin de l'instruction (Oracle : juste après chaque ligne).
ContraintesNOT NULL et CHECK vérifiées à l'écriture, après le BEFORE ROW de la ligne.
VisibilitéBEFORE ROW : les lignes déjà traitées ; AFTER : tout ; fonction STABLE : rien.
Même momentordre alphabétique des noms, octet par octet ; Oracle : FOLLOWS ou PRECEDES.
OLD et NEWNULL selon l'opération, et toujours NULL dans un trigger STATEMENT.
FiltrerUPDATE OF (colonne visée), WHEN (condition sur OLD et NEW).
EnsembleREFERENCING NEW TABLE / OLD TABLE dans un AFTER STATEMENT, sans liste de colonnes.

Quiz final

Teste-toi

Dernière étape : le quiz. Douze questions tirées au hasard, différentes à chaque partie. Si tu te trompes, lis bien l'explication.

Sources

  1. PostgreSQL 18 Documentation, ch. 37.1 : Overview of Trigger Behavior (moments, ROW et STATEMENT, ordre alphabétique). postgresql.org
  2. PostgreSQL 18 Documentation, ch. 37.2 : Visibility of Data Changes (ce que voit chaque trigger, fonctions VOLATILE, STABLE et IMMUTABLE). postgresql.org
  3. PostgreSQL 18 Documentation : CREATE TRIGGER (UPDATE OF, WHEN et sa mise en file pour les AFTER, INSTEAD OF sur une vue, ordre des noms face à la norme SQL). postgresql.org
  4. PostgreSQL 18 Documentation, PL/pgSQL 41.10 : Trigger Functions (OLD, NEW, TG_OP, TG_WHEN, TG_LEVEL, TG_ARGV, tables de transition). postgresql.org
  5. PostgreSQL 18 Documentation : ALTER TABLE (DISABLE et ENABLE TRIGGER). postgresql.org
  6. Oracle, Database PL/SQL Language Reference 19c : « Order in Which Triggers Fire » (FOLLOWS, PRECEDES), « Mutating-Table Restriction » (ORA-04091, triggers composés), « Correlation Names and Pseudorecords » (:OLD, :NEW, ORA-04084). ordre, restrictions, pseudo-enregistrements (docs.oracle.com)
  7. Oracle, Database Concepts 10g Release 2, « The Execution Model for Triggers and Integrity Constraint Checking » (pour chaque ligne : BEFORE ROW, modification et contraintes, AFTER ROW). docs.oracle.com
  8. PostgreSQL 18 Documentation : Event Triggers (déclencheurs d'événement pour le DDL). postgresql.org
  9. Oracle, Database PL/SQL Language Reference 19c, chapitre « PL/SQL Triggers » : « Compound Triggers » et événements système (fonctions ora_sysevent, ora_dict_obj_name, ora_login_user). docs.oracle.com
  10. Oracle, Database PL/SQL Language Reference 19c : « AUTONOMOUS_TRANSACTION Pragma ». docs.oracle.com
  11. Oracle, Database PL/SQL Language Reference 19c : « CREATE TRIGGER statement » (INSTEAD OF sur une vue, ON SCHEMA, ON DATABASE, FOLLOWS et PRECEDES). docs.oracle.com
  12. Oracle, Database Error Messages 19c : ORA-06519 (« active autonomous transaction detected and rolled back »). docs.oracle.com

Fiche 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.

Glisser pour continuer vers Retour au hub
Université