5 petites astuces SQL qui vous donnent l'air d'un pro

Vous voulez que votre langage SQL soit plus propre et plus professionnel ? Ces cinq astuces, petites mais puissantes, vous aideront à écrire des requêtes plus faciles à lire, à déboguer et à partager.

Vous avez écrit quelques requêtes SQL, joint quelques tables, peut-être même créé un petit rapport. Mais vos requêtes vous semblent toujours un peu... maladroites.

En réalité, la différence entre "faire le travail" et avoir l'air d'un pro se résume souvent à une poignée de petites habitudes - celles qui rendent votre code plus facile à lire, à maintenir et à partager avec d'autres.

Dans cet article, nous allons partager cinq petites astuces SQL qui peuvent instantanément améliorer vos requêtes. Elles sont simples, pratiques et vous donneront l'impression d'être beaucoup plus confiant en SQL.

Si vous souhaitez continuer à vous améliorer au-delà des astuces rapides, consultez notre La pratique du SQL piste. Il est rempli d'exercices réels conçus pour vous aider à dépasser la théorie et à écrire un langage SQL plus propre et plus efficace - exactement le type de compétences sur lesquelles ces astuces s'appuient.

Nous allons maintenant aborder les cinq habitudes qui peuvent rendre votre langage SQL plus soigné et plus professionnel.

1. Mettez votre code en retrait !

Cela semble ennuyeux. Cela semble évident. Mais une bonne indentation est la première chose qui sépare une requête bâclée d'une requête professionnelle.

Lorsque votre code SQL est correctement indenté, il est plus facile à lire, à déboguer et à comprendre - non seulement pour vos coéquipiers, mais aussi pour vous lorsque vous revisitez la requête des semaines plus tard. Un code SQL mal formaté est souvent à l'origine d'erreurs, de conditions manquées ou d'heures perdues à parcourir un mur de texte.

Voici ce que nous voyons souvent chez les débutants :

SELECT name, email, total FROM customers JOIN orders ON customers.id=orders.customer_id WHERE total>100;

Maintenant, regardez la même requête avec une indentation cohérente :

SELECT name,
       email,
       total
FROM customers
JOIN orders ON customers.id = orders.customer_id
WHERE total > 100;

Même requête, expérience complètement différente. Vous pouvez instantanément repérer les colonnes sélectionnées, la jointure et les conditions de filtrage. L'ajout ou la suppression d'une colonne ou d'une condition n'est plus un casse-tête.

Quelques retours à la ligne et quelques espaces rendent votre requête claire et professionnelle. C'est une petite habitude qui porte ses fruits à chaque fois que vous écrivez du SQL.

2. La virgule de tête

Je vais être honnête : je n'aime pas ce style. Mais je ne peux pas nier son utilité.

Une virgule de tête signifie que vous commencez chaque nouvelle colonne de votre liste SELECT par une virgule au lieu de terminer la ligne précédente par une virgule. Principal avantage ? Il est beaucoup plus facile de commenter des colonnes sans interrompre la requête.

Voici la méthode habituelle :

SELECT name,
       email,
       total
FROM customers;

Voici la méthode de la virgule :

SELECT name
     , email
     , total
FROM customers;

Si vous voulez commenter un courrier électronique, il suffit de le faire :

SELECT name
     -- , email
     , total
FROM customers;

Il n'est pas nécessaire de se préoccuper de supprimer les virgules ou de corriger les erreurs de syntaxe.

Vous verrez souvent des professionnels chevronnés du langage SQL utiliser ce style - non pas parce qu'il est plus joli, mais parce qu'il permet de gagner du temps lors de l'édition ou du débogage des requêtes.

3. Commencez vos filtres par WHERE 1 = 1

Cette astuce est dans le même esprit que la virgule de tête. Elle ne change rien à ce que fait votre requête, mais elle rend l'édition et le débogage de vos filtres beaucoup plus faciles.

L'idée est de commencer votre clause WHERE par une condition qui est toujours vraie (1 = 1). De cette façon, toutes les conditions réelles commencent par AND, et vous pouvez les commenter sans casser la requête.

Voici le style habituel :

