Skip to content
ClickHouse Docs
ClickHouse DocsClickHouse Docs
49.6kGet Started

날짜 및 시간 작업 함수

View as MarkdownEdit this pageReport an issueSet up docs MCP

이 섹션의 대부분의 함수는 선택적으로 시간대 인수를 받습니다. 예를 들어 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.0

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

이 함수는 now('UTC')와 동일한 결과를 반환합니다. MySQL 지원용으로만 추가되었습니다. 권장되는 사용 방식은 now입니다.

구문

UTCTimestamp()

별칭: UTC_timestamp

인수

  • 없음.

반환 값

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

예시

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

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

YYYYMMDDToDate

도입 버전: v23.9.0

연도, 월, 일 숫자가 포함된 숫자를 Date로 변환합니다. 이 함수는 toYYYYMMDD() 함수의 반대입니다. 입력이 유효한 Date 값을 나타내지 않으면 출력은 정의되지 않습니다.

구문

YYYYMMDDToDate(YYYYMMDD)

인수

반환 값

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

예시

예시

SELECT YYYYMMDDToDate(20230911);
┌─YYYYMMDDToDate(20230911)─┐
│               2023-09-11 │
└──────────────────────────┘

YYYYMMDDToDate32

도입 버전: v23.9.0

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

구문

YYYYMMDDToDate32(YYYYMMDD)

인수

반환 값

지정된 인수로부터 Date32 값을 반환합니다 Date32

예시

예시

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

YYYYMMDDhhmmssToDateTime

도입 버전: v23.9.0

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

구문

YYYYMMDDhhmmssToDateTime(YYYYMMDDhhmmss[, timezone])

인수

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

반환 값

주어진 인수로 DateTime 값을 반환합니다 DateTime

예시

예시

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

YYYYMMDDhhmmssToDateTime64

도입 버전: v23.9.0

연, 월, 일, 시, 분, 초를 포함하는 숫자를 DateTime64로 변환합니다. 이 함수는 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');
┌─YYYYMMDDhhmmssToDateTime64(20230911131415, 3, 'Asia/Istanbul')─┐
│                                        2023-09-11 13:14:15.000 │
└────────────────────────────────────────────────────────────────┘

addDate

도입 버전: v23.9.0

지정된 날짜, 시간이 포함된 날짜 또는 문자열로 인코딩된 날짜/시간 값에 시간 인터벌을 더합니다. 덧셈 결과가 데이터 타입의 범위를 벗어나면 결과는 정의되지 않습니다.

구문

addDate(datetime, interval)

인수

반환 값

datetime에 interval을 더해 얻은 날짜 또는 시간 정보가 포함된 날짜를 반환합니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

예시

날짜에 인터벌 추가

SELECT addDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
┌─addDate(toDate('2018-01-01'), toIntervalYear(3))─┐
│                                       2021-01-01 │
└──────────────────────────────────────────────────┘

addDays

도입 버전: v1.1.0

지정한 일 수를 날짜, 날짜 및 시간, 또는 문자열로 표현된 날짜나 날짜 및 시간 값에 더합니다.

구문

addDays(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
    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('1998-06-16', 'Date'), toIntervalDay(10))─┐
│                                          1998-06-26 │
└─────────────────────────────────────────────────────┘

addHours

도입 버전: v1.1.0

지정한 수의 시간을 날짜, 시간이 포함된 날짜 또는 문자열로 인코딩된 날짜나 시간이 포함된 날짜에 더합니다.

구문

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('1998-06-16', 'Date'), toIntervalHour(10))─┐
│                                  1998-06-16 10:00:00 │
└──────────────────────────────────────────────────────┘

addInterval

도입 버전: v22.11.0

하나의 인터벌을 다른 인터벌 또는 인터벌의 튜플에 더합니다.

구문

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.0

날짜와 시간이 포함된 값 또는 문자열로 인코딩된 날짜-시간 값에 지정한 개수의 마이크로초를 추가합니다.

구문

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('1998-06-16', 'DateTime'), toIntervalMicrosecond(10))─┐
│                                      1998-06-16 00:00:00.000010 │
└─────────────────────────────────────────────────────────────────┘

addMilliseconds

도입 버전: v22.6.0

날짜와 시간이 포함된 값 또는 문자열로 인코딩된 날짜-시간 값에 지정한 밀리초 수를 추가합니다.

구문

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('1998-06-16', 'DateTime'), toIntervalMillisecond(10))─┐
│                                         1998-06-16 00:00:00.010 │
└─────────────────────────────────────────────────────────────────┘

addMinutes

도입 버전: v1.1.0

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

구문

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('1998-06-16', 'Date'), toIntervalMinute(10))─┐
│                                    1998-06-16 00:10:00 │
└────────────────────────────────────────────────────────┘

addMonths

도입 버전: v1.1.0

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

구문

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('1998-06-16', 'Date'), toIntervalMonth(10))─┐
│                                            1999-04-16 │
└───────────────────────────────────────────────────────┘

addNanoseconds

도입 버전: v22.6.0

지정한 개수의 나노초를 시간이 포함된 날짜 값 또는 문자열로 인코딩된 날짜-시간 값에 더합니다.

구문

addNanoseconds(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
    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('1998-06-16', 'DateTime'), toIntervalNanosecond(1000))─┐
│                                    1998-06-16 00:00:00.000001000 │
└──────────────────────────────────────────────────────────────────┘

addQuarters

도입 버전: v20.1.0

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

구문

addQuarters(datetime, num)

인수

반환 값

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

예시

여러 날짜 타입에 분기 추가

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addQuarters(date, 1) AS add_quarters_with_date,
    addQuarters(date_time, 1) AS add_quarters_with_date_time,
    addQuarters(date_time_string, 1) AS add_quarters_with_date_time_string
┌─add_quarters_with_date─┬─add_quarters_with_date_time─┬─add_quarters_with_date_time_string─┐
│             2024-04-01 │         2024-04-01 00:00:00 │            2024-04-01 00:00:00.000 │
└────────────────────────┴─────────────────────────────┴────────────────────────────────────┘

대체 INTERVAL 구문 사용

SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 quarter)
┌─plus(CAST('1998-06-16', 'Date'), toIntervalQuarter(10))─┐
│                                              2000-12-16 │
└─────────────────────────────────────────────────────────┘

addSeconds

도입 버전: v1.1.0

날짜, 시간 정보가 포함된 날짜, 또는 문자열로 인코딩된 날짜나 시간 정보가 포함된 날짜에 지정된 초 수를 더합니다.

구문

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)
┌─plus(CAST('1998-06-16', 'Date'), toIntervalSecond(10))─┐
│                                    1998-06-16 00:00:10 │
└────────────────────────────────────────────────────────┘

addTupleOfIntervals

도입 버전: v22.11.0

날짜 또는 시간 정보가 포함된 날짜에 인터벌 튜플을 순차적으로 더합니다.

구문

addTupleOfIntervals(datetime, intervals)

인수

  • datetime — 인터벌을 더할 날짜 또는 시간이 포함된 날짜입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • intervals — datetime에 더할 인터벌로 구성된 Tuple입니다. Tuple(Interval)

반환 값

intervals가 추가된 date를 반환합니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

예시

날짜에 인터벌 Tuple 추가

WITH toDate('2018-01-01') AS date
SELECT addTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 MONTH, INTERVAL 1 YEAR))
┌─addTupleOfIntervals(date, (toIntervalDay(1), toIntervalMonth(1), toIntervalYear(1)))─┐
│                                                                           2019-02-02 │
└──────────────────────────────────────────────────────────────────────────────────────┘

addWeeks

도입 버전: v1.1.0

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

구문

addWeeks(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
    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('1998-06-16', 'Date'), toIntervalWeek(10))─┐
│                                           1998-08-25 │
└──────────────────────────────────────────────────────┘

addYears

도입 버전: v1.1.0

날짜, 시간 정보가 포함된 날짜 또는 문자열로 인코딩된 날짜나 시간 정보가 포함된 날짜에 지정한 수의 연도를 더합니다.

구문

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('1998-06-16', 'Date'), toIntervalYear(10))─┐
│                                           2008-06-16 │
└──────────────────────────────────────────────────────┘

age

도입 버전: v23.1.0

startdate와 enddate의 차이에서 지정된 단위 값을 반환합니다. 차이는 1나노초 정밀도로 계산됩니다.

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

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

구문

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

인수

  • unit — 결과를 표현할 인터벌 유형입니다.
