Dates et heures en SQL : maîtrisez les fonctions temporelles

La manipulation des dates est l'une des compétences les plus fréquemment testées en entretien SQL, et pourtant elle reste l'une des sources d'erreurs les plus courantes chez les candidats. Savoir extraire un mois, calculer un écart entre deux dates ou tronquer une valeur temporelle est indispensable dès qu'on travaille avec des données métier réelles : logs, transactions, inscriptions utilisateurs, événements e-commerce. Ces opérations apparaissent dans presque toutes les requêtes analytiques sérieuses.

Le problème ? Les fonctions de date varient significativement selon les moteurs SQL (PostgreSQL, MySQL, SQL Server, BigQuery). Un candidat qui ne connaît que la syntaxe d'un seul dialecte risque de bloquer face à une question formulée pour un autre environnement. Cet article vous donne les bases solides et transversales pour aborder sereinement n'importe quel exercice temporel en entretien.

Pourquoi les dates posent problème en SQL

Les dates en SQL ne sont pas de simples chaînes de caractères. Elles obéissent à des types spécifiques (DATE, TIMESTAMP, DATETIME, TIME) avec leurs propres règles de comparaison et de conversion. Une date stockée en VARCHAR se comparera alphabétiquement — et donnera des résultats faux sans lever la moindre erreur.

Un deuxième problème courant : les fuseaux horaires. En PostgreSQL, TIMESTAMP WITH TIME ZONE (alias TIMESTAMPTZ) stocke l'horodatage en UTC et le convertit selon le fuseau de la session. TIMESTAMP WITHOUT TIME ZONE n'effectue aucune conversion. Ce détail peut fausser des analyses sur des données internationales si on ne le maîtrise pas.

Enfin, les noms de fonctions changent d'un moteur à l'autre. Ce qui s'appelle GETDATE() en SQL Server s'appelle NOW() ou CURRENT_TIMESTAMP en PostgreSQL et MySQL. Comprendre la logique derrière chaque opération permet de transposer rapidement d'un dialecte à l'autre.

Les fonctions essentielles à connaître

Obtenir la date et l'heure courante

Chaque moteur expose une ou plusieurs fonctions pour récupérer l'instant présent :

-- PostgreSQL / MySQL
SELECT NOW();              -- TIMESTAMP avec timezone (PG) ou local (MySQL)
SELECT CURRENT_DATE;       -- Date seule, sans heure
SELECT CURRENT_TIMESTAMP;  -- Standard SQL, équivalent à NOW()

-- SQL Server
SELECT GETDATE();          -- DATETIME local
SELECT SYSDATETIMEOFFSET(); -- avec offset timezone

-- BigQuery
SELECT CURRENT_DATE();
SELECT CURRENT_TIMESTAMP();

En entretien, précisez toujours le moteur que vous utilisez avant d'écrire votre réponse. Cela montre une maturité technique que les recruteurs apprécient.

Extraire une composante de date avec EXTRACT

EXTRACT est la fonction standard SQL pour isoler une partie d'une date (année, mois, jour, heure, minute...) :

SELECT
  EXTRACT(YEAR  FROM order_date) AS annee,
  EXTRACT(MONTH FROM order_date) AS mois,
  EXTRACT(DOW   FROM order_date) AS jour_semaine  -- 0 = dimanche en PG
FROM orders;

En SQL Server, l'équivalent est DATEPART() :

SELECT DATEPART(YEAR, order_date) AS annee;

BigQuery utilise EXTRACT avec une syntaxe proche de PostgreSQL, ce qui facilite la transposition.

Tronquer une date avec DATE_TRUNC

DATE_TRUNC arrondit une date à la granularité souhaitée. C'est l'outil de référence pour les agrégations par semaine, mois ou trimestre :

-- PostgreSQL / BigQuery
SELECT
  DATE_TRUNC('month', order_date) AS debut_mois,
  SUM(amount) AS ca_mensuel
FROM orders
GROUP BY 1
ORDER BY 1;

En SQL Server, on simule DATE_TRUNC avec DATEADD et DATEDIFF :

