3 méthodes pour formater une date en SQL facilement

Quand j’ai commencé à travailler avec des bases de données en 2014, l’une des premières difficultés que j’ai rencontrées concernait le format date SQL. Afficher une date au format français, convertir un timestamp en chaîne lisible ou extraire uniquement le mois d’une colonne datetime : ces opérations reviennent dans pratiquement tous les projets. Le problème, c’est que chaque système de gestion de base de données (MySQL, SQL Server, Oracle) utilise sa propre syntaxe. Dans ce guide, je vous présente les trois méthodes principales pour formater une date en SQL, avec des exemples concrets que vous pouvez directement réutiliser dans vos projets.

Comprendre les types de données date en SQL

Avant de formater quoi que ce soit, il faut comprendre comment SQL stocke les dates. Selon la norme SQL définie par l’ISO, il existe plusieurs types de données temporelles que l’on retrouve dans tous les SGBD, avec quelques variations.

Le type DATE stocke uniquement la date (année, mois, jour). Le type DATETIME ou TIMESTAMP ajoute l’heure, les minutes et les secondes. Enfin, le type TIME ne conserve que la composante horaire. Chaque SGBD implémente ces types avec ses propres particularités.

En interne, les dates sont stockées sous un format binaire optimisé pour les calculs et les comparaisons. Ce que vous voyez à l’écran, c’est une représentation textuelle de cette valeur. Le formatage consiste donc à transformer cette valeur interne en une chaîne de caractères lisible, selon le modèle que vous définissez.

Le format par défaut varie selon les SGBD. MySQL affiche les dates au format YYYY-MM-DD (par exemple 2026-07-04), tandis que SQL Server peut utiliser différents formats selon la configuration régionale du serveur. C’est précisément pour cette raison qu’il est essentiel de maîtriser les fonctions de formatage : elles vous donnent un contrôle total sur l’affichage, indépendamment de la configuration du serveur.

Quand on développe des applications web, comme je le fais au quotidien avec des frameworks JavaScript ou PHP/Symfony, on a souvent besoin de récupérer les dates directement formatées depuis la base de données. C’est plus performant que de formater côté applicatif, surtout quand on manipule de gros volumes de données.

Méthode 1 : DATE_FORMAT() sous MySQL

MySQL est le SGBD que j’utilise le plus fréquemment, notamment dans mes projets WordPress et Symfony. La fonction DATE_FORMAT() est l’outil principal pour modifier le date sql format en sortie de requête.

Syntaxe de base

La syntaxe est simple et intuitive :

SELECT DATE_FORMAT(date_column, 'format_string') FROM table_name;

Le premier argument est la colonne ou la valeur de type date. Le second est une chaîne de formatage composée de spécificateurs précédés du caractère %.

Les spécificateurs les plus utilisés

Voici ceux que j’utilise au quotidien :

• %d : jour du mois sur deux chiffres (01 à 31)
• %m : mois sur deux chiffres (01 à 12)
• %Y : année sur quatre chiffres (2026)
• %y : année sur deux chiffres (26)
• %H : heure au format 24h (00 à 23)
• %i : minutes (00 à 59)
• %s : secondes (00 à 59)
• %W : nom complet du jour (Monday, Tuesday…)
• %M : nom complet du mois (January, February…)

Exemples concrets

Pour afficher une date au format français (jj/mm/aaaa) :

SELECT DATE_FORMAT(date_commande, '%d/%m/%Y') AS date_fr
FROM commandes;

Résultat : 04/07/2026

Pour un format complet avec l’heure :

SELECT DATE_FORMAT(created_at, '%d/%m/%Y à %H:%i') AS date_complete
FROM utilisateurs;

Résultat : 04/07/2026 à 14:30

Pour extraire uniquement le mois et l’année :

SELECT DATE_FORMAT(date_publication, '%M %Y') AS mois_annee
FROM articles;

Résultat : July 2026

Le format date MySQL avec DATE_FORMAT() est particulièrement souple. On peut mélanger du texte libre avec les spécificateurs : DATE_FORMAT(ma_date, 'Publié le %d/%m/%Y') fonctionne parfaitement.

Si vous travaillez avec des différentes versions de WordPress, sachez que le CMS utilise intensivement DATE_FORMAT() dans ses requêtes internes pour afficher les dates de publication.

STR_TO_DATE() : l’opération inverse

Parfois, vous recevez une date sous forme de chaîne et devez la convertir en type DATE. C’est le rôle de STR_TO_DATE() :

SELECT STR_TO_DATE('04/07/2026', '%d/%m/%Y') AS date_convertie;

Cette fonction est indispensable lors de l’import de données depuis des fichiers CSV ou des API externes, comme lorsqu’on travaille avec l’API Shopify qui renvoie des dates au format ISO 8601.

Méthode 2 : CONVERT() et FORMAT() sous SQL Server

SQL Server propose deux approches complémentaires pour gérer le format de date : CONVERT(), la méthode historique, et FORMAT(), arrivée avec SQL Server 2012.

CONVERT() avec les codes de style