단위 가능한 값
nanosecond nanosecond, nanoseconds, ns
microsecond microsecond, microseconds, us, u
millisecond millisecond, milliseconds, ms
second second, seconds, ss, s
minute minute, minutes, mi, n
hour hour, hours, hh, h
day day, days, dd, d
week week, weeks, wk, ww
month month, months, mm, m
quarter quarter, quarters, qq, q
year year, years, yyyy, yy
  • startdate — 뺄 값인 첫 번째 시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • enddate — 여기에서 빼는 대상인 두 번째 시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • timezone — 선택 사항입니다. 시간대 이름입니다. 지정하면 startdate와 enddate 모두에 적용됩니다. 지정하지 않으면 startdate와 enddate의 시간대가 사용됩니다. 두 값의 시간대가 같지 않으면 결과는 지정되지 않습니다. String

반환 값

unit으로 표현한 enddate와 startdate의 차이를 반환합니다. 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.0

date 또는 날짜-시간 값의 일 구성 요소를 변경합니다.

구문

changeDay(date_or_datetime, value)

인수

반환 값

date_or_datetime와 동일한 유형이며, 일(day) 값이 수정된 값을 반환합니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

예시

사용 예시

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

changeHour

도입 버전: v24.7.0

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

구문

changeHour(date_or_datetime, value)

인수

반환 값

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

예시

사용 예시

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

changeMinute

도입 버전: v24.7.0

date or date 날짜-시간 값의 분 구성 요소를 변경합니다.

구문

changeMinute(date_or_datetime, value)

인수

반환 값

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

예시

사용 예시

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

changeMonth

도입 버전: v24.7.0

날짜 또는 날짜-시간 값의 월 구성 요소를 변경합니다.

구문

changeMonth(date_or_datetime, value)

인수

반환 값

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

예시

사용 예시

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

changeSecond

도입 버전: v24.7.0

날짜 또는 날짜-시간 값의 초 구성 요소를 변경합니다.

구문

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.0

date 또는 날짜-시간 값의 연도 구성 요소를 변경합니다.

구문

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.0

지정한 unit를 기준으로 startdate와 enddate 사이에서 경계를 몇 번 지났는지 반환합니다. 차이는 상대 단위를 사용해 계산됩니다. 예를 들어 2021-12-29와 2022-01-01 사이의 차이는 unit이 day이면 3일 (toRelativeDayNum 참조), unit이 month이면 1개월 (toRelativeMonthNum 참조), unit이 year이면 1년입니다 (toRelativeYearNum 참조).

unit으로 week를 지정하면 dateDiff는 주가 월요일에 시작한다고 가정합니다. 이 동작은 기본적으로 주가 일요일에 시작하는 toWeek() 함수와 다르다는 점에 유의하십시오.

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

구문

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

별칭: timestampDiff, TIMESTAMP_DIFF, DATE_DIFF, date_diff, timestamp_diff

인수

  • unit — 결과를 표현할 인터벌 유형입니다.
Unit 가능한 값
nanosecond nanosecond, nanoseconds, ns
microsecond microsecond, microseconds, us, u
millisecond millisecond, milliseconds, ms
second second, seconds, ss, s
minute minute, minutes, mi, n
hour hour, hours, hh, h
day day, days, dd, d
week week, weeks, wk, ww
month month, months, mm, m
quarter quarter, quarters, qq, q
year year, years, yyyy, yy
  • startdate — 빼는 값인 첫 번째 시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • enddate — 여기에서 빼기를 수행하는 두 번째 시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • timezone — 선택 사항입니다. 시간대 이름입니다. 지정하면 startdate와 enddate 모두에 적용됩니다. 지정하지 않으면 startdate와 enddate의 시간대가 사용됩니다. 두 값의 시간대가 서로 다르면 결과는 정의되지 않습니다. String

반환 값

unit로 표현한 enddate와 startdate의 차이를 반환합니다. 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.0

날짜의 지정된 부분을 반환합니다.

가능한 값:

  • '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.0

날짜 및 시간 값을 지정된 날짜 단위로 절삭합니다.

구문

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 Argument datetime Argument Return Type
Year, Quarter, Month, Week Date32 or DateTime64 or Date or DateTime Date32 or Date
Day, Hour, Minute, Second Date32, DateTime64, Date, or DateTime DateTime64 or DateTime
Millisecond, Microsecond, Any DateTime64
Nanosecond with scale 3, 6, or 9

예시

시간대 없이 잘라내기

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

지정한 시간대 기준으로 자르기

SELECT now(), dateTrunc('hour', now(), 'Asia/Istanbul');
┌───────────────now()─┬─dateTrunc('hour', now(), 'Asia/Istanbul')──┐
│ 2020-09-28 10:46:26 │                        2020-09-28 13:00:00 │
└─────────────────────┴────────────────────────────────────────────┘

formatDateTime

도입 버전: v1.1.0

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

formatDateTime은 MySQL datetime 포맷 스타일을 사용합니다. 자세한 내용은 MySQL 문서를 참조하십시오.

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

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

대체 필드:

자리표시자 설명 예시
%a 요일 이름의 약어 (Mon-Sun) Mon
%b 월 이름의 약어 (Jan-Dec) Jan
%c 정수로 표현한 월 (01-12) 01
%C 연도를 100으로 나눈 뒤 정수로 자른 값 (00-99) 20
%d 0으로 채운 일 (01-31) 02
%D 짧은 MM/DD/YY 날짜, %m/%d/%y와 동일 01/02/18
%e 공백으로 채운 일 (1-31) 2
%f 초의 소수 부분 123456
%F 짧은 YYYY-MM-DD 날짜, %Y-%m-%d와 동일 2018-01-02
%g ISO 8601에 맞춘 두 자리 연도 형식 18
%G ISO week number용 네 자리 연도 형식 2018
%h 12시간 형식의 시 (01-12) 09
%H 24시간 형식의 시 (00-23) 22
%i 분 (00-59) 33
%I 12시간 형식의 시 (01-12) 10
%j 연중 일수 (001-366) 002
%k 24시간 형식의 시 (00-23) 14
%l 12시간 형식의 시 (01-12) 09
%m 정수로 표현한 월 (01-12) 01
%M 월 이름 전체 (January-December) January
%n 줄바꿈 문자
%p AM 또는 PM 표기 PM
%Q 분기 (1-4) 1
%r 12시간 HH:MM AM/PM 시간, %h:%i %p와 동일 10:30 PM
%R 24시간 HH:MM 시간, %H:%i와 동일 22:33
%s 초 (00-59) 44
%S 초 (00-59) 44
%t 가로 탭 문자
%T ISO 8601 시간 포맷 (HH:MM:SS), %H:%i:%S와 동일 22:33:44
%u 월요일을 1로 하는 숫자 형식의 ISO 8601 요일 (1-7) 2
%V ISO 8601 week number (01-53) 01
%w 일요일을 0으로 하는 정수 형식의 요일 (0-6) 2
%W 요일 이름 전체 (Monday-Sunday) Monday
%y 연도의 마지막 두 자리 (00-99) 18
%Y 연도 2018
%z UTC로부터의 시간 오프셋, +HHMM 또는 -HHMM 형식 -0500
%% % 기호 %
  • ClickHouse v23.4 이전 버전에서는 포맷된 값이 Date, Date32, DateTime(소수 초가 없음)이거나 정밀도가 0인 DateTime64인 경우 %f가 단일 0(0)을 출력합니다.
  • ClickHouse v25.1 이전 버전에서는 %f가 고정 6자리가 아니라 DateTime64의 scale에 지정된 자릿수만큼 출력됩니다.
  • ClickHouse v23.4 이전 버전에서는 %M이 월 이름 전체(January-December) 대신 분(00-59)을 출력합니다.

구문

formatDateTime(datetime, format[, timezone])

별칭: DATE_FORMAT

인수

  • 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')─┐
│ 123456                                                              │
└─────────────────────────────────────────────────────────────────────┘

시간대가 포함된 포맷

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.0

formatDateTime와 비슷하지만, MySQL 스타일 대신 Joda 스타일로 날짜-시간 값을 포맷합니다. 자세한 내용은 Joda Time documentation을 참조하십시오.

이 함수의 반대 연산은 parseDateTimeInJodaSyntax입니다.

대체 필드를 사용하면 결과 문자열의 패턴을 정의할 수 있습니다.

대체 필드:

Placeholder Description Presentation Examples
G 연호 텍스트 AD
C 연호의 세기 (>=0) 숫자 20
Y 연호의 연도 (>=0) 연도 1996
x 주 기준 연도(아직 지원되지 않음) 연도 1996
w 주 기준 연도의 주(아직 지원되지 않음) 숫자 27
e 요일 숫자 2
E 요일 텍스트 Tuesday; Tue
y 연도 연도 1996
D 연중 날짜 숫자 189
M 연중 월 월 July; Jul; 07
d 월의 날짜 숫자 10
a 오전/오후 텍스트 PM
K 반일 기준 시(0~11) 숫자 0
h 반일 기준 시각(1~12) 숫자 12
H 하루 기준 시(0~23) 숫자 0
k 하루 기준 시각(1~24) 숫자 24
m 시의 분 숫자 30
s 분의 초 숫자 55
S 초의 소수 부분 숫자 978
z 시간대 텍스트 Eastern Standard Time; EST
Z 시간대 오프셋 시간대 -0800; -0812
' 텍스트 이스케이프 구분자
'' 작은따옴표 리터럴 '

