> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentation des fonctions de manipulation des dates et des heures
# Fonctions de manipulation des dates et des heures
La plupart des fonctions de cette section acceptent un argument facultatif de fuseau horaire, par exemple `Europe/Amsterdam`. Dans ce cas, le fuseau horaire utilisé est celui qui est spécifié, au lieu du fuseau horaire local (par défaut).
**Exemple**
```sql theme={null}
SELECT
toDateTime('2016-06-15 23:00:00') AS time,
toDate(time) AS date_local,
toDate(time, 'Asia/Yekaterinburg') AS date_yekat,
toString(time, 'US/Samoa') AS time_samoa
```
```text theme={null}
┌────────────────time─┬─date_local─┬─date_yekat─┬─time_samoa──────────┐
│ 2016-06-15 23:00:00 │ 2016-06-15 │ 2016-06-16 │ 2016-06-15 09:00:00 │
└─────────────────────┴────────────┴────────────┴─────────────────────┘
```
Pour assurer la compatibilité avec la norme SQL, les fonctions suivantes, `NOW`, `CURRENT_TIMESTAMP`, `LOCALTIME`, `LOCALTIMESTAMP`, `TODAY` et `CURRENT_DATE`, peuvent être utilisées sans parenthèses.
{/*AUTOGENERATED_START*/}
## UTCTimestamp
Introduite dans : v22.11.0
Renvoyer la date et l’heure actuelles au moment de l’analyse de la requête. La fonction est une expression constante.
Cette fonction donne le même résultat que `now('UTC')`. Elle a été ajoutée uniquement pour la compatibilité avec MySQL. [`now`](#now) est l’usage recommandé.
**Syntaxe**
```sql theme={null}
UTCTimestamp()
```
**Alias** : `UTC_timestamp`
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie la date et l’heure actuelles au moment de l’analyse de la requête. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Obtenir l’horodatage UTC actuel**
```sql title=Query theme={null}
SELECT UTCTimestamp()
```
```response title=Response theme={null}
┌──────UTCTimestamp()─┐
│ 2024-05-28 08:32:09 │
└─────────────────────┘
```
## YYYYMMDDToDate
Introduite dans : v23.9.0
Convertit un nombre contenant l’année, le mois et le jour en `Date`.
Cette fonction est l’opposé de la fonction [`toYYYYMMDD()`](/fr/reference/functions/regular-functions/date-time-functions#toYYYYMMDD).
Le résultat est indéfini si l’entrée n’encode pas une valeur `Date` valide.
**Syntaxe**
```sql theme={null}
YYYYMMDDToDate(YYYYMMDD)
```
**Arguments**
* `YYYYMMDD` — Nombre contenant l'année, le mois et le jour. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
**Valeur renvoyée**
Renvoie une valeur `Date` à partir des arguments fournis [`Date`](/fr/reference/data-types/date)
**Exemples**
**Exemple**
```sql title=Query theme={null}
SELECT YYYYMMDDToDate(20230911);
```
```response title=Response theme={null}
┌─toYYYYMMDD(20230911)─┐
│ 2023-09-11 │
└──────────────────────┘
```
## YYYYMMDDToDate32
Introduit dans : v23.9.0
Convertit un nombre contenant l’année, le mois et le jour en `Date32`.
Cette fonction est l’inverse de la fonction [`toYYYYMMDD()`](/fr/reference/functions/regular-functions/date-time-functions#toYYYYMMDD).
Le résultat est indéfini si l’entrée n’encode pas une valeur `Date32` valide.
**Syntaxe**
```sql theme={null}
YYYYMMDDToDate32(YYYYMMDD)
```
**Arguments**
* `YYYYMMDD` — Nombre contenant l’année, le mois et le jour. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
**Valeur renvoyée**
Renvoie une valeur `Date32` à partir des arguments fournis [`Date32`](/fr/reference/data-types/date32)
**Exemples**
**Exemple**
```sql title=Query theme={null}
SELECT YYYYMMDDToDate32(20000507);
```
```response title=Response theme={null}
┌─YYYYMMDDToDate32(20000507)─┐
│ 2000-05-07 │
└────────────────────────────┘
```
## YYYYMMDDhhmmssToDateTime
Introduite dans : v23.9.0
Convertit un nombre contenant l’année, le mois, le jour, l’heure, les minutes et les secondes en `DateTime`.
Cette fonction est l’inverse de la fonction [`toYYYYMMDDhhmmss()`](/fr/reference/functions/regular-functions/date-time-functions#toYYYYMMDDhhmmss).
Le résultat est indéfini si l’entrée n’encode pas une valeur `DateTime` valide.
**Syntaxe**
```sql theme={null}
YYYYMMDDhhmmssToDateTime(YYYYMMDDhhmmss[, timezone])
```
**Arguments**
* `YYYYMMDDhhmmss` — Nombre contenant l’année, le mois, le jour, l’heure, les minutes et les secondes. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `timezone` — Nom du fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `DateTime` à partir des arguments fournis [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple**
```sql title=Query theme={null}
SELECT YYYYMMDDToDateTime(20230911131415);
```
```response title=Response theme={null}
┌──────YYYYMMDDhhmmssToDateTime(20230911131415)─┐
│ 2023-09-11 13:14:15 │
└───────────────────────────────────────────────┘
```
## YYYYMMDDhhmmssToDateTime64
Introduit dans : v23.9.0
Convertit un nombre contenant l’année, le mois, le jour, l’heure, la minute et la seconde en `DateTime64`.
Cette fonction est l’inverse de la fonction [`toYYYYMMDDhhmmss()`](/fr/reference/functions/regular-functions/date-time-functions#toYYYYMMDDhhmmss).
La sortie est indéfinie si l’entrée n’encode pas une valeur `DateTime64` valide.
**Syntaxe**
```sql theme={null}
YYYYMMDDhhmmssToDateTime64(YYYYMMDDhhmmss[, precision[, timezone]])
```
**Arguments**
* `YYYYMMDDhhmmss` — Nombre contenant l’année, le mois, le jour, l’heure, la minute et la seconde. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `precision` — Précision de la partie fractionnaire (0-9). [`UInt8`](/fr/reference/data-types/int-uint)
* `timezone` — Nom du fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `DateTime64` à partir des arguments fournis [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple**
```sql title=Query theme={null}
SELECT YYYYMMDDhhmmssToDateTime64(20230911131415, 3, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─YYYYMMDDhhmm⋯/Istanbul')─┐
│ 2023-09-11 13:14:15.000 │
└──────────────────────────┘
```
## addDate
Introduit dans : v23.9.0
Ajoute l’intervalle de temps à la date, à la date et heure, ou à la date ou date et heure fournie sous forme de chaîne.
Si l’addition produit une valeur hors des limites du type de données, le résultat est indéfini.
**Syntaxe**
```sql theme={null}
addDate(datetime, interval)
```
**Arguments**
* `datetime` — La date ou la date et heure à laquelle `interval` est ajouté. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `interval` — Intervalle à ajouter. [`Interval`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie la date ou la date et heure obtenue en ajoutant `interval` à `datetime`. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Ajouter un intervalle à une date**
```sql title=Query theme={null}
SELECT addDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
```
```response title=Response theme={null}
┌─addDate(toDa⋯valYear(3))─┐
│ 2021-01-01 │
└──────────────────────────┘
```
## addDays
Introduit dans : v1.1.0
Ajoute un nombre de jours spécifié à une date, à une date et heure ou à une date/date et heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
addDays(datetime, num)
```
**Arguments**
* `datetime` — Date ou date et heure à laquelle ajouter le nombre de jours spécifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de jours à ajouter. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` plus `num` jours. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Ajouter des jours à différents types de dates**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addDays(date, 5) AS add_days_with_date,
addDays(date_time, 5) AS add_days_with_date_time,
addDays(date_time_string, 5) AS add_days_with_date_time_string
```
```response title=Response theme={null}
┌─add_days_with_date─┬─add_days_with_date_time─┬─add_days_with_date_time_string─┐
│ 2024-01-06 │ 2024-01-06 00:00:00 │ 2024-01-06 00:00:00.000 │
└────────────────────┴─────────────────────────┴────────────────────────────────┘
```
**Utilisation d’une autre syntaxe INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 day)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯valDay(10))─┐
│ 1998-06-26 │
└──────────────────────────┘
```
## addHours
Introduit dans : v1.1.0
Ajoute un nombre spécifié d’heures à une date, une date et heure, ou une date ou date et heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
addHours(datetime, num)
```
**Arguments**
* `datetime` — Date ou date et heure à laquelle ajouter le nombre d’heures spécifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre d’heures à ajouter. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` plus `num` heures [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64(3)`](/fr/reference/data-types/datetime64)
**Exemples**
**Ajouter des heures à différents types de date**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addHours(date, 12) AS add_hours_with_date,
addHours(date_time, 12) AS add_hours_with_date_time,
addHours(date_time_string, 12) AS add_hours_with_date_time_string
```
```response title=Response theme={null}
┌─add_hours_with_date─┬─add_hours_with_date_time─┬─add_hours_with_date_time_string─┐
│ 2024-01-01 12:00:00 │ 2024-01-01 12:00:00 │ 2024-01-01 12:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
```
**Utilisation de la syntaxe alternative d’INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 hour)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯alHour(10))─┐
│ 1998-06-16 10:00:00 │
└──────────────────────────┘
```
## addInterval
Introduit dans : v22.11.0
Ajoute un intervalle à un autre intervalle ou à un tuple d’intervalles.
Les intervalles du même type sont combinés en un seul intervalle. Par exemple, si `toIntervalDay(1)` et `toIntervalDay(2)` sont transmis, le résultat sera `(3)` plutôt que `(1,1)`.
**Syntaxe**
```sql theme={null}
addInterval(interval_1, interval_2)
```
**Arguments**
* `interval_1` — Premier intervalle ou tuple d'intervalles. [`Interval`](/fr/reference/data-types/int-uint) ou [`Tuple(Interval)`](/fr/reference/data-types/tuple)
* `interval_2` — Deuxième intervalle à ajouter. [`Interval`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie un tuple d'intervalles [`Tuple(Interval)`](/fr/reference/data-types/tuple)
**Exemples**
**Ajouter des intervalles**
```sql title=Query theme={null}
SELECT addInterval(INTERVAL 1 DAY, INTERVAL 1 MONTH);
SELECT addInterval((INTERVAL 1 DAY, INTERVAL 1 YEAR), INTERVAL 1 MONTH);
SELECT addInterval(INTERVAL 2 DAY, INTERVAL 1 DAY)
```
```response title=Response theme={null}
┌─addInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,1) │
└───────────────────────────────────────────────────┘
┌─addInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,1) │
└────────────────────────────────────────────────────────────────────────┘
┌─addInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (3) │
└─────────────────────────────────────────────────┘
```
## addMicroseconds
Introduit dans : v22.6.0
Ajoute un nombre spécifié de microsecondes à une date et heure ou à une date et heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
addMicroseconds(datetime, num)
```
**Arguments**
* `datetime` — Date et heure auxquelles ajouter le nombre spécifié de microsecondes. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de microsecondes à ajouter. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `date_time` avec `num` microsecondes ajoutées [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Ajouter des microsecondes à différents types de date et heure**
```sql title=Query theme={null}
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addMicroseconds(date_time, 1000000) AS add_microseconds_with_date_time,
addMicroseconds(date_time_string, 1000000) AS add_microseconds_with_date_time_string
```
```response title=Response theme={null}
┌─add_microseconds_with_date_time─┬─add_microseconds_with_date_time_string─┐
│ 2024-01-01 00:00:01.000000 │ 2024-01-01 00:00:01.000000 │
└─────────────────────────────────┴────────────────────────────────────────┘
```
**Utilisation d’une syntaxe INTERVAL alternative**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 microsecond)
```
```response title=Response theme={null}
┌─plus(CAST('19⋯osecond(10))─┐
│ 1998-06-16 00:00:00.000010 │
└────────────────────────────┘
```
## addMilliseconds
Introduit dans : v22.6.0
Ajoute un nombre donné de millisecondes à une date et heure ou à une date et heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
addMilliseconds(datetime, num)
```
**Arguments**
* `datetime` — Date et heure auxquelles ajouter le nombre spécifié de millisecondes. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de millisecondes à ajouter. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` plus `num` millisecondes [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Ajouter des millisecondes à différents types de date et heure**
```sql title=Query theme={null}
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addMilliseconds(date_time, 1000) AS add_milliseconds_with_date_time,
addMilliseconds(date_time_string, 1000) AS add_milliseconds_with_date_time_string
```
```response title=Response theme={null}
┌─add_milliseconds_with_date_time─┬─add_milliseconds_with_date_time_string─┐
│ 2024-01-01 00:00:01.000 │ 2024-01-01 00:00:01.000 │
└─────────────────────────────────┴────────────────────────────────────────┘
```
**Utilisation d'une autre syntaxe INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 millisecond)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯second(10))─┐
│ 1998-06-16 00:00:00.010 │
└──────────────────────────┘
```
## addMinutes
Introduit dans : v1.1.0
Ajoute un nombre spécifié de minutes à une date, une date et heure, ou une date ou une date et heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
addMinutes(datetime, num)
```
**Arguments**
* `datetime` — Date ou date et heure à laquelle ajouter le nombre de minutes spécifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de minutes à ajouter. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` plus `num` minutes. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64(3)`](/fr/reference/data-types/datetime64)
**Exemples**
**Ajouter des minutes à différents types de dates**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addMinutes(date, 20) AS add_minutes_with_date,
addMinutes(date_time, 20) AS add_minutes_with_date_time,
addMinutes(date_time_string, 20) AS add_minutes_with_date_time_string
```
```response title=Response theme={null}
┌─add_minutes_with_date─┬─add_minutes_with_date_time─┬─add_minutes_with_date_time_string─┐
│ 2024-01-01 00:20:00 │ 2024-01-01 00:20:00 │ 2024-01-01 00:20:00.000 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘
```
**Utilisation d’une autre syntaxe INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 minute)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯Minute(10))─┐
│ 1998-06-16 00:10:00 │
└──────────────────────────┘
```
## addMonths
Introduit dans : v1.1.0
Ajoute un nombre donné de mois à une date, une date et heure ou une date ou date et heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
addMonths(datetime, num)
```
**Arguments**
* `datetime` — Date ou date et heure à laquelle ajouter le nombre de mois spécifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de mois à ajouter. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` plus `num` mois. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Ajouter des mois à différents types de date**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addMonths(date, 6) AS add_months_with_date,
addMonths(date_time, 6) AS add_months_with_date_time,
addMonths(date_time_string, 6) AS add_months_with_date_time_string
```
```response title=Response theme={null}
┌─add_months_with_date─┬─add_months_with_date_time─┬─add_months_with_date_time_string─┐
│ 2024-07-01 │ 2024-07-01 00:00:00 │ 2024-07-01 00:00:00.000 │
└──────────────────────┴───────────────────────────┴──────────────────────────────────┘
```
**Utilisation d'une autre syntaxe INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 month)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯lMonth(10))─┐
│ 1999-04-16 │
└──────────────────────────┘
```
## addNanoseconds
Introduit dans : v22.6.0
Ajoute un nombre spécifié de nanosecondes à une date et heure ou à une date et heure représentée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
addNanoseconds(datetime, num)
```
**Arguments**
* `datetime` — Date et heure auxquelles ajouter le nombre spécifié de nanosecondes. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de nanosecondes à ajouter. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` plus `num` nanosecondes [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Ajouter des nanosecondes à différents types date-heure**
```sql title=Query theme={null}
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addNanoseconds(date_time, 1000) AS add_nanoseconds_with_date_time,
addNanoseconds(date_time_string, 1000) AS add_nanoseconds_with_date_time_string
```
```response title=Response theme={null}
┌─add_nanoseconds_with_date_time─┬─add_nanoseconds_with_date_time_string─┐
│ 2024-01-01 00:00:00.000001000 │ 2024-01-01 00:00:00.000001000 │
└────────────────────────────────┴───────────────────────────────────────┘
```
**Utilisation de la syntaxe INTERVAL alternative**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 1000 nanosecond)
```
```response title=Response theme={null}
┌─plus(CAST('199⋯osecond(1000))─┐
│ 1998-06-16 00:00:00.000001000 │
└───────────────────────────────┘
```
## addQuarters
Introduit dans : v20.1.0
Ajoute un nombre spécifié de trimestres à une date, une date et heure, ou une date ou date et heure représentée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
addQuarters(datetime, num)
```
**Arguments**
* `datetime` — Date ou date et heure à laquelle ajouter le nombre de trimestres spécifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de trimestres à ajouter. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` plus `num` trimestres [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Ajouter des trimestres à différents types de dates**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addQuarters(date, 1) AS add_quarters_with_date,
addQuarters(date_time, 1) AS add_quarters_with_date_time,
addQuarters(date_time_string, 1) AS add_quarters_with_date_time_string
```
```response title=Response theme={null}
┌─add_quarters_with_date─┬─add_quarters_with_date_time─┬─add_quarters_with_date_time_string─┐
│ 2024-04-01 │ 2024-04-01 00:00:00 │ 2024-04-01 00:00:00.000 │
└────────────────────────┴─────────────────────────────┴────────────────────────────────────┘
```
**Utilisation de la syntaxe INTERVAL alternative**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 quarter)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯uarter(10))─┐
│ 2000-12-16 │
└──────────────────────────┘
```
## addSeconds
Introduit dans : v1.1.0
Ajoute un nombre spécifié de secondes à une date, une date et heure, ou une date/une date et heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
addSeconds(datetime, num)
```
**Arguments**
* `datetime` — Date ou date et heure à laquelle ajouter le nombre de secondes spécifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de secondes à ajouter. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` plus `num` secondes [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64(3)`](/fr/reference/data-types/datetime64)
**Exemples**
**Ajouter des secondes à différents types de date**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addSeconds(date, 30) AS add_seconds_with_date,
addSeconds(date_time, 30) AS add_seconds_with_date_time,
addSeconds(date_time_string, 30) AS add_seconds_with_date_time_string
```
```response title=Response theme={null}
┌─add_seconds_with_date─┬─add_seconds_with_date_time─┬─add_seconds_with_date_time_string─┐
│ 2024-01-01 00:00:30 │ 2024-01-01 00:00:30 │ 2024-01-01 00:00:30.000 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘
```
**Utilisation d’une autre syntaxe INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 second)
```
```response title=Response theme={null}
┌─dateAdd('1998-06-16'::Date, INTERVAL 10 second)─┐
│ 1998-06-16 00:00:10 │
└─────────────────────────────────────────────────┘
```
## addTupleOfIntervals
Introduit dans : v22.11.0
Ajoute consécutivement un tuple d’intervalles à une date ou à une date avec heure.
**Syntaxe**
```sql theme={null}
addTupleOfIntervals(datetime, intervals)
```
**Arguments**
* `datetime` — Date ou date avec heure à laquelle ajouter les intervalles. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `intervals` — Tuple d'intervalles à ajouter à `datetime`. [`Tuple(Interval)`](/fr/reference/data-types/tuple)
**Valeur renvoyée**
Renvoie `date` après ajout des `intervals` [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Ajouter un tuple d'intervalles à une date**
```sql title=Query theme={null}
WITH toDate('2018-01-01') AS date
SELECT addTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 MONTH, INTERVAL 1 YEAR))
```
```response title=Response theme={null}
┌─addTupleOfIntervals(date, (toIntervalDay(1), toIntervalMonth(1), toIntervalYear(1)))─┐
│ 2019-02-02 │
└──────────────────────────────────────────────────────────────────────────────────────┘
```
## addWeeks
Introduit dans : v1.1.0
Ajoute un nombre donné de semaines à une date, une date avec heure ou une date ou date avec heure représentée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
addWeeks(datetime, num)
```
**Arguments**
* `datetime` — Date ou date avec heure à laquelle ajouter le nombre de semaines indiqué. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de semaines à ajouter. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` plus `num` semaines. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Ajouter des semaines à différents types de dates**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addWeeks(date, 5) AS add_weeks_with_date,
addWeeks(date_time, 5) AS add_weeks_with_date_time,
addWeeks(date_time_string, 5) AS add_weeks_with_date_time_string
```
```response title=Response theme={null}
┌─add_weeks_with_date─┬─add_weeks_with_date_time─┬─add_weeks_with_date_time_string─┐
│ 2024-02-05 │ 2024-02-05 00:00:00 │ 2024-02-05 00:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
```
**Utilisation de la syntaxe INTERVAL alternative**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 week)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯alWeek(10))─┐
│ 1998-08-25 │
└──────────────────────────┘
```
## addYears
Introduit dans : v1.1.0
Ajoute un nombre d’années spécifié à une date, une date avec heure ou une date ou date avec heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
addYears(datetime, num)
```
**Arguments**
* `datetime` — Date ou date avec heure à laquelle ajouter le nombre d’années spécifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre d’années à ajouter. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` plus `num` ans. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Ajouter des années à différents types de dates**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addYears(date, 1) AS add_years_with_date,
addYears(date_time, 1) AS add_years_with_date_time,
addYears(date_time_string, 1) AS add_years_with_date_time_string
```
```response title=Response theme={null}
┌─add_years_with_date─┬─add_years_with_date_time─┬─add_years_with_date_time_string─┐
│ 2025-01-01 │ 2025-01-01 00:00:00 │ 2025-01-01 00:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
```
**Utilisation d'une autre syntaxe INTERVAL**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 year)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯alYear(10))─┐
│ 2008-06-16 │
└──────────────────────────┘
```
## age
Introduit dans : v23.1.0
Renvoyer le composant d’unité de la différence entre `startdate` et `enddate`.
La différence est calculée avec une précision de 1 nanoseconde.
Par exemple, la différence entre 2021-12-29 et 2022-01-01 est de 3 jours pour l’unité jour,
de 0 mois pour l’unité mois et de 0 an pour l’unité année.
Pour une alternative à age, voir la fonction [`dateDiff`](#dateDiff).
**Syntaxe**
```sql theme={null}
age('unit', startdate, enddate[, timezone])
```
**Arguments**
* `unit` — Le type d’intervalle du résultat.
| Unité | Valeurs possibles |
| ----------- | ---------------------------------------- |
| nanosecond | `nanosecond`, `nanoseconds`, `ns` |
| microsecond | `microsecond`, `microseconds`, `us`, `u` |
| millisecond | `millisecond`, `milliseconds`, `ms` |
| second | `second`, `seconds`, `ss`, `s` |
| minute | `minute`, `minutes`, `mi`, `n` |
| hour | `hour`, `hours`, `hh`, `h` |
| day | `day`, `days`, `dd`, `d` |
| week | `week`, `weeks`, `wk`, `ww` |
| month | `month`, `months`, `mm`, `m` |
| quarter | `quarter`, `quarters`, `qq`, `q` |
| year | `year`, `years`, `yyyy`, `yy` |
* `startdate` — Première valeur temporelle à soustraire (le terme soustrait). [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `enddate` — Deuxième valeur temporelle à partir de laquelle soustraire (le terme duquel on soustrait). [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Nom du fuseau horaire. S’il est spécifié, il s’applique à `startdate` et à `enddate`. S’il n’est pas spécifié, les fuseaux horaires de `startdate` et `enddate` sont utilisés. S’ils ne sont pas identiques, le résultat n’est pas défini. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
La différence entre `enddate` et `startdate`, exprimée en `unit`. [`Int32`](/fr/reference/data-types/int-uint)
**Exemples**
**Calcul de l’âge en heures**
```sql title=Query theme={null}
SELECT age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))
```
```response title=Response theme={null}
┌─age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))─┐
│ 24 │
└───────────────────────────────────────────────────────────────────────────────────┘
```
**Calculer l’âge dans différentes unités**
```sql title=Query theme={null}
SELECT
toDate('2022-01-01') AS e,
toDate('2021-12-29') AS s,
age('day', s, e) AS day_age,
age('month', s, e) AS month_age,
age('year', s, e) AS year_age
```
```response title=Response theme={null}
┌──────────e─┬──────────s─┬─day_age─┬─month_age─┬─year_age─┐
│ 2022-01-01 │ 2021-12-29 │ 3 │ 0 │ 0 │
└────────────┴────────────┴─────────┴───────────┴──────────┘
```
## changeDay
Introduit dans : v24.7.0
Modifie le composant « jour » d’une date ou d’une date/heure.
**Syntaxe**
```sql theme={null}
changeDay(date_or_datetime, value)
```
**Arguments**
* `date_or_datetime` — La valeur à modifier. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `value` — La nouvelle valeur. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur du même type que `date_or_datetime` dont la composante de jour a été modifiée. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT changeDay('2024-01-31'::DateTime, 15)
```
```response title=Response theme={null}
2024-01-15 00:00:00
```
## changeHour
Introduit dans : v24.7.0
Modifie la composante heure d’une date ou d’une date/heure.
**Syntaxe**
```sql theme={null}
changeHour(date_or_datetime, value)
```
**Arguments**
* `date_or_datetime` — La valeur à modifier. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `value` — La nouvelle valeur. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur du même type que `date_or_datetime`, avec la composante heure modifiée. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT changeHour('2024-01-01 12:00:00'::DateTime, 5)
```
```response title=Response theme={null}
2024-01-01 05:00:00
```
## changeMinute
Introduit dans : v24.7.0
Modifie la composante minute d’une `date ou date/heure`.
**Syntaxe**
```sql theme={null}
changeMinute(date_or_datetime, value)
```
**Arguments**
* `date_or_datetime` — Valeur à modifier. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `value` — Nouvelle valeur. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur du même type que `date_or_datetime`, dont la composante minute est modifiée. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT changeMinute('2024-01-01 12:30:00'::DateTime, 45)
```
```response title=Response theme={null}
2024-01-01 12:45:00
```
## changeMonth
Introduit dans : v24.7.0
Modifie le mois d'une date ou d'une date-heure.
**Syntaxe**
```sql theme={null}
changeMonth(date_or_datetime, value)
```
**Arguments**
* `date_or_datetime` — Valeur à modifier. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `value` — Nouvelle valeur. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur du même type que `date_or_datetime` dont le mois a été modifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT changeMonth('2024-01-01'::DateTime, 12)
```
```response title=Response theme={null}
2024-12-01 00:00:00
```
## changeSecond
Introduit dans : v24.7.0
Modifie la composante seconde d'une date ou d'une date/heure.
**Syntaxe**
```sql theme={null}
changeSecond(date_or_datetime, value)
```
**Arguments**
* `date_or_datetime` — La valeur à modifier. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `value` — La nouvelle valeur. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur du même type que `date_or_datetime` dont la composante des secondes est modifiée. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT changeSecond('2024-01-01 12:30:45'::DateTime, 15)
```
```response title=Response theme={null}
2024-01-01 12:30:15
```
## changeYear
Introduit dans : v24.7.0
Modifie l’année d’une date ou d’une date/heure.
**Syntaxe**
```sql theme={null}
changeYear(date_or_datetime, value)
```
**Arguments**
* `date_or_datetime` — La valeur à modifier. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `value` — La nouvelle valeur. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une valeur du même type que `date_or_datetime` dont la composante année a été modifiée. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT changeYear('2024-01-01'::DateTime, 2023)
```
```response title=Response theme={null}
2023-01-01 00:00:00
```
## dateDiff
Introduit dans : v23.4.0
Renvoyer le nombre de limites de `unit` spécifié franchies entre `startdate` et `enddate`.
La différence est calculée à l’aide d’unités relatives. Par exemple, la différence entre 2021-12-29 et 2022-01-01 est de 3 jours pour l’unité day
(voir [`toRelativeDayNum`](#toRelativeDayNum)), de 1 mois pour l’unité month (voir [`toRelativeMonthNum`](#toRelativeMonthNum)) et de 1 an pour l’unité year
(voir [`toRelativeYearNum`](#toRelativeYearNum)).
Si l’unité `week` est spécifiée, `dateDiff` considère que les semaines commencent le lundi.
Notez que ce comportement diffère de celui de la fonction `toWeek()`, dans laquelle les semaines commencent par défaut le dimanche.
Pour une alternative à `dateDiff`, voir la fonction [`age`](#age).
**Syntaxe**
```sql theme={null}
dateDiff(unit, startdate, enddate[, timezone])
```
**Alias** : `timestampDiff`, `TIMESTAMP_DIFF`, `DATE_DIFF`, `date_diff`, `timestamp_diff`
**Arguments**
* `unit` — Le type d’intervalle du résultat.
| Unité | Valeurs possibles |
| ----------- | ---------------------------------------- |
| nanosecond | `nanosecond`, `nanoseconds`, `ns` |
| microsecond | `microsecond`, `microseconds`, `us`, `u` |
| millisecond | `millisecond`, `milliseconds`, `ms` |
| second | `second`, `seconds`, `ss`, `s` |
| minute | `minute`, `minutes`, `mi`, `n` |
| hour | `hour`, `hours`, `hh`, `h` |
| day | `day`, `days`, `dd`, `d` |
| week | `week`, `weeks`, `wk`, `ww` |
| month | `month`, `months`, `mm`, `m` |
| quarter | `quarter`, `quarters`, `qq`, `q` |
| year | `year`, `years`, `yyyy`, `yy` |
* `startdate` — La première valeur temporelle à soustraire (le terme soustrait). [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `enddate` — La seconde valeur temporelle, de laquelle la première est soustraite (le terme diminué). [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Nom du fuseau horaire. S’il est spécifié, il s’applique à la fois à `startdate` et à `enddate`. S’il n’est pas spécifié, les fuseaux horaires de `startdate` et `enddate` sont utilisés. S’ils ne sont pas identiques, le résultat n’est pas spécifié. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la différence entre `enddate` et `startdate`, exprimée en `unit`. [`Int64`](/fr/reference/data-types/int-uint)
**Exemples**
**Calculer la différence entre deux dates en heures**
```sql title=Query theme={null}
SELECT dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res
```
```response title=Response theme={null}
┌─res─┐
│ 25 │
└─────┘
```
**Calculer l’écart entre deux dates dans différentes unités**
```sql title=Query theme={null}
SELECT
toDate('2022-01-01') AS e,
toDate('2021-12-29') AS s,
dateDiff('day', s, e) AS day_diff,
dateDiff('month', s, e) AS month_diff,
dateDiff('year', s, e) AS year_diff
```
```response title=Response theme={null}
┌──────────e─┬──────────s─┬─day_diff─┬─month_diff─┬─year_diff─┐
│ 2022-01-01 │ 2021-12-29 │ 3 │ 1 │ 1 │
└────────────┴────────────┴──────────┴────────────┴───────────┘
```
## dateName
Introduit dans : v21.7.0
Renvoie la partie spécifiée de la date.
Valeurs possibles :
* 'year'
* 'quarter'
* 'month'
* 'week'
* 'dayofyear'
* 'day'
* 'weekday'
* 'hour'
* 'minute'
* 'second'
**Syntaxe**
```sql theme={null}
dateName(date_part, date[, timezone])
```
**Arguments**
* `date_part` — La partie de la date que vous souhaitez extraire. [`String`](/fr/reference/data-types/string)
* `datetime` — Une valeur de date ou de date avec heure. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la partie spécifiée de la date. [`String`](/fr/reference/data-types/string)
**Exemples**
**Extraire différentes parties de la date**
```sql title=Query theme={null}
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT
dateName('year', date_value),
dateName('month', date_value),
dateName('day', date_value)
```
```response title=Response theme={null}
┌─dateName('year', date_value)─┬─dateName('month', date_value)─┬─dateName('day', date_value)─┐
│ 2021 │ April │ 14 │
└──────────────────────────────┴───────────────────────────────┴─────────────────────────────┘
```
## dateTrunc
Introduit dans : v20.8.0
Tronque une valeur de date et d’heure à la composante de date spécifiée.
**Syntaxe**
```sql theme={null}
dateTrunc(unit, datetime[, timezone])
```
**Alias** : `DATE_TRUNC`
**Arguments**
* `unit` —
Le type d’intervalle utilisé pour tronquer le résultat. Valeurs possibles : `nanosecond` (DateTime64 uniquement), `microsecond` (DateTime64 uniquement), `millisecond` (DateTime64 uniquement), `second`, `minute`, `hour`, `day`, `week`, `month`, `quarter`, `year`.
[`String`](/fr/reference/data-types/string)
* `datetime` — Date et heure. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Nom du fuseau horaire de la date et de l’heure renvoyées. S’il n’est pas spécifié, la fonction utilise le fuseau horaire du paramètre `datetime`. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la valeur de date et d’heure tronquée.
| Argument `unit` | Argument `datetime` | Type de retour |
| -------------------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------ |
| Year, Quarter, Month, Week | `Date32` ou `DateTime64` ou `Date` ou `DateTime` | [`Date32`](/fr/reference/data-types/date32) ou [`Date`](/fr/reference/data-types/date) |
| Day, Hour, Minute, Second | `Date32`, `DateTime64`, `Date` ou `DateTime` | [`DateTime64`](/fr/reference/data-types/datetime64) ou [`DateTime`](/fr/reference/data-types/datetime) |
| Millisecond, Microsecond, | N’importe lequel | [`DateTime64`](/fr/reference/data-types/datetime64) |
| Nanosecond | | avec une échelle de 3, 6 ou 9 |
**Exemples**
**Tronquer sans fuseau horaire**
```sql title=Query theme={null}
SELECT now(), dateTrunc('hour', now());
```
```response title=Response theme={null}
┌───────────────now()─┬─dateTrunc('hour', now())──┐
│ 2020-09-28 10:40:45 │ 2020-09-28 10:00:00 │
└─────────────────────┴───────────────────────────┘
```
**Tronquer selon le fuseau horaire spécifié**
```sql title=Query theme={null}
SELECT now(), dateTrunc('hour', now(), 'Asia/Istanbul');
```
```response title=Response theme={null}
┌───────────────now()─┬─dateTrunc('hour', now(), 'Asia/Istanbul')──┐
│ 2020-09-28 10:46:26 │ 2020-09-28 13:00:00 │
└─────────────────────┴────────────────────────────────────────────┘
```
## formatDateTime
Introduit dans : v1.1.0
Formate une date ou une date avec heure selon la chaîne de format spécifiée. `format` est une expression constante ; vous ne pouvez donc pas utiliser plusieurs formats pour une seule colonne de résultat.
`formatDateTime` utilise le style de format de date et d'heure de MySQL. Consultez la [documentation MySQL](https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_date-format).
L'opération inverse de cette fonction est [`parseDateTime`](/fr/reference/functions/regular-functions/type-conversion-functions#parseDateTime).
À l'aide de champs de remplacement, vous pouvez définir un motif pour la chaîne résultante.
La colonne d'exemple du tableau ci-dessous montre le résultat du formatage pour `2018-01-02 22:33:44`.
**Champs de remplacement :**
| Espace réservé | Description | Exemple |
| -------------- | ----------------------------------------------------------------------- | ---------- |
| %a | nom abrégé du jour de la semaine (Mon-Sun) | Mon |
| %b | nom abrégé du mois (Jan-Dec) | Jan |
| %c | mois sous forme de nombre entier (01-12) | 01 |
| %C | année divisée par 100 et tronquée en entier (00-99) | 20 |
| %d | jour du mois, complété par des zéros (01-31) | 02 |
| %D | date courte MM/DD/YY, équivalente à %m/%d/%y | 01/02/18 |
| %e | jour du mois, complété par des espaces (1-31) | 2 |
| %f | fraction de seconde | 123456 |
| %F | date courte YYYY-MM-DD, équivalente à %Y-%m-%d | 2018-01-02 |
| %g | année sur deux chiffres, conforme à ISO 8601 | 18 |
| %G | année sur quatre chiffres pour le numéro de semaine ISO | 2018 |
| %h | heure au format 12 h (01-12) | 09 |
| %H | heure au format 24 h (00-23) | 22 |
| %i | minute (00-59) | 33 |
| %I | heure au format 12 h (01-12) | 10 |
| %j | jour de l'année (001-366) | 002 |
| %k | heure au format 24 h (00-23) | 14 |
| %l | heure au format 12 h (01-12) | 09 |
| %m | mois sous forme de nombre entier (01-12) | 01 |
| %M | nom complet du mois (January-December) | January |
| %n | caractère de nouvelle ligne | |
| %p | indicateur AM ou PM | PM |
| %Q | trimestre (1-4) | 1 |
| %r | heure HH:MM AM/PM au format 12 h, équivalente à %h:%i %p | 10:30 PM |
| %R | heure HH:MM au format 24 h, équivalente à %H:%i | 22:33 |
| %s | seconde (00-59) | 44 |
| %S | seconde (00-59) | 44 |
| %t | caractère de tabulation horizontale | |
| %T | format d'heure ISO 8601 (HH:MM:SS), équivalent à %H:%i:%S | 22:33:44 |
| %u | jour de la semaine ISO 8601 sous forme de nombre, avec lundi = 1 (1-7) | 2 |
| %V | numéro de semaine ISO 8601 (01-53) | 01 |
| %w | jour de la semaine sous forme de nombre entier, avec dimanche = 0 (0-6) | 2 |
| %W | nom complet du jour de la semaine (Monday-Sunday) | Monday |
| %y | année, deux derniers chiffres (00-99) | 18 |
| %Y | année | 2018 |
| %z | décalage horaire par rapport à l'UTC sous la forme +HHMM ou -HHMM | -0500 |
| %% | signe % | % |
* Dans les versions de ClickHouse antérieures à v23.4, `%f` affiche un seul zéro (0) si la valeur formatée est de type Date, Date32 ou DateTime (qui n'ont pas de fractions de seconde), ou de type DateTime64 avec une précision de 0.
* Dans les versions de ClickHouse antérieures à v25.1, `%f` affiche autant de chiffres que l'échelle du DateTime64 l'indique, au lieu de 6 chiffres fixes.
* Dans les versions de ClickHouse antérieures à v23.4, `%M` affiche la minute (00-59) au lieu du nom complet du mois (January-December).
**Syntaxe**
```sql theme={null}
formatDateTime(datetime, format[, timezone])
```
**Alias** : `DATE_FORMAT`
**Arguments**
* `datetime` — Une date ou une date et heure à formater. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `format` — Chaîne de format avec des champs de remplacement. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Nom du fuseau horaire pour l’heure formatée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie des valeurs de date et d’heure selon le format spécifié. [`String`](/fr/reference/data-types/string)
**Exemples**
**Formater une date avec le champ de remplacement de l’année**
```sql title=Query theme={null}
SELECT formatDateTime(toDate('2010-01-04'), '%g')
```
```response title=Response theme={null}
┌─formatDateTime(toDate('2010-01-04'), '%g')─┐
│ 10 │
└────────────────────────────────────────────┘
```
**Formater DateTime64 avec des fractions de seconde**
```sql title=Query theme={null}
SELECT formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')
```
```response title=Response theme={null}
┌─formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')─┐
│ 1234560 │
└─────────────────────────────────────────────────────────────────────┘
```
**Formatage avec fuseau horaire**
```sql title=Query theme={null}
SELECT
now() AS ts,
time_zone,
formatDateTime(ts, '%T', time_zone) AS str_tz_time
FROM system.time_zones
WHERE time_zone LIKE 'Europe%'
LIMIT 10
```
```response title=Response theme={null}
┌──────────────────ts─┬─time_zone─────────┬─str_tz_time─┐
│ 2023-09-08 19:13:40 │ Europe/Amsterdam │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Andorra │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Astrakhan │ 23:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Athens │ 22:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Belfast │ 20:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Belgrade │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Berlin │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Bratislava │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Brussels │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Bucharest │ 22:13:40 │
└─────────────────────┴───────────────────┴─────────────┘
```
## formatDateTimeInJodaSyntax
Introduit dans : v20.1.0
Semblable à `formatDateTime`, sauf qu'il met en forme les valeurs datetime au format Joda plutôt qu'au format MySQL. Consultez la [documentation Joda Time](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html).
L'opération inverse de cette fonction est [`parseDateTimeInJodaSyntax`](/fr/reference/functions/regular-functions/type-conversion-functions#parseDateTimeInJodaSyntax).
À l'aide de champs de remplacement, vous pouvez définir un modèle pour la chaîne résultante.
**Champs de remplacement :**
| Espace réservé | Description | Présentation | Exemples |
| -------------- | ---------------------------------------------------------- | ------------ | -------------------------- |
| G | ère | texte | AD |
| C | siècle de l'ère (>=0) | nombre | 20 |
| Y | année de l'ère (>=0) | année | 1996 |
| x | année de semaine (pas encore prise en charge) | année | 1996 |
| w | semaine de l'année de semaine (pas encore prise en charge) | nombre | 27 |
| e | jour de la semaine | nombre | 2 |
| E | jour de la semaine | texte | Tuesday; Tue |
| y | année | année | 1996 |
| D | jour de l'année | nombre | 189 |
| M | mois de l'année | mois | July; Jul; 07 |
| d | jour du mois | nombre | 10 |
| a | moitié de journée | texte | PM |
| K | heure de la moitié de journée (0\~11) | nombre | 0 |
| h | heure sur 12 heures (1\~12) | nombre | 12 |
| H | heure du jour (0\~23) | nombre | 0 |
| k | heure sur 24 heures (1\~24) | nombre | 24 |
| m | minute de l'heure | nombre | 30 |
| s | seconde de la minute | nombre | 55 |
| S | fraction de seconde | nombre | 978 |
| z | fuseau horaire | texte | Eastern Standard Time; EST |
| Z | décalage du fuseau horaire | zone | -0800; -0812 |
| ' | caractère d'échappement pour le texte | délimiteur | |
| '' | apostrophe | littéral | ' |
**Syntaxe**
```sql theme={null}
formatDateTimeInJodaSyntax(datetime, format[, timezone])
```
**Arguments**
* `datetime` — Une date ou une date et une heure à formater. [`DateTime`](/fr/reference/data-types/datetime) ou [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `format` — Chaîne de format avec des champs de remplacement de style Joda. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Nom du fuseau horaire pour la date et l'heure formatées. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de date et d'heure selon le format déterminé. [`String`](/fr/reference/data-types/string)
**Exemples**
**Formater une date et une heure avec la syntaxe Joda**
```sql title=Query theme={null}
SELECT formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')
```
```response title=Response theme={null}
┌─formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')─┐
│ 2010-01-04 12:34:56 │
└─────────────────────────────────────────────────────────────────────────────────────────┘
```
## fromDaysSinceYearZero
Introduit dans : v23.11.0
Pour un nombre donné de jours écoulés depuis le [1er janvier 0000](https://en.wikipedia.org/wiki/Year_zero), renvoie la date correspondante dans le [calendrier grégorien proleptique défini par l’ISO 8601](https://en.wikipedia.org/wiki/Gregorian_calendar#Proleptic_Gregorian_calendar).
Le calcul est identique à celui de la fonction MySQL `FROM_DAYS()`. Le résultat est indéfini s’il ne peut pas être représenté dans les limites du type [Date](/fr/reference/data-types/date).
**Syntaxe**
```sql theme={null}
fromDaysSinceYearZero(days)
```
**Alias** : `FROM_DAYS`
**Arguments**
* `days` — Le nombre de jours écoulés depuis l’année zéro. [`UInt32`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie la date correspondant au nombre de jours écoulés depuis l’année zéro. [`Date`](/fr/reference/data-types/date)
**Exemples**
**Convertir le nombre de jours écoulés depuis l’année zéro en dates**
```sql title=Query theme={null}
SELECT
fromDaysSinceYearZero(739136) AS date1,
fromDaysSinceYearZero(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
```
```response title=Response theme={null}
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
```
## fromDaysSinceYearZero32
Introduit dans : v23.11.0
Pour un nombre donné de jours écoulés depuis le [1er janvier 0000](https://en.wikipedia.org/wiki/Year_zero), renvoie la date correspondante dans le [calendrier grégorien proleptique défini par l’ISO 8601](https://en.wikipedia.org/wiki/Gregorian_calendar#Proleptic_Gregorian_calendar).
Le calcul est identique à celui de la fonction `FROM_DAYS()` de MySQL. Le résultat est indéfini s’il ne peut pas être représenté dans les limites du type [`Date32`](/fr/reference/data-types/date32).
**Syntaxe**
```sql theme={null}
fromDaysSinceYearZero32(days)
```
**Arguments**
* `days` — Le nombre de jours écoulés depuis l’année zéro. [`UInt32`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie la date correspondant au nombre de jours écoulés depuis l’année zéro. [`Date32`](/fr/reference/data-types/date32)
**Exemples**
**Convertir les jours écoulés depuis l’année zéro en dates**
```sql title=Query theme={null}
SELECT
fromDaysSinceYearZero32(739136) AS date1,
fromDaysSinceYearZero32(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
```
```response title=Response theme={null}
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
```
## fromModifiedJulianDay
Introduit dans : v21.1.0
Convertit un nombre de [jour julien modifié](https://en.wikipedia.org/wiki/Julian_day#Variants) en une date du [calendrier grégorien proleptique](https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar) au format texte `YYYY-MM-DD`. Cette fonction prend en charge les numéros de jour compris entre `-678941` et `2973483` (qui représentent respectivement 0000-01-01 et 9999-12-31). Elle génère une exception si le numéro de jour se situe hors de la plage prise en charge.
**Syntaxe**
```sql theme={null}
fromModifiedJulianDay(day)
```
**Arguments**
* `day` — numéro de jour julien modifié. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie la date sous forme de texte. [`String`](/fr/reference/data-types/string)
**Exemples**
**Convertir un jour julien modifié en date**
```sql title=Query theme={null}
SELECT fromModifiedJulianDay(58849)
```
```response title=Response theme={null}
┌─fromModifiedJulianDay(58849)─┐
│ 2020-01-01 │
└──────────────────────────────┘
```
## fromModifiedJulianDayOrNull
Introduite dans : v21.1.0
Semblable à [`fromModifiedJulianDay()`](#fromModifiedJulianDay), mais au lieu de générer une exception, cette fonction renvoie `NULL`.
**Syntaxe**
```sql theme={null}
fromModifiedJulianDayOrNull(day)
```
**Arguments**
* `day` — numéro de jour julien modifié. [`(U)Int*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie la date sous forme textuelle pour un argument `day` valide, sinon `null`. [`Nullable(String)`](/fr/reference/data-types/nullable)
**Exemples**
**Convertir le jour julien modifié en date avec gestion des valeurs nulles**
```sql title=Query theme={null}
SELECT fromModifiedJulianDayOrNull(58849);
SELECT fromModifiedJulianDayOrNull(60000000); -- invalid argument, returns NULL
```
```response title=Response theme={null}
┌─fromModified⋯Null(58849)─┐
│ 2020-01-01 │
└──────────────────────────┘
┌─fromModified⋯l(60000000)─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
```
## fromUTCTimestamp
Introduit dans : v22.1.0
Convertit une valeur de date ou de date avec heure du fuseau horaire UTC en une valeur de date ou de date avec heure dans le fuseau horaire spécifié. Cette fonction est principalement incluse pour des raisons de compatibilité avec Apache Spark et des frameworks similaires.
**Syntaxe**
```sql theme={null}
fromUTCTimestamp(datetime, time_zone)
```
**Alias** : `from_utc_timestamp`
**Arguments**
* `datetime` — Une valeur constante de type date ou date avec heure, ou une expression. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `time_zone` — Une valeur constante de type String ou une expression représentant le fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un DateTime/DateTime64 dans le fuseau horaire spécifié. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Convertir du fuseau horaire UTC vers le fuseau horaire spécifié**
```sql title=Query theme={null}
SELECT fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00', 3), 'Asia/Shanghai')
```
```response title=Response theme={null}
┌─fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00',3), 'Asia/Shanghai')─┐
│ 2023-03-16 18:00:00.000 │
└─────────────────────────────────────────────────────────────────────────┘
```
## fromUnixTimestamp
Introduit dans : v20.8.0
Cette fonction convertit un horodatage Unix en date calendaire et en heure de la journée.
Elle peut être appelée de deux façons :
* Lorsqu’on lui passe un seul argument de type [`Integer`](/fr/reference/data-types/int-uint), elle renvoie une valeur de type [`DateTime`](/fr/reference/data-types/datetime), c’est-à-dire qu’elle se comporte comme [`toDateTime`](/fr/reference/functions/regular-functions/type-conversion-functions#toDateTime).
* Lorsqu’on lui passe deux ou trois arguments, où le premier est une valeur de type [`Integer`](/fr/reference/data-types/int-uint), [`Date`](/fr/reference/data-types/date), [`Date32`](/fr/reference/data-types/date32), [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64), le deuxième une chaîne de format constante et le troisième une chaîne constante facultative de fuseau horaire, la fonction renvoie une valeur de type [`String`](/fr/reference/data-types/string), c’est-à-dire qu’elle se comporte comme [`formatDateTime`](#formatDateTime).
Dans ce cas, [le style de format datetime de MySQL](https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_date-format) est utilisé.
**Syntaxe**
```sql theme={null}
fromUnixTimestamp(timestamp)
fromUnixTimestamp(timestamp[, format[, timezone]])
```
**Alias** : `FROM_UNIXTIME`
**Arguments**
* `timestamp` — Horodatage Unix ou valeur de date/date avec heure. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `format` — Facultatif. Chaîne de format constante pour le formatage de sortie. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Chaîne constante de fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un `DateTime` correspondant à l’horodatage lorsqu’elle est appelée avec un argument, ou une `String` lorsqu’elle est appelée avec deux ou trois arguments. [`DateTime`](/fr/reference/data-types/datetime) ou [`String`](/fr/reference/data-types/string)
**Exemples**
**Convertir un horodatage Unix en DateTime**
```sql title=Query theme={null}
SELECT fromUnixTimestamp(423543535)
```
```response title=Response theme={null}
┌─fromUnixTimestamp(423543535)─┐
│ 1983-06-04 10:58:55 │
└──────────────────────────────┘
```
**Convertir un horodatage Unix selon un format**
```sql title=Query theme={null}
SELECT fromUnixTimestamp(1234334543, '%Y-%m-%d %R:%S') AS DateTime
```
```response title=Response theme={null}
┌─DateTime────────────┐
│ 2009-02-11 14:42:23 │
└─────────────────────┘
```
## fromUnixTimestampInJodaSyntax
Introduit dans : v23.1.0
Cette fonction convertit un horodatage Unix en une date calendaire et une heure de la journée.
Elle peut être appelée de deux façons :
Lorsqu’un seul argument de type [`Integer`](/fr/reference/data-types/int-uint) est fourni, elle renvoie une valeur de type [`DateTime`](/fr/reference/data-types/datetime), c’est-à-dire qu’elle se comporte comme [`toDateTime`](/fr/reference/functions/regular-functions/type-conversion-functions#toDateTime).
Lorsque deux ou trois arguments sont fournis, le premier argument étant une valeur de type [`Integer`](/fr/reference/data-types/int-uint), [`Date`](/fr/reference/data-types/date), [`Date32`](/fr/reference/data-types/date32), [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64), le deuxième argument une chaîne de format constante et le troisième une chaîne constante facultative indiquant le fuseau horaire, la fonction renvoie une valeur de type [`String`](/fr/reference/data-types/string), c’est-à-dire qu’elle se comporte comme [`formatDateTimeInJodaSyntax`](#formatDateTimeInJodaSyntax). Dans ce cas, le [style de format date-heure de Joda](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html) est utilisé.
**Syntaxe**
```sql theme={null}
fromUnixTimestampInJodaSyntax(timestamp)
fromUnixTimestampInJodaSyntax(timestamp, format[, timezone])
```
**Arguments**
* `timestamp` — Horodatage Unix ou valeur de date/heure. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `format` — Facultatif. Chaîne de format constante utilisant la syntaxe Joda pour le formatage de sortie. [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Chaîne constante de fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une date avec heure lorsqu’elle est appelée avec un argument, ou une `String` lorsqu’elle est appelée avec deux ou trois arguments.} [`DateTime`](/fr/reference/data-types/datetime) ou [`String`](/fr/reference/data-types/string)
**Exemples**
**Convertir un horodatage Unix au format Joda**
```sql title=Query theme={null}
SELECT fromUnixTimestampInJodaSyntax(1234334543, 'yyyy-MM-dd HH:mm:ss', 'UTC') AS DateTime
```
```response title=Response theme={null}
┌─DateTime────────────┐
│ 2009-02-11 06:42:23 │
└─────────────────────┘
```
## localtime
Introduit dans : v26.7.0
Renvoie l’heure actuelle dans le fuseau horaire du serveur (ou de la session), au moment de l’analyse de la requête.
La fonction est une expression constante. Il s’agit du `LOCALTIME` SQL standard / PostgreSQL, et elle est équivalente à `CAST(now() AS Time)`.
**Syntaxe**
```sql theme={null}
localtime()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie l'heure actuelle. [`Time`](/fr/reference/data-types/time)
**Exemples**
**Syntaxe SQL standard sans parenthèses**
```sql title=Query theme={null}
SELECT LOCALTIME
```
```response title=Response theme={null}
┌───────LOCALTIME─┐
│ 07:42:09 │
└─────────────────┘
```
## makeDate
Introduit dans : v22.6.0
Crée une `Date` à partir de l’un des éléments suivants :
* une année, un mois et un jour
* une année et le quantième du jour dans l’année
**Syntaxe**
```sql theme={null}
makeDate(year, month, day)
makeDate(year, day_of_year)
```
**Arguments**
* `year` — Numéro de l’année. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `month` — Numéro du mois (1-12). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `day` — Jour du mois (1-31). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `day_of_year` — Jour de l’année (1-365). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
**Valeur renvoyée**
Renvoie une valeur `Date` construite à partir des arguments fournis [`Date`](/fr/reference/data-types/date)
**Exemples**
**Date à partir d’une année, d’un mois et d’un jour**
```sql title=Query theme={null}
SELECT makeDate(2023, 2, 28) AS date;
```
```response title=Response theme={null}
┌───────date─┐
│ 2023-02-28 │
└────────────┘
```
**Date à partir de l’année et du jour dans l’année**
```sql title=Query theme={null}
SELECT makeDate(2023, 42) AS date;
```
```response title=Response theme={null}
┌───────date─┐
│ 2023-02-11 │
└────────────┘
```
## makeDate32
Introduit dans : v22.6.0
Crée un `Date32` à partir de :
* une année, un mois et un jour
* une année et le jour de l'année
**Syntaxe**
```sql theme={null}
makeDate32(year, month, day)
makeDate32(year, day_of_year)
```
**Arguments**
* `year` — Numéro de l'année. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `month` — Numéro du mois (1-12). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `day` — Jour du mois (1-31). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `day_of_year` — Jour de l'année (1-365). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
**Valeur renvoyée**
Renvoie une valeur `Date32` construite à partir des arguments fournis [`Date32`](/fr/reference/data-types/date32)
**Exemples**
**Date32 à partir d'une année, d'un mois et d'un jour**
```sql title=Query theme={null}
SELECT makeDate(2023, 2, 28) AS date;
```
```response title=Response theme={null}
┌───────date─┐
│ 2023-02-28 │
└────────────┘
```
**Date32 à partir de l’année et du numéro du jour dans l’année**
```sql title=Query theme={null}
SELECT makeDate(2023, 42) AS date;
```
```response title=Response theme={null}
┌───────date─┐
│ 2023-02-11 │
└────────────┘
```
## makeDateTime
Introduit dans : v22.6.0
Crée un `DateTime` à partir de l’année, du mois, du jour, de l’heure, de la minute et de la seconde, avec un fuseau horaire facultatif.
**Syntaxe**
```sql theme={null}
makeDateTime(year, month, day, hour, minute, second[, timezone])
```
**Arguments**
* `year` — Numéro de l’année. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `month` — Numéro du mois (1-12). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `day` — Jour du mois (1-31). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `hour` — Heure (0-23). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `minute` — Minute (0-59). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `second` — Seconde (0-59). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `timezone` — Nom du fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `DateTime` construite à partir des arguments fournis [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**DateTime à partir de l’année, du mois, du jour, de l’heure, de la minute et de la seconde**
```sql title=Query theme={null}
SELECT makeDateTime(2023, 2, 28, 17, 12, 33) AS DateTime;
```
```response title=Response theme={null}
┌────────────DateTime─┐
│ 2023-02-28 17:12:33 │
└─────────────────────┘
```
## makeDateTime64
Introduit dans : v22.6.0
Crée une valeur `DateTime64` à partir de l’année, du mois, du jour, de l’heure, de la minute, de la seconde, avec une fraction, une précision et un fuseau horaire facultatifs.
**Syntaxe**
```sql theme={null}
makeDateTime64(year, month, day, hour, minute, second[, fraction[, precision[, timezone]]])
```
**Arguments**
* `year` — Numéro de l'année. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `month` — Numéro du mois (1-12). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `day` — Jour du mois (1-31). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `hour` — Heure (0-23). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `minute` — Minute (0-59). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `second` — Seconde (0-59). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `fraction` — Partie fractionnaire de la seconde. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `precision` — Précision de la partie fractionnaire (0-9). [`UInt8`](/fr/reference/data-types/int-uint)
* `timezone` — Nom du fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur `DateTime64` construite à partir des arguments fournis [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**DateTime64 à partir de l'année, du mois, du jour, de l'heure, de la minute et de la seconde**
```sql title=Query theme={null}
SELECT makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5);
```
```response title=Response theme={null}
┌─makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5)─┐
│ 2023-05-15 10:30:45.00779 │
└─────────────────────────────────────────────────┘
```
## monthName
Introduit dans : v22.1.0
Renvoie le nom du mois sous forme de chaîne de caractères à partir d'une valeur de date ou de date avec heure.
**Syntaxe**
```sql theme={null}
monthName(datetime)
```
**Arguments**
* `datetime` — Date ou date et heure. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le nom du mois. [`String`](/fr/reference/data-types/string)
**Exemples**
**Obtenir le nom du mois à partir d'une date**
```sql title=Query theme={null}
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT monthName(date_value)
```
```response title=Response theme={null}
┌─monthName(date_value)─┐
│ April │
└───────────────────────┘
```
## now
Introduit dans : v1.1.0
Renvoie la date et l’heure actuelles au moment de l’analyse de la requête. La fonction est une expression constante.
**Syntaxe**
```sql theme={null}
now([timezone])
```
**Alias** : `localtimestamp`, `current_timestamp`
**Arguments**
* `timezone` — Facultatif. Nom du fuseau horaire pour la valeur renvoyée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la date et l’heure actuelles. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Requête sans fuseau horaire**
```sql title=Query theme={null}
SELECT now()
```
```response title=Response theme={null}
┌───────────────now()─┐
│ 2020-10-17 07:42:09 │
└─────────────────────┘
```
**Requête avec un fuseau horaire spécifié**
```sql title=Query theme={null}
SELECT now('Asia/Istanbul')
```
```response title=Response theme={null}
┌─now('Asia/Istanbul')─┐
│ 2020-10-17 10:42:23 │
└──────────────────────┘
```
**Syntaxe SQL standard sans parenthèses**
```sql title=Query theme={null}
SELECT NOW, CURRENT_TIMESTAMP
```
```response title=Response theme={null}
┌─────────────────NOW─┬───CURRENT_TIMESTAMP─┐
│ 2020-10-17 07:42:19 │ 2020-10-17 07:42:19 │
└─────────────────────┴─────────────────────┘
```
## now64
Introduite dans : v20.1.0
Renvoie la date et l’heure actuelles avec une précision inférieure à la seconde au moment de l’analyse de la requête. La fonction est une expression constante.
**Syntaxe**
```sql theme={null}
now64([scale[, timezone]])
```
**Arguments**
* `scale` — Facultatif. Taille du tick (précision) : 10^-precision secondes. Plage valide : \[0 : 9]. En général, on utilise 3 (par défaut) (millisecondes), 6 (microsecondes) et 9 (nanosecondes). [`UInt8`](/fr/reference/data-types/int-uint)
* `timezone` — Facultatif. Nom du fuseau horaire pour la valeur renvoyée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la date et l’heure actuelles avec une précision inférieure à la seconde. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Requête avec la précision par défaut et une précision personnalisée**
```sql title=Query theme={null}
SELECT now64(), now64(9, 'Asia/Istanbul')
```
```response title=Response theme={null}
┌─────────────────now64()─┬─────now64(9, 'Asia/Istanbul')─┐
│ 2022-08-21 19:34:26.196 │ 2022-08-21 22:34:26.196542766 │
└─────────────────────────┴───────────────────────────────┘
```
## nowInBlock
Introduit dans : v22.8.0
Renvoie la date et l'heure actuelles au moment du traitement de chaque bloc de données. Contrairement à la fonction [`now`](#now), il ne s'agit pas d'une expression constante, et la valeur renvoyée diffère d'un bloc à l'autre dans les requêtes de longue durée.
Cette fonction est utile pour générer l'heure actuelle dans les requêtes `INSERT SELECT` de longue durée.
**Syntaxe**
```sql theme={null}
nowInBlock([timezone])
```
**Arguments**
* `timezone` — Facultatif. Nom du fuseau horaire de la valeur renvoyée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la date et l’heure actuelles au moment du traitement de chaque bloc de données. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Différence avec la fonction now()**
```sql title=Query theme={null}
SELECT
now(),
nowInBlock(),
sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock
```
```response title=Response theme={null}
┌───────────────now()─┬────────nowInBlock()─┬─sleep(1)─┐
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:19 │ 0 │
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:20 │ 0 │
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:21 │ 0 │
└─────────────────────┴─────────────────────┴──────────┘
```
## nowInBlock64
Introduit dans : v25.8.0
Renvoie la date et l’heure actuelles au moment du traitement de chaque bloc de données, en millisecondes. Contrairement à la fonction [now64](#now64), il ne s’agit pas d’une expression constante, et la valeur renvoyée diffère d’un bloc à l’autre dans le cas de requêtes de longue durée.
Il est judicieux d’utiliser cette fonction pour générer l’heure actuelle dans des requêtes INSERT SELECT de longue durée.
**Syntaxe**
```sql theme={null}
nowInBlock64([scale[, timezone]])
```
**Arguments**
* `scale` — Facultatif. Taille du tick (précision) : 10^-precision seconde. Plage valide : \[0 : 9]. Les valeurs généralement utilisées sont 3 (par défaut) (millisecondes), 6 (microsecondes), 9 (nanosecondes). [`UInt8`](/fr/reference/data-types/int-uint)
* `timezone` — Facultatif. Nom du fuseau horaire pour la valeur renvoyée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la date et l’heure actuelles au moment du traitement de chaque bloc de données, avec une précision inférieure à la seconde. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Différence avec la fonction now64()**
```sql title=Query theme={null}
SELECT
now64(),
nowInBlock64(),
sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock
```
```response title=Response theme={null}
┌─────────────────now64()─┬──────────nowInBlock64()─┬─sleep(1)─┐
│ 2025-07-29 17:07:29.526 │ 2025-07-29 17:07:29.534 │ 0 │
│ 2025-07-29 17:07:29.526 │ 2025-07-29 17:07:30.535 │ 0 │
│ 2025-07-29 17:07:29.526 │ 2025-07-29 17:07:31.535 │ 0 │
└─────────────────────────┴─────────────────────────┴──────────┘
```
## serverTimezone
Introduit dans : v23.6.0
Renvoie le fuseau horaire du serveur, c’est-à-dire la valeur du paramètre [`timezone`](/fr/reference/settings/server-settings/settings#timezone).
Si la fonction est exécutée dans le contexte d’une table distribuée, elle génère une colonne normale avec des valeurs correspondant à chaque shard. Sinon, elle renvoie une valeur constante.
**Syntaxe**
```sql theme={null}
serverTimezone()
```
**Alias** : `serverTimeZone`
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie le fuseau horaire du serveur sous forme de [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT serverTimeZone()
```
```response title=Response theme={null}
┌─serverTimeZone()─┐
│ UTC │
└──────────────────┘
```
## subDate
Introduit dans : v23.9.0
Soustrait l’intervalle de temps à la date, à la date avec heure, ou à la date ou date avec heure encodée sous forme de chaîne fournie.
Si la soustraction produit une valeur hors des limites du type de données, le résultat est indéfini.
**Syntaxe**
```sql theme={null}
subDate(datetime, interval)
```
**Arguments**
* `datetime` — La date, avec ou sans heure, à laquelle `interval` est soustrait. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `interval` — Intervalle à soustraire. [`Interval`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie la date, avec ou sans heure, obtenue en soustrayant `interval` à `datetime`. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Soustraire un intervalle à une date**
```sql title=Query theme={null}
SELECT subDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
```
```response title=Response theme={null}
┌─subDate(toDate('2018-01-01'), toIntervalYear(3))─┐
│ 2015-01-01 │
└──────────────────────────────────────────────────┘
```
## subtractDays
Introduit dans : v1.1.0
Soustrait un nombre spécifié de jours à une date, une date et heure, ou une date ou date et heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
subtractDays(datetime, num)
```
**Arguments**
* `datetime` — Date ou date avec heure à laquelle soustraire le nombre de jours spécifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de jours à soustraire. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` moins `num` jours [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Soustraire des jours à différents types de date**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractDays(date, 31) AS subtract_days_with_date,
subtractDays(date_time, 31) AS subtract_days_with_date_time,
subtractDays(date_time_string, 31) AS subtract_days_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_days_with_date─┬─subtract_days_with_date_time─┬─subtract_days_with_date_time_string─┐
│ 2023-12-01 │ 2023-12-01 00:00:00 │ 2023-12-01 00:00:00.000 │
└─────────────────────────┴──────────────────────────────┴─────────────────────────────────────┘
```
**Utilisation de la syntaxe alternative INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 day)
```
```response title=Response theme={null}
┌─minus(CAST('⋯valDay(10))─┐
│ 1998-06-06 │
└──────────────────────────┘
```
## subtractHours
Introduit dans : v1.1.0
Soustrait un nombre donné d’heures à une date, une date avec heure, ou une date ou une date avec heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
subtractHours(datetime, num)
```
**Arguments**
* `datetime` — Date ou date avec heure à laquelle soustraire le nombre d'heures spécifié. [`Date`](/fr/reference/data-types/date) or [`Date32`](/fr/reference/data-types/date32) or [`DateTime`](/fr/reference/data-types/datetime) or [`DateTime64`](/fr/reference/data-types/datetime64) or [`String`](/fr/reference/data-types/string)
* `num` — Nombre d'heures à soustraire. [`(U)Int*`](/fr/reference/data-types/int-uint) or [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` moins `num` heures [`DateTime`](/fr/reference/data-types/datetime) or [`DateTime64(3)`](/fr/reference/data-types/datetime64)
**Exemples**
**Soustraire des heures à différents types de date**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractHours(date, 12) AS subtract_hours_with_date,
subtractHours(date_time, 12) AS subtract_hours_with_date_time,
subtractHours(date_time_string, 12) AS subtract_hours_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_hours_with_date─┬─subtract_hours_with_date_time─┬─subtract_hours_with_date_time_string─┐
│ 2023-12-31 12:00:00 │ 2023-12-31 12:00:00 │ 2023-12-31 12:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
```
**Utilisation de la syntaxe INTERVAL alternative**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 hour)
```
```response title=Response theme={null}
┌─minus(CAST('⋯alHour(10))─┐
│ 1998-06-15 14:00:00 │
└──────────────────────────┘
```
## subtractInterval
Introduit dans : v22.11.0
Ajoute un intervalle négatif à un autre intervalle ou à un tuple d’intervalles.
Remarque : les intervalles du même type sont combinés en un seul intervalle. Par exemple, si `toIntervalDay(2)` et `toIntervalDay(1)` sont
passés, le résultat sera `(1)` plutôt que `(2,1)`.
**Syntaxe**
```sql theme={null}
subtractInterval(interval_1, interval_2)
```
**Arguments**
* `interval_1` — Premier intervalle ou tuple d’intervalles. [`Interval`](/fr/reference/data-types/int-uint) ou [`Tuple(Interval)`](/fr/reference/data-types/tuple)
* `interval_2` — Deuxième intervalle à rendre négatif. [`Interval`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie un tuple d’intervalles [`Tuple(T)`](/fr/reference/data-types/tuple)
**Exemples**
**Soustraction d’intervalles**
```sql title=Query theme={null}
SELECT subtractInterval(INTERVAL 1 DAY, INTERVAL 1 MONTH);
SELECT subtractInterval((INTERVAL 1 DAY, INTERVAL 1 YEAR), INTERVAL 1 MONTH);
SELECT subtractInterval(INTERVAL 2 DAY, INTERVAL 1 DAY);
```
```response title=Response theme={null}
┌─subtractInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,-1) │
└────────────────────────────────────────────────────────┘
┌─subtractInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,-1) │
└─────────────────────────────────────────────────────────────────────────────┘
┌─subtractInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (1) │
└──────────────────────────────────────────────────────┘
```
## subtractMicroseconds
Introduit dans : v22.6.0
Soustrait un nombre donné de microsecondes à une date et heure ou à une date et heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
subtractMicroseconds(datetime, num)
```
**Arguments**
* `datetime` — Date avec heure de laquelle soustraire le nombre spécifié de microsecondes. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de microsecondes à soustraire. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` moins `num` microsecondes [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Soustraire des microsecondes de différents types de date avec heure**
```sql title=Query theme={null}
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractMicroseconds(date_time, 1000000) AS subtract_microseconds_with_date_time,
subtractMicroseconds(date_time_string, 1000000) AS subtract_microseconds_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_microseconds_with_date_time─┬─subtract_microseconds_with_date_time_string─┐
│ 2023-12-31 23:59:59.000000 │ 2023-12-31 23:59:59.000000 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘
```
**Utilisation de la syntaxe INTERVAL alternative**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 microsecond)
```
```response title=Response theme={null}
┌─minus(CAST('1⋯osecond(10))─┐
│ 1998-06-15 23:59:59.999990 │
└────────────────────────────┘
```
## subtractMilliseconds
Introduit dans : v22.6.0
Soustrait un nombre spécifié de millisecondes à une date et heure ou à une date et heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
subtractMilliseconds(datetime, num)
```
**Arguments**
* `datetime` — Date avec heure à laquelle soustraire le nombre spécifié de millisecondes. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de millisecondes à soustraire. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
`datetime` moins `num` millisecondes. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Soustraire des millisecondes à différents types de dates et d’heures**
```sql title=Query theme={null}
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractMilliseconds(date_time, 1000) AS subtract_milliseconds_with_date_time,
subtractMilliseconds(date_time_string, 1000) AS subtract_milliseconds_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_milliseconds_with_date_time─┬─subtract_milliseconds_with_date_time_string─┐
│ 2023-12-31 23:59:59.000 │ 2023-12-31 23:59:59.000 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘
```
**Utilisation d'une syntaxe INTERVAL alternative**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 millisecond)
```
```response title=Response theme={null}
┌─minus(CAST('⋯second(10))─┐
│ 1998-06-15 23:59:59.990 │
└──────────────────────────┘
```
## subtractMinutes
Introduit dans : v1.1.0
Soustrait un nombre donné de minutes à une date, une date avec heure ou une date ou date avec heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
subtractMinutes(datetime, num)
```
**Arguments**
* `datetime` — Date ou date avec heure à laquelle soustraire le nombre de minutes spécifié. [`Date`](/fr/reference/data-types/date) or [`Date32`](/fr/reference/data-types/date32) or [`DateTime`](/fr/reference/data-types/datetime) or [`DateTime64`](/fr/reference/data-types/datetime64) or [`String`](/fr/reference/data-types/string)
* `num` — Nombre de minutes à soustraire. [`(U)Int*`](/fr/reference/data-types/int-uint) or [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` moins `num` minutes. [`DateTime`](/fr/reference/data-types/datetime) or [`DateTime64(3)`](/fr/reference/data-types/datetime64)
**Exemples**
**Soustraire des minutes à différents types de dates**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractMinutes(date, 30) AS subtract_minutes_with_date,
subtractMinutes(date_time, 30) AS subtract_minutes_with_date_time,
subtractMinutes(date_time_string, 30) AS subtract_minutes_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_minutes_with_date─┬─subtract_minutes_with_date_time─┬─subtract_minutes_with_date_time_string─┐
│ 2023-12-31 23:30:00 │ 2023-12-31 23:30:00 │ 2023-12-31 23:30:00.000 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘
```
**Utilisation de la syntaxe alternative INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 minute)
```
```response title=Response theme={null}
┌─minus(CAST('⋯Minute(10))─┐
│ 1998-06-15 23:50:00 │
└──────────────────────────┘
```
## subtractMonths
Introduit dans : v1.1.0
Soustrait un nombre donné de mois à une date, une date avec heure, ou une date ou date avec heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
subtractMonths(datetime, num)
```
**Arguments**
* `datetime` — Date ou date avec heure à laquelle soustraire le nombre de mois spécifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de mois à soustraire. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` moins `num` mois. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Soustraction de mois à différents types de date**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractMonths(date, 1) AS subtract_months_with_date,
subtractMonths(date_time, 1) AS subtract_months_with_date_time,
subtractMonths(date_time_string, 1) AS subtract_months_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_months_with_date─┬─subtract_months_with_date_time─┬─subtract_months_with_date_time_string─┐
│ 2023-12-01 │ 2023-12-01 00:00:00 │ 2023-12-01 00:00:00.000 │
└───────────────────────────┴────────────────────────────────┴───────────────────────────────────────┘
```
**Utilisation d’une autre syntaxe INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 month)
```
```response title=Response theme={null}
┌─minus(CAST('⋯lMonth(10))─┐
│ 1997-08-16 │
└──────────────────────────┘
```
## subtractNanoseconds
Introduit dans : v20.1.0
Soustrait un nombre spécifié de nanosecondes à une date avec heure ou à une date avec heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
subtractNanoseconds(datetime, num)
```
**Arguments**
* `datetime` — Date avec heure dont il faut soustraire le nombre spécifié de nanosecondes. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de nanosecondes à soustraire. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` moins `num` nanosecondes [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Soustraire des nanosecondes à différents types de date avec heure**
```sql title=Query theme={null}
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractNanoseconds(date_time, 1000) AS subtract_nanoseconds_with_date_time,
subtractNanoseconds(date_time_string, 1000) AS subtract_nanoseconds_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_nanoseconds_with_date_time─┬─subtract_nanoseconds_with_date_time_string─┐
│ 2023-12-31 23:59:59.999999000 │ 2023-12-31 23:59:59.999999000 │
└─────────────────────────────────────┴────────────────────────────────────────────┘
```
**Utilisation d'une syntaxe INTERVAL alternative**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 nanosecond)
```
```response title=Response theme={null}
┌─minus(CAST('19⋯anosecond(10))─┐
│ 1998-06-15 23:59:59.999999990 │
└───────────────────────────────┘
```
## subtractQuarters
Introduit dans : v20.1.0
Soustrait un nombre spécifié de trimestres à une date, une date avec heure, ou une date ou date avec heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
subtractQuarters(datetime, num)
```
**Arguments**
* `datetime` — Date ou date avec heure à partir de laquelle soustraire le nombre de trimestres spécifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de trimestres à soustraire. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` moins `num` trimestres [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Soustraire des trimestres à différents types de dates**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractQuarters(date, 1) AS subtract_quarters_with_date,
subtractQuarters(date_time, 1) AS subtract_quarters_with_date_time,
subtractQuarters(date_time_string, 1) AS subtract_quarters_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_quarters_with_date─┬─subtract_quarters_with_date_time─┬─subtract_quarters_with_date_time_string─┐
│ 2023-10-01 │ 2023-10-01 00:00:00 │ 2023-10-01 00:00:00.000 │
└─────────────────────────────┴──────────────────────────────────┴─────────────────────────────────────────┘
```
**Utilisation d'une autre syntaxe INTERVAL**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 quarter)
```
```response title=Response theme={null}
┌─minus(CAST('1⋯Quarter(10))─┐
│ 1996-09-16 │
└───────────────────────────┘
```
## subtractSeconds
Introduit dans : v1.1.0
Soustrait un nombre spécifié de secondes à une date, une date avec heure, ou une date ou une date avec heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
subtractSeconds(datetime, num)
```
**Arguments**
* `datetime` — Date ou date avec heure à laquelle soustraire le nombre de secondes spécifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de secondes à soustraire. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` moins `num` secondes. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64(3)`](/fr/reference/data-types/datetime64)
**Exemples**
**Soustraire des secondes à différents types de dates**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractSeconds(date, 60) AS subtract_seconds_with_date,
subtractSeconds(date_time, 60) AS subtract_seconds_with_date_time,
subtractSeconds(date_time_string, 60) AS subtract_seconds_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_seconds_with_date─┬─subtract_seconds_with_date_time─┬─subtract_seconds_with_date_time_string─┐
│ 2023-12-31 23:59:00 │ 2023-12-31 23:59:00 │ 2023-12-31 23:59:00.000 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘
```
**Utilisation de la syntaxe INTERVAL alternative**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 second)
```
```response title=Response theme={null}
┌─minus(CAST('⋯Second(10))─┐
│ 1998-06-15 23:59:50 │
└──────────────────────────┘
```
## subtractTupleOfIntervals
Introduit dans : v22.11.0
Soustrait successivement un tuple d’intervalles à une date ou à une date avec heure.
**Syntaxe**
```sql theme={null}
subtractTupleOfIntervals(datetime, intervals)
```
**Arguments**
* `datetime` — Date ou date avec heure à laquelle soustraire les intervalles. [`Date`](/fr/reference/data-types/date) or [`Date32`](/fr/reference/data-types/date32) or [`DateTime`](/fr/reference/data-types/datetime) or [`DateTime64`](/fr/reference/data-types/datetime64)
* `intervals` — Tuple d’intervalles à soustraire à `datetime`. [`Tuple(Interval)`](/fr/reference/data-types/tuple)
**Valeur renvoyée**
Renvoie `date` après soustraction des `intervals` [`Date`](/fr/reference/data-types/date) or [`Date32`](/fr/reference/data-types/date32) or [`DateTime`](/fr/reference/data-types/datetime) or [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Soustraire un tuple d’intervalles d’une date**
```sql title=Query theme={null}
WITH toDate('2018-01-01') AS date SELECT subtractTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 YEAR))
```
```response title=Response theme={null}
┌─subtractTupl⋯alYear(1)))─┐
│ 2016-12-31 │
└──────────────────────────┘
```
## subtractWeeks
Introduit dans : v1.1.0
Soustrait un nombre donné de semaines à une date, une date avec heure ou une date ou date avec heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
subtractWeeks(datetime, num)
```
**Arguments**
* `datetime` — Date ou date avec heure à laquelle soustraire le nombre de semaines spécifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre de semaines à soustraire. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` moins `num` semaines. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Soustraire des semaines à différents types de dates**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractWeeks(date, 1) AS subtract_weeks_with_date,
subtractWeeks(date_time, 1) AS subtract_weeks_with_date_time,
subtractWeeks(date_time_string, 1) AS subtract_weeks_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_weeks_with_date─┬─subtract_weeks_with_date_time─┬─subtract_weeks_with_date_time_string─┐
│ 2023-12-25 │ 2023-12-25 00:00:00 │ 2023-12-25 00:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
```
**Utilisation d’une syntaxe INTERVAL alternative**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 week)
```
```response title=Response theme={null}
┌─minus(CAST('⋯alWeek(10))─┐
│ 1998-04-07 │
└──────────────────────────┘
```
## subtractYears
Introduit dans : v1.1.0
Soustrait un nombre donné d’années à une date, une date avec heure, ou une date ou date avec heure encodée sous forme de chaîne.
**Syntaxe**
```sql theme={null}
subtractYears(datetime, num)
```
**Arguments**
* `datetime` — Date ou date avec heure à laquelle soustraire le nombre d'années spécifié. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `num` — Nombre d'années à soustraire. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `datetime` moins `num` ans [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Soustraire des années à différents types de date**
```sql title=Query theme={null}
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractYears(date, 1) AS subtract_years_with_date,
subtractYears(date_time, 1) AS subtract_years_with_date_time,
subtractYears(date_time_string, 1) AS subtract_years_with_date_time_string
```
```response title=Response theme={null}
┌─subtract_years_with_date─┬─subtract_years_with_date_time─┬─subtract_years_with_date_time_string─┐
│ 2023-01-01 │ 2023-01-01 00:00:00 │ 2023-01-01 00:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
```
**Utilisation d'une syntaxe INTERVAL alternative**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 year)
```
```response title=Response theme={null}
┌─minus(CAST('⋯alYear(10))─┐
│ 1988-06-16 │
└──────────────────────────┘
```
## timeDiff
Introduit dans : v23.4.0
Renvoie la différence en secondes entre deux dates ou deux dates avec heure.
La différence est calculée ainsi : `enddate` - `startdate`.
Cette fonction est équivalente à `dateDiff('second', startdate, enddate)`.
Pour calculer des différences de temps dans d'autres unités (heures, jours, mois, etc.), utilisez plutôt la fonction [`dateDiff`](#dateDiff).
**Syntaxe**
```sql theme={null}
timeDiff(startdate, enddate)
```
**Arguments**
* `startdate` — La première valeur temporelle à soustraire (le terme soustrait). [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `enddate` — La deuxième valeur temporelle à partir de laquelle soustraire (le terme de départ). [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la différence entre `enddate` et `startdate`, exprimée en secondes. [`Int64`](/fr/reference/data-types/int-uint)
**Exemples**
**Calculer la différence en secondes**
```sql title=Query theme={null}
SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res
```
```response title=Response theme={null}
┌───res─┐
│ 90000 │
└───────┘
```
**Calculer une différence de temps et la convertir en heures**
```sql title=Query theme={null}
SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) / 3600 AS hours
```
```response title=Response theme={null}
┌─hours─┐
│ 25 │
└───────┘
```
**Équivalent à dateDiff en secondes**
```sql title=Query theme={null}
SELECT
timeDiff(toDateTime('2021-12-29'), toDateTime('2022-01-01')) AS time_diff_result,
dateDiff('second', toDateTime('2021-12-29'), toDateTime('2022-01-01')) AS date_diff_result
```
```response title=Response theme={null}
┌─time_diff_result─┬─date_diff_result─┐
│ 259200 │ 259200 │
└──────────────────┴──────────────────┘
```
## timeSlot
Introduit dans : v1.1.0
Arrondit l'heure au début d'un intervalle de 30 minutes.
Bien que cette fonction puisse prendre en argument des valeurs des types étendus `Date32` et `DateTime64`,
lui transmettre une heure en dehors de la plage normale (de 1970 à 2149 pour `Date` / 2106 pour `DateTime`) produira des résultats erronés.
**Syntaxe**
```sql theme={null}
timeSlot(time[, time_zone])
```
**Arguments**
* `time` — Heure à arrondir au début d’un intervalle d’une demi-heure. [`DateTime`](/fr/reference/data-types/datetime) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `time_zone` — Facultatif. Valeur constante de type String ou expression représentant le fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie l’heure arrondie au début d’un intervalle d’une demi-heure. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Arrondir l’heure à un intervalle d’une demi-heure**
```sql title=Query theme={null}
SELECT timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))
```
```response title=Response theme={null}
┌─timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))─┐
│ 2000-01-02 03:00:00 │
└────────────────────────────────────────────────────┘
```
## timeSlots
Introduit dans : v1.1.0
Pour un intervalle de temps commençant à `StartTime` et durant `Duration` secondes, cette fonction renvoie un tableau d’instants correspondant aux points de cet intervalle, arrondis à l’inférieur selon `Size` secondes. `Size` est un paramètre facultatif dont la valeur par défaut est 1800 (30 minutes).
Cela est nécessaire, par exemple, pour rechercher des pages vues dans la session correspondante.
Pour `DateTime64`, la scale de la valeur renvoyée peut différer de celle de `StartTime`. La scale la plus élevée parmi tous les arguments fournis est utilisée.
**Syntaxe**
```sql theme={null}
timeSlots(StartTime, Duration[, Size])
```
**Arguments**
* `StartTime` — Heure de début de l’intervalle. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `Duration` — Durée de l’intervalle en secondes. [`UInt32`](/fr/reference/data-types/int-uint) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `Size` — Facultatif. Taille des créneaux horaires en secondes. La valeur par défaut est 1800 (30 minutes). [`UInt32`](/fr/reference/data-types/int-uint) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie un tableau de DateTime/DateTime64 (le type de retour correspond à celui de `StartTime`). Pour DateTime64, la précision de la valeur renvoyée peut différer de celle de `StartTime` ; la plus élevée parmi tous les arguments fournis est retenue. [`Array(DateTime)`](/fr/reference/data-types/array) ou [`Array(DateTime64)`](/fr/reference/data-types/array)
**Exemples**
**Générer des créneaux horaires pour un intervalle**
```sql title=Query theme={null}
SELECT timeSlots(toDateTime('2012-01-01 12:20:00'), toUInt32(600));
SELECT timeSlots(toDateTime('1980-12-12 21:01:02', 'UTC'), toUInt32(600), 299);
SELECT timeSlots(toDateTime64('1980-12-12 21:01:02.1234', 4, 'UTC'), toDecimal64(600.1, 1), toDecimal64(299, 0))
```
```response title=Response theme={null}
┌─timeSlots(toDateTime('2012-01-01 12:20:00'), toUInt32(600))─┐
│ ['2012-01-01 12:00:00','2012-01-01 12:30:00'] │
└─────────────────────────────────────────────────────────────┘
┌─timeSlots(toDateTime('1980-12-12 21:01:02', 'UTC'), toUInt32(600), 299)─┐
│ ['1980-12-12 20:56:13','1980-12-12 21:01:12','1980-12-12 21:06:11'] │
└─────────────────────────────────────────────────────────────────────────┘
┌─timeSlots(toDateTime64('1980-12-12 21:01:02.1234', 4, 'UTC'), toDecimal64(600.1, 1), toDecimal64(299, 0))─┐
│ ['1980-12-12 20:56:13.0000','1980-12-12 21:01:12.0000','1980-12-12 21:06:11.0000'] │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
## timestamp
Introduit dans : v23.9.0
Convertit le premier argument `expr` en type [`DateTime64(6)`](/fr/reference/data-types/datetime64).
Si un deuxième argument `expr_time` est fourni, il ajoute l'heure spécifiée à la valeur convertie.
**Syntaxe**
```sql theme={null}
timestamp(expr[, expr_time])
```
**Arguments**
* `expr` — Date ou date avec heure. [`String`](/fr/reference/data-types/string)
* `expr_time` — Facultatif. Heure à ajouter à la valeur convertie. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la valeur convertie de `expr`, ou `expr` après ajout de l'heure [`DateTime64(6)`](/fr/reference/data-types/datetime64)
**Exemples**
**Convertir une chaîne de date en DateTime64(6)**
```sql title=Query theme={null}
SELECT timestamp('2023-12-31') AS ts;
```
```response title=Response theme={null}
┌─────────────────────────ts─┐
│ 2023-12-31 00:00:00.000000 │
└────────────────────────────┘
```
**Ajouter une heure à une date au format chaîne**
```sql title=Query theme={null}
SELECT timestamp('2023-12-31 12:00:00', '12:00:00.11') AS ts;
```
```response title=Response theme={null}
┌─────────────────────────ts─┐
│ 2024-01-01 00:00:00.110000 │
└────────────────────────────┘
```
## timezone
Introduit dans : v21.4.0
Renvoie le nom du fuseau horaire de la session en cours ou convertit un décalage ou un nom de fuseau horaire en nom de fuseau horaire canonique.
**Syntaxe**
```sql theme={null}
timezone()
```
**Alias** : `timeZone`
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie le nom canonique du fuseau horaire sous forme de [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT timezone()
```
```response title=Response theme={null}
┌─timezone()───────┐
│ Europe/Amsterdam │
└──────────────────┘
```
## timezoneOf
Introduit dans : v21.4.0
Renvoie le nom du fuseau horaire d’une valeur [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64).
**Syntaxe**
```sql theme={null}
timezoneOf(datetime)
```
**Alias** : `timeZoneOf`
**Arguments**
* `datetime` — Une valeur de type [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Nom du fuseau horaire vers lequel convertir la valeur `datetime`. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le nom du fuseau horaire de `datetime` [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT timezoneOf(now());
```
```response title=Response theme={null}
┌─timezoneOf(now())─┐
│ Europe/Amsterdam │
└───────────────────┘
```
## timezoneOffset
Introduit dans : v21.6.0
Renvoie le décalage du fuseau horaire en secondes par rapport à [UTC](https://en.wikipedia.org/wiki/Coordinated_Universal_Time).
La fonction tient compte de l’heure d’été ainsi que des changements historiques de fuseau horaire à la date et à l’heure spécifiées.
**Syntaxe**
```sql theme={null}
timezoneOffset(datetime)
```
**Alias** : `timeZoneOffset`
**Arguments**
* `datetime` — valeur `DateTime` dont il faut obtenir le décalage de fuseau horaire. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le décalage par rapport à l’UTC en secondes [`Int32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toDateTime('2021-04-21 10:20:30', 'America/New_York') AS Time,
toTypeName(Time) AS Type,
timezoneOffset(Time) AS Offset_in_seconds,
(Offset_in_seconds / 3600) AS Offset_in_hours;
```
```response title=Response theme={null}
┌────────────────Time─┬─Type─────────────────────────┬─Offset_in_seconds─┬─Offset_in_hours─┐
│ 2021-04-21 10:20:30 │ DateTime('America/New_York') │ -14400 │ -4 │
└─────────────────────┴──────────────────────────────┴───────────────────┴─────────────────┘
```
## toDayOfMonth
Introduit dans : v1.1.0
Renvoie le jour du mois (1-31) d’une `Date` ou d’un `DateTime`.
**Syntaxe**
```sql theme={null}
toDayOfMonth(datetime)
```
**Alias** : `DAY`, `DAYOFMONTH`
**Arguments**
* `datetime` — Date ou date avec heure à partir de laquelle extraire le jour du mois. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le jour du mois de la date/heure donnée [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toDayOfMonth(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 21 │
└─────────────────────────────────────────────────┘
```
## toDayOfWeek
Introduit dans : v1.1.0
Renvoie le numéro du jour de la semaine pour une valeur `Date` ou `DateTime`.
La forme à deux arguments de `toDayOfWeek()` permet de préciser si la semaine commence le lundi ou le dimanche,
et si la valeur renvoyée doit être comprise dans l’intervalle de 0 à 6 ou de 1 à 7.
| Mode | Premier jour de la semaine | Intervalle |
| ---- | -------------------------- | ---------------------------------------------- |
| 0 | Lundi | 1-7 : lundi = 1, mardi = 2, ..., dimanche = 7 |
| 1 | Lundi | 0-6 : lundi = 0, mardi = 1, ..., dimanche = 6 |
| 2 | Dimanche | 0-6 : dimanche = 0, lundi = 1, ..., samedi = 6 |
| 3 | Dimanche | 1-7 : dimanche = 1, lundi = 2, ..., samedi = 7 |
**Syntaxe**
```sql theme={null}
toDayOfWeek(datetime[, mode[, timezone]])
```
**Alias** : `DAYOFWEEK`
**Arguments**
* `datetime` — Date ou date avec heure à partir de laquelle extraire le jour de la semaine. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `mode` — Facultatif. Entier spécifiant le mode de semaine (0-3). La valeur par défaut est 0 s’il est omis. [`UInt8`](/fr/reference/data-types/int-uint)
* `timezone` — Facultatif. Fuseau horaire à utiliser pour la conversion. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le jour de la semaine pour la valeur `Date` ou `DateTime` donnée. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
-- The following date is April 21, 2023, which was a Friday:
SELECT
toDayOfWeek(toDateTime('2023-04-21')),
toDayOfWeek(toDateTime('2023-04-21'), 1)
```
```response title=Response theme={null}
┌─toDayOfWeek(toDateTime('2023-04-21'))─┬─toDayOfWeek(toDateTime('2023-04-21'), 1)─┐
│ 5 │ 4 │
└───────────────────────────────────────┴──────────────────────────────────────────┘
```
## toDayOfYear
Introduite dans : v18.4.0
Renvoie le numéro du jour dans l’année (1-366) pour une valeur `Date` ou `DateTime`.
**Syntaxe**
```sql theme={null}
toDayOfYear(datetime)
```
**Alias** : `DAYOFYEAR`
**Arguments**
* `datetime` — Date ou date avec heure à partir de laquelle obtenir le jour de l'année. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le jour de l'année pour la valeur Date ou DateTime donnée [`UInt16`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toDayOfYear(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toDayOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 111 │
└────────────────────────────────────────────────┘
```
## toDaysInMonth
Introduit dans : v26.3.0
Renvoie le nombre de jours du mois d’une `Date` ou d’un `DateTime`.
La valeur renvoyée est comprise entre 28 et 31.
**Syntaxe**
```sql theme={null}
toDaysInMonth(datetime)
```
**Arguments**
* `datetime` — Date ou date avec heure à partir de laquelle obtenir le nombre de jours du mois. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le nombre de jours du mois de la date/heure donnée. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toDaysInMonth(toDate('2023-02-01')), toDaysInMonth(toDate('2024-02-01')), toDaysInMonth(toDate('2023-01-01'))
```
```response title=Response theme={null}
┌─toDaysInMonth(toDate('2023-02-01'))─┬─toDaysInMonth(toDate('2024-02-01'))─┬─toDaysInMonth(toDate('2023-01-01'))─┐
│ 28 │ 29 │ 31 │
└─────────────────────────────────────┴─────────────────────────────────────┴─────────────────────────────────────┘
```
## toDaysSinceYearZero
Introduit dans : v23.9.0
Pour une date donnée, renvoie le nombre de jours écoulés depuis le [1er janvier 0000](https://en.wikipedia.org/wiki/Year_zero) dans le
[calendrier grégorien proleptique défini par l’ISO 8601](https://en.wikipedia.org/wiki/Gregorian_calendar#Proleptic_Gregorian_calendar).
Le calcul est identique à celui de la fonction [`TO_DAYS`](https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_to-days) de MySQL.
**Syntaxe**
```sql theme={null}
toDaysSinceYearZero(date[, time_zone])
```
**Alias** : `TO_DAYS`
**Arguments**
* `date` — La date ou la date avec heure pour laquelle calculer le nombre de jours écoulés depuis l’année zéro. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `time_zone` — Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le nombre de jours écoulés depuis la date `0000-01-01`. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Calculer le nombre de jours depuis l’année zéro**
```sql title=Query theme={null}
SELECT toDaysSinceYearZero(toDate('2023-09-08'))
```
```response title=Response theme={null}
┌─toDaysSinceYearZero(toDate('2023-09-08')))─┐
│ 713569 │
└────────────────────────────────────────────┘
```
## toHour
Introduit dans : v1.1.0
Renvoie l’heure (0 à 23) d’une valeur `DateTime` ou `DateTime64`.
**Syntaxe**
```sql theme={null}
toHour(datetime)
```
**Alias** : `HOUR`
**Arguments**
* `datetime` — Date avec heure dont extraire l’heure. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie l’heure (0 à 23) de `datetime`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toHour(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toHour(toDateTime('2023-04-21 10:20:30'))─┐
│ 10 │
└───────────────────────────────────────────┘
```
## toISOWeek
Introduite dans : v20.1.0
Renvoie le numéro de semaine ISO d'une date ou d'une date et heure.
Il s'agit d'une fonction de compatibilité équivalente à `toWeek(date, 3)`.
Les semaines ISO commencent le lundi, et la première semaine de l'année contient le 4 janvier.
Conformément à la norme ISO 8601, les numéros de semaine vont de 1 à 53.
Notez que les dates proches du début ou de la fin d'une année peuvent renvoyer un numéro de semaine de l'année précédente ou suivante. Par exemple,
le 29 décembre 2025 renvoie la semaine 1, car cette date appartient à la première semaine qui contient le 4 janvier 2026.
**Syntaxe**
```sql theme={null}
toISOWeek(datetime[, timezone])
```
**Arguments**
* `datetime` — Date ou date avec heure à partir de laquelle obtenir le numéro de semaine ISO. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le numéro de semaine ISO selon la norme ISO 8601. Renvoie un nombre compris entre 1 et 53. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Obtenir les numéros de semaine ISO**
```sql title=Query theme={null}
SELECT toDate('2016-12-27') AS date, toISOWeek(date) AS isoWeek
```
```response title=Response theme={null}
┌───────date─┬─isoWeek─┐
│ 2016-12-27 │ 52 │
└────────────┴─────────┘
```
**Une semaine ISO peut appartenir à une année différente**
```sql title=Query theme={null}
SELECT toDate('2025-12-29') AS date, toISOWeek(date) AS isoWeek, toYear(date) AS year
```
```response title=Response theme={null}
┌───────date─┬─isoWeek─┬─year─┐
│ 2025-12-29 │ 1 │ 2025 │
└────────────┴─────────┴──────┘
```
## toISOYear
Introduit dans : v18.4.0
Convertit une date ou une date avec heure en numéro de l’année ISO.
**Syntaxe**
```sql theme={null}
toISOYear(datetime)
```
**Arguments**
* `datetime` — Valeur de type date ou date avec heure. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la valeur d’entrée convertie en numéro d’année ISO. [`UInt16`](/fr/reference/data-types/int-uint)
**Exemples**
**Obtenir l’année ISO à partir de valeurs de date**
```sql title=Query theme={null}
SELECT
toISOYear(toDate('2024/10/02')) as year1,
toISOYear(toDateTime('2024-10-02 01:30:00')) as year2
```
```response title=Response theme={null}
┌─week1─┬─week2─┐
│ 40 │ 40 │
└───────┴───────┘
```
## toLastDayOfMonth
Introduit dans : v1.1.0
Arrondit une date ou une date avec heure au dernier jour du mois.
Le type de retour peut être configuré via le paramètre [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toLastDayOfMonth(value)
```
**Alias** : `LAST_DAY`
**Arguments**
* `value` — La date ou la date avec heure à arrondir au dernier jour du mois. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la date du dernier jour du mois pour la date ou la date avec heure donnée. [`Date`](/fr/reference/data-types/date)
**Exemples**
**Arrondir au dernier jour du mois**
```sql title=Query theme={null}
SELECT toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-30 │
└─────────────────────────────────────────────────────┘
```
## toLastDayOfWeek
Introduit dans : v23.5.0
Arrondit une date ou une date avec heure au samedi ou au dimanche suivant le plus proche.
Le type de retour peut être configuré en définissant [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toLastDayOfWeek(datetime[, mode[, timezone]])
```
**Arguments**
* `datetime` — Une date avec heure ou une date à convertir. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `mode` — Détermine le premier jour de la semaine, comme décrit dans la fonction `toWeek()`. Valeur par défaut : `0`. [`UInt8`](/fr/reference/data-types/int-uint)
* `timezone` — Facultatif. Fuseau horaire à utiliser pour la conversion. S’il n’est pas spécifié, le fuseau horaire du serveur est utilisé. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la date du samedi ou du dimanche le plus proche, à compter de la date donnée, selon le mode. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32)
**Exemples**
**Arrondir au samedi ou au dimanche le plus proche**
```sql title=Query theme={null}
SELECT
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')), /* a Friday */
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* a Friday */
toLastDayOfWeek(toDate('2023-04-23')), /* a Sunday */
toLastDayOfWeek(toDate('2023-04-23'), 1) /* a Sunday */
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')): 2023-04-23
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-22
toLastDayOfWeek(toDate('2023-04-23')): 2023-04-23
toLastDayOfWeek(toDate('2023-04-23'), 1): 2023-04-23
```
## toMicrosecond
Introduit dans : v25.7.0
Renvoie la composante en microsecondes (0-999999) d’une valeur `DateTime64`.
**Syntaxe**
```sql theme={null}
toMicrosecond(datetime)
```
**Alias** : `MICROSECOND`
**Arguments**
* `datetime` — Date et heure dont extraire la microseconde. [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la microseconde de la seconde (0 - 999999) de `datetime`. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toMicrosecond(toDateTime64('2023-04-21 10:20:30.456789', 6));
```
```response title=Response theme={null}
┌─toMicrosecond(toDateTime64('2023-04-21 10:20:30.456789', 6))─┐
│ 456789 │
└──────────────────────────────────────────────────────────────┘
```
## toMillisecond
Introduit dans : v24.2.0
Renvoie la composante milliseconde (0 à 999) d’une valeur `DateTime` ou `DateTime64`.
**Syntaxe**
```sql theme={null}
toMillisecond(datetime)
```
**Alias** : `MILLISECOND`
**Arguments**
* `datetime` — date et heure dont extraire la minute. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la minute (0 - 59) de `datetime`. [`UInt16`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3));
```
```response title=Response theme={null}
┌──toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3))─┐
│ 456 │
└────────────────────────────────────────────────────────────┘
```
## toMinute
Introduite dans : v1.1.0
Renvoie la composante « minute » (0-59) d’une valeur `Date` ou `DateTime`.
**Syntaxe**
```sql theme={null}
toMinute(datetime)
```
**Alias** : `MINUTE`
**Arguments**
* `datetime` — Date et heure dont extraire la minute. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la minute de l'heure (0 - 59) de `datetime`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toMinute(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toMinute(toDateTime('2023-04-21 10:20:30'))─┐
│ 20 │
└─────────────────────────────────────────────┘
```
## toModifiedJulianDay
Introduit dans : v21.1.0
Convertit une date du [calendrier grégorien proleptique](https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar), sous forme de texte `YYYY-MM-DD`, en un numéro de [jour julien modifié](https://en.wikipedia.org/wiki/Julian_day#Variants) de type `Int32`. Cette fonction prend en charge les dates comprises entre `0000-01-01` et `9999-12-31`. Elle lève une exception si l'argument ne peut pas être interprété comme une date, ou si la date n'est pas valide.
**Syntaxe**
```sql theme={null}
toModifiedJulianDay(date)
```
**Arguments**
* `date` — La date au format String. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie le numéro de jour julien modifié. [`Int32`](/fr/reference/data-types/int-uint)
**Exemples**
**Convertir une date en numéro de jour julien modifié**
```sql title=Query theme={null}
SELECT toModifiedJulianDay('2020-01-01')
```
```response title=Response theme={null}
┌─toModifiedJulianDay('2020-01-01')─┐
│ 58849 │
└───────────────────────────────────┘
```
## toModifiedJulianDayOrNull
Introduit dans : v21.1.0
Similaire à [`toModifiedJulianDay()`](#toModifiedJulianDay), mais au lieu de déclencher des exceptions, elle renvoie `NULL`.
**Syntaxe**
```sql theme={null}
toModifiedJulianDayOrNull(date)
```
**Arguments**
* `date` — Date sous forme de texte. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
**Valeur renvoyée**
Renvoie le numéro de jour julien modifié si `date` est valide, sinon `null`. [`Nullable(Int32)`](/fr/reference/data-types/nullable)
**Exemples**
**Convertir une date en numéro de jour julien modifié avec gestion des valeurs nulles**
```sql title=Query theme={null}
SELECT toModifiedJulianDayOrNull('2020-01-01');
SELECT toModifiedJulianDayOrNull('0000-00-00'); -- invalid date, returns NULL
```
```response title=Response theme={null}
┌─toModifiedJu⋯020-01-01')─┐
│ 58849 │
└──────────────────────────┘
┌─toModifiedJu⋯000-00-00')─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
```
## toMonday
Introduit dans : v1.1.0
Arrondit à l'inférieur une date ou une date avec heure au lundi de la même semaine. Renvoie la date.
Le type de retour peut être configuré avec le paramètre [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toMonday(value)
```
**Arguments**
* `value` — date ou date avec heure à arrondir au lundi de la semaine. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la date du lundi de la même semaine pour la date ou date avec heure donnée. [`Date`](/fr/reference/data-types/date)
**Exemples**
**Arrondir au lundi de la semaine**
```sql title=Query theme={null}
SELECT
toMonday(toDateTime('2023-04-21 10:20:30')), -- A Friday
toMonday(toDate('2023-04-24')); -- Already a Monday
```
```response title=Response theme={null}
┌─toMonday(toDateTime('2023-04-21 10:20:30'))─┬─toMonday(toDate('2023-04-24'))─┐
│ 2023-04-17 │ 2023-04-24 │
└─────────────────────────────────────────────┴────────────────────────────────┘
```
## toMonth
Introduit dans : v1.1.0
Renvoie le mois (1-12) d'une valeur `Date` ou `DateTime`.
**Syntaxe**
```sql theme={null}
toMonth(datetime)
```
**Alias** : `MONTH`
**Arguments**
* `datetime` — Date ou date avec heure à partir de laquelle extraire le mois. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le mois de la date/heure donnée [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toMonth(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 4 │
└────────────────────────────────────────────┘
```
## toMonthNumSinceEpoch
Introduite dans : v25.3.0
Renvoie le nombre de mois écoulés depuis 1970
**Syntaxe**
```sql theme={null}
toMonthNumSinceEpoch(date)
```
**Arguments**
* `date` — Une date ou une date avec l'heure. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Entier positif
**Exemples**
**Exemple**
```sql title=Query theme={null}
SELECT toMonthNumSinceEpoch(toDate('2024-10-01'))
```
```response title=Response theme={null}
657
```
## toNanosecond
Introduit dans : v25.7.0
Renvoie la composante en nanosecondes (0-999999999) d’une valeur `DateTime64`.
**Syntaxe**
```sql theme={null}
toNanosecond(datetime)
```
**Alias** : `NANOSECOND`
**Arguments**
* `datetime` — Date et heure dont extraire la nanoseconde. [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la nanoseconde de la seconde (0 - 999999999) de `datetime`. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toNanosecond(toDateTime64('2023-04-21 10:20:30.123456789', 9));
```
```response title=Response theme={null}
┌─toNanosecond(toDateTime64('2023-04-21 10:20:30.123456789', 9))─┐
│ 123456789 │
└────────────────────────────────────────────────────────────────┘
```
## toQuarter
Introduit dans : v1.1.0
Renvoie le trimestre de l’année (de 1 à 4) pour une valeur `Date` ou `DateTime` donnée.
**Syntaxe**
```sql theme={null}
toQuarter(datetime)
```
**Alias** : `QUARTER`
**Arguments**
* `datetime` — Date ou date avec heure à partir de laquelle extraire le trimestre de l'année. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le trimestre de l'année pour la date/l'heure donnée [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toQuarter(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2 │
└──────────────────────────────────────────────┘
```
## toRelativeDayNum
Introduit dans : v1.1.0
Convertit une date ou une date avec heure en nombre de jours écoulés depuis un certain point fixe dans le passé.
Le moment exact correspondant est un détail d’implémentation, cette fonction n’est donc pas destinée à être utilisée seule.
La fonction sert principalement à calculer la différence en jours entre deux dates ou dates avec heure, par exemple `toRelativeDayNum(dt1) - toRelativeDayNum(dt2)`.
**Syntaxe**
```sql theme={null}
toRelativeDayNum(date)
```
**Arguments**
* `date` — Date ou date avec heure. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le nombre de jours écoulés depuis un point de référence fixe dans le passé. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Obtenir les numéros de jours relatifs**
```sql title=Query theme={null}
SELECT toRelativeDayNum(toDate('2023-04-01')) - toRelativeDayNum(toDate('2023-01-01'))
```
```response title=Response theme={null}
┌─minus(toRela⋯3-01-01')))─┐
│ 90 │
└──────────────────────────┘
```
## toRelativeHourNum
Introduit dans : v1.1.0
Convertit une date ou une date avec heure en nombre d'heures écoulées depuis un certain point fixe dans le passé.
Le moment exact est un détail d'implémentation ; cette fonction n'est donc pas destinée à être utilisée seule.
L'objectif principal de cette fonction est de calculer la différence en heures entre deux dates ou deux dates avec heure, par exemple `toRelativeHourNum(dt1) - toRelativeHourNum(dt2)`.
**Syntaxe**
```sql theme={null}
toRelativeHourNum(date)
```
**Arguments**
* `date` — Date ou date avec heure. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le nombre d’heures écoulées depuis un point de référence fixe dans le passé. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Obtenir les numéros d’heure relatifs**
```sql title=Query theme={null}
SELECT toRelativeHourNum(toDateTime('2023-01-01 12:00:00')) - toRelativeHourNum(toDateTime('2023-01-01 00:00:00')) AS hours_difference
```
```response title=Response theme={null}
┌─hours_difference─┐
│ 12 │
└──────────────────┘
```
## toRelativeMinuteNum
Introduit dans : v1.1.0
Convertit une date ou une date avec heure en nombre de minutes écoulées depuis un certain point fixe dans le passé.
Le moment exact est un détail d’implémentation, cette fonction n’est donc pas destinée à être utilisée seule.
Cette fonction sert principalement à calculer la différence en minutes entre deux dates ou dates avec heure, par exemple `toRelativeMinuteNum(dt1) - toRelativeMinuteNum(dt2)`.
**Syntaxe**
```sql theme={null}
toRelativeMinuteNum(date)
```
**Arguments**
* `date` — Date ou date avec heure. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le nombre de minutes écoulées depuis un point de référence fixe dans le passé. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Obtenir les numéros de minute relatifs**
```sql title=Query theme={null}
SELECT toRelativeMinuteNum(toDateTime('2023-01-01 00:30:00')) - toRelativeMinuteNum(toDateTime('2023-01-01 00:00:00')) AS minutes_difference
```
```response title=Response theme={null}
┌─minutes_difference─┐
│ 30 │
└────────────────────┘
```
## toRelativeMonthNum
Introduit dans : v1.1.0
Convertit une date ou une date avec heure en nombre de mois écoulés depuis un certain point fixe du passé.
Le moment exact est un détail d’implémentation ; cette fonction n’est donc pas destinée à être utilisée de manière autonome.
Cette fonction sert principalement à calculer la différence en mois entre deux dates ou deux dates avec heure, par exemple : `toRelativeMonthNum(dt1) - toRelativeMonthNum(dt2)`.
**Syntaxe**
```sql theme={null}
toRelativeMonthNum(date)
```
**Arguments**
* `date` — Date ou date avec heure. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le nombre de mois depuis un point de référence fixe dans le passé. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Récupérer les numéros relatifs des mois**
```sql title=Query theme={null}
SELECT toRelativeMonthNum(toDate('2023-04-01')) - toRelativeMonthNum(toDate('2023-01-01')) AS months_difference
```
```response title=Response theme={null}
┌─months_difference─┐
│ 3 │
└───────────────────┘
```
## toRelativeQuarterNum
Introduit dans : v1.1.0
Convertit une date ou une date avec heure en nombre de trimestres écoulés depuis un point fixe dans le passé.
Le point exact dans le temps est un détail d'implémentation, et cette fonction n'est donc pas destinée à être utilisée seule.
L'objectif principal de cette fonction est de calculer la différence en trimestres entre deux dates ou dates avec heure, par exemple : `toRelativeQuarterNum(dt1) - toRelativeQuarterNum(dt2)`.
**Syntaxe**
```sql theme={null}
toRelativeQuarterNum(date)
```
**Arguments**
* `date` — Date ou date avec heure. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le nombre de trimestres écoulés depuis un point de référence fixe dans le passé. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Obtenir les numéros de trimestre relatifs**
```sql title=Query theme={null}
SELECT toRelativeQuarterNum(toDate('2023-04-01')) - toRelativeQuarterNum(toDate('2023-01-01')) AS quarters_difference
```
```response title=Response theme={null}
┌─quarters_difference─┐
│ 1 │
└─────────────────────┘
```
## toRelativeSecondNum
Introduit dans : v1.1.0
Convertit une date ou une date avec heure en nombre de secondes écoulées depuis un certain point fixe dans le passé.
Le point exact dans le temps est un détail d’implémentation ; cette fonction n’est donc pas destinée à être utilisée seule.
L’objectif principal de la fonction est de calculer la différence en secondes entre deux dates ou deux dates avec heure, par exemple : `toRelativeSecondNum(dt1) - toRelativeSecondNum(dt2)`.
**Syntaxe**
```sql theme={null}
toRelativeSecondNum(date)
```
**Arguments**
* `date` — Date ou date avec heure. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le nombre de secondes écoulées depuis un point de référence fixe dans le passé. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Obtenir des numéros de secondes relatifs**
```sql title=Query theme={null}
SELECT toRelativeSecondNum(toDateTime('2023-01-01 00:01:00')) - toRelativeSecondNum(toDateTime('2023-01-01 00:00:00')) AS seconds_difference
```
```response title=Response theme={null}
┌─seconds_difference─┐
│ 60 │
└────────────────────┘
```
## toRelativeWeekNum
Disponible à partir de : v1.1.0
Convertit une date ou une date avec heure en nombre de semaines écoulées depuis un certain point fixe dans le passé.
Le point exact dans le temps est un détail d’implémentation ; cette fonction n’est donc pas destinée à être utilisée seule.
L’objectif principal de cette fonction est de calculer la différence en semaines entre deux dates ou dates avec heure, par exemple `toRelativeWeekNum(dt1) - toRelativeWeekNum(dt2)`.
**Syntaxe**
```sql theme={null}
toRelativeWeekNum(date)
```
**Arguments**
* `date` — Date ou date avec heure. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le nombre de semaines écoulées depuis un point de référence fixe dans le passé. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Obtenir les numéros de semaine relatifs**
```sql title=Query theme={null}
SELECT toRelativeWeekNum(toDate('2023-01-08')) - toRelativeWeekNum(toDate('2023-01-01')) AS weeks_difference
```
```response title=Response theme={null}
┌─weeks_difference─┐
│ 1 │
└──────────────────┘
```
## toRelativeYearNum
Introduit dans : v1.1.0
Convertit une date ou une date avec heure en nombre d'années écoulées depuis un point fixe donné dans le passé.
Le moment exact est un détail d'implémentation ; cette fonction n'est donc pas destinée à être utilisée
de manière autonome. Son objectif principal est de calculer la différence en années entre deux dates ou dates avec heure, par exemple `toRelativeYearNum(dt1) - toRelativeYearNum(dt2)`.
**Syntaxe**
```sql theme={null}
toRelativeYearNum(date)
```
**Arguments**
* `date` — Date ou date avec heure. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le nombre d'années depuis un point de référence fixe dans le passé. [`UInt16`](/fr/reference/data-types/int-uint)
**Exemples**
**Obtenir les numéros relatifs d'année**
```sql title=Query theme={null}
SELECT toRelativeYearNum('2010-10-01'::DateTime) - toRelativeYearNum('2000-01-01'::DateTime)
```
```response title=Response theme={null}
┌─minus(toRela⋯ateTime')))─┐
│ 10 │
└──────────────────────────┘
```
## toSecond
Introduit dans : v1.1.0
Renvoie la composante des secondes (0-59) d'une valeur `DateTime` ou `DateTime64`.
**Syntaxe**
```sql theme={null}
toSecond(datetime)
```
**Alias** : `SECOND`
**Arguments**
* `datetime` — Date et heure dont il faut extraire la seconde. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la seconde de la minute (0 à 59) de `datetime`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toSecond(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toSecond(toDateTime('2023-04-21 10:20:30'))─┐
│ 30 │
└─────────────────────────────────────────────┘
```
## toStartOfDay
Introduit dans : v1.1.0
Ramène à l’inférieur une date avec heure au début de la journée.
Le type de retour peut être configuré en définissant [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toStartOfDay(datetime)
```
**Arguments**
* `datetime` — Une date ou une date avec heure à arrondir. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime)
**Valeur renvoyée**
Renvoie la date avec heure arrondie à l’inférieur au début de la journée. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Arrondir à l’inférieur au début de la journée**
```sql title=Query theme={null}
SELECT toStartOfDay(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfDay(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-21 00:00:00 │
└─────────────────────────────────────────────────┘
```
## toStartOfFifteenMinutes
Introduit dans : v1.1.0
Arrondit à l'inférieur la date avec heure au début de l'intervalle de quinze minutes.
Le type de retour peut être configuré en définissant [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toStartOfFifteenMinutes(datetime)
```
**Arguments**
* `datetime` — Une date ou une date avec l’heure à arrondir. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la date avec l’heure arrondie au début de l’intervalle de quinze minutes le plus proche. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple**
```sql title=Query theme={null}
SELECT
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:17:00')),
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:20:00')),
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:15:00
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:15:00
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:15:00
```
## toStartOfFiveMinutes
Introduit dans : v22.6.0
Arrondit à l'inférieur une date avec heure au début de l'intervalle de cinq minutes le plus proche.
Le type de retour peut être configuré à l'aide du paramètre [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toStartOfFiveMinutes(datetime)
```
**Alias** : `toStartOfFiveMinute`
**Arguments**
* `datetime` — Une date et heure à arrondir. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la date et l'heure arrondies au début de l'intervalle de cinq minutes le plus proche. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple**
```sql title=Query theme={null}
SELECT
toStartOfFiveMinutes(toDateTime('2023-04-21 10:17:00')),
toStartOfFiveMinutes(toDateTime('2023-04-21 10:20:00')),
toStartOfFiveMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toStartOfFiveMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:15:00
toStartOfFiveMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:20:00
toStartOfFiveMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:20:00
```
## toStartOfHour
Introduit dans : v1.1.0
Arrondit à l’inférieur une date avec heure au début de l’heure.
Le type de retour peut être configuré en définissant [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toStartOfHour(datetime)
```
**Arguments**
* `datetime` — Une date et heure à arrondir. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la date et l’heure arrondie à l’inférieur au début de l’heure. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Arrondir à l’inférieur au début de l’heure**
```sql title=Query theme={null}
SELECT
toStartOfHour(toDateTime('2023-04-21 10:20:30'));
```
```response title=Response theme={null}
┌─────────────────res─┬─toTypeName(res)─┐
│ 2023-04-21 10:00:00 │ DateTime │
└─────────────────────┴─────────────────┘
```
## toStartOfISOYear
Introduite dans : v1.1.0
Ramène à l’inférieur une date ou une date avec heure au premier jour de l’année ISO, qui peut différer de l’année civile. Voir [ISO week date](https://en.wikipedia.org/wiki/ISO_week_date).
Le type de retour peut être configuré via le paramètre [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toStartOfISOYear(value)
```
**Arguments**
* `value` — La date ou date avec heure à arrondir à l’inférieur au premier jour de l'année ISO. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le premier jour de l'année ISO pour la date ou date avec heure donnée. [`Date`](/fr/reference/data-types/date)
**Exemples**
**Arrondir à l’inférieur au premier jour de l'année ISO**
```sql title=Query theme={null}
SELECT toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-01-02 │
└─────────────────────────────────────────────────────┘
```
## toStartOfInterval
Introduit dans : v20.1.0
Cette fonction généralise les autres fonctions `toStartOf*()` selon la syntaxe `toStartOfInterval(date_or_date_with_time, INTERVAL x unit [, time_zone])`.
Par exemple :
* `toStartOfInterval(t, INTERVAL 1 YEAR)` renvoie le même résultat que `toStartOfYear(t)`,
* `toStartOfInterval(t, INTERVAL 1 MONTH)` renvoie le même résultat que `toStartOfMonth(t)`,
* `toStartOfInterval(t, INTERVAL 1 DAY)` renvoie le même résultat que `toStartOfDay(t)`,
* `toStartOfInterval(t, INTERVAL 15 MINUTE)` renvoie le même résultat que `toStartOfFifteenMinutes(t)`.
Le calcul est effectué par rapport à des points de référence temporels précis :
| Interval | Début |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------- |
| YEAR | année 0 |
| QUARTER | 1900 T1 |
| MONTH | janvier 1900 |
| WEEK | 1970, 1re semaine (01-05) |
| DAY | 1970-01-01 |
| HOUR | (\*) |
| MINUTE | 1970-01-01 00:00:00 |
| SECOND | 1970-01-01 00:00:00 |
| MILLISECOND | 1970-01-01 00:00:00 |
| MICROSECOND | 1970-01-01 00:00:00 |
| NANOSECOND | 1970-01-01 00:00:00 |
| (\*) les intervalles en heures sont particuliers : le calcul est toujours effectué par rapport à 00:00:00 (minuit) du jour en cours. Par conséquent, seules | |
| les valeurs d’heure comprises entre 1 et 23 sont utiles. | |
Si l’unité `WEEK` est spécifiée, `toStartOfInterval` considère que les semaines commencent le lundi. Notez que ce comportement diffère de celui de la fonction `toStartOfWeek`, dans laquelle les semaines commencent par défaut le dimanche.
La seconde surcharge émule la fonction `time_bucket()` de TimescaleDB, ou, dans PostgreSQL, la fonction `date_bin()`.
**Syntaxe**
```sql theme={null}
toStartOfInterval(value, INTERVAL x unit[, time_zone])
toStartOfInterval(value, INTERVAL x unit[, origin[, time_zone]])
```
**Alias** : `time_bucket`, `date_bin`
**Arguments**
* `value` — Valeur de type Date ou date avec heure à arrondir à l’unité inférieure. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `x` — Nombre représentant la longueur de l’intervalle. - `unit` — Unité d’intervalle : YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE, SECOND, MILLISECOND, MICROSECOND, NANOSECOND. - `time_zone` — Facultatif. Nom du fuseau horaire sous forme de chaîne. - `origin` — Facultatif. Point d’origine du calcul (deuxième surcharge uniquement).
**Valeur renvoyée**
Renvoie le début de l’intervalle contenant la valeur en entrée. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Arrondi élémentaire d’un intervalle**
```sql title=Query theme={null}
SELECT toStartOfInterval(toDateTime('2023-01-15 14:30:00'), INTERVAL 1 MONTH)
```
```response title=Response theme={null}
┌─toStartOfInt⋯alMonth(1))─┐
│ 2023-01-01 │
└──────────────────────────┘
```
**Utilisation du point d’origine**
```sql title=Query theme={null}
SELECT toStartOfInterval(toDateTime('2023-01-01 14:45:00'), INTERVAL 1 MINUTE, toDateTime('2023-01-01 14:35:30'))
```
```response title=Response theme={null}
┌─toStartOfInt⋯14:35:30'))─┐
│ 2023-01-01 14:44:30 │
└──────────────────────────┘
```
## toStartOfMicrosecond
Introduit dans : v22.6.0
Arrondit à l'inférieur une date et heure au début des microsecondes.
**Syntaxe**
```sql theme={null}
toStartOfMicrosecond(datetime[, timezone])
```
**Arguments**
* `datetime` — Date et heure. [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Fuseau horaire de la valeur renvoyée. S’il n’est pas indiqué, la fonction utilise le fuseau horaire du paramètre `value`. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Valeur d’entrée avec des fractions de microseconde [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Requête sans fuseau horaire**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64);
```
```response title=Response theme={null}
┌────toStartOfMicrosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999000 │
└───────────────────────────────┘
```
**Requête avec fuseau horaire**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─toStartOfMicrosecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999999000 │
└─────────────────────────────────────────────┘
```
## toStartOfMillisecond
Introduit dans : v22.6.0
Arrondit à l’inférieur une date avec heure au début de la milliseconde.
**Syntaxe**
```sql theme={null}
toStartOfMillisecond(datetime[, timezone])
```
**Arguments**
* `datetime` — Date et heure. [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Fuseau horaire de la valeur renvoyée. S’il n’est pas précisé, la fonction utilise le fuseau horaire du paramètre `value`. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Valeur d’entrée avec des fractions de milliseconde. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Requête sans fuseau horaire**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64);
```
```response title=Response theme={null}
┌────toStartOfMillisecond(dt64)─┐
│ 2020-01-01 10:20:30.999000000 │
└───────────────────────────────┘
```
**Requête avec un fuseau horaire**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─toStartOfMillisecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999000000 │
└─────────────────────────────────────────────┘
```
## toStartOfMinute
Introduit dans : v1.1.0
Arrondit à l’inférieur une date avec heure au début de la minute.
Le type de retour peut être configuré via le paramètre [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toStartOfMinute(datetime)
```
**Arguments**
* `datetime` — Une date et une heure à arrondir. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la date et l'heure arrondies à l’inférieur au début de la minute. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Arrondir à l’inférieur au début de la minute**
```sql title=Query theme={null}
SELECT
toStartOfMinute(toDateTime('2023-04-21 10:20:30')),
toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8))
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toStartOfMinute(toDateTime('2023-04-21 10:20:30')): 2023-04-21 10:20:00
toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8)): 2023-04-21 10:20:00
```
## toStartOfMonth
Introduit dans : v1.1.0
Ramène à l’inférieur une date ou une date avec heure au premier jour du mois.
Le type de retour peut être configuré avec le paramètre [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toStartOfMonth(value)
```
**Arguments**
* `value` — La date ou la date avec heure à arrondir à l’inférieur au premier jour du mois. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le premier jour du mois pour la date ou la date avec heure donnée. [`Date`](/fr/reference/data-types/date)
**Exemples**
**Arrondir à l’inférieur au premier jour du mois**
```sql title=Query theme={null}
SELECT toStartOfMonth(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└───────────────────────────────────────────────────┘
```
## toStartOfNanosecond
Introduit dans : v22.6.0
Arrondit à l’inférieur une date et heure à la nanoseconde.
**Syntaxe**
```sql theme={null}
toStartOfNanosecond(datetime[, timezone])
```
**Arguments**
* `datetime` — Date et heure. [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Fuseau horaire de la valeur de retour. S’il n’est pas spécifié, la fonction utilise celui du paramètre `value`. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Valeur d’entrée avec des nanosecondes. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Requête sans fuseau horaire**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64);
```
```response title=Response theme={null}
┌─────toStartOfNanosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999999 │
└───────────────────────────────┘
```
**Requête avec fuseau horaire**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─toStartOfNanosecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999999999 │
└────────────────────────────────────────────┘
```
## toStartOfQuarter
Introduit dans : v1.1.0
Ramène à l’inférieur une date ou une date avec heure au premier jour du trimestre. Le premier jour du trimestre est le 1er janvier, le 1er avril, le 1er juillet ou le 1er octobre.
Le type de retour peut être configuré via le paramètre [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toStartOfQuarter(value)
```
**Arguments**
* `value` — La date ou la date avec heure à ramener à l’inférieur au premier jour du trimestre. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le premier jour du trimestre correspondant à la date ou à la date avec heure donnée. [`Date`](/fr/reference/data-types/date)
**Exemples**
**Ramener à l’inférieur au premier jour du trimestre**
```sql title=Query theme={null}
SELECT toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└─────────────────────────────────────────────────────┘
```
## toStartOfSecond
Introduit dans : v20.5.0
Arrondit à l’inférieur une date et heure au début de la seconde.
**Syntaxe**
```sql theme={null}
toStartOfSecond(datetime[, timezone])
```
**Arguments**
* `datetime` — Date et heure dont il faut tronquer les fractions de seconde. [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Fuseau horaire de la valeur renvoyée. S’il n’est pas spécifié, la fonction utilise le fuseau horaire du paramètre `value`. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la valeur d’entrée sans fractions de seconde. [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Requête sans fuseau horaire**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64);
```
```response title=Response theme={null}
┌───toStartOfSecond(dt64)─┐
│ 2020-01-01 10:20:30.000 │
└─────────────────────────┘
```
**Requête avec fuseau horaire**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─toStartOfSecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 13:20:30.000 │
└────────────────────────────────────────┘
```
## toStartOfTenMinutes
Introduit dans : v20.1.0
Arrondit une date avec heure à l’inférieur jusqu’au début de l’intervalle de dix minutes le plus proche.
Le type de retour peut être configuré en définissant [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toStartOfTenMinutes(datetime)
```
**Arguments**
* `datetime` — Une date et heure. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie la date et heure arrondie au début de l’intervalle de dix minutes le plus proche. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple**
```sql title=Query theme={null}
SELECT
toStartOfTenMinutes(toDateTime('2023-04-21 10:17:00')),
toStartOfTenMinutes(toDateTime('2023-04-21 10:20:00')),
toStartOfTenMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toStartOfTenMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:10:00
toStartOfTenMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:20:00
toStartOfTenMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:20:00
```
## toStartOfWeek
Introduit dans : v20.1.0
Ramène une date ou une date avec heure au dimanche ou au lundi précédent le plus proche.
Le type de retour peut être configuré en définissant [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toStartOfWeek(datetime[, mode[, timezone]])
```
**Arguments**
* `datetime` — Une date, avec ou sans heure, à convertir. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `mode` — Détermine le premier jour de la semaine comme décrit dans la fonction `toWeek()`. Valeur par défaut : `0`. [`UInt8`](/fr/reference/data-types/int-uint)
* `timezone` — Le fuseau horaire à utiliser pour la conversion. S’il n’est pas spécifié, le fuseau horaire du serveur est utilisé. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la date du dimanche ou du lundi le plus proche, égale ou antérieure à la date donnée, selon le mode. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32)
**Exemples**
**Arrondir à la baisse au dimanche ou au lundi le plus proche**
```sql title=Query theme={null}
SELECT
toStartOfWeek(toDateTime('2023-04-21 10:20:30')), /* a Friday */
toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* a Friday */
toStartOfWeek(toDate('2023-04-24')), /* a Monday */
toStartOfWeek(toDate('2023-04-24'), 1) /* a Monday */
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toStartOfWeek(toDateTime('2023-04-21 10:20:30')): 2023-04-17
toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-17
toStartOfWeek(toDate('2023-04-24')): 2023-04-24
toStartOfWeek(toDate('2023-04-24'), 1): 2023-04-24
```
## toStartOfYear
Introduit dans : v1.1.0
Ramène une date ou une date avec heure au premier jour de l’année. Renvoie la date sous forme d’objet `Date`.
Le type de retour peut être configuré via le paramètre [`enable_extended_results_for_datetime_functions`](/fr/reference/settings/session-settings#enable_extended_results_for_datetime_functions).
**Syntaxe**
```sql theme={null}
toStartOfYear(value)
```
**Arguments**
* `value` — La date ou la date avec heure à arrondir vers le bas. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le premier jour de l'année pour la date/l'heure donnée [`Date`](/fr/reference/data-types/date)
**Exemples**
**Arrondir vers le bas au premier jour de l'année**
```sql title=Query theme={null}
SELECT toStartOfYear(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-01-01 │
└──────────────────────────────────────────────────┘
```
## toTimeWithFixedDate
Introduit dans : v1.1.0
Extrait la composante horaire d'une date ou d'une date avec heure.
Le résultat renvoyé est un décalage par rapport à un instant fixe, actuellement `1970-01-02`,
mais l'instant exact est un détail d'implémentation susceptible d'évoluer à l'avenir.
`toTime` ne doit donc pas être utilisé seul.
La fonction sert principalement à calculer la différence horaire entre deux dates ou deux dates avec heure, par exemple `toTime(dt1) - toTime(dt2)`.
**Syntaxe**
```sql theme={null}
toTimeWithFixedDate(date[, timezone])
```
**Arguments**
* `date` — Date à convertir en heure. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Fuseau horaire de la valeur renvoyée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la composante heure d'une date ou d'une date avec heure, sous la forme d'un décalage par rapport à un point fixe dans le temps (actuellement 1970-01-02). [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Calculer l'écart horaire entre deux dates**
```sql title=Query theme={null}
SELECT toTimeWithFixedDate('2025-06-15 12:00:00'::DateTime) - toTimeWithFixedDate('2024-05-10 11:00:00'::DateTime) AS result, toTypeName(result)
```
```response title=Response theme={null}
┌─result─┬─toTypeName(result)─┐
│ 3600 │ Int32 │
└────────┴────────────────────┘
```
## toTimezone
Introduit dans : v1.1.0
Convertit un `DateTime` ou `DateTime64` vers le fuseau horaire spécifié.
La valeur interne (nombre de secondes Unix) des données ne change pas.
Seuls l’attribut de fuseau horaire de la valeur et sa représentation sous forme de chaîne changent.
**Syntaxe**
```sql theme={null}
toTimezone(datetime, timezone)
```
**Alias** : `toTimeZone`
**Arguments**
* `date` — La valeur à convertir. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Le nom du fuseau horaire cible. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le même horodatage que la valeur d’entrée, mais avec le fuseau horaire spécifié [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toDateTime('2019-01-01 00:00:00', 'UTC') AS time_utc,
toTypeName(time_utc) AS type_utc,
toInt32(time_utc) AS int32utc,
toTimezone(time_utc, 'Asia/Yekaterinburg') AS time_yekat,
toTypeName(time_yekat) AS type_yekat,
toInt32(time_yekat) AS int32yekat,
toTimezone(time_utc, 'US/Samoa') AS time_samoa,
toTypeName(time_samoa) AS type_samoa,
toInt32(time_samoa) AS int32samoa
FORMAT Vertical;
```
```response title=Response theme={null}
Row 1:
──────
time_utc: 2019-01-01 00:00:00
type_utc: DateTime('UTC')
int32utc: 1546300800
time_yekat: 2019-01-01 05:00:00
type_yekat: DateTime('Asia/Yekaterinburg')
int32yekat: 1546300800
time_samoa: 2018-12-31 13:00:00
type_samoa: DateTime('US/Samoa')
int32samoa: 1546300800
```
## toUTCTimestamp
Introduit dans : v23.8.0
Convertit une valeur de date ou de date avec heure d'un fuseau horaire vers un timestamp UTC. Cette fonction est principalement incluse pour la compatibilité avec Apache Spark et des frameworks similaires.
**Syntaxe**
```sql theme={null}
toUTCTimestamp(datetime, time_zone)
```
**Alias** : `to_utc_timestamp`
**Arguments**
* `datetime` — Une valeur constante de type date ou date et heure, ou une expression. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `time_zone` — Une valeur constante de type String ou une expression représentant le fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une date ou une date et heure dans le fuseau horaire UTC. [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Exemples**
**Convertir un fuseau horaire en UTC**
```sql title=Query theme={null}
SELECT toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')
```
```response title=Response theme={null}
┌─toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')─┐
│ 2023-03-15 16:00:00 │
└─────────────────────────────────────────────────────────┘
```
## toUnixTimestamp
Introduit dans : v1.1.0
Convertit une `String`, une `Date` ou une `DateTime` en timestamp Unix (nombre de secondes écoulées depuis `1970-01-01 00:00:00 UTC`) au format `UInt32`.
**Syntaxe**
```sql theme={null}
toUnixTimestamp(date[, timezone])
```
**Arguments**
* `date` — Valeur à convertir. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64) ou [`String`](/fr/reference/data-types/string)
* `timezone` — Facultatif. Fuseau horaire à utiliser pour la conversion. S’il n’est pas spécifié, le fuseau horaire du serveur est utilisé. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le timestamp Unix. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT
'2017-11-05 08:07:47' AS dt_str,
toUnixTimestamp(dt_str) AS from_str,
toUnixTimestamp(dt_str, 'Asia/Tokyo') AS from_str_tokyo,
toUnixTimestamp(toDateTime(dt_str)) AS from_datetime,
toUnixTimestamp(toDateTime64(dt_str, 0)) AS from_datetime64,
toUnixTimestamp(toDate(dt_str)) AS from_date,
toUnixTimestamp(toDate32(dt_str)) AS from_date32
FORMAT Vertical;
```
```response title=Response theme={null}
Row 1:
──────
dt_str: 2017-11-05 08:07:47
from_str: 1509869267
from_str_tokyo: 1509836867
from_datetime: 1509869267
from_datetime64: 1509869267
from_date: 1509840000
from_date32: 1509840000
```
## toWeek
Introduit dans : v20.1.0
Cette fonction renvoie le numéro de semaine d’une date ou d’une valeur DateTime. La forme à deux arguments de `toWeek()` permet d’indiquer si la semaine commence
le dimanche ou le lundi, et si la valeur renvoyée doit être comprise entre `0` et `53` ou entre `1` et `53`.
[`toISOWeek()`](#toWeek) est une fonction de compatibilité équivalente à `toWeek(date,3)`.
Le tableau suivant décrit le fonctionnement de l’argument mode.
| Mode | Premier jour de la semaine | Plage | La semaine 1 est la première semaine ... |
| ---- | -------------------------- | ----- | ---------------------------------------- |
| 0 | Dimanche | 0-53 | avec un dimanche dans cette année |
| 1 | Lundi | 0-53 | avec 4 jours ou plus dans cette année |
| 2 | Dimanche | 1-53 | avec un dimanche dans cette année |
| 3 | Lundi | 1-53 | avec 4 jours ou plus dans cette année |
| 4 | Dimanche | 0-53 | avec 4 jours ou plus dans cette année |
| 5 | Lundi | 0-53 | avec un lundi dans cette année |
| 6 | Dimanche | 1-53 | avec 4 jours ou plus dans cette année |
| 7 | Lundi | 1-53 | avec un lundi dans cette année |
| 8 | Dimanche | 1-53 | contient le 1er janvier |
| 9 | Lundi | 1-53 | contient le 1er janvier |
Pour les valeurs de mode correspondant à "avec 4 jours ou plus dans cette année", les semaines sont numérotées conformément à la norme ISO 8601:1988 :
* Si la semaine contenant le 1er janvier compte 4 jours ou plus dans la nouvelle année, c’est la semaine 1.
* Sinon, c’est la dernière semaine de l’année précédente, et la semaine suivante est la semaine 1.
Pour les valeurs de mode correspondant à "contient le 1er janvier", la semaine qui contient le 1er janvier est la semaine 1.
Le nombre de jours de la nouvelle année contenus dans la semaine n’a pas d’importance, même s’il n’y en a qu’un seul.
Autrement dit, si la dernière semaine de décembre contient le 1er janvier de l’année suivante, elle sera la semaine 1 de l’année suivante.
Le premier argument peut également être spécifié sous forme de [`String`](/fr/reference/data-types/string) dans un format pris en charge par [`parseDateTime64BestEffort()`](/fr/reference/functions/regular-functions/type-conversion-functions#parseDateTime64BestEffort). La prise en charge des arguments de type chaîne n’existe que pour des raisons de compatibilité avec MySQL, requise par certains outils tiers. Comme la prise en charge des arguments de type chaîne pourrait à l’avenir dépendre de nouveaux paramètres de compatibilité MySQL, et que l’analyse de chaînes est généralement lente, il est recommandé de ne pas l’utiliser.
**Syntaxe**
```sql theme={null}
toWeek(datetime[, mode[, time_zone]])
```
**Alias** : `week`
**Arguments**
* `datetime` — Date ou date avec heure dont extraire le numéro de semaine. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime)
* `mode` — Facultatif. Un mode de `0` à `9` détermine le premier jour de la semaine et la plage du numéro de semaine. Valeur par défaut : `0`. - `time_zone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le numéro de semaine selon le mode spécifié. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Obtenir les numéros de semaine selon différents modes**
```sql title=Query theme={null}
SELECT toDate('2016-12-27') AS date, toWeek(date) AS week0, toWeek(date,1) AS week1, toWeek(date,9) AS week9
```
```response title=Response theme={null}
┌───────date─┬─week0─┬─week1─┬─week9─┐
│ 2016-12-27 │ 52 │ 52 │ 1 │
└────────────┴───────┴───────┴───────┘
```
## toYYYYMM
Introduit dans : v1.1.0
Convertit une date ou une date avec heure en un nombre `UInt32` contenant l'année et le numéro du mois (YYYY \* 100 + MM).
Accepte un deuxième argument optionnel `timezone`. S'il est fourni, `timezone` doit être une constante de chaîne.
Cette fonction est l'opposé de la fonction `YYYYMMDDToDate()`.
**Syntaxe**
```sql theme={null}
toYYYYMM(datetime[, timezone])
```
**Arguments**
* `datetime` — Une date ou une date avec heure à convertir. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Fuseau horaire à utiliser pour la conversion. S’il est fourni, le fuseau horaire doit être une constante de chaîne. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un nombre UInt32 contenant l’année et le numéro du mois (YYYY \* 100 + MM). [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Convertir la date actuelle au format YYYYMM**
```sql title=Query theme={null}
SELECT toYYYYMM(now(), 'US/Eastern')
```
```response title=Response theme={null}
┌─toYYYYMM(now(), 'US/Eastern')─┐
│ 202303 │
└───────────────────────────────┘
```
## toYYYYMMDD
Introduit dans : v1.1.0
Convertit une date ou une date avec heure en un nombre `UInt32` contenant l’année, le mois et le jour (YYYY \* 10000 + MM \* 100 + DD). Accepte un second argument de fuseau horaire facultatif. S’il est fourni, le fuseau horaire doit être une constante de chaîne.
**Syntaxe**
```sql theme={null}
toYYYYMMDD(datetime[, timezone])
```
**Arguments**
* `datetime` — Une date ou une date avec composante horaire à convertir. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Fuseau horaire pour la conversion. S'il est indiqué, le fuseau horaire doit être une constante de chaîne de caractères. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un nombre `UInt32` contenant l'année, le mois et le jour (YYYY \* 10000 + MM \* 100 + DD). [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Convertir la date actuelle au format YYYYMMDD**
```sql title=Query theme={null}
SELECT toYYYYMMDD(now(), 'US/Eastern')
```
```response title=Response theme={null}
┌─toYYYYMMDD(now(), 'US/Eastern')─┐
│ 20230302 │
└─────────────────────────────────┘
```
## toYYYYMMDDhhmmss
Introduit dans : v1.1.0
Convertit une date ou une date avec heure en un nombre `UInt64` contenant l’année, le mois, le jour, l’heure, les minutes et les secondes (YYYY \* 10000000000 + MM \* 100000000 + DD \* 1000000 + hh \* 10000 + mm \* 100 + ss).
Accepte un second argument facultatif de fuseau horaire. S’il est fourni, le fuseau horaire doit être une constante de chaîne.
**Syntaxe**
```sql theme={null}
toYYYYMMDDhhmmss(datetime[, timezone])
```
**Arguments**
* `datetime` — Date ou date avec heure à convertir. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `timezone` — Facultatif. Fuseau horaire pour la conversion. S’il est fourni, le fuseau horaire doit être une constante de chaîne. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un nombre `UInt64` contenant l’année, le mois, le jour, l’heure, la minute et la seconde (YYYY \* 10000000000 + MM \* 100000000 + DD \* 1000000 + hh \* 10000 + mm \* 100 + ss). [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Convertir la date et l’heure actuelles au format YYYYMMDDhhmmss**
```sql title=Query theme={null}
SELECT toYYYYMMDDhhmmss(now(), 'US/Eastern')
```
```response title=Response theme={null}
┌─toYYYYMMDDhhmmss(now(), 'US/Eastern')─┐
│ 20230302112209 │
└───────────────────────────────────────┘
```
## toYear
Introduit dans : v1.1.0
Renvoie l’année (ap. J.-C.) d’une valeur `Date` ou `DateTime`.
**Syntaxe**
```sql theme={null}
toYear(datetime)
```
**Alias** : `YEAR`
**Arguments**
* `datetime` — Date ou date avec heure à partir de laquelle extraire l’année. [`Date`](/fr/reference/data-types/date) ou [`Date32`](/fr/reference/data-types/date32) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie l’année de la valeur [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) donnée. [`UInt16`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toYear(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023 │
└───────────────────────────────────────────┘
```
## toYearNumSinceEpoch
Introduit dans : v25.3.0
Renvoie le nombre d'années écoulées depuis 1970
**Syntaxe**
```sql theme={null}
toYearNumSinceEpoch(date)
```
**Arguments**
* `date` — Une date ou une date et heure à convertir. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Entier positif
**Exemples**
**Exemple**
```sql title=Query theme={null}
SELECT toYearNumSinceEpoch(toDate('2024-10-01'))
```
```response title=Response theme={null}
54
```
## toYearWeek
Introduit dans : v20.1.0
Renvoie l’année et la semaine correspondant à une date. L’année du résultat peut être différente de celle de l’argument date pour la première et la dernière semaine de l’année.
L’argument mode fonctionne comme celui de [`toWeek()`](/fr/reference/functions/regular-functions/date-time-functions#toWeek).
Avertissement : le numéro de semaine renvoyé par `toYearWeek()` peut être différent de celui renvoyé par `toWeek()`. `toWeek()` renvoie toujours le numéro de semaine dans le contexte de l’année donnée, et si `toWeek()` renvoie `0`, `toYearWeek()` renvoie la valeur correspondant à la dernière semaine de l’année précédente. Voir `prev_yearWeek` dans l’exemple ci-dessous.
Le premier argument peut aussi être spécifié sous forme de [`String`](/fr/reference/data-types/string), dans un format pris en charge par [`parseDateTime64BestEffort()`](/fr/reference/functions/regular-functions/type-conversion-functions#parseDateTime64BestEffort). La prise en charge des arguments de type chaîne n’existe que pour des raisons de compatibilité avec MySQL, requise par certains outils tiers. Comme cette prise en charge pourrait à l’avenir dépendre de nouveaux paramètres de compatibilité MySQL et que l’analyse de chaînes est généralement lente, il est recommandé de ne pas l’utiliser.
**Syntaxe**
```sql theme={null}
toYearWeek(datetime[, mode[, timezone]])
```
**Alias** : `yearweek`
**Arguments**
* `datetime` — Date ou date avec heure pour laquelle obtenir l’année et le numéro de semaine. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime)
* `mode` — Facultatif. Une valeur de `0` à `9` qui détermine le premier jour de la semaine et la plage du numéro de semaine. Valeur par défaut : `0`. - `timezone` — Facultatif. Fuseau horaire. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie l’année et le numéro de semaine sous la forme d’une valeur entière combinée. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Obtenir des combinaisons année-semaine avec différents modes**
```sql title=Query theme={null}
SELECT toDate('2016-12-27') AS date, toYearWeek(date) AS yearWeek0, toYearWeek(date,1) AS yearWeek1, toYearWeek(date,9) AS yearWeek9, toYearWeek(toDate('2022-01-01')) AS prev_yearWeek
```
```response title=Response theme={null}
┌───────date─┬─yearWeek0─┬─yearWeek1─┬─yearWeek9─┬─prev_yearWeek─┐
│ 2016-12-27 │ 201652 │ 201652 │ 201701 │ 202152 │
└────────────┴───────────┴───────────┴───────────┴───────────────┘
```
## today
Introduit dans : v1.1.0
Renvoie la date du jour au moment de l’analyse de la requête. Équivalent à `toDate(now())`.
**Syntaxe**
```sql theme={null}
today()
```
**Alias** : `curdate`, `current_date`
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie la date actuelle [`Date`](/fr/reference/data-types/date)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT today() AS today, curdate() AS curdate, current_date() AS current_date FORMAT Pretty
```
```response title=Response theme={null}
┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ today ┃ curdate ┃ current_date ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-03 │ 2025-03-03 │ 2025-03-03 │
└────────────┴────────────┴──────────────┘
```
**Syntaxe SQL standard sans parenthèses**
```sql title=Query theme={null}
SELECT TODAY, CURDATE,CURRENT_DATE
```
```response title=Response theme={null}
┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ TODAY ┃ CURDATE ┃ CURRENT_DATE ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-04 │ 2025-03-04 │ 2025-03-04 │
└────────────┴────────────┴──────────────┘
```
## yesterday
Introduit dans : v1.1.0
N’accepte aucun argument et renvoie la date d’hier à un moment de l’analyse de la requête.
**Syntaxe**
```sql theme={null}
yesterday()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie la date d’hier. [`Date`](/fr/reference/data-types/date)
**Exemples**
**Récupérer la date d’hier**
```sql title=Query theme={null}
SELECT yesterday();
SELECT today() - 1;
```
```response title=Response theme={null}
┌─yesterday()─┐
│ 2025-06-09 │
└─────────────┘
┌─minus(today(), 1)─┐
│ 2025-06-09 │
└───────────────────┘
```