Utilisation des boucles : LOOP, FOR, WHILE en PL/pgSQL

Les boucles te permettent d’exécuter un bloc de code plusieurs fois de suite, tant qu’une certaine condition est vraie ou tant qu’on parcourt un ensemble de données. C’est super utile pour automatiser des tâches, traiter de gros volumes de données ou faire des opérations répétitives.

Imagine que tu dois distribuer des bonbons à tous les enfants d’un groupe à la main. Ce serait le bazar ! À la place, tu peux parcourir la liste des enfants et donner un bonbon à chacun à tour de rôle. Dans ce scénario, le "parcours de la liste" — c’est une boucle.

PostgreSQL supporte plusieurs types de boucles :

1. LOOP — une boucle universelle qui tourne jusqu’à ce qu’on l’arrête explicitement.
2. FOR — une boucle avec un nombre d’itérations défini sur une plage de nombres ou sur le résultat d’une requête.
3. WHILE — une boucle qui s’exécute tant qu’une condition est vraie.

Allez, on va regarder chaque type séparément.

Boucle infinie : LOOP

LOOP — c’est la forme de base de la boucle en PL/pgSQL, qui répète l’exécution d’un bloc de code. Cette boucle tourne à l’infini, et il faut la stopper manuellement avec la commande EXIT.

Syntaxe :

LOOP
    -- Ton code ici
END LOOP;

Voici un exemple. Calculons la somme des nombres de 1 à 10 avec LOOP :

DO $$
DECLARE
    counter INT := 1;
    sum INT := 0;
BEGIN
    LOOP
        sum := sum + counter; -- on ajoute la valeur actuelle du compteur
        counter := counter + 1; -- on incrémente le compteur

        -- On arrête la boucle si le compteur dépasse 10
        IF counter > 10 THEN
            EXIT;
        END IF;
    END LOOP;

    RAISE NOTICE 'Somme des nombres de 1 à 10 : %', sum;
END $$;

1. La variable counter est incrémentée à chaque itération.
2. La condition IF counter > 10 THEN EXIT; termine la boucle quand le compteur dépasse 10.
3. À la fin, on affiche la somme des nombres.

Boucle sur une plage ou un ensemble de données : FOR

Le deuxième type de boucle, FOR, sert à itérer sur :

1. Une plage de nombres.
2. Le résultat d’une requête SQL.

Boucle sur une plage de nombres

Syntaxe :

FOR variable IN [REVERSE] start..end LOOP
    -- Ton code ici
END LOOP;

Affichons les nombres de 1 à 5 :

DO $$
BEGIN
    FOR i IN 1..5 LOOP
        RAISE NOTICE 'Valeur actuelle : %', i;
    END LOOP;
END $$;

Exemple en ordre inverse :

DO $$
BEGIN
    FOR i IN REVERSE 5..1 LOOP
        RAISE NOTICE 'Ordre inverse : %', i;
    END LOOP;
END $$;

Boucle sur le résultat d’une requête SQL

Cette variante est pratique pour traiter les lignes d’une table.

Syntaxe :

FOR variable IN QUERY (SELECT ...) LOOP
    -- Ton code ici
END LOOP;

Voici un exemple d’itération sur les lignes de la table students :

DO $$
DECLARE
    student_name TEXT;
BEGIN
    FOR student_name IN QUERY (SELECT name FROM students) LOOP
        RAISE NOTICE 'Salut, % !', student_name;
    END LOOP;
END $$;

Boucle conditionnelle : WHILE

WHILE s’exécute tant que la condition donnée est vraie.

Syntaxe :

WHILE condition LOOP
    -- Ton code ici
END LOOP;

Calculons la somme des nombres de 1 à 10 avec WHILE :

DO $$
DECLARE
    counter INT := 1;
    sum INT := 0;
BEGIN
    WHILE counter <= 10 LOOP
        sum := sum + counter;
        counter := counter + 1;
    END LOOP;

    RAISE NOTICE 'Somme des nombres de 1 à 10 : %', sum;
END $$;

Exemples de la vraie vie

Maintenant qu’on a pigé les bases des boucles, voyons des exemples d’utilisation.

Exemple 1 : génération de la table de multiplication

DO $$
DECLARE
    i INT;
    j INT;
BEGIN
    FOR i IN 1..5 LOOP
        FOR j IN 1..5 LOOP
            RAISE NOTICE '% x % = %', i, j, i * j;
        END LOOP;
    END LOOP;
END $$;

Exemple 2 : itération sur les résultats d’une requête. Imaginons qu’on a une table products avec les champs id et price. On va mettre à jour tous les prix en les augmentant de 10%.

DO $$
DECLARE
    prod RECORD;
BEGIN
    FOR prod IN QUERY (SELECT id, price FROM products) LOOP
        UPDATE products
        SET price = prod.price * 1.1
        WHERE id = prod.id;
    END LOOP;
END $$;

Erreurs classiques et comment les éviter

Boucle infinie dans LOOP ou WHILE. Si tu oublies d’ajouter une condition de sortie (EXIT ou une bonne condition dans WHILE), la boucle ne s’arrêtera jamais. C’est un peu comme conduire une voiture sans freins.

Erreur lors de l’itération sur le résultat d’une requête. Si la structure des données retournées n’est pas celle attendue, tu peux tomber sur une erreur dans la boucle FOR IN QUERY.

Requêtes non optimisées à l’intérieur des boucles. Par exemple, faire un UPDATE à chaque itération peut vraiment ralentir l’exécution. Dans ces cas-là, il vaut mieux utiliser une seule requête SQL au lieu d’une boucle.