구문

formatDateTimeInJodaSyntax(datetime, format[, timezone])

인수

  • 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.0

0000년 1월 1일부터 경과한 일수가 주어지면, ISO 8601에서 정의한 프로렙틱 그레고리력 기준의 해당 날짜를 반환합니다.

이 계산은 MySQL의 FROM_DAYS() 함수와 동일합니다. 결과를 Date 타입의 범위 내에서 표현할 수 없으면 결과는 정의되지 않습니다.

구문

fromDaysSinceYearZero(days)

별칭: FROM_DAYS

인수

  • days — 0년부터 경과한 일수입니다. UInt32

반환 값

0년부터 경과한 일수에 해당하는 날짜를 반환합니다. Date

예시

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.0

0000년 1월 1일부터 경과한 지정된 일 수에 해당하는 ISO 8601에서 정의한 프로렙틱 그레고리력상의 날짜를 반환합니다. 계산 방식은 MySQL의 FROM_DAYS() 함수와 동일합니다. 결과를 Date32 타입의 범위 내에서 표현할 수 없으면 결과는 정의되지 않습니다.

구문

fromDaysSinceYearZero32(days)

인수

  • days — 0년 기준 경과한 일수입니다. UInt32

반환 값

0년 기준 경과한 일수에 해당하는 날짜를 반환합니다. Date32

예시

0년 기준 일수를 날짜로 변환

SELECT
fromDaysSinceYearZero32(739136) AS date1,
fromDaysSinceYearZero32(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘

fromModifiedJulianDay

도입 버전: v21.1.0

수정 율리우스일 값을 텍스트 형식의 YYYY-MM-DD 프로렙틱 그레고리력 날짜로 변환합니다. 이 함수는 -678941부터 2973483까지의 일 수를 지원하며(각각 0000-01-01 및 9999-12-31에 해당), 일 수가 지원 범위를 벗어나면 예외를 발생시킵니다.

구문

fromModifiedJulianDay(day)

인수

  • day — 수정 율리우스일 번호입니다. (U)Int*

반환 값

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

예시

수정 율리우스일을 날짜로 변환합니다

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

fromModifiedJulianDayOrNull

도입 버전: v21.1.0

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

구문

fromModifiedJulianDayOrNull(day)

인수

  • day — 수정 율리우스일 번호. (U)Int*

반환 값

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

예시

수정 율리우스일을 날짜로 변환하고 null 처리하기

SELECT fromModifiedJulianDayOrNull(58849);
SELECT fromModifiedJulianDayOrNull(60000000); -- invalid argument, returns NULL
┌─fromModifiedJulianDayOrNull(58849)─┐
│ 2020-01-01                         │
└────────────────────────────────────┘
┌─fromModifiedJulianDayOrNull(60000000)─┐
│ ᴺᵁᴸᴸ                                  │
└───────────────────────────────────────┘

fromUTCTimestamp

도입 버전: v22.1.0

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

구문

fromUTCTimestamp(datetime, time_zone)

별칭: from_utc_timestamp

인수

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

반환 값

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

예시

UTC 시간대를 지정한 시간대로 변환

SELECT fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00', 3), 'Asia/Shanghai')
┌─fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00', 3), 'Asia/Shanghai')─┐
│                                                   2023-03-16 18:00:00.000 │
└───────────────────────────────────────────────────────────────────────────┘

fromUnixTimestamp

도입된 버전: v20.8.0

이 함수는 Unix 타임스탬프를 달력 날짜와 시간으로 변환합니다.

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

구문

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

별칭: FROM_UNIXTIME

인수

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

반환 값

인수가 하나이면 해당 timestamp의 DateTime을 반환하고, 인수가 두 개 또는 세 개이면 String을 반환합니다. DateTime 또는 String

예시

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

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

포맷을 사용한 Unix 타임스탬프 변환

SELECT fromUnixTimestamp(1234334543, '%Y-%m-%d %R:%S') AS DateTime
┌─DateTime────────────┐
│ 2009-02-11 06:42:23 │
└─────────────────────┘

fromUnixTimestampInJodaSyntax

도입 버전: v23.1.0

이 함수는 Unix 타임스탬프를 날짜와 시각으로 변환합니다.

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

Integer 타입의 단일 인수가 주어지면 DateTime 타입의 값을 반환합니다. 즉, toDateTime처럼 동작합니다.

2개 또는 3개의 인수가 주어지고 첫 번째 인수가 Integer, Date, Date32, DateTime 또는 DateTime64 타입의 값이며, 두 번째 인수가 상수 포맷 문자열이고 세 번째 인수가 선택적 상수 시간대 문자열이면, 이 함수는 String 타입의 값을 반환합니다. 즉, formatDateTimeInJodaSyntax처럼 동작합니다. 이 경우 Joda datetime format style을 사용합니다.

구문

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

인수

  • timestamp — Unix 타임스탬프 또는 날짜/시간 값입니다. (U)Int* 또는 Date 또는 Date32 또는 DateTime 또는 DateTime64
  • format — 선택 사항입니다. 출력 형식 지정에 사용하는 Joda 문법 기반의 상수 포맷 문자열입니다. String
  • timezone — 선택 사항입니다. 상수 시간대 문자열입니다. String

반환 값

인수가 1개이면 날짜와 시간이 포함된 값을 반환하고, 인수가 2개 또는 3개이면 String을 반환합니다.} DateTime 또는 String

예시

Joda 포맷으로 Unix 타임스탬프 변환

SELECT fromUnixTimestampInJodaSyntax(1234334543, 'yyyy-MM-dd HH:mm:ss', 'UTC') AS DateTime
┌─DateTime────────────┐
│ 2009-02-11 06:42:23 │
└─────────────────────┘

localtime

도입 버전: v26.7.0

쿼리 분석 시점의 서버(또는 세션) 시간대에서 현재 시각을 반환합니다. 이 함수는 상수 표현식입니다. SQL 표준 / PostgreSQL LOCALTIME이며, CAST(now() AS Time)와 동일합니다.

구문

localtime()

인수

  • None.

반환 값

현재 시간을 반환합니다. Time

예시

괄호 없는 SQL 표준 구문

SELECT LOCALTIME
┌───────LOCALTIME─┐
│        07:42:09 │
└─────────────────┘

makeDate

도입 버전: v22.6.0

다음 중 하나를 사용해 Date를 생성합니다.

  • 연도, 월, 일
  • 연도와 해당 연도의 일자

구문

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

인수

반환 값

제공된 인수로 구성한 Date 값을 반환합니다 Date

예시

연도, 월, 일로 Date 생성

SELECT makeDate(2023, 2, 28) AS date;
┌───────date─┐
│ 2023-02-28 │
└────────────┘

연도와 연중 일수로 날짜 만들기

SELECT makeDate(2023, 42) AS date;
┌───────date─┐
│ 2023-02-11 │
└────────────┘

makeDate32

도입 버전: v22.6.0

다음 중 하나를 사용해 Date32를 생성합니다.

  • 연, 월, 일
  • 연도와 연중 일수

구문

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

인수

반환 값

주어진 인수로 생성된 Date32 값을 반환합니다. Date32

예시

연, 월, 일로 Date32 생성

SELECT makeDate(2023, 2, 28) AS date;
┌───────date─┐
│ 2023-02-28 │
└────────────┘

연도와 연중 일수로 Date32 만들기

SELECT makeDate(2023, 42) AS date;
┌───────date─┐
│ 2023-02-11 │
└────────────┘

makeDateTime

도입 버전: v22.6.0

연, 월, 일, 시, 분, 초와 선택적 시간대를 사용해 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.0

선택적으로 fraction, precision, 시간대를 지정하여 year, month, day, hour, minute, second로 DateTime64를 생성합니다.

구문

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

인수

반환 값

제공된 인수로 구성된 DateTime64 값을 반환합니다. DateTime64

예시

연도, 월, 일, 시, 분, 초로 DateTime64 생성

SELECT makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5);
┌─makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5)─┐
│                       2023-05-15 10:30:45.00779 │
└─────────────────────────────────────────────────┘

monthName

도입 버전: v22.1.0

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

구문

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.0

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

구문

now([timezone])

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

괄호 없는 SQL 표준 구문

SELECT NOW, CURRENT_TIMESTAMP
┌─────────────────NOW─┬───CURRENT_TIMESTAMP─┐
│ 2020-10-17 07:42:19 │ 2020-10-17 07:42:19 │
└─────────────────────┴─────────────────────┘

now64

도입 버전: v20.1.0

쿼리 분석 시점의 현재 날짜 및 시간을 초 미만 정밀도로 반환합니다. 이 함수는 상수 표현식입니다.