SELECT DATEADD(MONTH, DATEDIFF(MONTH, 0, order_date), 0) AS debut_mois;

Calculer des intervalles avec DATEDIFF et DATEADD

Calculer le nombre de jours entre deux dates ou décaler une date d'un intervalle donné sont des opérations omniprésentes dans les exercices analytiques.

-- PostgreSQL : soustraction directe
SELECT (end_date - start_date) AS nb_jours FROM subscriptions;

-- MySQL / SQL Server
SELECT DATEDIFF(end_date, start_date) AS nb_jours FROM subscriptions;

-- Ajouter 30 jours
SELECT DATE_ADD(start_date, INTERVAL 30 DAY);   -- MySQL
SELECT start_date + INTERVAL '30 days';          -- PostgreSQL
SELECT DATEADD(DAY, 30, start_date);             -- SQL Server

Ces fonctions sont au cœur de calculs comme la durée d'abonnement, le délai de livraison ou l'âge d'un compte utilisateur — des exemples très classiques en entretien data analyst.

Tableau comparatif des fonctions temporelles par moteur

Cas pratiques pour l'entretien

Calculer l'ancienneté d'un utilisateur

Un classique : déterminer depuis combien de jours ou de mois un utilisateur est inscrit.

-- PostgreSQL
SELECT
  user_id,
  created_at,
  CURRENT_DATE - created_at::DATE AS anciennete_jours,
  EXTRACT(MONTH FROM AGE(CURRENT_DATE, created_at)) AS anciennete_mois
FROM users;

La fonction AGE() de PostgreSQL retourne un intervalle lisible. En SQL Server ou MySQL, on passera par DATEDIFF.

Identifier les commandes du mois en cours

-- Universel (adaptation syntaxique selon moteur)
SELECT *
FROM orders
WHERE DATE_TRUNC('month', order_date) = DATE_TRUNC('month', CURRENT_DATE);

Cette requête est plus robuste qu'un filtre sur EXTRACT(MONTH ...) car elle tient compte de l'année. Filtrer uniquement sur le mois sans l'année retournerait les données de tous les mois de janvier, par exemple.

Combiner dates et fonctions fenêtre

Combiner les fonctions temporelles avec les fonctions fenêtre SQL produit des analyses particulièrement puissantes. Par exemple, calculer le délai moyen entre 2 commandes consécutives pour chaque client :

SELECT
  user_id,
  order_date,
  LAG(order_date) OVER (PARTITION BY user_id ORDER BY order_date) AS commande_precedente,
  order_date - LAG(order_date) OVER (PARTITION BY user_id ORDER BY order_date) AS delai_jours
FROM orders;

Ce type de requête apparaît fréquemment dans les exercices sur la rétention utilisateur et les analyses de cohortes.

Regrouper par semaine ou trimestre

-- Par semaine (PostgreSQL)
SELECT
  DATE_TRUNC('week', event_date) AS semaine,
  COUNT(*) AS nb_evenements
FROM events
GROUP BY 1
ORDER BY 1;

-- Par trimestre
SELECT
  DATE_TRUNC('quarter', event_date) AS trimestre,
  SUM(revenue) AS ca
FROM orders
GROUP BY 1;

Ces agrégations temporelles sont fondamentales pour produire des rapports de performance. Maîtriser DATE_TRUNC vous fait gagner un temps précieux par rapport aux alternatives manuelles avec CASE WHEN.

Questions fréquentes

Conclusion

Les fonctions temporelles en SQL ne sont pas optionnelles pour un data analyst : elles structurent la quasi-totalité des analyses de performance, de cohorte ou de comportement utilisateur. Maîtriser EXTRACT, DATE_TRUNC, DATEDIFF et la gestion des intervalles vous place nettement au-dessus de la moyenne des candidats en entretien.

La priorité est de comprendre la logique derrière chaque opération plutôt que de mémoriser la syntaxe de chaque moteur. Une fois la logique assimilée, la transposition d'un dialecte à l'autre devient naturelle. Pour mettre en pratique ces concepts dans un environnement réel et vous préparer efficacement, explorez les exercices SQL interactifs disponibles sur SQL Pratique et testez vos requêtes directement en ligne.