Exemples de requêtes complexes avec des tableaux : agrégation, filtrage, tri

Aujourd’hui, on va voir comment tirer le max des tableaux dans tes requêtes : regrouper des valeurs, filtrer par contenu et même trier directement à l’intérieur des tableaux. Ce n’est pas juste de la théorie pour la théorie — ces techniques sont super utiles dans les rapports, l’analytics, la personnalisation et plein de cas réels. C’est simple quand tu piges le principe — et c’est exactement ce qu’on va faire maintenant.

Agrégation de données avec des tableaux

Travailler avec des tableaux, c’est vraiment puissant quand tu dois regrouper des données. Au lieu de récupérer plusieurs lignes — tu mets les valeurs qu’il te faut dans un seul tableau bien propre. Ça simplifie l’analyse, rend les résultats plus compacts et souvent t’évite des sous-requêtes inutiles. Voyons comment ça marche en pratique.

Exemple 1 : regrouper des données dans des tableaux avec array_agg()

Quand tu veux rassembler des valeurs de plusieurs lignes d’un même groupe dans un tableau, array_agg() est là pour toi. C’est probablement la fonction la plus utile pour manipuler les tableaux lors de l’agrégation.

-- On a une table students avec les champs id, name et course
CREATE TABLE students (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    course VARCHAR(100)
);

-- On insère quelques lignes
INSERT INTO students (name, course) VALUES
('Alice', 'Mathématiques'),
('Bob', 'Mathématiques'),
('Charlie', 'Physique'),
('Dave', 'Physique'),
('Emma', 'Mathématiques');

-- On groupe les étudiants par cours dans des tableaux
SELECT course, array_agg(name) AS students
FROM students
GROUP BY course;

Résultat :

Grouper des valeurs dans des tableaux, c’est super pratique si tu veux transmettre les données dans un format facile à parser, genre en JSON.

Exemple 2 : création de tableaux imbriqués

Et si on a une autre table, et qu’on veut rassembler des données de deux tables dans des tableaux ? Par exemple, une table courses avec des infos sur les profs.

-- On crée la table des profs
CREATE TABLE courses (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    teacher VARCHAR(100)
);

-- On insère les données
INSERT INTO courses (name, teacher) VALUES
('Mathématiques', 'Prof. Min'),
('Physique', 'Prof. Peterson');

-- Requête imbriquée pour créer des tableaux
SELECT
    c.name AS course_name,
    array_agg(s.name) AS students,
    c.teacher
FROM
    courses c
LEFT JOIN
    students s
ON
    c.name = s.course
GROUP BY
    c.name, c.teacher;

Résultat :

Maintenant, on a un tableau bien pratique qui montre les cours, leurs profs et les étudiants sous forme de tableaux.

Filtrage de données avec des tableaux

Les tableaux, c’est déjà un outil puissant, mais la vraie magie commence quand tu sais filtrer les données dessus. Tu veux sélectionner seulement les utilisateurs qui ont un mot précis dans leur liste d’intérêts ? Ou les commandes où chaque prix dépasse un certain seuil ? Tout ça, tu peux le faire direct en SQL — pas besoin de logique en plus côté appli.

Exemple 1 : filtrer des lignes par éléments du tableau

Imaginons qu’on veut trouver toutes les lignes où le tableau contient une certaine valeur, genre on cherche les étudiants inscrits au cours de mathématiques.

-- On filtre les étudiants inscrits aux cours avec `ANY`
SELECT *
FROM students
WHERE course = ANY(ARRAY['Mathématiques', 'Physique']);

Ici, ANY te permet de donner un tableau de valeurs, et la requête renverra les lignes où course correspond à au moins une des valeurs du tableau.

Exemple 2 : Vérifier l’intersection de tableaux

Maintenant, imaginons qu’on a une table student_interests où les intérêts des étudiants sont stockés sous forme de tableaux. On veut trouver les étudiants dont les intérêts croisent nos critères.

-- On crée une table avec les intérêts des étudiants
CREATE TABLE student_interests (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    interests TEXT[]
);

-- On insère les données
INSERT INTO student_interests (name, interests) VALUES
('Alice', ARRAY['programmation', 'musique']),
('Bob', ARRAY['sport', 'programmation']),
('Charlie', ARRAY['lecture', 'photographie']),
('Emma', ARRAY['musique', 'sport']);

-- On cherche les étudiants intéressés par la programmation ou la musique
SELECT *
FROM student_interests
WHERE interests && ARRAY['programmation', 'musique'];

L’opérateur && vérifie l’intersection de deux tableaux. Si au moins un élément du tableau de gauche est aussi dans celui de droite, la ligne passe le filtre.

Résultat :

Tri des tableaux

Parfois, l’ordre des valeurs dans un tableau compte — surtout si tu construis un tableau à partir de plusieurs lignes ou que tu veux préparer les données pour l’affichage. PostgreSQL te permet de trier les éléments direct dans la requête, sans traitement supplémentaire.

Exemple 1 : trier les valeurs à l’intérieur d’un tableau

Parfois, tu veux trier les éléments dans un tableau. Par exemple, trions le tableau des intérêts des étudiants par ordre alphabétique.

-- On trie les éléments du tableau avec la fonction `array_sort()`
SELECT 
    name,
    array_sort(interests) AS sorted_interests
FROM 
    student_interests;

Résultat :

Exemple 2 : trier les lignes par la taille du tableau

Et maintenant, imaginons qu’on veut classer les étudiants par le nombre de leurs intérêts — du plus passionné au plus "plan-plan".

-- On trie les lignes par la taille du tableau
SELECT 
    name, 
    interests, 
    array_length(interests, 1) AS interests_count
FROM 
    student_interests
ORDER BY 
    interests_count DESC;

Résultat :

Même si tous les étudiants ont le même nombre d’intérêts dans cet exemple, tu peux adapter ce genre de requête pour des tables plus grandes.