Introduction à la clause HAVING de SQL : Tutoriel pour les débutants

Vous êtes débutant en SQL et vous venez de découvrir la clause HAVING et vous venez de tomber sur la clause HAVING. Mais à quoi sert-elle ? Pourquoi est-elle essentielle ? Dans cet article, nous allons nous pencher sur les principes de base de la clause HAVING en SQL. Nous ferons également des exercices pratiques pour vous aider à mieux comprendre sa fonctionnalité.

Commençons par définir le langage de requête structuré (SQL). Le langage SQL est un langage de programmation puissant et standardisé, conçu spécifiquement pour gérer et manipuler les bases de données relationnelles ; en d'autres termes, c'est la façon dont nous communiquons avec les bases de données qui contiennent toutes nos données importantes. Ces systèmes de base de données nous permettent d'effectuer toute une série de tâches, notamment l'interrogation, la mise à jour et la gestion des données.

Le langage SQL est essentiel pour une gestion et une analyse efficaces des données. Il nous permet, en tant qu'utilisateurs, de récupérer des informations spécifiques, de manipuler des données dans des bases de données et de créer des structures de base de données. SQL offre un ensemble d'outils puissants pour extraire des informations pertinentes et générer des rapports dans le cadre de l'analyse des données. Pour en savoir plus sur ces bases de données, consultez notre article Qu'est-ce qu'une base de données SQL ?

Le langage SQL comporte des mots-clés et des clauses (commandes) spécifiques qui nous aident à effectuer ces actions, à l'instar de la grammaire et des constructions d'une langue écrite. La clause HAVING en est un exemple. En SQL, la clause HAVING est utile pour affiner les résultats des requêtes en filtrant les groupes de données sur la base de conditions spécifiques. Dans cet article, nous passerons en revue quelques exercices d'initiation à la clause HAVING pour vous aider à démarrer ; pour une explication plus approfondie, consultez notre article La clause SQL HAVING expliquée.

Si vous envisagez de vous lancer dans l'aventure SQL mais ne savez pas par où commencer, notre cours SQL pour les débutants est un excellent point de départ. Dans ce cours, vous apprendrez les principes fondamentaux du langage SQL en récupérant des données dans des bases de données et en créant des rapports simples à l'aide d'exemples interactifs et concrets. Cela étant dit, examinons plus en détail la clause SQL HAVING.

La clause HAVING

La clause HAVING fonctionne en tandem avec la clause GROUP BY pour restreindre les résultats sur la base de fonctions agrégées. Les fonctions d'agrégation sont des outils SQL qui nous permettent de calculer des valeurs telles que le total (SUM), la moyenne (AVG) et la valeur la plus basse (MIN) à partir de groupes de lignes dans nos données.

Expliquons ces clauses à l'aide d'un exemple. Imaginons que nous ayons une table sales qui stocke les rapports de vente de notre entreprise. Nous pouvons utiliser la requête suivante pour trouver les régions dont les ventes totales sont supérieures à 10 000 $ :

SELECT Region, SUM(TotalSales) as TotalSales
FROM Sales
GROUP BY Region
HAVING SUM(TotalSales) > 10000;

Voici la répartition :

