Comment écrire des requêtes SQL compréhensibles par tous

Écrire du code SQL qui fonctionne est une chose. Écrire du SQL que quelqu'un d'autre peut lire et dire "Oh, j'ai compris" est un tout autre niveau. Et honnêtement ? C'est l'une des choses les plus utiles que vous puissiez apprendre si vous travaillez avec des données.

Que vous élaboriez des rapports, analysiez le comportement de vos clients ou répondiez à une question rapide de votre patron, vous utiliserez probablement le langage SQL. Et si ce langage SQL est désordonné ou confus, vous ralentirez tout le monde, y compris vous-même.

Ce guide vous aidera à écrire des requêtes SQL faciles à lire, simples à modifier et qui ont un sens pour les autres, même si vous ne connaissez pas encore le langage SQL.

Vous voulez pratiquer le langage SQL avec des exercices adaptés aux débutants ? Essayez le coursSQL pour les débutants sur LearnSQL.com.

L'importance d'écrire un langage SQL compréhensible

Le langage SQL n'est pas réservé aux machines. Bien sûr, la base de données exécute vos requêtes, mais des personnes réelles doivent aussi les lire. Et si votre SQL est désordonné ou confus, vous ne rendez pas seulement la vie plus difficile aux autres, vous vous la rendez plus difficile à vous-même.

Écrire un code SQL clair permet de gagner du temps. Il est plus facile de corriger les bogues, de collaborer avec les coéquipiers et de revisiter un vieux code plus tard sans se gratter la tête. Pensez-y comme si vous écriviez une note à votre futur moi ou à un coéquipier - soyez suffisamment clair pour ne pas avoir besoin de traduction.

Un code SQL lisible montre également que vous vous souciez des autres. Cela fait partie d'une bonne communication. Et lorsque vous faites partie d'une équipe, cela va très loin.

Avez-vous déjà ouvert une requête géante de 100 lignes sans commentaires et avec des noms de variables peu clairs ? Imaginez maintenant que vous essayez de la corriger sous la pression. Ce n'est pas drôle.

Comprendre l'ordre de traitement de SQL

Vous pouvez écrire le langage SQL de haut en bas, mais la base de données ne le lit pas de cette façon. Voici l'ordre réel qu'il suit :

1. FROM
2. WHERE
3. GROUP BY
4. HAVING
5. SELECT
6. ORDER BY
7. LIMIT

Comprendre cet ordre vous permet de structurer votre logique et de repérer plus facilement les erreurs.