구문

now64([scale[, timezone]])

인수

  • scale — 선택 사항입니다. tick 크기(정밀도)입니다. 10^-precision초입니다. 유효 범위는 [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.0

각 데이터 블록의 처리 시점에 해당하는 현재 날짜와 시간을 반환합니다. 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.0

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

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

구문

nowInBlock64([scale[, timezone]])

인수

  • scale — 선택 사항입니다. 틱 크기(precision)입니다: 10^-precision초입니다. 유효 범위는 [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.0

서버의 시간대, 즉 timezone 설정 값을 반환합니다. 함수가 분산 테이블의 컨텍스트에서 실행되면 각 세그먼트에 해당하는 값을 가진 일반 컬럼을 생성합니다. 그렇지 않으면 상수 값을 생성합니다.

구문

serverTimezone()

별칭: serverTimeZone

인수

  • 없음.

반환 값

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

예시

사용 예시

SELECT serverTimeZone()
┌─serverTimeZone()─┐
│ Etc/UTC          │
└──────────────────┘

subDate

도입 버전: v23.9.0

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

구문

subDate(datetime, interval)

인수

  • datetime — interval을 차감할 날짜 또는 날짜/시간 값입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • 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.0

날짜, 시간 정보가 포함된 날짜, 또는 문자열로 인코딩된 날짜나 시간 정보가 포함된 날짜에서 지정한 일 수를 뺍니다.

구문

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('1998-06-16', 'Date'), toIntervalDay(10))─┐
│                                           1998-06-06 │
└──────────────────────────────────────────────────────┘

subtractHours

도입 버전: v1.1.0

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

구문

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('1998-06-16', 'Date'), toIntervalHour(10))─┐
│                                   1998-06-15 14:00:00 │
└───────────────────────────────────────────────────────┘

subtractInterval

도입 버전: v22.11.0

음수로 변환한 인터벌을 다른 인터벌 또는 인터벌의 튜플에 더합니다.

참고: 같은 유형의 인터벌은 하나의 인터벌로 합쳐집니다. 예를 들어 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.0

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

구문

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('1998-06-16', 'DateTime'), toIntervalMicrosecond(10))─┐
│                                       1998-06-15 23:59:59.999990 │
└──────────────────────────────────────────────────────────────────┘

subtractMilliseconds

도입 버전: v22.6.0

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

구문

subtractMilliseconds(datetime, num)

인수

반환 값

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

예시

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

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractMilliseconds(date_time, 1000) AS subtract_milliseconds_with_date_time,
    subtractMilliseconds(date_time_string, 1000) AS subtract_milliseconds_with_date_time_string
┌─subtract_milliseconds_with_date_time─┬─subtract_milliseconds_with_date_time_string─┐
│              2023-12-31 23:59:59.000 │                     2023-12-31 23:59:59.000 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘

대체 INTERVAL 구문 사용하기

SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 millisecond)
┌─minus(CAST('1998-06-16', 'DateTime'), toIntervalMillisecond(10))─┐
│                                          1998-06-15 23:59:59.990 │
└──────────────────────────────────────────────────────────────────┘

subtractMinutes

도입 버전: v1.1.0

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

구문

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('1998-06-16', 'Date'), toIntervalMinute(10))─┐
│                                     1998-06-15 23:50:00 │
└─────────────────────────────────────────────────────────┘

subtractMonths

도입 버전: v1.1.0

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

구문

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('1998-06-16', 'Date'), toIntervalMonth(10))─┐
│                                             1997-08-16 │
└────────────────────────────────────────────────────────┘

subtractNanoseconds

도입 버전: v20.1.0

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

구문

subtractNanoseconds(datetime, num)

인수

반환 값

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

예시

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

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractNanoseconds(date_time, 1000) AS subtract_nanoseconds_with_date_time,
    subtractNanoseconds(date_time_string, 1000) AS subtract_nanoseconds_with_date_time_string
┌─subtract_nanoseconds_with_date_time─┬─subtract_nanoseconds_with_date_time_string─┐
│       2023-12-31 23:59:59.999999000 │              2023-12-31 23:59:59.999999000 │
└─────────────────────────────────────┴────────────────────────────────────────────┘

대체 INTERVAL 구문 사용하기

SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 nanosecond)
┌─minus(CAST('1998-06-16', 'DateTime'), toIntervalNanosecond(10))─┐
│                                   1998-06-15 23:59:59.999999990 │
└─────────────────────────────────────────────────────────────────┘

subtractQuarters

도입 버전: v20.1.0

날짜, 시간 정보가 있는 날짜, 또는 문자열로 인코딩된 날짜나 시간 정보가 있는 날짜에서 지정된 개수의 분기를 뺍니다.

구문

subtractQuarters(datetime, num)

인수

반환 값

datetime에서 num 분기를 뺀 값을 반환합니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

예시

여러 날짜 타입에서 분기 빼기

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractQuarters(date, 1) AS subtract_quarters_with_date,
    subtractQuarters(date_time, 1) AS subtract_quarters_with_date_time,
    subtractQuarters(date_time_string, 1) AS subtract_quarters_with_date_time_string
┌─subtract_quarters_with_date─┬─subtract_quarters_with_date_time─┬─subtract_quarters_with_date_time_string─┐
│                  2023-10-01 │              2023-10-01 00:00:00 │                 2023-10-01 00:00:00.000 │
└─────────────────────────────┴──────────────────────────────────┴─────────────────────────────────────────┘

대체 INTERVAL 구문 사용하기

SELECT dateSub('1998-06-16'::Date, INTERVAL 10 quarter)
┌─minus(CAST('1998-06-16', 'Date'), toIntervalQuarter(10))─┐
│                                               1995-12-16 │
└──────────────────────────────────────────────────────────┘

subtractSeconds

도입 버전: v1.1.0

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

구문

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('1998-06-16', 'Date'), toIntervalSecond(10))─┐
│                                     1998-06-15 23:59:50 │
└─────────────────────────────────────────────────────────┘

subtractTupleOfIntervals

도입 버전: v22.11.0

날짜 또는 시간 정보가 포함된 날짜 값에서 인터벌 튜플을 순차적으로 뺍니다.

구문

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))
┌─subtractTupleOfIntervals(date, (toIntervalDay(1), toIntervalYear(1)))─┐
│                                                            2016-12-31 │
└───────────────────────────────────────────────────────────────────────┘

subtractWeeks

도입 버전: v1.1.0

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

구문

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('1998-06-16', 'Date'), toIntervalWeek(10))─┐
│                                            1998-04-07 │
└───────────────────────────────────────────────────────┘

subtractYears

처음 도입된 버전: v1.1.0

날짜, 날짜 및 시간이 포함된 값, 또는 문자열로 인코딩된 날짜/날짜 및 시간 값에서 지정한 연수만큼 뺍니다.

구문

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('1998-06-16', 'Date'), toIntervalYear(10))─┐
│                                            1988-06-16 │
└───────────────────────────────────────────────────────┘

timeDiff

도입 버전: v23.4.0

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

이 함수는 dateDiff('second', startdate, enddate)와 동일합니다.

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

구문

timeDiff(startdate, enddate)

인수

반환 값

enddate와 startdate의 차이를 초 단위로 반환합니다. Int64

예시

초 단위 시간 차이 계산

SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res
┌───res─┐
│ 90000 │
└───────┘

시간 차이를 계산해 시간 단위로 변환

SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) / 3600 AS hours
┌─hours─┐
│    25 │
└───────┘

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.0

시간을 30분 길이 인터벌의 시작 시점으로 내림합니다.

구문

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.0

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.0

첫 번째 인수 expr를 DateTime64(6) 타입으로 변환합니다. 두 번째 인수 expr_time를 지정하면, 변환된 값에 지정된 시간이 더해집니다.

구문

timestamp(expr[, expr_time])

인수

  • expr — 날짜 또는 시간이 포함된 날짜입니다. String
  • expr_time — 선택 사항입니다. 변환된 값에 추가할 시간입니다. String

반환 값

변환된 expr 값 또는 시간이 추가된 expr 값을 반환합니다. DateTime64(6)

예시

날짜 문자열을 DateTime64(6)로 변환

SELECT timestamp('2023-12-31') AS ts;
┌─────────────────────────ts─┐
│ 2023-12-31 00:00:00.000000 │
└────────────────────────────┘

날짜 문자열에 시간 추가

SELECT timestamp('2023-12-31 12:00:00', '12:00:00.11') AS ts;
┌─────────────────────────ts─┐
│ 2024-01-01 00:00:00.110000 │
└────────────────────────────┘

timezone

도입 버전: v21.4.0

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

구문

timezone()

별칭: timeZone

인수

  • 없음.

반환 값

정식 시간대 이름을 String으로 반환합니다

예시

사용 예시

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

timezoneOf

