본문으로 바로가기
본문으로 바로가기

날짜 및 시간 작업용 함수

이 섹션의 대부분 함수는 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 │
└─────────────────────┴────────────┴────────────┴─────────────────────┘

UTCTimestamp​

도입 버전: v22.11

쿼리 분석 시점의 현재 날짜와 시간을 반환합니다. 이 함수는 상수 표현식입니다.

이 함수는 now('UTC')가 반환하는 것과 동일한 결과를 제공합니다. MySQL 지원을 위해 추가되었습니다. now 사용을 권장합니다.

구문

UTCTimestamp()

별칭: UTC_timestamp

인수

  • 없음.

반환값

쿼리 분석 시점의 현재 날짜와 시간을 반환합니다. DateTime

예시

현재 UTC 타임스탬프 가져오기

SELECT UTCTimestamp()

┌──────UTCTimestamp()─┐
│ 2024-05-28 08:32:09 │
└─────────────────────┘

YYYYMMDDToDate​

도입 버전: v23.9

연, 월, 일을 나타내는 숫자를 Date로 변환합니다. 이 함수는 함수 toYYYYMMDD()의 역함수입니다. 입력이 유효한 Date 값을 나타내지 않으면 결과는 정의되지 않습니다.

구문

YYYYMMDDToDate(YYYYMMDD)

인수

  • YYYYMMDD — 연도, 월, 일을 포함하는 숫자입니다. (U)Int* 또는 Float* 또는 Decimal 형식의 값입니다.

반환 값

제공된 인수로부터 Date 값을 반환합니다. Date

예제

예제

SELECT YYYYMMDDToDate(20230911);

┌─toYYYYMMDD(20230911)─┐
│           2023-09-11 │
└──────────────────────┘

YYYYMMDDToDate32​

도입된 버전: v23.9

연, 월, 일을 나타내는 숫자를 Date32로 변환합니다. 이 함수는 함수 toYYYYMMDD()의 역함수입니다. 입력이 유효한 Date32 값을 인코딩하지 않으면 출력은 정의되지 않습니다.

구문

YYYYMMDDToDate32(YYYYMMDD)

인수

  • YYYYMMDD — 연도, 월, 일을 나타내는 숫자입니다. (U)Int* 또는 Float* 또는 Decimal

반환 값

제공된 인수로부터 Date32 값을 반환합니다. Date32

예시

예시

SELECT YYYYMMDDToDate32(20000507);

┌─YYYYMMDDToDate32(20000507)─┐
│                 2000-05-07 │
└────────────────────────────┘

YYYYMMDDhhmmssToDateTime​

도입 버전: v23.9

연, 월, 일, 시, 분, 초를 포함하는 숫자 값을 DateTime으로 변환합니다. 이 함수는 함수 toYYYYMMDDhhmmss()의 역함수입니다. 입력이 유효한 DateTime 값을 나타내지 않는 경우 결과는 정의되지 않습니다.

구문

YYYYMMDDhhmmssToDateTime(YYYYMMDDhhmmss[, timezone])

인수

  • YYYYMMDDhhmmss — 연, 월, 일, 시, 분, 초를 포함하는 수. (U)Int* 또는 Float* 또는 Decimal
  • timezone — 시간대 이름. String

반환 값

제공된 인수를 사용해 DateTime 값을 반환합니다. DateTime

예시

예시

SELECT YYYYMMDDToDateTime(20230911131415);

┌──────YYYYMMDDhhmmssToDateTime(20230911131415)─┐
│                           2023-09-11 13:14:15 │
└───────────────────────────────────────────────┘

YYYYMMDDhhmmssToDateTime64​

도입 버전: v23.9

년, 월, 일, 시, 분, 초를 포함하는 숫자를 DateTime64로 변환합니다. 이 FUNCTION은 toYYYYMMDDhhmmss()의 역연산입니다. 입력이 유효한 DateTime64 값을 나타내지 않으면 결과는 정의되지 않습니다.

구문

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

인자

  • YYYYMMDDhhmmss — 연, 월, 일, 시, 분, 초를 포함하는 숫자. (U)Int* 또는 Float* 또는 Decimal
  • precision — 소수 부분의 자릿수 정밀도(0-9). UInt8
  • timezone — 타임존 이름. String

반환 값

제공된 인자를 기반으로 DateTime64 값을 반환합니다. DateTime64

예시

예시

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

┌─YYYYMMDDhhmm⋯/Istanbul')─┐
│  2023-09-11 13:14:15.000 │
└──────────────────────────┘

addDate​

도입 버전: v23.9

제공된 date, date with time 값 또는 문자열로 인코딩된 date 혹은 date with time 값에 시간 간격을 더합니다. 연산 결과가 데이터 타입의 허용 범위를 벗어나는 경우 결과는 정의되지 않습니다.

구문

addDate(datetime, interval)

인수

반환 값

datetime에 interval을 더하여 얻은 날짜 또는 날짜와 시간을 반환합니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

예시

날짜에 interval 추가하기

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

┌─addDate(toDa⋯valYear(3))─┐
│               2021-01-01 │
└──────────────────────────┘

addDays​

도입 버전: v1.1

지정한 일 수를 날짜, 날짜-시간 또는 문자열로 인코딩된 날짜/날짜-시간 값에 더합니다.

구문

addDays(datetime, num)

인수(Arguments)

반환 값(Returned value)

datetime 값에 num일을 더한 결과를 반환합니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

예시(Examples)

서로 다른 날짜 타입에 일 수를 더하기

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 │
└────────────────────┴─────────────────────────┴────────────────────────────────┘

다른 INTERVAL 구문 사용

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

