Améliorez vos requêtes : 7 astuces SQL intermédiaires que tout analyste devrait connaître

La maîtrise du SQL ne se limite pas à la rédaction de requêtes simples : elle commence lorsque vous transformez les données en informations exploitables. Découvrez sept astuces SQL intermédiaires que tout analyste devrait connaître pour analyser plus intelligemment, travailler plus rapidement et découvrir des modèles que vos requêtes de base ne peuvent pas révéler.

Si vous maîtrisez déjà SELECT, JOIN et WHERE, il est temps de passer à la vitesse supérieure. Le SQL ne s'arrête pas à SELECT. Si vous voulez devenir un analyste de données professionnel, vous devez aller au-delà des bases et commencer à penser comme quelqu'un qui transforme les données en réponses. C'est avec le SQL intermédiaire que l'analyse devient intéressante, lorsque vous cessez d'extraire des données brutes et commencez à construire des informations qui orientent réellement les décisions commerciales.

Dans cet article, nous allons passer en revue sept astuces SQL de niveau intermédiaire qui aideront tout analyste de données à travailler plus intelligemment et plus rapidement. Ces techniques sont des compétences pratiques et concrètes qui rendront vos requêtes plus puissantes, plus efficaces et prêtes pour une analyse avancée.

Chez LearnSQL.fr, notre formation SQL pour l'analyse de données vous aide à passer de la rédaction de requêtes de base à une compréhension plus approfondie des données. Vous trouverez ci-dessous sept astuces SQL que tout analyste de données devrait maîtriser pour rendre ses requêtes plus rapides, plus claires et plus pertinentes.

1. Utilisez CASE WHEN pour les colonnes conditionnelles

Souvent, les analystes doivent créer leurs propres catégories, par exemple en séparant les clients VIP des clients réguliers ou en classant les transactions comme ayant une valeur « élevée » ou « faible ». Si les filtres vous montrent les groupes existants, vous devez parfois définir les vôtres. C'est là que CASE WHEN vous aide. Il s'agit d'une expression SQL standard qui fonctionne comme une instruction IF, vous permettant d'intégrer directement une logique conditionnelle dans vos requêtes afin de segmenter les données ou d'appliquer des règles métier de manière dynamique.

Exemple :

SELECT 
  customer_id, 
  total_spent, 
  CASE 
    WHEN total_spent > 1000 THEN 'VIP' 
    WHEN total_spent BETWEEN 500 AND 1000 THEN 'Regular' 
    ELSE 'New' END AS customer_segment 
FROM customers;

Voici ce qui se passe dans cette requête. Elle commence par sélectionner l'ID et le total des dépenses de chaque client dans la table des clients. Ensuite, l' CASE expression parcourt chaque ligne, vérifiant la valeur de total_spent dans l'ordre. Si un client a dépensé plus de 1 000, SQL lui attribue le label 'VIP'. Sinon, il passe à la condition suivante : les clients qui ont dépensé entre 500 et 1000 reçoivent le label 'Regular'. Tous les autres clients sont classés dans la 'New' catégorie définie par la ELSE .

L'expression CASE expression s'arrête dès qu'elle trouve la première condition vraie, garantissant ainsi que chaque client obtient exactement une catégorie. Le résultat final comprend une nouvelle colonne, customer_segment, qui reflète l'étiquette déterminée par ces règles. Cette approche vous permet d'intégrer une logique métier simple directement dans votre SQL, rendant vos rapports ou tableaux de bord immédiatement plus pertinents sans nettoyage supplémentaire des données ni classification manuelle.

Vous pouvez en savoir plus sur l' CASE expression dans notre article SQL CASE WHEN Explained: 10 Easy Examples for Beginners

2. Combiner CASE WHEN avec GROUP BY et SUM

Vous devez parfois créer vos propres mesures récapitulatives, par exemple pour compter le nombre de commandes de valeur élevée, moyenne et faible générées par chaque région. Le regroupement standard ne peut résumer que les colonnes existantes, mais l'analyse métier nécessite souvent des définitions personnalisées. C'est là qu'intervient la combinaison de CASE WHEN avec GROUP BY et des fonctions d'agrégation telles que SUM ou COUNT devient très utile. Elle vous permet de calculer plusieurs statistiques basées sur des conditions dans une seule requête, ce qui constitue un moyen efficace de transformer des données brutes en informations commerciales significatives.