• SELECT Region, SUM(TotalSales) as TotalSales: La clause SELECT affiche à la fois la colonne région et la somme totale des ventes.
• FROM Sales: La clause FROM spécifie la table source - ici, sales.
• GROUP BY Region: La clause GROUP BY regroupe les données en fonction de la colonne Région. Par exemple, si nous avons les valeurs "France", "Italie" et "Espagne" dans la colonne Region, nous aurons trois groupes.
• HAVING SUM(TotalSales) > 10000: La clause HAVING spécifie que les données agrégées pour cette valeur de colonne (c'est-à-dire toutes les ventes pour 'Italie') doivent avoir des ventes totales supérieures à $10,000 pour être incluses dans notre ensemble de résultats. Si les ventes totales d'une région étaient inférieures à ce montant, elle n'apparaîtrait pas dans les résultats de notre requête.

Avec HAVING, nous pouvons affiner les résultats de la requête en filtrant les données agrégées (groupées) en fonction des conditions que nous spécifions. Les utilisateurs peuvent ainsi se concentrer sur des sous-ensembles de données répondant à des critères spécifiques, ce qui permet d'extraire des informations utiles des ensembles de données.

Vous avez peut-être entendu dire que la clause WHERE est utilisée en SQL pour filtrer les données. Quelle est la différence entre ces deux clauses ? Laquelle devez-vous utiliser ?

En SQL, les clauses HAVING et WHERE sont toutes deux importantes pour filtrer les données, mais elles sont utilisées à des étapes différentes de la requête. Pour une analyse plus approfondie, consultez notre article Quelle est la différence entre les clauses WHERE et HAVING en SQL ? Pour l'instant, voyons quelques exemples.

Modifions légèrement la requête précédente. Cette fois, nous calculons les ventes totales pour chaque région en 2023 :

SELECT Region,SUM(TotalSales) as TotalSales
FROM Sales
WHERE YEAR(SaleDate) = 2023
GROUP BY Region;

In this version, the WHERE clause filters individual rows before they are grouped to include only those with a sale date in 2023. Now, let’s include both the WHERE and HAVING clauses:

SELECT Region, SUM(TotalSales) as TotalSales
FROM Sales
WHERE YEAR(SaleDate) = 2023
GROUP BY Region
HAVING SUM(TotalSales) > 10000;

Ici, la clause WHERE filtre les lignes individuelles en fonction de la date de vente. Après l'application de GROUP BY, la clause HAVING garantit que seules les régions dont les ventes totales sont supérieures à 10 000 dollars en 2023 sont incluses dans le résultat final.

En résumé :

• WHERE est utilisé pour filtrer des lignes individuelles, en réduisant les données avant l'agrégation.
• HAVING est utilisé pour filtrer des groupes de lignes ; il est appliqué aux groupes créés par l'agrégation.

Exemples de requêtes avec HAVING

La meilleure façon d'apprendre un langage est de le pratiquer. Dans cette section, nous allons donc examiner quelques exemples pratiques pour expliquer la clause HAVING dans son contexte. Si vous êtes totalement novice en matière de requêtes SQL, jetez un coup d'œil à notre feuille d'aideSQL pour les débutants pour vous aider à naviguer dans les requêtes suivantes.

Exercice 1 : Clients ayant effectué plus d'un achat

Exercice : Vous disposez des données d'achat d'une boutique en ligne et l'équipe d'analyse de la boutique souhaite identifier les clients qui ont effectué plusieurs achats, c'est-à-dire trouver les clients qui reviennent. Affichez les identifiants des clients et le nombre d'achats qu'ils ont effectués.

Solution :

SELECT customer_id, COUNT(purchase_id) as purchase_count
FROM purchases
GROUP BY customer_id
HAVING COUNT(purchase_id) > 1;

Solution Explication :

• SELECT customer_id, COUNT(purchase_id) as purchase_count: La clause SELECT permet d'afficher les identifiants des clients et le nombre d'achats qu'ils ont effectués.
• FROM purchases: Spécifie la table source comme purchases.
• GROUP BY customer_id: Regroupe les données d'achat en fonction des identifiants des clients, en créant un groupe pour chaque client.
• HAVING COUNT(purchase_id) > 1: La clause HAVING filtre l'ensemble des résultats, en n'incluant que les clients qui ont effectué plus d'un achat.

Résultat :

Cette requête met en évidence les clients qui ont effectué plus d'un achat - ou les clients qui reviennent. La clause HAVING est essentielle car elle filtre les clients qui n'ont effectué qu'un seul achat. Sans HAVING, la requête renverrait tous les clients.

Exercice 2 : reconnaître les clients fidèles

Exercice : Le directeur d'un magasin de vêtements en ligne souhaite récompenser les clients qui ont effectué au moins dix achats en 2023. On vous a demandé d'afficher l'identifiant du client et le nombre de commandes pour les clients qui ont passé plus de 10 commandes l'année dernière. De plus, assurez-vous que le client ayant passé le plus grand nombre de commandes apparaisse en tête des résultats.

Solution :

SELECT customer_id, COUNT(order_id) as order_count
FROM orders
WHERE YEAR(order_date) = 2023
GROUP BY customer_id
HAVING COUNT(order_id) > 10
ORDER BY OrderCount DESC;

Solution Explication :

• SELECT customer_id, COUNT(order_id) as OrderCount: La clause SELECT affiche l'identifiant du client et son nombre de commandes.
• FROM orders: La table source est spécifiée comme suit orders.
• WHERE YEAR(order_date) = 2023: Ceci filtre les lignes pour n'inclure que les commandes de 2023.
• GROUP BY customer_id: Cette opération regroupe les données en fonction de l'ID du client, en créant un groupe pour chaque client.
• HAVING COUNT(order_id) > 10: Cette clause limite l'ensemble des résultats aux clients ayant passé plus de dix commandes.
• ORDER BY OrderCount DESC: Cette clause trie les résultats en fonction du nombre de commandes dans l'ordre décroissant (10-1), de sorte que le client ayant le plus grand nombre de commandes passe en premier.

Résultat :

Cette requête renvoie une liste de clients ayant effectué au moins dix achats l'année dernière, le client ayant passé le plus grand nombre de commandes étant placé en tête des résultats. La clause HAVING est importante dans ce scénario car elle restreint les résultats aux seuls clients fidèles qui ont passé plus de dix commandes. Sans la clause HAVING, la requête renverrait tous les clients, quel que soit le nombre de commandes.

Exercice 3 : Principaux produits par chiffre d'affaires

Exercice : Le responsable des ventes d'un magasin de meubles souhaite identifier les produits les plus vendus. Pour les produits dont les ventes sont supérieures à 10 000 $, il affiche l'identifiant du produit ainsi que le montant total des ventes. Veillez également à ce que les produits les plus vendus soient affichés en tête des résultats.

Solution :

SELECT product_id, SUM(sales_amount) as total_sales
FROM sales
GROUP BY product_id
HAVING SUM(sales_amount) > 10000
ORDER BY total_sales DESC;

Solution Explication :

• SELECT product_id, SUM(sales_amount) as total_sales: La clause SELECT affiche à la fois l'identifiant du produit et le montant total des ventes.
• FROM sales: La table source est spécifiée comme suit sales.
• GROUP BY product_id: Les données sont regroupées en fonction de l'ID du produit, ce qui crée un groupe pour chaque produit.
• HAVING SUM(sales_amount) > 10000: La clause HAVING filtre l'ensemble des résultats pour n'inclure que les produits dont les ventes totales sont supérieures à 10 000 $.
• ORDER BY total_sales DESC: Les résultats sont triés par ordre décroissant des ventes totales, ce qui garantit que les produits les plus vendus apparaissent en premier.

Résultat :

Cette requête renvoie une liste des produits les plus performants, en affichant les produits dont les ventes sont supérieures à 10 000 $ et en triant les lignes par ordre décroissant des ventes totales.

La clause HAVING est nécessaire ici car elle nous permet de filtrer l'ensemble des résultats à l'aide de données agrégées, en particulier les ventes totales. Sans la clause HAVING, nous ne pourrions pas filtrer les résultats en fonction des ventes totales de chaque produit. La clause WHERE n'est pas adaptée à cette tâche car elle filtre les lignes avant le regroupement ; nous sommes intéressés par les conditions appliquées aux données agrégées après le regroupement.

Exercice 4 : note moyenne par genre

Exercice : Un critique de cinéma souhaite identifier les genres de films dont la note moyenne est élevée en 2020. On vous a demandé d'afficher les genres de films et les notes moyennes pour les genres dont la note est supérieure à 4,0. Veillez également à ce que les genres dont les notes moyennes sont les plus élevées apparaissent en haut de l'écran.

Solution :

SELECT genre, AVG(rating) as avg_rating
FROM movies
WHERE YEAR(release_date) = 2020
GROUP BY genre
HAVING AVG(rating) > 4.0
ORDER BY avg_rating DESC;

Explication :

• SELECT genre, AVG(rating) as avg_rating: La clause SELECT permet d'afficher le genre de film et la note moyenne.
• FROM movies : cette clause spécifie que la table source est movies.
• WHERE YEAR(release_date) = 2020: Cette clause filtre les lignes pour n'inclure que les films sortis en 2020.
• GROUP BY genre : Cette option permet de regrouper les données par genre, en créant un groupe pour chaque genre.
• HAVING AVG(rating) > 4.0: Ceci filtre l'ensemble des résultats pour n'inclure que les genres dont la note moyenne est supérieure à 4.0.
• ORDER BY avg_rating DESC: Trie les résultats par note moyenne dans l'ordre décroissant, en veillant à ce que les genres ayant les notes moyennes les plus élevées figurent en haut de la liste.

Résultats :

Cette requête aide le critique de cinéma à identifier les genres cinématographiques exceptionnels dont la note moyenne est supérieure à 4,0 en 2020. L'ensemble des résultats comprend chaque genre et sa note moyenne, qui sont triés par ordre décroissant en fonction de la note moyenne.

La clause HAVING est essentielle car elle nous permet de filtrer les genres sur la base de données agrégées (la note moyenne).

Exercice 5 : identification des utilisateurs ayant des durées de connexion prolongées

Exercice : À l'aide des données de connexion d'un site web, l'équipe de sécurité informatique cherche à identifier les utilisateurs dont la durée de connexion est anormalement longue, ce qui lui permet d'effectuer une surveillance et une analyse complètes de la sécurité. Affichez le nom et l'adresse électronique des utilisateurs, ainsi que la durée de leur plus longue session de connexion. Ne tenez compte que des utilisateurs dont la durée de connexion dépasse deux heures (7 200 secondes). En outre, veillez à ce que les utilisateurs dont la durée de connexion est la plus longue apparaissent en tête des résultats.

Solution :

SELECT 
  users.user_name, 
  users.email_address, 
  MAX(logins.login_duration) as longest_login_duration
FROM users
JOIN logins 
ON users.user_id = logins.user_id
GROUP BY users.user_name, users.email_address
HAVING MAX(logins.login_duration) > 7200
ORDER BY longest_login_duration DESC;

Explication :

• SELECT users.user_name, users.email_address, MAX(logins.login_duration) as longest_login_duration: La clause SELECT affiche les noms des utilisateurs, leurs adresses électroniques et la durée de leur plus longue session de connexion.
• FROM users: La table source est spécifiée comme suit users.
• JOIN logins ON users.user_id = logins.user_id: Effectue une jointure interne entre les tables users et logins sur la base de l'ID de l'utilisateur.
• GROUP BY users.user_name: Cela permet de regrouper les données en fonction des noms d'utilisateur, en créant un groupe pour chaque utilisateur.
• HAVING MAX(logins.login_duration) > 7200: La clause HAVING filtre l'ensemble des résultats, en n'incluant que les utilisateurs dont la durée de connexion est supérieure à 2 heures (7200 secondes).
• ORDER BY longest_login_duration DESC: Cette clause classe les résultats en fonction de la durée de connexion la plus longue, par ordre décroissant.

Résultat :

Cette requête fournit à l'équipe de sécurité informatique les noms et adresses électroniques des utilisateurs, ainsi que la durée de leur plus longue session de connexion. Elle n'affiche que les utilisateurs dont la durée de connexion est longue, afin de renforcer la sécurité.

Dans ce cas, la clause HAVING est importante car elle nous permet de filtrer l'ensemble des résultats sur la base de données agrégées, en particulier la durée de connexion maximale atteinte par chaque utilisateur. Comme nous voulons identifier les utilisateurs qui se sont connectés pendant plus de deux heures, la clause HAVING nous permet d'imposer cette condition sur la durée maximale de connexion.

Cas d'utilisation courants pour HAVING

La clause HAVING de SQL est un outil essentiel dans les scénarios réels où l'analyse des données, la création de rapports et la veille stratégique sont importantes. Examinons quelques cas d'utilisation courants qui démontrent la polyvalence de la clause HAVING.

1) Segmentation des clients