SELECT *
FROM orders
WHERE order_date >= '2024-01-01'
  AND status = 'Shipped';

Voici l'approche WHERE 1 = 1:

SELECT *
FROM orders
WHERE 1 = 1
  AND order_date >= '2024-01-01'
  AND status = 'Shipped';

Maintenant, si vous avez besoin de tester ou de déboguer sans le filtre d'état, vous pouvez simplement le mettre en commentaire :

SELECT *
FROM orders
WHERE 1 = 1
  AND order_date >= '2024-01-01'
  -- AND status = 'Shipped';

Pas d'erreur de syntaxe, pas de manipulation des ET. Il s'agit d'une petite astuce qui rend votre requête plus flexible pendant que vous la construisez ou la testez.

4. Utiliser CASE

Il s'agit d'une construction SQL que de nombreux débutants ne connaissent pas - et qui change la donne. Considérez CASE comme la version SQL d'une déclaration IF. Elle vous permet de créer vos propres catégories ou étiquettes directement dans la requête, sans avoir à exporter les données vers Excel ou à écrire des scripts supplémentaires.

Voici un exemple simple :

SELECT customer_name,
       CASE
           WHEN points >= 100 THEN 'Gold'
           WHEN points >= 50  THEN 'Silver'
           ELSE 'Bronze'
       END AS loyalty_tier
FROM customers;

Ce qui est fait :
Pour chaque ligne de la table clients, SQL vérifie la valeur de la colonne points.

• Si les points sont égaux ou supérieurs à 100, il renvoie 'Gold'.
• S'il est compris entre 50 et 99, il renvoie 'Silver'.
• Sinon, il renvoie 'Bronze'.

Le résultat est une nouvelle colonne (loyalty_tier) qui affecte chaque client à une catégorie en fonction de ses points.

Comment cela fonctionne-t-il ?

• CASE commence l'expression.
• Chaque WHEN définit une condition.
• THEN définit la valeur renvoyée si cette condition est vraie.
• ELSE est facultatif - il est utilisé lorsqu'aucune des conditions ne correspond.
• END ferme l'expression.

Vous pouvez également utiliser CASE dans d'autres parties d'une requête, et pas seulement dans SELECT. Par exemple, vous pouvez regrouper des données en fonction de plages :

SELECT
    CASE
        WHEN total < 100 THEN 'Small'
        WHEN total < 500 THEN 'Medium'
        ELSE 'Large'
    END AS order_size,
    COUNT(*) AS orders_count
FROM orders
GROUP BY
    CASE
        WHEN total < 100 THEN 'Small'
        WHEN total < 500 THEN 'Medium'
        ELSE 'Large'
    END;

Une fois que vous aurez appris à utiliser CASE, vous ne dépendrez plus d'outils externes pour une catégorisation rapide - et c'est l'une des compétences qui distingue un débutant d'une personne vraiment à l'aise avec SQL.

Pour d'autres façons d'utiliser CASE, consultez nos articles :

• Comment utiliser CASE WHEN dans GROUP BY
• Comment utiliser CASE WHEN avec SUM() en SQL

Cette seule construction marque souvent la différence entre la simple connaissance de la syntaxe SQL et le fait de penser en SQL.

5. Utiliser COALESCE

La fonction COALESCE est l'un de ces outils étonnamment utiles que de nombreux débutants négligent.
Elle est simple mais puissante : elle renvoie la première valeur non NULL d ' une liste d'expressions.

Elle est donc parfaite pour gérer les données manquantes, fournir des valeurs de repli ou ajouter des valeurs par défaut significatives directement dans votre requête.

Exemple 1 : Valeurs de repli

Si vous avez plusieurs colonnes de numéros de téléphone et que vous souhaitez afficher le premier disponible :

SELECT customer_id,
       COALESCE(phone_mobile, phone_home, phone_office) AS contact_number
FROM customers;

Ici, SQL vérifie d'abord phone_mobile. S'il s'agit de NULL, il essaie phone_home. Si c'est aussi NULL, il essaie phone_office. La requête renvoie toujours la première valeur qui n'est pasNULL - vous n'avez donc pas besoin d'écrire des instructions CASE imbriquées.

