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.
now('UTC'). Elle a été ajoutée uniquement pour la compatibilité avec MySQL. now est l’usage recommandé.
Syntaxe
Alias : UTC_timestamp
Arguments
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
┌──────UTCTimestamp()─┐
│ 2024-05-28 08:32:09 │
└─────────────────────┘
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
Arguments
Valeur renvoyée
Renvoie une valeur Date à partir des arguments fournis Date
Exemples
Exemple
SELECT YYYYMMDDToDate(20230911);
┌─toYYYYMMDD(20230911)─┐
│ 2023-09-11 │
└──────────────────────┘
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)
Date32 à partir des arguments fournis Date32
Exemples
Exemple
SELECT YYYYMMDDToDate32(20000507);
┌─YYYYMMDDToDate32(20000507)─┐
│ 2000-05-07 │
└────────────────────────────┘
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])
YYYYMMDDhhmmss — Nombre contenant l’année, le mois, le jour, l’heure, les minutes et les secondes. (U)Int* ou Float* ou Decimaltimezone — Nom du fuseau horaire. String
Valeur renvoyée
Renvoie une valeur DateTime à partir des arguments fournis DateTime
Exemples
Exemple
SELECT YYYYMMDDToDateTime(20230911131415);
┌──────YYYYMMDDhhmmssToDateTime(20230911131415)─┐
│ 2023-09-11 13:14:15 │
└───────────────────────────────────────────────┘
YYYYMMDDhhmmssToDateTime64
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]])
YYYYMMDDhhmmss — Nombre contenant l’année, le mois, le jour, l’heure, la minute et la seconde. (U)Int* ou Float* ou Decimalprecision — Précision de la partie fractionnaire (0-9). UInt8timezone — Nom du fuseau horaire. String
Valeur renvoyée
Renvoie une valeur DateTime64 à partir des arguments fournis DateTime64
Exemples
Exemple
SELECT YYYYMMDDhhmmssToDateTime64(20230911131415, 3, 'Asia/Istanbul');
┌─YYYYMMDDhhmm⋯/Istanbul')─┐
│ 2023-09-11 13:14:15.000 │
└──────────────────────────┘
addDate(datetime, interval)
interval à datetime. Date ou Date32 ou DateTime ou DateTime64
Exemples
Ajouter un intervalle à une date
SELECT addDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
┌─addDate(toDa⋯valYear(3))─┐
│ 2021-01-01 │
└──────────────────────────┘
datetime plus num jours. Date ou Date32 ou DateTime ou DateTime64
Exemples
Ajouter des jours à différents types de dates
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
┌─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 │
└────────────────────┴─────────────────────────┴────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 day)
┌─plus(CAST('1⋯valDay(10))─┐
│ 1998-06-26 │
└──────────────────────────┘
datetime plus num heures DateTime ou DateTime64(3)
Exemples
Ajouter des heures à différents types de date
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
┌─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 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 hour)
┌─plus(CAST('1⋯alHour(10))─┐
│ 1998-06-16 10:00:00 │
└──────────────────────────┘
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).
addInterval(interval_1, interval_2)
Tuple(Interval)
Exemples
Ajouter des intervalles
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)
┌─addInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,1) │
└───────────────────────────────────────────────────┘
┌─addInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,1) │
└────────────────────────────────────────────────────────────────────────┘
┌─addInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (3) │
└─────────────────────────────────────────────────┘
addMicroseconds(datetime, num)
date_time avec num microsecondes ajoutées DateTime64
Exemples
Ajouter des microsecondes à différents types de date et heure
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
┌─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 │
└─────────────────────────────────┴────────────────────────────────────────┘
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 microsecond)
┌─plus(CAST('19⋯osecond(10))─┐
│ 1998-06-16 00:00:00.000010 │
└────────────────────────────┘
addMilliseconds(datetime, num)
datetime plus num millisecondes DateTime64
Exemples
Ajouter des millisecondes à différents types de date et heure
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
┌─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 │
└─────────────────────────────────┴────────────────────────────────────────┘
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 millisecond)
┌─plus(CAST('1⋯second(10))─┐
│ 1998-06-16 00:00:00.010 │
└──────────────────────────┘
addMinutes(datetime, num)
datetime plus num minutes. DateTime ou DateTime64(3)
Exemples
Ajouter des minutes à différents types de dates
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
┌─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 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 minute)
┌─plus(CAST('1⋯Minute(10))─┐
│ 1998-06-16 00:10:00 │
└──────────────────────────┘
datetime plus num mois. Date ou Date32 ou DateTime ou DateTime64
Exemples
Ajouter des mois à différents types de date
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
┌─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 │
└──────────────────────┴───────────────────────────┴──────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 month)
┌─plus(CAST('1⋯lMonth(10))─┐
│ 1999-04-16 │
└──────────────────────────┘
addNanoseconds(datetime, num)
datetime plus num nanosecondes DateTime64
Exemples
Ajouter des nanosecondes à différents types date-heure
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
┌─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 │
└────────────────────────────────┴───────────────────────────────────────┘
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 1000 nanosecond)
┌─plus(CAST('199⋯osecond(1000))─┐
│ 1998-06-16 00:00:00.000001000 │
└───────────────────────────────┘
addQuarters(datetime, num)
datetime plus num trimestres Date ou Date32 ou DateTime ou DateTime64
Exemples
Ajouter des trimestres à différents types de dates
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
┌─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 │
└────────────────────────┴─────────────────────────────┴────────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 quarter)
┌─plus(CAST('1⋯uarter(10))─┐
│ 2000-12-16 │
└──────────────────────────┘
addSeconds(datetime, num)
datetime plus num secondes DateTime ou DateTime64(3)
Exemples
Ajouter des secondes à différents types de date
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
┌─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 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 second)
┌─dateAdd('1998-06-16'::Date, INTERVAL 10 second)─┐
│ 1998-06-16 00:00:10 │
└─────────────────────────────────────────────────┘
addTupleOfIntervals(datetime, intervals)
date après ajout des intervals Date ou Date32 ou DateTime ou DateTime64
Exemples
Ajouter un tuple d’intervalles à une date
WITH toDate('2018-01-01') AS date
SELECT addTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 MONTH, INTERVAL 1 YEAR))
┌─addTupleOfIntervals(date, (toIntervalDay(1), toIntervalMonth(1), toIntervalYear(1)))─┐
│ 2019-02-02 │
└──────────────────────────────────────────────────────────────────────────────────────┘
datetime plus num semaines. Date ou Date32 ou DateTime ou DateTime64
Exemples
Ajouter des semaines à différents types de dates
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
┌─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 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 week)
┌─plus(CAST('1⋯alWeek(10))─┐
│ 1998-08-25 │
└──────────────────────────┘
datetime plus num ans. Date ou Date32 ou DateTime ou DateTime64
Exemples
Ajouter des années à différents types de dates
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
┌─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 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 year)
┌─plus(CAST('1⋯alYear(10))─┐
│ 2008-06-16 │
└──────────────────────────┘
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])
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 DateTime64enddate — Deuxième valeur temporelle à partir de laquelle soustraire (le terme duquel on soustrait). Date ou Date32 ou DateTime ou DateTime64timezone — 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
SELECT age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))
┌─age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))─┐
│ 24 │
└───────────────────────────────────────────────────────────────────────────────────┘
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
┌──────────e─┬──────────s─┬─day_age─┬─month_age─┬─year_age─┐
│ 2022-01-01 │ 2021-12-29 │ 3 │ 0 │ 0 │
└────────────┴────────────┴─────────┴───────────┴──────────┘
changeDay(date_or_datetime, value)
date_or_datetime dont la composante de jour a été modifiée. Date ou Date32 ou DateTime ou DateTime64
Exemples
Exemple d’utilisation
SELECT changeDay('2024-01-31'::DateTime, 15)
changeHour(date_or_datetime, value)
date_or_datetime, avec la composante heure modifiée. DateTime ou DateTime64
Exemples
Exemple d’utilisation
SELECT changeHour('2024-01-01 12:00:00'::DateTime, 5)
date ou date/heure.
Syntaxe
changeMinute(date_or_datetime, value)
date_or_datetime, dont la composante minute est modifiée. DateTime ou DateTime64
Exemples
Exemple d’utilisation
SELECT changeMinute('2024-01-01 12:30:00'::DateTime, 45)
changeMonth(date_or_datetime, value)
date_or_datetime dont le mois a été modifié. Date ou Date32 ou DateTime ou DateTime64
Exemples
Exemple d’utilisation
SELECT changeMonth('2024-01-01'::DateTime, 12)
changeSecond(date_or_datetime, value)
date_or_datetime dont la composante des secondes est modifiée. DateTime ou DateTime64
Exemples
Exemple d’utilisation
SELECT changeSecond('2024-01-01 12:30:45'::DateTime, 15)
changeYear(date_or_datetime, value)
date_or_datetime dont la composante année a été modifiée. Date ou Date32 ou DateTime ou DateTime64
Exemples
Exemple d’utilisation
SELECT changeYear('2024-01-01'::DateTime, 2023)
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])
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 DateTime64enddate — La seconde valeur temporelle, de laquelle la première est soustraite (le terme diminué). Date ou Date32 ou DateTime ou DateTime64timezone — 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
SELECT dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res
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
┌──────────e─┬──────────s─┬─day_diff─┬─month_diff─┬─year_diff─┐
│ 2022-01-01 │ 2021-12-29 │ 3 │ 1 │ 1 │
└────────────┴────────────┴──────────┴────────────┴───────────┘
- ‘year’
- ‘quarter’
- ‘month’
- ‘week’
- ‘dayofyear’
- ‘day’
- ‘weekday’
- ‘hour’
- ‘minute’
- ‘second’
Syntaxe
dateName(date_part, date[, timezone])
date_part — La partie de la date que vous souhaitez extraire. Stringdatetime — Une valeur de date ou de date avec heure. Date ou Date32 ou DateTime ou DateTime64timezone — 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
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT
dateName('year', date_value),
dateName('month', date_value),
dateName('day', date_value)
┌─dateName('year', date_value)─┬─dateName('month', date_value)─┬─dateName('day', date_value)─┐
│ 2021 │ April │ 14 │
└──────────────────────────────┴───────────────────────────────┴─────────────────────────────┘
dateTrunc(unit, datetime[, timezone])
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.
Stringdatetime — Date et heure. Date ou Date32 ou DateTime ou DateTime64timezone — 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 |
SELECT now(), dateTrunc('hour', now());
┌───────────────now()─┬─dateTrunc('hour', now())──┐
│ 2020-09-28 10:40:45 │ 2020-09-28 10:00:00 │
└─────────────────────┴───────────────────────────┘
SELECT now(), dateTrunc('hour', now(), 'Asia/Istanbul');
┌───────────────now()─┬─dateTrunc('hour', now(), 'Asia/Istanbul')──┐
│ 2020-09-28 10:46:26 │ 2020-09-28 13:00:00 │
└─────────────────────┴────────────────────────────────────────────┘
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])
DATE_FORMAT
Arguments
datetime — Une date ou une date et heure à formater. Date ou Date32 ou DateTime ou DateTime64format — Chaîne de format avec des champs de remplacement. Stringtimezone — 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
SELECT formatDateTime(toDate('2010-01-04'), '%g')
┌─formatDateTime(toDate('2010-01-04'), '%g')─┐
│ 10 │
└────────────────────────────────────────────┘
SELECT formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')
┌─formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')─┐
│ 1234560 │
└─────────────────────────────────────────────────────────────────────┘
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
┌──────────────────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 │
└─────────────────────┴───────────────────┴─────────────┘
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 | ’ |
formatDateTimeInJodaSyntax(datetime, format[, timezone])
datetime — Une date ou une date et une heure à formater. DateTime ou Date ou Date32 ou DateTime64format — Chaîne de format avec des champs de remplacement de style Joda. Stringtimezone — 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
SELECT formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')
┌─formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')─┐
│ 2010-01-04 12:34:56 │
└─────────────────────────────────────────────────────────────────────────────────────────┘
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)
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
SELECT
fromDaysSinceYearZero(739136) AS date1,
fromDaysSinceYearZero(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
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)
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
SELECT
fromDaysSinceYearZero32(739136) AS date1,
fromDaysSinceYearZero32(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
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)
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
SELECT fromModifiedJulianDay(58849)
┌─fromModifiedJulianDay(58849)─┐
│ 2020-01-01 │
└──────────────────────────────┘
fromModifiedJulianDayOrNull
fromModifiedJulianDay(), mais au lieu de générer une exception, cette fonction renvoie NULL.
Syntaxe
fromModifiedJulianDayOrNull(day)
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
SELECT fromModifiedJulianDayOrNull(58849);
SELECT fromModifiedJulianDayOrNull(60000000); -- invalid argument, returns NULL
┌─fromModified⋯Null(58849)─┐
│ 2020-01-01 │
└──────────────────────────┘
┌─fromModified⋯l(60000000)─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
fromUTCTimestamp(datetime, time_zone)
from_utc_timestamp
Arguments
datetime — Une valeur constante de type date ou date avec heure, ou une expression. DateTime ou DateTime64time_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é
SELECT fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00', 3), 'Asia/Shanghai')
┌─fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00',3), 'Asia/Shanghai')─┐
│ 2023-03-16 18:00:00.000 │
└─────────────────────────────────────────────────────────────────────────┘
- 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]])
FROM_UNIXTIME
Arguments
timestamp — Horodatage Unix ou valeur de date/date avec heure. (U)Int* ou Date ou Date32 ou DateTime ou DateTime64format — Facultatif. Chaîne de format constante pour le formatage de sortie. Stringtimezone — 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
SELECT fromUnixTimestamp(423543535)
┌─fromUnixTimestamp(423543535)─┐
│ 1983-06-04 10:58:55 │
└──────────────────────────────┘
SELECT fromUnixTimestamp(1234334543, '%Y-%m-%d %R:%S') AS DateTime
┌─DateTime────────────┐
│ 2009-02-11 14:42:23 │
└─────────────────────┘
fromUnixTimestampInJodaSyntax
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])
timestamp — Horodatage Unix ou valeur de date/heure. (U)Int* ou Date ou Date32 ou DateTime ou DateTime64format — Facultatif. Chaîne de format constante utilisant la syntaxe Joda pour le formatage de sortie. Stringtimezone — 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
SELECT fromUnixTimestampInJodaSyntax(1234334543, 'yyyy-MM-dd HH:mm:ss', 'UTC') AS DateTime
┌─DateTime────────────┐
│ 2009-02-11 06:42:23 │
└─────────────────────┘
LOCALTIME SQL standard / PostgreSQL, et elle est équivalente à CAST(now() AS Time).
Syntaxe
Arguments
Valeur renvoyée
Renvoie l’heure actuelle. Time
Exemples
Syntaxe SQL standard sans parenthèses
┌───────LOCALTIME─┐
│ 07:42:09 │
└─────────────────┘
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)
Date construite à partir des arguments fournis Date
Exemples
Date à partir d’une année, d’un mois et d’un jour
SELECT makeDate(2023, 2, 28) AS date;
┌───────date─┐
│ 2023-02-28 │
└────────────┘
SELECT makeDate(2023, 42) AS date;
┌───────date─┐
│ 2023-02-11 │
└────────────┘
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)
Date32 construite à partir des arguments fournis Date32
Exemples
Date32 à partir d’une année, d’un mois et d’un jour
SELECT makeDate(2023, 2, 28) AS date;
┌───────date─┐
│ 2023-02-28 │
└────────────┘
SELECT makeDate(2023, 42) AS date;
┌───────date─┐
│ 2023-02-11 │
└────────────┘
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])
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
SELECT makeDateTime(2023, 2, 28, 17, 12, 33) AS DateTime;
┌────────────DateTime─┐
│ 2023-02-28 17:12:33 │
└─────────────────────┘
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]]])
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
SELECT makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5);
┌─makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5)─┐
│ 2023-05-15 10:30:45.00779 │
└─────────────────────────────────────────────────┘
String
Exemples
Obtenir le nom du mois à partir d’une date
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT monthName(date_value)
┌─monthName(date_value)─┐
│ April │
└───────────────────────┘
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
┌───────────────now()─┐
│ 2020-10-17 07:42:09 │
└─────────────────────┘
SELECT now('Asia/Istanbul')
┌─now('Asia/Istanbul')─┐
│ 2020-10-17 10:42:23 │
└──────────────────────┘
SELECT NOW, CURRENT_TIMESTAMP
┌─────────────────NOW─┬───CURRENT_TIMESTAMP─┐
│ 2020-10-17 07:42:19 │ 2020-10-17 07:42:19 │
└─────────────────────┴─────────────────────┘
now64([scale[, timezone]])
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). UInt8timezone — 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
SELECT now64(), now64(9, 'Asia/Istanbul')
┌─────────────────now64()─┬─────now64(9, 'Asia/Istanbul')─┐
│ 2022-08-21 19:34:26.196 │ 2022-08-21 22:34:26.196542766 │
└─────────────────────────┴───────────────────────────────┘
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
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()
SELECT
now(),
nowInBlock(),
sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock
┌───────────────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([scale[, timezone]])
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). UInt8timezone — 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()
SELECT
now64(),
nowInBlock64(),
sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock
┌─────────────────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 │
└─────────────────────────┴─────────────────────────┴──────────┘
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
Alias : serverTimeZone
Arguments
Valeur renvoyée
Renvoie le fuseau horaire du serveur sous forme de String
Exemples
Exemple d’utilisation
┌─serverTimeZone()─┐
│ UTC │
└──────────────────┘
subDate(datetime, interval)
interval à datetime. Date ou Date32 ou DateTime ou DateTime64
Exemples
Soustraire un intervalle à une date
SELECT subDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
┌─subDate(toDate('2018-01-01'), toIntervalYear(3))─┐
│ 2015-01-01 │
└──────────────────────────────────────────────────┘
subtractDays(datetime, num)
datetime moins num jours Date ou Date32 ou DateTime ou DateTime64
Exemples
Soustraire des jours à différents types de date
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
┌─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 │
└─────────────────────────┴──────────────────────────────┴─────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 day)
┌─minus(CAST('⋯valDay(10))─┐
│ 1998-06-06 │
└──────────────────────────┘
subtractHours(datetime, num)
datetime moins num heures DateTime or DateTime64(3)
Exemples
Soustraire des heures à différents types de date
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
┌─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 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 hour)
┌─minus(CAST('⋯alHour(10))─┐
│ 1998-06-15 14:00:00 │
└──────────────────────────┘
toIntervalDay(2) et toIntervalDay(1) sont
passés, le résultat sera (1) plutôt que (2,1).
Syntaxe
subtractInterval(interval_1, interval_2)
Tuple(T)
Exemples
Soustraction d’intervalles
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);
┌─subtractInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,-1) │
└────────────────────────────────────────────────────────┘
┌─subtractInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,-1) │
└─────────────────────────────────────────────────────────────────────────────┘
┌─subtractInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (1) │
└──────────────────────────────────────────────────────┘
subtractMicroseconds(datetime, num)
datetime moins num microsecondes DateTime64
Exemples
Soustraire des microsecondes de différents types de date avec heure
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
┌─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 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 microsecond)
┌─minus(CAST('1⋯osecond(10))─┐
│ 1998-06-15 23:59:59.999990 │
└────────────────────────────┘
subtractMilliseconds(datetime, num)
datetime moins num millisecondes. DateTime64
Exemples
Soustraire des millisecondes à différents types de dates et d’heures
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
┌─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 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 millisecond)
┌─minus(CAST('⋯second(10))─┐
│ 1998-06-15 23:59:59.990 │
└──────────────────────────┘
subtractMinutes(datetime, num)
datetime moins num minutes. DateTime or DateTime64(3)
Exemples
Soustraire des minutes à différents types de dates
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
┌─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 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 minute)
┌─minus(CAST('⋯Minute(10))─┐
│ 1998-06-15 23:50:00 │
└──────────────────────────┘
subtractMonths(datetime, num)
datetime moins num mois. Date ou Date32 ou DateTime ou DateTime64
Exemples
Soustraction de mois à différents types de date
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
┌─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 │
└───────────────────────────┴────────────────────────────────┴───────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 month)
┌─minus(CAST('⋯lMonth(10))─┐
│ 1997-08-16 │
└──────────────────────────┘
subtractNanoseconds(datetime, num)
datetime moins num nanosecondes DateTime64
Exemples
Soustraire des nanosecondes à différents types de date avec heure
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
┌─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 │
└─────────────────────────────────────┴────────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 nanosecond)
┌─minus(CAST('19⋯anosecond(10))─┐
│ 1998-06-15 23:59:59.999999990 │
└───────────────────────────────┘
subtractQuarters(datetime, num)
datetime moins num trimestres Date ou Date32 ou DateTime ou DateTime64
Exemples
Soustraire des trimestres à différents types de dates
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
┌─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 │
└─────────────────────────────┴──────────────────────────────────┴─────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 quarter)
┌─minus(CAST('1⋯Quarter(10))─┐
│ 1996-09-16 │
└───────────────────────────┘
subtractSeconds(datetime, num)
datetime moins num secondes. DateTime ou DateTime64(3)
Exemples
Soustraire des secondes à différents types de dates
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
┌─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 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 second)
┌─minus(CAST('⋯Second(10))─┐
│ 1998-06-15 23:59:50 │
└──────────────────────────┘
subtractTupleOfIntervals(datetime, intervals)
date après soustraction des intervals Date or Date32 or DateTime or DateTime64
Exemples
Soustraire un tuple d’intervalles d’une date
WITH toDate('2018-01-01') AS date SELECT subtractTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 YEAR))
┌─subtractTupl⋯alYear(1)))─┐
│ 2016-12-31 │
└──────────────────────────┘
subtractWeeks(datetime, num)
datetime moins num semaines. Date ou Date32 ou DateTime ou DateTime64
Exemples
Soustraire des semaines à différents types de dates
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
┌─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 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 week)
┌─minus(CAST('⋯alWeek(10))─┐
│ 1998-04-07 │
└──────────────────────────┘
subtractYears(datetime, num)
datetime moins num ans Date ou Date32 ou DateTime ou DateTime64
Exemples
Soustraire des années à différents types de date
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
┌─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 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 year)
┌─minus(CAST('⋯alYear(10))─┐
│ 1988-06-16 │
└──────────────────────────┘
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)
enddate et startdate, exprimée en secondes. Int64
Exemples
Calculer la différence en secondes
SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res
┌───res─┐
│ 90000 │
└───────┘
SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) / 3600 AS hours
┌─hours─┐
│ 25 │
└───────┘
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
┌─time_diff_result─┬─date_diff_result─┐
│ 259200 │ 259200 │
└──────────────────┴──────────────────┘
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.
timeSlot(time[, time_zone])
time — Heure à arrondir au début d’un intervalle d’une demi-heure. DateTime ou Date32 ou DateTime64time_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
SELECT timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))
┌─timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))─┐
│ 2000-01-02 03:00:00 │
└────────────────────────────────────────────────────┘
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])
StartTime — Heure de début de l’intervalle. DateTime ou DateTime64Duration — Durée de l’intervalle en secondes. UInt32 ou DateTime64Size — 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
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))
┌─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'] │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────┘
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])
expr — Date ou date avec heure. Stringexpr_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)
SELECT timestamp('2023-12-31') AS ts;
┌─────────────────────────ts─┐
│ 2023-12-31 00:00:00.000000 │
└────────────────────────────┘
SELECT timestamp('2023-12-31 12:00:00', '12:00:00.11') AS ts;
┌─────────────────────────ts─┐
│ 2024-01-01 00:00:00.110000 │
└────────────────────────────┘
timeZone
Arguments
Valeur renvoyée
Renvoie le nom canonique du fuseau horaire sous forme de String
Exemples
Exemple d’utilisation
┌─timezone()───────┐
│ Europe/Amsterdam │
└──────────────────┘
DateTime ou DateTime64.
Syntaxe
Alias : timeZoneOf
Arguments
datetime — Une valeur de type DateTime ou DateTime64timezone — 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
SELECT timezoneOf(now());
┌─timezoneOf(now())─┐
│ Europe/Amsterdam │
└───────────────────┘
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
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;
┌────────────────Time─┬─Type─────────────────────────┬─Offset_in_seconds─┬─Offset_in_hours─┐
│ 2021-04-21 10:20:30 │ DateTime('America/New_York') │ -14400 │ -4 │
└─────────────────────┴──────────────────────────────┴───────────────────┴─────────────────┘
Date ou d’un DateTime.
Syntaxe
Alias : DAY, DAYOFMONTH
Arguments
Valeur renvoyée
Renvoie le jour du mois de la date/heure donnée UInt8
Exemples
Exemple d’utilisation
SELECT toDayOfMonth(toDateTime('2023-04-21 10:20:30'))
┌─toDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 21 │
└─────────────────────────────────────────────────┘
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 |
toDayOfWeek(datetime[, mode[, timezone]])
DAYOFWEEK
Arguments
datetime — Date ou date avec heure à partir de laquelle extraire le jour de la semaine. Date ou Date32 ou DateTime ou DateTime64mode — Facultatif. Entier spécifiant le mode de semaine (0-3). La valeur par défaut est 0 s’il est omis. UInt8timezone — 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
-- The following date is April 21, 2023, which was a Friday:
SELECT
toDayOfWeek(toDateTime('2023-04-21')),
toDayOfWeek(toDateTime('2023-04-21'), 1)
┌─toDayOfWeek(toDateTime('2023-04-21'))─┬─toDayOfWeek(toDateTime('2023-04-21'), 1)─┐
│ 5 │ 4 │
└───────────────────────────────────────┴──────────────────────────────────────────┘
Date ou DateTime.
Syntaxe
Alias : DAYOFYEAR
Arguments
Valeur renvoyée
Renvoie le jour de l’année pour la valeur Date ou DateTime donnée UInt16
Exemples
Exemple d’utilisation
SELECT toDayOfYear(toDateTime('2023-04-21 10:20:30'))
┌─toDayOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 111 │
└────────────────────────────────────────────────┘
Date ou d’un DateTime.
La valeur renvoyée est comprise entre 28 et 31.
Syntaxe
Arguments
Valeur renvoyée
Renvoie le nombre de jours du mois de la date/heure donnée. UInt8
Exemples
Exemple d’utilisation
SELECT toDaysInMonth(toDate('2023-02-01')), toDaysInMonth(toDate('2024-02-01')), toDaysInMonth(toDate('2023-01-01'))
┌─toDaysInMonth(toDate('2023-02-01'))─┬─toDaysInMonth(toDate('2024-02-01'))─┬─toDaysInMonth(toDate('2023-01-01'))─┐
│ 28 │ 29 │ 31 │
└─────────────────────────────────────┴─────────────────────────────────────┴─────────────────────────────────────┘
TO_DAYS de MySQL.
Syntaxe
toDaysSinceYearZero(date[, time_zone])
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 DateTime64time_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
SELECT toDaysSinceYearZero(toDate('2023-09-08'))
┌─toDaysSinceYearZero(toDate('2023-09-08')))─┐
│ 713569 │
└────────────────────────────────────────────┘
DateTime ou DateTime64.
Syntaxe
Alias : HOUR
Arguments
Valeur renvoyée
Renvoie l’heure (0 à 23) de datetime. UInt8
Exemples
Exemple d’utilisation
SELECT toHour(toDateTime('2023-04-21 10:20:30'))
┌─toHour(toDateTime('2023-04-21 10:20:30'))─┐
│ 10 │
└───────────────────────────────────────────┘
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])
datetime — Date ou date avec heure à partir de laquelle obtenir le numéro de semaine ISO. Date ou DateTime ou Date32 ou DateTime64timezone — 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
SELECT toDate('2016-12-27') AS date, toISOWeek(date) AS isoWeek
┌───────date─┬─isoWeek─┐
│ 2016-12-27 │ 52 │
└────────────┴─────────┘
SELECT toDate('2025-12-29') AS date, toISOWeek(date) AS isoWeek, toYear(date) AS year
┌───────date─┬─isoWeek─┬─year─┐
│ 2025-12-29 │ 1 │ 2025 │
└────────────┴─────────┴──────┘
UInt16
Exemples
Obtenir l’année ISO à partir de valeurs de date
SELECT
toISOYear(toDate('2024/10/02')) as year1,
toISOYear(toDateTime('2024-10-02 01:30:00')) as year2
┌─week1─┬─week2─┐
│ 40 │ 40 │
└───────┴───────┘
LAST_DAY
Arguments
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
SELECT toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))
┌─toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-30 │
└─────────────────────────────────────────────────────┘
toLastDayOfWeek(datetime[, mode[, timezone]])
datetime — Une date avec heure ou une date à convertir. Date ou DateTime ou Date32 ou DateTime64mode — Détermine le premier jour de la semaine, comme décrit dans la fonction toWeek(). Valeur par défaut : 0. UInt8timezone — 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
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
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
DateTime64.
Syntaxe
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
SELECT toMicrosecond(toDateTime64('2023-04-21 10:20:30.456789', 6));
┌─toMicrosecond(toDateTime64('2023-04-21 10:20:30.456789', 6))─┐
│ 456789 │
└──────────────────────────────────────────────────────────────┘
DateTime ou DateTime64.
Syntaxe
Alias : MILLISECOND
Arguments
Valeur renvoyée
Renvoie la minute (0 - 59) de datetime. UInt16
Exemples
Exemple d’utilisation
SELECT toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3));
┌──toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3))─┐
│ 456 │
└────────────────────────────────────────────────────────────┘
Date ou DateTime.
Syntaxe
Alias : MINUTE
Arguments
Valeur renvoyée
Renvoie la minute de l’heure (0 - 59) de datetime. UInt8
Exemples
Exemple d’utilisation
SELECT toMinute(toDateTime('2023-04-21 10:20:30'))
┌─toMinute(toDateTime('2023-04-21 10:20:30'))─┐
│ 20 │
└─────────────────────────────────────────────┘
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)
Int32
Exemples
Convertir une date en numéro de jour julien modifié
SELECT toModifiedJulianDay('2020-01-01')
┌─toModifiedJulianDay('2020-01-01')─┐
│ 58849 │
└───────────────────────────────────┘
toModifiedJulianDayOrNull
toModifiedJulianDay(), mais au lieu de déclencher des exceptions, elle renvoie NULL.
Syntaxe
toModifiedJulianDayOrNull(date)
date est valide, sinon null. Nullable(Int32)
Exemples
Convertir une date en numéro de jour julien modifié avec gestion des valeurs nulles
SELECT toModifiedJulianDayOrNull('2020-01-01');
SELECT toModifiedJulianDayOrNull('0000-00-00'); -- invalid date, returns NULL
┌─toModifiedJu⋯020-01-01')─┐
│ 58849 │
└──────────────────────────┘
┌─toModifiedJu⋯000-00-00')─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
Date
Exemples
Arrondir au lundi de la semaine
SELECT
toMonday(toDateTime('2023-04-21 10:20:30')), -- A Friday
toMonday(toDate('2023-04-24')); -- Already a Monday
┌─toMonday(toDateTime('2023-04-21 10:20:30'))─┬─toMonday(toDate('2023-04-24'))─┐
│ 2023-04-17 │ 2023-04-24 │
└─────────────────────────────────────────────┴────────────────────────────────┘
Date ou DateTime.
Syntaxe
Alias : MONTH
Arguments
Valeur renvoyée
Renvoie le mois de la date/heure donnée UInt8
Exemples
Exemple d’utilisation
SELECT toMonth(toDateTime('2023-04-21 10:20:30'))
┌─toMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 4 │
└────────────────────────────────────────────┘
toMonthNumSinceEpoch(date)
SELECT toMonthNumSinceEpoch(toDate('2024-10-01'))
DateTime64.
Syntaxe
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
SELECT toNanosecond(toDateTime64('2023-04-21 10:20:30.123456789', 9));
┌─toNanosecond(toDateTime64('2023-04-21 10:20:30.123456789', 9))─┐
│ 123456789 │
└────────────────────────────────────────────────────────────────┘
Date ou DateTime donnée.
Syntaxe
Alias : QUARTER
Arguments
Valeur renvoyée
Renvoie le trimestre de l’année pour la date/l’heure donnée UInt8
Exemples
Exemple d’utilisation
SELECT toQuarter(toDateTime('2023-04-21 10:20:30'))
┌─toQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2 │
└──────────────────────────────────────────────┘
toRelativeDayNum(dt1) - toRelativeDayNum(dt2).
Syntaxe
Arguments
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
SELECT toRelativeDayNum(toDate('2023-04-01')) - toRelativeDayNum(toDate('2023-01-01'))
┌─minus(toRela⋯3-01-01')))─┐
│ 90 │
└──────────────────────────┘
toRelativeHourNum(dt1) - toRelativeHourNum(dt2).
Syntaxe
Arguments
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
SELECT toRelativeHourNum(toDateTime('2023-01-01 12:00:00')) - toRelativeHourNum(toDateTime('2023-01-01 00:00:00')) AS hours_difference
┌─hours_difference─┐
│ 12 │
└──────────────────┘
toRelativeMinuteNum(dt1) - toRelativeMinuteNum(dt2).
Syntaxe
toRelativeMinuteNum(date)
UInt32
Exemples
Obtenir les numéros de minute relatifs
SELECT toRelativeMinuteNum(toDateTime('2023-01-01 00:30:00')) - toRelativeMinuteNum(toDateTime('2023-01-01 00:00:00')) AS minutes_difference
┌─minutes_difference─┐
│ 30 │
└────────────────────┘
toRelativeMonthNum(dt1) - toRelativeMonthNum(dt2).
Syntaxe
Arguments
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
SELECT toRelativeMonthNum(toDate('2023-04-01')) - toRelativeMonthNum(toDate('2023-01-01')) AS months_difference
┌─months_difference─┐
│ 3 │
└───────────────────┘
toRelativeQuarterNum(dt1) - toRelativeQuarterNum(dt2).
Syntaxe
toRelativeQuarterNum(date)
UInt32
Exemples
Obtenir les numéros de trimestre relatifs
SELECT toRelativeQuarterNum(toDate('2023-04-01')) - toRelativeQuarterNum(toDate('2023-01-01')) AS quarters_difference
┌─quarters_difference─┐
│ 1 │
└─────────────────────┘
toRelativeSecondNum(dt1) - toRelativeSecondNum(dt2).
Syntaxe
toRelativeSecondNum(date)
UInt32
Exemples
Obtenir des numéros de secondes relatifs
SELECT toRelativeSecondNum(toDateTime('2023-01-01 00:01:00')) - toRelativeSecondNum(toDateTime('2023-01-01 00:00:00')) AS seconds_difference
┌─seconds_difference─┐
│ 60 │
└────────────────────┘
toRelativeWeekNum(dt1) - toRelativeWeekNum(dt2).
Syntaxe
Arguments
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
SELECT toRelativeWeekNum(toDate('2023-01-08')) - toRelativeWeekNum(toDate('2023-01-01')) AS weeks_difference
┌─weeks_difference─┐
│ 1 │
└──────────────────┘
toRelativeYearNum(dt1) - toRelativeYearNum(dt2).
Syntaxe
Arguments
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
SELECT toRelativeYearNum('2010-10-01'::DateTime) - toRelativeYearNum('2000-01-01'::DateTime)
┌─minus(toRela⋯ateTime')))─┐
│ 10 │
└──────────────────────────┘
DateTime ou DateTime64.
Syntaxe
Alias : SECOND
Arguments
Valeur renvoyée
Renvoie la seconde de la minute (0 à 59) de datetime. UInt8
Exemples
Exemple d’utilisation
SELECT toSecond(toDateTime('2023-04-21 10:20:30'))
┌─toSecond(toDateTime('2023-04-21 10:20:30'))─┐
│ 30 │
└─────────────────────────────────────────────┘
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
SELECT toStartOfDay(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfDay(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-21 00:00:00 │
└─────────────────────────────────────────────────┘
toStartOfFifteenMinutes(datetime)
DateTime ou DateTime64
Exemples
Exemple
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
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(datetime)
toStartOfFiveMinute
Arguments
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
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
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
DateTime ou DateTime64
Exemples
Arrondir à l’inférieur au début de l’heure
SELECT
toStartOfHour(toDateTime('2023-04-21 10:20:30'));
┌─────────────────res─┬─toTypeName(res)─┐
│ 2023-04-21 10:00:00 │ DateTime │
└─────────────────────┴─────────────────┘
Date
Exemples
Arrondir à l’inférieur au premier jour de l’année ISO
SELECT toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-01-02 │
└─────────────────────────────────────────────────────┘
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. | |
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]])
time_bucket, date_bin
Arguments
value — Valeur de type Date ou date avec heure à arrondir à l’unité inférieure. Date ou DateTime ou DateTime64x — 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
SELECT toStartOfInterval(toDateTime('2023-01-15 14:30:00'), INTERVAL 1 MONTH)
┌─toStartOfInt⋯alMonth(1))─┐
│ 2023-01-01 │
└──────────────────────────┘
SELECT toStartOfInterval(toDateTime('2023-01-01 14:45:00'), INTERVAL 1 MINUTE, toDateTime('2023-01-01 14:35:30'))
┌─toStartOfInt⋯14:35:30'))─┐
│ 2023-01-01 14:44:30 │
└──────────────────────────┘
toStartOfMicrosecond(datetime[, timezone])
datetime — Date et heure. DateTime64timezone — 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
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64);
┌────toStartOfMicrosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999000 │
└───────────────────────────────┘
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64, 'Asia/Istanbul');
┌─toStartOfMicrosecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999999000 │
└─────────────────────────────────────────────┘
toStartOfMillisecond(datetime[, timezone])
datetime — Date et heure. DateTime64timezone — 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
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64);
┌────toStartOfMillisecond(dt64)─┐
│ 2020-01-01 10:20:30.999000000 │
└───────────────────────────────┘
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64, 'Asia/Istanbul');
┌─toStartOfMillisecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999000000 │
└─────────────────────────────────────────────┘
toStartOfMinute(datetime)
DateTime ou DateTime64
Exemples
Arrondir à l’inférieur au début de la minute
SELECT
toStartOfMinute(toDateTime('2023-04-21 10:20:30')),
toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8))
FORMAT Vertical
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
Date
Exemples
Arrondir à l’inférieur au premier jour du mois
SELECT toStartOfMonth(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└───────────────────────────────────────────────────┘
toStartOfNanosecond(datetime[, timezone])
datetime — Date et heure. DateTime64timezone — 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
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64);
┌─────toStartOfNanosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999999 │
└───────────────────────────────┘
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64, 'Asia/Istanbul');
┌─toStartOfNanosecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999999999 │
└────────────────────────────────────────────┘
Date
Exemples
Ramener à l’inférieur au premier jour du trimestre
SELECT toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└─────────────────────────────────────────────────────┘
toStartOfSecond(datetime[, timezone])
datetime — Date et heure dont il faut tronquer les fractions de seconde. DateTime64timezone — 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
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64);
┌───toStartOfSecond(dt64)─┐
│ 2020-01-01 10:20:30.000 │
└─────────────────────────┘
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64, 'Asia/Istanbul');
┌─toStartOfSecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 13:20:30.000 │
└────────────────────────────────────────┘
toStartOfTenMinutes(datetime)
DateTime ou DateTime64
Exemples
Exemple
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
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(datetime[, mode[, timezone]])
datetime — Une date, avec ou sans heure, à convertir. Date ou DateTime ou Date32 ou DateTime64mode — Détermine le premier jour de la semaine comme décrit dans la fonction toWeek(). Valeur par défaut : 0. UInt8timezone — 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
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
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
Date.
Syntaxe
Arguments
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
SELECT toStartOfYear(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-01-01 │
└──────────────────────────────────────────────────┘
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])
DateTime
Exemples
Calculer l’écart horaire entre deux dates
SELECT toTimeWithFixedDate('2025-06-15 12:00:00'::DateTime) - toTimeWithFixedDate('2024-05-10 11:00:00'::DateTime) AS result, toTypeName(result)
┌─result─┬─toTypeName(result)─┐
│ 3600 │ Int32 │
└────────┴────────────────────┘
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)
toTimeZone
Arguments
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
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;
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(datetime, time_zone)
to_utc_timestamp
Arguments
datetime — Une valeur constante de type date ou date et heure, ou une expression. DateTime ou DateTime64time_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
SELECT toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')
┌─toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')─┐
│ 2023-03-15 16:00:00 │
└─────────────────────────────────────────────────────────┘
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])
date — Valeur à convertir. Date ou Date32 ou DateTime ou DateTime64 ou Stringtimezone — 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
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;
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() 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 |
- 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]])
week
Arguments
datetime — Date ou date avec heure dont extraire le numéro de semaine. Date ou DateTimemode — 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
SELECT toDate('2016-12-27') AS date, toWeek(date) AS week0, toWeek(date,1) AS week1, toWeek(date,9) AS week9
┌───────date─┬─week0─┬─week1─┬─week9─┐
│ 2016-12-27 │ 52 │ 52 │ 1 │
└────────────┴───────┴───────┴───────┘
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])
datetime — Une date ou une date avec heure à convertir. Date ou Date32 ou DateTime ou DateTime64timezone — 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
SELECT toYYYYMM(now(), 'US/Eastern')
┌─toYYYYMM(now(), 'US/Eastern')─┐
│ 202303 │
└───────────────────────────────┘
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])
datetime — Une date ou une date avec composante horaire à convertir. Date ou Date32 ou DateTime ou DateTime64timezone — 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
SELECT toYYYYMMDD(now(), 'US/Eastern')
┌─toYYYYMMDD(now(), 'US/Eastern')─┐
│ 20230302 │
└─────────────────────────────────┘
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])
datetime — Date ou date avec heure à convertir. Date ou Date32 ou DateTime ou DateTime64timezone — 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
SELECT toYYYYMMDDhhmmss(now(), 'US/Eastern')
┌─toYYYYMMDDhhmmss(now(), 'US/Eastern')─┐
│ 20230302112209 │
└───────────────────────────────────────┘
Date ou DateTime.
Syntaxe
Alias : YEAR
Arguments
Valeur renvoyée
Renvoie l’année de la valeur Date ou DateTime donnée. UInt16
Exemples
Exemple d’utilisation
SELECT toYear(toDateTime('2023-04-21 10:20:30'))
┌─toYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023 │
└───────────────────────────────────────────┘
toYearNumSinceEpoch(date)
SELECT toYearNumSinceEpoch(toDate('2024-10-01'))
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]])
yearweek
Arguments
datetime — Date ou date avec heure pour laquelle obtenir l’année et le numéro de semaine. Date ou DateTimemode — 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
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
┌───────date─┬─yearWeek0─┬─yearWeek1─┬─yearWeek9─┬─prev_yearWeek─┐
│ 2016-12-27 │ 201652 │ 201652 │ 201701 │ 202152 │
└────────────┴───────────┴───────────┴───────────┴───────────────┘
toDate(now()).
Syntaxe
Alias : curdate, current_date
Arguments
Valeur renvoyée
Renvoie la date actuelle Date
Exemples
Exemple d’utilisation
SELECT today() AS today, curdate() AS curdate, current_date() AS current_date FORMAT Pretty
┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ today ┃ curdate ┃ current_date ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-03 │ 2025-03-03 │ 2025-03-03 │
└────────────┴────────────┴──────────────┘
SELECT TODAY, CURDATE,CURRENT_DATE
┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ TODAY ┃ CURDATE ┃ CURRENT_DATE ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-04 │ 2025-03-04 │ 2025-03-04 │
└────────────┴────────────┴──────────────┘
Date
Exemples
Récupérer la date d’hier
SELECT yesterday();
SELECT today() - 1;
┌─yesterday()─┐
│ 2025-06-09 │
└─────────────┘
┌─minus(today(), 1)─┐
│ 2025-06-09 │
└───────────────────┘
