Introduction aux structures de contrôle : IF, CASE, RETURN

Les structures de contrôle, c’est la base de n’importe quel programme, que ce soit un script SQL, du code Python ou même un robot sur Mars qui se demande s’il doit envoyer un signal à la maison ou chercher de la vie derrière le cratère.

En PL/pgSQL, les structures de contrôle nous aident à :

• Exécuter certaines actions si les conditions sont vraies.
• Contrôler l’ordre d’exécution du code.
• Mettre en place la logique de prise de décision.

Tu peux les imaginer comme des panneaux de signalisation sur la route : "Si tu vois STOP, tu t’arrêtes. Si tu vois le feu vert — tu fonces !"

Les structures de contrôle les plus populaires en PL/pgSQL :

• IF – vérifie une condition et exécute les commandes correspondantes.
• CASE – une alternative à IF quand il y a plein de conditions.
• RETURN – termine l’exécution d’une fonction et renvoie le résultat.

Tu as déjà une idée de ce que c’est. Et franchement, après avoir vu d’autres langages de programmation, tu vas piger ça super vite.

L’opérateur conditionnel IF

L’opérateur IF sert à exécuter du code seulement si une certaine condition est TRUE (vraie). Voilà sa structure de base :

IF condition THEN
  -- Code qui s’exécute si la condition est vraie.
ELSE
  -- Code alternatif si la condition est fausse.
END IF;

On va écrire une fonction qui prend un nombre et renvoie s’il est pair ou impair :

CREATE OR REPLACE FUNCTION check_even_odd(num INTEGER)
RETURNS TEXT AS $$
BEGIN
  IF num % 2 = 0 THEN
    RETURN 'Nombre pair';
  ELSE
    RETURN 'Nombre impair';
  END IF;
END;
$$ LANGUAGE plpgsql;

Testons-la maintenant :

SELECT check_even_odd(4); -- Nombre pair
SELECT check_even_odd(7); -- Nombre impair

Petit rappel : IF num % 2 = 0 THEN vérifie si le nombre est divisible par 2 sans reste.

La condition ELSIF

Parfois, un seul test ne suffit pas, et tu dois vérifier plusieurs conditions. Pour ça, il y a ELSIF.

Imaginons qu’on a une fonction qui renvoie un message texte sur la température :

CREATE OR REPLACE FUNCTION temperature_comment(temp INTEGER)
RETURNS TEXT AS $$
BEGIN
  IF temp < 0 THEN
    RETURN 'Très froid !';
  ELSIF temp >= 0 AND temp <= 20 THEN
    RETURN 'Frais';
  ELSE
    RETURN 'Chaud !';
  END IF;
END;
$$ LANGUAGE plpgsql;

On teste :

SELECT temperature_comment(-5);  -- Très froid !
SELECT temperature_comment(15);  -- Frais
SELECT temperature_comment(25);  -- Chaud !

Syntaxe de CASE

Si tu as plein de conditions, l’opérateur CASE devient ton sauveur. Il ressemble un peu à IF, mais il est plus "élégant".

CASE
  WHEN condition_1 THEN valeur_1
  WHEN condition_2 THEN valeur_2
  ELSE valeur_par_défaut
END;

Créons une fonction qui renvoie une appréciation texte selon un nombre :

CREATE OR REPLACE FUNCTION grade_comment(score INTEGER)
RETURNS TEXT AS $$
BEGIN
  RETURN CASE
    WHEN score >= 90 THEN 'Excellent'
    WHEN score >= 75 THEN 'Bien'
    WHEN score >= 50 THEN 'Satisfaisant'
    ELSE 'Insuffisant'
  END;
END;
$$ LANGUAGE plpgsql;

On teste :

SELECT grade_comment(95); -- Excellent
SELECT grade_comment(80); -- Bien
SELECT grade_comment(45); -- Insuffisant

Remarque : contrairement à IF, CASE renvoie une valeur, donc tu peux utiliser RETURN direct dans CASE.

L’opérateur RETURN

RETURN termine l’exécution d’une fonction et renvoie une valeur. C’est super important pour les fonctions en PL/pgSQL qui doivent forcément renvoyer quelque chose (genre texte, nombre, etc.).

Regarde comment RETURN marche dans un exemple tout simple :

CREATE OR REPLACE FUNCTION return_example()
RETURNS TEXT AS $$
BEGIN
  RETURN 'Hello, World!';
END;
$$ LANGUAGE plpgsql;

Résultat :

SELECT return_example(); -- Hello, World!

Mais si on a plusieurs branches dans le code ? Genre, vérifier les données d’entrée. Là, RETURN sera utilisé à différents endroits dans la fonction :

CREATE OR REPLACE FUNCTION check_positive_negative(num INTEGER)
RETURNS TEXT AS $$
BEGIN
  IF num > 0 THEN
    RETURN 'Nombre positif';
  ELSIF num = 0 THEN
    RETURN 'Zéro';
  ELSE
    RETURN 'Nombre négatif';
  END IF;
END;
$$ LANGUAGE plpgsql;

On teste :

SELECT check_positive_negative(10); -- Nombre positif
SELECT check_positive_negative(0);  -- Zéro
SELECT check_positive_negative(-5); -- Nombre négatif

Erreurs classiques et pièges fréquents

1. Oublier l’opérateur END : si tu oublies END CASE; ou END IF;, PostgreSQL va direct te rappeler qu’il faut fermer le bloc de code.
2. Erreurs logiques avec ELSIF : l’ordre des conditions est super important ! Une condition plus générale (temp > 0) ne doit pas venir avant une plus spécifique (temp > 20).
3. Oubli de RETURN : en PL/pgSQL, une fonction doit renvoyer quelque chose si tu as mis RETURNS.

Voilà, c’est tout pour aujourd’hui. On a vu les bases des structures de contrôle et de la logique en PL/pgSQL. Ces connaissances te serviront pour créer des fonctions plus balèzes ! La prochaine fois, on verra les boucles et comment les utiliser.