Types de données et leur utilisation dans PL/pgSQL : INTEGER, TEXT, BOOLEAN, RECORD

Dans cette leçon, on va voir quels types de données sont supportés dans PL/pgSQL et comment bosser efficacement avec. On va surtout se concentrer sur quatre types de données :

• INTEGER pour manipuler des nombres.
• TEXT pour gérer des chaînes de caractères.
• BOOLEAN pour bosser avec des valeurs logiques.
• RECORD pour manipuler des structures de données dynamiques.

On va voir chaque type de données à travers des exemples, histoire que tu comprennes bien comment ça marche en pratique.

Types de données supportés dans PL/pgSQL

PL/pgSQL supporte tous les types de données que tu connais déjà dans PostgreSQL. Des types numériques simples (INTEGER, NUMERIC) jusqu’aux trucs plus avancés comme les tableaux et JSONB. On va faire un petit tour des principaux.

1. Types primitifs :

   • INTEGER, BIGINT, FLOAT, NUMERIC — types numériques.
   • TEXT, CHAR, VARCHAR — types texte.
   • BOOLEAN — type logique.

2. Types complexes :

   • RECORD — pour manipuler des ensembles de données dynamiques.
   • ROWTYPE — pour manipuler des types de lignes de table.
   • Tableaux et JSON — on verra ça plus tard dans le cours.

Travailler avec le type INTEGER

INTEGER — c’est l’un des types de données les plus utilisés. Il sert à stocker des nombres entiers. En PL/pgSQL, tu peux t’en servir pour faire des calculs, gérer des identifiants d’enregistrements et tester des conditions.

Exemple : compter le nombre d’enregistrements

Imaginons qu’on a une table students et qu’on veut savoir combien d’étudiants sont enregistrés dans la base.

DO $$
DECLARE
    total_students INTEGER; -- Variable pour stocker le nombre d’étudiants
BEGIN
    SELECT COUNT(*) INTO total_students FROM students; -- On met le résultat de la requête dans la variable
    RAISE NOTICE 'Nombre d’étudiants : %', total_students; -- On affiche le message
END;
$$;

Points importants avec INTEGER :

• En PL/pgSQL, pour assigner une valeur à une variable, on utilise le mot-clé INTO.
• Si tu essaies de mettre une valeur décimale dans un INTEGER, tu auras une erreur. Pour ça, utilise plutôt NUMERIC ou FLOAT.

Travailler avec le type TEXT

TEXT sert à stocker des chaînes de caractères. C’est super utile quand tu dois manipuler des noms, des descriptions ou n’importe quel texte.

Exemple : afficher les prénoms des étudiants

Dans cet exemple, on va afficher les prénoms de tous les étudiants de la table students.

DO $$
DECLARE
    student_name TEXT; -- Variable pour le prénom de l’étudiant
BEGIN
    FOR student_name IN SELECT name FROM students LOOP
        RAISE NOTICE 'Prénom de l’étudiant : %', student_name; -- On affiche chaque prénom
    END LOOP;
END;
$$;

Fonctions utiles pour bosser avec TEXT :

• UPPER() et LOWER() — pour mettre en majuscules/minuscules.
• CONCAT() — pour concaténer des chaînes.
• LENGTH() — pour obtenir la longueur d’une chaîne.

Par exemple :

DO $$
DECLARE
    full_name TEXT;
BEGIN
    full_name := CONCAT('Alex', ' Min'); -- On concatène les chaînes
    RAISE NOTICE 'Nom complet : %', UPPER(full_name); -- On affiche le nom en majuscules
END;
$$;

Travailler avec le type BOOLEAN

BOOLEAN sert à stocker des valeurs logiques : TRUE, FALSE et NULL. Ce type est super pratique pour tester des conditions et filtrer des données.

Exemple : vérifier si un étudiant est actif

Imaginons que tu as une table students avec une colonne is_active qui indique si l’étudiant est actif.

DO $$
DECLARE
    is_active BOOLEAN; -- Variable pour stocker l’état d’activité
BEGIN
    SELECT is_active INTO is_active FROM students WHERE id = 1; -- On récupère la valeur depuis la table
    IF is_active THEN
        RAISE NOTICE 'L’étudiant est actif !';
    ELSE
        RAISE NOTICE 'L’étudiant N’EST PAS actif.';
    END IF;
END;
$$;

Points importants avec BOOLEAN :

• Tu peux utiliser les valeurs logiques directement dans les conditions IF et WHILE.
• La valeur NULL est considérée comme "indéfinie" en logique, donc fais gaffe quand tu fais des tests.

Travailler avec le type RECORD

RECORD — c’est un type de données puissant qui sert à stocker des lignes de données sans structure prédéfinie. C’est super utile quand tu bosses avec des résultats de requêtes SQL qui renvoient plusieurs colonnes.

Exemple : parcourir tous les enregistrements d’une table

Dans l’exemple suivant, on parcourt tous les enregistrements de la table students et on affiche le prénom et l’ID de chaque étudiant.

DO $$
DECLARE
    student RECORD; -- Type dynamique pour stocker une ligne de données
BEGIN
    FOR student IN SELECT id, name FROM students LOOP
        RAISE NOTICE 'ID : %, Prénom : %', student.id, student.name; -- On accède aux colonnes de l’enregistrement
    END LOOP;
END;
$$;

Points importants avec RECORD :

• Les variables de type RECORD sont remplies seulement dans une boucle ou avec une requête SELECT INTO.
• Pour accéder aux colonnes, utilise record.nom_colonne.

Types de données ROWTYPE pour bosser avec les tables

Si tu veux stocker tout un enregistrement d’une table (et que tu veux une typage strict), tu peux utiliser le type ROWTYPE. Il hérite automatiquement de la structure de la ligne de la table.

Exemple : bosser avec le type ROWTYPE

DO $$
DECLARE
    student students%ROWTYPE; -- Variable avec la structure de la ligne de la table students
BEGIN
    SELECT * INTO student FROM students WHERE id = 1; -- On charge les données de la ligne dans la variable
    RAISE NOTICE 'Prénom de l’étudiant : %, Cours : %', student.name, student.course;
END;
$$;

Différences entre RECORD et ROWTYPE

Exemple pratique

Écrivons une fonction qui retourne le nombre d’étudiants actifs et leurs prénoms.

CREATE FUNCTION active_students_report() RETURNS TABLE(id INT, name TEXT) AS $$
BEGIN
    RETURN QUERY
    SELECT id, name FROM students WHERE is_active = TRUE;
END;
$$ LANGUAGE plpgsql;

Appel de la fonction :

SELECT * FROM active_students_report();

Erreurs fréquentes avec les types de données

Parfois, manipuler les données peut causer des erreurs. Voilà quelques cas classiques :

• Erreur de type : essayer de mettre une chaîne dans une variable INTEGER (genre my_var := 'abc';).
• Utiliser NULL là où on attend TRUE ou FALSE.
• Mauvaise utilisation de RECORD sans initialisation.

Comment éviter les erreurs :

• Déclare toujours explicitement le type des variables.
• Vérifie les types de données des colonnes dans les tables avant d’écrire dedans.
• Utilise des commandes de debug comme RAISE NOTICE.

Maintenant tu sais comment bosser avec les types de données INTEGER, TEXT, BOOLEAN et RECORD dans PL/pgSQL. Avec ça, tu vas pouvoir écrire des programmes plus costauds et puissants en PostgreSQL procedural.