La fonction CONVERT date SQL Server utilise un système de codes numériques pour définir le format de sortie :

SELECT CONVERT(VARCHAR, date_column, style_code) FROM table_name;

Les codes de style les plus courants sont :

• 103 : format britannique/français (dd/MM/yyyy) → 04/07/2026
• 104 : format allemand (dd.MM.yyyy) → 04.07.2026
• 105 : format italien (dd-MM-yyyy) → 04-07-2026
• 112 : format ISO compact (yyyyMMdd) → 20260704
• 120 : format ODBC (yyyy-MM-dd HH:mm:ss) → 2026-07-04 14:30:00
• 126 : format ISO 8601 → 2026-07-04T14:30:00

Exemple pour obtenir le format dd/MM/yyyy :

SELECT CONVERT(VARCHAR(10), date_inscription, 103) AS date_fr
FROM clients;

La fonction CONVERT date SQL reste très performante car elle ne dépend pas des paramètres régionaux du serveur. C’est un atout majeur en production.

FORMAT() : plus lisible, moins performant

Depuis SQL Server 2012, la fonction FORMAT() offre une syntaxe inspirée du framework .NET :

SELECT FORMAT(date_commande, 'dd/MM/yyyy', 'fr-FR') AS date_fr
FROM commandes;

L’avantage est la lisibilité. Le troisième paramètre permet de spécifier la culture, ce qui traduit automatiquement les noms de jours et de mois. En revanche, FORMAT() est significativement plus lent que CONVERT() sur de gros volumes. Microsoft indique dans sa documentation officielle de FORMAT() que cette fonction repose sur le CLR .NET, ce qui explique la différence de performance.

Mon conseil : utilisez CONVERT() pour les requêtes exécutées fréquemment ou sur de gros jeux de données, et FORMAT() pour les requêtes ponctuelles où la lisibilité prime.

CAST() : la conversion simple

Pour une conversion basique sans contrôle fin du format :

SELECT CAST(date_creation AS DATE) AS date_seule
FROM projets;

CAST() est conforme au standard SQL et fonctionne sur tous les SGBD. C’est la solution à privilégier quand vous avez simplement besoin de retirer la composante horaire d’un DATETIME.

Méthode 3 : TO_CHAR() sous Oracle

Oracle Database utilise la fonction TO_CHAR() pour le formatage de date. Le format date SQL Oracle repose sur des masques de formatage expressifs et puissants.

Syntaxe de base

SELECT TO_CHAR(date_column, 'format_mask') FROM table_name;

Masques de formatage courants

• DD : jour du mois (01-31)
• MM : numéro du mois (01-12)
• MON : abréviation du mois (JAN, FEV…)
• MONTH : nom complet du mois
• YYYY : année sur 4 chiffres
• HH24 : heure au format 24h
• MI : minutes
• SS : secondes
• DAY : nom complet du jour

Exemples pratiques

Date au format français :

SELECT TO_CHAR(date_facture, 'DD/MM/YYYY') AS date_fr
FROM factures;

Date avec le nom du jour et du mois :

SELECT TO_CHAR(date_evenement, 'DAY DD MONTH YYYY', 'NLS_DATE_LANGUAGE=FRENCH') AS date_complete
FROM evenements;

Résultat : VENDREDI 04 JUILLET 2026

Le paramètre NLS_DATE_LANGUAGE permet d’obtenir les noms en français sans modifier la configuration globale de la base. C’est une fonctionnalité que j’apprécie particulièrement quand je travaille sur des projets internationaux.

TO_DATE() : l’opération inverse sous Oracle

Pour convertir une chaîne en date :

SELECT TO_DATE('04/07/2026', 'DD/MM/YYYY') AS date_convertie
FROM DUAL;

Cette symétrie entre TO_CHAR() et TO_DATE() rend le système Oracle particulièrement cohérent pour la manipulation des dates.

Tableau comparatif des syntaxes par SGBD

Pour vous aider à retrouver rapidement la bonne syntaxe selon votre SGBD, voici un tableau récapitulatif que je garde toujours sous la main.

Ce tableau couvre les formats que je rencontre le plus souvent en développement web. Le format dd/MM/yyyy est celui que mes clients francophones demandent systématiquement, tandis que le format ISO 8601 est incontournable pour les échanges entre systèmes, notamment quand on utilise des objets JavaScript côté front-end.

Les erreurs fréquentes lors du formatage de date

En plus de dix ans de développement, j’ai vu (et commis) un certain nombre d’erreurs récurrentes liées au formatage des dates. Voici celles que vous devez absolument éviter.

Confondre mm et MM

C’est l’erreur la plus classique, surtout sous SQL Server. En minuscules, mm désigne les minutes. En majuscules, MM désigne le mois. Une confusion entre les deux peut produire des résultats absurdes sans générer d’erreur, ce qui rend le bug difficile à détecter.

Formater dans le WHERE

J’observe souvent cette erreur dans les projets que je reprends :

-- MAUVAISE PRATIQUE : empêche l'utilisation des index
SELECT * FROM commandes
WHERE DATE_FORMAT(date_commande, '%Y-%m') = '2026-07';

