SQL (2) : filtrer, trier, compter

Avant de commencer

Pourquoi ces requêtes changent tout

Lire une liste, c'est utile. Mais une entreprise veut surtout des chiffres : combien de clients ? quel chiffre d'affaires ce mois ? le total des frais par visiteur ? C'est le rôle des fonctions d'agrégation et du GROUP BY. Et pour croiser des infos de plusieurs tables (les frais ET le nom du visiteur), il faut les relier avec un JOIN. Ces requêtes sont le cœur du métier de développeur côté données.

Ce que tu sauras faire à la fin

0. La base de jeu

On reprend deux tables GSB. Crée-les dans l'outil (sqliteonline) :

CREATE TABLE visiteur (id INT, nom TEXT, ville TEXT);
INSERT INTO visiteur VALUES (1,'Marc','Lyon'),(2,'Sophie','Paris'),(3,'Karim','Lyon');

CREATE TABLE frais (id INT, id_visiteur INT, montant DECIMAL, type TEXT);
INSERT INTO frais VALUES
 (1,1,45.50,'Restaurant'),(2,1,120.00,'Hotel'),
 (3,3,12.00,'Transport'),(4,2,89.90,'Hotel'),(5,3,60.00,'Restaurant');

1. Compter : COUNT

Agréger = réduire plusieurs lignes à un résultat unique. COUNT, SUM, AVG, MIN, MAX font toutes ça.

COUNT compte le nombre de lignes d'un résultat.

SELECT COUNT(*) FROM frais;

Compter avec une condition

SELECT COUNT(*) FROM frais WHERE type = 'Hotel';

Compter les valeurs DIFFÉRENTES : COUNT(DISTINCT …)

« Combien de frais ? » → 5. Mais « combien de visiteurs différents ont au moins un frais ? » → là, le visiteur 1 apparaît deux fois, le 3 aussi. On ne veut pas les compter deux fois : c'est DISTINCT.

SELECT COUNT(DISTINCT id_visiteur) FROM frais;

COUNT(*) ou COUNT(colonne) ? Le piège des NULL

Deux écritures voisines, mais une différence cruciale :

2. Totaliser & moyenner

Quatre fonctions essentielles, qui s'appliquent à une colonne de nombres.

SELECT SUM(montant), AVG(montant), MAX(montant) FROM frais;

Le moins cher et le plus cher : MIN & MAX

SELECT MIN(montant) AS mini, MAX(montant) AS maxi FROM frais;

Arrondir une moyenne : ROUND()

Une moyenne tombe souvent sur un nombre à rallonge (65.48, ou pire 65.4833…). Pour un affichage propre, on l'arrondit avec ROUND.

SELECT ROUND(AVG(montant), 1) AS moyenne FROM frais;

3. Calculer PAR groupe : GROUP BY

Le total de TOUS les frais, c'est bien. Mais on veut souvent le total par visiteur, ou par type. C'est le rôle de GROUP BY : il fait des paquets et calcule sur chacun.

SELECT type, SUM(montant)
FROM frais
GROUP BY type;

Compter par groupe : GROUP BY + COUNT

On peut mettre n'importe quelle fonction d'agrégation après un GROUP BY. « Combien de frais de chaque type ? » → COUNT(*) par groupe.

SELECT type, COUNT(*) AS nb
FROM frais
GROUP BY type;

4. Filtrer les groupes : HAVING

On a vu WHERE pour filtrer les lignes. Pour filtrer les groupes (après le calcul), c'est HAVING.

SELECT id_visiteur, SUM(montant) AS total
FROM frais
GROUP BY id_visiteur
HAVING SUM(montant) > 100;

SELECT type, SUM(montant) FROM frais
WHERE SUM(montant) > 100
GROUP BY type;

5. La requête complète : l'ordre des clauses

Tu connais maintenant cinq clauses. Une vraie requête métier les combine souvent toutes. Mais attention : elles doivent être écrites dans un ordre précis, sinon la base refuse la requête.

Vert = les deux filtres (WHERE sur les lignes, HAVING sur les paquets). C'est l'ordre dans lequel tu ÉCRIS les clauses.

Un exemple qui empile quatre clauses : « les types de frais (hors Transport) qui totalisent plus de 100 €, du plus gros total au plus petit ».

SELECT type, SUM(montant) AS total
FROM frais
WHERE type <> 'Transport'
GROUP BY type
HAVING SUM(montant) > 100
ORDER BY total DESC;

6. Relier deux tables : JOIN

Problème : la table frais ne contient que l'id_visiteur, pas son nom. Pour afficher « Marc a dépensé 120 € », il faut relier les deux tables avec un JOIN, via la clé étrangère.

La clé étrangère frais.id_visiteur pointe vers la clé primaire visiteur.id : c'est le pont du JOIN.

SELECT visiteur.nom, frais.montant, frais.type
FROM frais
JOIN visiteur ON frais.id_visiteur = visiteur.id;

