Bases de la syntaxe des triggers : CREATE TRIGGER, WHEN, EXECUTE FUNCTION

Pour créer un trigger dans PostgreSQL, tu dois définir les éléments suivants :

• Le nom du trigger.
• Le type d'événement (INSERT, UPDATE, DELETE).
• Le moment d'exécution (BEFORE ou AFTER).
• La table à laquelle il est rattaché.
• La fonction qui sera exécutée (en PL/pgSQL ou un autre langage).

Voici la structure générale de la commande :

CREATE TRIGGER nom_du_trigger
[BEFORE | AFTER] {INSERT | UPDATE | DELETE}
ON nom_de_la_table
[FOR EACH ROW | FOR EACH STATEMENT]
WHEN (condition)
EXECUTE FUNCTION nom_de_la_fonction();

Exemple d'un trigger simple

On va créer une table de base students et ajouter un trigger qui se déclenche après l'ajout d'une nouvelle ligne.

Pour commencer, créons la table students

CREATE TABLE students (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    last_modified TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Qu'est-ce qui se passe ici ? On a créé une table avec les champs id, name et last_modified. Le champ last_modified va stocker la date et l'heure de la dernière modif de la ligne.

Les triggers sont toujours liés à des fonctions. On va d'abord créer une petite fonction qui va mettre à jour le champ last_modified à chaque ajout :

CREATE OR REPLACE FUNCTION update_last_modified()
RETURNS TRIGGER AS $$
BEGIN
    -- On met la date et l'heure actuelles dans le champ last_modified
    NEW.last_modified := CURRENT_TIMESTAMP;
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

C'est quoi cette magie ?

1. NEW — une variable spéciale qui contient les nouvelles valeurs de la ligne (pour les événements INSERT ou UPDATE).
2. CURRENT_TIMESTAMP — une fonction qui renvoie la date et l'heure actuelles.
3. RETURN NEW — retourne la ligne modifiée pour qu'elle soit sauvegardée.

Maintenant, on crée le trigger :

CREATE TRIGGER set_last_modified
AFTER INSERT
ON students
FOR EACH ROW
EXECUTE FUNCTION update_last_modified();

Décryptage :

• AFTER INSERT : le trigger se déclenche après l'ajout d'une nouvelle ligne.
• ON students : le trigger s'applique à la table students.
• FOR EACH ROW : le trigger s'exécute pour chaque nouvelle ligne.
• EXECUTE FUNCTION : indique quelle fonction doit être appelée.

Tester le trigger

On va voir comment marche notre trigger :

INSERT INTO students (name) VALUES ('Alice');
SELECT * FROM students;

Tu vas voir un résultat du genre :

Le trigger a automatiquement mis à jour le champ last_modified. Magique ? Non, c'est juste PostgreSQL.

Utiliser des conditions avec WHEN

Parfois, tu veux que le trigger ne s'exécute pas tout le temps, mais seulement dans certains cas. Pour ça, on utilise le mot-clé WHEN.

Regardons un exemple où le trigger ne s'exécute que pour certaines valeurs.

Imaginons qu'on veut que le trigger ne s'active que pour les étudiants qui s'appellent "Alice". On modifie notre trigger :

CREATE OR REPLACE FUNCTION update_last_modified_condition()
RETURNS TRIGGER AS $$
BEGIN
    NEW.last_modified := CURRENT_TIMESTAMP;
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER set_last_modified_condition
AFTER INSERT
ON students
FOR EACH ROW
WHEN (NEW.name = 'Alice')
EXECUTE FUNCTION update_last_modified_condition();

Maintenant, le trigger va mettre à jour le champ last_modified seulement pour les étudiants qui s'appellent "Alice".

Testons :

INSERT INTO students (name) VALUES ('Alice');
INSERT INTO students (name) VALUES ('Bob');
SELECT * FROM students;

Résultat :

À noter : pour l'étudiant "Bob", le champ last_modified est resté vide, parce que le trigger ne s'est pas déclenché.

Lien entre trigger et fonction : EXECUTE FUNCTION

La fonction, c'est le cœur de tout trigger. Un trigger ne peut pas exister sans une fonction qui définit sa logique. Dans PostgreSQL, tu peux écrire des fonctions en PL/pgSQL ou dans d'autres langages supportés, comme Python ou C.

Voici un exemple avec une fonction PL/pgSQL.

On va créer une fonction qui log les changements dans une table séparée audit_log.

D'abord, créons la table audit_log

CREATE TABLE audit_log (
    id SERIAL PRIMARY KEY,
    operation TEXT NOT NULL,
    student_id INTEGER NOT NULL,
    log_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Et maintenant – la fonction :

CREATE OR REPLACE FUNCTION log_insert()
RETURNS TRIGGER AS $$
BEGIN
    INSERT INTO audit_log (operation, student_id)
    VALUES ('INSERT', NEW.id);
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

On écrit maintenant le trigger :

CREATE TRIGGER log_student_insert
AFTER INSERT
ON students
FOR EACH ROW
EXECUTE FUNCTION log_insert();

Et on teste :

INSERT INTO students (name) VALUES ('Charlie');
SELECT * FROM audit_log;

Tu vas voir un résultat du genre :

Le trigger a automatiquement enregistré un log pour la nouvelle ligne.

Erreurs et particularités des triggers

Erreur : absence de fonction. Si tu essaies de créer un trigger sans fonction, PostgreSQL va te sortir une erreur. Crée toujours la fonction avant le trigger.

Problèmes de perf. Trop de triggers ou des fonctions trop lourdes peuvent ralentir ta base de données. Utilise-les avec modération.

Récursivité. Si un trigger modifie la même table sur laquelle il s'applique, ça peut partir en boucle infinie. Utilise des conditions WHEN pour éviter ça.