도입 버전: v21.4.0

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

구문

timezoneOf(datetime)

별칭: timeZoneOf

인수

  • datetime — DateTime 또는 DateTime64 타입의 값입니다.
  • timezone — 선택 사항입니다. datetime 값의 시간대를 변환할 대상 시간대 이름입니다. String

반환 값

datetime의 시간대 이름을 반환합니다. String

예시

사용 예시

SELECT timezoneOf(now());
┌─timezoneOf(now())─┐
│ Etc/UTC           │
└───────────────────┘

timezoneOffset

도입 버전: v21.6.0

UTC로부터의 시간대 오프셋을 초 단위로 반환합니다. 이 함수는 지정된 날짜 및 시간에 적용되는 일광 절약 시간과 과거의 시간대 변경 사항을 고려합니다.

구문

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.0

Date 또는 DateTime의 해당 월 날짜(1-31)를 반환합니다.

구문

toDayOfMonth(datetime)

별칭: DAY, DAYOFMONTH

인수

  • datetime — 월의 일을 가져올 날짜 또는 시간이 포함된 날짜입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

반환 값

주어진 날짜/시간의 월의 일을 반환합니다. UInt8

예시

사용 예시

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

toDayOfWeek

도입 버전: v1.1.0

Date 또는 DateTime 값이 한 주에서 몇 번째 요일에 해당하는지 나타내는 숫자를 반환합니다.

toDayOfWeek()의 2인수 형식에서는 한 주의 시작일을 월요일 또는 일요일로 지정할 수 있으며, 반환값의 범위를 06 또는 17로 지정할 수도 있습니다.

Mode First day of week Range
0 월요일 1-7: 월요일 = 1, 화요일 = 2, …, 일요일 = 7
1 월요일 0-6: 월요일 = 0, 화요일 = 1, …, 일요일 = 6
2 일요일 0-6: 일요일 = 0, 월요일 = 1, …, 토요일 = 6
3 일요일 1-7: 일요일 = 1, 월요일 = 2, …, 토요일 = 7

구문

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

별칭: DAYOFWEEK

인수

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

반환 값

지정된 Date 또는 DateTime에 해당하는 요일을 반환합니다. UInt8

예시

사용 예시

-- 다음 날짜는 2023년 4월 21일이며, 금요일이었습니다:
SELECT
    toDayOfWeek(toDateTime('2023-04-21')),
    toDayOfWeek(toDateTime('2023-04-21'), 1)
┌─toDayOfWeek(toDateTime('2023-04-21'))─┬─toDayOfWeek(toDateTime('2023-04-21'), 1)─┐
│                                     5 │                                        4 │
└───────────────────────────────────────┴──────────────────────────────────────────┘

toDayOfYear

도입 버전: v18.4.0

Date 또는 DateTime 값이 해당 연도에서 몇 번째 날인지 나타내는 숫자(1-366)를 반환합니다.

구문

toDayOfYear(datetime)

별칭: DAYOFYEAR

인수

  • datetime — 해당 연도의 몇 번째 날인지를 구할 날짜 또는 시간이 포함된 날짜입니다. 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 │
└────────────────────────────────────────────────┘

toDaysInMonth

도입 버전: v26.3.0

Date 또는 DateTime이 속한 월의 일 수를 반환합니다.

반환 값의 범위는 28~31입니다.

구문

toDaysInMonth(datetime)

인수

  • datetime — 해당 월의 일 수를 구할 날짜 또는 시간이 포함된 날짜입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

반환 값

지정된 날짜/시간이 속한 월의 일 수를 반환합니다. UInt8

예시

사용 예시

SELECT toDaysInMonth(toDate('2023-02-01')), toDaysInMonth(toDate('2024-02-01')), toDaysInMonth(toDate('2023-01-01'))
┌─toDaysInMonth(toDate('2023-02-01'))─┬─toDaysInMonth(toDate('2024-02-01'))─┬─toDaysInMonth(toDate('2023-01-01'))─┐
│                                  28 │                                  29 │                                  31 │
└─────────────────────────────────────┴─────────────────────────────────────┴─────────────────────────────────────┘

toDaysSinceYearZero

도입 버전: v23.9.0

지정한 날짜를 기준으로 0000년 1월 1일부터 ISO 8601에서 정의한 프로렙틱 그레고리력에서 경과한 일수를 반환합니다.

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

구문

toDaysSinceYearZero(date[, time_zone])

별칭: TO_DAYS

인수

  • date — 연도 0부터의 일수를 계산할 날짜 또는 날짜와 시간입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64
  • time_zone — 시간대입니다. String

반환 값

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

예시

연도 0부터의 일수 계산

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

toHour

도입 버전: v1.1.0

DateTime 또는 DateTime64 값의 시(hour) 부분(0-23)을 반환합니다.

구문

toHour(datetime)

별칭: HOUR

인수

  • datetime — 시간을 추출할 날짜 및 시간 값입니다. DateTime 또는 DateTime64

반환 값

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.0

날짜 또는 시간이 포함된 날짜의 ISO 주 번호를 반환합니다.

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

연도 시작이나 종료에 가까운 날짜는 이전 해 또는 다음 해의 주 번호를 반환할 수 있습니다. 예를 들어, 2025년 12월 29일은 2026년 1월 4일이 포함된 첫 번째 주에 속하므로 1을 반환합니다.

구문

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.0

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

구문

toISOYear(datetime)

인수

반환 값

입력 값을 ISO 연도 번호로 변환한 결과를 반환합니다. UInt16

예시

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

SELECT
toISOYear(toDate('2024/10/02')) as year1,
toISOYear(toDateTime('2024-10-02 01:30:00')) as year2
┌─year1─┬─year2─┐
│  2024 │  2024 │
└───────┴───────┘

toLastDayOfMonth

도입 버전: v1.1.0

날짜 또는 날짜와 시간이 포함된 값을 해당 월의 마지막 날로 올림합니다.

구문

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.0

날짜 또는 날짜/시간 값을 가장 가까운 토요일 또는 일요일로 올림합니다.

구문

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

인수

  • datetime — 변환할 날짜 또는 시간이 포함된 날짜/시간 값입니다. Date 또는 DateTime 또는 Date32 또는 DateTime64
  • mode — toWeek() 함수에 설명된 대로 주의 시작일을 결정합니다. 기본값은 0입니다. UInt8
  • timezone — 선택 사항입니다. 변환에 사용할 시간대입니다. 지정하지 않으면 서버의 시간대가 사용됩니다. String

반환 값

모드에 따라, 지정한 날짜와 같거나 그 이후의 가장 가까운 토요일 또는 일요일 날짜를 반환합니다. Date 또는 Date32

예시

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

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-22
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-23
toLastDayOfWeek(toDate('2023-04-23')):                 2023-04-29
toLastDayOfWeek(toDate('2023-04-23'), 1):              2023-04-23

toMicrosecond

도입 버전: v25.7.0

DateTime64 값의 마이크로초 부분(0-999999)을 반환합니다.

구문

toMicrosecond(datetime)

별칭: MICROSECOND

인수

  • datetime — 마이크로초를 추출할 날짜 및 시간입니다. DateTime64

반환 값

datetime의 초 단위 내 마이크로초(0 - 999999)를 반환합니다. UInt32

예시

사용 예시

SELECT toMicrosecond(toDateTime64('2023-04-21 10:20:30.456789', 6));
┌─toMicrosecond(toDateTime64('2023-04-21 10:20:30.456789', 6))─┐
│                                                       456789 │
└──────────────────────────────────────────────────────────────┘

toMillisecond

도입 버전: v24.2.0

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

구문

toMillisecond(datetime)

별칭: MILLISECOND

인수

  • datetime — 밀리초를 추출할 날짜 및 시간입니다. DateTime 또는 DateTime64

반환 값

datetime의 분 값(0 - 59)을 반환합니다. UInt16

예시

사용 예시

SELECT toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3));
┌─toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3))─┐
│                                                       456 │
└───────────────────────────────────────────────────────────┘

toMinute

도입 버전: v1.1.0

Date 또는 DateTime 값의 분 구성 요소(0-59)를 반환합니다.

구문

toMinute(datetime)

별칭: MINUTE

인수

반환 값

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.0

텍스트 형식의 YYYY-MM-DD 프로렙틱 그레고리력 날짜를 Int32 수정 율리우스일 숫자로 변환합니다. 이 함수는 0000-01-01부터 9999-12-31까지의 날짜를 지원합니다. 인수를 날짜로 파싱할 수 없거나 날짜가 올바르지 않으면 예외를 발생시킵니다.

구문

toModifiedJulianDay(date)

인수

반환 값

수정 율리우스일 번호를 반환합니다. Int32

예시

날짜를 수정 율리우스일로 변환

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

toModifiedJulianDayOrNull

도입 버전: v21.1.0

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

구문

