Fonctions de manipulation des dates et des heures

Documentation des 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

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

┌────────────────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.

​

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 est l’usage recommandé.

Syntaxe

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

Exemples

Obtenir l’horodatage UTC actuel

Query

SELECT UTCTimestamp()

Response

┌──────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(). Le résultat est indéfini si l’entrée n’encode pas une valeur Date valide.

Syntaxe

YYYYMMDDToDate(YYYYMMDD)

Arguments

• YYYYMMDD — Nombre contenant l’année, le mois et le jour. (U)Int* ou Float* ou Decimal

Valeur renvoyée

Renvoie une valeur Date à partir des arguments fournis Date

Exemples

Exemple

Query

SELECT YYYYMMDDToDate(20230911);

Response

┌─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(). Le résultat est indéfini si l’entrée n’encode pas une valeur Date32 valide.

Syntaxe

YYYYMMDDToDate32(YYYYMMDD)

Arguments

• YYYYMMDD — Nombre contenant l’année, le mois et le jour. (U)Int* ou Float* ou Decimal

Valeur renvoyée

Renvoie une valeur Date32 à partir des arguments fournis Date32

Exemples

Exemple

Query

SELECT YYYYMMDDToDate32(20000507);

Response

┌─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(). Le résultat est indéfini si l’entrée n’encode pas une valeur DateTime valide.

Syntaxe

YYYYMMDDhhmmssToDateTime(YYYYMMDDhhmmss[, timezone])

Arguments

• YYYYMMDDhhmmss — Nombre contenant l’année, le mois, le jour, l’heure, les minutes et les secondes. (U)Int* ou Float* ou Decimal
• timezone — Nom du fuseau horaire. String

Valeur renvoyée

Renvoie une valeur DateTime à partir des arguments fournis DateTime

Exemples

Exemple

Query

SELECT YYYYMMDDToDateTime(20230911131415);

Response

┌──────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(). La sortie est indéfinie si l’entrée n’encode pas une valeur DateTime64 valide.

Syntaxe

YYYYMMDDhhmmssToDateTime64(YYYYMMDDhhmmss[, precision[, timezone]])

Arguments

• YYYYMMDDhhmmss — Nombre contenant l’année, le mois, le jour, l’heure, la minute et la seconde. (U)Int* ou Float* ou Decimal
• precision — Précision de la partie fractionnaire (0-9). UInt8
• timezone — Nom du fuseau horaire. String

Valeur renvoyée

Renvoie une valeur DateTime64 à partir des arguments fournis DateTime64

Exemples

Exemple

Query

SELECT YYYYMMDDhhmmssToDateTime64(20230911131415, 3, 'Asia/Istanbul');

Response

┌─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

addDate(datetime, interval)

Arguments

• datetime — La date ou la date et heure à laquelle interval est ajouté. Date ou Date32 ou DateTime ou DateTime64 ou String
• interval — Intervalle à ajouter. Interval

Valeur renvoyée

Renvoie la date ou la date et heure obtenue en ajoutant interval à datetime. Date ou Date32 ou DateTime ou DateTime64

Exemples

Ajouter un intervalle à une date

Query

SELECT addDate(toDate('2018-01-01'), INTERVAL 3 YEAR)

Response

┌─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

addDays(datetime, num)

Arguments

• datetime — Date ou date et heure à laquelle ajouter le nombre de jours spécifié. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre de jours à ajouter. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime plus num jours. Date ou Date32 ou DateTime ou DateTime64

Exemples

Ajouter des jours à différents types de dates

Query

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

┌─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

Query

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 day)

Response

┌─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

addHours(datetime, num)

Arguments

• datetime — Date ou date et heure à laquelle ajouter le nombre d’heures spécifié. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre d’heures à ajouter. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime plus num heures DateTime ou DateTime64(3)

Exemples

Ajouter des heures à différents types de date

Query

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

┌─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

Query

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 hour)

Response

┌─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

addInterval(interval_1, interval_2)

Arguments

• interval_1 — Premier intervalle ou tuple d’intervalles. Interval ou Tuple(Interval)
• interval_2 — Deuxième intervalle à ajouter. Interval

Valeur renvoyée

Renvoie un tuple d’intervalles Tuple(Interval)

Exemples

Ajouter des intervalles

Query

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

┌─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

addMicroseconds(datetime, num)

Arguments

• datetime — Date et heure auxquelles ajouter le nombre spécifié de microsecondes. DateTime ou DateTime64 ou String
• num — Nombre de microsecondes à ajouter. (U)Int* ou Float*

Valeur renvoyée

Renvoie date_time avec num microsecondes ajoutées DateTime64

Exemples

Ajouter des microsecondes à différents types de date et heure

Query

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

┌─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

Query

SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 microsecond)

Response

┌─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

addMilliseconds(datetime, num)

Arguments

• datetime — Date et heure auxquelles ajouter le nombre spécifié de millisecondes. DateTime ou DateTime64 ou String
• num — Nombre de millisecondes à ajouter. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime plus num millisecondes DateTime64

Exemples

Ajouter des millisecondes à différents types de date et heure

Query

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

┌─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

Query

SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 millisecond)

Response

┌─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

addMinutes(datetime, num)

Arguments

• datetime — Date ou date et heure à laquelle ajouter le nombre de minutes spécifié. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre de minutes à ajouter. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime plus num minutes. DateTime ou DateTime64(3)

Exemples

Ajouter des minutes à différents types de dates

Query

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

┌─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

Query

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 minute)

Response

┌─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

addMonths(datetime, num)

Arguments

• datetime — Date ou date et heure à laquelle ajouter le nombre de mois spécifié. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre de mois à ajouter. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime plus num mois. Date ou Date32 ou DateTime ou DateTime64

Exemples

Ajouter des mois à différents types de date

Query

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

┌─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

Query

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 month)

Response

┌─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

addNanoseconds(datetime, num)

Arguments

• datetime — Date et heure auxquelles ajouter le nombre spécifié de nanosecondes. DateTime ou DateTime64 ou String
• num — Nombre de nanosecondes à ajouter. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime plus num nanosecondes DateTime64

Exemples

Ajouter des nanosecondes à différents types date-heure

Query

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

┌─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

Query

SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 1000 nanosecond)

Response

┌─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

addQuarters(datetime, num)

Arguments

• datetime — Date ou date et heure à laquelle ajouter le nombre de trimestres spécifié. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre de trimestres à ajouter. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime plus num trimestres Date ou Date32 ou DateTime ou DateTime64

Exemples

Ajouter des trimestres à différents types de dates

Query

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

┌─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

Query

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 quarter)

Response

┌─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

addSeconds(datetime, num)

Arguments

• datetime — Date ou date et heure à laquelle ajouter le nombre de secondes spécifié. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre de secondes à ajouter. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime plus num secondes DateTime ou DateTime64(3)

Exemples

Ajouter des secondes à différents types de date

Query

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

┌─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

Query

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 second)

Response

┌─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

addTupleOfIntervals(datetime, intervals)

Arguments

• datetime — Date ou date avec heure à laquelle ajouter les intervalles. Date ou Date32 ou DateTime ou DateTime64
• intervals — Tuple d’intervalles à ajouter à datetime. Tuple(Interval)

Valeur renvoyée

Renvoie date après ajout des intervals Date ou Date32 ou DateTime ou DateTime64

Exemples

Ajouter un tuple d’intervalles à une date

Query

WITH toDate('2018-01-01') AS date
SELECT addTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 MONTH, INTERVAL 1 YEAR))

Response

┌─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

addWeeks(datetime, num)

Arguments

• datetime — Date ou date avec heure à laquelle ajouter le nombre de semaines indiqué. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre de semaines à ajouter. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime plus num semaines. Date ou Date32 ou DateTime ou DateTime64

Exemples

Ajouter des semaines à différents types de dates

Query

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

┌─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

Query

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 week)

Response

┌─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

addYears(datetime, num)

Arguments