Décomposer les longues requêtes en plusieurs parties (à l'aide des CTE)

Au lieu de tout regrouper dans une longue requête, utilisez des expressions de table communes (CTE) pour diviser la logique en étapes gérables.

Voici une version utilisant une sous-requête :

SELECT *
FROM (
  SELECT customer_id, COUNT(*) AS order_count
  FROM orders
  GROUP BY customer_id
) AS subquery
WHERE order_count > 5;

Voici maintenant la même logique à l'aide d'une ETC :

WITH orders_cte AS (
  SELECT customer_id, COUNT(*) AS order_count
  FROM orders
  GROUP BY customer_id
)
SELECT *
FROM orders_cte
WHERE order_count > 5;

Cette version est plus facile à suivre. Elle raconte l'histoire étape par étape et rend votre code plus facile à réutiliser, à tester et à maintenir.

Utilisez les majuscules pour les mots-clés SQL

L'utilisation de majuscules pour les mots-clés tels que SELECT, FROM, et WHERE les fait ressortir et améliore la lisibilité. C'est une pratique courante qui facilite l'analyse des requêtes.

Indentation du code

L'indentation montre comment les différentes parties de la requête sont liées les unes aux autres. Lorsque vous utilisez des sous-requêtes ou une logique complexe, l'indentation rend la structure claire. Comparez ces exemples :

Sans indentation :

SELECT customer_id FROM (SELECT customer_id, COUNT(*) AS total_orders FROM orders GROUP BY customer_id) AS subquery WHERE total_orders > 5;

Avec indentation :

SELECT customer_id
FROM (
    SELECT customer_id, COUNT(*) AS total_orders
    FROM orders
    GROUP BY customer_id
) AS subquery
WHERE total_orders > 5;

Une clause par ligne

En divisant les requêtes en lignes distinctes pour chaque clause (SELECT, FROM, WHERE, etc.), il est plus facile de les analyser et de les déboguer :

SELECT customer_id,
       COUNT(*) AS order_count
FROM orders
WHERE status = 'delivered'
GROUP BY customer_id;

Utiliser des alias significatifs

Évitez les alias courts et vagues tels que a, b, ou t1. Utilisez plutôt des alias qui décrivent ce qu'est la table :

SELECT o.customer_id
FROM orders AS o

Ou mieux encore :

SELECT orders.customer_id
FROM orders

N'utilisez des alias qu'en cas de besoin, et assurez-vous qu'ils sont utiles et non source de confusion.

Utilisez AS pour renommer les colonnes

Si vous créez de nouvelles colonnes, comme des totaux ou des moyennes, utilisez AS pour leur donner des noms clairs :

SELECT COUNT(*) AS total_orders

Cela facilite la compréhension de vos résultats et vous permet d'obtenir des résultats clairs et professionnels.

Évitez les SELECT *

L'extraction de toutes les colonnes à l'aide de SELECT * peut sembler facile, mais elle peut poser des problèmes :

• Elle inclut des données inutiles ou sensibles
• Elle ralentit vos requêtes
• Il rend votre code plus difficile à comprendre et à maintenir.

Au lieu de cela, listez les colonnes dont vous avez réellement besoin :

SELECT customer_id, order_date, total_amount
FROM orders

Ajouter des commentaires utiles

Utilisez -- pour ajouter des commentaires en SQL. Les commentaires expliquent pourquoi votre requête fait quelque chose, ce qui est souvent plus utile que ce qu'elle fait.

Exemple :

-- Only show active customers who ordered in the last 30 days
WHERE customer_status = 'active'
  AND order_date >= CURRENT_DATE - INTERVAL '30 days'

Les commentaires sont comme des notes pour votre futur moi - ou pour la prochaine personne travaillant sur la requête.

Utilisez des index lorsque cela est nécessaire

Si vous filtrez ou joignez souvent une colonne spécifique, cette colonne peut bénéficier d'un index. Les index permettent à la base de données de trouver les données plus rapidement. Si vous ne savez pas quelles colonnes sont indexées, demandez à l'administrateur de votre base de données ou consultez votre schéma.

Ne vous répétez pas

Si vous calculez quelque chose de complexe, faites-le une fois et réutilisez-le - ne répétez pas la logique. Les CTE sont parfaits pour cela :

WITH order_totals AS (
  SELECT customer_id, SUM(total_amount) AS total_spent
  FROM orders
  GROUP BY customer_id
)
SELECT *
FROM order_totals
WHERE total_spent > 1000;

Utiliser des outils utiles

Voici quelques outils pour débutants qui peuvent faciliter l'écriture du langage SQL :

• SQL Formatter - Nettoie automatiquement votre code avec un espacement et une structure appropriés. Essayez-en un dans VS Code ou dans votre éditeur SQL préféré.
• Outils d'embellissement en ligne - Des sites comme org vous permettent de coller des requêtes désordonnées et d'obtenir instantanément une version propre.
• SQL Linters - Ces outils vérifient vos requêtes à la recherche d'erreurs ou de formatages incohérents et suggèrent des améliorations. C'est idéal pour apprendre les meilleures pratiques au fur et à mesure.

L'utilisation de ces outils vous aide à prendre de meilleures habitudes et à écrire plus rapidement un langage SQL plus clair.

Prêt à continuer à apprendre ?

Vous êtes arrivé jusqu'ici, ce qui vous donne déjà une longueur d'avance. Si vous souhaitez continuer à développer vos compétences d'une manière pratique et agréable, la meilleure étape suivante est la pratique.

Voici quelques ressources utiles sur LearnSQL.fr:

• SQL pour les débutants - Construisez votre base avec des compétences SQL essentielles.
• Les jointures en SQL - Apprenez à combiner des données dans plusieurs tables.
• 20 exemples de requêtes SQL de base pour les débutants

Choisissez une requête désordonnée dans votre propre travail et nettoyez-la à l'aide de ce que vous avez appris. Puis faites-en une autre. Bientôt, il vous semblera naturel d'écrire des requêtes SQL propres et faciles à comprendre.