Exemple :

SELECT 
  region, 
  SUM(CASE WHEN total_amount > 1000 THEN 1 ELSE 0 END) 
    AS high_value_orders, 
  SUM(CASE WHEN total_amount BETWEEN 500 AND 1000 THEN 1 ELSE 0 END) 
    AS mid_value_orders, 
  SUM(CASE WHEN total_amount < 500 THEN 1 ELSE 0 END) 
    AS low_value_orders 
FROM orders 
GROUP BY region;

Cette requête regroupe les commandes par région et compte combien d'entre elles appartiennent à différentes catégories de valeur. Pour chaque commande, l'expression CASE vérifie l'expression total_amount et renvoie 1 si la condition est vraie ou 0 si elle est fausse. La fonction SUM additionne ensuite les valeurs 1 pour produire les totaux pour chaque catégorie au sein d'une région.

Ce modèle est utile pour comparer les performances commerciales, par exemple pour identifier les régions qui génèrent le plus de transactions à forte valeur ajoutée ou pour suivre les différences de taille des commandes entre les marchés. Au lieu d'écrire plusieurs requêtes, vous pouvez tout résumer dans une seule vue à l'aide de CASE WHEN avec GROUP BY.

Vous pouvez apprendre à utiliser CASE, COUNT, SUM, et GROUP BY dans notre cours de niveau intermédiaire Création de rapports basiques en SQL.

3. Simplifiez les résumés avec ROLLUP

Lorsque vous analysez des données dans le temps, telles que les ventes par mois et par année, vous avez souvent besoin de plusieurs niveaux d'agrégation : totaux mensuels, totaux annuels et total général. En général, cela nécessite plusieurs requêtes ou instructions UNION instructions distinctes. ROLLUP résout ce problème de manière élégante. Il étend GROUP BY automatiquement aux sous-totaux et aux totaux généraux, ce qui le rend idéal pour les rapports financiers, les tableaux de bord ou les résumés exécutifs.

Exemple :

SELECT 
  EXTRACT(YEAR FROM order_date) AS year, 
  EXTRACT(MONTH FROM order_date) AS month, 
  SUM(total_amount) AS total_sales 
FROM orders 
GROUP BY ROLLUP(
  EXTRACT(YEAR FROM order_date), 
  EXTRACT(MONTH FROM order_date)) 
ORDER BY year, month;

Résultat :

Ici, ROLLUP(year, month) indique à SQL de regrouper d'abord les données par année et par mois, puis d'ajouter une ligne supplémentaire résumant chaque année, et enfin une autre ligne indiquant le total général pour toutes les années. Partout où vous voyez NULL dans le résultat, il s'agit d'un sous-total ou d'un total généré automatiquement par ROLLUP.

Cela facilite la préparation de résumés basés sur le temps dans une seule requête, par exemple :

• Rapports de ventes mensuels et annuels.
• Visites du site web par jour, par mois et globalement.
• Suivi des dépenses par service avec totaux à l'échelle de l'entreprise.

En bref, ROLLUP est un moyen rapide et fiable de produire des résumés hiérarchiques directement en SQL, sans avoir besoin de formules de tableur ou d'agrégation manuelle.

Vous pouvez en savoir plus sur ROLLUP et d'autres GROUP BY extensions dans notre cours de niveau Les extensions GROUP BY en SQLintermédiaire .

4. Traiter les données manquantes avec COALESCE et NULLIF

L'exemple ROLLUP illustre un problème courant : les lignes de sous-totaux utilisent NULL pour représenter les niveaux de regroupement manquants, ce qui peut rendre les résultats plus difficiles à lire. De manière plus générale, NULL les valeurs dans les données sont souvent source de confusion : cellules vides dans les rapports, texte manquant dans les tableaux de bord ou calculs incomplets dans les agrégats. Tout analyste de données doit savoir comment gérer NULLde manière efficace, car des valeurs manquantes non gérées peuvent conduire à des conclusions erronées ou à des requêtes échouées. Heureusement, SQL fournit des outils simples pour rendre ces valeurs plus significatives et plus faciles à utiliser : COALESCE et NULLIF.

