Большинство функций в этом разделе принимают необязательный аргумент — часовой пояс, например Europe/Amsterdam. В этом случае используется указанный часовой пояс, а не локальный (по умолчанию).
Пример
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 │
└─────────────────────┴────────────┴────────────┴─────────────────────┘
Для совместимости со стандартом SQL следующие функции — NOW, CURRENT_TIMESTAMP, TODAY и CURRENT_DATE — можно использовать без скобок.
now('UTC'). Она была добавлена только для поддержки MySQL. Предпочтительно использовать now.
Синтаксис
Псевдонимы: UTC_timestamp
Аргументы
Возвращаемое значение
Возвращает текущие дату и время на этапе анализа запроса. DateTime
Примеры
Получение текущей временной метки UTC
┌──────UTCTimestamp()─┐
│ 2024-05-28 08:32:09 │
└─────────────────────┘
Date.
Эта функция обратна функции toYYYYMMDD().
Результат не определён, если входное значение не кодирует корректное значение Date.
Синтаксис
Аргументы
Возвращаемое значение
Возвращает значение типа Date, сформированное из переданных аргументов Date
Примеры
Пример
SELECT YYYYMMDDToDate(20230911);
┌─toYYYYMMDD(20230911)─┐
│ 2023-09-11 │
└──────────────────────┘
Date32.
Эта функция является обратной для toYYYYMMDD().
Результат не определён, если входное значение не кодирует корректное значение Date32.
Синтаксис
YYYYMMDDToDate32(YYYYMMDD)
Date32 из указанных аргументов Date32
Примеры
Пример
SELECT YYYYMMDDToDate32(20000507);
┌─YYYYMMDDToDate32(20000507)─┐
│ 2000-05-07 │
└────────────────────────────┘
DateTime.
Эта функция является обратной к функции toYYYYMMDDhhmmss().
Результат не определён, если входное значение не кодирует корректное значение DateTime.
Синтаксис
YYYYMMDDhhmmssToDateTime(YYYYMMDDhhmmss[, timezone])
YYYYMMDDhhmmss — Число, содержащее год, месяц, день, час, минуту и секунду. (U)Int* или Float* или Decimaltimezone — Название часового пояса. String
Возвращаемое значение
Возвращает значение DateTime из указанных аргументов DateTime
Примеры
Пример
SELECT YYYYMMDDToDateTime(20230911131415);
┌──────YYYYMMDDhhmmssToDateTime(20230911131415)─┐
│ 2023-09-11 13:14:15 │
└───────────────────────────────────────────────┘
YYYYMMDDhhmmssToDateTime64
DateTime64.
Эта функция является обратной по отношению к функции toYYYYMMDDhhmmss().
Результат не определён, если входное значение не кодирует допустимое значение DateTime64.
Синтаксис
YYYYMMDDhhmmssToDateTime64(YYYYMMDDhhmmss[, precision[, timezone]])
YYYYMMDDhhmmss — Число, содержащее год, месяц, день, часы, минуты и секунды. (U)Int* или Float* или Decimalprecision — Точность дробной части (0-9). UInt8timezone — Название часового пояса. String
Возвращаемое значение
Возвращает значение DateTime64 на основе переданных аргументов DateTime64
Примеры
Пример
SELECT YYYYMMDDhhmmssToDateTime64(20230911131415, 3, 'Asia/Istanbul');
┌─YYYYMMDDhhmm⋯/Istanbul')─┐
│ 2023-09-11 13:14:15.000 │
└──────────────────────────┘
addDate(datetime, interval)
interval к datetime. Date или Date32 или DateTime или DateTime64
Примеры
Добавление интервала к дате
SELECT addDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
┌─addDate(toDa⋯valYear(3))─┐
│ 2021-01-01 │
└──────────────────────────┘
datetime с добавленными num днями. Date или Date32 или DateTime или DateTime64
Примеры
Добавление дней к значениям разных типов даты
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 с добавленными num часами. DateTime или DateTime64(3)
Примеры
Добавление часов к различным типам дат
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 │
└──────────────────────────┘
Интервалы одного и того же типа будут объединены в один интервал. Например, если переданы toIntervalDay(1) и toIntervalDay(2), результатом будет (3), а не (1,1).
addInterval(interval_1, interval_2)
Tuple(Interval)
Примеры
Добавление интервалов
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, увеличенное на num микросекунд DateTime64
Примеры
Добавление микросекунд к различным типам даты и времени
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 — Дата и время, к которым нужно добавить указанное количество миллисекунд. DateTime или DateTime64 или Stringnum — Количество миллисекунд, которое нужно добавить. (U)Int* или Float*
Возвращаемое значение
Возвращает datetime с добавлением num миллисекунд. DateTime64
Примеры
Добавление миллисекунд к различным типам даты и времени
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 с добавленными num минутами. DateTime или DateTime64(3)
Примеры
Добавление минут к различным типам дат
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 плюс num месяцев. Date или Date32 или DateTime или DateTime64
Примеры
Добавление месяцев к разным типам дат
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 с добавленными num наносекундами DateTime64
Примеры
Добавление наносекунд к различным типам даты и времени
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 с добавленными num кварталами. Date или Date32 или DateTime или DateTime64
Примеры
Добавление кварталов к значениям разных типов дат
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 с добавленными num секундами. DateTime или DateTime64(3)
Примеры
Добавление секунд к различным типам дат
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 с добавленными intervals: Date или Date32 или DateTime или DateTime64
Примеры
Добавление кортежа интервалов к дате
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 с добавленными num неделями. Date или Date32 или DateTime или DateTime64
Примеры
Добавление недель к разным типам дат
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 с добавленными num годами. Date или Date32 или DateTime или DateTime64
Примеры
Добавление лет к различным типам дат
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 и enddate.
Разница вычисляется с точностью до 1 наносекунды.
Например, разница между 2021-12-29 и 2022-01-01 составляет 3 дня для единицы day,
0 месяцев для единицы month и 0 лет для единицы year.
В качестве альтернативы age см. функцию dateDiff.
Синтаксис
age('unit', startdate, enddate[, timezone])
unit — Тип интервала результата.
| Единица | Возможные значения |
|---|
| 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 — Первое значение времени для вычитания (вычитаемое). Date или Date32 или DateTime или DateTime64enddate — Второе значение времени, из которого вычитается первое (уменьшаемое). Date или Date32 или DateTime или DateTime64timezone — Необязательно. Название часового пояса. Если указано, применяется и к startdate, и к enddate. Если не указано, используются часовые пояса startdate и enddate. Если они не совпадают, результат не определён. String
Возвращаемое значение
Возвращает разность между enddate и startdate, выраженную в единицах unit. Int32
Примеры
Расчёт возраста в часах
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, с изменённым значением часа. Date или Date32 или DateTime или DateTime64
Примеры
Пример использования
SELECT changeDay('2024-01-31'::DateTime, 15)
changeHour(date_or_datetime, value)
date_or_datetime, с изменённым компонентом часа. DateTime или DateTime64
Примеры
Пример использования
SELECT changeHour('2024-01-01 12:00:00'::DateTime, 5)
Date или DateTime.
Синтаксис
changeMinute(date_or_datetime, value)
date_or_datetime, с изменённым значением минут. DateTime или DateTime64
Примеры
Пример использования
SELECT changeMinute('2024-01-01 12:30:00'::DateTime, 45)
changeMonth(date_or_datetime, value)
date_or_datetime, с изменённым компонентом месяца. Date или Date32 или DateTime или DateTime64
Примеры
Пример использования
SELECT changeMonth('2024-01-01'::DateTime, 12)
changeSecond(date_or_datetime, value)
date_or_datetime, с изменённым значением секунд. DateTime или DateTime64
Примеры
Пример использования
SELECT changeSecond('2024-01-01 12:30:45'::DateTime, 15)
changeYear(date_or_datetime, value)
date_or_datetime, с изменённым компонентом года. Date или Date32 или DateTime или DateTime64
Примеры
Пример использования
SELECT changeYear('2024-01-01'::DateTime, 2023)
unit, пересечённых между startdate и enddate.
Разница вычисляется с использованием относительных единиц. Например, разница между 2021-12-29 и 2022-01-01 составляет 3 дня для единицы day
(см. toRelativeDayNum), 1 месяц для единицы month (см. toRelativeMonthNum) и 1 год для единицы year
(см. toRelativeYearNum).
Если указана единица week, то dateDiff считает, что недели начинаются в понедельник.
Обратите внимание, что это поведение отличается от функции toWeek(), в которой недели по умолчанию начинаются в воскресенье.
В качестве альтернативы dateDiff см. функцию age.
Синтаксис
dateDiff(unit, startdate, enddate[, timezone])
timestampDiff, TIMESTAMP_DIFF, DATE_DIFF, date_diff, timestamp_diff
Аргументы
unit — Тип интервала, в котором выражается результат.
| Unit | Возможные значения |
|---|
| 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 — Первое значение времени, которое вычитается (вычитаемое). Date или Date32 или DateTime или DateTime64enddate — Второе значение времени, из которого выполняется вычитание (уменьшаемое). Date или Date32 или DateTime или DateTime64timezone — Необязательно. Имя часового пояса. Если указано, оно применяется и к startdate, и к enddate. Если не указано, используются часовые пояса startdate и enddate. Если они различаются, результат не определён. String
Возвращаемое значение
Возвращает разницу между enddate и startdate, выраженную в unit. Int64
Примеры
Расчёт разницы между датами в часах
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’
Синтаксис
dateName(date_part, date[, timezone])
String
Примеры
Извлечение различных частей даты
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
Аргументы
unit —
Тип интервала, до которого нужно усечь результат. Возможные значения: nanosecond (только DateTime64), microsecond (только DateTime64), millisecond (только DateTime64), second, minute, hour, day, week, month, quarter, year.
Stringdatetime — Дата и время. Date или Date32 или DateTime или DateTime64timezone — Необязательно. Имя часового пояса для возвращаемого значения даты и времени. Если не указан, функция использует часовой пояс параметра datetime. String
Возвращаемое значение
Возвращает усечённое значение даты и времени.
| Аргумент unit | Аргумент datetime | Тип возвращаемого значения |
|---|
| Год, квартал, месяц, неделя | Date32 или DateTime64 или Date или DateTime | Date32 или Date |
| День, час, минута, секунда | Date32, DateTime64, Date или DateTime | DateTime64 или DateTime |
| Миллисекунда, микросекунда, | Любой | DateTime64 |
| Наносекунда | | со scale 3, 6 или 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 — константное выражение, поэтому для одного результирующего столбца нельзя использовать несколько форматов.
formatDateTime использует стиль форматирования даты и времени MySQL, см. документацию MySQL.
Обратная операция для этой функции — parseDateTime.
С помощью полей замены можно задать шаблон результирующей строки.
Столбец примера в таблице ниже показывает результат форматирования для 2018-01-02 22:33:44.
Поля замены:
| Placeholder | Description | Example |
|---|
| %a | сокращённое название дня недели (Mon-Sun) | Mon |
| %b | сокращённое название месяца (Jan-Dec) | Jan |
| %c | месяц в виде целого числа (01-12) | 01 |
| %C | год, разделённый на 100 и усечённый до целого числа (00-99) | 20 |
| %d | день месяца с ведущим нулём (01-31) | 02 |
| %D | краткая дата в формате MM/DD/YY, эквивалентно %m/%d/%y | 01/02/18 |
| %e | день месяца с дополнением пробелом (1-31) | 2 |
| %f | дробная часть секунды | 123456 |
| %F | краткая дата в формате YYYY-MM-DD, эквивалентно %Y-%m-%d | 2018-01-02 |
| %g | двузначный год по ISO 8601 | 18 |
| %G | четырёхзначный год для номера недели по ISO | 2018 |
| %h | час в 12-часовом формате (01-12) | 09 |
| %H | час в 24-часовом формате (00-23) | 22 |
| %i | минуты (00-59) | 33 |
| %I | час в 12-часовом формате (01-12) | 10 |
| %j | день года (001-366) | 002 |
| %k | час в 24-часовом формате (00-23) | 14 |
| %l | час в 12-часовом формате (01-12) | 09 |
| %m | месяц в виде целого числа (01-12) | 01 |
| %M | полное название месяца (January-December) | January |
| %n | символ новой строки | |
| %p | обозначение AM или PM | PM |
| %Q | квартал (1-4) | 1 |
| %r | время в 12-часовом формате HH:MM AM/PM, эквивалентно %h:%i %p | 10:30 PM |
| %R | время в 24-часовом формате HH:MM, эквивалентно %H:%i | 22:33 |
| %s | секунды (00-59) | 44 |
| %S | секунды (00-59) | 44 |
| %t | символ горизонтальной табуляции | |
| %T | время в формате ISO 8601 (HH:MM:SS), эквивалентно %H:%i:%S | 22:33:44 |
| %u | день недели по ISO 8601 в виде числа, где понедельник = 1 (1-7) | 2 |
| %V | номер недели по ISO 8601 (01-53) | 01 |
| %w | день недели в виде целого числа, где воскресенье = 0 (0-6) | 2 |
| %W | полное название дня недели (Monday-Sunday) | Monday |
| %y | год, последние две цифры (00-99) | 18 |
| %Y | год | 2018 |
| %z | смещение относительно UTC в формате +HHMM или -HHMM | -0500 |
| %% | знак % | % |
- В версиях ClickHouse до v23.4
%f выводит один ноль (0), если форматируемое значение имеет тип Date, Date32 или DateTime (у которых нет дробной части секунд) либо DateTime64 с точностью 0.
- В версиях ClickHouse до v25.1
%f выводит столько цифр, сколько указано в scale типа DateTime64, вместо фиксированных 6 цифр.
- В версиях ClickHouse до v23.4
%M выводит минуты (00-59) вместо полного названия месяца (January-December).
Синтаксис
formatDateTime(datetime, format[, timezone])
DATE_FORMAT
Аргументы
datetime — Значение Date или DateTime для форматирования. Date or Date32 or DateTime or DateTime64format — Строка формата с полями подстановки. Stringtimezone — Необязательно. Имя часового пояса для форматируемого времени. String
Возвращаемое значение
Возвращает значение даты и времени в указанном формате. String
Примеры
Форматирование даты с плейсхолдером года
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, но форматирует дату и время в стиле Joda, а не MySQL. См. документацию Joda Time.
Обратной операцией для этой функции является parseDateTimeInJodaSyntax.
С помощью полей замены можно задать шаблон результирующей строки.
Поля замены:
| Заполнитель | Описание | Представление | Примеры |
|---|
| G | эра | текст | AD |
| C | век эры (>=0) | число | 20 |
| Y | год эры (>=0) | год | 1996 |
| x | год нумерации недель (пока не поддерживается) | год | 1996 |
| w | неделя года нумерации недель (пока не поддерживается) | число | 27 |
| e | день недели | число | 2 |
| E | день недели | текст | Tuesday; Tue |
| y | год | год | 1996 |
| D | день года | число | 189 |
| M | месяц года | месяц | July; Jul; 07 |
| d | день месяца | число | 10 |
| a | половина дня | текст | PM |
| K | час половины дня (0~11) | число | 0 |
| h | час половины дня по циферблату (1~12) | число | 12 |
| H | час дня (0~23) | число | 0 |
| k | час дня по циферблату (1~24) | число | 24 |
| m | минута часа | число | 30 |
| s | секунда минуты | число | 55 |
| S | доля секунды | число | 978 |
| z | часовой пояс | текст | Eastern Standard Time; EST |
| Z | смещение часового пояса | зона | -0800; -0812 |
| ’ | экранирование текста | разделитель | |
| ” | одинарная кавычка | литерал | ’ |
formatDateTimeInJodaSyntax(datetime, format[, timezone])
datetime — Date или DateTime для форматирования. DateTime или Date или Date32 или DateTime64format — Строка формата с полями замены в стиле Joda. Stringtimezone — Необязательно. Имя часового пояса для форматируемых даты и времени. String
Возвращаемое значение
Возвращает значения даты и времени в соответствии с указанным форматом. String
Примеры
Форматирование datetime с помощью синтаксиса 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(). Результат не определён, если его нельзя представить в пределах типа Date.
Синтаксис
fromDaysSinceYearZero(days)
FROM_DAYS
Аргументы
days — Количество дней, прошедших с нулевого года. UInt32
Возвращаемое значение
Возвращает дату, соответствующую числу дней, прошедших с нулевого года. Date
Примеры
Преобразование числа дней с нулевого года в даты
SELECT
fromDaysSinceYearZero(739136) AS date1,
fromDaysSinceYearZero(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
FROM_DAYS(). Результат не определён, если его нельзя представить в пределах типа Date32.
Синтаксис
fromDaysSinceYearZero32(days)
days — Количество дней, прошедших с начала нулевого года. UInt32
Возвращаемое значение
Возвращает дату, соответствующую числу дней, прошедших с начала нулевого года. Date32
Примеры
Преобразование дней с начала нулевого года в даты
SELECT
fromDaysSinceYearZero32(739136) AS date1,
fromDaysSinceYearZero32(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
YYYY-MM-DD. Функция поддерживает номера дней от -678941 до 2973483 (что соответствует датам 0000-01-01 и 9999-12-31 соответственно). Если номер дня выходит за пределы поддерживаемого диапазона, генерируется исключение.
Синтаксис
fromModifiedJulianDay(day)
day — номер модифицированного юлианского дня. (U)Int*
Возвращаемое значение
Возвращает дату в текстовом виде. String
Примеры
Преобразование модифицированного юлианского дня в дату
SELECT fromModifiedJulianDay(58849)
┌─fromModifiedJulianDay(58849)─┐
│ 2020-01-01 │
└──────────────────────────────┘
fromModifiedJulianDayOrNull
fromModifiedJulianDay(), но вместо вызова исключения возвращает NULL.
Синтаксис
fromModifiedJulianDayOrNull(day)
day — номер модифицированного юлианского дня. (U)Int*
Возвращаемое значение
Возвращает дату в текстовом виде для корректного аргумента day, в противном случае — null. Nullable(String)
Примеры
Преобразование модифицированного юлианского дня в дату с обработкой null
SELECT fromModifiedJulianDayOrNull(58849);
SELECT fromModifiedJulianDayOrNull(60000000); -- некорректный аргумент, возвращает NULL
┌─fromModified⋯Null(58849)─┐
│ 2020-01-01 │
└──────────────────────────┘
┌─fromModified⋯l(60000000)─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
fromUTCTimestamp(datetime, time_zone)
from_utc_timestamp
Аргументы
datetime — Константное значение даты или даты и времени либо выражение. DateTime или DateTime64time_zone — Константное значение типа String или выражение, задающее часовой пояс. String
Возвращаемое значение
Возвращает DateTime/DateTime64 в указанном часовом поясе. DateTime или DateTime64
Примеры
Преобразование времени из часового пояса UTC в указанный часовой пояс
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 │
└─────────────────────────────────────────────────────────────────────────┘
- Если передан один аргумент типа
Integer, функция возвращает значение типа DateTime, то есть ведет себя как toDateTime.
- Если переданы два или три аргумента, где первый аргумент — значение типа
Integer, Date, Date32, DateTime или DateTime64, второй аргумент — константная строка формата, а третий аргумент — необязательная константная строка часового пояса, функция возвращает значение типа String, то есть ведет себя как formatDateTime.
В этом случае используется стиль форматирования datetime из MySQL.
Синтаксис
fromUnixTimestamp(timestamp)
fromUnixTimestamp(timestamp[, format[, timezone]])
FROM_UNIXTIME
Аргументы
timestamp — Unix-временная метка или значение типа date/дата и время. (U)Int* или Date или Date32 или DateTime или DateTime64format — Необязательно. Константная строка формата для форматирования вывода. Stringtimezone — Необязательно. Константная строка часового пояса. String
Возвращаемое значение
Возвращает DateTime, если вызвана с одним аргументом, или String, если вызвана с двумя или тремя аргументами. DateTime или String
Примеры
Преобразование Unix-временной метки в 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, функция возвращает значение типа DateTime, то есть ведёт себя как toDateTime.
Если переданы два или три аргумента, где первый аргумент — значение типа Integer, Date, Date32, DateTime или DateTime64, второй аргумент — константная строка формата, а третий — необязательная константная строка с часовым поясом, функция возвращает значение типа String, то есть ведёт себя как formatDateTimeInJodaSyntax. В этом случае используется стиль форматирования даты и времени Joda.
Синтаксис
fromUnixTimestampInJodaSyntax(timestamp)
fromUnixTimestampInJodaSyntax(timestamp, format[, timezone])
timestamp — Unix-временная метка или значение даты и времени. (U)Int* или Date или Date32 или DateTime или DateTime64format — Необязательно. Константная строка формата в синтаксисе Joda для форматирования вывода. Stringtimezone — Необязательно. Константная строка часового пояса. String
Возвращаемое значение
Возвращает дату и время при вызове с одним аргументом или строку при вызове с двумя или тремя аргументами.} DateTime или String
Примеры
Преобразование Unix-временной метки в формате Joda
SELECT fromUnixTimestampInJodaSyntax(1234334543, 'yyyy-MM-dd HH:mm:ss', 'UTC') AS DateTime
┌─DateTime────────────┐
│ 2009-02-11 06:42:23 │
└─────────────────────┘
Date на основе:
- года, месяца и дня
- года и порядкового дня в году
Синтаксис
makeDate(year, month, day)
makeDate(year, day_of_year)
Date, сформированное из указанных аргументов Date
Примеры
Date из года, месяца и дня
SELECT makeDate(2023, 2, 28) AS date;
┌───────date─┐
│ 2023-02-28 │
└────────────┘
SELECT makeDate(2023, 42) AS date;
┌───────date─┐
│ 2023-02-11 │
└────────────┘
Date32, используя:
- год, месяц и день
- год и день года
Синтаксис
makeDate32(year, month, day)
makeDate32(year, day_of_year)
Date32, созданное на основе переданных аргументов Date32
Примеры
Date32 из года, месяца и дня
SELECT makeDate(2023, 2, 28) AS date;
┌───────date─┐
│ 2023-02-28 │
└────────────┘
SELECT makeDate(2023, 42) AS date;
┌───────date─┐
│ 2023-02-11 │
└────────────┘
DateTime из года, месяца, дня, часа, минуты и секунды с необязательным часовым поясом.
Синтаксис
makeDateTime(year, month, day, hour, minute, second[, timezone])
DateTime, сформированное из указанных аргументов DateTime
Примеры
DateTime из года, месяца, дня, часа, минуты и секунды
SELECT makeDateTime(2023, 2, 28, 17, 12, 33) AS DateTime;
┌────────────DateTime─┐
│ 2023-02-28 17:12:33 │
└─────────────────────┘
DateTime64 из года, месяца, дня, часа, минуты и секунды с необязательной дробной частью, точностью и часовым поясом.
Синтаксис
makeDateTime64(year, month, day, hour, minute, second[, fraction[, precision[, timezone]]])
DateTime64, сформированное из указанных аргументов DateTime64
Примеры
DateTime64 из года, месяца, дня, часа, минуты, секунды
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
Примеры
Получить название месяца из даты
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT monthName(date_value)
┌─monthName(date_value)─┐
│ April │
└───────────────────────┘
current_timestamp
Аргументы
timezone — Необязательный. Имя часового пояса для возвращаемого значения. String
Возвращаемое значение
Возвращает текущие дату и время. DateTime
Примеры
Запрос без указания часового пояса
┌───────────────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 — Необязательный. Размер шага (точность): 10^-precision секунды. Допустимый диапазон: [0 : 9]. Обычно используются значения 3 (по умолчанию) — миллисекунды, 6 — микросекунды, 9 — наносекунды. UInt8timezone — Необязательный. Название часового пояса для возвращаемого значения. String
Возвращаемое значение
Возвращает текущие дату и время с точностью до долей секунды. DateTime64
Примеры
Запрос со стандартной и пользовательской точностью
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, это не константное выражение, и при длительном выполнении запроса возвращаемое значение будет различаться в разных блоках.
Эту функцию имеет смысл использовать для генерации текущего времени в длительно выполняющихся запросах INSERT SELECT.
Синтаксис
Аргументы
timezone — Необязательный параметр. Имя часового пояса для возвращаемого значения. String
Возвращаемое значение
Возвращает текущие дату и время на момент обработки каждого блока данных. DateTime
Примеры
Отличие от функции 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 — Необязательный. Размер шага (precision): 10^-precision секунды. Допустимый диапазон: [0 : 9]. Обычно используются значения 3 (по умолчанию) (миллисекунды), 6 (микросекунды), 9 (наносекунды). UInt8timezone — Необязательный. Имя часового пояса для возвращаемого значения. String
Возвращаемое значение
Возвращает текущие дату и время на момент обработки каждого блока данных с точностью до долей секунды. DateTime64
Примеры
Отличие от функции 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.
Если функция выполняется в контексте distributed таблицы, она создаёт обычный столбец со значениями для каждого сегмента. В противном случае она возвращает константное значение.
Синтаксис
Псевдонимы: serverTimeZone
Аргументы
Возвращаемое значение
Возвращает часовой пояс сервера в виде String
Примеры
Пример использования
┌─serverTimeZone()─┐
│ UTC │
└──────────────────┘
subDate(datetime, interval)
interval из datetime. Date or Date32 or DateTime or DateTime64
Примеры
Вычитание интервала из даты
SELECT subDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
┌─subDate(toDate('2018-01-01'), toIntervalYear(3))─┐
│ 2015-01-01 │
└──────────────────────────────────────────────────┘
subtractDays(datetime, num)
datetime за вычетом num дней Date или Date32 или DateTime или DateTime64
Примеры
Вычитание дней из значений разных типов даты
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 за вычетом num часов: DateTime или DateTime64(3)
Примеры
Вычитание часов из значений разных типов даты
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) и toIntervalDay(1),
то результатом будет (1), а не (2,1).
Синтаксис
subtractInterval(interval_1, interval_2)
Tuple(T)
Примеры
Вычитание интервалов
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 — Значение даты и времени, из которого нужно вычесть указанное количество микросекунд. DateTime или DateTime64 или Stringnum — Количество микросекунд, которое нужно вычесть. (U)Int* или Float*
Возвращаемое значение
Возвращает datetime за вычетом num микросекунд. DateTime64
Примеры
Вычитание микросекунд из значений разных типов даты и времени
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 за вычетом num миллисекунд. DateTime64
Примеры
Вычитание миллисекунд из различных типов даты и времени
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 за вычетом num минут. DateTime или DateTime64(3)
Примеры
Вычитание минут из значений разных типов даты
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 минус num месяцев. Date или Date32 или DateTime или DateTime64
Примеры
Вычитание месяцев из различных типов дат
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 — дата и время, из которых нужно вычесть указанное количество наносекунд. DateTime или DateTime64, или Stringnum — количество наносекунд, которое нужно вычесть. (U)Int* или Float*
Возвращаемое значение
Возвращает datetime за вычетом num наносекунд. DateTime64
Примеры
Вычитание наносекунд из значений разных типов даты и времени
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 за вычетом num кварталов Date or Date32 or DateTime or DateTime64
Примеры
Вычитание кварталов для разных типов дат
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 за вычетом num секунд. DateTime или DateTime64(3)
Примеры
Вычитание секунд из различных типов дат
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, из которого вычтены intervals: Date или Date32 или DateTime или DateTime64
Примеры
Вычитание кортежа интервалов из даты
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 минус num недель. Date или Date32 или DateTime или DateTime64
Примеры
Вычитание недель из значений разных типов даты
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 за вычетом num лет. Date или Date32 или DateTime или DateTime64
Примеры
Вычитание лет из разных типов дат
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.
Эта функция эквивалентна dateDiff('second', startdate, enddate).
Чтобы вычислить разницу во времени в других единицах (часах, днях, месяцах и т. д.), используйте функцию dateDiff.
Синтаксис
timeDiff(startdate, enddate)
enddate и startdate, выраженную в секундах. Int64
Примеры
Вычисление разницы во времени в секундах
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 │
└──────────────────┴──────────────────┘
Хотя эта функция может принимать в качестве аргумента значения расширенных типов Date32 и DateTime64,
передача ей времени вне обычного диапазона (с 1970 по 2149 год для Date / до 2106 года для DateTime) приведет к неверным результатам.
timeSlot(time[, time_zone])
time — Время, которое нужно округлить до начала получасового интервала. DateTime или Date32 или DateTime64time_zone — Необязательно. Константное значение типа String или выражение, задающее часовой пояс. String
Возвращаемое значение
Возвращает время, округлённое до начала получасового интервала. DateTime
Примеры
Округление времени до получасового интервала
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 и длящегося Duration секунд, возвращает массив моментов времени, состоящий из точек этого интервала, округлённых вниз с шагом Size секунд. Size — необязательный параметр, по умолчанию равный 1800 (30 минутам).
Это необходимо, например, при поиске просмотров страниц в соответствующем сеансе.
Для DateTime64 масштаб возвращаемого значения может отличаться от масштаба StartTime. Используется наибольший масштаб среди всех переданных аргументов.
Синтаксис
timeSlots(StartTime, Duration[, Size])
StartTime). Для DateTime64 масштаб возвращаемого значения может отличаться от масштаба StartTime — берется наибольший масштаб среди всех переданных аргументов. Array(DateTime) или Array(DateTime64)
Примеры
Генерация временных слотов для интервала
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 в тип DateTime64(6).
Если указан второй аргумент expr_time, к преобразованному значению будет добавлено указанное время.
Синтаксис
timestamp(expr[, expr_time])
expr — Дата или дата и время. Stringexpr_time — Необязательно. Время, которое будет добавлено к преобразованному значению. String
Возвращаемое значение
Возвращает преобразованное значение expr или expr с добавленным временем в формате DateTime64(6)
Примеры
Преобразование строки даты в 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
Аргументы
Возвращаемое значение
Возвращает каноническое имя часового пояса в виде String
Примеры
Пример использования
┌─timezone()───────┐
│ Europe/Amsterdam │
└──────────────────┘
DateTime или DateTime64.
Синтаксис
Псевдонимы: timeZoneOf
Аргументы
datetime — Значение типа DateTime или DateTime64timezone — Необязательно. Имя часового пояса, в который нужно преобразовать значение datetime. String
Возвращаемое значение
Возвращает имя часового пояса для datetime. String
Примеры
Пример использования
SELECT timezoneOf(now());
┌─timezoneOf(now())─┐
│ Europe/Amsterdam │
└───────────────────┘
timeZoneOffset
Аргументы
datetime — значение DateTime, для которого требуется получить смещение часового пояса. DateTime или DateTime64
Возвращаемое значение
Возвращает смещение относительно UTC в секундах Int32
Примеры
Пример использования
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 или DateTime.
Синтаксис
Псевдонимы: DAY, DAYOFMONTH
Аргументы
Возвращаемое значение
Возвращает день месяца для указанной даты/времени UInt8
Примеры
Пример использования
SELECT toDayOfMonth(toDateTime('2023-04-21 10:20:30'))
┌─toDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 21 │
└─────────────────────────────────────────────────┘
Date или DateTime.
Форма toDayOfWeek() с двумя аргументами позволяет указать, начинается ли неделя с понедельника или воскресенья,
а также должен ли возвращаемый результат находиться в диапазоне от 0 до 6 или от 1 до 7.
| Режим | Первый день недели | Диапазон |
|---|
| 0 | Понедельник | 1-7: понедельник = 1, вторник = 2, …, воскресенье = 7 |
| 1 | Понедельник | 0-6: понедельник = 0, вторник = 1, …, воскресенье = 6 |
| 2 | Воскресенье | 0-6: воскресенье = 0, понедельник = 1, …, суббота = 6 |
| 3 | Воскресенье | 1-7: воскресенье = 1, понедельник = 2, …, суббота = 7 |
toDayOfWeek(datetime[, mode[, timezone]])
DAYOFWEEK
Аргументы
datetime — Дата или дата и время, для которых нужно определить день недели. Date или Date32 или DateTime или DateTime64mode — Необязательный параметр. Целое число, задающее режим недели (0-3). Если не указан, по умолчанию используется 0. UInt8timezone — Необязательный параметр. Часовой пояс, используемый для преобразования. String
Возвращаемое значение
Возвращает день недели для указанного Date или DateTime. UInt8
Примеры
Пример использования
-- Следующая дата — 21 апреля 2023 года, это пятница:
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 или DateTime.
Синтаксис
Псевдонимы: DAYOFYEAR
Аргументы
Возвращаемое значение
Возвращает день года для указанного значения Date или DateTime UInt16
Примеры
Пример использования
SELECT toDayOfYear(toDateTime('2023-04-21 10:20:30'))
┌─toDayOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 111 │
└────────────────────────────────────────────────┘
Date или DateTime.
Возвращаемое значение находится в диапазоне от 28 до 31.
Синтаксис
Аргументы
Возвращаемое значение
Возвращает количество дней в месяце для указанной даты/времени. UInt8
Примеры
Пример использования
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.
Синтаксис
toDaysSinceYearZero(date[, time_zone])
TO_DAYS
Аргументы
date — Дата или дата и время, для которых вычисляется количество дней с начала нулевого года. Date или Date32 или DateTime или DateTime64time_zone — Часовой пояс. String
Возвращаемое значение
Возвращает количество дней, прошедших с даты 0000-01-01. UInt32
Примеры
Вычислить количество дней с начала нулевого года
SELECT toDaysSinceYearZero(toDate('2023-09-08'))
┌─toDaysSinceYearZero(toDate('2023-09-08')))─┐
│ 713569 │
└────────────────────────────────────────────┘
DateTime или DateTime64.
Синтаксис
Псевдонимы: HOUR
Аргументы
Возвращаемое значение
Возвращает час (0–23) для datetime. UInt8
Примеры
Пример использования
SELECT toHour(toDateTime('2023-04-21 10:20:30'))
┌─toHour(toDateTime('2023-04-21 10:20:30'))─┐
│ 10 │
└───────────────────────────────────────────┘
toWeek(date, 3).
Недели ISO начинаются в понедельник, а первая неделя года включает 4 января.
Согласно ISO 8601, номера недель находятся в диапазоне от 1 до 53.
Обратите внимание, что для дат вблизи начала или конца года может возвращаться номер недели предыдущего или следующего года. Например,
29 декабря 2025 года возвращает неделю 1, поскольку эта дата попадает в первую неделю, включающую 4 января 2026 года.
Синтаксис
toISOWeek(datetime[, timezone])
datetime — Дата или дата и время, для которых нужно получить номер недели по ISO. Date или DateTime или Date32 или DateTime64timezone — Необязательно. Часовой пояс. String
Возвращаемое значение
Возвращает номер недели по ISO в соответствии со стандартом ISO 8601. Возвращает число от 1 до 53. UInt8
Примеры
Получение номеров недель по 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
Примеры
Получение года по ISO из значений даты
SELECT
toISOYear(toDate('2024/10/02')) as year1,
toISOYear(toDateTime('2024-10-02 01:30:00')) as year2
┌─week1─┬─week2─┐
│ 40 │ 40 │
└───────┴───────┘
LAST_DAY
Аргументы
Возвращаемое значение
Возвращает дату последнего дня месяца для указанной даты или даты и времени. Date
Примеры
Округлить вверх до последнего дня месяца
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 — Дата или дата и время для преобразования. Date или DateTime или Date32 или DateTime64mode — Определяет первый день недели, как описано в функции toWeek(). По умолчанию — 0. UInt8timezone — Необязательно. Часовой пояс, используемый для преобразования. Если не указан, используется часовой пояс сервера. String
Возвращаемое значение
Возвращает дату ближайшей субботы или воскресенья, совпадающую с указанной датой или следующую за ней, в зависимости от режима. Date или Date32
Примеры
Округление вверх до ближайшей субботы или воскресенья
SELECT
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')), /* пятница */
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* пятница */
toLastDayOfWeek(toDate('2023-04-23')), /* воскресенье */
toLastDayOfWeek(toDate('2023-04-23'), 1) /* воскресенье */
FORMAT Vertical
Строка 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
DateTime или DateTime64.
Синтаксис
Псевдонимы: MILLISECOND
Аргументы
Возвращаемое значение
Возвращает миллисекунду в пределах минуты (0 - 59) для datetime. UInt16
Примеры
Пример использования
SELECT toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3));
┌──toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3))─┐
│ 456 │
└────────────────────────────────────────────────────────────┘
Date или DateTime.
Синтаксис
Псевдонимы: MINUTE
Аргументы
Возвращаемое значение
Возвращает минуты в часе (0 - 59) для datetime. UInt8
Примеры
Пример использования
SELECT toMinute(toDateTime('2023-04-21 10:20:30'))
┌─toMinute(toDateTime('2023-04-21 10:20:30'))─┐
│ 20 │
└─────────────────────────────────────────────┘
YYYY-MM-DD в номер модифицированного юлианского дня типа Int32. Эта функция поддерживает даты от 0000-01-01 до 9999-12-31. Она вызывает исключение, если аргумент не удаётся разобрать как дату или если дата недопустима.
Синтаксис
toModifiedJulianDay(date)
Int32
Примеры
Преобразование даты в модифицированный юлианский день
SELECT toModifiedJulianDay('2020-01-01')
┌─toModifiedJulianDay('2020-01-01')─┐
│ 58849 │
└───────────────────────────────────┘
toModifiedJulianDayOrNull
toModifiedJulianDay(), но вместо генерации исключений возвращает NULL.
Синтаксис
toModifiedJulianDayOrNull(date)
date, в противном случае — null. Nullable(Int32)
Примеры
Преобразование даты в модифицированный юлианский день с обработкой null
SELECT toModifiedJulianDayOrNull('2020-01-01');
SELECT toModifiedJulianDayOrNull('0000-00-00'); -- некорректная дата, возвращает NULL
┌─toModifiedJu⋯020-01-01')─┐
│ 58849 │
└──────────────────────────┘
┌─toModifiedJu⋯000-00-00')─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
value — дата или дата и время, которые нужно округлить вниз до понедельника соответствующей недели. Date или Date32 или DateTime или DateTime64
Возвращаемое значение
Возвращает дату понедельника той же недели для указанной даты или даты и времени. Date
Примеры
Округлить вниз до понедельника недели
SELECT
toMonday(toDateTime('2023-04-21 10:20:30')), -- Пятница
toMonday(toDate('2023-04-24')); -- Уже понедельник
┌─toMonday(toDateTime('2023-04-21 10:20:30'))─┬─toMonday(toDate('2023-04-24'))─┐
│ 2023-04-17 │ 2023-04-24 │
└─────────────────────────────────────────────┴────────────────────────────────┘
Date или DateTime.
Синтаксис
Псевдонимы: MONTH
Аргументы
Возвращаемое значение
Возвращает месяц для указанной даты или даты и времени UInt8
Примеры
Пример использования
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'))
Date или DateTime.
Синтаксис
Псевдонимы: QUARTER
Аргументы
Возвращаемое значение
Возвращает квартал года для указанной даты/времени UInt8
Примеры
Пример использования
SELECT toQuarter(toDateTime('2023-04-21 10:20:30'))
┌─toQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2 │
└──────────────────────────────────────────────┘
toRelativeDayNum(dt1) - toRelativeDayNum(dt2).
Синтаксис
Аргументы
Возвращаемое значение
Возвращает количество дней от фиксированной точки отсчета в прошлом. UInt32
Примеры
Вычисление относительных номеров дней
SELECT toRelativeDayNum(toDate('2023-04-01')) - toRelativeDayNum(toDate('2023-01-01'))
┌─minus(toRela⋯3-01-01')))─┐
│ 90 │
└──────────────────────────┘
toRelativeHourNum(dt1) - toRelativeHourNum(dt2).
Синтаксис
Аргументы
Возвращаемое значение
Возвращает число часов с фиксированной точки отсчета в прошлом. UInt32
Примеры
Получить относительные номера часов
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).
Синтаксис
toRelativeMinuteNum(date)
UInt32
Примеры
Получение относительных номеров минут
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).
Синтаксис
Аргументы
Возвращаемое значение
Возвращает количество месяцев от фиксированной точки отсчёта в прошлом. UInt32
Примеры
Получение относительных номеров месяцев
SELECT toRelativeMonthNum(toDate('2023-04-01')) - toRelativeMonthNum(toDate('2023-01-01')) AS months_difference
┌─months_difference─┐
│ 3 │
└───────────────────┘
toRelativeQuarterNum(dt1) - toRelativeQuarterNum(dt2).
Синтаксис
toRelativeQuarterNum(date)
UInt32
Примеры
Получение относительных номеров кварталов
SELECT toRelativeQuarterNum(toDate('2023-04-01')) - toRelativeQuarterNum(toDate('2023-01-01')) AS quarters_difference
┌─quarters_difference─┐
│ 1 │
└─────────────────────┘
toRelativeSecondNum(dt1) - toRelativeSecondNum(dt2).
Синтаксис
toRelativeSecondNum(date)
UInt32
Примеры
Получение относительных номеров секунд
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).
Синтаксис
Аргументы
Возвращаемое значение
Возвращает количество недель, прошедших с фиксированной точки отсчета в прошлом. UInt32
Примеры
Получение относительных номеров недель
SELECT toRelativeWeekNum(toDate('2023-01-08')) - toRelativeWeekNum(toDate('2023-01-01')) AS weeks_difference
┌─weeks_difference─┐
│ 1 │
└──────────────────┘
toRelativeYearNum(dt1) - toRelativeYearNum(dt2).
Синтаксис
Аргументы
Возвращаемое значение
Возвращает количество лет от фиксированной точки отсчета в прошлом. UInt16
Примеры
Получение относительного номера года
SELECT toRelativeYearNum('2010-10-01'::DateTime) - toRelativeYearNum('2000-01-01'::DateTime)
┌─minus(toRela⋯ateTime')))─┐
│ 10 │
└──────────────────────────┘
DateTime или DateTime64.
Синтаксис
Псевдонимы: SECOND
Аргументы
Возвращаемое значение
Возвращает секунду минуты (0 - 59) для datetime. UInt8
Примеры
Пример использования
SELECT toSecond(toDateTime('2023-04-21 10:20:30'))
┌─toSecond(toDateTime('2023-04-21 10:20:30'))─┐
│ 30 │
└─────────────────────────────────────────────┘
datetime — Дата или дата и время, которые нужно округлить. Date или DateTime
Возвращаемое значение
Возвращает дату и время, округлённые вниз до начала дня. DateTime или DateTime64
Примеры
Округление вниз до начала дня
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 или DateTime64
Примеры
Пример
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
Аргументы
Возвращаемое значение
Возвращает дату и время, округлённые к началу ближайшего пятиминутного интервала. DateTime или DateTime64
Примеры
Пример
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
Строка 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 или DateTime64
Примеры
Округление до начала часа
SELECT
toStartOfHour(toDateTime('2023-04-21 10:20:30'));
┌─────────────────res─┬─toTypeName(res)─┐
│ 2023-04-21 10:00:00 │ DateTime │
└─────────────────────┴─────────────────┘
Date
Примеры
Округлить вниз до первого дня года по ISO
SELECT toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-01-02 │
└─────────────────────────────────────────────────────┘
toStartOf*() с синтаксисом toStartOfInterval(date_or_date_with_time, INTERVAL x unit [, time_zone]).
Например,
toStartOfInterval(t, INTERVAL 1 YEAR) возвращает тот же результат, что и toStartOfYear(t),toStartOfInterval(t, INTERVAL 1 MONTH) возвращает тот же результат, что и toStartOfMonth(t),toStartOfInterval(t, INTERVAL 1 DAY) возвращает тот же результат, что и toStartOfDay(t),toStartOfInterval(t, INTERVAL 15 MINUTE) возвращает тот же результат, что и toStartOfFifteenMinutes(t).
Вычисление выполняется относительно определённых моментов времени:
| Interval | Start |
|---|
| YEAR | год 0 |
| QUARTER | 1900 Q1 |
| MONTH | январь 1900 |
| WEEK | 1970, 1-я неделя (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 |
| (*) интервалы в часах — особый случай: вычисление всегда выполняется относительно 00:00:00 (полуночи) текущего дня. Поэтому | |
| имеют смысл только значения часов от 1 до 23. | |
WEEK, toStartOfInterval считает, что недели начинаются с понедельника. Обратите внимание, что это поведение отличается от поведения функции toStartOfWeek, в которой недели по умолчанию начинаются с воскресенья.
Вторая перегрузка имитирует функцию time_bucket() из TimescaleDB и, соответственно, функцию date_bin() из PostgreSQL.
Синтаксис
toStartOfInterval(value, INTERVAL x unit[, time_zone])
toStartOfInterval(value, INTERVAL x unit[, origin[, time_zone]])
time_bucket, date_bin
Аргументы
value — Значение типа дата или дата и время, которое нужно округлить вниз. Date или DateTime или DateTime64x — Число, задающее длину интервала. - unit — Единица интервала: YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE, SECOND, MILLISECOND, MICROSECOND, NANOSECOND. - time_zone — Необязательно. Имя часового пояса в виде строки. - origin — Необязательно. Точка отсчёта для вычисления (только для второй перегрузки).
Возвращаемое значение
Возвращает начало интервала, в который попадает входное значение. DateTime
Примеры
Базовое округление по интервалу
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 — Дата и время. DateTime64timezone — Необязательно. Часовой пояс для возвращаемого значения. Если не указан, функция использует часовой пояс параметра value. String
Возвращаемое значение
Исходное значение с субмикросекундами DateTime64
Примеры
Запрос без часового пояса
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 — Дата и время. DateTime64timezone — Необязательный. Часовой пояс для возвращаемого значения. Если не указан, функция использует часовой пояс параметра value. String
Возвращаемое значение
Входное значение с долями миллисекунды. DateTime64
Примеры
Запрос без часового пояса
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 или DateTime64
Примеры
Округление до начала минуты
SELECT
toStartOfMinute(toDateTime('2023-04-21 10:20:30')),
toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8))
FORMAT Vertical
Строка 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
Примеры
Округление до первого дня месяца
SELECT toStartOfMonth(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└───────────────────────────────────────────────────┘
toStartOfNanosecond(datetime[, timezone])
datetime — Дата и время. DateTime64timezone — Необязательно. Часовой пояс возвращаемого значения. Если не указан, функция использует часовой пояс параметра value. String
Возвращаемое значение
Исходное значение с наносекундами. DateTime64
Примеры
Запрос без часового пояса
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
Примеры
Округление вниз до первого дня квартала
SELECT toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└─────────────────────────────────────────────────────┘
toStartOfSecond(datetime[, timezone])
datetime — Дата и время, у которых нужно отбросить доли секунды. DateTime64timezone — Необязательный. Часовой пояс для возвращаемого значения. Если не указан, функция использует часовой пояс параметра value. String
Возвращаемое значение
Возвращает входное значение без долей секунды. DateTime64
Примеры
Запрос без часового пояса
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 или DateTime64
Примеры
Пример
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 — дата или дата и время для преобразования. Date или DateTime или Date32 или DateTime64mode — определяет первый день недели, как описано для функции toWeek(). Значение по умолчанию — 0. UInt8timezone — часовой пояс, используемый для преобразования. Если не указан, используется часовой пояс сервера. String
Возвращаемое значение
Возвращает дату ближайшего воскресенья или понедельника, не превышающую указанную дату, в зависимости от режима. Date или Date32
Примеры
Округление вниз до ближайшего воскресенья или понедельника
SELECT
toStartOfWeek(toDateTime('2023-04-21 10:20:30')), /* пятница */
toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* пятница */
toStartOfWeek(toDate('2023-04-24')), /* понедельник */
toStartOfWeek(toDate('2023-04-24'), 1) /* понедельник */
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.
Синтаксис
Аргументы
Возвращаемое значение
Возвращает первый день года для заданной даты/времени Date
Примеры
Округление вниз до первого дня года
SELECT toStartOfYear(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-01-01 │
└──────────────────────────────────────────────────┘
1970-01-02,
но точная точка во времени является деталью реализации и в будущем может измениться.
Поэтому toTime не следует использовать автономно.
Основное назначение функции — вычисление разницы во времени между двумя датами или значениями даты и времени, например: toTime(dt1) - toTime(dt2).
Синтаксис
toTimeWithFixedDate(date[, timezone])
date — Дата для преобразования в значение времени. Date или DateTime или DateTime64timezone — Необязательно. Часовой пояс для возвращаемого значения. String
Возвращаемое значение
Возвращает компонент времени даты или даты и времени в виде смещения относительно фиксированного момента времени (сейчас это 1970-01-02). DateTime
Примеры
Вычисление разницы во времени между двумя датами
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 или DateTime64 в указанный часовой пояс.
Внутреннее значение (число unix-секунд) данных не изменяется.
Изменяются только атрибут часового пояса значения и его строковое представление.
Синтаксис
toTimezone(datetime, timezone)
toTimeZone
Аргументы
Возвращаемое значение
Возвращает ту же временную метку, что и входное значение, но с указанным часовым поясом. DateTime или DateTime64
Примеры
Пример использования
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;
Строка 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
Аргументы
datetime — Константное значение типа «дата или дата и время» либо выражение. DateTime или DateTime64time_zone — Константное значение строкового типа либо выражение, задающее часовой пояс. String
Возвращаемое значение
Возвращает дату или дату и время в часовом поясе UTC. DateTime или DateTime64
Примеры
Преобразование в UTC
SELECT toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')
┌─toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')─┐
│ 2023-03-15 16:00:00 │
└─────────────────────────────────────────────────────────┘
String, Date или DateTime в Unix-временную метку (UInt32; количество секунд с 1970-01-01 00:00:00 UTC).
Синтаксис
toUnixTimestamp(date[, timezone])
date — Значение для преобразования. Date или Date32 или DateTime или DateTime64 или Stringtimezone — Необязательно. Часовой пояс для преобразования. Если не указан, используется часовой пояс сервера. String
Возвращаемое значение
Возвращает Unix-временную метку. UInt32
Примеры
Пример использования
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;
строка 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() с двумя аргументами позволяет указать, начинается ли неделя
в воскресенье или в понедельник, а также должен ли возвращаемый номер находиться в диапазоне от 0 до 53 или от 1 до 53.
toISOWeek() — функция совместимости, эквивалентная toWeek(date,3).
В следующей таблице описано, как работает аргумент mode.
| Mode | Первый день недели | Диапазон | Неделя 1 — это первая неделя … |
|---|
| 0 | Воскресенье | 0-53 | с воскресеньем в этом году |
| 1 | Понедельник | 0-53 | как минимум с 4 днями в этом году |
| 2 | Воскресенье | 1-53 | с воскресеньем в этом году |
| 3 | Понедельник | 1-53 | как минимум с 4 днями в этом году |
| 4 | Воскресенье | 0-53 | как минимум с 4 днями в этом году |
| 5 | Понедельник | 0-53 | с понедельником в этом году |
| 6 | Воскресенье | 1-53 | как минимум с 4 днями в этом году |
| 7 | Понедельник | 1-53 | с понедельником в этом году |
| 8 | Воскресенье | 1-53 | содержит 1 января |
| 9 | Понедельник | 1-53 | содержит 1 января |
- Если неделя, содержащая 1 января, включает 4 или более дней нового года, то это неделя 1.
- В противном случае это последняя неделя предыдущего года, а следующая неделя — неделя 1.
Для значений mode со смыслом “содержит 1 января” неделя, содержащая 1 января, считается неделей 1.
Не имеет значения, сколько дней нового года она содержит, даже если только один.
То есть если последняя неделя декабря содержит 1 января следующего года, она будет неделей 1 следующего года.
Первый аргумент также можно указать как String в формате, поддерживаемом parseDateTime64BestEffort(). Поддержка строковых аргументов существует только из соображений совместимости с MySQL, которая требуется некоторым сторонним инструментам. Поскольку в будущем поддержка строковых аргументов может зависеть от новых настроек совместимости с MySQL, а разбор строк в целом работает медленно, рекомендуется её не использовать.
Синтаксис
toWeek(datetime[, mode[, time_zone]])
week
Аргументы
datetime — Дата или дата и время, для которых нужно получить номер недели. Date или DateTimemode — Необязательно. Режим от 0 до 9 определяет первый день недели и диапазон номеров недель. По умолчанию 0. - time_zone — Необязательно. Часовой пояс. String
Возвращаемое значение
Возвращает номер недели в соответствии с указанным режимом. UInt32
Примеры
Получение номеров недель в разных режимах
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, содержащее год и номер месяца (YYYY * 100 + MM).
Принимает второй необязательный аргумент — timezone. Если он указан, timezone должен быть строковой константой.
Эта функция является обратной к функции YYYYMMDDToDate().
Синтаксис
toYYYYMM(datetime[, timezone])
datetime — дата или дата и время для преобразования. Date или Date32 или DateTime или DateTime64timezone — необязательно. Часовой пояс для преобразования. Если указан, часовой пояс должен быть строковой константой. String
Возвращаемое значение
Возвращает число типа UInt32, содержащее год и номер месяца (YYYY * 100 + MM). UInt32
Примеры
Преобразование текущей даты в формат YYYYMM
SELECT toYYYYMM(now(), 'US/Eastern')
┌─toYYYYMM(now(), 'US/Eastern')─┐
│ 202303 │
└───────────────────────────────┘
UInt32, содержащее год, месяц и день (YYYY * 10000 + MM * 100 + DD). Принимает второй необязательный аргумент timezone. Если он указан, timezone должен быть строковой константой.
Синтаксис
toYYYYMMDD(datetime[, timezone])
datetime — Дата или дата и время для преобразования. Date или Date32 или DateTime или DateTime64timezone — Необязательно. Часовой пояс, используемый при преобразовании. Если указан, часовой пояс должен быть строковой константой. String
Возвращаемое значение
Возвращает число типа UInt32, содержащее год, месяц и день (YYYY * 10000 + MM * 100 + DD). UInt32
Примеры
Преобразование текущей даты в формат YYYYMMDD
SELECT toYYYYMMDD(now(), 'US/Eastern')
┌─toYYYYMMDD(now(), 'US/Eastern')─┐
│ 20230302 │
└─────────────────────────────────┘
UInt64, содержащее год, месяц, день, часы, минуты и секунды (YYYY * 10000000000 + MM * 100000000 + DD * 1000000 + hh * 10000 + mm * 100 + ss).
Принимает необязательный второй аргумент — часовой пояс. Если он указан, часовой пояс должен быть строковой константой.
Синтаксис
toYYYYMMDDhhmmss(datetime[, timezone])
datetime — Дата или дата и время для преобразования. Date или Date32 или DateTime или DateTime64timezone — Необязательно. Часовой пояс для преобразования. Если указан, часовой пояс должен быть строковой константой. String
Возвращаемое значение
Возвращает число UInt64, содержащее год, месяц, день, час, минуту и секунду (YYYY * 10000000000 + MM * 100000000 + DD * 1000000 + hh * 10000 + mm * 100 + ss). UInt64
Примеры
Преобразование текущей даты и времени в формат YYYYMMDDhhmmss
SELECT toYYYYMMDDhhmmss(now(), 'US/Eastern')
┌─toYYYYMMDDhhmmss(now(), 'US/Eastern')─┐
│ 20230302112209 │
└───────────────────────────────────────┘
Date или DateTime.
Синтаксис
Псевдонимы: YEAR
Аргументы
Возвращаемое значение
Возвращает год из указанного значения Date или DateTime UInt16
Примеры
Пример использования
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().
Предупреждение: номер недели, возвращаемый toYearWeek(), может отличаться от значения, возвращаемого toWeek(). toWeek() всегда возвращает номер недели в контексте указанного года, и если toWeek() возвращает 0, toYearWeek() возвращает значение, соответствующее последней неделе предыдущего года. См. prev_yearWeek в примере ниже.
Первый аргумент также может быть указан как String в формате, поддерживаемом parseDateTime64BestEffort(). Поддержка строковых аргументов существует только из соображений совместимости с MySQL, которая требуется некоторым сторонним инструментам. Поскольку в будущем поддержка строковых аргументов может зависеть от новых настроек совместимости с MySQL, а разбор строк сам по себе обычно медленный, рекомендуется их не использовать.
Синтаксис
toYearWeek(datetime[, mode[, timezone]])
yearweek
Аргументы
datetime — дата или дата и время, для которых нужно получить год и номер недели. Date или DateTimemode — необязательно. Режим от 0 до 9 задаёт первый день недели и диапазон номеров недель. По умолчанию 0. - timezone — необязательно. Часовой пояс. String
Возвращаемое значение
Возвращает год и номер недели в виде одного целочисленного значения. UInt32
Примеры
Получение комбинаций год-неделя для разных режимов
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()).
Синтаксис
Псевдонимы: curdate, current_date
Аргументы
Возвращаемое значение
Возвращает текущую дату Date
Примеры
Пример использования
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
Примеры
Получение вчерашней даты
SELECT yesterday();
SELECT today() - 1;
┌─yesterday()─┐
│ 2025-06-09 │
└─────────────┘
┌─minus(today(), 1)─┐
│ 2025-06-09 │
└───────────────────┘
Последнее изменение 10 июня 2026 г.
