Passer au contenu
🛠️
Whiz Tools

Formateur et Validateur SQL - Formatez des Requêtes SQL en Ligne Gratuitement

Formateur et validateur SQL gratuit. Formatez automatiquement SQL avec une indentation et une capitalisation appropriées. Vérifiez les erreurs de syntaxe instantanément. Fonctionne avec MySQL, PostgreSQL, SQL Server, Oracle.

Formateur et Validateur SQL

Formatez et validez des requêtes SQL avec indentation automatique, capitalisation des mots-clés et détection des erreurs de syntaxe.

Saisissez une requête SQL pour voir le résultat formaté.
Calculateur de chargement...
📚

Documentation

Qu’est-ce qu’un formateur et validateur SQL ?

Un outil de formatage SQL est un outil qui réécrit une requête SQL avec des espacements, des retours à la ligne et des mots-clés en majuscules uniformes, afin de la rendre plus facile à lire. Un validateur SQL vérifie cette même requête pour détecter des erreurs structurelles, comme une apostrophe non fermée ou une parenthèse manquante, sans se connecter à une base de données. Cet outil fait les deux. Il s’exécute entièrement dans le navigateur, de sorte que le texte de la requête n’est jamais envoyé à un serveur.

Comment formater une requête SQL

  1. Collez ou saisissez une requête SQL dans la zone de saisie.
  2. La version formatée apparaît automatiquement à droite, sans bouton à actionner.
  3. Les erreurs de validation apparaissent dans une liste sous le résultat.
  4. Un bouton de copie envoie la requête formatée dans le presse-papiers.

Règles de formatage SQL

Mise en majuscules des mots-clés

Le formateur met en majuscules une liste fixe de mots-clés SQL partout où ils apparaissent en dehors d’une chaîne de caractères ou d’un identifiant entre guillemets. Les mots-clés SQL ne sont pas sensibles à la casse : cela modifie donc l’aspect de la requête, mais pas son comportement. La liste couvre les clauses principales (SELECT, FROM, WHERE, GROUP BY, ORDER BY, HAVING, LIMIT, OFFSET), les mots de jointure (JOIN, LEFT, RIGHT, INNER, OUTER, FULL, ON), les types d’instruction (INSERT, UPDATE, DELETE, CREATE, ALTER, DROP) ainsi que les opérateurs et connecteurs courants (AND, OR, NOT, IN, BETWEEN, LIKE, AS, CASE, WHEN, THEN, ELSE, END, UNION, DISTINCT, VALUES, SET et quelques autres).

Certains mots qui ressemblent à des mots-clés sont laissés tels que saisis. Les fonctions d’agrégation comme COUNT, SUM et AVG ne figurent pas dans la liste ; count(*) reste donc en minuscules s’il a été saisi en minuscules. Les mots de sens de tri ASC et DESC, ainsi que les littéraux TRUE, FALSE et NULL employés seuls, sont eux aussi laissés intacts. Le texte à l’intérieur d’une chaîne littérale ('...'), d’un identifiant entre guillemets ("...", les accents graves de MySQL `...`, ou les crochets de SQL Server [...]) ou d’un commentaire n’est jamais modifié, quel que soit son contenu.

Retours à la ligne et indentation

Chaque clause principale commence sur une nouvelle ligne, à la marge gauche : SELECT, FROM, WHERE, GROUP BY, ORDER BY, HAVING, LIMIT et OFFSET. JOIN (et ses variantes comme LEFT JOIN) commence aussi une nouvelle ligne. CASE, WHEN, THEN, ELSE et END commencent chacun une nouvelle ligne, et UNION (ou UNION ALL, gardés ensemble sur une seule ligne) est isolé par des lignes vides. Chaque virgule commence elle aussi une nouvelle ligne : une liste de colonnes dans SELECT ou GROUP BY se retrouve donc avec une colonne par ligne.

L’indentation n’apparaît qu’à l’intérieur des parenthèses. Le contenu d’une sous-requête ou d’une expression groupée est indenté de deux espaces par niveau d’imbrication. Une requête sans parenthèses est formatée avec chaque clause alignée sur la marge gauche, sans aucune indentation.

Exemple : avant et après le formatage

Avant :

1select id, first_name, last_name, email from customers where status = 'active' order by last_name, first_name;
2

Après :

1SELECT id,
2first_name,
3last_name,
4email
5FROM customers
6WHERE status = 'active'
7ORDER BY last_name,
8first_name;
9

Chaque mot-clé est en majuscules et chaque clause et colonne se trouve sur sa propre ligne. Comme la requête ne contient pas de parenthèses, aucune ligne n’est indentée.

Les parenthèses modifient ce résultat. Le formatage de (select count(*) from employees e where e.department_id = d.id) dans une requête plus grande indente de deux espaces les éléments internes SELECT, FROM et WHERE, et laisse count en minuscules, car il s’agit d’un nom de fonction et non d’un mot-clé répertorié.

Ce que vérifie le validateur SQL

