SQL Server

WHERE ou HAVING dans SQL Server

Comprenez quand utiliser WHERE et HAVING dans SQL Server : filtrer les lignes avant le regroupement ou les groupes après.

Par JaviPublié 12 min de lectureDébutant

Après avoir appris les agrégats et les groupements avec GROUP BY, vous voudrez peut-être ne conserver que certaines lignes ou certains groupes. SQL Server propose deux filtres différents : WHERE filtre les lignes individuelles avant le regroupement ; HAVING filtre les groupes après leur création. C’est la distinction essentielle, liée à l’ordre logique de traitement.

WHERE élimine les lignes avant le regroupement

Pour compter les commandes par statut, en ne gardant que celles d’au moins 100 :

Requête SQL: WHERE élimine les lignes avant le regroupementT-SQL
SELECT
    Status,
    COUNT(*) AS OrderCount
FROM dbo.Orders
WHERE Amount >= 100
GROUP BY Status;
T-SQL6 lignesAffichage en lecture seule. Aucune connexion à une base de données.

WHERE examine d’abord le Amount de chaque commande. Les montants 125.50, 310.00 et 199.00 restent ; les cinq autres lignes, dont celle avec Amount NULL, sont écartées de cette requête. Ensuite, GROUP BY regroupe les lignes restantes selon Status. Le résultat compte deux commandes Complete et une Pending, sans groupe Shipped. La table n’est pas modifiée. Il s’agit du filtrage ligne par ligne présenté dans la leçon WHERE.

HAVING élimine les groupes après l’agrégation

Pour trouver les clients ayant passé plusieurs commandes, il faut d’abord former les groupes, puis les filtrer :

Requête SQL: HAVING élimine les groupes après l’agrégationT-SQL
SELECT
    CustomerId,
    COUNT(*) AS OrderCount
FROM dbo.Orders
GROUP BY CustomerId
HAVING COUNT(*) > 1;
T-SQL6 lignesAffichage en lecture seule. Aucune connexion à une base de données.

SQL Server regroupe les commandes par CustomerId et compte chaque groupe. HAVING conserve les groupes dont le compte dépasse un. Dans ce jeu de données, les clients 1, 4 et 7 restent : Ana a 3 commandes, David en a 2 et Grace en a 2, dont une sans montant connu. Ben n’en a qu’une et est éliminé. Le résultat comporte trois lignes, chacune représentant un groupe client admissible.

  1. Orders
  2. WHERE — filtre les lignes individuelles
  3. GROUP BY — crée des groupes
  4. HAVING — filtre les groupes
  5. SELECT — renvoie les colonnes
  6. ORDER BY — trie le résultat
WHERE filtre les lignes avant le regroupement et HAVING filtre les groupes après

Une condition d’agrégat comme COUNT(*) > 1 ne peut normalement pas se trouver dans WHERE :

Requête SQL: HAVING élimine les groupes après l’agrégation (2)T-SQL
-- Incorrect : le compte des groupes n’existe pas au stade WHERE
SELECT CustomerId, COUNT(*) AS OrderCount
FROM dbo.Orders
WHERE COUNT(*) > 1
GROUP BY CustomerId;
T-SQL5 lignesAffichage en lecture seule. Aucune connexion à une base de données.

WHERE évalue les lignes candidates avant que les groupes et leurs comptes existent. La condition porte sur le groupe : elle va dans HAVING. C’est une explication logique ; les détails physiques d’exécution sont un autre sujet.

Employer WHERE et HAVING ensemble

Une requête peut filtrer les lignes, regrouper les survivantes, puis filtrer les groupes :

Requête SQL: Employer WHERE et HAVING ensembleT-SQL
SELECT
    CustomerId,
    COUNT(*) AS OrderCount,
    SUM(Amount) AS Amount
FROM dbo.Orders
WHERE Status = N'Complete'
GROUP BY CustomerId
HAVING SUM(Amount) >= 100
ORDER BY Amount DESC;
T-SQL9 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Voici la séquence logique :

  1. WHERE conserve les quatre commandes Complete.
  2. GROUP BY crée un groupe par client parmi ces lignes.
  3. COUNT et SUM calculent les mesures de chaque groupe.
  4. HAVING conserve les groupes dont le total atteint 100.
  5. SELECT renvoie le client, le compte et le total.
  6. ORDER BY trie les résultats par total décroissant.