• datetime — Date ou date avec heure à laquelle ajouter le nombre d’années spécifié. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre d’années à ajouter. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime plus num ans. Date ou Date32 ou DateTime ou DateTime64

Exemples

Ajouter des années à différents types de dates

Query

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

┌─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

Query

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 year)

Response

┌─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.

Syntaxe

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 ou Date32 ou DateTime ou DateTime64
• enddate — Deuxième valeur temporelle à partir de laquelle soustraire (le terme duquel on soustrait). Date ou Date32 ou DateTime ou 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

Valeur renvoyée

La différence entre enddate et startdate, exprimée en unit. Int32

Exemples

Calcul de l’âge en heures

Query

SELECT age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))

Response

┌─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

Query

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

┌──────────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

changeDay(date_or_datetime, value)

Arguments

• date_or_datetime — La valeur à modifier. Date ou Date32 ou DateTime ou DateTime64
• value — La nouvelle valeur. (U)Int*

Valeur renvoyée

Renvoie une valeur du même type que date_or_datetime dont la composante de jour a été modifiée. Date ou Date32 ou DateTime ou DateTime64

Exemples

Exemple d’utilisation

Query

SELECT changeDay('2024-01-31'::DateTime, 15)

Response

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

changeHour(date_or_datetime, value)

Arguments

• date_or_datetime — La valeur à modifier. Date ou Date32 ou DateTime ou DateTime64
• value — La nouvelle valeur. (U)Int*

Valeur renvoyée

Renvoie une valeur du même type que date_or_datetime, avec la composante heure modifiée. DateTime ou DateTime64

Exemples

Exemple d’utilisation

Query

SELECT changeHour('2024-01-01 12:00:00'::DateTime, 5)

Response

2024-01-01 05:00:00

​

changeMinute

Introduit dans : v24.7.0

Modifie la composante minute d’une date ou date/heure.

Syntaxe

changeMinute(date_or_datetime, value)

Arguments

• date_or_datetime — Valeur à modifier. Date ou Date32 ou DateTime ou DateTime64
• value — Nouvelle valeur. (U)Int*

Valeur renvoyée

Renvoie une valeur du même type que date_or_datetime, dont la composante minute est modifiée. DateTime ou DateTime64

Exemples

Exemple d’utilisation

Query

SELECT changeMinute('2024-01-01 12:30:00'::DateTime, 45)

Response

2024-01-01 12:45:00

​

changeMonth

Introduit dans : v24.7.0

Modifie le mois d’une date ou d’une date-heure.

Syntaxe

changeMonth(date_or_datetime, value)

Arguments

• date_or_datetime — Valeur à modifier. Date ou Date32 ou DateTime ou DateTime64
• value — Nouvelle valeur. (U)Int*

Valeur renvoyée

Renvoie une valeur du même type que date_or_datetime dont le mois a été modifié. Date ou Date32 ou DateTime ou DateTime64

Exemples

Exemple d’utilisation

Query

SELECT changeMonth('2024-01-01'::DateTime, 12)

Response

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

changeSecond(date_or_datetime, value)

Arguments

• date_or_datetime — La valeur à modifier. Date ou Date32 ou DateTime ou DateTime64
• value — La nouvelle valeur. (U)Int*

Valeur renvoyée

Renvoie une valeur du même type que date_or_datetime dont la composante des secondes est modifiée. DateTime ou DateTime64

Exemples

Exemple d’utilisation

Query

SELECT changeSecond('2024-01-01 12:30:45'::DateTime, 15)

Response

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

changeYear(date_or_datetime, value)

Arguments

• date_or_datetime — La valeur à modifier. Date ou Date32 ou DateTime ou DateTime64
• value — La nouvelle valeur. (U)Int*

Valeur renvoyée

Renvoie une valeur du même type que date_or_datetime dont la composante année a été modifiée. Date ou Date32 ou DateTime ou DateTime64

Exemples

Exemple d’utilisation

Query

SELECT changeYear('2024-01-01'::DateTime, 2023)