toModifiedJulianDayOrNull(date)

인수

반환 값

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

예시

null 처리와 함께 날짜를 수정 율리우스일로 변환

SELECT toModifiedJulianDayOrNull('2020-01-01');
SELECT toModifiedJulianDayOrNull('0000-00-00'); -- invalid date, returns NULL
┌─toModifiedJulianDayOrNull('2020-01-01')─┐
│                                   58849 │
└─────────────────────────────────────────┘
┌─toModifiedJulianDayOrNull('0000-00-00')─┐
│                                    ᴺᵁᴸᴸ │
└─────────────────────────────────────────┘

toMonday

도입 버전: v1.1.0

날짜 또는 날짜/시간을 해당 주의 월요일로 내림합니다. 반환값은 날짜입니다.

구문

toMonday(value)

인수

반환 값

지정된 날짜 또는 날짜/시간과 같은 주의 월요일 날짜를 반환합니다. Date

예시

해당 주의 월요일로 내림

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.0

Date 또는 DateTime 값의 월(1-12) 구성 요소를 반환합니다.

구문

toMonth(datetime)

별칭: MONTH

인수

반환 값

지정한 날짜/시간의 월을 반환합니다. UInt8

예시

사용 예시

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

toMonthNumSinceEpoch

도입 버전: v25.3.0

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

구문

toMonthNumSinceEpoch(date)

인수

반환 값

양의 정수

예시

예시

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

toNanosecond

도입 버전: v25.7.0

DateTime64 값의 나노초 부분(0-999999999)을 반환합니다.

구문

toNanosecond(datetime)

별칭: NANOSECOND

인수

  • datetime — 나노초를 추출할 날짜 및 시간입니다. DateTime64

반환 값

datetime의 초 단위 내 나노초(0 - 999999999)를 반환합니다. UInt32

예시

사용 예시

SELECT toNanosecond(toDateTime64('2023-04-21 10:20:30.123456789', 9));
┌─toNanosecond(toDateTime64('2023-04-21 10:20:30.123456789', 9))─┐
│                                                      123456789 │
└────────────────────────────────────────────────────────────────┘

toQuarter

도입 버전: v1.1.0

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

구문

toQuarter(datetime)

별칭: QUARTER

인수

  • datetime — 연도의 분기를 구할 날짜 또는 시간이 포함된 날짜입니다. Date 또는 Date32 또는 DateTime 또는 DateTime64

반환 값

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

예시

사용 예시

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

toRelativeDayNum

도입 버전: v1.1.0

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

구문

toRelativeDayNum(date)

인수

반환 값

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

예시

상대 일 번호 가져오기

SELECT toRelativeDayNum(toDate('2023-04-01')) - toRelativeDayNum(toDate('2023-01-01'))
┌─minus(toRelativeDayNum(toDate('2023-04-01')), toRelativeDayNum(toDate('2023-01-01')))─┐
│                                                                                    90 │
└───────────────────────────────────────────────────────────────────────────────────────┘

toRelativeHourNum

도입 버전: v1.1.0

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

구문

toRelativeHourNum(date)

인수

반환 값

과거의 고정된 기준 시점으로부터 지난 시간 수를 반환합니다. UInt32

예시

상대 시간 수 구하기

SELECT toRelativeHourNum(toDateTime('2023-01-01 12:00:00')) - toRelativeHourNum(toDateTime('2023-01-01 00:00:00')) AS hours_difference
┌─hours_difference─┐
│               12 │
└──────────────────┘

toRelativeMinuteNum

도입 버전: v1.1.0

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

구문

toRelativeMinuteNum(date)

인수

반환 값

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

예시

상대 분 번호 구하기

SELECT toRelativeMinuteNum(toDateTime('2023-01-01 00:30:00')) - toRelativeMinuteNum(toDateTime('2023-01-01 00:00:00')) AS minutes_difference
┌─minutes_difference─┐
│                 30 │
└────────────────────┘

toRelativeMonthNum

도입 버전: v1.1.0

날짜 또는 시간이 포함된 날짜를 과거의 특정 고정 시점을 기준으로 경과한 개월 수로 변환합니다. 정확한 기준 시점은 구현 세부 사항이므로, 이 함수는 단독으로 사용하도록 설계되지 않았습니다. 이 함수의 주된 목적은 두 날짜 또는 시간이 포함된 날짜 사이의 개월 수 차이를 계산하는 것입니다. 예를 들어 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.0

날짜 또는 시간이 포함된 날짜를 과거의 특정 고정 시점을 기준으로 경과한 분기 수로 변환합니다. 정확한 시점은 구현 세부 사항이므로 이 함수는 단독으로 사용하도록 설계되지 않았습니다. 이 함수의 주요 목적은 두 날짜 또는 시간이 포함된 날짜 사이의 분기 차이를 계산하는 것입니다. 예: 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.0

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

구문

toRelativeSecondNum(date)

인수

반환 값

과거의 고정된 기준 시점으로부터 지난 초 수를 반환합니다. UInt32

예시

상대 초 번호 구하기

SELECT toRelativeSecondNum(toDateTime('2023-01-01 00:01:00')) - toRelativeSecondNum(toDateTime('2023-01-01 00:00:00')) AS seconds_difference
┌─seconds_difference─┐
│                 60 │
└────────────────────┘

toRelativeWeekNum

도입 버전: v1.1.0

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

구문

toRelativeWeekNum(date)

인수

반환 값

과거의 고정된 기준 시점으로부터 지난 주 수를 반환합니다. UInt32

예시

상대 주 번호 구하기

SELECT toRelativeWeekNum(toDate('2023-01-08')) - toRelativeWeekNum(toDate('2023-01-01')) AS weeks_difference
┌─weeks_difference─┐
│                1 │
└──────────────────┘

toRelativeYearNum

도입 버전: v1.1.0

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

구문

toRelativeYearNum(date)

인수

반환 값

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

예시

상대 연도 번호 구하기

SELECT toRelativeYearNum('2010-10-01'::DateTime) - toRelativeYearNum('2000-01-01'::DateTime)
┌─minus(toRelativeYearNum(CAST('2010-10-01', 'DateTime')), toRelativeYearNum(CAST('2000-01-01', 'DateTime')))─┐
│                                                                                                          10 │
└─────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

toSecond

도입 버전: v1.1.0

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

구문

toSecond(datetime)

별칭: SECOND

인수

반환 값

datetime에서 분의 초(0 - 59)를 반환합니다. UInt8

예시

사용 예시

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

toStartOfDay

도입 버전: v1.1.0

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

구문

toStartOfDay(datetime)

인수

  • datetime — 내림할 시간이 포함된 날짜입니다. Date 또는 DateTime

반환 값

날짜와 시간을 하루 시작 시점으로 내림한 값을 반환합니다. DateTime 또는 DateTime64

예시

하루 시작 시점으로 내림

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

toStartOfFifteenMinutes

도입 버전: v1.1.0

시간이 포함된 날짜를 15분 인터벌 시작 시점으로 내림합니다.

구문

toStartOfFifteenMinutes(datetime)

인수

  • datetime — 내림할 날짜 또는 시간이 포함된 날짜입니다. DateTime 또는 DateTime64

반환 값

가장 가까운 15분 인터벌의 시작 시점으로 내림한 시간이 포함된 날짜를 반환합니다. DateTime 또는 DateTime64

예시

예시

SELECT
    toStartOfFifteenMinutes(toDateTime('2023-04-21 10:17:00')),
    toStartOfFifteenMinutes(toDateTime('2023-04-21 10:20:00')),
    toStartOfFifteenMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical
Row 1:
──────
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:15:00
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:15:00
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:15:00

toStartOfFiveMinutes

도입 버전: v22.6.0

시간이 포함된 날짜를 가장 가까운 5분 인터벌의 시작 시점으로 내림합니다.

구문

toStartOfFiveMinutes(datetime)

별칭: toStartOfFiveMinute

인수

  • datetime — 내림할 시간 정보가 포함된 날짜입니다. DateTime 또는 DateTime64

반환 값

가장 가까운 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.0

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

구문

toStartOfHour(datetime)

인수

반환 값

시간이 포함된 날짜를 해당 시간의 시작 시각으로 내림한 값을 반환합니다. DateTime 또는 DateTime64

예시

시간의 시작 시각으로 내림

SELECT
    toStartOfHour(toDateTime('2023-04-21 10:20:30'));
┌─toStartOfHour(toDateTime('2023-04-21 10:20:30'))─┐
│                              2023-04-21 10:00:00 │
└──────────────────────────────────────────────────┘

toStartOfISOYear

도입 버전: v1.1.0

날짜 또는 시간이 포함된 날짜 값을 ISO 연도의 첫날로 내림합니다. ISO 연도는 일반적인 연도와 다를 수 있습니다. ISO 주차 날짜를 참조하세요.

구문

toStartOfISOYear(value)