Utilisation de COALESCE : remplacer NULL par des valeurs lisibles

COALESCE renvoie la première valeur nonNULL d'une liste, vous permettant de remplacer l' NULL étiquette par quelque chose de plus significatif.

Exemple :

SELECT 
  COALESCE(region, 'Total') AS region_label, 
  SUM(total_amount) AS total_sales 
FROM orders 
GROUP BY ROLLUP(region);

Résultat :

Ici, COALESCE(region, 'Total') remplace la NULL de la ligne du sous-total par une étiquette lisible. Vous pouvez l'utiliser de la même manière pour remplir les nombres manquants (COALESCE(discount, 0)) ou des valeurs textuelles (COALESCE(name, 'Unknown')).

Utilisation de NULLIF : éviter les erreurs de division par zéro

NULLIF fait l'inverse : il convertit une valeur spécifique en NULL. Son utilisation la plus pratique consiste à empêcher la division par zéro dans les calculs.

Exemple :

SELECT 
  product_id, 
  sales, 
  returns, 
  sales / NULLIF(returns, 0) AS sales_to_returns_ratio 
FROM product_stats;

Si renvoie une valeur égale à zéro, NULLIF(returns, 0) renvoie NULL, empêchant ainsi SQL de générer une erreur de division par zéro.

En maîtrisant COALESCE et NULLIF, les analystes peuvent rendre leurs requêtes plus fiables et plus lisibles, garantissant ainsi que les données manquantes n'entravent jamais l'exactitude des informations.

5. Maîtrisez la manipulation des dates et des heures

Les dates sont au cœur de presque toutes les analyses : suivi des revenus mensuels, de la rétention hebdomadaire, du taux de désabonnement trimestriel ou de la croissance annuelle. Mais les horodatages bruts sont rarement au format dont vous avez besoin. Pour obtenir des informations significatives, vous devez souvent extraire des parties d'une date, calculer des intervalles de temps ou ajuster les fuseaux horaires. Un analyste de données doit savoir comment :

• trier les enregistrements par ordre chronologique,
• extraire des parties spécifiques d'une date ou d'une heure (année, mois, jour, heure, minute),
• ajouter ou soustraire des intervalles de temps,
• formater les dates pour les rapports,
• convertir les fuseaux horaires, et
• gérer les conversions entre les types de données date et chaîne ou horodatage.

SQL fournit des fonctions pour toutes ces opérations.

Exemple :

SELECT 
  EXTRACT(YEAR FROM order_date) AS year, 
  EXTRACT(MONTH FROM order_date) AS month, 
  COUNT(order_id) AS orders 
FROM orders 
GROUP BY 
  EXTRACT(YEAR FROM order_date), 
  EXTRACT(MONTH FROM order_date) 
ORDER BY year, month;

Cette requête regroupe toutes les commandes par année et par mois afin de compter le nombre de commandes passées au cours de chaque période. EXTRACT extrait des parties d'une date — ici, l'année et le mois à partir de order_date. La GROUP BY utilise ces valeurs extraites pour agréger les données par période, et ORDER BY garantit que les résultats apparaissent par ordre chronologique.

Une fois que vous comprenez comment extraire et manipuler des parties de dates, vous pouvez facilement étendre votre analyse : comparer la croissance d'un mois à l'autre, mesurer les intervalles moyens entre les commandes ou calculer les fenêtres de rétention. Ces compétences vous permettent de transformer les horodatages en informations qui reflètent les cycles commerciaux réels.