Response

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), de 1 mois pour l’unité month (voir toRelativeMonthNum) et de 1 an pour l’unité year (voir 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.

Syntaxe

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 ou Date32 ou DateTime ou DateTime64
• enddate — La seconde valeur temporelle, de laquelle la première est soustraite (le terme diminué). Date ou Date32 ou DateTime ou 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

Valeur renvoyée

Renvoie la différence entre enddate et startdate, exprimée en unit. Int64

Exemples

Calculer la différence entre deux dates en heures

Query

SELECT dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res

Response

┌─res─┐
│  25 │
└─────┘

Calculer l’écart entre deux dates dans différentes unités

Query

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

┌──────────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

dateName(date_part, date[, timezone])

Arguments

• date_part — La partie de la date que vous souhaitez extraire. String
• datetime — Une valeur de date ou de date avec heure. Date ou Date32 ou DateTime ou DateTime64
• timezone — Facultatif. Fuseau horaire. String

Valeur renvoyée

Renvoie la partie spécifiée de la date. String

Exemples

Extraire différentes parties de la date

Query

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

┌─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

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
• datetime — Date et heure. Date ou Date32 ou DateTime ou 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

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 ou Date
Day, Hour, Minute, Second	Date32, DateTime64, Date ou DateTime	DateTime64 ou DateTime
Millisecond, Microsecond,	N’importe lequel	DateTime64
Nanosecond		avec une échelle de 3, 6 ou 9

Exemples

Tronquer sans fuseau horaire

Query

SELECT now(), dateTrunc('hour', now());

Response

┌───────────────now()─┬─dateTrunc('hour', now())──┐
│ 2020-09-28 10:40:45 │       2020-09-28 10:00:00 │
└─────────────────────┴───────────────────────────┘

Tronquer selon le fuseau horaire spécifié

Query

SELECT now(), dateTrunc('hour', now(), 'Asia/Istanbul');

Response

┌───────────────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.

L’opération inverse de cette fonction est 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

formatDateTime(datetime, format[, timezone])

Alias : DATE_FORMAT

Arguments

• datetime — Une date ou une date et heure à formater. Date ou Date32 ou DateTime ou DateTime64
• format — Chaîne de format avec des champs de remplacement. String
• timezone — Facultatif. Nom du fuseau horaire pour l’heure formatée. String

Valeur renvoyée

Renvoie des valeurs de date et d’heure selon le format spécifié. String

Exemples

Formater une date avec le champ de remplacement de l’année

Query

SELECT formatDateTime(toDate('2010-01-04'), '%g')

Response

┌─formatDateTime(toDate('2010-01-04'), '%g')─┐
│ 10                                         │
└────────────────────────────────────────────┘

Formater DateTime64 avec des fractions de seconde

Query

SELECT formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')

Response

┌─formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')─┐
│ 1234560                                                             │
└─────────────────────────────────────────────────────────────────────┘

Formatage avec fuseau horaire

Query

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

┌──────────────────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.

L’opération inverse de cette fonction est 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

formatDateTimeInJodaSyntax(datetime, format[, timezone])

Arguments

• datetime — Une date ou une date et une heure à formater. DateTime ou Date ou Date32 ou DateTime64
• format — Chaîne de format avec des champs de remplacement de style Joda. String
• timezone — Facultatif. Nom du fuseau horaire pour la date et l’heure formatées. String

Valeur renvoyée

Renvoie une valeur de date et d’heure selon le format déterminé. String

Exemples

Formater une date et une heure avec la syntaxe Joda

Query

SELECT formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')

Response

┌─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, renvoie la date correspondante dans le calendrier grégorien proleptique défini par l’ISO 8601.

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.

Syntaxe

fromDaysSinceYearZero(days)

Alias : FROM_DAYS

Arguments

• days — Le nombre de jours écoulés depuis l’année zéro. UInt32

Valeur renvoyée

Renvoie la date correspondant au nombre de jours écoulés depuis l’année zéro. Date

Exemples

Convertir le nombre de jours écoulés depuis l’année zéro en dates

Query

SELECT
fromDaysSinceYearZero(739136) AS date1,
fromDaysSinceYearZero(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2

Response

┌──────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, renvoie la date correspondante dans le calendrier grégorien proleptique défini par l’ISO 8601. 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.

Syntaxe

fromDaysSinceYearZero32(days)

Arguments

• days — Le nombre de jours écoulés depuis l’année zéro. UInt32

Valeur renvoyée

Renvoie la date correspondant au nombre de jours écoulés depuis l’année zéro. Date32

Exemples

Convertir les jours écoulés depuis l’année zéro en dates

Query

SELECT
fromDaysSinceYearZero32(739136) AS date1,
fromDaysSinceYearZero32(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2

Response

┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘

​

fromModifiedJulianDay

Introduit dans : v21.1.0

Convertit un nombre de jour julien modifié en une date du calendrier grégorien proleptique 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

fromModifiedJulianDay(day)

Arguments

• day — numéro de jour julien modifié. (U)Int*

Valeur renvoyée

Renvoie la date sous forme de texte. String

Exemples

Convertir un jour julien modifié en date

Query

SELECT fromModifiedJulianDay(58849)

Response

┌─fromModifiedJulianDay(58849)─┐
│ 2020-01-01                   │
└──────────────────────────────┘

​

fromModifiedJulianDayOrNull

Introduite dans : v21.1.0

Semblable à fromModifiedJulianDay(), mais au lieu de générer une exception, cette fonction renvoie NULL.

Syntaxe

fromModifiedJulianDayOrNull(day)

Arguments

• day — numéro de jour julien modifié. (U)Int*

Valeur renvoyée

Renvoie la date sous forme textuelle pour un argument day valide, sinon null. Nullable(String)

Exemples

Convertir le jour julien modifié en date avec gestion des valeurs nulles

Query

SELECT fromModifiedJulianDayOrNull(58849);
SELECT fromModifiedJulianDayOrNull(60000000); -- invalid argument, returns NULL

Response

┌─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

fromUTCTimestamp(datetime, time_zone)

Alias : from_utc_timestamp

Arguments

• datetime — Une valeur constante de type date ou date avec heure, ou une expression. DateTime ou DateTime64
• time_zone — Une valeur constante de type String ou une expression représentant le fuseau horaire. String

Valeur renvoyée

Renvoie un DateTime/DateTime64 dans le fuseau horaire spécifié. DateTime ou DateTime64

Exemples

Convertir du fuseau horaire UTC vers le fuseau horaire spécifié

Query

SELECT fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00', 3), 'Asia/Shanghai')

Response

┌─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, elle renvoie une valeur de type DateTime, c’est-à-dire qu’elle se comporte comme toDateTime.
• Lorsqu’on lui passe deux ou trois arguments, où le premier est une valeur de type Integer, Date, Date32, DateTime ou 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, c’est-à-dire qu’elle se comporte comme formatDateTime. Dans ce cas, le style de format datetime de MySQL est utilisé.

Syntaxe

fromUnixTimestamp(timestamp)
fromUnixTimestamp(timestamp[, format[, timezone]])

Alias : FROM_UNIXTIME

Arguments

• timestamp — Horodatage Unix ou valeur de date/date avec heure. (U)Int* ou Date ou Date32 ou DateTime ou DateTime64
• format — Facultatif. Chaîne de format constante pour le formatage de sortie. String
• timezone — Facultatif. Chaîne constante de fuseau horaire. 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 ou String

Exemples

Convertir un horodatage Unix en DateTime

Query

SELECT fromUnixTimestamp(423543535)

Response

┌─fromUnixTimestamp(423543535)─┐
│          1983-06-04 10:58:55 │
└──────────────────────────────┘

Convertir un horodatage Unix selon un format

Query

SELECT fromUnixTimestamp(1234334543, '%Y-%m-%d %R:%S') AS DateTime

Response

┌─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 est fourni, elle renvoie une valeur de type DateTime, c’est-à-dire qu’elle se comporte comme toDateTime.

Lorsque deux ou trois arguments sont fournis, le premier argument étant une valeur de type Integer, Date, Date32, DateTime ou 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, c’est-à-dire qu’elle se comporte comme formatDateTimeInJodaSyntax. Dans ce cas, le style de format date-heure de Joda est utilisé.

Syntaxe

fromUnixTimestampInJodaSyntax(timestamp)
fromUnixTimestampInJodaSyntax(timestamp, format[, timezone])

Arguments

• timestamp — Horodatage Unix ou valeur de date/heure. (U)Int* ou Date ou Date32 ou DateTime ou DateTime64
• format — Facultatif. Chaîne de format constante utilisant la syntaxe Joda pour le formatage de sortie. String
• timezone — Facultatif. Chaîne constante de fuseau horaire. 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 ou String

Exemples

Convertir un horodatage Unix au format Joda

Query

SELECT fromUnixTimestampInJodaSyntax(1234334543, 'yyyy-MM-dd HH:mm:ss', 'UTC') AS DateTime

Response

┌─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

localtime()

Arguments

• Aucun.

Valeur renvoyée

Renvoie l’heure actuelle. Time

Exemples

Syntaxe SQL standard sans parenthèses

Query

SELECT LOCALTIME

Response

┌───────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

makeDate(year, month, day)
makeDate(year, day_of_year)

Arguments

• year — Numéro de l’année. (U)Int* ou Float* ou Decimal
• month — Numéro du mois (1-12). (U)Int* ou Float* ou Decimal
• day — Jour du mois (1-31). (U)Int* ou Float* ou Decimal
• day_of_year — Jour de l’année (1-365). (U)Int* ou Float* ou Decimal

Valeur renvoyée

Renvoie une valeur Date construite à partir des arguments fournis Date

Exemples

Date à partir d’une année, d’un mois et d’un jour

Query

SELECT makeDate(2023, 2, 28) AS date;

Response

┌───────date─┐
│ 2023-02-28 │
└────────────┘

Date à partir de l’année et du jour dans l’année

Query

SELECT makeDate(2023, 42) AS date;

Response

┌───────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

makeDate32(year, month, day)
makeDate32(year, day_of_year)

Arguments

• year — Numéro de l’année. (U)Int* ou Float* ou Decimal
• month — Numéro du mois (1-12). (U)Int* ou Float* ou Decimal
• day — Jour du mois (1-31). (U)Int* ou Float* ou Decimal
• day_of_year — Jour de l’année (1-365). (U)Int* ou Float* ou Decimal

Valeur renvoyée

Renvoie une valeur Date32 construite à partir des arguments fournis Date32

Exemples

Date32 à partir d’une année, d’un mois et d’un jour

Query

SELECT makeDate(2023, 2, 28) AS date;

Response

┌───────date─┐
│ 2023-02-28 │
└────────────┘

Date32 à partir de l’année et du numéro du jour dans l’année

Query

SELECT makeDate(2023, 42) AS date;

Response

┌───────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

makeDateTime(year, month, day, hour, minute, second[, timezone])

Arguments

• year — Numéro de l’année. (U)Int* ou Float* ou Decimal
• month — Numéro du mois (1-12). (U)Int* ou Float* ou Decimal
• day — Jour du mois (1-31). (U)Int* ou Float* ou Decimal
• hour — Heure (0-23). (U)Int* ou Float* ou Decimal
• minute — Minute (0-59). (U)Int* ou Float* ou Decimal
• second — Seconde (0-59). (U)Int* ou Float* ou Decimal
• timezone — Nom du fuseau horaire. String

Valeur renvoyée

Renvoie une valeur DateTime construite à partir des arguments fournis DateTime

Exemples

DateTime à partir de l’année, du mois, du jour, de l’heure, de la minute et de la seconde

Query

SELECT makeDateTime(2023, 2, 28, 17, 12, 33) AS DateTime;

Response

┌────────────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

makeDateTime64(year, month, day, hour, minute, second[, fraction[, precision[, timezone]]])

Arguments

• year — Numéro de l’année. (U)Int* ou Float* ou Decimal
• month — Numéro du mois (1-12). (U)Int* ou Float* ou Decimal
• day — Jour du mois (1-31). (U)Int* ou Float* ou Decimal
• hour — Heure (0-23). (U)Int* ou Float* ou Decimal
• minute — Minute (0-59). (U)Int* ou Float* ou Decimal
• second — Seconde (0-59). (U)Int* ou Float* ou Decimal
• fraction — Partie fractionnaire de la seconde. (U)Int* ou Float* ou Decimal
• precision — Précision de la partie fractionnaire (0-9). UInt8
• timezone — Nom du fuseau horaire. String

Valeur renvoyée

Renvoie une valeur DateTime64 construite à partir des arguments fournis DateTime64

Exemples

DateTime64 à partir de l’année, du mois, du jour, de l’heure, de la minute et de la seconde

Query

SELECT makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5);

Response

┌─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

monthName(datetime)

Arguments

• datetime — Date ou date et heure. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le nom du mois. String

Exemples

Obtenir le nom du mois à partir d’une date

Query

WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT monthName(date_value)

Response

┌─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

now([timezone])

Alias : localtimestamp, current_timestamp

Arguments

• timezone — Facultatif. Nom du fuseau horaire pour la valeur renvoyée. String

Valeur renvoyée

Renvoie la date et l’heure actuelles. DateTime

Exemples

Requête sans fuseau horaire

Query

SELECT now()

Response

┌───────────────now()─┐
│ 2020-10-17 07:42:09 │
└─────────────────────┘

Requête avec un fuseau horaire spécifié

Query

SELECT now('Asia/Istanbul')

Response

┌─now('Asia/Istanbul')─┐
│  2020-10-17 10:42:23 │
└──────────────────────┘

Syntaxe SQL standard sans parenthèses

Query

SELECT NOW, CURRENT_TIMESTAMP

Response

┌─────────────────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

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
• timezone — Facultatif. Nom du fuseau horaire pour la valeur renvoyée. String

Valeur renvoyée

Renvoie la date et l’heure actuelles avec une précision inférieure à la seconde. DateTime64

Exemples

Requête avec la précision par défaut et une précision personnalisée

Query

SELECT now64(), now64(9, 'Asia/Istanbul')

Response

┌─────────────────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, 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

nowInBlock([timezone])

Arguments

• timezone — Facultatif. Nom du fuseau horaire de la valeur renvoyée. String

Valeur renvoyée

Renvoie la date et l’heure actuelles au moment du traitement de chaque bloc de données. DateTime

Exemples

Différence avec la fonction now()

Query

SELECT
    now(),
    nowInBlock(),
    sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock

Response

┌───────────────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, 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

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
• timezone — Facultatif. Nom du fuseau horaire pour la valeur renvoyée. 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

Exemples

Différence avec la fonction now64()

Query

SELECT
    now64(),
    nowInBlock64(),
    sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock

Response

┌─────────────────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. 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

serverTimezone()

Alias : serverTimeZone

Arguments

• Aucun.

Valeur renvoyée

Renvoie le fuseau horaire du serveur sous forme de String

Exemples

Exemple d’utilisation

Query

SELECT serverTimeZone()

Response

┌─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

subDate(datetime, interval)

Arguments

• datetime — La date, avec ou sans heure, à laquelle interval est soustrait. Date ou Date32 ou DateTime ou DateTime64
• interval — Intervalle à soustraire. Interval

Valeur renvoyée

Renvoie la date, avec ou sans heure, obtenue en soustrayant interval à datetime. Date ou Date32 ou DateTime ou DateTime64

Exemples

Soustraire un intervalle à une date

Query

SELECT subDate(toDate('2018-01-01'), INTERVAL 3 YEAR)

Response

┌─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

subtractDays(datetime, num)

Arguments

• datetime — Date ou date avec heure à laquelle soustraire le nombre de jours spécifié. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre de jours à soustraire. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime moins num jours Date ou Date32 ou DateTime ou DateTime64

Exemples

Soustraire des jours à différents types de date

Query

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

┌─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

Query

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 day)

Response

┌─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

subtractHours(datetime, num)

Arguments

• datetime — Date ou date avec heure à laquelle soustraire le nombre d’heures spécifié. Date or Date32 or DateTime or DateTime64 or String
• num — Nombre d’heures à soustraire. (U)Int* or Float*

Valeur renvoyée

Renvoie datetime moins num heures DateTime or DateTime64(3)

Exemples

Soustraire des heures à différents types de date

Query

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

┌─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

Query

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 hour)