인수

  • value — ISO 연도의 첫째 날로 내림할 날짜 또는 시간이 포함된 날짜입니다. 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.0

이 함수는 toStartOfInterval(date_or_date_with_time, INTERVAL x unit [, time_zone]) 구문을 사용하여 다른 toStartOf*() 함수들을 일반화한 함수입니다.

예를 들어,

  • toStartOfInterval(t, INTERVAL 1 YEAR)는 toStartOfYear(t)와 동일한 값을 반환합니다.
  • toStartOfInterval(t, INTERVAL 1 MONTH)는 toStartOfMonth(t)와 동일한 값을 반환합니다.
  • toStartOfInterval(t, INTERVAL 1 DAY)는 toStartOfDay(t)와 동일한 값을 반환합니다.
  • toStartOfInterval(t, INTERVAL 15 MINUTE)는 toStartOfFifteenMinutes(t)와 동일한 값을 반환합니다.

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

Interval Start
YEAR 0년
QUARTER 1900년 1분기
MONTH 1900년 1월
WEEK 1970년 첫째 주 (01-05)
DAY 1970-01-01
HOUR (*)
MINUTE 1970-01-01 00:00:00
SECOND 1970-01-01 00:00:00
MILLISECOND 1970-01-01 00:00:00
MICROSECOND 1970-01-01 00:00:00
NANOSECOND 1970-01-01 00:00:00
(*) 시간 인터벌은 예외적입니다. 계산은 항상 현재 날짜의 00:00:00(자정)을 기준으로 수행됩니다. 따라서
1~23 범위의 시간 값만 유용합니다.

unit으로 WEEK를 지정하면 toStartOfInterval은 주가 월요일에 시작한다고 가정합니다. 이 동작은 기본적으로 주가 일요일에 시작하는 toStartOfWeek 함수와 다릅니다.

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

구문

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

별칭: date_bin, time_bucket

인수

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

반환 값

입력 값이 포함된 인터벌의 시작 시점을 반환합니다. DateTime

예시

기본 인터벌 내림

SELECT toStartOfInterval(toDateTime('2023-01-15 14:30:00'), INTERVAL 1 MONTH)
┌─toStartOfInterval(toDateTime('2023-01-15 14:30:00'), toIntervalMonth(1))─┐
│                                                               2023-01-01 │
└──────────────────────────────────────────────────────────────────────────┘

기준점을 사용하는 경우

SELECT toStartOfInterval(toDateTime('2023-01-01 14:45:00'), INTERVAL 1 MINUTE, toDateTime('2023-01-01 14:35:30'))
┌─toStartOfInterval(toDateTime('2023-01-01 14:45:00'), toIntervalMinute(1), toDateTime('2023-01-01 14:35:30'))─┐
│                                                                                          2023-01-01 14:44:30 │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

toStartOfMicrosecond

도입 버전: v22.6.0

시간이 포함된 날짜 값을 해당 마이크로초의 시작 시점으로 내림합니다.

구문

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 13:20:30.999999000 │
└─────────────────────────────────────────────┘

toStartOfMillisecond

도입 버전: v22.6.0

시간이 포함된 날짜 값을 해당 밀리초의 시작 시점으로 내림합니다.

구문

toStartOfMillisecond(datetime[, timezone])

인수

  • datetime — 날짜와 시간입니다. DateTime64
  • 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 13:20:30.999000000 │
└─────────────────────────────────────────────┘

toStartOfMinute

도입 버전: v1.1.0

날짜와 시간이 포함된 값을 해당 분의 시작으로 내림합니다.

구문

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.0

시간이 포함된 날짜를 해당 월의 첫째 날로 내림합니다.

구문

toStartOfMonth(value)

인수

반환 값

지정한 시간이 포함된 날짜가 속한 월의 첫째 날을 반환합니다. Date

예시

해당 월의 첫째 날로 내림

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

toStartOfNanosecond

도입 버전: v22.6.0

시간이 포함된 날짜를 나노초 단위의 시작으로 내림합니다.

구문

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 13:20:30.999999999 │
└────────────────────────────────────────────┘

toStartOfQuarter

도입 버전: v1.1.0

시간이 포함된 날짜를 해당 분기의 첫날로 내림합니다. 분기의 첫날은 1월 1일, 4월 1일, 7월 1일 또는 10월 1일입니다.

구문

toStartOfQuarter(value)

인수

반환 값

지정된 시간이 포함된 날짜에 해당하는 분기의 첫날을 반환합니다. Date

예시

분기의 첫날로 내림

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

toStartOfSecond

도입 버전: v20.5.0

날짜 및 시간 값을 해당 초의 시작 시점으로 내림합니다.

구문

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

시간대를 지정한 쿼리

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.0

날짜/시간 값을 가장 가까운 10분 인터벌의 시작 시각으로 내림합니다.

구문

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.0

날짜 또는 날짜/시간 값을 가장 가까운 일요일 또는 월요일로 내림합니다.

구문

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

인수

  • datetime — 변환할 날짜 또는 날짜/시간입니다. Date 또는 DateTime 또는 Date32 또는 DateTime64
  • mode — toWeek() 함수에 설명된 대로 한 주의 시작 요일을 결정합니다. 기본값은 0입니다. UInt8
  • timezone — 변환에 사용할 시간대입니다. 지정하지 않으면 서버의 시간대가 사용됩니다. String

반환 값

mode에 따라 지정한 날짜와 같거나 그 이전인 가장 가까운 일요일 또는 월요일 날짜를 반환합니다. Date 또는 Date32

예시

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

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-16
toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-17
toStartOfWeek(toDate('2023-04-24')):                 2023-04-23
toStartOfWeek(toDate('2023-04-24'), 1):              2023-04-24

toStartOfYear

도입 버전: v1.1.0

날짜 또는 날짜/시간 값을 해당 연도의 첫날로 내림합니다. 결과는 Date 객체로 반환됩니다.

구문

toStartOfYear(value)

인수

반환 값

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

예시

연도의 첫째 날로 내림

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

toTimeWithFixedDate

도입 버전: v25.5.0

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

따라서 toTimeWithFixedDate를 단독으로 사용해서는 안 됩니다. 이 함수의 주된 용도는 toTimeWithFixedDate(dt1) - toTimeWithFixedDate(dt2)와 같이 두 날짜/시간 간의 시간 차이를 계산하는 것입니다.

이는 레거시 toTime 함수로, 값을 Time 데이터 타입으로 변환하는 toTime 함수가 이제 toTime이라는 이름을 사용하므로 v25.5에서 이름이 변경되었습니다. 설정 use_legacy_to_time가 활성화되면 이전 이름인 toTime으로도 계속 사용할 수 있습니다(v26.7부터 기본값은 0이며, v25.6부터 v26.6까지는 기본값이 1이었습니다).

datetime 인수에 초 미만 구성 요소가 있으면 초 단위 정밀도를 갖는 반환 DateTime 값에서는 해당 구성 요소가 제거됩니다.

구문

toTimeWithFixedDate(datetime[, timezone])

인수

  • datetime — 시간으로 변환할 날짜/시간입니다. DateTime 또는 DateTime64
  • timezone — 선택 사항입니다. 반환 값에 적용할 시간대입니다. String

반환 값

날짜/시간 값의 시간 구성 요소를 고정된 시점(현재는 1970-01-02) 기준의 오프셋 형태로 반환합니다. DateTime

예시

두 날짜 간의 시간 차이 계산

SELECT toTimeWithFixedDate('2025-06-15 12:00:00'::DateTime) - toTimeWithFixedDate('2024-05-10 11:00:00'::DateTime) AS result, toTypeName(result)
┌─result─┬─toTypeName(result)─┐
│   3600 │ Int32              │
└────────┴────────────────────┘

초 미만 단위는 삭제됩니다

SELECT toTimeWithFixedDate(toDateTime64('1970-12-10 01:20:30.3000', 3)) AS result, toTypeName(result)
┌──────────────result─┬─toTypeName(result)─┐
│ 1970-01-02 01:20:30 │ DateTime           │
└─────────────────────┴────────────────────┘

레거시 이름으로 호출되는 동일한 함수

SET use_legacy_to_time = 1;
SELECT toTime(toDateTime64('1970-12-10 01:20:30.3000', 3)) AS result, toTypeName(result)
┌──────────────result─┬─toTypeName(result)─┐
│ 1970-01-02 01:20:30 │ DateTime           │
└─────────────────────┴────────────────────┘

toTimezone

도입 버전: v1.1.0

DateTime 또는 DateTime64를 지정된 시간대로 변환합니다. 데이터의 내부 값(Unix 초 단위 숫자)은 변경되지 않습니다. 시간대 속성과 문자열 표현만 변경됩니다.

구문

toTimezone(datetime, timezone)

별칭: toTimeZone

인수

반환 값

