Bonnes pratiques de formatage SQL : Écrivez des requêtes propres et maintenables

Pourquoi le formatage SQL est important

SQL est l'un des langages les plus utilisés en développement logiciel. Chaque développeur backend, analyste de données et ingénieur DevOps écrit régulièrement des requêtes SQL.

Mais la plupart des requêtes SQL dans les bases de code en production ressemblent à ceci :

SELECT u.id,u.name,u.email,o.total,o.created_at FROM users u JOIN orders o ON u.id=o.user_id WHERE o.total>100 AND u.active=1 ORDER BY o.created_at DESC LIMIT 50;

Ça fonctionne. La base de données n'en a rien à faire du formatage. Mais les humains, oui.

Quand une requête tient sur une seule ligne, elle est :

difficile à lire lors de la revue de code
difficile à débugger quand quelque chose casse
difficile à modifier quand les exigences changent
impossible à comprendre à 2h du matin pendant un incident

Un formatage SQL propre n'est pas une question d'esthétique. C'est une question de réduction du coût de compréhension du code.

Les bases : une clause par ligne

La règle de formatage la plus impactante est : placez chaque clause SQL majeure sur sa propre ligne.

SELECT
  u.id,
  u.name,
  u.email,
  o.total,
  o.created_at
FROM users u
JOIN orders o ON u.id = o.user_id
WHERE o.total > 100
  AND u.active = 1
ORDER BY o.created_at DESC
LIMIT 50;

Même requête. Même résultat. Mais maintenant vous pouvez instantanément voir :

quelles colonnes sont sélectionnées
quelles tables sont jointes
quelles conditions sont appliquées
comment les résultats sont ordonnés

Listes de colonnes

Quand vous sélectionnez plusieurs colonnes, mettez chacune sur sa propre ligne :

-- Mauvais
SELECT id, name, email, created_at, updated_at, status FROM users;

-- Bon
SELECT
  id,
  name,
  email,
  created_at,
  updated_at,
  status
FROM users;

Cela facilite :

l'ajout ou la suppression de colonnes
la mise en commentaire d'une seule colonne pour le débugage
la visualisation exacte des données récupérées

Formatage des JOIN

Les JOIN sont là où les requêtes deviennent complexes. Un formatage clair évite la confusion :

-- Mauvais
SELECT u.name,o.total,p.name FROM users u JOIN orders o ON u.id=o.user_id JOIN products p ON o.product_id=p.id WHERE o.status='completed';

-- Bon
SELECT
  u.name,
  o.total,
  p.name AS product_name
FROM users u
JOIN orders o
  ON u.id = o.user_id
JOIN products p
  ON o.product_id = p.id
WHERE o.status = 'completed';

Règles pour les JOIN :

chaque JOIN a sa propre ligne
la condition ON est indentée sous le JOIN
utilisez des types de JOIN explicites (INNER JOIN, LEFT JOIN) plutôt que simplement JOIN quand le type est important
donnez aux tables des alias courts et significatifs

Clauses WHERE

Pour les conditions multiples, indentez chaque condition :

-- Mauvais
WHERE status='active' AND created_at>'2025-01-01' AND total>100 AND country IN ('US','UK','FR')

-- Bon
WHERE status = 'active'
  AND created_at > '2025-01-01'
  AND total > 100
  AND country IN ('US', 'UK', 'FR')

Pour une logique complexe avec OR, utilisez des parenthèses clairement :

WHERE status = 'active'
  AND (
    country = 'US'
    OR country = 'UK'
  )
  AND total > 100

Sous-requêtes

Les sous-requêtes sont la partie la plus difficile à formater. La clé est une indentation cohérente :

SELECT
  u.name,
  u.email,
  order_summary.total_spent
FROM users u
JOIN (
  SELECT
    user_id,
    SUM(total) AS total_spent
  FROM orders
  WHERE status = 'completed'
  GROUP BY user_id
) AS order_summary
  ON u.id = order_summary.user_id
