이 섹션의 대부분의 함수는 선택적으로 시간대 인수를 받습니다. 예를 들어 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])
DateTime 값을 반환합니다 DateTime
예시
예시
SELECT YYYYMMDDToDateTime(20230911131415);
┌──────YYYYMMDDhhmmssToDateTime(20230911131415)─┐
│ 2023-09-11 13:14:15 │
└───────────────────────────────────────────────┘
YYYYMMDDhhmmssToDateTime64
DateTime64로 변환합니다.
이 함수는 toYYYYMMDDhhmmss() 함수와 반대입니다.
입력이 유효한 DateTime64 값을 나타내지 않으면 출력은 정의되지 않습니다.
구문
YYYYMMDDhhmmssToDateTime64(YYYYMMDDhhmmss[, precision[, timezone]])
DateTime64 값을 반환합니다. DateTime64
예시
예시
SELECT YYYYMMDDhhmmssToDateTime64(20230911131415, 3, 'Asia/Istanbul');
┌─YYYYMMDDhhmm⋯/Istanbul')─┐
│ 2023-09-11 13:14:15.000 │
└──────────────────────────┘
addDate(datetime, interval)
datetime에 interval을 더해 얻은 날짜 또는 시간 정보가 포함된 날짜를 반환합니다. 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)를 전달하면 결과는 (1,1)이 아니라 (3)이 됩니다.
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에 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)
intervals가 추가된 date를 반환합니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
예시
날짜에 인터벌 Tuple 추가
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의 차이는 day 단위로는 3일,
month 단위로는 0개월, year 단위로는 0년입니다.
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 |
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와 동일한 유형이며, 일(day) 값이 수정된 값을 반환합니다. 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 or date 날짜-시간 값의 분 구성 요소를 변경합니다.
구문
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 사이의 차이는 unit이 day이면 3일
(toRelativeDayNum 참조), unit이 month이면 1개월 (toRelativeMonthNum 참조), unit이 year이면 1년입니다
(toRelativeYearNum 참조).
unit으로 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 |
unit로 표현한 enddate와 startdate의 차이를 반환합니다. 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의 시간대 이름입니다. 지정하지 않으면 함수는 datetime 매개변수의 시간대를 사용합니다. String
반환 값
잘라낸 날짜 및 시간 값을 반환합니다.
| Unit Argument | datetime Argument | Return Type |
|---|
| Year, Quarter, Month, Week | Date32 or DateTime64 or Date or DateTime | Date32 or Date |
| Day, Hour, Minute, Second | Date32, DateTime64, Date, or DateTime | DateTime64 or DateTime |
| Millisecond, Microsecond, | Any | DateTime64 |
| Nanosecond | | with scale 3, 6, or 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 datetime 포맷 스타일을 사용합니다. 자세한 내용은 MySQL 문서를 참조하십시오.
이 함수의 반대 연산은 parseDateTime입니다.
대체 필드를 사용하면 결과 문자열의 패턴을 정의할 수 있습니다.
아래 표의 예시 컬럼은 2018-01-02 22:33:44를 포맷한 결과를 보여줍니다.
대체 필드:
| 자리표시자 | 설명 | 예시 |
|---|
| %a | 요일 이름의 약어 (Mon-Sun) | Mon |
| %b | 월 이름의 약어 (Jan-Dec) | Jan |
| %c | 정수로 표현한 월 (01-12) | 01 |
| %C | 연도를 100으로 나눈 뒤 정수로 자른 값 (00-99) | 20 |
| %d | 0으로 채운 일 (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 week number용 네 자리 연도 형식 | 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 | 월요일을 1로 하는 숫자 형식의 ISO 8601 요일 (1-7) | 2 |
| %V | ISO 8601 week number (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 이전 버전에서는 포맷된 값이 Date, Date32, DateTime(소수 초가 없음)이거나 정밀도가 0인 DateTime64인 경우
%f가 단일 0(0)을 출력합니다.
- ClickHouse v25.1 이전 버전에서는
%f가 고정 6자리가 아니라 DateTime64의 scale에 지정된 자릿수만큼 출력됩니다.
- ClickHouse v23.4 이전 버전에서는
%M이 월 이름 전체(January-December) 대신 분(00-59)을 출력합니다.
구문
formatDateTime(datetime, format[, timezone])
DATE_FORMAT
인수
반환 값
지정된 포맷에 따라 시간 및 날짜 값을 반환합니다. 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와 비슷하지만, MySQL 스타일 대신 Joda 스타일로 날짜/시간 값을 포맷합니다. 자세한 내용은 Joda Time documentation을 참조하십시오.
이 함수의 반대 연산은 parseDateTimeInJodaSyntax입니다.
대체 필드를 사용하면 결과 문자열의 패턴을 정의할 수 있습니다.
대체 필드:
| Placeholder | Description | Presentation | Examples |
|---|
| 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])
String
예시
Joda 문법을 사용하여 datetime 포맷하기
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
인수
반환 값
0년부터 경과한 일수에 해당하는 날짜를 반환합니다. Date
예시
0년부터 경과한 일수를 날짜로 변환합니다
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 — 0년 기준 경과한 일수입니다. UInt32
반환 값
0년 기준 경과한 일수에 해당하는 날짜를 반환합니다. Date32
예시
0년 기준 일수를 날짜로 변환
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)
String
예시
수정 율리우스일을 날짜로 변환합니다
SELECT fromModifiedJulianDay(58849)
┌─fromModifiedJulianDay(58849)─┐
│ 2020-01-01 │
└──────────────────────────────┘
fromModifiedJulianDayOrNull
fromModifiedJulianDay()와 유사하지만, 예외를 발생시키는 대신 NULL을 반환합니다.
구문
fromModifiedJulianDayOrNull(day)
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 │
└─────────────────────────────────────────────────────────────────────────┘
fromUnixTimestamp(timestamp)
fromUnixTimestamp(timestamp[, format[, timezone]])
FROM_UNIXTIME
인수
반환 값
인수가 하나이면 해당 timestamp의 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처럼 동작합니다.
2개 또는 3개의 인수가 주어지고 첫 번째 인수가 Integer, Date, Date32, DateTime 또는 DateTime64 타입의 값이며, 두 번째 인수가 상수 포맷 문자열이고 세 번째 인수가 선택적 상수 시간대 문자열이면, 이 함수는 String 타입의 값을 반환합니다. 즉, formatDateTimeInJodaSyntax처럼 동작합니다. 이 경우 Joda datetime format style을 사용합니다.
구문
fromUnixTimestampInJodaSyntax(timestamp)
fromUnixTimestampInJodaSyntax(timestamp, format[, timezone])
DateTime 또는 String
예시
Joda 포맷으로 Unix 타임스탬프 변환
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 — 선택 사항입니다. tick 크기(정밀도)입니다. 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 설정 값을 반환합니다.
함수가 분산 테이블에서 실행되면 각 세그먼트에 해당하는 값을 가진 일반 컬럼을 생성합니다. 그렇지 않으면 상수 값을 생성합니다.
구문
별칭: serverTimeZone
인수
반환 값
서버의 시간대를 String으로 반환합니다.
예시
사용 예시
┌─serverTimeZone()─┐
│ UTC │
└──────────────────┘
subDate(datetime, interval)
datetime에서 interval을 차감해 얻은 날짜 또는 날짜/시간 값을 반환합니다. Date 또는 Date32 또는 DateTime 또는 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)이
전달되면 결과는 (2,1)이 아니라 (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에서 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에서 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 또는 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
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)
intervals를 뺀 date를 반환합니다. 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 값도 인수로 받을 수 있지만,
일반적인 범위를 벗어난 시간(Date는 1970년부터 2149년까지, DateTime은 2106년까지)을 전달하면 잘못된 결과가 나올 수 있습니다.
timeSlot(time[, time_zone])
DateTime
예시
시간을 30분 인터벌로 반올림
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의 시간대 이름을 반환합니다. String
예시
사용 예시
SELECT timezoneOf(now());
┌─timezoneOf(now())─┐
│ Europe/Amsterdam │
└───────────────────┘
timeZoneOffset
인수
반환 값
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의 해당 월 날짜(1-31)를 반환합니다.
구문
별칭: DAY, DAYOFMONTH
인수
반환 값
주어진 날짜/시간의 월의 일을 반환합니다. UInt8
예시
사용 예시
SELECT toDayOfMonth(toDateTime('2023-04-21 10:20:30'))
┌─toDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 21 │
└─────────────────────────────────────────────────┘
Date 또는 DateTime 값이 한 주에서 몇 번째 요일에 해당하는지 나타내는 숫자를 반환합니다.
toDayOfWeek()의 2인수 형식에서는 한 주의 시작일을 월요일 또는 일요일로 지정할 수 있으며,
반환값의 범위를 06 또는 17로 지정할 수도 있습니다.
| Mode | First day of week | Range |
|---|
| 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
인수
반환 값
지정된 Date 또는 DateTime에 해당하는 요일을 반환합니다. UInt8
예시
사용 예시
-- 다음 날짜는 2023년 4월 21일이며, 금요일이었습니다:
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 값이 해당 연도에서 몇 번째 날인지 나타내는 숫자(1-366)를 반환합니다.
구문
별칭: 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
인수
반환 값
날짜 0000-01-01부터 경과한 일수를 반환합니다. UInt32
예시
연도 0부터의 일수 계산
SELECT toDaysSinceYearZero(toDate('2023-09-08'))
┌─toDaysSinceYearZero(toDate('2023-09-08')))─┐
│ 713569 │
└────────────────────────────────────────────┘
DateTime 또는 DateTime64 값의 시(hour) 부분(0-23)을 반환합니다.
구문
별칭: HOUR
인수
반환 값
datetime의 시(0-23)를 반환합니다. UInt8
예시
사용 예시
SELECT toHour(toDateTime('2023-04-21 10:20:30'))
┌─toHour(toDateTime('2023-04-21 10:20:30'))─┐
│ 10 │
└───────────────────────────────────────────┘
toWeek(date, 3)와 동일한 호환성 함수입니다.
ISO 주는 월요일에 시작하며, 한 해의 첫 번째 주에는 1월 4일이 포함됩니다.
ISO 8601에 따르면 주 번호의 범위는 1부터 53까지입니다.
연도 시작이나 종료에 가까운 날짜는 이전 해 또는 다음 해의 주 번호를 반환할 수 있습니다. 예를 들어,
2025년 12월 29일은 2026년 1월 4일이 포함된 첫 번째 주에 속하므로 1을 반환합니다.
구문
toISOWeek(datetime[, timezone])
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
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
DateTime 또는 DateTime64 값의 밀리초 부분(0-999)을 반환합니다.
구문
별칭: MILLISECOND
인수
반환 값
datetime의 분 값(0 - 59)을 반환합니다. 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 값의 분 구성 요소(0-59)를 반환합니다.
구문
별칭: MINUTE
인수
반환 값
datetime의 시각에서 분(0 - 59)을 반환합니다. 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')─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
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 값의 월(1-12) 구성 요소를 반환합니다.
구문
별칭: 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 값이 해당하는 연도의 분기(1-4)를 반환합니다.
구문
별칭: 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 값의 초 부분(0-59)을 반환합니다.
구문
별칭: SECOND
인수
반환 값
datetime에서 분의 초(0 - 59)를 반환합니다. UInt8
예시
사용 예시
SELECT toSecond(toDateTime('2023-04-21 10:20:30'))
┌─toSecond(toDateTime('2023-04-21 10:20:30'))─┐
│ 30 │
└─────────────────────────────────────────────┘
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
인수
반환 값
가장 가까운 5분 인터벌의 시작으로 반올림된 시간 정보가 포함된 날짜를 반환합니다. 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
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 또는 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 │
└─────────────────────────────────────────────────────┘
toStartOfInterval(date_or_date_with_time, INTERVAL x unit [, time_zone]) 구문을 사용하여 다른 toStartOf*() 함수들을 일반화한 함수입니다.
예를 들어,
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년 1분기 |
| MONTH | 1900년 1월 |
| WEEK | 1970년 첫째 주 (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 함수와 다릅니다.
두 번째 오버로드는 TimescaleDB의 time_bucket() 함수와 PostgreSQL의 date_bin() 함수를 각각 에뮬레이션합니다.
구문
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
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
예시
해당 월의 첫째 날로 내림
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]])
mode에 따라 지정한 날짜와 같거나 그 이전인 가장 가까운 일요일 또는 월요일 날짜를 반환합니다. 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은 단독으로 사용해서는 안 됩니다.
이 함수의 주된 목적은 두 date 또는 날짜/시간 값 사이의 시간 차이를 계산하는 것입니다. 예를 들어 toTime(dt1) - toTime(dt2)와 같습니다.
구문
toTimeWithFixedDate(date[, timezone])
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;
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
인수
반환 값
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 timestamp(1970-01-01 00:00:00 UTC 이후 경과한 초)인 UInt32로 변환합니다.
구문
toUnixTimestamp(date[, timezone])
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()의 2인수 형식을 사용하면 주가 일요일에 시작할지 월요일에 시작할지, 그리고 반환값 범위를 053으로 할지 153으로 할지 지정할 수 있습니다.
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월 1일을 포함하는 주 |
| 9 | 월요일 | 1-53 | 1월 1일을 포함하는 주 |
mode 값의 경우, 주 번호는 ISO 8601:1988에 따라 매겨집니다.
- 1월 1일이 포함된 주가 새해에 4일 이상 포함되어 있으면 그 주는 1주차입니다.
- 그렇지 않으면 그 주는 이전 연도의 마지막 주이고, 다음 주가 1주차입니다.
“1월 1일을 포함”을 의미하는 mode 값의 경우, 1월 1일을 포함하는 주가 1주차입니다.
그 주에 새해의 날짜가 며칠 포함되어 있는지는 중요하지 않으며, 하루만 포함되어 있어도 마찬가지입니다.
즉, 12월의 마지막 주가 다음 해의 1월 1일을 포함하면 그 주는 다음 해의 1주차가 됩니다.
첫 번째 인수는 parseDateTime64BestEffort()에서 지원하는 포맷의 String으로도 지정할 수 있습니다. 문자열 인수 지원은 일부 타사 도구가 기대하는 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 숫자로 변환합니다.
선택적으로 두 번째 시간대 인수를 받을 수 있습니다. 이 인수를 지정하는 경우 시간대는 문자열 상수여야 합니다.
이 함수는 YYYYMMDDToDate() 함수와 반대입니다.
구문
toYYYYMM(datetime[, timezone])
UInt32
예시
현재 날짜를 YYYYMM 포맷으로 변환
SELECT toYYYYMM(now(), 'US/Eastern')
┌─toYYYYMM(now(), 'US/Eastern')─┐
│ 202303 │
└───────────────────────────────┘
UInt32 숫자(YYYY * 10000 + MM * 100 + DD)로 변환합니다. 두 번째 선택적 시간대 인수를 받을 수 있습니다. 이 인수가 제공되면 시간대는 문자열 상수여야 합니다.
구문
toYYYYMMDD(datetime[, timezone])
UInt32 숫자를 반환합니다. 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])
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 값의 연도 구성 요소(AD)를 반환합니다.
구문
별칭: 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()의 mode 인수와 동일한 방식으로 동작합니다.
경고: toYearWeek()가 반환하는 주 번호는 toWeek()의 반환값과 다를 수 있습니다. toWeek()는 항상 지정된 연도를 기준으로 주 번호를 반환하며, toWeek()가 0을 반환하는 경우 toYearWeek()는 이전 연도의 마지막 주에 해당하는 값을 반환합니다. 아래 예시의 prev_yearWeek를 참조하십시오.
첫 번째 인수는 parseDateTime64BestEffort()에서 지원하는 포맷의 String으로도 지정할 수 있습니다. 문자열 인수 지원은 일부 타사 도구에서 기대하는 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 │
└───────────────────┘