Les entreprises ont tout intérêt à comprendre les différents groupes de clients afin de pouvoir cibler leurs efforts de marketing. La création de segments de clientèle permet d'élaborer des stratégies sur mesure, ce qui améliore la satisfaction des clients.

En utilisant HAVING, nous pouvons filtrer les clients à forte valeur ajoutée en fonction de seuils d'achat :

SELECT customer_id, SUM(purchase_amount) as total_purchase
FROM purchases
GROUP BY customer_id
HAVING SUM(purchase_amount) > 500;

2. analyse des performances des employés

Lesprofessionnels des ressources humaines peuvent utiliser SQL pour évaluer les performances des employés. Cela facilite les évaluations justes et spécifiques des performances.

La requête suivante permet de trouver les employés qui ont réalisé plus d'un certain nombre de projets :

SELECT employee_id, COUNT(project_id) as completed_projects
FROM projects
GROUP BY employee_id
HAVING COUNT(project_id) >= 5;

3. suivi des ventes de produits

Pour assurer une gestion efficace des stocks, les entreprises doivent suivre les produits les plus performants. Cela peut les aider à identifier les articles les plus vendus et à allouer les ressources de manière plus efficace.

La requête suivante permet de filtrer les produits dont les ventes dépassent un certain seuil :

SELECT product_id, SUM(sales_quantity) as total_sales
FROM sales	
GROUP BY product_id
HAVING SUM(sales_quantity) > 50;