Response

┌─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

subtractInterval(interval_1, interval_2)

Arguments

• interval_1 — Premier intervalle ou tuple d’intervalles. Interval ou Tuple(Interval)
• interval_2 — Deuxième intervalle à rendre négatif. Interval

Valeur renvoyée

Renvoie un tuple d’intervalles Tuple(T)

Exemples

Soustraction d’intervalles

Query

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

┌─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

subtractMicroseconds(datetime, num)

Arguments

• datetime — Date avec heure de laquelle soustraire le nombre spécifié de microsecondes. DateTime ou DateTime64 ou String
• num — Nombre de microsecondes à soustraire. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime moins num microsecondes DateTime64

Exemples

Soustraire des microsecondes de différents types de date avec heure

Query

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

┌─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

Query

SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 microsecond)

Response

┌─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

subtractMilliseconds(datetime, num)

Arguments

• datetime — Date avec heure à laquelle soustraire le nombre spécifié de millisecondes. DateTime ou DateTime64 ou String
• num — Nombre de millisecondes à soustraire. (U)Int* ou Float*

Valeur renvoyée

datetime moins num millisecondes. DateTime64

Exemples

Soustraire des millisecondes à différents types de dates et d’heures

Query

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

┌─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

Query

SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 millisecond)

Response

┌─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

subtractMinutes(datetime, num)

Arguments

• datetime — Date ou date avec heure à laquelle soustraire le nombre de minutes spécifié. Date or Date32 or DateTime or DateTime64 or String
• num — Nombre de minutes à soustraire. (U)Int* or Float*

Valeur renvoyée

Renvoie datetime moins num minutes. DateTime or DateTime64(3)

Exemples

Soustraire des minutes à différents types de dates

Query

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

┌─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

Query

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 minute)

Response

┌─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

subtractMonths(datetime, num)

Arguments

• datetime — Date ou date avec heure à laquelle soustraire le nombre de mois spécifié. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre de mois à soustraire. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime moins num mois. Date ou Date32 ou DateTime ou DateTime64

Exemples

Soustraction de mois à différents types de date

Query

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

┌─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

Query

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 month)

Response

┌─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

subtractNanoseconds(datetime, num)

Arguments

• datetime — Date avec heure dont il faut soustraire le nombre spécifié de nanosecondes. DateTime ou DateTime64 ou String
• num — Nombre de nanosecondes à soustraire. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime moins num nanosecondes DateTime64

Exemples

Soustraire des nanosecondes à différents types de date avec heure

Query

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

┌─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

Query

SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 nanosecond)

Response

┌─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

subtractQuarters(datetime, num)

Arguments

• datetime — Date ou date avec heure à partir de laquelle soustraire le nombre de trimestres spécifié. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre de trimestres à soustraire. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime moins num trimestres Date ou Date32 ou DateTime ou DateTime64

Exemples

Soustraire des trimestres à différents types de dates

Query

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

┌─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

Query

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 quarter)

Response

┌─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

subtractSeconds(datetime, num)

Arguments

• datetime — Date ou date avec heure à laquelle soustraire le nombre de secondes spécifié. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre de secondes à soustraire. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime moins num secondes. DateTime ou DateTime64(3)

Exemples

Soustraire des secondes à différents types de dates

Query

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

┌─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

Query

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 second)

Response

┌─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

subtractTupleOfIntervals(datetime, intervals)

Arguments

• datetime — Date ou date avec heure à laquelle soustraire les intervalles. Date or Date32 or DateTime or DateTime64
• intervals — Tuple d’intervalles à soustraire à datetime. Tuple(Interval)