Les clients 1 et 4 sont retenus : Ana a 3 commandes Complete totalisant 250.49 ; David en a une de 199.00. Pour Ana, il s’agit des montants 125.50, 49.99 et 75.00. L’autre commande de David est Shipped et n’entre donc pas dans les groupes. WHERE détermine les lignes qui contribuent au compte et à la somme ; HAVING n’enlève pas une commande avant le calcul de l’agrégat du groupe.

Règle pratique et portée des alias

Utilisez WHERE pour les conditions portant sur une ligne, comme Status = N'Complete' ou Amount >= 100. Utilisez HAVING pour les conditions portant sur un groupe ou un agrégat, comme COUNT(*) > 1 ou SUM(Amount) >= 100. Si une condition peut être exprimée comme filtre de ligne, WHERE exprime généralement plus clairement l’intention : les lignes inutiles ne contribuent pas au regroupement. Cette règle aide à choisir la clause ; elle ne garantit pas un plan d’exécution particulier.

Ne supposez pas qu’un alias défini dans SELECT est déjà utilisable dans HAVING. Dans l’ordre logique de la leçon 5, HAVING précède la création des alias de SELECT. Écrivez HAVING SUM(Amount) >= 100, plutôt que HAVING Amount >= 100 si Amount est l’alias de cet agrégat. ORDER BY, traité après SELECT dans ce modèle logique, peut utiliser l’alias choisi.

SQL Server autorise aussi HAVING dans certaines requêtes d’agrégation sans GROUP BY explicite : l’entrée est alors traitée comme un groupe unique. Ce cas est moins courant pour les débutants. Pour l’instant, utilisez GROUP BY pour obtenir une ligne par catégorie, puis HAVING pour conserver certains groupes.

Lire chaque condition au bon niveau

Comparez deux questions proches. « Conserver les commandes d’au moins 100 » concerne chaque commande. Une ligne répond ou non à la condition : elle va dans WHERE. « Conserver les clients dont le montant cumulé atteint 100 » concerne le total d’un ensemble de commandes. Aucune commande individuelle ne doit atteindre 100 ; c’est la somme du groupe qui compte. Il faut donc regrouper par client puis utiliser HAVING.

Ces deux questions peuvent renvoyer certains des mêmes clients, mais elles ne sont pas équivalentes. Imaginons un client ayant deux commandes de 60. WHERE Amount >= 100 élimine les deux lignes, donc le client n’apparaît pas. En regroupant les commandes et avec HAVING SUM(Amount) >= 100, il reste, car le total combiné vaut 120. Ces filtres répondent à deux questions métier différentes. Choisissez la clause selon le sens de la condition, et non selon le résultat aperçu lors d’un essai rapide.

WHERE peut utiliser des comparaisons ordinaires sur les colonnes d’entrée : constante, intervalle ou test de NULL comme IS NULL. Il ne peut pas tester le compte ou la somme d’un groupe, car cet agrégat n’existe pas encore. HAVING peut évaluer des agrégats et des valeurs de regroupement. Pour débuter, réservez HAVING aux groupes et aux agrégats. SQL Server permet certaines conditions non agrégées dans HAVING, mais déplacer un simple filtre de ligne à cet endroit rend souvent l’intention moins claire.

Dans l’exemple combiné, chaque agrégat est calculé sur les lignes conservées par WHERE. Si l’on déplaçait Status = N'Complete' vers HAVING, les commandes seraient d’abord regroupées par client, puis le groupe entier serait conservé ou rejeté selon une condition de groupe. Cela ne signifie pas « seules les commandes terminées contribuent ». Si un client a des commandes terminées et en attente, ces deux statuts pourraient contribuer au total, selon les groupes et la condition choisis. Filtrer l’entrée dans WHERE rend explicite la population mesurée.