4) Suivi de la participation à un événement

Les organisateurs d'événements peuvent vouloir identifier les participants les plus engagés, c'est-à-dire ceux qui ont participé à plus d'un événement. La recherche d'informations sur ces participants peut aider à planifier les événements à venir.

L'utilisation de HAVING dans la requête suivante nous permet d'identifier les participants les plus engagés en fonction du nombre d'événements auxquels ils ont participé :

SELECT attendee_id, COUNT(event_id) as attended_events
FROM event_attendance
GROUP BY attendee_id
HAVING COUNT(event_id) > 3;

5. le contrôle de la qualité dans l'industrie manufacturière

Dans le secteur de la fabrication, le contrôle de la qualité est essentiel à la production de produits de haute qualité. En spécifiant des seuils dans ses requêtes SQL, l'équipe peut garantir la qualité de ses produits.

En utilisant HAVING dans la requête suivante, nous pouvons identifier les produits dont les taux de défauts sont inférieurs à la limite spécifiée :

SELECT product_id, AVG(defect_rate) as avg_defect_rate
FROM manufacturing_quality
GROUP BY product_id
HAVING AVG(defect_rate) > 0.02;

Conseils de dépannage pour la clause HAVING

L'utilisation de la clause HAVING en SQL peut parfois entraîner des erreurs courantes, en particulier si vous débutez. Voici quelques conseils de dépannage pour résoudre les problèmes éventuels :