Valeur renvoyée

Renvoie date après soustraction des intervals Date or Date32 or DateTime or DateTime64

Exemples

Soustraire un tuple d’intervalles d’une date

Query

WITH toDate('2018-01-01') AS date SELECT subtractTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 YEAR))

Response

┌─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

subtractWeeks(datetime, num)

Arguments

• datetime — Date ou date avec heure à laquelle soustraire le nombre de semaines spécifié. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre de semaines à soustraire. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime moins num semaines. Date ou Date32 ou DateTime ou DateTime64

Exemples

Soustraire des semaines à différents types de dates

Query

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

┌─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

Query

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 week)

Response

┌─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

subtractYears(datetime, num)

Arguments

• datetime — Date ou date avec heure à laquelle soustraire le nombre d’années spécifié. Date ou Date32 ou DateTime ou DateTime64 ou String
• num — Nombre d’années à soustraire. (U)Int* ou Float*

Valeur renvoyée

Renvoie datetime moins num ans Date ou Date32 ou DateTime ou DateTime64

Exemples

Soustraire des années à différents types de date

Query

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

┌─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

Query

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 year)

Response

┌─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.

Syntaxe

timeDiff(startdate, enddate)

Arguments

• startdate — La première valeur temporelle à soustraire (le terme soustrait). Date ou Date32 ou DateTime ou DateTime64
• enddate — La deuxième valeur temporelle à partir de laquelle soustraire (le terme de départ). Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie la différence entre enddate et startdate, exprimée en secondes. Int64

Exemples

Calculer la différence en secondes

Query

SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res

Response

┌───res─┐
│ 90000 │
└───────┘

Calculer une différence de temps et la convertir en heures

Query

SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) / 3600 AS hours

Response

┌─hours─┐
│    25 │
└───────┘

Équivalent à dateDiff en secondes

Query

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

┌─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

timeSlot(time[, time_zone])

Arguments

• time — Heure à arrondir au début d’un intervalle d’une demi-heure. DateTime ou Date32 ou DateTime64
• time_zone — Facultatif. Valeur constante de type String ou expression représentant le fuseau horaire. String

Valeur renvoyée

Renvoie l’heure arrondie au début d’un intervalle d’une demi-heure. DateTime

Exemples

Arrondir l’heure à un intervalle d’une demi-heure

Query

SELECT timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))

Response

┌─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

timeSlots(StartTime, Duration[, Size])

Arguments

• StartTime — Heure de début de l’intervalle. DateTime ou DateTime64
• Duration — Durée de l’intervalle en secondes. UInt32 ou DateTime64
• Size — Facultatif. Taille des créneaux horaires en secondes. La valeur par défaut est 1800 (30 minutes). UInt32 ou 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) ou Array(DateTime64)

Exemples

Générer des créneaux horaires pour un intervalle

Query

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

┌─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). Si un deuxième argument expr_time est fourni, il ajoute l’heure spécifiée à la valeur convertie.

Syntaxe

timestamp(expr[, expr_time])

Arguments

• expr — Date ou date avec heure. String
• expr_time — Facultatif. Heure à ajouter à la valeur convertie. String

Valeur renvoyée

Renvoie la valeur convertie de expr, ou expr après ajout de l’heure DateTime64(6)

Exemples

Convertir une chaîne de date en DateTime64(6)

Query

SELECT timestamp('2023-12-31') AS ts;

Response

┌─────────────────────────ts─┐
│ 2023-12-31 00:00:00.000000 │
└────────────────────────────┘

Ajouter une heure à une date au format chaîne

Query

SELECT timestamp('2023-12-31 12:00:00', '12:00:00.11') AS ts;

Response

┌─────────────────────────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

timezone()

Alias : timeZone

Arguments

• Aucun.

Valeur renvoyée

Renvoie le nom canonique du fuseau horaire sous forme de String

Exemples

Exemple d’utilisation

Query

SELECT timezone()

Response

┌─timezone()───────┐
│ Europe/Amsterdam │
└──────────────────┘

​

timezoneOf

Introduit dans : v21.4.0

Renvoie le nom du fuseau horaire d’une valeur DateTime ou DateTime64.

Syntaxe

timezoneOf(datetime)

Alias : timeZoneOf

Arguments

• datetime — Une valeur de type DateTime ou DateTime64
• timezone — Facultatif. Nom du fuseau horaire vers lequel convertir la valeur datetime. String

Valeur renvoyée

Renvoie le nom du fuseau horaire de datetime String

Exemples

Exemple d’utilisation

Query

SELECT timezoneOf(now());

Response

┌─timezoneOf(now())─┐
│ Europe/Amsterdam  │
└───────────────────┘

​

timezoneOffset

Introduit dans : v21.6.0

Renvoie le décalage du fuseau horaire en secondes par rapport à UTC. 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

timezoneOffset(datetime)

Alias : timeZoneOffset

Arguments

• datetime — valeur DateTime dont il faut obtenir le décalage de fuseau horaire. DateTime ou DateTime64

Valeur renvoyée

Renvoie le décalage par rapport à l’UTC en secondes Int32

Exemples

Exemple d’utilisation

Query

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

┌────────────────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

toDayOfMonth(datetime)

Alias : DAY, DAYOFMONTH

Arguments

• datetime — Date ou date avec heure à partir de laquelle extraire le jour du mois. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le jour du mois de la date/heure donnée UInt8

Exemples

Exemple d’utilisation

Query

SELECT toDayOfMonth(toDateTime('2023-04-21 10:20:30'))

Response

┌─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

toDayOfWeek(datetime[, mode[, timezone]])

Alias : DAYOFWEEK

Arguments

• datetime — Date ou date avec heure à partir de laquelle extraire le jour de la semaine. Date ou Date32 ou DateTime ou DateTime64
• mode — Facultatif. Entier spécifiant le mode de semaine (0-3). La valeur par défaut est 0 s’il est omis. UInt8
• timezone — Facultatif. Fuseau horaire à utiliser pour la conversion. String

Valeur renvoyée

Renvoie le jour de la semaine pour la valeur Date ou DateTime donnée. UInt8

Exemples

Exemple d’utilisation

Query

-- The following date is April 21, 2023, which was a Friday:
SELECT
    toDayOfWeek(toDateTime('2023-04-21')),
    toDayOfWeek(toDateTime('2023-04-21'), 1)

Response

┌─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

toDayOfYear(datetime)

Alias : DAYOFYEAR

Arguments

• datetime — Date ou date avec heure à partir de laquelle obtenir le jour de l’année. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le jour de l’année pour la valeur Date ou DateTime donnée UInt16

Exemples

Exemple d’utilisation

Query

SELECT toDayOfYear(toDateTime('2023-04-21 10:20:30'))

Response

┌─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

toDaysInMonth(datetime)

Arguments

• datetime — Date ou date avec heure à partir de laquelle obtenir le nombre de jours du mois. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le nombre de jours du mois de la date/heure donnée. UInt8

Exemples

Exemple d’utilisation

Query

SELECT toDaysInMonth(toDate('2023-02-01')), toDaysInMonth(toDate('2024-02-01')), toDaysInMonth(toDate('2023-01-01'))

Response

┌─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 dans le calendrier grégorien proleptique défini par l’ISO 8601.

Le calcul est identique à celui de la fonction TO_DAYS de MySQL.

Syntaxe

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 ou Date32 ou DateTime ou DateTime64
• time_zone — Fuseau horaire. String

Valeur renvoyée

Renvoie le nombre de jours écoulés depuis la date 0000-01-01. UInt32

Exemples

Calculer le nombre de jours depuis l’année zéro

Query

SELECT toDaysSinceYearZero(toDate('2023-09-08'))

Response

┌─toDaysSinceYearZero(toDate('2023-09-08')))─┐
│                                     713569 │
└────────────────────────────────────────────┘

​

toHour

Introduit dans : v1.1.0

Renvoie l’heure (0 à 23) d’une valeur DateTime ou DateTime64.

Syntaxe