Le validateur recherche des problèmes structurels sans se connecter à une base de données :

  • Guillemets non fermés. Un guillemet simple ou double ouvert mais jamais fermé.
  • Parenthèses déséquilibrées. Le nombre de ( et de ) en dehors des chaînes et des commentaires doit être identique.
  • Sous-requêtes sans parenthèses. Un SELECT imbriqué dans un autre selon le motif SELECT ... FROM ... SELECT sans être placé entre ( ).
  • WHERE commençant par AND ou OR. Un connecteur en tête de clause, sans rien avant lui.
  • JOIN sans condition correspondante. Une JOIN doit comporter une clause ON ou USING. CROSS JOIN et NATURAL JOIN font exception, car elles n’en prennent pas.
  • GROUP BY ou ORDER BY vide. Le mot-clé de clause sans colonne après lui, à la fin de la requête.
  • Condition WHERE incomplète. Une comparaison laissée en suspens, comme WHERE status = sans valeur, ou un WHERE seul sans rien après lui, à la fin de la requête.
  • Un SELECT sans FROM. Signalé uniquement lorsque la liste de sélection ne contient que de simples noms de colonnes ; une expression, un appel de fonction ou un littéral après SELECT est valide en soi et n’est pas signalé.
  • Ordre des clauses. Deux vérifications précises sont effectuées : GROUP BY ne doit pas précéder WHERE et ORDER BY ne doit pas précéder GROUP BY. Ces vérifications sont effectuées au niveau supérieur de la requête, en ignorant le contenu des sous-requêtes.

Ce qu’il ne vérifie pas

Le validateur ne sait pas si les tables ou les colonnes existent réellement, si les colonnes jointes ont des types compatibles, ni quelles seront les performances d’une requête. Il ne signale pas non plus toutes les règles qu’applique une vraie base de données. Deux exemples : HAVING utilisé sans GROUP BY est accepté, car la présence de HAVING transforme une requête en requête groupée même sans GROUP BY, de sorte que le validateur ne lève aucune erreur. De même, il ne vérifie pas que chaque colonne non agrégée de la liste SELECT figure aussi dans GROUP BY. De nombreuses bases de données appliquent cette règle, mais cet outil ne la contrôle pas. Un point-virgule final manquant n’est pas signalé non plus, car le point-virgule est un séparateur d’instructions et ne fait pas partie d’une requête isolée.

Exemple : erreurs détectées par le validateur

1SELECT id FROM orders
2JOIN users
3WHERE status =
4

Cette requête produit deux erreurs :

  1. « Une ou plusieurs instructions JOIN n’ont pas de condition ON. » JOIN users n’a ni clause ON ni clause USING.
  2. « La condition WHERE est incomplète. » status = n’a aucune valeur après le signe égal.

Foire aux questions

Cet outil fonctionne-t-il avec MySQL, PostgreSQL, SQL Server et Oracle ?

Il prend en charge la syntaxe SQL de base commune à ces bases de données : SELECT, JOIN, WHERE, GROUP BY et les clauses similaires. La syntaxe propre à une base de données, comme les littéraux de tableaux PostgreSQL ou les blocs procéduraux T-SQL, ne perturbera pas le formateur, mais pourrait ne pas bénéficier d’un traitement particulier.

La requête SQL est-elle envoyée à un serveur ?

Non. Le formatage et la validation s’exécutent tous deux dans le navigateur. Le texte de la requête n’est transmis nulle part.

Met-il les noms de fonctions tels que COUNT, SUM et AVG en majuscules ?

Non. Seuls les mots-clés de clause, les mots-clés de jointure et une liste fixe d’opérateurs sont mis en majuscules. Les noms de fonctions tels que count, sum et avg, ainsi que les mots asc, desc, true, false et null, sont laissés exactement tels qu’ils ont été saisis.

Le validateur signale-t-il l’utilisation de HAVING sans GROUP BY ?

Non. Une clause HAVING sans GROUP BY regroupe l’ensemble du résultat en un seul groupe, ce qui est du SQL valide ; le validateur ne la traite donc pas comme une erreur.

Le validateur peut-il détecter toutes les erreurs SQL ?

Non. Il vérifie la structure : parenthèses, guillemets, quelques règles d’ordre des clauses et quelques lacunes logiques courantes, comme un JOIN sans condition. Il ne vérifie ni les noms de tables ou de colonnes, ni les types de données, ni les performances des requêtes. Une vraie connexion à une base de données reste nécessaire pour confirmer qu’une requête s’exécute correctement.

Le formatage modifie-t-il l’exécution d’une requête ?

Non. Le formatage ne modifie que les espaces et la mise en majuscules des mots-clés non placés entre guillemets. Tout ce qui se trouve dans une chaîne, un identifiant entre guillemets ou un commentaire est recopié sans modification ; la requête conserve donc exactement le même sens.

Références

  1. PostgreSQL Global Development Group. Lexical Structure. postgresql.org — les mots-clés ne sont pas sensibles à la casse.
  2. Oracle. MySQL 8.0 Reference Manual: Schema Object Names. dev.mysql.com — l’accent grave est le caractère de guillemet des identifiants de MySQL.
  3. Microsoft. Database Identifiers. learn.microsoft.com — les identifiants délimités de SQL Server utilisent des crochets ou des guillemets doubles.
  4. PostgreSQL Global Development Group. SELECT. postgresql.org — HAVING rend une requête groupée même sans GROUP BY.