WHERE order_summary.total_spent > 1000
ORDER BY order_summary.total_spent DESC;

Règles :

indentez le corps de la sous-requête
fermez la parenthèse au même niveau que le mot-clé d'ouverture
donnez toujours un alias significatif aux sous-requêtes

Common Table Expressions (CTEs)

Pour les requêtes complexes, les CTEs sont plus propres que les sous-requêtes imbriquées :

WITH active_users AS (
  SELECT
    id,
    name,
    email
  FROM users
  WHERE status = 'active'
    AND last_login > '2025-01-01'
),
user_orders AS (
  SELECT
    user_id,
    COUNT(*) AS order_count,
    SUM(total) AS total_spent
  FROM orders
  WHERE status = 'completed'
  GROUP BY user_id
)
SELECT
  au.name,
  au.email,
  uo.order_count,
  uo.total_spent
FROM active_users au
JOIN user_orders uo
  ON au.id = uo.user_id
WHERE uo.total_spent > 500
ORDER BY uo.total_spent DESC;

Les CTEs rendent les requêtes complexes lisibles en les décomposant en étapes logiques nommées.

Conventions de nommage

Des conventions cohérentes évitent la confusion :

| Élément | Convention | Exemple | |---|---|---| | Tables | minuscules, pluriel | users, orders, products | | Colonnes | minuscules, snake_case | created_at, user_id, total_amount | | Alias | courts, significatifs | u pour users, o pour orders | | CTEs | snake_case descriptif | active_users, monthly_revenue | | Mots-clés SQL | MAJUSCULES | SELECT, FROM, WHERE, JOIN |

La règle la plus importante : soyez cohérent. Choisissez une convention et utilisez-la partout.

Formatage INSERT et UPDATE

-- INSERT
INSERT INTO users (
  name,
  email,
  status,
  created_at
) VALUES (
  'Alice',
  'alice@example.com',
  'active',
  NOW()
);

-- UPDATE
UPDATE users
SET
  status = 'inactive',
  updated_at = NOW()
WHERE last_login < '2024-01-01'
  AND status = 'active';

Commentaires en SQL

Utilisez les commentaires pour expliquer le pourquoi, pas le quoi :

-- Mauvais commentaire (explique le quoi)
-- Sélectionner les utilisateurs avec status actif
SELECT * FROM users WHERE status = 'active';

-- Bon commentaire (explique le pourquoi)
-- N'inclure que les utilisateurs actifs pour exclure
-- les comptes supprimés du rapport
SELECT * FROM users WHERE status = 'active';

Outils de formatage

Formater manuellement chaque requête est fastidieux. Utilisez un formateur pour faire le gros du travail, puis ajustez si nécessaire.

Lorsque vous utilisez un formateur SQL en ligne, faites attention à ce que vous collez. Si votre requête contient de vrais noms de tables, de colonnes ou de logique métier, vous exposez peut-être le schéma de votre base de données à un serveur tiers.

Utilisez un formateur qui fonctionne entièrement dans votre navigateur pour que vos requêtes ne quittent jamais votre machine.

Le Formateur SQL de FmtDev traite tout localement. Votre SQL ne quitte jamais votre navigateur.

Checklist de formatage SQL

Une clause par ligne — SELECT, FROM, JOIN, WHERE, ORDER BY, LIMIT
Une colonne par ligne dans les listes SELECT
Indenter les conditions sous WHERE et ON
Types de JOIN explicites — écrire INNER JOIN ou LEFT JOIN, pas juste JOIN
Alias significatifs — u pour users, pas t1
Mots-clés en MAJUSCULES — SELECT, FROM, WHERE, JOIN
Identifiants en minuscules — noms de tables, noms de colonnes
CTEs plutôt que sous-requêtes pour la logique complexe
Les commentaires expliquent le pourquoi, pas le quoi
Formatez localement — ne collez jamais du SQL propriétaire dans des outils en ligne