L’ordre logique explique aussi pourquoi un alias de sortie n’est pas visible dans chaque clause. SELECT crée les noms de sortie après WHERE, GROUP BY et HAVING dans ce modèle. L’alias Amount donné à SUM(Amount) est une étiquette ; ce n’est pas une colonne d’entrée et il ne rend pas l’agrégat utilisable dans WHERE. Répétez l’expression d’agrégat dans HAVING pour indiquer clairement ce qui est testé. ORDER BY vient ensuite et peut utiliser un alias sélectionné.

Lors d’une révision, décrivez la population et les groupes en langage courant : « d’abord, seulement les commandes Complete ; ensuite, un groupe par client ; enfin, garder les groupes dont le total atteint 100 ». Si cette phrase ne correspond pas aux clauses SQL, la requête exprime probablement une autre question. Cette méthode simple permet de repérer les changements accidentels lorsqu’on ajoute un filtre à un rapport existant.

Un dernier contrôle consiste à comparer le détail filtré avec le résultat groupé. Exécutez d’abord la partie WHERE comme une requête de détail si la population d’entrée n’est pas claire, puis vérifiez les CustomerId conservés avant l’agrégation. Après l’ajout de GROUP BY, contrôlez le compte et la somme pour un client connu. Par exemple, les trois commandes Complete d’Ana valent 125.50, 49.99 et 75.00, soit un total de 250.49. Cette vérification permet de confirmer que le filtre de ligne et le calcul par groupe ont le sens attendu. Elle est utile quand la requête comprend plusieurs conditions : une condition mal placée peut donner un résultat SQL valide qui répond pourtant à la mauvaise question.

Vous pouvez aussi conserver temporairement OrderId pendant l’inspection du filtre WHERE. Ces identifiants permettent de vérifier précisément quelles commandes restent avant le regroupement. Retirez-les ensuite de la requête de synthèse : afficher OrderId et regrouper par client changerait le grain, car chaque commande pourrait former sa propre ligne. Les colonnes de diagnostic sont utiles pendant la vérification, mais elles doivent correspondre au niveau de détail voulu dans le résultat final.

Erreurs fréquentes et exercices

Ne placez pas une condition d’agrégat dans WHERE, n’utilisez pas HAVING pour un simple filtre de ligne et ne supposez pas que HAVING précède GROUP BY. N’oubliez pas que WHERE modifie les lignes entrant dans chaque agrégat. Enfin, distinguez l’ordre écrit de l’ordre logique et ne supposez pas qu’un alias SELECT existe déjà au moment d’évaluer HAVING.

Exercices sur dbo.Orders : (1) compter par statut les commandes inférieures à 100 ; (2) trouver les clients ayant plus d’une commande ; (3) pour Pending, afficher les clients dont le total atteint 100 ; (4) expliquer la différence entre filtrer chaque Amount >= 100 dans WHERE et exiger une SUM(Amount) >= 100 dans HAVING ; (5) expliquer pourquoi WHERE COUNT(*) > 1 est invalide.

Réponses

Requête SQL: RéponsesT-SQL
-- 1 : Complete 2, Shipped 1, Pending 1
SELECT Status, COUNT(*) AS OrderCount FROM dbo.Orders
WHERE Amount < 100 GROUP BY Status;
-- 2 : clients 1, 4 et 7
SELECT CustomerId, COUNT(*) AS OrderCount FROM dbo.Orders
GROUP BY CustomerId HAVING COUNT(*) > 1;
-- 3 : le client 2 totalise 310.00
SELECT CustomerId, SUM(Amount) AS PendingTotal FROM dbo.Orders
WHERE Status = N'Pending' GROUP BY CustomerId
HAVING SUM(Amount) >= 100;
T-SQL10 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Cette partie se termine et continue avec INSERT dans le parcours de modification des donnees. Consultez la feuille de route SQL Server Foundations pour voir l’étape suivante.

Vérifiez ce que vous avez retenu

2 questions rapides

Question 1 sur 2Quelle clause filtre les lignes avant le regroupement ?
Question 2 sur 2Quelle clause filtre les groupes après agrégation ?

Fondamentaux de SQL Server

Leçon 15 sur 25

Continuer vers la leçon suivante

Les bases d’INSERT dans SQL Server

Continuer vers la leçon 16

Étiquettes

  • SQL Server
  • Fondamentaux SQL
  • SSMS
  • T-SQL