Ordre des instructions SQL

Lorsque l'on commence à utiliser des requêtes SQL, il est fréquent de commettre des erreurs dans l'ordre des instructions. Veillez toujours à ce que votre requête respecte cet ordre :

SELECT column1, COUNT(column2) as count_column2
FROM my_table
WHERE condition
GROUP BY column1
HAVING COUNT(column2) > 10
ORDER BY column1;

Absence de regroupement des données

Lorsque vous utilisez la clause HAVING, les données doivent d'abord être regroupées à l'aide de la clause GROUP BY. La requête suivante entraînerait une erreur parce qu'elle ne contient pas la clause GROUP BY:

SELECT category, COUNT(product_id) as product_count
FROM products
HAVING COUNT(product_id) > 5;

Incohérence entre SELECT et GROUP BY

La colonne non agrégée dans l'instruction SELECT doit être incluse dans la clause GROUP BY. L'exemple ci-dessous montre que la catégorie n'étant pas agrégée, elle doit être incluse dans la clause GROUP BY.

SELECT category, COUNT(product_id) as product_count
FROM products
GROUP BY category
HAVING COUNT(product_id) > 5;

Utilisation incorrecte des conditions HAVING

La requête suivante s'exécutera sans erreur, mais elle ne respecte pas les meilleures pratiques. La clause HAVING est utilisée pour filtrer les résultats sur la base de valeurs agrégées, de sorte que l'inclusion de colonnes non agrégées ou de conditions incorrectes va à l'encontre de l'objectif recherché.