toHour(datetime)

Alias : HOUR

Arguments

• datetime — Date avec heure dont extraire l’heure. DateTime ou DateTime64

Valeur renvoyée

Renvoie l’heure (0 à 23) de datetime. UInt8

Exemples

Exemple d’utilisation

Query

SELECT toHour(toDateTime('2023-04-21 10:20:30'))

Response

┌─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

toISOWeek(datetime[, timezone])

Arguments

• datetime — Date ou date avec heure à partir de laquelle obtenir le numéro de semaine ISO. Date ou DateTime ou Date32 ou DateTime64
• timezone — Facultatif. Fuseau horaire. 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

Exemples

Obtenir les numéros de semaine ISO

Query

SELECT toDate('2016-12-27') AS date, toISOWeek(date) AS isoWeek

Response

┌───────date─┬─isoWeek─┐
│ 2016-12-27 │      52 │
└────────────┴─────────┘

Une semaine ISO peut appartenir à une année différente

Query

SELECT toDate('2025-12-29') AS date, toISOWeek(date) AS isoWeek, toYear(date) AS year

Response

┌───────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

toISOYear(datetime)

Arguments

• datetime — Valeur de type date ou date avec heure. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie la valeur d’entrée convertie en numéro d’année ISO. UInt16

Exemples

Obtenir l’année ISO à partir de valeurs de date

Query

SELECT
toISOYear(toDate('2024/10/02')) as year1,
toISOYear(toDateTime('2024-10-02 01:30:00')) as year2

Response

┌─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.

Syntaxe

toLastDayOfMonth(value)

Alias : LAST_DAY

Arguments

• value — La date ou la date avec heure à arrondir au dernier jour du mois. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie la date du dernier jour du mois pour la date ou la date avec heure donnée. Date

Exemples

Arrondir au dernier jour du mois

Query

SELECT toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))

Response

┌─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.

Syntaxe

toLastDayOfWeek(datetime[, mode[, timezone]])

Arguments

• datetime — Une date avec heure ou une date à convertir. Date ou DateTime ou Date32 ou DateTime64
• mode — Détermine le premier jour de la semaine, comme décrit dans la fonction toWeek(). Valeur par défaut : 0. UInt8
• timezone — Facultatif. Fuseau horaire à utiliser pour la conversion. S’il n’est pas spécifié, le fuseau horaire du serveur est utilisé. 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 ou Date32

Exemples

Arrondir au samedi ou au dimanche le plus proche

Query

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

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

toMicrosecond(datetime)

Alias : MICROSECOND

Arguments

• datetime — Date et heure dont extraire la microseconde. DateTime64

Valeur renvoyée

Renvoie la microseconde de la seconde (0 - 999999) de datetime. UInt32

Exemples

Exemple d’utilisation

Query

SELECT toMicrosecond(toDateTime64('2023-04-21 10:20:30.456789', 6));

Response

┌─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

toMillisecond(datetime)

Alias : MILLISECOND

Arguments

• datetime — date et heure dont extraire la minute. DateTime ou DateTime64

Valeur renvoyée

Renvoie la minute (0 - 59) de datetime. UInt16

Exemples

Exemple d’utilisation

Query

SELECT toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3));

Response

┌──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

toMinute(datetime)

Alias : MINUTE

Arguments

• datetime — Date et heure dont extraire la minute. DateTime ou DateTime64

Valeur renvoyée

Renvoie la minute de l’heure (0 - 59) de datetime. UInt8

Exemples

Exemple d’utilisation

Query

SELECT toMinute(toDateTime('2023-04-21 10:20:30'))

Response

┌─toMinute(toDateTime('2023-04-21 10:20:30'))─┐
│                                          20 │
└─────────────────────────────────────────────┘

​

toModifiedJulianDay

Introduit dans : v21.1.0

Convertit une date du calendrier grégorien proleptique, sous forme de texte YYYY-MM-DD, en un numéro de jour julien modifié 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

toModifiedJulianDay(date)

Arguments

• date — La date au format String. String ou FixedString

Valeur renvoyée

Renvoie le numéro de jour julien modifié. Int32

Exemples

Convertir une date en numéro de jour julien modifié

Query

SELECT toModifiedJulianDay('2020-01-01')

Response

┌─toModifiedJulianDay('2020-01-01')─┐
│                             58849 │
└───────────────────────────────────┘

​

toModifiedJulianDayOrNull

Introduit dans : v21.1.0

Similaire à toModifiedJulianDay(), mais au lieu de déclencher des exceptions, elle renvoie NULL.

Syntaxe

toModifiedJulianDayOrNull(date)

Arguments

• date — Date sous forme de texte. String ou FixedString

Valeur renvoyée

Renvoie le numéro de jour julien modifié si date est valide, sinon null. Nullable(Int32)

Exemples

Convertir une date en numéro de jour julien modifié avec gestion des valeurs nulles

Query

SELECT toModifiedJulianDayOrNull('2020-01-01');
SELECT toModifiedJulianDayOrNull('0000-00-00'); -- invalid date, returns NULL

Response

┌─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.

Syntaxe

toMonday(value)

Arguments

• value — date ou date avec heure à arrondir au lundi de la semaine. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie la date du lundi de la même semaine pour la date ou date avec heure donnée. Date

Exemples

Arrondir au lundi de la semaine

Query

SELECT
toMonday(toDateTime('2023-04-21 10:20:30')), -- A Friday
toMonday(toDate('2023-04-24'));              -- Already a Monday

Response

┌─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

toMonth(datetime)

Alias : MONTH

Arguments

• datetime — Date ou date avec heure à partir de laquelle extraire le mois. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le mois de la date/heure donnée UInt8

Exemples

Exemple d’utilisation

Query

SELECT toMonth(toDateTime('2023-04-21 10:20:30'))

Response

┌─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

toMonthNumSinceEpoch(date)

Arguments

• date — Une date ou une date avec l’heure. Date ou DateTime ou DateTime64

Valeur renvoyée

Entier positif

Exemples

Exemple

Query

SELECT toMonthNumSinceEpoch(toDate('2024-10-01'))

Response

657

​

toNanosecond

Introduit dans : v25.7.0

Renvoie la composante en nanosecondes (0-999999999) d’une valeur DateTime64.

Syntaxe

toNanosecond(datetime)

Alias : NANOSECOND

Arguments

• datetime — Date et heure dont extraire la nanoseconde. DateTime64

Valeur renvoyée

Renvoie la nanoseconde de la seconde (0 - 999999999) de datetime. UInt32

Exemples

Exemple d’utilisation

Query

SELECT toNanosecond(toDateTime64('2023-04-21 10:20:30.123456789', 9));

Response

┌─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

toQuarter(datetime)

Alias : QUARTER

Arguments

• datetime — Date ou date avec heure à partir de laquelle extraire le trimestre de l’année. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le trimestre de l’année pour la date/l’heure donnée UInt8

Exemples

Exemple d’utilisation

Query

SELECT toQuarter(toDateTime('2023-04-21 10:20:30'))

Response

┌─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

toRelativeDayNum(date)

Arguments

• date — Date ou date avec heure. Date ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le nombre de jours écoulés depuis un point de référence fixe dans le passé. UInt32

Exemples

Obtenir les numéros de jours relatifs

Query

SELECT toRelativeDayNum(toDate('2023-04-01')) - toRelativeDayNum(toDate('2023-01-01'))

Response

┌─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

toRelativeHourNum(date)

Arguments

• date — Date ou date avec heure. Date ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le nombre d’heures écoulées depuis un point de référence fixe dans le passé. UInt32

Exemples

Obtenir les numéros d’heure relatifs

Query

SELECT toRelativeHourNum(toDateTime('2023-01-01 12:00:00')) - toRelativeHourNum(toDateTime('2023-01-01 00:00:00')) AS hours_difference

Response

┌─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

toRelativeMinuteNum(date)

Arguments

• date — Date ou date avec heure. Date ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le nombre de minutes écoulées depuis un point de référence fixe dans le passé. UInt32

