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.
Dans cet article
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 :
SELECT
Status,
COUNT(*) AS OrderCount
FROM dbo.Orders
WHERE Amount >= 100
GROUP BY Status;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 :
SELECT
CustomerId,
COUNT(*) AS OrderCount
FROM dbo.Orders
GROUP BY CustomerId
HAVING COUNT(*) > 1;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.
- Orders
- WHERE — filtre les lignes individuelles
- GROUP BY — crée des groupes
- HAVING — filtre les groupes
- SELECT — renvoie les colonnes
- ORDER BY — trie le résultat
Une condition d’agrégat comme COUNT(*) > 1 ne peut normalement pas se trouver dans WHERE :
-- 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;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 :
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;Voici la séquence logique :
WHEREconserve les quatre commandesComplete.GROUP BYcrée un groupe par client parmi ces lignes.COUNTetSUMcalculent les mesures de chaque groupe.HAVINGconserve les groupes dont le total atteint 100.SELECTrenvoie le client, le compte et le total.ORDER BYtrie 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
-- 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;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
Fondamentaux de SQL Server
Leçon 15 sur 25
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Continuer à apprendre
- Aide-mémoireTypes d’attente SQL ServerUtilisez les statistiques d’attente SQL Server pour identifier où le travail passe son temps, distinguer les attentes en cours des attentes cumulées et choisir la prochaine piste d’investigation des performances.Ouvrir l’aide-mémoire
- ArticleFonctions d’agrégation dans SQL Server : COUNT, SUM, AVG, MIN et MAXApprenez à résumer les lignes de SQL Server avec COUNT, SUM, AVG, MIN et MAX sur Customers et Orders.Lire l’article
- Feuille de routeSQL Server FoundationsComprenez quand utiliser WHERE et HAVING dans SQL Server : filtrer les lignes avant le regroupement ou les groupes après.Voir la feuille de route
Que devrais-je créer ensuite ?
Je développe Javi Builds autour des problèmes concrets rencontrés par les data engineers. Dites-moi quel sujet vous aimeriez voir ensuite.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.