Exemple 2 : valeurs par défaut significatives

Vous pouvez utiliser COALESCE pour remplacer les valeurs NULL par une valeur par défaut adaptée à votre contexte.

Pour les champs de texte :

SELECT COALESCE(middle_name, '') AS middle_name
FROM customers;

Si middle_name est NULL, la requête renvoie une chaîne vide.

Pour les champs numériques :

SELECT product_name,
       price - COALESCE(discount, 0) AS final_price
FROM products;

Si discount est NULL, il est traité comme un zéro, de sorte que le calcul fonctionne toujours sans erreur.

Exemple 3 : Notes conviviales

Vous pouvez même l'utiliser pour ajouter des espaces réservés descriptifs :

SELECT order_id,
       COALESCE(notes, 'No notes') AS order_notes
FROM orders;

Si une note est manquante, la requête affiche 'No notes' au lieu d'un blanc ou de NULL.

COALESCE est l'une de ces fonctions, petites mais puissantes, qui rendent instantanément votre langage SQL plus robuste et plus convivial. Une fois que vous vous y serez habitué, vous l'utiliserez partout pour mettre de l'ordre dans vos données.

Gros truc en prime : Utiliser les CTE

Les CTE (Common Table Expressions) ne sont pas exactement une fonctionnalité pour les débutants, mais une fois que vous commencez à les utiliser, ils changent la façon dont vous écrivez le langage SQL.

Un CTE vous permet de diviser une requête en parties logiques et de donner un nom à chacune d'entre elles. Les requêtes complexes sont ainsi plus faciles à lire, à déboguer et à maintenir. Au lieu d'empiler des sous-requêtes à l'intérieur de sous-requêtes, vous pouvez construire votre logique étape par étape.

Voici un exemple simple :

WITH high_value_orders AS (
    SELECT customer_id, total
    FROM orders
    WHERE total > 1000
)
SELECT customer_id,
       COUNT(*) AS big_orders
FROM high_value_orders
GROUP BY customer_id;

Voici ce qui se passe :

• La clause WITH définit un ensemble de résultats temporaire appelé high_value_orders.
• Vous pouvez ensuite y faire référence dans la requête principale comme s'il s'agissait d'un tableau normal.
• Cette structure est beaucoup plus propre que l'écriture d'une longue requête imbriquée.

Si vous devez modifier la définition de high_value_orders, vous pouvez le faire à un seul endroit.

Si vous êtes prêt à aller au-delà des requêtes simples, consultez notre Requêtes récursives cours. Il couvre les ETC en profondeur, y compris les modèles avancés tels que les requêtes hiérarchiques et la récursion.

Les CTE constituent un grand pas vers l'écriture d'un langage SQL qui n'est pas seulement correct, mais aussi élégant et facile à maintenir.

Récapitulatif

Les astuces que nous avons abordées - de l'indentation propre à l'utilisation de CASE, COALESCE, et même des CTE - ne sont pas seulement des raccourcis astucieux. Ce sont des habitudes qui rendent votre langage SQL plus propre, plus facile à déboguer et beaucoup plus professionnel.

Une fois que vous les aurez assimilées, vous ne voudrez plus jamais revenir à des requêtes désordonnées et difficiles à lire.

Si vous voulez vraiment vous améliorer en SQL, ces conseils ne sont qu'un début. La meilleure façon de continuer à s'améliorer est de s'entraîner sur différents sujets et scénarios du monde réel. C'est là que notre Tout à vie Pack SQL entre en jeu.

C'est le meilleur rapport qualité-prix : vous payez une fois et vous obtenez un accès à vie à tous les cours actuels et futurs sur LearnSQL.fr. Vous pouvez commencer par des cours pratiques tels que La pratique du SQL pour affiner vos compétences, puis passer à des sujets plus avancés comme Requêtes récursives ou Fonctions de fenêtrage - à votre rythme.

L'apprentissage de ces petites mais puissantes techniques est ce qui transforme SQL d'un outil de base en une véritable compétence professionnelle. Pourquoi s'arrêter à cinq astuces quand vous pouvez continuer à ajouter à votre boîte à outils pour la vie ?