Comparatif des types de JOIN

Alléger avec des alias de table

Écrire frais. et visiteur. partout, c'est long. On donne à chaque table un surnom (alias) juste après son nom dans le FROM : frais f, visiteur v.

SELECT v.nom, f.montant, f.type
FROM frais f
JOIN visiteur v ON f.id_visiteur = v.id;

Filtrer sur une colonne de l'autre table

Une fois les tables reliées, le WHERE peut porter sur n'importe quelle colonne des deux tables. Exemple : « tous les frais des visiteurs basés à Lyon ». La ville est dans visiteur, le montant dans frais : sans JOIN, impossible.

SELECT v.nom, f.montant, f.type
FROM frais f
JOIN visiteur v ON f.id_visiteur = v.id
WHERE v.ville = 'Lyon';

7. Grouper sur plusieurs colonnes

On peut faire des paquets sur deux colonnes à la fois : un paquet par combinaison. Exemple métier : « combien dépense-t-on par ville ET par type de frais ? » La ville est dans visiteur, le type dans frais → on a besoin du JOIN.

SELECT v.ville, f.type, COUNT(*) AS nb, SUM(f.montant) AS total
FROM frais f
JOIN visiteur v ON f.id_visiteur = v.id
GROUP BY v.ville, f.type
ORDER BY v.ville, total DESC;

8. INNER JOIN vs LEFT JOIN

Le JOIN qu'on a utilisé jusqu'ici est un INNER JOIN (jointure interne) : il ne garde que les lignes qui ont une correspondance des deux côtés. Conséquence : un visiteur sans aucun frais n'apparaîtrait pas. Souvent on veut quand même le voir (avec un total de 0). C'est le LEFT JOIN.

Étape 1 — On ajoute un visiteur sans frais

INSERT INTO visiteur VALUES (4, 'Léa', 'Nice');

Étape 2 — L'INNER JOIN l'ignore

SELECT v.nom, f.montant
FROM visiteur v
JOIN frais f ON f.id_visiteur = v.id
ORDER BY v.id;

Étape 3 — Le LEFT JOIN la garde

SELECT v.nom, f.montant
FROM visiteur v
LEFT JOIN frais f ON f.id_visiteur = v.id
ORDER BY v.id;

INNER JOIN = seulement l'intersection (qui correspond des deux côtés). LEFT JOIN = TOUTE la table de gauche + ce qui correspond à droite.

Étape 4 — Le piège des NULL avec COUNT

Maintenant qu'on a des NULL, la différence COUNT(*) vs COUNT(colonne) devient visible :

SELECT COUNT(*) AS lignes, COUNT(f.montant) AS frais_reels
FROM visiteur v
LEFT JOIN frais f ON f.id_visiteur = v.id;

Étape 5 — Le total par visiteur, Léa comprise

SELECT v.nom, COUNT(f.id) AS nb_frais, SUM(f.montant) AS total
FROM visiteur v
LEFT JOIN frais f ON f.id_visiteur = v.id
GROUP BY v.nom
ORDER BY total DESC;

9. Mini-projet : le tableau de bord GSB

On produit de vraies statistiques métier, comme un développeur le ferait sur la base de GLPI/GSB. Vérifie d'abord que tu as bien supprimé Léa (3 visiteurs).

Les questions à traduire en SQL

1. Combien de frais au total ? (COUNT)
2. Quel est le montant total et moyen (arrondi à 2 décimales) des frais ? (SUM, ROUND, AVG)
3. Le total des frais par type, du plus gros au plus petit. (GROUP BY + ORDER BY)
4. Les visiteurs (par nom) ayant dépensé plus de 100 € au total. (JOIN + GROUP BY + HAVING)
5. Le nom du visiteur ayant le frais le plus élevé. (JOIN + ORDER BY + LIMIT)

10. Entraînement express

Le SQL ne s'apprend qu'en écrivant des requêtes. Voici une batterie de petits défis : pour chacun, écris la requête, exécute-la, et garde le résultat. Tout se résout avec ce que tu viens d'apprendre (base de 3 visiteurs, 5 frais — Léa supprimée).

Pour finir

Ton antisèche

Vérifie tes acquis

1. Que fait COUNT(*) ?
2. Différence entre SUM et AVG ?
3. À quoi sert GROUP BY ?
4. Différence entre WHERE et HAVING ?
5. À quoi sert un JOIN et la clause ON ?
6. Pourquoi le JOIN justifie-t-il qu'on découpe les données en plusieurs tables ?
7. Différence entre COUNT(*) et COUNT(montant) quand il y a des NULL ?
8. Quand préfère-t-on LEFT JOIN à un JOIN classique ?
9. Dans quel ordre écrit-on WHERE, GROUP BY, HAVING et ORDER BY ?

Corrigé du quiz

Glossaire