┌─plus(CAST('1⋯valDay(10))─┐
│               1998-06-26 │
└──────────────────────────┘

addHours​

도입 버전: v1.1

날짜, 날짜-시간 또는 문자열로 인코딩된 날짜/날짜-시간 값에 지정된 시간 수를 더합니다.

구문

addHours(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
    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 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘

INTERVAL의 대체 구문 사용하기

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

┌─plus(CAST('1⋯alHour(10))─┐
│      1998-06-16 10:00:00 │
└──────────────────────────┘

addInterval​

도입 버전: v22.11

하나의 interval 또는 interval 튜플에 다른 interval을 더합니다.

참고

동일한 타입의 interval은 하나의 interval로 합쳐집니다. 예를 들어 toIntervalDay(1)과 toIntervalDay(2)가 전달되면 결과는 (1,1)이 아니라 (3)이 됩니다.

구문

addInterval(interval_1, interval_2)

인자

  • interval_1 — 첫 번째 간격 또는 간격의 튜플입니다. Interval 또는 Tuple(Interval)
  • interval_2 — 더할 두 번째 간격입니다. Interval

반환 값

간격의 튜플을 반환합니다. 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​

도입 버전: v22.6

일시 값 또는 문자열로 인코딩된 일시에 지정된 마이크로초 수를 더합니다.

구문

addMicroseconds(datetime, num)

인수

  • datetime — 지정한 마이크로초 수를 더할 기준이 되는 날짜와 시각. DateTime 또는 DateTime64 또는 String
  • num — 더할 마이크로초 수. (U)Int* 또는 Float*

반환 값

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 │
└─────────────────────────────────┴────────────────────────────────────────┘

대체 INTERVAL 구문 사용

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

┌─plus(CAST('19⋯osecond(10))─┐
│ 1998-06-16 00:00:00.000010 │
└────────────────────────────┘

addMilliseconds​

도입 버전: v22.6

날짜-시간 값 또는 문자열로 인코딩된 날짜-시간 값에 지정된 밀리초 수를 더합니다.

구문

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 │
└─────────────────────────────────┴────────────────────────────────────────┘

대체 INTERVAL 구문 형식 사용하기

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

┌─plus(CAST('1⋯second(10))─┐
│  1998-06-16 00:00:00.010 │
└──────────────────────────┘

addMinutes​

도입 버전: v1.1

날짜, 날짜와 시간, 또는 이들이 문자열로 인코딩된 값에 지정한 분(minute) 수만큼을 더합니다.

구문

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 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘

다른 INTERVAL 구문 사용

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

┌─plus(CAST('1⋯Minute(10))─┐
│      1998-06-16 00:10:00 │
└──────────────────────────┘

addMonths​

도입 버전: v1.1

날짜, 날짜와 시간, 또는 문자열로 인코딩된 날짜나 날짜와 시간 값에 지정한 개월 수를 더합니다.

구문

addMonths(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
    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 │
└──────────────────────┴───────────────────────────┴──────────────────────────────────┘

대체 INTERVAL 구문 사용

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

┌─plus(CAST('1⋯lMonth(10))─┐
│               1999-04-16 │
└──────────────────────────┘

addNanoseconds​

도입 버전: v22.6

날짜‑시간 값 또는 문자열로 인코딩된 날짜‑시간 값에 지정된 나노초를 더합니다.

구문

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 │
└────────────────────────────────┴───────────────────────────────────────┘

다른 INTERVAL 구문 사용하기

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

┌─plus(CAST('199⋯osecond(1000))─┐
│ 1998-06-16 00:00:00.000001000 │
└───────────────────────────────┘

addQuarters​

도입: v20.1

날짜, 날짜‑시간 또는 문자열로 인코딩된 날짜나 날짜‑시간 값에 지정한 개수의 분기를 더합니다.

구문

addQuarters(datetime, num)

인수(Arguments)

반환 값(Returned value)

datetime에 num 분기를 더한 값을 반환합니다. 반환 타입은 Date 또는 Date32 또는 DateTime 또는 DateTime64입니다.

예시(Examples)

서로 다른 날짜형에 분기 추가하기

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 │
└────────────────────────┴─────────────────────────────┴────────────────────────────────────┘

대체 INTERVAL 구문 사용

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

┌─plus(CAST('1⋯uarter(10))─┐
│               2000-12-16 │
└──────────────────────────┘

addSeconds​

도입 버전: v1.1

날짜, 날짜·시간 값, 또는 문자열로 인코딩된 날짜나 날짜·시간 값에 지정한 초(second) 수를 더합니다.

구문

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 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘

다른 INTERVAL 구문 사용

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

┌─dateAdd('1998-06-16'::Date, INTERVAL 10 second)─┐
│                             1998-06-16 00:00:10 │
└─────────────────────────────────────────────────┘

addTupleOfIntervals​

도입 버전: v22.11

날짜 또는 날짜·시간 값에 기간 튜플(tuple of intervals)을 차례대로 더합니다.

구문

addTupleOfIntervals(datetime, intervals)

인수

  • datetime — 간격을 더할 대상이 되는 날짜 또는 날짜/시간입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • intervals — datetime에 더할 간격들의 튜플입니다. Tuple(Interval)

반환 값

intervals가 더해진 date 값을 반환합니다. 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 │
└──────────────────────────────────────────────────────────────────────────────────────┘

addWeeks​

도입 버전: v1.1

날짜, 날짜‑시간 또는 문자열로 인코딩된 날짜나 날짜‑시간 값에 지정한 주 수를 더합니다.

구문

addWeeks(datetime, num)

인수(Arguments)

반환 값(Returned value)

datetime에 num 주를 더한 값을 반환합니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

예시(Examples)

서로 다른 날짜/시간 유형에 주(week) 더하기

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 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘

대체 INTERVAL 구문 사용하기

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

┌─plus(CAST('1⋯alWeek(10))─┐
│               1998-08-25 │
└──────────────────────────┘

addYears​

도입: v1.1

지정한 연 수를 날짜, 날짜‑시간 값 또는 문자열로 인코딩된 날짜/날짜‑시간 값에 더합니다.

구문

addYears(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
    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 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘

다른 INTERVAL 구문 사용

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

┌─plus(CAST('1⋯alYear(10))─┐
│               2008-06-16 │
└──────────────────────────┘

age​

도입된 버전: v23.1

startdate와 enddate 사이의 차이를 지정한 단위로 반환합니다. 차이는 1 나노초 단위의 정밀도로 계산됩니다.

예를 들어, 2021-12-29와 2022-01-01 사이의 차이는 일(day) 단위로 3일, 월(month) 단위로 0개월, 연(year) 단위로 0년입니다.

age의 대안으로는 함수 dateDiff를 참고하십시오.

구문

age('unit', startdate, enddate[, timezone])

인수

  • unit — 결과를 표현할 간격 단위의 유형입니다.
Unit가능한 값
nanosecondnanosecond, nanoseconds, ns
microsecondmicrosecond, microseconds, us, u
millisecondmillisecond, milliseconds, ms
secondsecond, seconds, ss, s
minuteminute, minutes, mi, n
hourhour, hours, hh, h
dayday, days, dd, d
weekweek, weeks, wk, ww
monthmonth, months, mm, m
quarterquarter, quarters, qq, q
yearyear, years, yyyy, yy
  • startdate — 뺄셈에서 빼는 값(감수)에 해당하는 첫 번째 시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • enddate — 뺄셈에서 기준이 되는 값(피감수)에 해당하는 두 번째 시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • timezone — 선택 사항입니다. 타임존 이름입니다. 지정된 경우 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​

도입 버전: v24.7

Date 또는 DateTime 값의 일(day) 부분을 변경합니다.

구문

changeDay(date_or_datetime, value)

인수(Arguments)

반환 값(Returned value)

date_or_datetime와 동일한 형식이면서 일(day) 부분이 변경된 값을 반환합니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

예시(Examples)

사용 예시(Usage example)

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

2024-01-15 00:00:00

changeHour​

도입 버전: v24.7

날짜 또는 날짜-시간의 시(hour) 구성 요소를 변경합니다.

구문

changeHour(date_or_datetime, value)

인수

반환 값

date_or_datetime와 동일한 타입의 값에서 시간(hour) 구성 요소가 변경된 값을 반환합니다. DateTime 또는 DateTime64

예시

사용 예시

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

2024-01-01 05:00:00

changeMinute​

도입 버전: v24.7

Date 또는 DateTime 값의 분(minute) 구성 요소를 변경합니다.

구문

changeMinute(date_or_datetime, value)

인수

반환 값

분(minute) 구성 요소가 수정된, date_or_datetime와 동일한 타입의 값을 반환합니다. DateTime 또는 DateTime64

예시

사용 예시

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

2024-01-01 12:45:00

changeMonth​

도입 버전: v24.7

날짜(Date) 또는 날짜-시간(DateTime) 값의 월(month) 부분을 변경합니다.

구문

changeMonth(date_or_datetime, value)

인수

반환 값

date_or_datetime와 동일한 타입으로, 월(month) 구성 요소가 변경된 값을 반환합니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

예시

사용 예시

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

2024-12-01 00:00:00

changeSecond​

도입 버전: v24.7

날짜 또는 날짜‑시간 값에서 초(second) 구성 요소를 변경합니다.

구문

changeSecond(date_or_datetime, value)

인수

반환 값

date_or_datetime와 동일한 타입의 값으로, 초 부분이 수정된 값을 반환합니다. DateTime 또는 DateTime64

예시

사용 예시

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

2024-01-01 12:30:15

changeYear​

도입 버전: v24.7

날짜나 날짜-시간 값의 연도 부분을 변경합니다.

구문

changeYear(date_or_datetime, value)

인수

반환 값

date_or_datetime와 동일한 타입의 값으로, 연도 부분이 변경된 값을 반환합니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

예시

사용 예시

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

2023-01-01 00:00:00

dateDiff​

도입 버전: v23.4

지정된 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() FUNCTION과는 다르다는 점에 유의하십시오.

dateDiff의 대안으로는 age FUNCTION을 사용할 수 있습니다.

구문

dateDiff(unit, startdate, enddate[, timezone])

별칭(Aliases): timestampDiff, TIMESTAMP_DIFF, DATE_DIFF, date_diff, timestamp_diff

인수(Arguments)

  • unit — 결과 간격의 단위입니다.
Unit가능한 값
nanosecondnanosecond, nanoseconds, ns
microsecondmicrosecond, microseconds, us, u
millisecondmillisecond, milliseconds, ms
secondsecond, seconds, ss, s
minuteminute, minutes, mi, n
hourhour, hours, hh, h
dayday, days, dd, d
weekweek, weeks, wk, ww
monthmonth, months, mm, m
quarterquarter, quarters, qq, q
yearyear, years, yyyy, yy
  • startdate — 처음에 빼는 시간 값(감수)입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • enddate — 여기에서 값을 빼는 두 번째 시간 값(피감수)입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • timezone — 선택 사항입니다. 시간대 이름입니다. 지정하면 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

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

여러 단위로 날짜 차이 계산

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 │
└────────────┴────────────┴──────────┴────────────┴───────────┘

dateName​

도입된 버전: v21.7

날짜에서 지정한 부분을 반환합니다.

허용되는 값:

  • 'year'
  • 'quarter'
  • 'month'
  • 'week'
  • 'dayofyear'
  • 'day'
  • 'weekday'
  • 'hour'
  • 'minute'
  • 'second'

구문

dateName(date_part, date[, timezone])

인자

  • date_part — 추출하려는 날짜의 부분입니다. String
  • datetime — 날짜 또는 시간 정보를 포함한 날짜 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • timezone — 선택 사항입니다. 시간대입니다. String

반환 값

지정된 날짜 부분을 반환합니다. 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​

도입: v20.8

날짜/시간 값을 지정된 날짜 부분까지 잘라냅니다.

구문

dateTrunc(unit, datetime[, timezone])

별칭: DATE_TRUNC

인수

  • unit — 결과를 어떤 간격 단위로 절삭할지 지정합니다. 가능한 값: nanosecond (DateTime64에서만 사용), microsecond (DateTime64에서만 사용), millisecond (DateTime64에서만 사용), second, minute, hour, day, week, month, quarter, year. String
  • datetime — 날짜와 시간입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • timezone — 선택 사항입니다. 반환되는 datetime에 사용할 시간대 이름입니다. 지정하지 않으면 함수는 datetime 매개변수의 시간대를 사용합니다. String

반환 값

절삭된 날짜와 시간 값을 반환합니다.

Unit Argumentdatetime ArgumentReturn Type
Year, Quarter, Month, WeekDate32 or DateTime64 or Date or DateTimeDate32 or Date
Day, Hour, Minute, SecondDate32, DateTime64, Date, or DateTimeDateTime64 or DateTime
Millisecond, Microsecond,AnyDateTime64
Nanosecond스케일 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 │
└─────────────────────┴────────────────────────────────────────────┘

formatDateTime​

도입된 버전: v1.1

지정된 형식 문자열에 따라 날짜 또는 날짜·시간을 포맷합니다. format은 상수 표현식이므로 하나의 결과 컬럼에 여러 형식을 사용할 수 없습니다.

formatDateTime은 MySQL datetime 형식 스타일을 사용합니다. 자세한 내용은 mysql docs를 참고하십시오.

이 함수의 역연산은 parseDateTime입니다.

치환 필드를 사용하여 결과 문자열에 대한 패턴을 정의할 수 있습니다. 아래 표의 예시 컬럼은 2018-01-02 22:33:44에 대한 포맷 결과를 보여줍니다.

치환 필드:

Placeholder설명예시
%a요일 이름 약어 (Mon-Sun)Mon
%b월 이름 약어 (Jan-Dec)Jan
%c월을 정수형 숫자(01-12)로 표시01
%C연도를 100으로 나누고 정수로 절단한 값 (00-99)20
%d0으로 채운 일자(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
%gISO 8601에 맞춘 2자리 연도 형식18
%GISO 주 번호용 4자리 연도 형식2018
%h12시간제 시(01-12)09
%H24시간제 시(00-23)22
%i분(00-59)33
%I12시간제 시(01-12)10
%j연중 일수(001-366)002
%k24시간제 시(00-23)14
%l12시간제 시(01-12)09
%m월을 정수형 숫자(01-12)로 표시01
%M전체 월 이름 (January-December)January
%n개행 문자
%pAM 또는 PM 표기PM
%Q분기(1-4)1
%r12시간제 HH:MM AM/PM 시간, %h:%i %p와 동일10:30 PM
%R24시간제 HH:MM 시간, %H:%i와 동일22:33
%s초(00-59)44
%S초(00-59)44
%t수평 탭 문자
%TISO 8601 시간 형식 (HH:MM:SS), %H:%i:%S와 동일22:33:44
%u월요일을 1로 하는 ISO 8601 요일 번호(1-7)2
%VISO 8601 주 번호(01-53)01
%w일요일을 0으로 하는 요일 번호(0-6)2
%W전체 요일 이름 (Monday-Sunday)Monday
%y연도의 마지막 두 자리(00-99)18
%Y연도2018
%zUTC로부터의 시차, +HHMM 또는 -HHMM-0500
%%'%' 기호%
  • ClickHouse v23.4 이전 버전에서는 포맷 대상 값이 Date, Date32, DateTime(초 소수부 없음) 또는 정밀도가 0인 DateTime64인 경우 %f가 0 한 자리(0)만 출력합니다.
  • ClickHouse v25.1 이전 버전에서는 %f가 고정 6자리가 아니라 DateTime64의 스케일에 지정된 자리수만큼 숫자를 출력합니다.
  • ClickHouse v23.4 이전 버전에서는 %M이 전체 월 이름(January-December)이 아니라 분(00-59)을 출력합니다.

구문

formatDateTime(datetime, format[, timezone])

별칭: DATE_FORMAT

인수

  • datetime — 형식을 지정할 날짜 또는 날짜-시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • format — 치환 필드를 포함한 형식 문자열입니다. String
  • timezone — 선택 사항입니다. 형식이 적용된 시간에 사용할 시간대 이름입니다. String

반환 값

지정된 형식에 따라 시간과 날짜 값을 반환합니다. String

예시

연도 자리표시자를 사용하여 날짜 형식 지정하기

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

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

소수 초를 포함해 DateTime64 포맷하기

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    │
└─────────────────────┴───────────────────┴─────────────┘

formatDateTimeInJodaSyntax​

도입 버전: v20.1

formatDateTime와 유사하지만, MySQL 스타일 대신 Joda 스타일로 날짜-시간(datetime)을 포맷합니다. Joda Time 설명서를 참조하십시오.

이 함수의 반대 동작을 수행하는 함수는 parseDateTimeInJodaSyntax입니다.

치환 필드를 사용하여 결과 문자열의 패턴을 정의할 수 있습니다.

치환 필드:

Placeholder설명표시 형식예시
G연대(era)텍스트AD
C연대의 세기(>=0)숫자20
Y연대의 연도(>=0)연도1996
xweekyear(아직 지원되지 않음)연도1996
wweekyear의 주(아직 지원되지 않음)숫자27
e요일숫자2
E요일텍스트Tuesday; Tue
y연도연도1996
D연중 일수(day of year)숫자189
M월월July; Jul; 07
d월중 일(day of month)숫자10
a오전/오후(halfday of day)텍스트PM
Khalfday의 시각(0~11)숫자0
hhalfday의 시각(1~12, clockhour)숫자12
H하루의 시각(0~23)숫자0
k하루의 시각(1~24, clockhour)숫자24
m분숫자30
s초숫자55
S초의 분수 부분숫자978
z시간대텍스트Eastern Standard Time; EST
Z시간대 오프셋zone-0800; -0812
'텍스트 이스케이프구분 기호
''작은따옴표리터럴'

구문

formatDateTimeInJodaSyntax(datetime, format[, timezone])

인수

  • datetime — 형식을 지정할 날짜 또는 날짜‑시간 값. DateTime 또는 Date 또는 Date32 또는 DateTime64
  • format — Joda 스타일 치환 필드를 사용하는 형식 문자열. String
  • timezone — 선택 사항. 형식화된 시간에 사용할 타임존 이름. String

반환 값

지정된 형식에 따라 시간과 날짜 값을 반환합니다. 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                                                                     │
└─────────────────────────────────────────────────────────────────────────────────────────┘

fromDaysSinceYearZero​

도입된 버전: v23.11

0000년 1월 1일 이후 경과한 일 수가 주어지면, ISO 8601에서 정의한 프로렙틱 그레고리력(proleptic Gregorian calendar)에 따른 해당 날짜를 반환합니다.

계산 방식은 MySQL의 FROM_DAYS() FUNCTION과 동일합니다. 결과가 Date 타입의 범위 내에서 표현될 수 없는 경우, 결과는 정의되지 않습니다.

구문

fromDaysSinceYearZero(days)

별칭: FROM_DAYS

인수

  • days — 0년(Year 0) 이후 경과한 일 수입니다. UInt32

반환 값

0년(Year 0) 이후 경과한 일 수에 해당하는 날짜를 반환합니다. Date

예시

0년(Year 0) 이후 경과한 일 수를 날짜로 변환하기

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

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

fromDaysSinceYearZero32​

도입 버전: v23.11

0000년 1월 1일 이후 경과한 일 수가 주어지면, ISO 8601에서 정의한 선형 그레고리력(proleptic Gregorian calendar)에서 해당하는 날짜를 반환합니다. 계산은 MySQL의 FROM_DAYS() FUNCTION과 동일합니다. 결과가 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 │
└────────────┴────────────┘

fromModifiedJulianDay​

도입 버전: v21.1

Modified Julian Day 숫자를 선행 그레고리력(Proleptic Gregorian calendar)의 텍스트 형식 YYYY-MM-DD인 날짜로 변환합니다. 이 함수는 -678941부터 2973483까지의 날짜 번호를 지원합니다(각각 0000-01-01과 9999-12-31을 의미합니다). 지원 범위를 벗어난 날짜 번호가 주어지면 예외를 발생시킵니다.

구문

fromModifiedJulianDay(day)

인수

  • day — Modified Julian Day 숫자. (U)Int*

반환 값

텍스트 형식의 날짜를 반환합니다. String

예제

Modified Julian Day 값을 날짜로 변환

SELECT fromModifiedJulianDay(58849)

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

fromModifiedJulianDayOrNull​

도입 버전: v21.1

fromModifiedJulianDay()와 유사하지만, 예외를 발생시키는 대신 NULL을 반환합니다.

구문

fromModifiedJulianDayOrNull(day)

인수

  • day — 수정 율리우스일(Modified Julian Day) 숫자. (U)Int*

반환 값

day 인수가 유효한 경우 해당 날짜를 텍스트 형식으로 반환하고, 그렇지 않으면 null을 반환합니다. Nullable(String)

예시

널 값 처리를 포함하여 수정 율리우스일을 날짜로 변환

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

┌─fromModified⋯Null(58849)─┐
│ 2020-01-01               │
└──────────────────────────┘
┌─fromModified⋯l(60000000)─┐
│ ᴺᵁᴸᴸ                     │
└──────────────────────────┘

fromUTCTimestamp​

도입된 버전: v22.1

UTC 시간대의 날짜 또는 날짜와 시간 값을 지정된 시간대의 날짜 또는 날짜와 시간 값으로 변환합니다. 이 함수는 주로 Apache Spark 및 유사한 프레임워크와의 호환성을 위해 포함되어 있습니다.

구문

fromUTCTimestamp(datetime, time_zone)

별칭(Aliases): from_utc_timestamp

인수(Arguments)

  • datetime — 날짜 또는 날짜와 시간을 포함한 상수 값이나 표현식입니다. DateTime 또는 DateTime64
  • time_zone — 시간대를 나타내는 String 타입의 상수 값 또는 표현식입니다. String

반환 값(Returned value)

지정된 시간대의 DateTime/DateTime64 값을 반환합니다. DateTime 또는 DateTime64

예시(Examples)

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​

도입 버전: v20.8

이 FUNCTION은 Unix 타임스탬프를 달력 날짜와 하루 중 시간으로 변환합니다.

다음 두 가지 방식으로 호출할 수 있습니다.

구문

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

별칭(Aliases): FROM_UNIXTIME

인수(Arguments)

  • timestamp — Unix 타임스탬프 또는 날짜/날짜와 시간 값. (U)Int* 또는 Date 또는 Date32 또는 DateTime 또는 DateTime64
  • format — 선택 사항. 출력 형식을 지정하는 상수 형식 문자열입니다. String
  • timezone — 선택 사항. 시간대를 나타내는 상수 문자열입니다. String

반환 값(Returned value)

하나의 인수로 호출되면 해당 타임스탬프의 DateTime 값을 반환하고, 두 개 또는 세 개의 인수로 호출되면 String 값을 반환합니다. DateTime 또는 String

예시(Examples)

Unix 타임스탬프를 DateTime으로 변환

SELECT fromUnixTimestamp(423543535)

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

형식을 지정하여 Unix 타임스탬프 변환

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

┌─DateTime────────────┐
│ 2009-02-11 14:42:23 │
└─────────────────────┘

fromUnixTimestampInJodaSyntax​

도입 버전: v23.1

이 FUNCTION은 Unix 타임스탬프를 달력 날짜와 하루 중 시간으로 변환합니다.

다음 두 가지 방식으로 호출할 수 있습니다.

Integer 타입의 인수를 하나만 전달하면 DateTime 타입의 값을 반환하며, 즉 toDateTime과 동일하게 동작합니다.

첫 번째 인수가 Integer, Date, Date32, DateTime 또는 DateTime64 타입의 값이고, 두 번째 인수가 상수 형식 문자열이며, 세 번째 인수가 선택적인 상수 시간대 문자열인 두 개 또는 세 개의 인수를 전달하는 경우, FUNCTION은 String 타입의 값을 반환하며, 즉 formatDateTimeInJodaSyntax와 동일하게 동작합니다. 이때 Joda 날짜-시간 형식 스타일을 사용합니다.

구문

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

인수

  • timestamp — Unix 타임스탬프 또는 날짜/시간 값. (U)Int* 또는 Date 또는 Date32 또는 DateTime 또는 DateTime64
  • format — 선택 사항입니다. 출력 형식을 위한 Joda 구문을 사용하는 상수 형식 문자열입니다. String
  • timezone — 선택 사항입니다. 상수 시간대 문자열입니다. String

반환 값

하나의 인수로 호출되면 시간 정보가 포함된 날짜를 반환하고, 두 개 또는 세 개의 인수로 호출되면 String을 반환합니다.} DateTime 또는 String

예시

Joda 형식을 사용하여 Unix 타임스탬프를 변환

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

┌─DateTime────────────┐
│ 2009-02-11 06:42:23 │
└─────────────────────┘

makeDate​

도입된 버전: v22.6

다음 입력을 사용하여 Date를 생성합니다:

  • 연도, 월, 일
  • 연도와 연중 일(day of year)

구문

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 │
└────────────┘

makeDate32​

도입 버전: v22.6

다음 입력으로부터 Date32 값을 생성합니다.

  • 연, 월, 일
  • 연, 연중 날짜(day of year)

구문

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

인자

반환 값

제공된 인자로부터 구성한 Date32 값을 반환합니다. Date32

예시

연, 월, 일로부터 Date32 생성

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

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

연도와 연중 일(day of year)로 Date32 생성

SELECT makeDate(2023, 42) AS date;

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

makeDateTime​

도입 버전: v22.6

연, 월, 일, 시, 분, 초와 선택적 타임존을 사용하여 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 │
└─────────────────────┘

makeDateTime64​

도입된 버전: v22.6

year, month, day, hour, minute, second 값과 선택적인 fraction, precision, timezone 값을 사용하여 DateTime64를 생성합니다.

구문

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

인자

반환 값

제공된 인자들로부터 구성된 DateTime64 값을 반환합니다. DateTime64

예시

year, month, day, hour, minute, second 값으로부터 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 │
└─────────────────────────────────────────────────┘

monthName​

도입된 버전: v22.1

날짜 또는 날짜-시간(DateTime) 값에서 월 이름을 문자열로 반환합니다.

구문

monthName(datetime)

인수

반환 값

월 이름을 반환합니다. String

예제

날짜에서 월 이름 구하기

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

┌─monthName(date_value)─┐
│ April                 │
└───────────────────────┘

now​

도입된 버전: v1.1

쿼리 분석 시점에 현재 날짜와 시간을 반환합니다. 이 함수는 상수 표현식입니다.

구문

now([timezone])

별칭: current_timestamp

인수

  • timezone — 선택입니다. 반환되는 값의 시간대 이름입니다. String

반환 값

현재 날짜와 시간을 반환합니다. DateTime

예제

시간대를 지정하지 않은 쿼리

SELECT now()

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

타임존을 지정하여 쿼리하기

SELECT now('Asia/Istanbul')

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

now64​

도입된 버전: v20.1

쿼리 분석 시점의 현재 날짜와 시간을 하위 초 단위(서브초) 정밀도로 반환합니다. 이 함수는 상수 표현식입니다.

구문

now64([scale[, timezone]])

인수

  • scale — 선택 사항. 틱 크기(정밀도): 10^-scale 초입니다. 유효 범위: [0 : 9]. 일반적으로 3(기본값, 밀리초), 6(마이크로초), 9(나노초)를 사용합니다. UInt8
  • timezone — 선택 사항. 반환 값의 시간대 이름입니다. 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 │
└─────────────────────────┴───────────────────────────────┘

nowInBlock​

도입된 버전: v22.8

각 데이터 블록을 처리하는 시점의 현재 날짜와 시간을 반환합니다. 함수 now와 달리 상수 표현식이 아니므로, 장시간 실행되는 쿼리에서는 블록마다 반환값이 달라집니다.

장시간 실행되는 INSERT SELECT 쿼리에서 현재 시간을 생성하는 용도로 이 함수를 사용하는 것이 적합합니다.

구문

nowInBlock([timezone])

인수

  • 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​

도입 버전: v25.8

각 데이터 블록을 처리하는 시점의 현재 날짜와 시간을 밀리초 단위로 반환합니다. 함수 now64와 달리 상수 표현식이 아니며, 장시간 실행되는 쿼리에서는 블록마다 반환 값이 달라집니다.

장시간 실행되는 INSERT SELECT 쿼리에서 현재 시간을 생성하는 용도로 이 함수를 사용하는 것이 좋습니다.

구문

nowInBlock([scale[, timezone]])

인수

  • scale — 선택 사항입니다. 틱 크기(정밀도): 10^-정밀도 초입니다. 유효 범위: [0 : 9]. 일반적으로 사용하는 값은 3(기본값, 밀리초), 6(마이크로초), 9(나노초)입니다. UInt8
  • timezone — 선택 사항입니다. 반환 값의 시간대 이름입니다. 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 │
└─────────────────────────┴─────────────────────────┴──────────┘

serverTimezone​

도입 버전: v23.6

서버의 타임존, 즉 timezone 설정 값을 반환합니다. 함수가 분산 테이블 컨텍스트에서 실행되는 경우에는 각 세그먼트에 해당하는 값이 들어 있는 일반 컬럼을 생성합니다. 그렇지 않은 경우 상수 값을 생성합니다.

구문

serverTimeZone()

별칭: serverTimeZone

인수

  • 없음.

반환 값

서버 시간대를 String 형식으로 반환합니다.

예제

사용 예제

SELECT serverTimeZone()

┌─serverTimeZone()─┐
│ UTC              │
└──────────────────┘

subDate​

도입 버전: v23.9

지정된 날짜, 시간 정보가 있는 날짜 또는 문자열로 인코딩된 날짜/날짜-시간 값에서 시간 간격을 뺍니다. 뺄셈 결과가 데이터 타입의 허용 범위를 벗어나면 결과는 정의되지 않습니다.

구문

subDate(datetime, interval)

인수

  • datetime — interval을 뺄 기준이 되는 날짜 또는 날짜와 시간입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • interval — 빼려는 기간(interval)입니다. 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​

도입: v1.1

날짜, 날짜-시간 값, 또는 문자열로 인코딩된 날짜나 날짜-시간 값에서 지정된 일 수를 뺍니다.

구문

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 │
└─────────────────────────┴──────────────────────────────┴─────────────────────────────────────┘

다른 INTERVAL 구문 사용하기

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

┌─minus(CAST('⋯valDay(10))─┐
│               1998-06-06 │
└──────────────────────────┘

subtractHours​

도입된 버전: v1.1

날짜, 날짜와 시간, 또는 문자열로 인코딩된 날짜나 날짜와 시간 값에서 지정한 시간 수만큼을 뺍니다.

구문

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 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘

다른 INTERVAL 구문 사용하기

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

┌─minus(CAST('⋯alHour(10))─┐
│      1998-06-15 14:00:00 │
└──────────────────────────┘

subtractInterval​

도입 버전: v22.11

음수 interval을 다른 interval 또는 interval 튜플(tuple)에 더합니다.

참고: 같은 타입의 interval은 하나의 interval로 합쳐집니다. 예를 들어 toIntervalDay(2)와 toIntervalDay(1)이 전달되면 결과는 (2,1)이 아니라 (1)이 됩니다.

구문

subtractInterval(interval_1, interval_2)

인수

  • interval_1 — 첫 번째 인터벌 또는 인터벌 튜플. Interval 또는 Tuple(Interval)
  • interval_2 — 부호를 반전할 두 번째 인터벌. Interval

반환 값

인터벌의 튜플 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​

도입된 버전: v22.6

시간을 포함한 날짜 값 또는 문자열로 인코딩된 시간 포함 날짜 값에서 지정된 마이크로초 수를 뺍니다.

구문

subtractMicroseconds(datetime, num)

인수

  • datetime — 지정된 마이크로초 수를 빼려는 날짜와 시간입니다. DateTime 또는 DateTime64 또는 String
  • num — 빼려는 마이크로초 수입니다. (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 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘

다른 INTERVAL 구문 사용

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

┌─minus(CAST('1⋯osecond(10))─┐
│ 1998-06-15 23:59:59.999990 │
└────────────────────────────┘

subtractMilliseconds​

도입된 버전: v22.6

날짜 및 시간 값 또는 문자열로 인코딩된 날짜 및 시간 값에서 지정된 밀리초 수를 뺍니다.

구문

subtractMilliseconds(datetime, num)

인수(Arguments)

반환 값(Returned value)

datetime에서 num 밀리초를 뺀 값을 반환합니다. DateTime64

예시(Examples)

서로 다른 날짜 및 시간 타입에서 밀리초 빼기

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 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘

대체 INTERVAL 구문 사용하기

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

┌─minus(CAST('⋯second(10))─┐
│  1998-06-15 23:59:59.990 │
└──────────────────────────┘

subtractMinutes​

도입 버전: v1.1

날짜, 날짜-시간 값 또는 문자열로 인코딩된 날짜나 날짜-시간 값에서 지정된 분 수를 뺍니다.

구문

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 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘

다른 INTERVAL 구문 사용

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

┌─minus(CAST('⋯Minute(10))─┐
│      1998-06-15 23:50:00 │
└──────────────────────────┘

subtractMonths​

도입 버전: v1.1

날짜, 날짜와 시간, 또는 문자열로 인코딩된 날짜나 날짜와 시간 값에서 지정한 개월 수를 뺍니다.

구문

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 │
└───────────────────────────┴────────────────────────────────┴───────────────────────────────────────┘

대체 INTERVAL 구문 사용

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

┌─minus(CAST('⋯lMonth(10))─┐
│               1997-08-16 │
└──────────────────────────┘

subtractNanoseconds​

도입 버전: v20.1

날짜‑시간 값 또는 문자열로 인코딩된 날짜‑시간 값에서 지정된 나노초 수를 뺍니다.

구문

subtractNanoseconds(datetime, num)

인수(Arguments)

반환 값(Returned value)

datetime 값에서 num 나노초를 뺀 DateTime64 값을 반환합니다.

예시(Examples)

서로 다른 날짜/시간 타입에서 나노초 빼기

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 │
└─────────────────────────────────────┴────────────────────────────────────────────┘

대체 INTERVAL 구문 사용

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

┌─minus(CAST('19⋯anosecond(10))─┐
│ 1998-06-15 23:59:59.999999990 │
└───────────────────────────────┘

subtractQuarters​

도입 버전: v20.1

날짜, 날짜와 시간, 또는 이러한 값이 문자열로 인코딩된 값에서 지정한 개수의 분기를 뺍니다.

구문

subtractQuarters(datetime, num)

인수

  • datetime — 지정된 개수의 분기를 차감할 기준 날짜 또는 날짜와 시간입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64 또는 String
  • num — 차감할 분기의 개수입니다. (U)Int* 또는 Float*

반환 값

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 │
└─────────────────────────────┴──────────────────────────────────┴─────────────────────────────────────────┘

INTERVAL 대체 구문 사용

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

┌─minus(CAST('1⋯Quarter(10))─┐
│                1996-09-16 │
└───────────────────────────┘

subtractSeconds​

도입 버전: v1.1

날짜, 날짜와 시간, 또는 문자열로 인코딩된 날짜나 날짜와 시간에서 지정된 초 수를 뺍니다.

문법

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 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘

다른 INTERVAL 구문 사용하기

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

┌─minus(CAST('⋯Second(10))─┐
│      1998-06-15 23:59:50 │
└──────────────────────────┘

subtractTupleOfIntervals​

도입 버전: v22.11

날짜 또는 날짜와 시간 값에서 인터벌 튜플을 순차적으로 차감하는 함수입니다.

구문

subtractTupleOfIntervals(datetime, intervals)

인수

  • datetime — 간격을 빼는 기준이 되는 날짜 또는 날짜와 시간입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • intervals — datetime에서 뺄 간격을 나타내는 튜플입니다. Tuple(Interval)

반환 값

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​

도입 버전: v1.1

날짜, 날짜-시간 또는 문자열로 인코딩된 날짜나 날짜-시간 값에서 지정된 주 수를 뺍니다.

구문

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 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘

대체 INTERVAL 구문 사용하기

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

┌─minus(CAST('⋯alWeek(10))─┐
│               1998-04-07 │
└──────────────────────────┘

subtractYears​

도입된 버전: v1.1

날짜 값, 날짜‑시간 값, 또는 문자열로 인코딩된 날짜/날짜‑시간 값에서 지정한 연도 수를 뺍니다.

구문

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 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘

다른 INTERVAL 구문 사용하기

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

┌─minus(CAST('⋯alYear(10))─┐
│               1988-06-16 │
└──────────────────────────┘

timeDiff​

도입된 버전: v23.4

두 개의 날짜 또는 날짜-시간 값 사이의 차이를 초 단위로 반환합니다. 차이는 enddate - startdate로 계산됩니다.

이 FUNCTION은 dateDiff('second', startdate, enddate)와 동일합니다.

다른 단위(시간, 일, 월 등)로 시간 차이를 계산하려면 dateDiff FUNCTION을 사용하십시오.

구문

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 │
└───────┘

초 단위 dateDiff와 동일합니다

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 │
└──────────────────┴──────────────────┘

timeSlot​

도입 버전: v1.1

시간을 30분 길이 구간의 시작 시각으로 반올림합니다.

참고

이 함수는 확장 타입인 Date32 및 DateTime64 값을 인수로 받을 수 있지만, 일반 범위( Date는 1970년부터 2149년까지, DateTime은 1970년부터 2106년까지) 밖의 시간을 전달하면 잘못된 결과가 나옵니다.

구문

timeSlot(time[, time_zone])

인수

  • time — 30분 길이의 구간 시작 시각으로 반올림할 기준 시각입니다. DateTime 또는 Date32 또는 DateTime64
  • time_zone — 선택 사항입니다. 시간대를 나타내는 String 타입 상수 값 또는 표현식입니다. String

반환 값

30분 길이의 구간 시작 시각으로 반올림한 시각을 반환합니다. 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 │
└────────────────────────────────────────────────────┘

timeSlots​

도입된 버전: v1.1

StartTime에서 시작하여 Duration초 동안 이어지는 시간 구간에 대해, 이 구간에 속하는 시점들을 Size초 단위로 내림한 시각들의 배열을 반환합니다. Size는 선택적 매개변수이며 기본값은 1800초(30분)입니다.

이는 예를 들어, 해당 세션에서 페이지 조회수를 조회할 때 필요합니다.

DateTime64의 경우, 반환값의 스케일은 StartTime의 스케일과 다를 수 있습니다. 전달된 모든 인수 중 가장 높은 스케일이 사용됩니다.

구문

timeSlots(StartTime, Duration[, Size])

인수

  • StartTime — 구간의 시작 시각입니다. DateTime 또는 DateTime64
  • Duration — 구간의 지속 시간(초 단위)입니다. UInt32 또는 DateTime64
  • Size — 선택 사항입니다. 시간 슬롯의 크기(초 단위)입니다. 기본값은 1800(30분)입니다. UInt32 또는 DateTime64

반환 값

DateTime/DateTime64 배열을 반환합니다(반환 타입은 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']                        │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────┘

timestamp​

도입: v23.9

첫 번째 인수 expr을 데이터 타입 DateTime64(6)으로 변환합니다. 두 번째 인수 expr_time이 제공되면, 변환된 값에 지정된 시간을 더합니다.

구문

timestamp(expr[, expr_time])

인수

  • expr — 날짜 또는 날짜와 시간. String
  • expr_time — 선택 사항. 변환된 값에 더할 시간. String

반환 값

expr을 변환한 값 또는 expr_time 시간이 더해진 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​

도입된 버전: v21.4

현재 세션의 시간대 이름을 반환하거나, 시간대 오프셋 또는 이름을 표준 시간대 이름으로 변환합니다.

구문

timezone()

별칭: timeZone

인수

  • 없음.

반환 값

정식 시간대(canonical time zone) 이름을 String 형식으로 반환합니다.

예시

사용 예시

SELECT timezone()

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

timezoneOf​

도입된 버전: v21.4

DateTime 또는 DateTime64 값의 시간대(time zone) 이름을 반환합니다.

구문

timeZoneOf(datetime)

별칭: timeZoneOf

인수

  • datetime — DateTime 또는 DateTime64 타입의 값입니다.
  • timezone — 선택적입니다. datetime 값의 타임존을 변환할 대상 타임존 이름입니다. String

반환 값

datetime의 타임존 이름을 반환합니다. String

예시

사용 예시

SELECT timezoneOf(now());

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

timezoneOffset​

도입 버전: v21.6

UTC로부터의 시간대 오프셋을 초 단위로 반환합니다. 이 함수는 지정한 날짜와 시간에 대해 일광 절약 시간제(DST)와 과거 시간대 변경 사항을 고려합니다.

구문

timeZoneOffset(datetime)

별칭: 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 │
└─────────────────────┴──────────────────────────────┴───────────────────┴─────────────────┘

toDayOfMonth​

도입 버전: v1.1

Date 또는 DateTime 값의 월별 일자(1-31)를 반환합니다.

구문

toDayOfMonth(datetime)

별칭(Aliases): DAY, DAYOFMONTH

인수(Arguments)

  • datetime — 일(day of month) 값을 가져올 기준이 되는 날짜 또는 날짜·시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

반환 값(Returned value)

지정된 날짜/시간 값의 일(day of month)을 반환합니다. UInt8

예시(Examples)

사용 예시(Usage example)

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

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

toDayOfWeek​

도입된 버전: v1.1

Date 또는 DateTime 값의 주(週)에서 요일을 나타내는 번호를 반환합니다.

toDayOfWeek()의 두 개 인자를 받는 형식을 사용하면 주의 시작 요일을 Monday 또는 Sunday로 지정하고, 반환값의 범위를 0-6 또는 1-7 중에서 선택할 수 있습니다.

ModeFirst day of weekRange
0Monday1-7: Monday = 1, Tuesday = 2, ..., Sunday = 7
1Monday0-6: Monday = 0, Tuesday = 1, ..., Sunday = 6
2Sunday0-6: Sunday = 0, Monday = 1, ..., Saturday = 6
3Sunday1-7: Sunday = 1, Monday = 2, ..., Saturday = 7

구문

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

별칭(Aliases): DAYOFWEEK

인수(Arguments)

  • datetime — 요일을 구할 날짜 또는 날짜·시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • mode — 선택 사항입니다. 주 모드(week mode)를 지정하는 0–3 범위의 정수입니다. 생략하면 기본값은 0입니다. UInt8
  • timezone — 선택 사항입니다. 변환에 사용할 시간대(timezone)입니다. String

반환 값(Returned value)

지정된 Date 또는 DateTime 값의 요일을 반환합니다. UInt8

예시(Examples)

사용 예시(Usage example)

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

┌─toDayOfWeek(toDateTime('2023-04-21'))─┬─toDayOfWeek(toDateTime('2023-04-21'), 1)─┐
│                                     5 │                                        4 │
└───────────────────────────────────────┴──────────────────────────────────────────┘

toDayOfYear​

도입된 버전: v18.4

Date 또는 DateTime 값이 속한 연도에서, 해당 날짜의 일(日) 번호(1-366)를 반환합니다.

구문

toDayOfYear(datetime)

별칭: DAYOFYEAR

인수

  • datetime — 연중 일수(day of year)를 가져올 날짜 또는 날짜-시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

반환 값

지정된 Date 또는 DateTime 값의 연중 일수를 반환합니다. UInt16

예시

사용 예시

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

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

toDaysSinceYearZero​

도입 버전: v23.9

지정된 날짜에 대해, ISO 8601에서 정의한 선대 그레고리력(proleptic Gregorian calendar)에서 서기 0000년 1월 1일 이후 경과한 일수를 반환합니다.

계산 방식은 MySQL의 TO_DAYS 함수와 동일합니다.

구문

toDaysSinceYearZero(date[, time_zone])

별칭(Aliases): TO_DAYS

인수(Arguments)

  • date — 0년부터 경과한 일수를 계산할 날짜 또는 날짜와 시간 값. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • time_zone — 시간대. String

반환 값(Returned value)

날짜 0000-01-01 이후 경과한 일수를 반환합니다. UInt32

예시(Examples)

0년 기준 경과 일수 계산

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

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

toHour​

도입 버전: v1.1

DateTime 또는 DateTime64 값의 시(hour) 구성 요소(0-23)를 반환합니다.

구문

toHour(datetime)

별칭: HOUR

인수

반환 값

datetime의 시(0-23)를 반환합니다. UInt8

예시

사용 예

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

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

toISOWeek​

도입 버전: v20.1

Date 또는 시간 정보를 포함한 DateTime 값의 ISO 주(week) 번호를 반환합니다.

이 FUNCTION은 toWeek(date, 3)와 동일한 호환성 FUNCTION입니다. ISO 주는 월요일에 시작하며, 한 해의 첫 번째 주는 1월 4일을 포함하는 주입니다. ISO 8601에 따르면, 주 번호는 1부터 53까지의 범위를 가집니다.

연도 시작 또는 끝에 가까운 날짜는 이전 연도나 다음 연도의 주 번호를 반환할 수 있다는 점에 유의하십시오. 예를 들어, 2025년 12월 29일은 2026년 1월 4일을 포함하는 첫 번째 주에 속하기 때문에 주 번호 1을 반환합니다.

Syntax

toISOWeek(datetime[, timezone])

인수

  • datetime — ISO 주 번호를 계산할 날짜 또는 날짜와 시간입니다. Date 또는 DateTime 또는 Date32 또는 DateTime64
  • timezone — 선택 사항인 시간대입니다. String

반환 값

ISO 8601 표준에 따른 ISO 주 번호를 반환합니다. 1에서 53 사이의 값을 반환합니다. UInt8

예제

ISO 주 번호 구하기

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

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

ISO 주는 다른 해에 속할 수 있습니다

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

┌───────date─┬─isoWeek─┬─year─┐
│ 2025-12-29 │       1 │ 2025 │
└────────────┴─────────┴──────┘

toISOYear​

도입 버전: v18.4

날짜 또는 날짜-시간 값을 ISO 연도 번호로 변환합니다.

구문

toISOYear(datetime)

인수

반환 값

입력 값을 ISO 연도 번호로 변환하여 반환합니다. UInt16

예제

날짜 값에서 ISO 연도 추출하기

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

┌─week1─┬─week2─┐
│    40 │    40 │
└───────┴───────┘

toLastDayOfMonth​

도입 버전: v1.1

날짜 또는 날짜·시간 값을 해당 월의 마지막 날로 올립니다.

참고

반환 타입은 enable_extended_results_for_datetime_functions 설정을 통해 구성할 수 있습니다.

구문

toLastDayOfMonth(value)

별칭: LAST_DAY

인수

  • value — 해당 월의 마지막 날로 올림할 날짜 또는 날짜 및 시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

반환 값

지정된 날짜 또는 날짜 및 시간 값에 대해 해당 월의 마지막 날짜를 반환합니다. Date

예시

월의 마지막 날로 올림하기

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

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

toLastDayOfWeek​

도입 버전: v23.5

날짜 또는 날짜-시간 값을 다음 토요일 또는 일요일로 올림합니다.

참고

반환 타입은 enable_extended_results_for_datetime_functions 설정으로 구성할 수 있습니다.

구문

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

인수

  • datetime — 변환할 날짜 또는 날짜와 시간입니다. Date 또는 DateTime 또는 Date32 또는 DateTime64
  • mode — toWeek() FUNCTION에서 설명된 대로 주의 첫 번째 요일을 결정합니다. 기본값은 0입니다. UInt8
  • timezone — 선택 사항입니다. 변환에 사용할 시간대입니다. 지정하지 않으면 서버의 시간대를 사용합니다. String

반환 값

지정된 mode에 따라 주어진 날짜와 같거나 이후인 날짜 중 가장 가까운 토요일 또는 일요일의 날짜를 반환합니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

예시

가장 가까운 토요일 또는 일요일로 올림

SELECT
    toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')), /* a Friday */
    toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* a Friday */
    toLastDayOfWeek(toDate('2023-04-23')), /* a Sunday */
    toLastDayOfWeek(toDate('2023-04-23'), 1) /* a Sunday */
FORMAT Vertical

Row 1:
──────
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')):      2023-04-23
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1):   2023-04-22
toLastDayOfWeek(toDate('2023-04-23')):                   2023-04-23
toLastDayOfWeek(toDate('2023-04-23'), 1):                2023-04-23

toMillisecond​

도입: v24.2

DateTime 또는 DateTime64 값의 밀리초 부분(0-999)을 반환합니다.

구문

toMillisecond(datetime)

별칭: MILLISECOND

인수

  • datetime — 밀리초를 가져올 날짜 및 시간 값입니다. DateTime 또는 DateTime64

반환 값

datetime의 분(minute) 내 밀리초 값(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 │
└────────────────────────────────────────────────────────────┘

toMinute​

도입된 버전: v1.1

Date 또는 DateTime 값의 분(0-59) 부분을 반환합니다.

구문

toMinute(datetime)

별칭: MINUTE

인자

  • datetime — 분 값을 가져올 날짜 및 시간입니다. DateTime 또는 DateTime64

반환 값

datetime 값의 시각에서 분(0 - 59)을 반환합니다. UInt8

예시

사용 예시

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

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

toModifiedJulianDay​

도입 버전: v21.1

텍스트 형식 YYYY-MM-DD로 표현된 전진 그레고리력(Proleptic Gregorian calendar) 날짜를 수정 율리우스일(Modified Julian Day) Int32 숫자로 변환합니다. 이 함수는 0000-01-01부터 9999-12-31까지의 날짜를 지원합니다. 인수를 날짜로 파싱할 수 없거나 날짜가 유효하지 않은 경우 예외를 발생시킵니다.

구문

toModifiedJulianDay(date)

인수

반환 값

Modified Julian Day 번호를 반환합니다. Int32

예시

날짜를 Modified Julian Day로 변환

SELECT toModifiedJulianDay('2020-01-01')

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

toModifiedJulianDayOrNull​

도입 버전: v21.1

toModifiedJulianDay()와 유사하지만, 예외를 발생시키는 대신 NULL을 반환합니다.

구문

toModifiedJulianDayOrNull(date)

인수(Arguments)

반환 값

유효한 date 값이면 수정 율리우스일 수를 반환하고, 그렇지 않으면 null을 반환합니다. Nullable(Int32)

예시

널 처리를 포함하여 날짜를 수정 율리우스일 수로 변환

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

┌─toModifiedJu⋯020-01-01')─┐
│                    58849 │
└──────────────────────────┘
┌─toModifiedJu⋯000-00-00')─┐
│                     ᴺᵁᴸᴸ │
└──────────────────────────┘

toMonday​

도입 버전: v1.1

날짜나 날짜-시간 값을 같은 주의 월요일로 내림(round down)합니다. 날짜를 반환합니다.

참고

반환 형식은 enable_extended_results_for_datetime_functions 설정을 통해 구성할 수 있습니다.

구문

toMonday(value)

인수

  • value — 주(week)의 월요일 날짜로 내림할 대상 날짜 또는 날짜‑시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

반환 값

지정된 날짜 또는 날짜‑시간 값과 같은 주에 속하는 월요일 날짜를 반환합니다. Date

예시

주(week)의 월요일로 내림하기

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

┌─toMonday(toDateTime('2023-04-21 10:20:30'))─┬─toMonday(toDate('2023-04-24'))─┐
│                                  2023-04-17 │                     2023-04-24 │
└─────────────────────────────────────────────┴────────────────────────────────┘

toMonth​

도입: v1.1

Date 또는 DateTime 값에서 월(1-12)을 반환합니다.

구문

toMonth(datetime)

별칭(Aliases): MONTH

인수(Arguments)

반환 값(Returned value)

지정된 날짜/시간 값의 월을 반환합니다. 반환 타입은 UInt8입니다.

예시(Examples)

사용 예시(Usage example)

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

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

toMonthNumSinceEpoch​

도입 버전: v25.3

1970년 이후 경과한 개월 수를 반환합니다.

구문

toMonthNumSinceEpoch(date)

인자

반환 값

양의 정수 값입니다.

예시

예시

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

657

toQuarter​

도입 버전: v1.1

지정된 Date 또는 DateTime 값에 대해 연도의 분기(1-4)를 반환합니다.

구문

toQuarter(datetime)

별칭(Aliases): QUARTER

인수(Arguments)

  • datetime — 연도의 분기를 계산할 기준이 되는 날짜 또는 날짜·시간입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

반환 값(Returned value)

지정된 날짜/시간이 속한 연도의 분기를 반환합니다. UInt8

예시(Examples)

사용 예시(Usage example)

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

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

toRelativeDayNum​

도입 버전: v1.1

날짜 또는 날짜 시간 값을 과거의 특정 고정 시점으로부터 경과한 일 수로 변환합니다. 그 특정 시점은 구현 세부 사항에 해당하므로, 이 FUNCTION은 단독으로 사용하도록 설계되지 않았습니다. 이 FUNCTION의 주요 목적은 두 날짜 또는 날짜 시간 값 사이의 일 수 차이를 계산하는 것입니다. 예: toRelativeDayNum(dt1) - toRelativeDayNum(dt2).

구문

toRelativeDayNum(date)

인수

반환 값

과거의 고정 기준 시점으로부터 경과한 일 수를 반환합니다. UInt32

예제

상대적인 일 번호 가져오기

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

┌─minus(toRela⋯3-01-01')))─┐
│                       90 │
└──────────────────────────┘

toRelativeHourNum​

도입 버전: v1.1

날짜 또는 시간 정보를 포함한 날짜를 과거의 특정 고정 시점으로부터 경과한 시간(시간 단위) 수로 변환합니다. 정확한 기준 시점은 구현 세부 사항이므로, 이 함수는 단독으로 사용하도록 설계되지 않았습니다. 함수의 주된 목적은 두 날짜 또는 시간 정보를 포함한 날짜 사이의 시간(시간 단위) 차이를 계산하는 것입니다. 예를 들어 toRelativeHourNum(dt1) - toRelativeHourNum(dt2)와 같이 사용할 수 있습니다.

구문

toRelativeHourNum(date)

인수

반환 값

과거의 고정 기준 시점으로부터의 시간(시 단위) 수를 반환합니다. UInt32

예시

상대적인 시(hour) 번호 가져오기

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

┌─hours_difference─┐
│               12 │
└──────────────────┘

toRelativeMinuteNum​

도입된 버전: v1.1

날짜 또는 시간 정보를 포함한 날짜를 과거의 특정 고정 시점으로부터 경과한 분 수로 변환합니다. 해당 기준 시각은 구현 세부 사항이므로, 이 FUNCTION은 단독으로 사용하기 위한 것이 아닙니다. 이 FUNCTION의 주요 목적은 두 개의 날짜 또는 시간 정보를 포함한 날짜 사이의 분 단위 차이를 계산하는 것입니다. 예: toRelativeMinuteNum(dt1) - toRelativeMinuteNum(dt2).

구문

toRelativeMinuteNum(date)

인수

반환 값

고정된 과거 기준점으로부터 경과한 분(minute) 수를 반환합니다. 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​

도입 버전: v1.1

날짜 또는 날짜-시간 값을 과거의 특정 고정 시점 이후 경과한 개월 수로 변환합니다. 이때의 정확한 시점은 구현 세부 내용에 속하므로, 이 함수는 단독 사용을 위한 것이 아닙니다. 함수의 주된 목적은 두 날짜 또는 날짜-시간 값 사이의 개월 수 차이를 계산하는 것이며, 예를 들어 toRelativeMonthNum(dt1) - toRelativeMonthNum(dt2)와 같습니다.

구문

toRelativeMonthNum(date)

인수

반환 값

과거의 고정 기준점으로부터 경과한 개월 수를 반환합니다. UInt32

예시

상대적인 월 번호 구하기

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

┌─months_difference─┐
│                 3 │
└───────────────────┘

toRelativeQuarterNum​

도입 버전: v1.1

날짜 또는 시간 정보를 포함한 날짜를 과거의 특정 고정 시점부터 경과한 분기 수로 변환합니다. 정확한 기준 시점은 구현 세부 정보이므로, 이 함수는 단독 사용을 염두에 둔 함수가 아닙니다. 함수의 주요 목적은 두 날짜 또는 시간 정보를 포함한 날짜 사이의 분기 차이를 계산하는 것입니다. 예: 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​

도입 버전: v1.1

날짜 또는 시간 정보를 포함한 날짜를 과거의 특정 고정 시점 이후 경과한 초(second) 수로 변환합니다. 이 시점의 정확한 값은 구현 세부사항에 해당하므로, 이 FUNCTION은 단독으로 사용하는 용도로는 제공되지 않습니다. 이 FUNCTION의 주요 목적은 두 날짜 또는 시간 정보를 포함한 날짜 사이의 초 단위 차이를 계산하는 것입니다. 예: toRelativeSecondNum(dt1) - toRelativeSecondNum(dt2).

구문

toRelativeSecondNum(date)

인수(Arguments)

반환값(Returned value)

과거의 고정 기준 시점으로부터 경과한 초 단위를 반환합니다. UInt32

예시(Examples)

상대적인 초 값 가져오기

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

┌─seconds_difference─┐
│                 60 │
└────────────────────┘

toRelativeWeekNum​

도입 버전: v1.1

날짜 또는 시간 정보를 포함한 날짜를 과거의 고정된 기준 시점으로부터 경과한 주 수로 변환합니다. 정확한 기준 시점은 구현상의 세부 사항이므로, 이 FUNCTION은 단독으로 사용하기 위한 것이 아닙니다. 이 FUNCTION의 주요 목적은 두 날짜 또는 시간 정보를 포함한 날짜 사이의 주 단위 차이를 계산하는 것입니다. 예: toRelativeWeekNum(dt1) - toRelativeWeekNum(dt2).

구문

toRelativeWeekNum(date)

인자

반환 값

과거의 고정 기준 시점으로부터의 주(week) 수를 반환합니다. UInt32

예시

상대적인 주 번호 구하기

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

┌─weeks_difference─┐
│                1 │
└──────────────────┘

toRelativeYearNum​

도입 버전: v1.1

날짜 또는 시간 값을 포함한 날짜를 과거의 특정 고정된 시점으로부터 경과한 연수로 변환합니다. 정확한 기준 시점은 구현 세부 사항에 해당하므로, 이 함수는 단독으로 사용하도록 설계되지 않았습니다. 이 함수의 주된 목적은 두 날짜 또는 시간 값을 포함한 날짜 사이의 연수 차이를 계산하는 것이며, 예를 들면 toRelativeYearNum(dt1) - toRelativeYearNum(dt2)와 같이 사용합니다.

구문

toRelativeYearNum(date)

인자

반환 값

과거의 고정 기준점으로부터의 연도 수를 반환합니다. UInt16

예시

상대 연도 번호 가져오기

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

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

toSecond​

도입 버전: v1.1

DateTime 또는 DateTime64 값의 초(0-59) 부분을 반환합니다.

구문

toSecond(datetime)

별칭(Aliases): SECOND

인자(Arguments)

반환 값(Returned value)

datetime이 속한 분의 초 값(0 - 59)을 반환합니다. UInt8

예시(Examples)

사용 예시(Usage example)

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

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

toStartOfDay​

도입: v1.1

시간이 포함된 날짜를 해당 날짜의 시작 시각으로 내림합니다.

참고

enable_extended_results_for_datetime_functions 설정을 통해 반환 타입을 구성할 수 있습니다.

구문

toStartOfDay(datetime)

인수

  • datetime — 내림 반올림할 날짜 또는 날짜‑시간입니다. Date 또는 DateTime

반환 값

해당 일의 시작 시각으로 내림 반올림된 날짜‑시간을 반환합니다. Date 또는 DateTime 또는 Date32 또는 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​

도입 버전: v1.1

날짜와 시간을 15분 단위 구간의 시작 시각으로 내림합니다.

참고

반환 유형은 enable_extended_results_for_datetime_functions 설정을 통해 구성할 수 있습니다.

구문

toStartOfFifteenMinutes(datetime)

인수(Arguments)

  • datetime — 반올림할 날짜 또는 날짜와 시간입니다. DateTime 또는 DateTime64

반환 값(Returned value)

가장 가까운 15분 구간의 시작 시각으로 반올림된 날짜와 시간을 반환합니다. DateTime 또는 DateTime64

예시(Examples)

예시(Example)

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​

도입된 버전: v22.6

날짜와 시간을 바로 이전 5분 구간의 시작 시점으로 내림합니다.

참고

반환 타입은 enable_extended_results_for_datetime_functions 설정을 통해 구성할 수 있습니다.

구문

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

toStartOfHour​

도입 버전: v1.1

날짜와 시간을 해당 시(hour)의 시작 시각(정각)으로 내립니다.

참고

반환 타입은 enable_extended_results_for_datetime_functions을(를) 설정하여 변경할 수 있습니다.

구문

toStartOfHour(datetime)

인자

반환 값

해당 시각이 속한 시(hour)의 시작 시점으로 시간을 내림 처리한 날짜와 시간을 반환합니다. DateTime 또는 DateTime64

예시

시간 단위의 시작 시점으로 내림 처리

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

┌─────────────────res─┬─toTypeName(res)─┐
│ 2023-04-21 10:00:00 │ DateTime        │
└─────────────────────┴─────────────────┘

toStartOfISOYear​

도입 버전: v1.1

날짜 또는 날짜-시간 값을 ISO 연도의 첫째 날로 내림합니다. ISO 연도는 일반 연도와 다를 수 있습니다. 자세한 내용은 ISO week date를 참고하십시오.

참고

반환 타입은 enable_extended_results_for_datetime_functions 설정으로 변경할 수 있습니다.

구문

toStartOfISOYear(value)

인수

  • value — ISO 연도의 첫째 날로 내림(round down)할 날짜 또는 시간 포함 날짜입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

반환 값

지정된 날짜 또는 시간 포함 날짜에 대해 해당 ISO 연도의 첫째 날을 반환합니다. Date

예시

ISO 연도의 첫째 날로 내림

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

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

toStartOfInterval​

도입 버전: v20.1

이 함수는 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)와 동일한 값을 반환합니다.

계산은 특정 시점을 기준으로 수행됩니다:

IntervalStart
YEARyear 0
QUARTER1900 Q1
MONTH1900 January
WEEK1970, 1st week (01-05)
DAY1970-01-01
HOUR(*)
MINUTE1970-01-01 00:00:00
SECOND1970-01-01 00:00:00
MILLISECOND1970-01-01 00:00:00
MICROSECOND1970-01-01 00:00:00
NANOSECOND1970-01-01 00:00:00
(*) hour intervals are special: the calculation is always performed relative to 00:00:00 (midnight) of the current day. As a result, only
hour values between 1 and 23 are useful.

단위 WEEK이 지정되면, toStartOfInterval은 주가 월요일에 시작된다고 가정합니다. 이 동작은 기본적으로 주가 일요일에 시작되는 함수 toStartOfWeek의 동작과 다르다는 점에 유의하십시오.

두 번째 오버로드는 TimescaleDB의 time_bucket() 함수와 PostgreSQL의 date_bin() 함수를 각각 에뮬레이션합니다.

구문

toStartOfInterval(value, INTERVAL x unit[, time_zone])
toStartOfInterval(value, INTERVAL x unit[, origin[, time_zone]])

별칭(Aliases): time_bucket, date_bin

인수(Arguments)

  • value — 내림(round down) 처리할 날짜 또는 날짜와 시간 값입니다. Date 또는 DateTime 또는 DateTime64
  • x — 구간 길이를 나타내는 숫자입니다. - unit — 구간 단위입니다: YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE, SECOND, MILLISECOND, MICROSECOND, NANOSECOND. - time_zone — 선택 사항입니다. 시간대 이름을 나타내는 문자열입니다. - origin — 선택 사항입니다. 계산의 기준이 되는 기준 시점(두 번째 오버로드에서만 사용)입니다.

반환 값(Returned value)

입력 값을 포함하는 구간의 시작 시점을 반환합니다. DateTime

예시(Examples)

기본 구간 반올림(Basic interval rounding)

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​

도입 버전: v22.6

날짜‑시간 값을 마이크로초 단위의 시작 시점으로 내림합니다.

구문

toStartOfMicrosecond(datetime[, timezone])

인수

  • datetime — 날짜와 시간. DateTime64
  • timezone — 선택 사항입니다. 반환 값에 사용할 시간대입니다. 지정하지 않으면 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​

도입 버전: v22.6

날짜와 시간을 밀리초 단위로 내림합니다.

구문

toStartOfMillisecond(datetime[, timezone])

인수

  • datetime — 날짜와 시간입니다. DateTime64
  • timezone — 선택 사항입니다. 반환 값에 사용할 시간대(timezone)입니다. 지정하지 않으면 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​

도입된 버전: v1.1

시간이 포함된 날짜를 해당 분의 시작 시각으로 내립니다.

참고

enable_extended_results_for_datetime_functions를 설정하여 반환 유형을 설정할 수 있습니다.

구문

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

toStartOfMonth​

도입: v1.1

날짜 또는 날짜·시간 값을 해당 월의 첫날로 내림(round down)합니다.

참고

반환 유형은 enable_extended_results_for_datetime_functions 설정을 통해 구성할 수 있습니다.

구문

toStartOfMonth(value)

인수

  • value — 해당 월의 첫째 날로 내림 처리할 날짜 또는 날짜와 시간입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

반환 값

지정된 날짜 또는 날짜와 시간 값에 대해 해당 월의 첫째 날을 반환합니다. Date

예시

해당 월의 첫째 날로 내림

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

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

toStartOfNanosecond​

도입 버전: v22.6

날짜와 시간을 나노초 단위의 시작 시점으로 내림합니다.

구문

toStartOfNanosecond(datetime[, timezone])

인자

  • datetime — 날짜와 시간. DateTime64
  • timezone — 선택 사항. 반환 값에 사용할 시간대입니다. 지정하지 않으면 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 │
└────────────────────────────────────────────┘

toStartOfQuarter​

도입 버전: v1.1

날짜 또는 날짜·시간 값을 해당 분기의 첫째 날로 내림 처리합니다. 분기의 첫째 날은 1월 1일, 4월 1일, 7월 1일, 10월 1일 중 하나입니다.

참고

반환 타입은 enable_extended_results_for_datetime_functions 설정을 통해 구성할 수 있습니다.

구문

toStartOfQuarter(value)

인수

  • value — 분기 첫째 날로 내림 처리할 날짜 또는 날짜와 시간입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

반환 값

지정된 날짜 또는 날짜와 시간에 대해 해당 분기의 첫째 날을 반환합니다. Date

예시

분기 첫째 날로 내림

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

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

toStartOfSecond​

도입 버전: v20.5

날짜와 시간을 해당 초의 시작 시각으로 내림(round down)합니다.

구문

toStartOfSecond(datetime[, timezone])

인수

  • datetime — 소수점 이하 초 단위를 잘라낼 날짜와 시간입니다. DateTime64
  • timezone — 선택 사항입니다. 반환 값에 사용할 시간대입니다. 지정하지 않으면 함수는 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 │
└─────────────────────────┘

시간대(timezone)를 사용하는 쿼리

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​

도입된 버전: v20.1

날짜와 시간을 가장 가까운 10분 구간의 시작 시점으로 내림합니다.

참고

반환 타입은 enable_extended_results_for_datetime_functions 설정으로 변경할 수 있습니다.

구문

toStartOfTenMinutes(datetime)

인수

반환 값

가장 가까운 10분 구간의 시작 시각으로 반올림한 시간 정보를 포함한 날짜 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​

도입 버전: v20.1

날짜 또는 날짜‑시간 값을 가장 가까운 일요일 또는 월요일의 시작 시각으로 내림합니다.

참고

반환 타입은 enable_extended_results_for_datetime_functions 설정으로 구성할 수 있습니다.

구문

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

인수

  • datetime — 변환할 일 또는 일시입니다. Date 또는 DateTime 또는 Date32 또는 DateTime64
  • mode — toWeek() FUNCTION에서 설명된 것처럼 한 주의 첫 번째 요일을 결정합니다. 기본값은 0입니다. UInt8
  • timezone — 변환에 사용할 시간대입니다. 지정하지 않으면 서버의 시간대를 사용합니다. String

반환 값

지정된 mode에 따라 주어진 날짜와 같거나 그 이전의 가장 가까운 일요일 또는 월요일의 날짜를 반환합니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

예시

가장 가까운 일요일 또는 월요일로 내림

SELECT
        toStartOfWeek(toDateTime('2023-04-21 10:20:30')), /* a Friday */
        toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* a Friday */
        toStartOfWeek(toDate('2023-04-24')), /* a Monday */
        toStartOfWeek(toDate('2023-04-24'), 1) /* a Monday */
    FORMAT Vertical

Row 1:
    ──────
    toStartOfWeek(toDateTime('2023-04-21 10:20:30')):      2023-04-17
    toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1):   2023-04-17
    toStartOfWeek(toDate('2023-04-24')):                   2023-04-24
    toStartOfWeek(toDate('2023-04-24'), 1):                2023-04-24

toStartOfYear​

도입 버전: v1.1

날짜 또는 시간 정보를 포함한 날짜를 해당 연도의 첫째 날로 내립니다. 날짜는 Date 객체로 반환됩니다.

참고

반환 타입은 enable_extended_results_for_datetime_functions 설정을 통해 구성할 수 있습니다.

구문

toStartOfYear(value)

인수

반환 값

지정된 날짜/시간에 대해 해당 연도의 첫날을 반환합니다. Date

예시

연도의 첫날로 내림 처리하기

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

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

toTimeWithFixedDate​

도입 버전: v1.1

날짜 또는 날짜-시간 값에서 시간 구성 요소를 추출합니다. 반환 결과는 고정된 기준 시점으로부터의 오프셋이며, 현재 기준 시점은 1970-01-02입니다. 다만 정확한 기준 시점은 구현 세부 사항이므로 향후 변경될 수 있습니다.

따라서 toTime은 단독으로 사용하지 않는 것이 좋습니다. 이 함수의 주요 목적은 두 날짜 또는 날짜-시간 값 사이의 시간 차이를 계산하는 것입니다. 예: toTime(dt1) - toTime(dt2).

구문

toTime(date[, timezone])

인수

  • date — 시간을 계산할 기준이 되는 날짜. Date 또는 DateTime 또는 DateTime64
  • timezone — 선택적 인수입니다. 반환 값에 적용할 시간대. String

반환 값

날짜 또는 날짜와 시간에서 시간 구성 요소를, 고정된 시점(현재 1970-01-02로 선택됨)에 대한 오프셋 형태로 반환합니다. DateTime

예제

두 날짜 사이의 시간 차이 계산

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

┌─result─┬─toTypeName(result)─┐
│   3600 │ Int32              │
└────────┴────────────────────┘

toTimezone​

도입된 버전: v1.1

DateTime 또는 DateTime64 값을 지정한 시간대(time zone)로 변환합니다. 데이터의 내부 값(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​

도입 버전: v23.8

날짜 또는 날짜/시간 값을 특정 시간대에서 UTC 시간대의 타임스탬프로 변환합니다. 이 함수는 주로 Apache Spark 및 유사한 프레임워크와의 호환성을 위해 포함되어 있습니다.

구문

toUTCTimestamp(datetime, time_zone)

별칭: to_utc_timestamp

인수

  • datetime — 날짜(Date) 또는 날짜와 시간을 포함한 타입의 상수 값 또는 표현식입니다. DateTime 또는 DateTime64
  • time_zone — 시간대를 나타내는 String 타입 상수 값 또는 표현식입니다. 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 │
└─────────────────────────────────────────────────────────┘

toUnixTimestamp​

도입: v1.1

String, Date, 또는 DateTime을 Unix 타임스탬프(1970-01-01 00:00:00 UTC 이후 경과한 초 수)를 나타내는 UInt32 값으로 변환합니다.

구문

toUnixTimestamp(date[, timezone])

인자

  • date — 변환할 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64 또는 String
  • timezone — 선택 사항입니다. 변환에 사용할 시간대입니다. 지정하지 않으면 서버의 시간대가 사용됩니다. 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;

Row 1:
──────
dt_str:          2017-11-05 08:07:47
from_str:        1509869267
from_str_tokyo:  1509836867
from_datetime:   1509869267
from_datetime64: 1509869267
from_date:       1509840000
from_date32:     1509840000

toWeek​

도입 버전: v20.1

이 함수는 date 또는 datetime 값에 대한 주(week) 번호를 반환합니다. toWeek()의 두 개의 인자를 받는 형식에서는 주의 시작 요일을 일요일 또는 월요일로 지정할 수 있으며, 반환 값의 범위를 0에서 53까지로 할지, 1에서 53까지로 할지 지정할 수 있습니다.

toISOWeek()은 toWeek(date,3)와 동일한 동작을 하는 호환성 함수입니다.

다음 표는 mode 인자가 어떻게 동작하는지 설명합니다.

ModeFirst day of weekRangeWeek 1 is the first week ...
0Sunday0-53해당 연도에 일요일이 포함된 주
1Monday0-53해당 연도에 4일 이상이 포함된 주
2Sunday1-53해당 연도에 일요일이 포함된 주
3Monday1-53해당 연도에 4일 이상이 포함된 주
4Sunday0-53해당 연도에 4일 이상이 포함된 주
5Monday0-53해당 연도에 월요일이 포함된 주
6Sunday1-53해당 연도에 4일 이상이 포함된 주
7Monday1-53해당 연도에 월요일이 포함된 주
8Sunday1-531월 1일을 포함하는 주
9Monday1-531월 1일을 포함하는 주

의미가 "해당 연도에 4일 이상이 포함된 주"인 mode 값의 경우, 주 번호는 ISO 8601:1988에 따라 매겨집니다.

  • 1월 1일을 포함하는 주가 새해에 4일 이상을 포함하면, 그 주가 1주차입니다.
  • 그렇지 않으면, 그 주는 이전 해의 마지막 주가 되며, 그다음 주가 1주차입니다.

의미가 "1월 1일을 포함하는 주"인 mode 값의 경우, 1월 1일을 포함하는 주가 1주차가 됩니다. 해당 주에 새해 날짜가 며칠 포함되는지는 중요하지 않으며, 단 하루만 포함되어 있어도 마찬가지입니다. 즉, 12월의 마지막 주가 다음 해의 1월 1일을 포함하면, 그 주는 다음 해의 1주차가 됩니다.

첫 번째 인자는 parseDateTime64BestEffort()가 지원하는 형식의 String으로도 지정할 수 있습니다. 문자열 인자 지원은 특정 서드 파티 도구에서 기대하는 MySQL과의 호환성을 위한 이유로만 존재합니다. 문자열 인자 지원은 향후 새로운 MySQL 호환성 SETTINGS 설정에 따라 달라질 수 있으며, 일반적으로 문자열 파싱 속도가 느리기 때문에 사용하지 않을 것을 권장합니다.

구문

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

별칭: week

인수

  • datetime — 주 번호를 계산할 날짜 또는 시간 포함 날짜입니다. Date 또는 DateTime
  • mode — 선택 사항입니다. 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 │
└────────────┴───────┴───────┴───────┘

toYYYYMM​

도입 버전: v1.1

날짜 또는 날짜·시간 값을 연도와 월(YYYY * 100 + MM) 정보를 담은 UInt32 숫자로 변환합니다. 두 번째 인수로 선택적인 시간대를 받을 수 있습니다. 지정하는 경우 시간대는 문자열 상수여야 합니다.

이 FUNCTION은 YYYYMMDDToDate() FUNCTION과 반대 동작을 합니다.

구문

toYYYYMM(datetime[, timezone])

인자

  • datetime — 변환할 날짜 또는 날짜와 시간입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • timezone — 선택 사항입니다. 변환에 사용할 타임존입니다. 지정하는 경우 타임존은 문자열 상수여야 합니다. String

반환 값

연도와 월 숫자를 포함하는 UInt32 숫자(YYYY * 100 + MM)를 반환합니다. UInt32

예시

현재 날짜를 YYYYMM 형식으로 변환

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

┌─toYYYYMM(now(), 'US/Eastern')─┐
│                        202303 │
└───────────────────────────────┘

toYYYYMMDD​

도입 버전: v1.1

날짜 또는 시간 정보를 포함한 날짜를 연, 월, 일을 조합한 UInt32 숫자(YYYY * 10000 + MM * 100 + DD)로 변환합니다. 두 번째 선택적 인자로 시간대를 받을 수 있습니다. 이 인자를 지정하는 경우, 시간대는 문자열 상수여야 합니다.

구문

toYYYYMMDD(datetime[, timezone])

인수(Arguments)

  • datetime — 변환할 날짜 또는 날짜·시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • timezone — 선택적 인수입니다. 변환에 사용할 타임존입니다. 지정하는 경우, 타임존은 문자열 상수여야 합니다. String

반환 값(Returned value)

연, 월, 일을 포함하는 UInt32 정수 값을 반환합니다(YYYY * 10000 + MM * 100 + DD). UInt32

예시(Examples)

현재 날짜를 YYYYMMDD 형식으로 변환

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

┌─toYYYYMMDD(now(), 'US/Eastern')─┐
│                        20230302 │
└─────────────────────────────────┘

toYYYYMMDDhhmmss​

도입 버전: v1.1

날짜 또는 날짜와 시간을 연, 월, 일, 시, 분, 초를 포함하는 UInt64 숫자로 변환합니다(YYYY * 10000000000 + MM * 100000000 + DD * 1000000 + hh * 10000 + mm * 100 + ss). 두 번째 인수로 선택적인 타임존을 지정할 수 있습니다. 지정하는 경우 타임존은 문자열 상수여야 합니다.

구문

toYYYYMMDDhhmmss(datetime[, timezone])

인자

  • datetime — 변환할 날짜 또는 날짜와 시간입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • timezone — 선택 사항입니다. 변환에 사용할 시간대입니다. 지정한 경우 시간대는 문자열 상수여야 합니다. 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 │
└───────────────────────────────────────┘

toYear​

도입: v1.1

Date 또는 DateTime 값에서 연도(서기)를 반환합니다.

구문

toYear(datetime)

별칭: YEAR

인수

  • datetime — 연도를 추출할 날짜 또는 날짜와 시간이 포함된 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

반환 값

지정된 Date 또는 DateTime 값의 연도를 반환합니다. UInt16

예시

사용 예시

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

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

toYearNumSinceEpoch​

도입된 버전: v25.3

1970년 이후 경과한 연 수를 반환합니다.

구문

toYearNumSinceEpoch(date)

인자

반환값

양의 정수입니다.

예시

예제

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

54

toYearWeek​

도입된 버전: v20.1

날짜에 대해 연도와 주(week)를 반환합니다. 결과에 포함되는 연도는, 연도의 첫 주와 마지막 주의 경우 인자로 전달된 날짜의 연도와 다를 수 있습니다.

mode 인자는 toWeek()의 mode 인자와 동일하게 동작합니다.

경고: toYearWeek()가 반환하는 주 번호는 toWeek()가 반환하는 값과 다를 수 있습니다. toWeek()는 항상 주어진 연도의 맥락에서 주 번호를 반환하며, toWeek()가 0을 반환하는 경우 toYearWeek()는 이전 해의 마지막 주에 해당하는 값을 반환합니다. 아래 예시의 prev_yearWeek를 참고하십시오.

첫 번째 인자는 parseDateTime64BestEffort()가 지원하는 형식의 String으로도 지정할 수 있습니다. 문자열 인자에 대한 지원은 특정 서드파티 도구에서 기대하는 MySQL과의 호환성을 위한 것입니다. 향후 문자열 인자 지원이 새로운 MySQL 호환성 설정에 따라 달라질 수 있고, 일반적으로 문자열 파싱은 느리므로 사용하지 않는 것이 좋습니다.

문법

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

별칭: yearweek

인수

  • datetime — 연도와 주 번호를 가져올 날짜 또는 날짜와 시간 값입니다. Date 또는 DateTime
  • mode — 선택 사항입니다. 0부터 9까지의 mode는 주의 첫 요일과 주 번호 범위를 결정합니다. 기본값은 0입니다.
  • timezone — 선택 사항입니다. 시간대입니다. String

반환 값

연도와 주 번호를 결합한 정수 값을 반환합니다. UInt32

예시

서로 다른 mode에서 연도-주 조합 가져오기

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 │
└────────────┴───────────┴───────────┴───────────┴───────────────┘

today​

도입: v1.1

쿼리 분석 시점의 현재 날짜를 반환합니다. toDate(now())와 동일합니다.

구문

today()

별칭: 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 │
└────────────┴────────────┴──────────────┘

yesterday​

도입 버전: v1.1

인수가 없으며, 쿼리 분석 시점 중 하나에서 어제 날짜를 반환합니다.

구문

yesterday()

인수

  • 없음.

반환값

어제 날짜를 반환합니다. Date

예시

어제 날짜 가져오기

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

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