입력과 동일한 타임스탬프를 반환하지만, 지정된 시간대가 적용된 DateTime 또는 DateTime64입니다.

예시

사용 예시

SELECT toDateTime('2019-01-01 00:00:00', 'UTC') AS time_utc,
toTypeName(time_utc) AS type_utc,
toInt32(time_utc) AS int32utc,
toTimezone(time_utc, 'Asia/Yekaterinburg') AS time_yekat,
toTypeName(time_yekat) AS type_yekat,
toInt32(time_yekat) AS int32yekat,
toTimezone(time_utc, 'US/Samoa') AS time_samoa,
toTypeName(time_samoa) AS type_samoa,
toInt32(time_samoa) AS int32samoa
FORMAT Vertical;
Row 1:
──────
time_utc:   2019-01-01 00:00:00
type_utc:   DateTime('UTC')
int32utc:   1546300800
time_yekat: 2019-01-01 05:00:00
type_yekat: DateTime('Asia/Yekaterinburg')
int32yekat: 1546300800
time_samoa: 2018-12-31 13:00:00
type_samoa: DateTime('US/Samoa')
int32samoa: 1546300800

toUTCTimestamp

도입 버전: v23.8.0

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

구문

toUTCTimestamp(datetime, time_zone)

별칭: to_utc_timestamp

인수

  • datetime — 날짜 또는 날짜/시간 타입의 상수 값이나 표현식입니다. 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.0

String, Date 또는 DateTime 값을 Unix timestamp(1970-01-01 00:00:00 UTC 이후 경과한 초)인 UInt32로 변환합니다.

구문

toUnixTimestamp(date[, timezone])

인수

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

반환 값

유닉스 타임스탬프를 반환합니다. UInt32

예시

사용 예시

SELECT
'2017-11-05 08:07:47' AS dt_str,
toUnixTimestamp(dt_str) AS from_str,
toUnixTimestamp(dt_str, 'Asia/Tokyo') AS from_str_tokyo,
toUnixTimestamp(toDateTime(dt_str)) AS from_datetime,
toUnixTimestamp(toDateTime64(dt_str, 0)) AS from_datetime64,
toUnixTimestamp(toDate(dt_str)) AS from_date,
toUnixTimestamp(toDate32(dt_str)) AS from_date32
FORMAT Vertical;
행 1:
──────
dt_str:          2017-11-05 08:07:47
from_str:        1509869267
from_str_tokyo:  1509836867
from_datetime:   1509869267
from_datetime64: 1509869267
from_date:       1509840000
from_date32:     1509840000

toWeek

도입 버전: v20.1.0

이 함수는 date 또는 datetime 값의 주 번호를 반환합니다. toWeek()의 2인수 형식을 사용하면 주가 일요일에 시작할지 월요일에 시작할지, 그리고 반환값 범위를 053으로 할지 153으로 할지 지정할 수 있습니다.

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

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

Mode 주의 첫째 날 범위 1주차는 다음 조건을 만족하는 첫 번째 주 …
0 일요일 0-53 해당 연도에 일요일이 포함된 주
1 월요일 0-53 해당 연도에 4일 이상 포함된 주
2 일요일 1-53 해당 연도에 일요일이 포함된 주
3 월요일 1-53 해당 연도에 4일 이상 포함된 주
4 일요일 0-53 해당 연도에 4일 이상 포함된 주
5 월요일 0-53 해당 연도에 월요일이 포함된 주
6 일요일 1-53 해당 연도에 4일 이상 포함된 주
7 월요일 1-53 해당 연도에 월요일이 포함된 주
8 일요일 1-53 1월 1일을 포함하는 주
9 월요일 1-53 1월 1일을 포함하는 주

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

  • 1월 1일이 포함된 주가 새해에 4일 이상 포함되어 있으면 그 주는 1주차입니다.
  • 그렇지 않으면 그 주는 이전 연도의 마지막 주이고, 다음 주가 1주차입니다.

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

첫 번째 인수는 parseDateTime64BestEffort에서 지원하는 포맷의 String으로도 지정할 수 있습니다. 문자열 인수 지원은 일부 타사 도구가 기대하는 MySQL 호환성을 위해서만 제공됩니다. 문자열 인수 지원은 향후 새로운 MySQL 호환성 설정에 따라 달라질 수 있으며, 문자열 파싱은 일반적으로 느리므로 사용하지 않는 것이 좋습니다.

구문

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

별칭: week

인수

  • datetime — 주 번호를 구할 날짜 또는 날짜/시간 값입니다. Date 또는 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.0

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

이 함수는 YYYYMMDDToDate() 함수와 반대입니다.

구문

toYYYYMM(datetime[, timezone])

인수

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

반환 값

연도와 월 번호(YYYY * 100 + MM)를 포함하는 UInt32 값을 반환합니다. UInt32

예시

현재 날짜를 YYYYMM 포맷으로 변환

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

toYYYYMMDD

도입 버전: v1.1.0

날짜 또는 날짜/시간 값을 연, 월, 일 값을 담은 UInt32 숫자(YYYY * 10000 + MM * 100 + DD)로 변환합니다. 두 번째 선택적 시간대 인수를 받을 수 있습니다. 이 인수가 제공되면 시간대는 문자열 상수여야 합니다.

구문

toYYYYMMDD(datetime[, timezone])

인수

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

반환 값

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

예시

다른 시간대의 날짜를 YYYYMMDD 포맷으로 변환

SELECT toYYYYMMDD(toDateTime('2026-01-02 03:04:05', 'UTC'), 'US/Eastern')
┌─toYYYYMMDD(toDateTime('2026-01-02 03:04:05', 'UTC'), 'US/Eastern')─┐
│                                                           20260101 │
└────────────────────────────────────────────────────────────────────┘

toYYYYMMDDhhmmss

도입 버전: v1.1.0

날짜 또는 날짜/시간를 연월일시분초를 담은 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(toDateTime('2023-03-02 16:22:09', 'UTC'), 'US/Eastern')
┌─toYYYYMMDDhhmmss(toDateTime('2023-03-02 16:22:09', 'UTC'), 'US/Eastern')─┐
│                                                           20230302112209 │
└──────────────────────────────────────────────────────────────────────────┘

toYear

도입 버전: v1.1.0

Date 또는 DateTime 값의 연도 구성 요소(AD)를 반환합니다.

구문

toYear(datetime)

별칭: YEAR

인수

반환 값

주어진 Date 또는 DateTime의 연도를 반환합니다. UInt16

예시

사용 예시

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

toYearNumSinceEpoch

도입 버전: v25.3.0

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

구문

toYearNumSinceEpoch(date)

인수

반환 값

양의 정수

예시

예시

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

toYearWeek

도입 버전: v20.1.0

날짜의 연도와 주 번호를 반환합니다. 연도의 첫째 주와 마지막 주에는 결과의 연도가 날짜 인수의 연도와 다를 수 있습니다.

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까지의 모드는 주의 시작 요일과 주 번호 범위를 결정합니다. 기본값은 0입니다. - timezone — 선택 사항입니다. 시간대입니다. String

반환 값

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

예시

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

SELECT toDate('2016-12-27') AS date, toYearWeek(date) AS yearWeek0, toYearWeek(date,1) AS yearWeek1, toYearWeek(date,9) AS yearWeek9, toYearWeek(toDate('2022-01-01')) AS prev_yearWeek
┌───────date─┬─yearWeek0─┬─yearWeek1─┬─yearWeek9─┬─prev_yearWeek─┐
│ 2016-12-27 │    201652 │    201652 │    201701 │        202152 │
└────────────┴───────────┴───────────┴───────────┴───────────────┘

today

도입 버전: v1.1.0

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

구문

today()

별칭: current_date, curdate

인수

  • 없음.

반환 값

현재 날짜 Date를 반환합니다.

예시

사용 예시

SELECT today() AS today, curdate() AS curdate, current_date() AS current_date FORMAT Pretty
┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃      today ┃    curdate ┃ current_date ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2026-08-02 │ 2026-08-02 │   2026-08-02 │
└────────────┴────────────┴──────────────┘

괄호 없는 SQL 표준 구문

SELECT TODAY, CURDATE,CURRENT_DATE
┌──────TODAY─┬────CURDATE─┬─CURRENT_DATE─┐
│ 2026-08-02 │ 2026-08-02 │   2026-08-02 │
└────────────┴────────────┴──────────────┘

yesterday

도입 버전: v1.1.0

인수를 받지 않으며, 쿼리 분석이 수행되는 시점의 어제 날짜를 반환합니다.

구문

yesterday()

인수

  • 없음.

반환 값

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

예시

어제 날짜를 구합니다

SELECT yesterday();
SELECT today() - 1;
┌─yesterday()─┐
│  2026-08-01 │
└─────────────┘
┌─minus(today(), 1)─┐
│        2026-08-01 │
└───────────────────┘
Navigation