SELECT category, COUNT(product_id) as product_count
FROM products
GROUP BY category
HAVING category = 'Electronics';

Bien que la requête s'exécute correctement, il est recommandé d'utiliser la clause WHERE pour filtrer les colonnes non agrégées. Cela est conforme aux meilleures pratiques et garantit la clarté de votre code SQL.

WHERE vs. HAVING

Des erreurs peuvent se produire en raison d'une confusion entre WHERE et HAVING. Pour éviter cela, rappelez-vous que WHERE concerne les lignes et HAVING les groupes.

Dans la requête précédente, il serait plus approprié d'utiliser WHERE plutôt que HAVING:

SELECT category, COUNT(product_id) as product_count
FROM products
WHERE category = 'Electronics'
GROUP BY category;

Exclusion des fonctions agrégées de HAVING

Lors d'un filtrage basé sur des valeurs agrégées, n'oubliez pas d'inclure la fonction agrégée dans la clause HAVING. Dans l'exemple suivant, product_id devrait être COUNT(product_id) dans la clause HAVING:

SELECT category, COUNT(product_id)
FROM products
GROUP BY category
HAVING product_id > 5;

Il existe de nombreuses autres erreurs de syntaxe SQL possibles. La bonne nouvelle est qu'avec de la pratique, vous apprendrez rapidement à les éviter. Lorsque vous rencontrez une erreur, prêtez attention au message d'erreur, qui peut vous aider à identifier le problème spécifique.

Prêt pour une pratique de la clause SQL HAVING ?

La clause SQL HAVING est un outil précieux pour optimiser les résultats des requêtes dans l'analyse des données, le reporting et la Business Intelligence. La maîtrise de cette clause permet aux utilisateurs de SQL d'extraire des informations précieuses à partir de données agrégées.

Au fur et à mesure que vous progressez dans votre apprentissage du langage SQL, n'ayez pas peur de faire des erreurs en écrivant des requêtes avec la clause HAVING ; cela fait partie du processus d'apprentissage ! La bonne nouvelle, c'est que vous n'êtes pas seul. De nombreux documents sont disponibles sur LearnSQL.fr pour vous aider à maîtriser la clause HAVING. Pour plus d'exemples, consultez notre didacticiel SQL HAVING.

Pour aller encore plus loin, consultez notre piste Le SQL de A à Z . Il couvre tout ce que SQL a à offrir, y compris la clause HAVING, qui est d'une importance capitale. Ce cours vous permet de combiner les connaissances théoriques avec la pratique en écrivant vos propres requêtes SQL dans une console interactive et en recevant un retour d'information instantané. Alors, qu'attendez-vous ? C'est parti !