Exemples

Obtenir les numéros de minute relatifs

Query

SELECT toRelativeMinuteNum(toDateTime('2023-01-01 00:30:00')) - toRelativeMinuteNum(toDateTime('2023-01-01 00:00:00')) AS minutes_difference

Response

┌─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

toRelativeMonthNum(date)

Arguments

• date — Date ou date avec heure. Date ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le nombre de mois depuis un point de référence fixe dans le passé. UInt32

Exemples

Récupérer les numéros relatifs des mois

Query

SELECT toRelativeMonthNum(toDate('2023-04-01')) - toRelativeMonthNum(toDate('2023-01-01')) AS months_difference

Response

┌─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

toRelativeQuarterNum(date)

Arguments

• date — Date ou date avec heure. Date ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le nombre de trimestres écoulés depuis un point de référence fixe dans le passé. UInt32

Exemples

Obtenir les numéros de trimestre relatifs

Query

SELECT toRelativeQuarterNum(toDate('2023-04-01')) - toRelativeQuarterNum(toDate('2023-01-01')) AS quarters_difference

Response

┌─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

toRelativeSecondNum(date)

Arguments

• date — Date ou date avec heure. Date ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le nombre de secondes écoulées depuis un point de référence fixe dans le passé. UInt32

Exemples

Obtenir des numéros de secondes relatifs

Query

SELECT toRelativeSecondNum(toDateTime('2023-01-01 00:01:00')) - toRelativeSecondNum(toDateTime('2023-01-01 00:00:00')) AS seconds_difference

Response

┌─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

toRelativeWeekNum(date)

Arguments

• date — Date ou date avec heure. Date ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le nombre de semaines écoulées depuis un point de référence fixe dans le passé. UInt32

Exemples

Obtenir les numéros de semaine relatifs

Query

SELECT toRelativeWeekNum(toDate('2023-01-08')) - toRelativeWeekNum(toDate('2023-01-01')) AS weeks_difference

Response

┌─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

toRelativeYearNum(date)

Arguments

• date — Date ou date avec heure. Date ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le nombre d’années depuis un point de référence fixe dans le passé. UInt16

Exemples

Obtenir les numéros relatifs d’année

Query

SELECT toRelativeYearNum('2010-10-01'::DateTime) - toRelativeYearNum('2000-01-01'::DateTime)

Response

┌─minus(toRela⋯ateTime')))─┐
│                       10 │
└──────────────────────────┘

​

toSecond

Introduit dans : v1.1.0

Renvoie la composante des secondes (0-59) d’une valeur DateTime ou DateTime64.

Syntaxe

toSecond(datetime)

Alias : SECOND

Arguments

• datetime — Date et heure dont il faut extraire la seconde. DateTime ou DateTime64

Valeur renvoyée

Renvoie la seconde de la minute (0 à 59) de datetime. UInt8

Exemples

Exemple d’utilisation

Query

SELECT toSecond(toDateTime('2023-04-21 10:20:30'))

Response

┌─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.

Syntaxe

toStartOfDay(datetime)

Arguments

• datetime — Une date ou une date avec heure à arrondir. Date ou DateTime

Valeur renvoyée

Renvoie la date avec heure arrondie à l’inférieur au début de la journée. DateTime ou DateTime64

Exemples

Arrondir à l’inférieur au début de la journée

Query

SELECT toStartOfDay(toDateTime('2023-04-21 10:20:30'))

Response

┌─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.

Syntaxe

toStartOfFifteenMinutes(datetime)

Arguments

• datetime — Une date ou une date avec l’heure à arrondir. DateTime ou DateTime64

Valeur renvoyée

Renvoie la date avec l’heure arrondie au début de l’intervalle de quinze minutes le plus proche. DateTime ou DateTime64

Exemples

Exemple

Query

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

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.

Syntaxe

toStartOfFiveMinutes(datetime)

Alias : toStartOfFiveMinute

Arguments

• datetime — Une date et heure à arrondir. DateTime ou DateTime64

Valeur renvoyée

Renvoie la date et l’heure arrondies au début de l’intervalle de cinq minutes le plus proche. DateTime ou DateTime64

Exemples

Exemple

Query

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

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.

Syntaxe

toStartOfHour(datetime)

Arguments

• datetime — Une date et heure à arrondir. DateTime ou DateTime64

Valeur renvoyée

Renvoie la date et l’heure arrondie à l’inférieur au début de l’heure. DateTime ou DateTime64

Exemples

Arrondir à l’inférieur au début de l’heure

Query

SELECT
    toStartOfHour(toDateTime('2023-04-21 10:20:30'));

Response

┌─────────────────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.

Le type de retour peut être configuré via le paramètre enable_extended_results_for_datetime_functions.

Syntaxe

toStartOfISOYear(value)

Arguments

• value — La date ou date avec heure à arrondir à l’inférieur au premier jour de l’année ISO. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le premier jour de l’année ISO pour la date ou date avec heure donnée. Date

Exemples

Arrondir à l’inférieur au premier jour de l’année ISO

Query

SELECT toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))

Response

┌─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

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 ou DateTime ou 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

Exemples

Arrondi élémentaire d’un intervalle

Query

SELECT toStartOfInterval(toDateTime('2023-01-15 14:30:00'), INTERVAL 1 MONTH)

Response

┌─toStartOfInt⋯alMonth(1))─┐
│               2023-01-01 │
└──────────────────────────┘

Utilisation du point d’origine

Query

SELECT toStartOfInterval(toDateTime('2023-01-01 14:45:00'), INTERVAL 1 MINUTE, toDateTime('2023-01-01 14:35:30'))

Response

┌─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

toStartOfMicrosecond(datetime[, timezone])

Arguments

• datetime — Date et heure. 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

Valeur renvoyée

Valeur d’entrée avec des fractions de microseconde DateTime64

Exemples

Requête sans fuseau horaire

Query

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64);

Response

┌────toStartOfMicrosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999000 │
└───────────────────────────────┘

Requête avec fuseau horaire

Query

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64, 'Asia/Istanbul');

Response

┌─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

toStartOfMillisecond(datetime[, timezone])

Arguments

• datetime — Date et heure. 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

Valeur renvoyée

Valeur d’entrée avec des fractions de milliseconde. DateTime64

Exemples

Requête sans fuseau horaire

Query

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64);

Response

┌────toStartOfMillisecond(dt64)─┐
│ 2020-01-01 10:20:30.999000000 │
└───────────────────────────────┘

Requête avec un fuseau horaire

Query

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64, 'Asia/Istanbul');

Response

┌─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.

Syntaxe

toStartOfMinute(datetime)

Arguments

• datetime — Une date et une heure à arrondir. DateTime ou DateTime64

Valeur renvoyée

Renvoie la date et l’heure arrondies à l’inférieur au début de la minute. DateTime ou DateTime64

Exemples

Arrondir à l’inférieur au début de la minute

Query

SELECT
    toStartOfMinute(toDateTime('2023-04-21 10:20:30')),
    toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8))
FORMAT Vertical

Response

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.

Syntaxe

toStartOfMonth(value)

Arguments

• value — La date ou la date avec heure à arrondir à l’inférieur au premier jour du mois. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le premier jour du mois pour la date ou la date avec heure donnée. Date

Exemples

Arrondir à l’inférieur au premier jour du mois

Query

SELECT toStartOfMonth(toDateTime('2023-04-21 10:20:30'))

Response

┌─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

toStartOfNanosecond(datetime[, timezone])

Arguments

• datetime — Date et heure. 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

Valeur renvoyée

Valeur d’entrée avec des nanosecondes. DateTime64

Exemples

Requête sans fuseau horaire

Query

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64);

Response

┌─────toStartOfNanosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999999 │
└───────────────────────────────┘

Requête avec fuseau horaire

Query

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64, 'Asia/Istanbul');

Response

┌─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.

Syntaxe

toStartOfQuarter(value)

Arguments