-- BONNE PRATIQUE : préserve l'index
SELECT * FROM commandes
WHERE date_commande >= '2026-07-01'
AND date_commande < '2026-08-01';

Appliquer une fonction de formatage dans une clause WHERE empêche le moteur SQL d'utiliser les index sur la colonne date. Sur une table de plusieurs millions de lignes, la différence de performance est considérable.

Stocker les dates en VARCHAR

Stocker des dates sous forme de chaînes de caractères est une erreur de conception qui revient régulièrement. Les colonnes VARCHAR ne permettent ni les comparaisons fiables, ni les calculs de durée, ni le tri chronologique correct. Utilisez toujours les types natifs (DATE, DATETIME, TIMESTAMP) pour le stockage et réservez le formatage à l'affichage.

Ignorer les fuseaux horaires

Si votre application gère des utilisateurs dans différents fuseaux horaires, le type TIMESTAMP (qui stocke en UTC) est préférable à DATETIME (qui stocke la valeur brute). Sous MySQL, CONVERT_TZ() permet ensuite de convertir :

SELECT DATE_FORMAT(
  CONVERT_TZ(created_at, '+00:00', '+02:00'),
  '%d/%m/%Y %H:%i'
) AS date_paris
FROM logs;

Bonnes pratiques pour le format date SQL en production

Après des années à maintenir des applications en production, voici les règles que j'applique systématiquement dans mes projets.

Stocker en UTC, afficher en local

Je stocke toutes les dates en UTC dans la base de données. Le formatage et la conversion vers le fuseau horaire de l'utilisateur se font au moment de l'affichage, que ce soit en SQL ou côté applicatif. Cette approche évite les incohérences et simplifie les migrations de serveur.

Utiliser le format ISO pour les échanges

Pour les API REST, les exports de données et les échanges entre systèmes, le format ISO 8601 (yyyy-MM-ddTHH:mm:ss) est le standard. C'est le format que j'utilise systématiquement quand je développe des API, y compris pour des projets e-commerce comme ceux que l'on peut construire avec des solutions de boutique en ligne.

Formater au bon niveau

La question revient souvent : faut-il formater en SQL ou côté application ? Ma règle est simple :

• En SQL : quand la requête alimente directement un rapport, un export CSV ou une vue qui n'a pas de couche applicative
• Côté application : quand la date doit être affichée dans une interface utilisateur multilingue, avec des formats variables selon les préférences de l'utilisateur

Dans un projet React avec des formulaires, par exemple, je préfère récupérer la date au format ISO depuis la base et utiliser les fonctions Intl.DateTimeFormat de JavaScript pour le formatage côté navigateur.

Nommer ses alias de manière explicite

Quand vous formatez une date dans une requête, donnez un alias clair à la colonne résultante :

SELECT
  DATE_FORMAT(created_at, '%d/%m/%Y') AS date_creation_fr,
  DATE_FORMAT(created_at, '%Y-%m-%d') AS date_creation_iso
FROM utilisateurs;

Un alias explicite facilite la maintenance du code et la compréhension par les autres développeurs de l'équipe.

Cas pratiques : requêtes de formatage courantes

Voici des requêtes que j'utilise régulièrement et que vous pouvez adapter à vos projets.

Grouper les ventes par mois (MySQL)

SELECT
  DATE_FORMAT(date_vente, '%Y-%m') AS mois,
  COUNT(*) AS nombre_ventes,
  SUM(montant) AS total
FROM ventes
WHERE date_vente >= '2026-01-01'
GROUP BY DATE_FORMAT(date_vente, '%Y-%m')
ORDER BY mois;

Afficher l'ancienneté relative (SQL Server)

SELECT
  nom,
  CONVERT(VARCHAR(10), date_embauche, 103) AS date_embauche_fr,
  DATEDIFF(YEAR, date_embauche, GETDATE()) AS anciennete_annees
FROM employes
ORDER BY date_embauche;

Filtrer les enregistrements du jour (Oracle)

SELECT
  TO_CHAR(date_connexion, 'DD/MM/YYYY HH24:MI:SS') AS connexion_fr,
  utilisateur
FROM logs_connexion
WHERE TRUNC(date_connexion) = TRUNC(SYSDATE);

Calculer un âge à partir d'une date de naissance (MySQL)

SELECT
  nom,
  DATE_FORMAT(date_naissance, '%d/%m/%Y') AS ne_le,
  TIMESTAMPDIFF(YEAR, date_naissance, CURDATE()) AS age
FROM clients
ORDER BY age DESC;

Ces exemples illustrent comment le formatage s'intègre dans des requêtes réelles. Si vous débutez en développement web et souhaitez approfondir vos compétences techniques, je vous recommande de vous intéresser aux outils no-code en complément, pour comprendre les alternatives disponibles avant de plonger dans le SQL pur.

Pour les développeurs qui travaillent avec des environnements conteneurisés, la formation Docker est un excellent moyen de standardiser votre environnement de base de données et d'éviter les surprises liées aux configurations régionales différentes entre développement et production.