(Procurez-vous notre aide-mémoire SQL pour l'analyse de données afin de voir ces fonctions en un seul endroit.)

6. Utilisez les fonctions JSON pour les données semi-structurées

De nos jours, de plus en plus de données commerciales proviennent d'API REST, des services web qui renvoient des informations au format JSON (JavaScript Object Notation). JSON est un moyen léger et semi-structuré de stocker des données à l'aide de paires clé-valeur, de tableaux et d'objets imbriqués. Par exemple, une API peut renvoyer ceci :

{"user_id": 42, "device": "mobile", "location": {"country": "US", "city": "Boston"}}

Ce type de données est flexible, mais ne s'intègre pas parfaitement dans les tables SQL standard. Une seule colonne peut contenir un objet JSON entier, ce qui rend impossible l'utilisation d'opérateurs SQL traditionnels tels que = ou LIKE pour extraire des valeurs. C'est pourquoi les bases de données modernes incluent des fonctions JSON telles que JSON_EXTRACT() dans MySQL ou JSON_VALUE() dans SQL Server. Elles vous permettent d'interroger, de filtrer et d'agréger directement des données semi-structurées.

Exemple :

SELECT 
  JSON_EXTRACT(user_data, '$.device') AS device_type, 
  COUNT(*) AS users 
FROM events 
GROUP BY device_type;

Ici, la colonne user_data stocke des objets JSON décrivant les sessions utilisateur. La fonction JSON_EXTRACT(user_data, '$.device') récupère la valeur de la clé device clé (comme 'mobile' ou 'desktop') pour chaque ligne. La requête regroupe ensuite les résultats par type d'appareil et compte le nombre d'utilisateurs appartenant à chaque catégorie.

La possibilité de travailler avec JSON signifie que vous pouvez analyser les données provenant de systèmes modernes (réponses API, journaux d'applications ou événements de suivi) sans avoir à les remodeler au préalable. Il s'agit d'une compétence essentielle pour les analystes qui traitent des données qui ne sont pas entièrement structurées, mais qui regorgent néanmoins d'informations précieuses.

7. Organisez vos requêtes à l'aide d'expressions de table communes (CTE)

À mesure que vos compétences en SQL s'améliorent, vos requêtes s'allongent naturellement : plusieurs jointures, filtres et agrégations sont regroupés dans une seule instruction. C'est excellent pour l'analyse, mais difficile à lire et à maintenir. Les expressions de table communes (CTE) rendent les requêtes complexes plus claires et plus faciles à gérer. Elles vous permettent de définir un ensemble de résultats temporaire et nommé que vous pouvez référencer dans la même requête. Considérez une CTE comme une sous-requête réutilisable avec un nom.

Les CTE sont particulièrement utiles lorsque :

• vous devez décomposer une analyse en plusieurs étapes en parties logiques,
• le même calcul est utilisé plusieurs fois, ou
• vous souhaitez déboguer et tester séparément des sections d'une requête plus importante.

Exemple :

WITH monthly_sales AS ( 
  SELECT 
    EXTRACT(YEAR FROM order_date) AS year, 
    EXTRACT(MONTH FROM order_date) AS month, 
    SUM(amount) AS total_sales 
   FROM orders 
   GROUP BY 
     EXTRACT(YEAR FROM order_date), 
     EXTRACT(MONTH FROM order_date) 
) 
SELECT 
  year, 
  month, 
  total_sales 
FROM monthly_sales 
WHERE total_sales > 50000 
ORDER BY year, month;

Ici, le CTE nommé monthly_sales calcule le total des ventes par mois et par année. Il agit comme une table temporaire qui n'existe que pendant la durée de la requête. La requête externe filtre ensuite ce résultat pour n'afficher que les mois où les ventes ont dépassé 50 000.

Cette structure améliore la lisibilité et facilite l'extension de la requête. Par exemple, vous pouvez joindre monthly_sales avec une table de cibles ou calculer les taux de croissance sans réécrire la logique d'agrégation. Les CTE sont un outil essentiel pour les analystes qui rédigent des rapports stratifiés, basés sur des données, ou qui ont besoin de garder un SQL complexe organisé et facile à maintenir.

Vous pouvez en savoir plus sur les expressions de table communes dans notre cours Requêtes récursivesavancé .

Continuez à développer vos superpouvoirs SQL

Chacune de ces techniques vous aide à rédiger des requêtes plus intelligentes et plus flexibles, qui vous feront gagner du temps et impressionneront vos équipes.

Si vous êtes prêt à aller au-delà des bases et à acquérir de véritables compétences analytiques, explorez SQL pour l'analyse de données. Ce cours couvre tout, du reporting intermédiaire au reporting avancé, le tout avec des exercices pratiques.

Vous souhaitez avoir accès à tous les cours que nous proposons ? Le pack Tout à vie SQL vous donne un accès à vie à tous les cours etLearnSQL.fr parcours actuels et futurs. C'est le meilleur rapport qualité-prix et un paiement unique qui sera rentable tout au long de votre carrière.

Continuez à apprendre, à interroger et à progresser.