• value — La date ou la date avec heure à ramener à l’inférieur au premier jour du trimestre. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le premier jour du trimestre correspondant à la date ou à la date avec heure donnée. Date

Exemples

Ramener à l’inférieur au premier jour du trimestre

Query

SELECT toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))

Response

┌─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

toStartOfSecond(datetime[, timezone])

Arguments

• datetime — Date et heure dont il faut tronquer les fractions de seconde. 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

Valeur renvoyée

Renvoie la valeur d’entrée sans fractions de seconde. DateTime64

Exemples

Requête sans fuseau horaire

Query

WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64);

Response

┌───toStartOfSecond(dt64)─┐
│ 2020-01-01 10:20:30.000 │
└─────────────────────────┘

Requête avec fuseau horaire

Query

WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64, 'Asia/Istanbul');

Response

┌─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.

Syntaxe

toStartOfTenMinutes(datetime)

Arguments

• datetime — Une date et heure. DateTime ou DateTime64

Valeur renvoyée

Renvoie la date et heure arrondie au début de l’intervalle de dix minutes le plus proche. DateTime ou DateTime64

Exemples

Exemple

Query

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

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.

Syntaxe

toStartOfWeek(datetime[, mode[, timezone]])

Arguments

• datetime — Une date, avec ou sans heure, à convertir. Date ou DateTime ou Date32 ou DateTime64
• mode — Détermine le premier jour de la semaine comme décrit dans la fonction toWeek(). Valeur par défaut : 0. UInt8
• timezone — Le fuseau horaire à utiliser pour la conversion. S’il n’est pas spécifié, le fuseau horaire du serveur est utilisé. 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 ou Date32

Exemples

Arrondir à la baisse au dimanche ou au lundi le plus proche

Query

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

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.

Syntaxe

toStartOfYear(value)

Arguments

• value — La date ou la date avec heure à arrondir vers le bas. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie le premier jour de l’année pour la date/l’heure donnée Date

Exemples

Arrondir vers le bas au premier jour de l’année

Query

SELECT toStartOfYear(toDateTime('2023-04-21 10:20:30'))

Response

┌─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

toTimeWithFixedDate(date[, timezone])

Arguments

• date — Date à convertir en heure. Date ou DateTime ou DateTime64
• timezone — Facultatif. Fuseau horaire de la valeur renvoyée. 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

Exemples

Calculer l’écart horaire entre deux dates

Query

SELECT toTimeWithFixedDate('2025-06-15 12:00:00'::DateTime) - toTimeWithFixedDate('2024-05-10 11:00:00'::DateTime) AS result, toTypeName(result)

Response

┌─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

toTimezone(datetime, timezone)

Alias : toTimeZone

Arguments

• date — La valeur à convertir. DateTime ou DateTime64
• timezone — Le nom du fuseau horaire cible. String

Valeur renvoyée

Renvoie le même horodatage que la valeur d’entrée, mais avec le fuseau horaire spécifié DateTime ou DateTime64

Exemples

Exemple d’utilisation

Query

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

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

toUTCTimestamp(datetime, time_zone)

Alias : to_utc_timestamp

Arguments

• datetime — Une valeur constante de type date ou date et heure, ou une expression. DateTime ou DateTime64
• time_zone — Une valeur constante de type String ou une expression représentant le fuseau horaire. String

Valeur renvoyée

Renvoie une date ou une date et heure dans le fuseau horaire UTC. DateTime ou DateTime64

Exemples

Convertir un fuseau horaire en UTC

Query

SELECT toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')

Response

┌─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

toUnixTimestamp(date[, timezone])

Arguments

• date — Valeur à convertir. Date ou Date32 ou DateTime ou DateTime64 ou String
• timezone — Facultatif. Fuseau horaire à utiliser pour la conversion. S’il n’est pas spécifié, le fuseau horaire du serveur est utilisé. String

Valeur renvoyée

Renvoie le timestamp Unix. UInt32

Exemples

Exemple d’utilisation

Query

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

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() 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 dans un format pris en charge par 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

toWeek(datetime[, mode[, time_zone]])

Alias : week

Arguments

• datetime — Date ou date avec heure dont extraire le numéro de semaine. Date ou 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

Valeur renvoyée

Renvoie le numéro de semaine selon le mode spécifié. UInt32

Exemples

Obtenir les numéros de semaine selon différents modes

Query

SELECT toDate('2016-12-27') AS date, toWeek(date) AS week0, toWeek(date,1) AS week1, toWeek(date,9) AS week9

Response

┌───────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

toYYYYMM(datetime[, timezone])

Arguments

• datetime — Une date ou une date avec heure à convertir. Date ou Date32 ou DateTime ou DateTime64
• timezone — Facultatif. Fuseau horaire à utiliser pour la conversion. S’il est fourni, le fuseau horaire doit être une constante de chaîne. String

Valeur renvoyée

Renvoie un nombre UInt32 contenant l’année et le numéro du mois (YYYY * 100 + MM). UInt32

Exemples

Convertir la date actuelle au format YYYYMM

Query

SELECT toYYYYMM(now(), 'US/Eastern')

Response

┌─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

toYYYYMMDD(datetime[, timezone])

Arguments

• datetime — Une date ou une date avec composante horaire à convertir. Date ou Date32 ou DateTime ou 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

Valeur renvoyée

Renvoie un nombre UInt32 contenant l’année, le mois et le jour (YYYY * 10000 + MM * 100 + DD). UInt32

Exemples

Convertir la date actuelle au format YYYYMMDD

Query

SELECT toYYYYMMDD(now(), 'US/Eastern')

Response

┌─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

toYYYYMMDDhhmmss(datetime[, timezone])

Arguments

• datetime — Date ou date avec heure à convertir. Date ou Date32 ou DateTime ou DateTime64
• timezone — Facultatif. Fuseau horaire pour la conversion. S’il est fourni, le fuseau horaire doit être une constante de chaîne. 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

Exemples

Convertir la date et l’heure actuelles au format YYYYMMDDhhmmss

Query

SELECT toYYYYMMDDhhmmss(now(), 'US/Eastern')

Response

┌─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

toYear(datetime)

Alias : YEAR

Arguments

• datetime — Date ou date avec heure à partir de laquelle extraire l’année. Date ou Date32 ou DateTime ou DateTime64

Valeur renvoyée

Renvoie l’année de la valeur Date ou DateTime donnée. UInt16

Exemples

Exemple d’utilisation

Query

SELECT toYear(toDateTime('2023-04-21 10:20:30'))

Response

┌─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

toYearNumSinceEpoch(date)

Arguments

• date — Une date ou une date et heure à convertir. Date ou DateTime ou DateTime64

Valeur renvoyée

Entier positif

Exemples

Exemple

Query

SELECT toYearNumSinceEpoch(toDate('2024-10-01'))

Response

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().

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, dans un format pris en charge par 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

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 ou 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

Valeur renvoyée

Renvoie l’année et le numéro de semaine sous la forme d’une valeur entière combinée. UInt32

Exemples

Obtenir des combinaisons année-semaine avec différents modes

Query

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

┌───────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

today()

Alias : curdate, current_date

Arguments

• Aucun.

Valeur renvoyée

Renvoie la date actuelle Date

Exemples

Exemple d’utilisation

Query

SELECT today() AS today, curdate() AS curdate, current_date() AS current_date FORMAT Pretty

Response

┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃      today ┃    curdate ┃ current_date ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-03 │ 2025-03-03 │   2025-03-03 │
└────────────┴────────────┴──────────────┘

Syntaxe SQL standard sans parenthèses

Query

SELECT TODAY, CURDATE,CURRENT_DATE

Response

┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃      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

yesterday()

Arguments

• Aucun.

Valeur renvoyée

Renvoie la date d’hier. Date

Exemples

Récupérer la date d’hier

Query

SELECT yesterday();
SELECT today() - 1;

Response

┌─yesterday()─┐
│  2025-06-09 │
└─────────────┘
┌─minus(today(), 1)─┐
│        2025-06-09 │
└───────────────────┘