> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> 날짜 및 시간 작업 함수에 대한 문서
# 날짜 및 시간 작업 함수
이 섹션의 대부분의 함수는 선택적으로 시간대 인수를 받습니다. 예를 들어 `Europe/Amsterdam`입니다. 이 경우 로컬(기본) 시간대 대신 지정한 시간대가 사용됩니다.
**예시**
```sql theme={null}
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
```
```text theme={null}
┌────────────────time─┬─date_local─┬─date_yekat─┬─time_samoa──────────┐
│ 2016-06-15 23:00:00 │ 2016-06-15 │ 2016-06-16 │ 2016-06-15 09:00:00 │
└─────────────────────┴────────────┴────────────┴─────────────────────┘
```
SQL 표준과의 호환성을 위해 `NOW`, `CURRENT_TIMESTAMP`, `LOCALTIME`, `LOCALTIMESTAMP`, `TODAY`, `CURRENT_DATE` 함수는 괄호 없이 사용할 수 있습니다.
{/*AUTOGENERATED_START*/}
## UTCTimestamp
도입 버전: v22.11.0
쿼리 분석 시점의 현재 날짜 및 시간을 반환합니다. 이 함수는 상수 표현식입니다.
이 함수는 `now('UTC')`와 동일한 결과를 반환합니다. MySQL 지원용으로만 추가되었습니다. 권장되는 사용 방식은 [`now`](#now)입니다.
**구문**
```sql theme={null}
UTCTimestamp()
```
**별칭**: `UTC_timestamp`
**인수**
* 없음.
**반환 값**
쿼리 분석 시점의 현재 날짜 및 시간을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime)
**예시**
**현재 UTC 타임스탬프 가져오기**
```sql title=Query theme={null}
SELECT UTCTimestamp()
```
```response title=Response theme={null}
┌──────UTCTimestamp()─┐
│ 2024-05-28 08:32:09 │
└─────────────────────┘
```
## YYYYMMDDToDate
도입 버전: v23.9.0
연도, 월, 일 숫자가 포함된 숫자를 `Date`로 변환합니다.
이 함수는 [`toYYYYMMDD()`](/ko/reference/functions/regular-functions/date-time-functions#toYYYYMMDD) 함수의 반대입니다.
입력이 유효한 Date 값을 나타내지 않으면 출력은 정의되지 않습니다.
**구문**
```sql theme={null}
YYYYMMDDToDate(YYYYMMDD)
```
**인수**
* `YYYYMMDD` — 연, 월, 일을 포함하는 숫자입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
**반환 값**
제공된 인수로부터 `Date` 값을 반환합니다. [`Date`](/ko/reference/data-types/date)
**예시**
**예시**
```sql title=Query theme={null}
SELECT YYYYMMDDToDate(20230911);
```
```response title=Response theme={null}
┌─toYYYYMMDD(20230911)─┐
│ 2023-09-11 │
└──────────────────────┘
```
## YYYYMMDDToDate32
도입 버전: v23.9.0
연, 월, 일 정보를 담은 숫자를 `Date32`로 변환합니다.
이 함수는 [`toYYYYMMDD()`](/ko/reference/functions/regular-functions/date-time-functions#toYYYYMMDD) 함수와 반대입니다.
입력이 유효한 `Date32` 값을 나타내지 않으면 출력은 정의되지 않습니다.
**구문**
```sql theme={null}
YYYYMMDDToDate32(YYYYMMDD)
```
**인수**
* `YYYYMMDD` — 연, 월, 일이 포함된 숫자입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
**반환 값**
지정된 인수로부터 `Date32` 값을 반환합니다 [`Date32`](/ko/reference/data-types/date32)
**예시**
**예시**
```sql title=Query theme={null}
SELECT YYYYMMDDToDate32(20000507);
```
```response title=Response theme={null}
┌─YYYYMMDDToDate32(20000507)─┐
│ 2000-05-07 │
└────────────────────────────┘
```
## YYYYMMDDhhmmssToDateTime
도입 버전: v23.9.0
연, 월, 일, 시, 분, 초를 포함하는 숫자를 `DateTime`으로 변환합니다.
이 함수는 [`toYYYYMMDDhhmmss()`](/ko/reference/functions/regular-functions/date-time-functions#toYYYYMMDDhhmmss)의 반대 함수입니다.
입력이 유효한 `DateTime` 값을 나타내지 않으면 출력은 정의되지 않습니다.
**구문**
```sql theme={null}
YYYYMMDDhhmmssToDateTime(YYYYMMDDhhmmss[, timezone])
```
**인수**
* `YYYYMMDDhhmmss` — 연도, 월, 일, 시, 분, 초를 포함하는 숫자입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `timezone` — 시간대 이름입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
주어진 인수로 `DateTime` 값을 반환합니다 [`DateTime`](/ko/reference/data-types/datetime)
**예시**
**예시**
```sql title=Query theme={null}
SELECT YYYYMMDDToDateTime(20230911131415);
```
```response title=Response theme={null}
┌──────YYYYMMDDhhmmssToDateTime(20230911131415)─┐
│ 2023-09-11 13:14:15 │
└───────────────────────────────────────────────┘
```
## YYYYMMDDhhmmssToDateTime64
도입 버전: v23.9.0
연, 월, 일, 시, 분, 초를 포함하는 숫자를 `DateTime64`로 변환합니다.
이 함수는 [`toYYYYMMDDhhmmss()`](/ko/reference/functions/regular-functions/date-time-functions#toYYYYMMDDhhmmss) 함수와 반대입니다.
입력이 유효한 `DateTime64` 값을 나타내지 않으면 출력은 정의되지 않습니다.
**구문**
```sql theme={null}
YYYYMMDDhhmmssToDateTime64(YYYYMMDDhhmmss[, precision[, timezone]])
```
**인수**
* `YYYYMMDDhhmmss` — 연, 월, 일, 시, 분, 초를 포함하는 숫자입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `precision` — 소수 부분의 정밀도(0-9)입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `timezone` — 시간대 이름입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
주어진 인수로부터 `DateTime64` 값을 반환합니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**예시**
```sql title=Query theme={null}
SELECT YYYYMMDDhhmmssToDateTime64(20230911131415, 3, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─YYYYMMDDhhmm⋯/Istanbul')─┐
│ 2023-09-11 13:14:15.000 │
└──────────────────────────┘
```
## addDate
도입 버전: v23.9.0
지정된 날짜, 시간이 포함된 날짜 또는 문자열로 인코딩된 날짜/시간 값에 시간 인터벌을 더합니다.
덧셈 결과가 데이터 타입의 범위를 벗어나면 결과는 정의되지 않습니다.
**구문**
```sql theme={null}
addDate(datetime, interval)
```
**인수**
* `datetime` — `interval`을 더할 날짜 또는 시간 정보가 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `interval` — 더할 인터벌입니다. [`Interval`](/ko/reference/data-types/int-uint)
**반환 값**
`datetime`에 `interval`을 더해 얻은 날짜 또는 시간 정보가 포함된 날짜를 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**날짜에 인터벌 추가**
```sql title=Query theme={null}
SELECT addDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
```
```response title=Response theme={null}
┌─addDate(toDa⋯valYear(3))─┐
│ 2021-01-01 │
└──────────────────────────┘
```
## addDays
도입 버전: v1.1.0
지정한 일 수를 날짜, 날짜 및 시간, 또는 문자열로 표현된 날짜나 날짜 및 시간 값에 더합니다.
**구문**
```sql theme={null}
addDays(datetime, num)
```
**인수**
* `datetime` — 지정한 일 수를 더할 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 추가할 일 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에 `num`일을 더한 값을 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜 타입에 일 수 추가**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 day)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯valDay(10))─┐
│ 1998-06-26 │
└──────────────────────────┘
```
## addHours
도입 버전: v1.1.0
지정한 수의 시간을 날짜, 시간이 포함된 날짜 또는 문자열로 인코딩된 날짜나 시간이 포함된 날짜에 더합니다.
**구문**
```sql theme={null}
addHours(datetime, num)
```
**인수**
* `datetime` — 지정된 수의 시간을 더할 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 더할 시간의 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에 `num`시간을 더한 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64(3)`](/ko/reference/data-types/datetime64)
**예시**
**다양한 날짜 타입에 시간 추가**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 hour)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯alHour(10))─┐
│ 1998-06-16 10:00:00 │
└──────────────────────────┘
```
## addInterval
도입 버전: v22.11.0
하나의 인터벌을 다른 인터벌 또는 인터벌의 튜플에 더합니다.
동일한 유형의 인터벌은 하나의 인터벌로 합쳐집니다. 예를 들어 `toIntervalDay(1)`과 `toIntervalDay(2)`를 전달하면 결과는 `(1,1)`이 아니라 `(3)`이 됩니다.
**구문**
```sql theme={null}
addInterval(interval_1, interval_2)
```
**인수**
* `interval_1` — 첫 번째 인터벌 또는 인터벌 튜플입니다. [`Interval`](/ko/reference/data-types/int-uint) 또는 [`Tuple(Interval)`](/ko/reference/data-types/tuple)
* `interval_2` — 추가할 두 번째 인터벌입니다. [`Interval`](/ko/reference/data-types/int-uint)
**반환 값**
인터벌 튜플 [`Tuple(Interval)`](/ko/reference/data-types/tuple)을 반환합니다.
**예시**
**인터벌 추가**
```sql title=Query theme={null}
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)
```
```response title=Response theme={null}
┌─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
날짜와 시간이 포함된 값 또는 문자열로 인코딩된 날짜/시간 값에 지정한 개수의 마이크로초를 추가합니다.
**구문**
```sql theme={null}
addMicroseconds(datetime, num)
```
**인수**
* `datetime` — 지정한 개수의 마이크로초를 더할 날짜-시간 값입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 더할 마이크로초 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`date_time`에 `num` 마이크로초를 더한 값인 [`DateTime64`](/ko/reference/data-types/datetime64)를 반환합니다.
**예시**
**서로 다른 날짜-시간 타입에 마이크로초 추가**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용하기**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 microsecond)
```
```response title=Response theme={null}
┌─plus(CAST('19⋯osecond(10))─┐
│ 1998-06-16 00:00:00.000010 │
└────────────────────────────┘
```
## addMilliseconds
도입 버전: v22.6.0
날짜와 시간이 포함된 값 또는 날짜와 시간이 포함된 문자열 값에 지정한 밀리초 수를 추가합니다.
**구문**
```sql theme={null}
addMilliseconds(datetime, num)
```
**인수**
* `datetime` — 지정된 밀리초 수를 더할 날짜 및 시간입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 더할 밀리초 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에 `num`밀리초를 더한 값을 반환합니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜/시간 타입에 밀리초 추가**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 millisecond)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯second(10))─┐
│ 1998-06-16 00:00:00.010 │
└──────────────────────────┘
```
## addMinutes
도입 버전: v1.1.0
날짜, 날짜 및 시간, 또는 문자열로 인코딩된 날짜나 날짜 및 시간에 지정된 분 수를 더합니다.
**구문**
```sql theme={null}
addMinutes(datetime, num)
```
**인수**
* `datetime` — 지정된 분 수를 더할 날짜 또는 시간 정보가 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 더할 분 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에 `num`분을 더한 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64(3)`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜 타입에 분 추가**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용하기**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 minute)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯Minute(10))─┐
│ 1998-06-16 00:10:00 │
└──────────────────────────┘
```
## addMonths
도입 버전: v1.1.0
지정한 개월 수를 날짜, 날짜 및 시간, 또는 문자열로 인코딩된 날짜/날짜 및 시간 값에 더합니다.
**구문**
```sql theme={null}
addMonths(datetime, num)
```
**인수**
* `datetime` — 지정된 개수의 월을 더할 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 더할 월 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에 `num`개월을 더한 값을 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**여러 날짜 타입에 월 추가하기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 month)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯lMonth(10))─┐
│ 1999-04-16 │
└──────────────────────────┘
```
## addNanoseconds
도입 버전: v22.6.0
지정한 개수의 나노초를 시간이 포함된 날짜 값 또는 문자열로 인코딩된 날짜-시간 값에 더합니다.
**구문**
```sql theme={null}
addNanoseconds(datetime, num)
```
**인수**
* `datetime` — 지정한 개수의 나노초를 더할 날짜/시간 값입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 더할 나노초의 개수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에 `num` 나노초를 더한 값을 반환합니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜/시간 타입에 나노초 추가**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용하기**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 1000 nanosecond)
```
```response title=Response theme={null}
┌─plus(CAST('199⋯osecond(1000))─┐
│ 1998-06-16 00:00:00.000001000 │
└───────────────────────────────┘
```
## addQuarters
도입 버전: v20.1.0
날짜, 날짜 및 시간, 또는 문자열로 인코딩된 날짜나 날짜 및 시간에 지정한 개수의 분기를 추가합니다.
**구문**
```sql theme={null}
addQuarters(datetime, num)
```
**인수**
* `datetime` — 지정한 개수의 분기를 더할 날짜 또는 날짜/시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 더할 분기의 개수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에 `num`개 분기를 더한 값을 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**여러 날짜 타입에 분기 추가**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 quarter)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯uarter(10))─┐
│ 2000-12-16 │
└──────────────────────────┘
```
## addSeconds
도입 버전: v1.1.0
날짜, 시간 정보가 포함된 날짜, 또는 문자열로 인코딩된 날짜나 시간 정보가 포함된 날짜에 지정된 초 수를 더합니다.
**구문**
```sql theme={null}
addSeconds(datetime, num)
```
**인수**
* `datetime` — 지정한 초 수를 더할 날짜 또는 시간 정보가 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 더할 초 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에 `num`초를 더한 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64(3)`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜 타입에 초를 추가**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용하기**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 second)
```
```response title=Response theme={null}
┌─dateAdd('1998-06-16'::Date, INTERVAL 10 second)─┐
│ 1998-06-16 00:00:10 │
└─────────────────────────────────────────────────┘
```
## addTupleOfIntervals
도입 버전: v22.11.0
날짜 또는 시간 정보가 포함된 날짜에 인터벌 튜플을 순차적으로 더합니다.
**구문**
```sql theme={null}
addTupleOfIntervals(datetime, intervals)
```
**인수**
* `datetime` — 인터벌을 더할 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `intervals` — `datetime`에 더할 인터벌로 구성된 Tuple입니다. [`Tuple(Interval)`](/ko/reference/data-types/tuple)
**반환 값**
`intervals`가 추가된 `date`를 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**날짜에 인터벌 Tuple 추가**
```sql title=Query theme={null}
WITH toDate('2018-01-01') AS date
SELECT addTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 MONTH, INTERVAL 1 YEAR))
```
```response title=Response theme={null}
┌─addTupleOfIntervals(date, (toIntervalDay(1), toIntervalMonth(1), toIntervalYear(1)))─┐
│ 2019-02-02 │
└──────────────────────────────────────────────────────────────────────────────────────┘
```
## addWeeks
도입 버전: v1.1.0
날짜, 시간 정보가 포함된 날짜 또는 문자열로 인코딩된 날짜나 시간 정보가 포함된 날짜에 지정한 주 수를 더합니다.
**구문**
```sql theme={null}
addWeeks(datetime, num)
```
**인수**
* `datetime` — 지정된 주 수를 더할 날짜 또는 날짜와 시간 정보가 포함된 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 더할 주 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에 `num`주를 더한 값을 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜 타입에 주를 더하기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 week)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯alWeek(10))─┐
│ 1998-08-25 │
└──────────────────────────┘
```
## addYears
도입 버전: v1.1.0
날짜, 시간 정보가 포함된 날짜 또는 문자열로 인코딩된 날짜나 시간 정보가 포함된 날짜에 지정한 수의 연도를 더합니다.
**구문**
```sql theme={null}
addYears(datetime, num)
```
**인수**
* `datetime` — 지정한 연 수를 더할 날짜 또는 시간 정보가 포함된 날짜 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 더할 연 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에 `num`년을 더한 값을 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜 타입에 연도 추가**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용**
```sql title=Query theme={null}
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 year)
```
```response title=Response theme={null}
┌─plus(CAST('1⋯alYear(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`](#dateDiff) 함수를 참조하십시오.
**구문**
```sql theme={null}
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`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `enddate` — 여기에서 빼는 대상인 두 번째 시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 선택 사항입니다. 시간대 이름입니다. 지정하면 startdate와 enddate 모두에 적용됩니다. 지정하지 않으면 startdate와 enddate의 시간대가 사용됩니다. 두 값의 시간대가 같지 않으면 결과는 지정되지 않습니다. [`String`](/ko/reference/data-types/string)
**반환 값**
unit으로 표현한 enddate와 startdate의 차이를 반환합니다. [`Int32`](/ko/reference/data-types/int-uint)
**예시**
**시간 단위로 나이 계산**
```sql title=Query theme={null}
SELECT age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))
```
```response title=Response theme={null}
┌─age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))─┐
│ 24 │
└───────────────────────────────────────────────────────────────────────────────────┘
```
**다양한 단위로 나이 계산하기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌──────────e─┬──────────s─┬─day_age─┬─month_age─┬─year_age─┐
│ 2022-01-01 │ 2021-12-29 │ 3 │ 0 │ 0 │
└────────────┴────────────┴─────────┴───────────┴──────────┘
```
## changeDay
도입 버전: v24.7.0
date 또는 날짜-시간 값의 일 구성 요소를 변경합니다.
**구문**
```sql theme={null}
changeDay(date_or_datetime, value)
```
**인수**
* `date_or_datetime` — 변경할 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `value` — 새 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
`date_or_datetime`와 동일한 유형이며, 일(day) 값이 수정된 값을 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT changeDay('2024-01-31'::DateTime, 15)
```
```response title=Response theme={null}
2024-01-15 00:00:00
```
## changeHour
도입 버전: v24.7.0
date 또는 날짜-시간 값의 hour 구성 요소를 변경합니다.
**구문**
```sql theme={null}
changeHour(date_or_datetime, value)
```
**인수**
* `date_or_datetime` — 변경할 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `value` — 새로운 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
시(hour) 구성 요소가 수정된, `date_or_datetime`와 동일한 타입의 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT changeHour('2024-01-01 12:00:00'::DateTime, 5)
```
```response title=Response theme={null}
2024-01-01 05:00:00
```
## changeMinute
도입 버전: v24.7.0
`date or date 날짜-시간` 값의 분 구성 요소를 변경합니다.
**구문**
```sql theme={null}
changeMinute(date_or_datetime, value)
```
**인수**
* `date_or_datetime` — 변경할 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `value` — 새 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
분 구성 요소가 수정된, `date_or_datetime`와 동일한 타입의 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT changeMinute('2024-01-01 12:30:00'::DateTime, 45)
```
```response title=Response theme={null}
2024-01-01 12:45:00
```
## changeMonth
도입 버전: v24.7.0
날짜 또는 날짜-시간 값의 월 구성 요소를 변경합니다.
**구문**
```sql theme={null}
changeMonth(date_or_datetime, value)
```
**인수**
* `date_or_datetime` — 변경할 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `value` — 새 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
월 구성 요소가 수정된, `date_or_datetime`와 동일한 타입의 값을 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT changeMonth('2024-01-01'::DateTime, 12)
```
```response title=Response theme={null}
2024-12-01 00:00:00
```
## changeSecond
도입 버전: v24.7.0
날짜 또는 날짜-시간 값의 초 구성 요소를 변경합니다.
**구문**
```sql theme={null}
changeSecond(date_or_datetime, value)
```
**인수**
* `date_or_datetime` — 변경할 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `value` — 새 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
초 구성 요소가 수정된 `date_or_datetime`와 동일한 타입의 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT changeSecond('2024-01-01 12:30:45'::DateTime, 15)
```
```response title=Response theme={null}
2024-01-01 12:30:15
```
## changeYear
도입 버전: v24.7.0
date 또는 날짜-시간 값의 연도 구성 요소를 변경합니다.
**구문**
```sql theme={null}
changeYear(date_or_datetime, value)
```
**인수**
* `date_or_datetime` — 변경할 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `value` — 새 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
연도 구성 요소가 수정된, `date_or_datetime`와 동일한 타입의 값을 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT changeYear('2024-01-01'::DateTime, 2023)
```
```response title=Response theme={null}
2023-01-01 00:00:00
```
## dateDiff
도입 버전: v23.4.0
지정한 `unit`를 기준으로 `startdate`와 `enddate` 사이에서 경계를 몇 번 지났는지 반환합니다.
차이는 상대 단위를 사용해 계산됩니다. 예를 들어 2021-12-29와 2022-01-01 사이의 차이는 unit이 day이면 3일
([`toRelativeDayNum`](#toRelativeDayNum) 참조), unit이 month이면 1개월 ([`toRelativeMonthNum`](#toRelativeMonthNum) 참조), unit이 year이면 1년입니다
([`toRelativeYearNum`](#toRelativeYearNum) 참조).
unit으로 `week`를 지정하면 `dateDiff`는 주가 월요일에 시작한다고 가정합니다.
이 동작은 기본적으로 주가 일요일에 시작하는 `toWeek()` 함수와 다르다는 점에 유의하십시오.
`dateDiff`의 대안으로 [`age`](#age) 함수를 참조하십시오.
**구문**
```sql theme={null}
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`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `enddate` — 여기에서 빼기를 수행하는 두 번째 시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 선택 사항입니다. 시간대 이름입니다. 지정하면 `startdate`와 `enddate` 모두에 적용됩니다. 지정하지 않으면 `startdate`와 `enddate`의 시간대가 사용됩니다. 두 값의 시간대가 서로 다르면 결과는 정의되지 않습니다. [`String`](/ko/reference/data-types/string)
**반환 값**
`unit`로 표현한 `enddate`와 `startdate`의 차이를 반환합니다. [`Int64`](/ko/reference/data-types/int-uint)
**예시**
**시간 단위로 날짜 차이 계산**
```sql title=Query theme={null}
SELECT dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res
```
```response title=Response theme={null}
┌─res─┐
│ 25 │
└─────┘
```
**다양한 단위로 날짜 차이 계산**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌──────────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'
**구문**
```sql theme={null}
dateName(date_part, date[, timezone])
```
**인수**
* `date_part` — 추출할 날짜의 부분입니다. [`String`](/ko/reference/data-types/string)
* `datetime` — 날짜 또는 시간이 포함된 날짜 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 선택 사항입니다. 시간대입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
지정된 날짜 부분을 반환합니다. [`String`](/ko/reference/data-types/string)
**예시**
**다양한 날짜 부분 추출**
```sql title=Query theme={null}
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT
dateName('year', date_value),
dateName('month', date_value),
dateName('day', date_value)
```
```response title=Response theme={null}
┌─dateName('year', date_value)─┬─dateName('month', date_value)─┬─dateName('day', date_value)─┐
│ 2021 │ April │ 14 │
└──────────────────────────────┴───────────────────────────────┴─────────────────────────────┘
```
## dateTrunc
도입 버전: v20.8.0
날짜 및 시간 값을 지정된 날짜 단위로 절삭합니다.
**구문**
```sql theme={null}
dateTrunc(unit, datetime[, timezone])
```
**별칭**: `DATE_TRUNC`
**인수**
* `unit` —
결과를 잘라낼 인터벌의 유형입니다. 가능한 값: `nanosecond` (DateTime64에서만 지원), `microsecond` (DateTime64에서만 지원), `millisecond` (DateTime64에서만 지원), `second`, `minute`, `hour`, `day`, `week`, `month`, `quarter`, `year`.
[`String`](/ko/reference/data-types/string)
* `datetime` — 날짜 및 시간입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 선택 사항입니다. 반환할 datetime의 시간대 이름입니다. 지정하지 않으면 함수는 `datetime` 매개변수의 시간대를 사용합니다. [`String`](/ko/reference/data-types/string)
**반환 값**
잘라낸 날짜 및 시간 값을 반환합니다.
| Unit Argument | `datetime` Argument | Return Type |
| -------------------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------ |
| Year, Quarter, Month, Week | `Date32` or `DateTime64` or `Date` or `DateTime` | [`Date32`](/ko/reference/data-types/date32) or [`Date`](/ko/reference/data-types/date) |
| Day, Hour, Minute, Second | `Date32`, `DateTime64`, `Date`, or `DateTime` | [`DateTime64`](/ko/reference/data-types/datetime64) or [`DateTime`](/ko/reference/data-types/datetime) |
| Millisecond, Microsecond, | Any | [`DateTime64`](/ko/reference/data-types/datetime64) |
| Nanosecond | | with scale 3, 6, or 9 |
**예시**
**시간대 없이 잘라내기**
```sql title=Query theme={null}
SELECT now(), dateTrunc('hour', now());
```
```response title=Response theme={null}
┌───────────────now()─┬─dateTrunc('hour', now())──┐
│ 2020-09-28 10:40:45 │ 2020-09-28 10:00:00 │
└─────────────────────┴───────────────────────────┘
```
**지정한 시간대 기준으로 자르기**
```sql title=Query theme={null}
SELECT now(), dateTrunc('hour', now(), 'Asia/Istanbul');
```
```response title=Response theme={null}
┌───────────────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 문서](https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_date-format)를 참조하십시오.
이 함수의 반대 연산은 [`parseDateTime`](/ko/reference/functions/regular-functions/type-conversion-functions#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)을 출력합니다.
**구문**
```sql theme={null}
formatDateTime(datetime, format[, timezone])
```
**별칭**: `DATE_FORMAT`
**인수**
* `datetime` — 포맷할 날짜 또는 날짜-시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `format` — 대체 필드가 포함된 포맷 문자열입니다. [`String`](/ko/reference/data-types/string)
* `timezone` — 선택 사항입니다. 포맷된 시간에 사용할 시간대 이름입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
지정된 포맷에 따라 시간 및 날짜 값을 반환합니다. [`String`](/ko/reference/data-types/string)
**예시**
**연도 플레이스홀더를 사용해 날짜 포맷하기**
```sql title=Query theme={null}
SELECT formatDateTime(toDate('2010-01-04'), '%g')
```
```response title=Response theme={null}
┌─formatDateTime(toDate('2010-01-04'), '%g')─┐
│ 10 │
└────────────────────────────────────────────┘
```
**소수점 이하 초를 포함한 DateTime64 형식 지정**
```sql title=Query theme={null}
SELECT formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')
```
```response title=Response theme={null}
┌─formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')─┐
│ 1234560 │
└─────────────────────────────────────────────────────────────────────┘
```
**시간대가 포함된 포맷**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌──────────────────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](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html)을 참조하십시오.
이 함수의 반대 연산은 [`parseDateTimeInJodaSyntax`](/ko/reference/functions/regular-functions/type-conversion-functions#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 |
| ' | 텍스트 이스케이프 | 구분자 | |
| '' | 작은따옴표 | 리터럴 | ' |
**구문**
```sql theme={null}
formatDateTimeInJodaSyntax(datetime, format[, timezone])
```
**인수**
* `datetime` — 포맷할 날짜 또는 날짜/시간 값입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `format` — Joda 스타일 대체 필드가 포함된 포맷 문자열입니다. [`String`](/ko/reference/data-types/string)
* `timezone` — 선택 사항입니다. 포맷된 시간에 사용할 시간대 이름입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
지정된 포맷에 따른 시간 및 날짜 값을 반환합니다. [`String`](/ko/reference/data-types/string)
**예시**
**Joda 문법을 사용하여 datetime 포맷하기**
```sql title=Query theme={null}
SELECT formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')
```
```response title=Response theme={null}
┌─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일](https://en.wikipedia.org/wiki/Year_zero)부터 경과한 일수가 주어지면, [ISO 8601에서 정의한 프로렙틱 그레고리력](https://en.wikipedia.org/wiki/Gregorian_calendar#Proleptic_Gregorian_calendar) 기준의 해당 날짜를 반환합니다.
이 계산은 MySQL의 `FROM_DAYS()` 함수와 동일합니다. 결과를 [Date](/ko/reference/data-types/date) 타입의 범위 내에서 표현할 수 없으면 결과는 정의되지 않습니다.
**구문**
```sql theme={null}
fromDaysSinceYearZero(days)
```
**별칭**: `FROM_DAYS`
**인수**
* `days` — 0년부터 경과한 일수입니다. [`UInt32`](/ko/reference/data-types/int-uint)
**반환 값**
0년부터 경과한 일수에 해당하는 날짜를 반환합니다. [`Date`](/ko/reference/data-types/date)
**예시**
**0년부터 경과한 일수를 날짜로 변환합니다**
```sql title=Query theme={null}
SELECT
fromDaysSinceYearZero(739136) AS date1,
fromDaysSinceYearZero(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
```
```response title=Response theme={null}
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
```
## fromDaysSinceYearZero32
도입 버전: v23.11.0
[0000년 1월 1일](https://en.wikipedia.org/wiki/Year_zero)부터 경과한 지정된 일 수에 해당하는 [ISO 8601에서 정의한 프로렙틱 그레고리력](https://en.wikipedia.org/wiki/Gregorian_calendar#Proleptic_Gregorian_calendar)상의 날짜를 반환합니다.
계산 방식은 MySQL의 `FROM_DAYS()` 함수와 동일합니다. 결과를 [`Date32`](/ko/reference/data-types/date32) 타입의 범위 내에서 표현할 수 없으면 결과는 정의되지 않습니다.
**구문**
```sql theme={null}
fromDaysSinceYearZero32(days)
```
**인수**
* `days` — 0년 기준 경과한 일수입니다. [`UInt32`](/ko/reference/data-types/int-uint)
**반환 값**
0년 기준 경과한 일수에 해당하는 날짜를 반환합니다. [`Date32`](/ko/reference/data-types/date32)
**예시**
**0년 기준 일수를 날짜로 변환**
```sql title=Query theme={null}
SELECT
fromDaysSinceYearZero32(739136) AS date1,
fromDaysSinceYearZero32(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
```
```response title=Response theme={null}
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
```
## fromModifiedJulianDay
도입 버전: v21.1.0
[수정 율리우스일](https://en.wikipedia.org/wiki/Julian_day#Variants) 값을 텍스트 형식의 `YYYY-MM-DD` [프로렙틱 그레고리력](https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar) 날짜로 변환합니다. 이 함수는 `-678941`부터 `2973483`까지의 일 수를 지원하며(각각 0000-01-01 및 9999-12-31에 해당), 일 수가 지원 범위를 벗어나면 예외를 발생시킵니다.
**구문**
```sql theme={null}
fromModifiedJulianDay(day)
```
**인수**
* `day` — 수정 율리우스일 번호입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
날짜를 텍스트 형식으로 반환합니다. [`String`](/ko/reference/data-types/string)
**예시**
**수정 율리우스일을 날짜로 변환합니다**
```sql title=Query theme={null}
SELECT fromModifiedJulianDay(58849)
```
```response title=Response theme={null}
┌─fromModifiedJulianDay(58849)─┐
│ 2020-01-01 │
└──────────────────────────────┘
```
## fromModifiedJulianDayOrNull
도입 버전: v21.1.0
[`fromModifiedJulianDay()`](#fromModifiedJulianDay)와 유사하지만, 예외를 발생시키는 대신 `NULL`을 반환합니다.
**구문**
```sql theme={null}
fromModifiedJulianDayOrNull(day)
```
**인수**
* `day` — 수정 율리우스일 번호. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
`day` 인수가 유효하면 문자열 형식의 날짜를 반환하고, 그렇지 않으면 `null`을 반환합니다. [`Nullable(String)`](/ko/reference/data-types/nullable)
**예시**
**수정 율리우스일을 날짜로 변환하고 null 처리하기**
```sql title=Query theme={null}
SELECT fromModifiedJulianDayOrNull(58849);
SELECT fromModifiedJulianDayOrNull(60000000); -- 유효하지 않은 인수, NULL 반환
```
```response title=Response theme={null}
┌─fromModified⋯Null(58849)─┐
│ 2020-01-01 │
└──────────────────────────┘
┌─fromModified⋯l(60000000)─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
```
## fromUTCTimestamp
도입 버전: v22.1.0
UTC 시간대의 날짜 또는 날짜/시간 값을 지정한 시간대의 날짜 또는 날짜/시간 값으로 변환합니다. 이 함수는 주로 Apache Spark 및 이와 유사한 프레임워크와의 호환성을 위해 제공됩니다.
**구문**
```sql theme={null}
fromUTCTimestamp(datetime, time_zone)
```
**별칭**: `from_utc_timestamp`
**인수**
* `datetime` — 날짜 또는 시간 정보가 포함된 날짜의 상수 값이나 표현식입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `time_zone` — 시간대를 나타내는 String 타입의 상수 값이나 표현식입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
지정된 시간대의 DateTime/DateTime64를 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**UTC 시간대를 지정한 시간대로 변환**
```sql title=Query theme={null}
SELECT fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00', 3), 'Asia/Shanghai')
```
```response title=Response theme={null}
┌─fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00',3), 'Asia/Shanghai')─┐
│ 2023-03-16 18:00:00.000 │
└─────────────────────────────────────────────────────────────────────────┘
```
## fromUnixTimestamp
도입된 버전: v20.8.0
이 함수는 Unix 타임스탬프를 달력 날짜와 시간으로 변환합니다.
이 함수는 두 가지 방식으로 호출할 수 있습니다.
* [`Integer`](/ko/reference/data-types/int-uint) 타입의 단일 인수가 주어지면 [`DateTime`](/ko/reference/data-types/datetime) 타입의 값을 반환합니다. 즉, [`toDateTime`](/ko/reference/functions/regular-functions/type-conversion-functions#toDateTime)처럼 동작합니다.
* 2개 또는 3개의 인수가 주어질 때, 첫 번째 인수가 [`Integer`](/ko/reference/data-types/int-uint), [`Date`](/ko/reference/data-types/date), [`Date32`](/ko/reference/data-types/date32), [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 타입의 값이고, 두 번째 인수가 상수 포맷 문자열이며, 세 번째 인수가 선택적 상수 시간대 문자열이면 이 함수는 [`String`](/ko/reference/data-types/string) 타입의 값을 반환합니다. 즉, [`formatDateTime`](#formatDateTime)처럼 동작합니다.
이 경우 [MySQL의 datetime 포맷 스타일](https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_date-format)을 사용합니다.
**구문**
```sql theme={null}
fromUnixTimestamp(timestamp)
fromUnixTimestamp(timestamp[, format[, timezone]])
```
**별칭**: `FROM_UNIXTIME`
**인수**
* `timestamp` — Unix 타임스탬프 또는 날짜/날짜 및 시간 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `format` — 선택 사항입니다. 출력 형식 지정을 위한 상수 포맷 문자열입니다. [`String`](/ko/reference/data-types/string)
* `timezone` — 선택 사항입니다. 상수 시간대 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
인수가 하나이면 해당 timestamp의 `DateTime`을 반환하고, 인수가 두 개 또는 세 개이면 `String`을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`String`](/ko/reference/data-types/string)
**예시**
**Unix 타임스탬프를 DateTime으로 변환**
```sql title=Query theme={null}
SELECT fromUnixTimestamp(423543535)
```
```response title=Response theme={null}
┌─fromUnixTimestamp(423543535)─┐
│ 1983-06-04 10:58:55 │
└──────────────────────────────┘
```
**포맷을 사용한 Unix 타임스탬프 변환**
```sql title=Query theme={null}
SELECT fromUnixTimestamp(1234334543, '%Y-%m-%d %R:%S') AS DateTime
```
```response title=Response theme={null}
┌─DateTime────────────┐
│ 2009-02-11 14:42:23 │
└─────────────────────┘
```
## fromUnixTimestampInJodaSyntax
도입 버전: v23.1.0
이 함수는 Unix 타임스탬프를 날짜와 시각으로 변환합니다.
다음 두 가지 방식으로 호출할 수 있습니다:
[`Integer`](/ko/reference/data-types/int-uint) 타입의 단일 인수가 주어지면 [`DateTime`](/ko/reference/data-types/datetime) 타입의 값을 반환합니다. 즉, [`toDateTime`](/ko/reference/functions/regular-functions/type-conversion-functions#toDateTime)처럼 동작합니다.
2개 또는 3개의 인수가 주어지고 첫 번째 인수가 [`Integer`](/ko/reference/data-types/int-uint), [`Date`](/ko/reference/data-types/date), [`Date32`](/ko/reference/data-types/date32), [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 타입의 값이며, 두 번째 인수가 상수 포맷 문자열이고 세 번째 인수가 선택적 상수 시간대 문자열이면, 이 함수는 [`String`](/ko/reference/data-types/string) 타입의 값을 반환합니다. 즉, [`formatDateTimeInJodaSyntax`](#formatDateTimeInJodaSyntax)처럼 동작합니다. 이 경우 [Joda datetime format style](https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html)을 사용합니다.
**구문**
```sql theme={null}
fromUnixTimestampInJodaSyntax(timestamp)
fromUnixTimestampInJodaSyntax(timestamp, format[, timezone])
```
**인수**
* `timestamp` — Unix 타임스탬프 또는 날짜/시간 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `format` — 선택 사항입니다. 출력 형식 지정에 사용하는 Joda 문법 기반의 상수 포맷 문자열입니다. [`String`](/ko/reference/data-types/string)
* `timezone` — 선택 사항입니다. 상수 시간대 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
인수가 1개이면 날짜와 시간이 포함된 값을 반환하고, 인수가 2개 또는 3개이면 String을 반환합니다.} [`DateTime`](/ko/reference/data-types/datetime) 또는 [`String`](/ko/reference/data-types/string)
**예시**
**Joda 포맷으로 Unix 타임스탬프 변환**
```sql title=Query theme={null}
SELECT fromUnixTimestampInJodaSyntax(1234334543, 'yyyy-MM-dd HH:mm:ss', 'UTC') AS DateTime
```
```response title=Response theme={null}
┌─DateTime────────────┐
│ 2009-02-11 06:42:23 │
└─────────────────────┘
```
## localtime
도입 버전: v26.7.0
쿼리 분석 시점의 서버(또는 세션) 시간대에서 현재 시각을 반환합니다.
이 함수는 상수 표현식입니다. SQL 표준 / PostgreSQL `LOCALTIME`이며, `CAST(now() AS Time)`와 동일합니다.
**구문**
```sql theme={null}
localtime()
```
**인수**
* None.
**반환 값**
현재 시간을 반환합니다. [`Time`](/ko/reference/data-types/time)
**예시**
**괄호 없는 SQL 표준 구문**
```sql title=Query theme={null}
SELECT LOCALTIME
```
```response title=Response theme={null}
┌───────LOCALTIME─┐
│ 07:42:09 │
└─────────────────┘
```
## makeDate
도입 버전: v22.6.0
다음 중 하나를 사용해 `Date`를 생성합니다.
* 연도, 월, 일
* 연도와 해당 연도의 일자
**구문**
```sql theme={null}
makeDate(year, month, day)
makeDate(year, day_of_year)
```
**인수**
* `year` — 연도 번호입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `month` — 월 번호입니다(1-12). [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `day` — 날짜의 일 번호입니다(1-31). [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `day_of_year` — 연중 일 번호입니다(1-365). [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
**반환 값**
제공된 인수로 구성한 `Date` 값을 반환합니다 [`Date`](/ko/reference/data-types/date)
**예시**
**연도, 월, 일로 Date 생성**
```sql title=Query theme={null}
SELECT makeDate(2023, 2, 28) AS date;
```
```response title=Response theme={null}
┌───────date─┐
│ 2023-02-28 │
└────────────┘
```
**연도와 연중 일수로 날짜 만들기**
```sql title=Query theme={null}
SELECT makeDate(2023, 42) AS date;
```
```response title=Response theme={null}
┌───────date─┐
│ 2023-02-11 │
└────────────┘
```
## makeDate32
도입 버전: v22.6.0
다음 중 하나를 사용해 `Date32`를 생성합니다.
* 연, 월, 일
* 연도와 연중 일수
**구문**
```sql theme={null}
makeDate32(year, month, day)
makeDate32(year, day_of_year)
```
**인수**
* `year` — 연도 번호입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `month` — 월 번호(1-12)입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `day` — 일(1-31)입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `day_of_year` — 연중 날짜 번호(1-365)입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
**반환 값**
주어진 인수로 생성된 `Date32` 값을 반환합니다. [`Date32`](/ko/reference/data-types/date32)
**예시**
**연, 월, 일로 Date32 생성**
```sql title=Query theme={null}
SELECT makeDate(2023, 2, 28) AS date;
```
```response title=Response theme={null}
┌───────date─┐
│ 2023-02-28 │
└────────────┘
```
**연도와 연중 일수로 Date32 만들기**
```sql title=Query theme={null}
SELECT makeDate(2023, 42) AS date;
```
```response title=Response theme={null}
┌───────date─┐
│ 2023-02-11 │
└────────────┘
```
## makeDateTime
도입 버전: v22.6.0
연, 월, 일, 시, 분, 초와 선택적 시간대를 사용해 `DateTime`을 생성합니다.
**구문**
```sql theme={null}
makeDateTime(year, month, day, hour, minute, second[, timezone])
```
**인수**
* `year` — 연도. [`(U)Int*`](/ko/reference/data-types/int-uint) or [`Float*`](/ko/reference/data-types/float) or [`Decimal`](/ko/reference/data-types/decimal)
* `month` — 월(1-12). [`(U)Int*`](/ko/reference/data-types/int-uint) or [`Float*`](/ko/reference/data-types/float) or [`Decimal`](/ko/reference/data-types/decimal)
* `day` — 일(1-31). [`(U)Int*`](/ko/reference/data-types/int-uint) or [`Float*`](/ko/reference/data-types/float) or [`Decimal`](/ko/reference/data-types/decimal)
* `hour` — 시(0-23). [`(U)Int*`](/ko/reference/data-types/int-uint) or [`Float*`](/ko/reference/data-types/float) or [`Decimal`](/ko/reference/data-types/decimal)
* `minute` — 분(0-59). [`(U)Int*`](/ko/reference/data-types/int-uint) or [`Float*`](/ko/reference/data-types/float) or [`Decimal`](/ko/reference/data-types/decimal)
* `second` — 초(0-59). [`(U)Int*`](/ko/reference/data-types/int-uint) or [`Float*`](/ko/reference/data-types/float) or [`Decimal`](/ko/reference/data-types/decimal)
* `timezone` — 시간대 이름. [`String`](/ko/reference/data-types/string)
**반환 값**
주어진 인수로 구성된 `DateTime` 값을 반환합니다 [`DateTime`](/ko/reference/data-types/datetime)
**예시**
**연도, 월, 일, 시, 분, 초로 DateTime 생성**
```sql title=Query theme={null}
SELECT makeDateTime(2023, 2, 28, 17, 12, 33) AS DateTime;
```
```response title=Response theme={null}
┌────────────DateTime─┐
│ 2023-02-28 17:12:33 │
└─────────────────────┘
```
## makeDateTime64
도입 버전: v22.6.0
선택적으로 fraction, precision, 시간대를 지정하여 year, month, day, hour, minute, second로 `DateTime64`를 생성합니다.
**구문**
```sql theme={null}
makeDateTime64(year, month, day, hour, minute, second[, fraction[, precision[, timezone]]])
```
**인수**
* `year` — 연도 값. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `month` — 월 값(1-12). [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `day` — 일 값(1-31). [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `hour` — 시 값(0-23). [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `minute` — 분 값(0-59). [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `second` — 초 값(0-59). [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `fraction` — 초의 소수 부분. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`Decimal`](/ko/reference/data-types/decimal)
* `precision` — 소수 부분의 정밀도(0-9). [`UInt8`](/ko/reference/data-types/int-uint)
* `timezone` — 시간대 이름. [`String`](/ko/reference/data-types/string)
**반환 값**
제공된 인수로 구성된 `DateTime64` 값을 반환합니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**연도, 월, 일, 시, 분, 초로 DateTime64 생성**
```sql title=Query theme={null}
SELECT makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5);
```
```response title=Response theme={null}
┌─makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5)─┐
│ 2023-05-15 10:30:45.00779 │
└─────────────────────────────────────────────────┘
```
## monthName
도입 버전: v22.1.0
날짜 또는 날짜/시간 값에서 월 이름을 문자열로 반환합니다.
**구문**
```sql theme={null}
monthName(datetime)
```
**인수**
* `datetime` — 날짜 또는 시간이 포함된 날짜 값. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
월 이름을 반환합니다. [`String`](/ko/reference/data-types/string)
**예시**
**날짜에서 월 이름 추출하기**
```sql title=Query theme={null}
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT monthName(date_value)
```
```response title=Response theme={null}
┌─monthName(date_value)─┐
│ April │
└───────────────────────┘
```
## now
도입 버전: v1.1.0
쿼리 분석 시점의 현재 날짜와 시간을 반환합니다. 이 함수는 상수 표현식입니다.
**구문**
```sql theme={null}
now([timezone])
```
**별칭**: `localtimestamp`, `current_timestamp`
**인수**
* `timezone` — 선택 사항입니다. 반환 값에 사용할 시간대 이름입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
현재 날짜와 시간을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime)
**예시**
**시간대를 지정하지 않은 쿼리**
```sql title=Query theme={null}
SELECT now()
```
```response title=Response theme={null}
┌───────────────now()─┐
│ 2020-10-17 07:42:09 │
└─────────────────────┘
```
**시간대를 지정한 쿼리**
```sql title=Query theme={null}
SELECT now('Asia/Istanbul')
```
```response title=Response theme={null}
┌─now('Asia/Istanbul')─┐
│ 2020-10-17 10:42:23 │
└──────────────────────┘
```
**괄호 없는 SQL 표준 구문**
```sql title=Query theme={null}
SELECT NOW, CURRENT_TIMESTAMP
```
```response title=Response theme={null}
┌─────────────────NOW─┬───CURRENT_TIMESTAMP─┐
│ 2020-10-17 07:42:19 │ 2020-10-17 07:42:19 │
└─────────────────────┴─────────────────────┘
```
## now64
도입 버전: v20.1.0
쿼리 분석 시점의 현재 날짜 및 시간을 초 미만 정밀도로 반환합니다. 이 함수는 상수 표현식입니다.
**구문**
```sql theme={null}
now64([scale[, timezone]])
```
**인수**
* `scale` — 선택 사항입니다. tick 크기(정밀도)입니다. `10^-precision`초입니다. 유효 범위는 \[0 : 9]입니다. 일반적으로 3(기본값, 밀리초), 6(마이크로초), 9(나노초)를 사용합니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `timezone` — 선택 사항입니다. 반환 값의 시간대 이름입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
밀리초 미만 정밀도를 포함한 현재 날짜 및 시간을 반환합니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**기본값 및 사용자 지정 정밀도를 사용하는 쿼리**
```sql title=Query theme={null}
SELECT now64(), now64(9, 'Asia/Istanbul')
```
```response title=Response theme={null}
┌─────────────────now64()─┬─────now64(9, 'Asia/Istanbul')─┐
│ 2022-08-21 19:34:26.196 │ 2022-08-21 22:34:26.196542766 │
└─────────────────────────┴───────────────────────────────┘
```
## nowInBlock
도입 버전: v22.8.0
각 데이터 블록의 처리 시점에 해당하는 현재 날짜와 시간을 반환합니다. [`now`](#now) 함수와 달리 상수 표현식이 아니므로, 장시간 실행되는 쿼리에서는 블록마다 반환 값이 달라집니다.
장시간 실행되는 `INSERT SELECT` 쿼리에서 현재 시간을 생성할 때 이 함수를 사용하는 것이 적절합니다.
**구문**
```sql theme={null}
nowInBlock([timezone])
```
**인수**
* `timezone` — 선택 사항입니다. 반환 값에 사용할 시간대 이름입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
각 데이터 블록의 처리 시점 기준 현재 날짜와 시간을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime)
**예시**
**now() 함수와의 차이점**
```sql title=Query theme={null}
SELECT
now(),
nowInBlock(),
sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock
```
```response title=Response theme={null}
┌───────────────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](#now64) 함수와 달리 상수 표현식이 아니므로, 장시간 실행되는 쿼리에서는 블록마다 반환 값이 달라집니다.
장시간 실행되는 INSERT SELECT 쿼리에서 현재 시간을 생성할 때는 이 함수를 사용하는 것이 좋습니다.
**구문**
```sql theme={null}
nowInBlock64([scale[, timezone]])
```
**인수**
* `scale` — 선택 사항입니다. 틱 크기(precision)입니다: 10^-precision초입니다. 유효 범위는 \[0 : 9]입니다. 일반적으로 3(기본값, 밀리초), 6(마이크로초), 9(나노초)를 사용합니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `timezone` — 선택 사항입니다. 반환 값에 사용할 시간대 이름입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
각 데이터 블록을 처리하는 시점의 현재 날짜와 시간을 초 미만 정밀도로 반환합니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**`now64()` 함수와의 차이점**
```sql title=Query theme={null}
SELECT
now64(),
nowInBlock64(),
sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock
```
```response title=Response theme={null}
┌─────────────────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`](/ko/reference/settings/server-settings/settings#timezone) 설정 값을 반환합니다.
함수가 분산 테이블에서 실행되면 각 세그먼트에 해당하는 값을 가진 일반 컬럼을 생성합니다. 그렇지 않으면 상수 값을 생성합니다.
**구문**
```sql theme={null}
serverTimezone()
```
**별칭**: `serverTimeZone`
**인수**
* 없음.
**반환 값**
서버의 시간대를 [`String`](/ko/reference/data-types/string)으로 반환합니다.
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT serverTimeZone()
```
```response title=Response theme={null}
┌─serverTimeZone()─┐
│ UTC │
└──────────────────┘
```
## subDate
도입 버전: v23.9.0
지정된 날짜, 날짜 및 시간, 또는 문자열로 인코딩된 날짜나 날짜 및 시간에서 시간 인터벌을 뺍니다.
뺄셈 결과가 데이터 타입의 범위를 벗어나면 결과는 정의되지 않습니다.
**구문**
```sql theme={null}
subDate(datetime, interval)
```
**인수**
* `datetime` — `interval`을 차감할 날짜 또는 날짜/시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `interval` — 차감할 인터벌입니다. [`Interval`](/ko/reference/data-types/int-uint)
**반환 값**
`datetime`에서 `interval`을 차감해 얻은 날짜 또는 날짜/시간 값을 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**날짜에서 인터벌 차감**
```sql title=Query theme={null}
SELECT subDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
```
```response title=Response theme={null}
┌─subDate(toDate('2018-01-01'), toIntervalYear(3))─┐
│ 2015-01-01 │
└──────────────────────────────────────────────────┘
```
## subtractDays
도입 버전: v1.1.0
날짜, 시간 정보가 포함된 날짜, 또는 문자열로 인코딩된 날짜나 시간 정보가 포함된 날짜에서 지정한 일 수를 뺍니다.
**구문**
```sql theme={null}
subtractDays(datetime, num)
```
**인수**
* `datetime` — 지정한 일 수를 뺄 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 뺄 일 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에서 `num`일을 뺀 값을 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**다양한 날짜 타입에서 일 수 빼기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 day)
```
```response title=Response theme={null}
┌─minus(CAST('⋯valDay(10))─┐
│ 1998-06-06 │
└──────────────────────────┘
```
## subtractHours
도입 버전: v1.1.0
날짜, 시간이 포함된 날짜 또는 문자열로 인코딩된 날짜나 시간이 포함된 날짜에서 지정된 시간 수를 뺍니다.
**구문**
```sql theme={null}
subtractHours(datetime, num)
```
**인수**
* `datetime` — 지정한 시간 수만큼 뺄 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 뺄 시간 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에서 `num`시간을 뺀 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64(3)`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜 타입에서 시간 빼기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 hour)
```
```response title=Response theme={null}
┌─minus(CAST('⋯alHour(10))─┐
│ 1998-06-15 14:00:00 │
└──────────────────────────┘
```
## subtractInterval
도입 버전: v22.11.0
음수로 변환한 인터벌을 다른 인터벌 또는 인터벌의 튜플에 더합니다.
참고: 같은 유형의 인터벌은 하나의 인터벌로 합쳐집니다. 예를 들어 `toIntervalDay(2)`와 `toIntervalDay(1)`이
전달되면 결과는 `(2,1)`이 아니라 `(1)`이 됩니다.
**구문**
```sql theme={null}
subtractInterval(interval_1, interval_2)
```
**인수**
* `interval_1` — 첫 번째 인터벌 또는 인터벌의 튜플입니다. [`Interval`](/ko/reference/data-types/int-uint) 또는 [`Tuple(Interval)`](/ko/reference/data-types/tuple)
* `interval_2` — 부호를 반전할 두 번째 인터벌입니다. [`Interval`](/ko/reference/data-types/int-uint)
**반환 값**
인터벌의 튜플 [`Tuple(T)`](/ko/reference/data-types/tuple)을 반환합니다.
**예시**
**인터벌 빼기**
```sql title=Query theme={null}
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);
```
```response title=Response theme={null}
┌─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
날짜 및 시간 값 또는 문자열로 인코딩된 날짜 및 시간 값에서 지정한 개수의 마이크로초를 뺍니다.
**구문**
```sql theme={null}
subtractMicroseconds(datetime, num)
```
**인수**
* `datetime` — 지정된 개수의 마이크로초를 뺄 날짜 및 시간입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 뺄 마이크로초의 개수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에서 `num` 마이크로초를 뺀 값을 반환합니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜/시간 타입에서 마이크로초 빼기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 microsecond)
```
```response title=Response theme={null}
┌─minus(CAST('1⋯osecond(10))─┐
│ 1998-06-15 23:59:59.999990 │
└────────────────────────────┘
```
## subtractMilliseconds
도입 버전: v22.6.0
날짜 및 시간 값 또는 문자열로 표현된 날짜 및 시간 값에서 지정된 밀리초 수를 뺍니다.
**구문**
```sql theme={null}
subtractMilliseconds(datetime, num)
```
**인수**
* `datetime` — 지정된 밀리초 수를 뺄 날짜/시간 값입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 뺄 밀리초 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에서 `num` 밀리초를 뺀 값을 반환합니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜/시간 타입에서 밀리초 빼기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘
```
**대체 인터벌 구문 사용하기**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 millisecond)
```
```response title=Response theme={null}
┌─minus(CAST('⋯second(10))─┐
│ 1998-06-15 23:59:59.990 │
└──────────────────────────┘
```
## subtractMinutes
도입 버전: v1.1.0
날짜, 시간 정보가 포함된 날짜, 또는 문자열로 인코딩된 날짜나 시간 정보가 포함된 날짜에서 지정된 분 수를 뺍니다.
**구문**
```sql theme={null}
subtractMinutes(datetime, num)
```
**인수**
* `datetime` — 지정한 분 수를 뺄 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 뺄 분 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에서 `num`분을 뺀 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64(3)`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜 타입에서 분 빼기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용하기**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 minute)
```
```response title=Response theme={null}
┌─minus(CAST('⋯Minute(10))─┐
│ 1998-06-15 23:50:00 │
└──────────────────────────┘
```
## subtractMonths
도입 버전: v1.1.0
날짜, 날짜와 시간이 포함된 값 또는 문자열로 인코딩된 날짜나 날짜와 시간이 포함된 값에서 지정된 개월 수를 뺍니다.
**구문**
```sql theme={null}
subtractMonths(datetime, num)
```
**인수**
* `datetime` — 지정한 개월 수를 뺄 날짜 또는 시간이 포함된 날짜 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 뺄 개월 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에서 `num`개월을 뺀 값을 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**다양한 날짜 타입에서 개월 빼기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용하기**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 month)
```
```response title=Response theme={null}
┌─minus(CAST('⋯lMonth(10))─┐
│ 1997-08-16 │
└──────────────────────────┘
```
## subtractNanoseconds
도입 버전: v20.1.0
시간 정보가 포함된 날짜 또는 문자열로 인코딩된 날짜-시간 값에서 지정한 나노초 수를 뺍니다.
**구문**
```sql theme={null}
subtractNanoseconds(datetime, num)
```
**인수**
* `datetime` — 지정된 나노초 수를 뺄 날짜 및 시간입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 뺄 나노초 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에서 `num` 나노초를 뺀 값을 반환합니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜 및 시간 타입에서 나노초 빼기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용하기**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 nanosecond)
```
```response title=Response theme={null}
┌─minus(CAST('19⋯anosecond(10))─┐
│ 1998-06-15 23:59:59.999999990 │
└───────────────────────────────┘
```
## subtractQuarters
도입 버전: v20.1.0
날짜, 시간 정보가 있는 날짜, 또는 문자열로 인코딩된 날짜나 시간 정보가 있는 날짜에서 지정된 개수의 분기를 뺍니다.
**구문**
```sql theme={null}
subtractQuarters(datetime, num)
```
**인수**
* `datetime` — 지정된 개수의 분기를 뺄 날짜 또는 날짜/시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 뺄 분기의 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에서 `num` 분기를 뺀 값을 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**여러 날짜 타입에서 분기 빼기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용하기**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 quarter)
```
```response title=Response theme={null}
┌─minus(CAST('1⋯Quarter(10))─┐
│ 1996-09-16 │
└───────────────────────────┘
```
## subtractSeconds
도입 버전: v1.1.0
날짜, 날짜와 시간 또는 문자열로 인코딩된 날짜나 날짜와 시간에서 지정된 초 수를 뺍니다.
**구문**
```sql theme={null}
subtractSeconds(datetime, num)
```
**인수**
* `datetime` — 지정한 초 수를 뺄 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 뺄 초 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에서 `num`초를 뺀 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64(3)`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜 타입에서 초를 빼기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 second)
```
```response title=Response theme={null}
┌─minus(CAST('⋯Second(10))─┐
│ 1998-06-15 23:59:50 │
└──────────────────────────┘
```
## subtractTupleOfIntervals
도입 버전: v22.11.0
날짜 또는 시간 정보가 포함된 날짜 값에서 인터벌 튜플을 순차적으로 뺍니다.
**구문**
```sql theme={null}
subtractTupleOfIntervals(datetime, intervals)
```
**인수**
* `datetime` — 여기에서 인터벌을 뺄 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `intervals` — `datetime`에서 뺄 인터벌의 튜플입니다. [`Tuple(Interval)`](/ko/reference/data-types/tuple)
**반환 값**
`intervals`를 뺀 `date`를 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**날짜에서 인터벌 튜플 빼기**
```sql title=Query theme={null}
WITH toDate('2018-01-01') AS date SELECT subtractTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 YEAR))
```
```response title=Response theme={null}
┌─subtractTupl⋯alYear(1)))─┐
│ 2016-12-31 │
└──────────────────────────┘
```
## subtractWeeks
도입 버전: v1.1.0
날짜, 날짜 및 시간이 포함된 값, 또는 문자열로 인코딩된 날짜나 날짜 및 시간이 포함된 값에서 지정한 주 수를 뺍니다.
**구문**
```sql theme={null}
subtractWeeks(datetime, num)
```
**인수**
* `datetime` — 지정한 수의 주를 뺄 날짜 또는 시간 정보가 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 뺄 주 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에서 `num`주를 뺀 결과를 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**다양한 날짜 타입에서 주 빼기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용하기**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 week)
```
```response title=Response theme={null}
┌─minus(CAST('⋯alWeek(10))─┐
│ 1998-04-07 │
└──────────────────────────┘
```
## subtractYears
처음 도입된 버전: v1.1.0
날짜, 날짜 및 시간이 포함된 값, 또는 문자열로 인코딩된 날짜/날짜 및 시간 값에서 지정한 연수만큼 뺍니다.
**구문**
```sql theme={null}
subtractYears(datetime, num)
```
**인수**
* `datetime` — 지정한 연도 수를 뺄 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `num` — 뺄 연도 수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
**반환 값**
`datetime`에서 `num`년을 뺀 값을 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**서로 다른 날짜 타입에서 연도 빼기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─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 구문 사용하기**
```sql title=Query theme={null}
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 year)
```
```response title=Response theme={null}
┌─minus(CAST('⋯alYear(10))─┐
│ 1988-06-16 │
└──────────────────────────┘
```
## timeDiff
도입 버전: v23.4.0
두 날짜 또는 시간을 포함한 날짜 2개 사이의 차이를 초 단위로 반환합니다.
차이는 `enddate` - `startdate`로 계산합니다.
이 함수는 `dateDiff('second', startdate, enddate)`와 동일합니다.
다른 단위(시간, 일, 월 등)로 시간 차이를 계산하려면 [`dateDiff`](#dateDiff) 함수를 대신 사용하십시오.
**구문**
```sql theme={null}
timeDiff(startdate, enddate)
```
**인수**
* `startdate` — 먼저 뺄 시간 값(감수)입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `enddate` — 기준이 되는 시간 값(피감수)입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
`enddate`와 `startdate`의 차이를 초 단위로 반환합니다. [`Int64`](/ko/reference/data-types/int-uint)
**예시**
**초 단위 시간 차이 계산**
```sql title=Query theme={null}
SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res
```
```response title=Response theme={null}
┌───res─┐
│ 90000 │
└───────┘
```
**시간 차이를 계산해 시간 단위로 변환**
```sql title=Query theme={null}
SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) / 3600 AS hours
```
```response title=Response theme={null}
┌─hours─┐
│ 25 │
└───────┘
```
**dateDiff의 초 단위와 동일**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌─time_diff_result─┬─date_diff_result─┐
│ 259200 │ 259200 │
└──────────────────┴──────────────────┘
```
## timeSlot
도입 버전: v1.1.0
시간을 30분 길이 인터벌의 시작 시점으로 내림합니다.
이 함수는 확장 타입인 `Date32` 및 `DateTime64` 값도 인수로 받을 수 있지만,
일반적인 범위를 벗어난 시간(`Date`는 1970년부터 2149년까지, `DateTime`은 2106년까지)을 전달하면 잘못된 결과가 나올 수 있습니다.
**구문**
```sql theme={null}
timeSlot(time[, time_zone])
```
**인수**
* `time` — 30분 인터벌의 시작 시점으로 반올림할 시간입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `time_zone` — 선택 사항입니다. 시간대를 나타내는 String 타입의 상수 값 또는 표현식입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
30분 인터벌의 시작 시점으로 반올림된 시간을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime)
**예시**
**시간을 30분 인터벌로 반올림**
```sql title=Query theme={null}
SELECT timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))
```
```response title=Response theme={null}
┌─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`의 스케일과 다를 수 있습니다. 제공된 모든 인수 중 가장 높은 스케일이 사용됩니다.
**구문**
```sql theme={null}
timeSlots(StartTime, Duration[, Size])
```
**인수**
* `StartTime` — 인터벌의 시작 시각입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `Duration` — 초 단위 인터벌 지속 시간입니다. [`UInt32`](/ko/reference/data-types/int-uint) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `Size` — 선택 사항입니다. 초 단위 시간 슬롯의 크기입니다. 기본값은 1800(30분)입니다. [`UInt32`](/ko/reference/data-types/int-uint) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
DateTime/DateTime64 배열을 반환합니다(반환 타입은 `StartTime`의 타입과 일치합니다). DateTime64의 경우 반환 값의 스케일은 `StartTime`의 스케일과 다를 수 있으며, 전달된 모든 인수 중 가장 높은 스케일이 적용됩니다. [`Array(DateTime)`](/ko/reference/data-types/array) 또는 [`Array(DateTime64)`](/ko/reference/data-types/array)
**예시**
**인터벌의 시간 슬롯 생성**
```sql title=Query theme={null}
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))
```
```response title=Response theme={null}
┌─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)`](/ko/reference/data-types/datetime64) 타입으로 변환합니다.
두 번째 인수 `expr_time`를 지정하면, 변환된 값에 지정된 시간이 더해집니다.
**구문**
```sql theme={null}
timestamp(expr[, expr_time])
```
**인수**
* `expr` — 날짜 또는 시간이 포함된 날짜입니다. [`String`](/ko/reference/data-types/string)
* `expr_time` — 선택 사항입니다. 변환된 값에 추가할 시간입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
변환된 `expr` 값 또는 시간이 추가된 `expr` 값을 반환합니다. [`DateTime64(6)`](/ko/reference/data-types/datetime64)
**예시**
**날짜 문자열을 DateTime64(6)로 변환**
```sql title=Query theme={null}
SELECT timestamp('2023-12-31') AS ts;
```
```response title=Response theme={null}
┌─────────────────────────ts─┐
│ 2023-12-31 00:00:00.000000 │
└────────────────────────────┘
```
**날짜 문자열에 시간 추가**
```sql title=Query theme={null}
SELECT timestamp('2023-12-31 12:00:00', '12:00:00.11') AS ts;
```
```response title=Response theme={null}
┌─────────────────────────ts─┐
│ 2024-01-01 00:00:00.110000 │
└────────────────────────────┘
```
## timezone
도입 버전: v21.4.0
현재 세션의 시간대 이름을 반환하거나, 시간대 오프셋 또는 이름을 정식 시간대 이름으로 변환합니다.
**구문**
```sql theme={null}
timezone()
```
**별칭**: `timeZone`
**인수**
* 없음.
**반환 값**
정식 시간대 이름을 [`String`](/ko/reference/data-types/string)으로 반환합니다
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT timezone()
```
```response title=Response theme={null}
┌─timezone()───────┐
│ Europe/Amsterdam │
└──────────────────┘
```
## timezoneOf
도입 버전: v21.4.0
[`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 값의 시간대 이름을 반환합니다.
**구문**
```sql theme={null}
timezoneOf(datetime)
```
**별칭**: `timeZoneOf`
**인수**
* `datetime` — [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 타입의 값입니다.
* `timezone` — 선택 사항입니다. `datetime` 값의 시간대를 변환할 대상 시간대 이름입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
`datetime`의 시간대 이름을 반환합니다. [`String`](/ko/reference/data-types/string)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT timezoneOf(now());
```
```response title=Response theme={null}
┌─timezoneOf(now())─┐
│ Europe/Amsterdam │
└───────────────────┘
```
## timezoneOffset
도입 버전: v21.6.0
[UTC](https://en.wikipedia.org/wiki/Coordinated_Universal_Time)로부터의 시간대 오프셋을 초 단위로 반환합니다.
이 함수는 지정된 날짜 및 시간에 적용되는 일광 절약 시간과 과거의 시간대 변경 사항을 고려합니다.
**구문**
```sql theme={null}
timezoneOffset(datetime)
```
**별칭**: `timeZoneOffset`
**인수**
* `datetime` — 시간대 오프셋을 가져올 `DateTime` 값입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
UTC 기준 오프셋을 초 단위로 반환합니다. [`Int32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
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;
```
```response title=Response theme={null}
┌────────────────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)를 반환합니다.
**구문**
```sql theme={null}
toDayOfMonth(datetime)
```
**별칭**: `DAY`, `DAYOFMONTH`
**인수**
* `datetime` — 월의 일을 가져올 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
주어진 날짜/시간의 월의 일을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT toDayOfMonth(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 21 │
└─────────────────────────────────────────────────┘
```
## toDayOfWeek
도입 버전: v1.1.0
`Date` 또는 `DateTime` 값이 한 주에서 몇 번째 요일에 해당하는지 나타내는 숫자를 반환합니다.
`toDayOfWeek()`의 2인수 형식에서는 한 주의 시작일을 월요일 또는 일요일로 지정할 수 있으며,
반환값의 범위를 0~~6 또는 1~~7로 지정할 수도 있습니다.
| 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 |
**구문**
```sql theme={null}
toDayOfWeek(datetime[, mode[, timezone]])
```
**별칭**: `DAYOFWEEK`
**인수**
* `datetime` — 요일을 구할 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `mode` — 선택 사항입니다. 주 모드(0-3)를 지정하는 정수입니다. 생략하면 기본값은 0입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `timezone` — 선택 사항입니다. 변환에 사용할 시간대입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
지정된 `Date` 또는 `DateTime`에 해당하는 요일을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
-- 다음 날짜는 2023년 4월 21일이며, 금요일이었습니다:
SELECT
toDayOfWeek(toDateTime('2023-04-21')),
toDayOfWeek(toDateTime('2023-04-21'), 1)
```
```response title=Response theme={null}
┌─toDayOfWeek(toDateTime('2023-04-21'))─┬─toDayOfWeek(toDateTime('2023-04-21'), 1)─┐
│ 5 │ 4 │
└───────────────────────────────────────┴──────────────────────────────────────────┘
```
## toDayOfYear
도입 버전: v18.4.0
`Date` 또는 `DateTime` 값이 해당 연도에서 몇 번째 날인지 나타내는 숫자(1-366)를 반환합니다.
**구문**
```sql theme={null}
toDayOfYear(datetime)
```
**별칭**: `DAYOFYEAR`
**인수**
* `datetime` — 해당 연도의 몇 번째 날인지를 구할 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
지정된 Date 또는 DateTime이 해당 연도의 몇 번째 날인지 반환합니다. [`UInt16`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT toDayOfYear(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toDayOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 111 │
└────────────────────────────────────────────────┘
```
## toDaysInMonth
도입 버전: v26.3.0
`Date` 또는 `DateTime`이 속한 월의 일 수를 반환합니다.
반환 값의 범위는 28\~31입니다.
**구문**
```sql theme={null}
toDaysInMonth(datetime)
```
**인수**
* `datetime` — 해당 월의 일 수를 구할 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
지정된 날짜/시간이 속한 월의 일 수를 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT toDaysInMonth(toDate('2023-02-01')), toDaysInMonth(toDate('2024-02-01')), toDaysInMonth(toDate('2023-01-01'))
```
```response title=Response theme={null}
┌─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일](https://en.wikipedia.org/wiki/Year_zero)부터
[ISO 8601에서 정의한 프로렙틱 그레고리력](https://en.wikipedia.org/wiki/Gregorian_calendar#Proleptic_Gregorian_calendar)에서 경과한 일수를 반환합니다.
계산 방식은 MySQL의 [`TO_DAYS`](https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html#function_to-days) 함수와 동일합니다.
**구문**
```sql theme={null}
toDaysSinceYearZero(date[, time_zone])
```
**별칭**: `TO_DAYS`
**인수**
* `date` — 연도 0부터의 일수를 계산할 날짜 또는 날짜와 시간입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `time_zone` — 시간대입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
날짜 `0000-01-01`부터 경과한 일수를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**연도 0부터의 일수 계산**
```sql title=Query theme={null}
SELECT toDaysSinceYearZero(toDate('2023-09-08'))
```
```response title=Response theme={null}
┌─toDaysSinceYearZero(toDate('2023-09-08')))─┐
│ 713569 │
└────────────────────────────────────────────┘
```
## toHour
도입 버전: v1.1.0
`DateTime` 또는 `DateTime64` 값의 시(hour) 부분(0-23)을 반환합니다.
**구문**
```sql theme={null}
toHour(datetime)
```
**별칭**: `HOUR`
**인수**
* `datetime` — 시간을 추출할 날짜 및 시간 값입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
`datetime`의 시(0-23)를 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT toHour(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─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을 반환합니다.
**구문**
```sql theme={null}
toISOWeek(datetime[, timezone])
```
**인수**
* `datetime` — ISO 주 번호를 가져올 날짜 또는 날짜와 시간이 포함된 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 선택 사항입니다. 시간대입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
ISO 8601 표준에 따른 ISO 주 번호를 반환합니다. 반환 값은 1부터 53 사이의 숫자입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**ISO 주 번호 가져오기**
```sql title=Query theme={null}
SELECT toDate('2016-12-27') AS date, toISOWeek(date) AS isoWeek
```
```response title=Response theme={null}
┌───────date─┬─isoWeek─┐
│ 2016-12-27 │ 52 │
└────────────┴─────────┘
```
**ISO 주차는 다른 연도에 속할 수 있습니다**
```sql title=Query theme={null}
SELECT toDate('2025-12-29') AS date, toISOWeek(date) AS isoWeek, toYear(date) AS year
```
```response title=Response theme={null}
┌───────date─┬─isoWeek─┬─year─┐
│ 2025-12-29 │ 1 │ 2025 │
└────────────┴─────────┴──────┘
```
## toISOYear
도입 버전: v18.4.0
날짜 또는 날짜/시간 값을 ISO 연도 번호로 변환합니다.
**구문**
```sql theme={null}
toISOYear(datetime)
```
**인수**
* `datetime` — 날짜 또는 시간이 포함된 날짜 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
입력 값을 ISO 연도 번호로 변환한 결과를 반환합니다. [`UInt16`](/ko/reference/data-types/int-uint)
**예시**
**날짜 값에서 ISO 연도 추출하기**
```sql title=Query theme={null}
SELECT
toISOYear(toDate('2024/10/02')) as year1,
toISOYear(toDateTime('2024-10-02 01:30:00')) as year2
```
```response title=Response theme={null}
┌─week1─┬─week2─┐
│ 40 │ 40 │
└───────┴───────┘
```
## toLastDayOfMonth
도입 버전: v1.1.0
날짜 또는 날짜와 시간이 포함된 값을 해당 월의 마지막 날로 올림합니다.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정으로 지정할 수 있습니다.
**구문**
```sql theme={null}
toLastDayOfMonth(value)
```
**별칭**: `LAST_DAY`
**인수**
* `value` — 해당 월의 마지막 날로 올림할 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
지정된 날짜 또는 시간이 포함된 날짜에 대해 해당 월의 마지막 날에 해당하는 날짜를 반환합니다. [`Date`](/ko/reference/data-types/date)
**예시**
**해당 월의 마지막 날로 올림**
```sql title=Query theme={null}
SELECT toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-30 │
└─────────────────────────────────────────────────────┘
```
## toLastDayOfWeek
도입 버전: v23.5.0
날짜 또는 날짜/시간 값을 가장 가까운 토요일 또는 일요일로 올림합니다.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정으로 지정할 수 있습니다.
**구문**
```sql theme={null}
toLastDayOfWeek(datetime[, mode[, timezone]])
```
**인수**
* `datetime` — 변환할 날짜 또는 시간이 포함된 날짜/시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `mode` — `toWeek()` 함수에 설명된 대로 주의 시작일을 결정합니다. 기본값은 `0`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `timezone` — 선택 사항입니다. 변환에 사용할 시간대입니다. 지정하지 않으면 서버의 시간대가 사용됩니다. [`String`](/ko/reference/data-types/string)
**반환 값**
모드에 따라, 지정한 날짜와 같거나 그 이후의 가장 가까운 토요일 또는 일요일 날짜를 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32)
**예시**
**가장 가까운 토요일 또는 일요일로 올림**
```sql title=Query theme={null}
SELECT
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')), /* 금요일 */
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* 금요일 */
toLastDayOfWeek(toDate('2023-04-23')), /* 일요일 */
toLastDayOfWeek(toDate('2023-04-23'), 1) /* 일요일 */
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')): 2023-04-23
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-22
toLastDayOfWeek(toDate('2023-04-23')): 2023-04-23
toLastDayOfWeek(toDate('2023-04-23'), 1): 2023-04-23
```
## toMicrosecond
도입 버전: v25.7.0
`DateTime64` 값의 마이크로초 부분(0-999999)을 반환합니다.
**구문**
```sql theme={null}
toMicrosecond(datetime)
```
**별칭**: `MICROSECOND`
**인수**
* `datetime` — 마이크로초를 추출할 날짜 및 시간입니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
`datetime`의 초 단위 내 마이크로초(0 - 999999)를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT toMicrosecond(toDateTime64('2023-04-21 10:20:30.456789', 6));
```
```response title=Response theme={null}
┌─toMicrosecond(toDateTime64('2023-04-21 10:20:30.456789', 6))─┐
│ 456789 │
└──────────────────────────────────────────────────────────────┘
```
## toMillisecond
도입 버전: v24.2.0
`DateTime` 또는 `DateTime64` 값의 밀리초 부분(0-999)을 반환합니다.
**구문**
```sql theme={null}
toMillisecond(datetime)
```
**별칭**: `MILLISECOND`
**인수**
* `datetime` — 밀리초를 추출할 날짜 및 시간입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
`datetime`의 분 값(0 - 59)을 반환합니다. [`UInt16`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3));
```
```response title=Response theme={null}
┌──toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3))─┐
│ 456 │
└────────────────────────────────────────────────────────────┘
```
## toMinute
도입 버전: v1.1.0
`Date` 또는 `DateTime` 값의 분 구성 요소(0-59)를 반환합니다.
**구문**
```sql theme={null}
toMinute(datetime)
```
**별칭**: `MINUTE`
**인수**
* `datetime` — 분을 추출할 날짜 및 시간입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
`datetime`의 시각에서 분(0 - 59)을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT toMinute(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toMinute(toDateTime('2023-04-21 10:20:30'))─┐
│ 20 │
└─────────────────────────────────────────────┘
```
## toModifiedJulianDay
도입 버전: v21.1.0
텍스트 형식의 `YYYY-MM-DD` [프로렙틱 그레고리력](https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar) 날짜를 `Int32` [수정 율리우스일](https://en.wikipedia.org/wiki/Julian_day#Variants) 숫자로 변환합니다. 이 함수는 `0000-01-01`부터 `9999-12-31`까지의 날짜를 지원합니다. 인수를 날짜로 파싱할 수 없거나 날짜가 올바르지 않으면 예외를 발생시킵니다.
**구문**
```sql theme={null}
toModifiedJulianDay(date)
```
**인수**
* `date` — `String` 형식의 날짜입니다. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring)
**반환 값**
수정 율리우스일 번호를 반환합니다. [`Int32`](/ko/reference/data-types/int-uint)
**예시**
**날짜를 수정 율리우스일로 변환**
```sql title=Query theme={null}
SELECT toModifiedJulianDay('2020-01-01')
```
```response title=Response theme={null}
┌─toModifiedJulianDay('2020-01-01')─┐
│ 58849 │
└───────────────────────────────────┘
```
## toModifiedJulianDayOrNull
도입 버전: v21.1.0
[`toModifiedJulianDay()`](#toModifiedJulianDay)와 유사하지만, 예외를 발생시키는 대신 `NULL`을 반환합니다.
**구문**
```sql theme={null}
toModifiedJulianDayOrNull(date)
```
**인수**
* `date` — 텍스트 형식의 날짜입니다. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring)
**반환 값**
유효한 `date`이면 수정 율리우스일 번호를 반환하고, 그렇지 않으면 `null`을 반환합니다. [`Nullable(Int32)`](/ko/reference/data-types/nullable)
**예시**
**null 처리와 함께 날짜를 수정 율리우스일로 변환**
```sql title=Query theme={null}
SELECT toModifiedJulianDayOrNull('2020-01-01');
SELECT toModifiedJulianDayOrNull('0000-00-00'); -- 유효하지 않은 날짜이므로 NULL을 반환합니다
```
```response title=Response theme={null}
┌─toModifiedJu⋯020-01-01')─┐
│ 58849 │
└──────────────────────────┘
┌─toModifiedJu⋯000-00-00')─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
```
## toMonday
도입 버전: v1.1.0
날짜 또는 날짜와 시간이 포함된 값을 해당 주의 월요일로 내림합니다. 반환값은 날짜입니다.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정으로 지정할 수 있습니다.
**구문**
```sql theme={null}
toMonday(value)
```
**인수**
* `value` — 해당 주의 월요일로 내림할 날짜 또는 날짜 및 시간입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
지정된 날짜 또는 날짜 및 시간과 같은 주의 월요일 날짜를 반환합니다. [`Date`](/ko/reference/data-types/date)
**예시**
**해당 주의 월요일로 내림**
```sql title=Query theme={null}
SELECT
toMonday(toDateTime('2023-04-21 10:20:30')), -- 금요일
toMonday(toDate('2023-04-24')); -- 이미 월요일인 경우
```
```response title=Response theme={null}
┌─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) 구성 요소를 반환합니다.
**구문**
```sql theme={null}
toMonth(datetime)
```
**별칭**: `MONTH`
**인수**
* `datetime` — 월을 추출할 날짜 또는 날짜/시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
지정한 날짜/시간의 월을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT toMonth(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 4 │
└────────────────────────────────────────────┘
```
## toMonthNumSinceEpoch
도입 버전: v25.3.0
1970년 이후 경과한 개월 수를 반환합니다
**구문**
```sql theme={null}
toMonthNumSinceEpoch(date)
```
**인수**
* `date` — 날짜 또는 시간이 포함된 날짜/시간입니다. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
양의 정수
**예시**
**예시**
```sql title=Query theme={null}
SELECT toMonthNumSinceEpoch(toDate('2024-10-01'))
```
```response title=Response theme={null}
657
```
## toNanosecond
도입 버전: v25.7.0
`DateTime64` 값의 나노초 부분(0-999999999)을 반환합니다.
**구문**
```sql theme={null}
toNanosecond(datetime)
```
**별칭**: `NANOSECOND`
**인수**
* `datetime` — 나노초를 추출할 날짜 및 시간입니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
`datetime`의 초 단위 내 나노초(0 - 999999999)를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT toNanosecond(toDateTime64('2023-04-21 10:20:30.123456789', 9));
```
```response title=Response theme={null}
┌─toNanosecond(toDateTime64('2023-04-21 10:20:30.123456789', 9))─┐
│ 123456789 │
└────────────────────────────────────────────────────────────────┘
```
## toQuarter
도입 버전: v1.1.0
지정된 `Date` 또는 `DateTime` 값이 해당하는 연도의 분기(1-4)를 반환합니다.
**구문**
```sql theme={null}
toQuarter(datetime)
```
**별칭**: `QUARTER`
**인수**
* `datetime` — 연도의 분기를 구할 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
지정된 날짜/시간의 연도 분기를 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT toQuarter(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2 │
└──────────────────────────────────────────────┘
```
## toRelativeDayNum
도입 버전: v1.1.0
날짜 또는 날짜와 시간이 포함된 값을 과거의 특정 고정 시점을 기준으로 경과한 일수로 변환합니다.
정확한 시점은 구현 세부 사항이므로 이 함수는 단독으로 사용하도록 설계되지 않았습니다.
이 함수의 주요 목적은 두 날짜 또는 날짜와 시간이 포함된 값 사이의 일수 차이를 계산하는 것입니다. 예: `toRelativeDayNum(dt1) - toRelativeDayNum(dt2)`.
**구문**
```sql theme={null}
toRelativeDayNum(date)
```
**인수**
* `date` — 날짜 또는 시간이 포함된 날짜. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
과거의 고정된 기준 시점으로부터 지난 일 수를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**상대 일 번호 가져오기**
```sql title=Query theme={null}
SELECT toRelativeDayNum(toDate('2023-04-01')) - toRelativeDayNum(toDate('2023-01-01'))
```
```response title=Response theme={null}
┌─minus(toRela⋯3-01-01')))─┐
│ 90 │
└──────────────────────────┘
```
## toRelativeHourNum
도입 버전: v1.1.0
날짜 또는 날짜/시간 값을 과거의 특정 고정 시점을 기준으로 경과한 시간 수로 변환합니다.
정확한 시점은 구현 세부 사항이므로, 이 함수는 단독으로 사용하기 위한 용도가 아닙니다.
이 함수의 주된 목적은 두 날짜 또는 날짜/시간 값 사이의 시간 차이를 계산하는 것입니다. 예: `toRelativeHourNum(dt1) - toRelativeHourNum(dt2)`.
**구문**
```sql theme={null}
toRelativeHourNum(date)
```
**인수**
* `date` — 날짜 또는 시간 정보가 포함된 날짜. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
과거의 고정된 기준 시점으로부터 지난 시간 수를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**상대 시간 수 구하기**
```sql title=Query theme={null}
SELECT toRelativeHourNum(toDateTime('2023-01-01 12:00:00')) - toRelativeHourNum(toDateTime('2023-01-01 00:00:00')) AS hours_difference
```
```response title=Response theme={null}
┌─hours_difference─┐
│ 12 │
└──────────────────┘
```
## toRelativeMinuteNum
도입 버전: v1.1.0
날짜 또는 시간이 포함된 날짜 값을 과거의 특정 고정 시점부터 경과한 분 수로 변환합니다.
정확한 시점은 구현 세부 사항이므로 이 함수는 단독으로 사용하도록 설계되지 않았습니다.
이 함수의 주된 목적은 두 날짜 또는 시간이 포함된 날짜 값 사이의 분 차이를 계산하는 것입니다. 예: `toRelativeMinuteNum(dt1) - toRelativeMinuteNum(dt2)`.
**구문**
```sql theme={null}
toRelativeMinuteNum(date)
```
**인수**
* `date` — 날짜 또는 시간이 포함된 날짜값. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
과거의 고정된 기준 시점으로부터의 분 수를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**상대 분 번호 구하기**
```sql title=Query theme={null}
SELECT toRelativeMinuteNum(toDateTime('2023-01-01 00:30:00')) - toRelativeMinuteNum(toDateTime('2023-01-01 00:00:00')) AS minutes_difference
```
```response title=Response theme={null}
┌─minutes_difference─┐
│ 30 │
└────────────────────┘
```
## toRelativeMonthNum
도입 버전: v1.1.0
날짜 또는 시간이 포함된 날짜를 과거의 특정 고정 시점을 기준으로 경과한 개월 수로 변환합니다.
정확한 기준 시점은 구현 세부 사항이므로, 이 함수는 단독으로 사용하도록 설계되지 않았습니다.
이 함수의 주된 목적은 두 날짜 또는 시간이 포함된 날짜 사이의 개월 수 차이를 계산하는 것입니다. 예를 들어 `toRelativeMonthNum(dt1) - toRelativeMonthNum(dt2)`와 같습니다.
**구문**
```sql theme={null}
toRelativeMonthNum(date)
```
**인수**
* `date` — 날짜 또는 날짜/시간입니다. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
과거의 고정된 기준 시점으로부터의 개월 수를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**상대 월 번호 구하기**
```sql title=Query theme={null}
SELECT toRelativeMonthNum(toDate('2023-04-01')) - toRelativeMonthNum(toDate('2023-01-01')) AS months_difference
```
```response title=Response theme={null}
┌─months_difference─┐
│ 3 │
└───────────────────┘
```
## toRelativeQuarterNum
도입 버전: v1.1.0
날짜 또는 시간이 포함된 날짜를 과거의 특정 고정 시점을 기준으로 경과한 분기 수로 변환합니다.
정확한 시점은 구현 세부 사항이므로 이 함수는 단독으로 사용하도록 설계되지 않았습니다.
이 함수의 주요 목적은 두 날짜 또는 시간이 포함된 날짜 사이의 분기 차이를 계산하는 것입니다. 예: `toRelativeQuarterNum(dt1) - toRelativeQuarterNum(dt2)`.
**구문**
```sql theme={null}
toRelativeQuarterNum(date)
```
**인수**
* `date` — 날짜 또는 시간이 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
과거의 고정된 기준 시점부터의 분기 수를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**상대 분기 번호 구하기**
```sql title=Query theme={null}
SELECT toRelativeQuarterNum(toDate('2023-04-01')) - toRelativeQuarterNum(toDate('2023-01-01')) AS quarters_difference
```
```response title=Response theme={null}
┌─quarters_difference─┐
│ 1 │
└─────────────────────┘
```
## toRelativeSecondNum
도입 버전: v1.1.0
날짜 또는 날짜/시간 값을 과거의 특정 고정 시점을 기준으로 경과한 초 수로 변환합니다.
정확한 시점은 구현 세부 사항이므로 이 함수는 단독으로 사용하도록 의도되지 않았습니다.
이 함수의 주된 목적은 두 날짜 또는 날짜/시간 값 사이의 초 단위 차이를 계산하는 것입니다. 예를 들어 `toRelativeSecondNum(dt1) - toRelativeSecondNum(dt2)`와 같습니다.
**구문**
```sql theme={null}
toRelativeSecondNum(date)
```
**인수**
* `date` — 날짜 또는 시간이 포함된 날짜. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
과거의 고정된 기준 시점으로부터 지난 초 수를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**상대 초 번호 구하기**
```sql title=Query theme={null}
SELECT toRelativeSecondNum(toDateTime('2023-01-01 00:01:00')) - toRelativeSecondNum(toDateTime('2023-01-01 00:00:00')) AS seconds_difference
```
```response title=Response theme={null}
┌─seconds_difference─┐
│ 60 │
└────────────────────┘
```
## toRelativeWeekNum
도입 버전: v1.1.0
날짜 또는 시간이 포함된 날짜를 과거의 특정 고정 시점 이후 경과한 주 수로 변환합니다.
정확한 시점은 구현 세부 사항이므로 이 함수는 단독으로 사용하도록 설계되지 않았습니다.
이 함수의 주된 목적은 두 날짜 또는 시간이 포함된 날짜 사이의 주 차이를 계산하는 것입니다. 예: `toRelativeWeekNum(dt1) - toRelativeWeekNum(dt2)`.
**구문**
```sql theme={null}
toRelativeWeekNum(date)
```
**인수**
* `date` — 날짜 또는 시간이 포함된 날짜 값. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
과거의 고정된 기준 시점으로부터 지난 주 수를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**상대 주 번호 구하기**
```sql title=Query theme={null}
SELECT toRelativeWeekNum(toDate('2023-01-08')) - toRelativeWeekNum(toDate('2023-01-01')) AS weeks_difference
```
```response title=Response theme={null}
┌─weeks_difference─┐
│ 1 │
└──────────────────┘
```
## toRelativeYearNum
도입 버전: v1.1.0
날짜 또는 시간이 포함된 날짜를 과거의 특정 고정 시점을 기준으로 경과한 연수로 변환합니다.
정확한 시점은 구현 세부 사항이므로 이 함수는 단독으로 사용하도록 되어 있지 않습니다.
이 함수의 주된 목적은 두 날짜 또는 날짜/시간 값 사이의 연도 차이를 계산하는 것입니다. 예를 들어 `toRelativeYearNum(dt1) - toRelativeYearNum(dt2)`와 같습니다.
**구문**
```sql theme={null}
toRelativeYearNum(date)
```
**인수**
* `date` — 날짜 또는 시간이 포함된 날짜. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
과거의 고정된 기준 시점부터의 연도 수를 반환합니다. [`UInt16`](/ko/reference/data-types/int-uint)
**예시**
**상대 연도 번호 구하기**
```sql title=Query theme={null}
SELECT toRelativeYearNum('2010-10-01'::DateTime) - toRelativeYearNum('2000-01-01'::DateTime)
```
```response title=Response theme={null}
┌─minus(toRela⋯ateTime')))─┐
│ 10 │
└──────────────────────────┘
```
## toSecond
도입 버전: v1.1.0
`DateTime` 또는 `DateTime64` 값의 초 부분(0-59)을 반환합니다.
**구문**
```sql theme={null}
toSecond(datetime)
```
**별칭**: `SECOND`
**인수**
* `datetime` — 초를 추출할 날짜 및 시간입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
`datetime`에서 분의 초(0 - 59)를 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT toSecond(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toSecond(toDateTime('2023-04-21 10:20:30'))─┐
│ 30 │
└─────────────────────────────────────────────┘
```
## toStartOfDay
도입 버전: v1.1.0
시간이 포함된 날짜를 그 날짜의 시작 시각으로 내림합니다.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정을 통해 구성할 수 있습니다.
**구문**
```sql theme={null}
toStartOfDay(datetime)
```
**인수**
* `datetime` — 내림할 날짜 또는 날짜/시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime)
**반환 값**
날짜와 시간을 하루 시작 시점으로 내림한 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**하루 시작 시점으로 내림**
```sql title=Query theme={null}
SELECT toStartOfDay(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfDay(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-21 00:00:00 │
└─────────────────────────────────────────────────┘
```
## toStartOfFifteenMinutes
도입 버전: v1.1.0
날짜 및 시간 값을 15분 인터벌 시작 시점으로 내림합니다.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정으로 지정할 수 있습니다.
**구문**
```sql theme={null}
toStartOfFifteenMinutes(datetime)
```
**인수**
* `datetime` — 반올림할 날짜 또는 날짜와 시간이 포함된 값입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
가장 가까운 15분 인터벌의 시작 시점으로 반올림된 날짜 및 시간 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**예시**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
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분 인터벌의 시작 시점으로 내림 처리합니다.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정으로 지정할 수 있습니다.
**구문**
```sql theme={null}
toStartOfFiveMinutes(datetime)
```
**별칭**: `toStartOfFiveMinute`
**인수**
* `datetime` — 반올림할 시간 정보가 포함된 날짜입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
가장 가까운 5분 인터벌의 시작으로 반올림된 시간 정보가 포함된 날짜를 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**예시**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
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
시간 정보가 포함된 날짜 값을 해당 시간의 시작으로 내림합니다.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정으로 구성할 수 있습니다.
**구문**
```sql theme={null}
toStartOfHour(datetime)
```
**인수**
* `datetime` — 내림할 날짜 및 시간. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
날짜 및 시간을 해당 시간의 시작 시각으로 내림한 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**시간의 시작 시각으로 내림**
```sql title=Query theme={null}
SELECT
toStartOfHour(toDateTime('2023-04-21 10:20:30'));
```
```response title=Response theme={null}
┌─────────────────res─┬─toTypeName(res)─┐
│ 2023-04-21 10:00:00 │ DateTime │
└─────────────────────┴─────────────────┘
```
## toStartOfISOYear
도입 버전: v1.1.0
날짜 또는 날짜/시간 값을 ISO 연도의 첫날로 내림합니다. ISO 연도는 일반적인 연도와 다를 수 있습니다. [ISO 주차 날짜](https://en.wikipedia.org/wiki/ISO_week_date)를 참조하세요.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정으로 지정할 수 있습니다.
**구문**
```sql theme={null}
toStartOfISOYear(value)
```
**인수**
* `value` — ISO 연도의 첫째 날로 내림할 날짜 또는 날짜와 시간입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
지정된 날짜 또는 날짜와 시간에 해당하는 ISO 연도의 첫째 날을 반환합니다. [`Date`](/ko/reference/data-types/date)
**예시**
**ISO 연도의 첫째 날로 내림**
```sql title=Query theme={null}
SELECT toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─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()` 함수를 각각 에뮬레이션합니다.
**구문**
```sql theme={null}
toStartOfInterval(value, INTERVAL x unit[, time_zone])
toStartOfInterval(value, INTERVAL x unit[, origin[, time_zone]])
```
**별칭**: `time_bucket`, `date_bin`
**인수**
* `value` — 내림할 날짜 또는 날짜와 시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `x` — 인터벌 길이를 나타내는 숫자입니다. - `unit` — 인터벌 단위: YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE, SECOND, MILLISECOND, MICROSECOND, NANOSECOND. - `time_zone` — 선택 사항입니다. 문자열 형식의 시간대 이름입니다. - `origin` — 선택 사항입니다. 계산의 기준점입니다(두 번째 오버로드에만 해당).
**반환 값**
입력 값이 포함된 인터벌의 시작 시점을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime)
**예시**
**기본 인터벌 내림**
```sql title=Query theme={null}
SELECT toStartOfInterval(toDateTime('2023-01-15 14:30:00'), INTERVAL 1 MONTH)
```
```response title=Response theme={null}
┌─toStartOfInt⋯alMonth(1))─┐
│ 2023-01-01 │
└──────────────────────────┘
```
**원점을 사용하는 경우**
```sql title=Query theme={null}
SELECT toStartOfInterval(toDateTime('2023-01-01 14:45:00'), INTERVAL 1 MINUTE, toDateTime('2023-01-01 14:35:30'))
```
```response title=Response theme={null}
┌─toStartOfInt⋯14:35:30'))─┐
│ 2023-01-01 14:44:30 │
└──────────────────────────┘
```
## toStartOfMicrosecond
도입 버전: v22.6.0
시간이 포함된 날짜 값을 해당 마이크로초의 시작 시점으로 내림합니다.
**구문**
```sql theme={null}
toStartOfMicrosecond(datetime[, timezone])
```
**인수**
* `datetime` — 날짜 및 시간입니다. [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 선택 사항입니다. 반환 값에 사용할 시간대입니다. 지정하지 않으면 함수는 `value` 매개변수의 시간대를 사용합니다. [`String`](/ko/reference/data-types/string)
**반환 값**
마이크로초보다 작은 단위가 제거된 입력 값 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**시간대 없이 쿼리**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64);
```
```response title=Response theme={null}
┌────toStartOfMicrosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999000 │
└───────────────────────────────┘
```
**시간대를 지정한 쿼리**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─toStartOfMicrosecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999999000 │
└─────────────────────────────────────────────┘
```
## toStartOfMillisecond
도입 버전: v22.6.0
시간이 포함된 날짜 값을 해당 밀리초의 시작 시점으로 내림합니다.
**구문**
```sql theme={null}
toStartOfMillisecond(datetime[, timezone])
```
**인수**
* `datetime` — 날짜와 시간입니다. [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 선택 사항입니다. 반환 값에 사용할 시간대입니다. 지정하지 않으면 함수는 `value` 매개변수의 시간대를 사용합니다. [`String`](/ko/reference/data-types/string)
**반환 값**
밀리초 미만 자릿수가 제거된 입력 값입니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**시간대 없이 쿼리**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64);
```
```response title=Response theme={null}
┌────toStartOfMillisecond(dt64)─┐
│ 2020-01-01 10:20:30.999000000 │
└───────────────────────────────┘
```
**시간대를 지정한 쿼리**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─toStartOfMillisecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999000000 │
└─────────────────────────────────────────────┘
```
## toStartOfMinute
도입 버전: v1.1.0
날짜와 시간이 포함된 값을 해당 분의 시작으로 내림합니다.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정으로 구성할 수 있습니다.
**구문**
```sql theme={null}
toStartOfMinute(datetime)
```
**인수**
* `datetime` — 내림할 날짜 및 시간 값. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
날짜 및 시간을 해당 분의 시작 시점으로 내림한 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**분의 시작 시점으로 내림**
```sql title=Query theme={null}
SELECT
toStartOfMinute(toDateTime('2023-04-21 10:20:30')),
toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8))
FORMAT Vertical
```
```response title=Response theme={null}
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
날짜 또는 날짜/시간 값을 해당 월의 첫째 날로 내림합니다.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정으로 지정할 수 있습니다.
**구문**
```sql theme={null}
toStartOfMonth(value)
```
**인수**
* `value` — 해당 월의 첫째 날로 내림할 날짜 또는 날짜/시간 값입니다. [`Date`](/ko/reference/data-types/date) or [`Date32`](/ko/reference/data-types/date32) or [`DateTime`](/ko/reference/data-types/datetime) or [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
지정한 날짜 또는 날짜/시간 값이 속한 월의 첫째 날을 반환합니다. [`Date`](/ko/reference/data-types/date)
**예시**
**해당 월의 첫째 날로 내림**
```sql title=Query theme={null}
SELECT toStartOfMonth(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└───────────────────────────────────────────────────┘
```
## toStartOfNanosecond
도입 버전: v22.6.0
시간이 포함된 날짜를 나노초 단위의 시작으로 내림합니다.
**구문**
```sql theme={null}
toStartOfNanosecond(datetime[, timezone])
```
**인수**
* `datetime` — 날짜 및 시간입니다. [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 선택 사항입니다. 반환 값의 시간대입니다. 지정하지 않으면 함수는 `value` 매개변수의 시간대를 사용합니다. [`String`](/ko/reference/data-types/string)
**반환 값**
나노초가 포함된 입력 값입니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**시간대 없이 쿼리**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64);
```
```response title=Response theme={null}
┌─────toStartOfNanosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999999 │
└───────────────────────────────┘
```
**시간대를 지정한 쿼리**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─toStartOfNanosecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999999999 │
└────────────────────────────────────────────┘
```
## toStartOfQuarter
도입 버전: v1.1.0
날짜 또는 날짜/시간 값을 해당 분기의 첫날로 내림합니다. 분기의 첫날은 1월 1일, 4월 1일, 7월 1일 또는 10월 1일입니다.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정에 따라 지정할 수 있습니다.
**구문**
```sql theme={null}
toStartOfQuarter(value)
```
**인수**
* `value` — 분기의 첫날로 내림할 날짜 또는 시간 정보가 포함된 날짜입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
지정된 날짜 또는 시간 정보가 포함된 날짜에 해당하는 분기의 첫날을 반환합니다. [`Date`](/ko/reference/data-types/date)
**예시**
**분기의 첫날로 내림**
```sql title=Query theme={null}
SELECT toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└─────────────────────────────────────────────────────┘
```
## toStartOfSecond
도입 버전: v20.5.0
날짜 및 시간 값을 해당 초의 시작 시점으로 내림합니다.
**구문**
```sql theme={null}
toStartOfSecond(datetime[, timezone])
```
**인수**
* `datetime` — 초 미만 단위를 잘라낼 날짜 및 시간입니다. [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 선택 사항입니다. 반환 값에 사용할 시간대입니다. 지정하지 않으면 함수는 `value` 매개변수의 시간대를 사용합니다. [`String`](/ko/reference/data-types/string)
**반환 값**
초 미만 단위가 제거된 입력 값을 반환합니다. [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**시간대 없이 쿼리**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64);
```
```response title=Response theme={null}
┌───toStartOfSecond(dt64)─┐
│ 2020-01-01 10:20:30.000 │
└─────────────────────────┘
```
**시간대를 지정한 쿼리**
```sql title=Query theme={null}
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64, 'Asia/Istanbul');
```
```response title=Response theme={null}
┌─toStartOfSecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 13:20:30.000 │
└────────────────────────────────────────┘
```
## toStartOfTenMinutes
도입 버전: v20.1.0
시간이 포함된 날짜 값을 가장 가까운 10분 인터벌의 시작 시각으로 내립니다.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정을 통해 지정할 수 있습니다.
**구문**
```sql theme={null}
toStartOfTenMinutes(datetime)
```
**인수**
* `datetime` — 시간이 포함된 날짜입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
날짜와 시간을 가장 가까운 10분 인터벌의 시작으로 반올림한 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**예시**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
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
날짜 또는 날짜/시간 값을 가장 가까운 일요일 또는 월요일로 내림합니다.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정으로 지정할 수 있습니다.
**구문**
```sql theme={null}
toStartOfWeek(datetime[, mode[, timezone]])
```
**인수**
* `datetime` — 변환할 날짜 또는 날짜/시간입니다. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `mode` — `toWeek()` 함수에 설명된 대로 한 주의 시작 요일을 결정합니다. 기본값은 `0`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `timezone` — 변환에 사용할 시간대입니다. 지정하지 않으면 서버의 시간대가 사용됩니다. [`String`](/ko/reference/data-types/string)
**반환 값**
`mode`에 따라 지정한 날짜와 같거나 그 이전인 가장 가까운 일요일 또는 월요일 날짜를 반환합니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32)
**예시**
**가장 가까운 일요일 또는 월요일로 내림**
```sql title=Query theme={null}
SELECT
toStartOfWeek(toDateTime('2023-04-21 10:20:30')), /* 금요일 */
toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* 금요일 */
toStartOfWeek(toDate('2023-04-24')), /* 월요일 */
toStartOfWeek(toDate('2023-04-24'), 1) /* 월요일 */
FORMAT Vertical
```
```response title=Response theme={null}
Row 1:
──────
toStartOfWeek(toDateTime('2023-04-21 10:20:30')): 2023-04-17
toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-17
toStartOfWeek(toDate('2023-04-24')): 2023-04-24
toStartOfWeek(toDate('2023-04-24'), 1): 2023-04-24
```
## toStartOfYear
도입 버전: v1.1.0
날짜 또는 날짜/시간 값을 해당 연도의 첫날로 내림합니다. 결과는 `Date` 객체로 반환됩니다.
반환 유형은 [`enable_extended_results_for_datetime_functions`](/ko/reference/settings/session-settings#enable_extended_results_for_datetime_functions) 설정으로 변경할 수 있습니다.
**구문**
```sql theme={null}
toStartOfYear(value)
```
**인수**
* `value` — 내림할 날짜 또는 날짜/시간입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
지정된 날짜/시간에 해당하는 연도의 첫째 날을 [`Date`](/ko/reference/data-types/date)로 반환합니다.
**예시**
**연도의 첫째 날로 내림**
```sql title=Query theme={null}
SELECT toStartOfYear(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toStartOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-01-01 │
└──────────────────────────────────────────────────┘
```
## toTimeWithFixedDate
도입 버전: v1.1.0
date 또는 날짜/시간 값에서 시간 component를 추출합니다.
반환되는 결과는 현재 `1970-01-02`인 고정 시점으로부터의 오프셋이며,
정확한 시점은 구현 세부 사항이므로 향후 변경될 수 있습니다.
따라서 `toTime`은 단독으로 사용해서는 안 됩니다.
이 함수의 주된 목적은 두 date 또는 날짜/시간 값 사이의 시간 차이를 계산하는 것입니다. 예를 들어 `toTime(dt1) - toTime(dt2)`와 같습니다.
**구문**
```sql theme={null}
toTimeWithFixedDate(date[, timezone])
```
**인수**
* `date` — 시간으로 변환할 날짜. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 선택 사항. 반환 값에 사용할 시간대. [`String`](/ko/reference/data-types/string)
**반환 값**
날짜 또는 날짜/시간에서 시간 구성 요소를 고정된 기준 시점(현재는 1970-01-02)으로부터의 오프셋 형태로 반환합니다. [`DateTime`](/ko/reference/data-types/datetime)
**예시**
**두 날짜 사이의 시간 차이 계산**
```sql title=Query theme={null}
SELECT toTimeWithFixedDate('2025-06-15 12:00:00'::DateTime) - toTimeWithFixedDate('2024-05-10 11:00:00'::DateTime) AS result, toTypeName(result)
```
```response title=Response theme={null}
┌─result─┬─toTypeName(result)─┐
│ 3600 │ Int32 │
└────────┴────────────────────┘
```
## toTimezone
도입 버전: v1.1.0
`DateTime` 또는 `DateTime64`를 지정된 시간대로 변환합니다.
데이터의 내부 값(Unix 초 단위 숫자)은 변경되지 않습니다.
시간대 속성과 문자열 표현만 변경됩니다.
**구문**
```sql theme={null}
toTimezone(datetime, timezone)
```
**별칭**: `toTimeZone`
**인수**
* `date` — 변환할 값입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 대상 시간대 이름입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
입력과 동일한 타임스탬프를 반환하지만, 지정된 시간대가 적용된 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)입니다.
**예시**
**사용 예시**
```sql title=Query theme={null}
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;
```
```response title=Response theme={null}
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 시간대의 timestamp로 변환합니다. 이 함수는 주로 Apache Spark 및 이와 유사한 프레임워크와의 호환성을 위해 포함되어 있습니다.
**구문**
```sql theme={null}
toUTCTimestamp(datetime, time_zone)
```
**별칭**: `to_utc_timestamp`
**인수**
* `datetime` — 날짜 또는 날짜/시간 타입의 상수 값이나 표현식입니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `time_zone` — 시간대를 나타내는 `String` 타입의 상수 값이나 표현식입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
UTC 시간대의 날짜 또는 날짜/시간 값을 반환합니다. [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**예시**
**시간대를 UTC로 변환**
```sql title=Query theme={null}
SELECT toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')
```
```response title=Response theme={null}
┌─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`로 변환합니다.
**구문**
```sql theme={null}
toUnixTimestamp(date[, timezone])
```
**인수**
* `date` — 변환할 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64) 또는 [`String`](/ko/reference/data-types/string)
* `timezone` — 선택 사항입니다. 변환에 사용할 시간대입니다. 지정하지 않으면 서버의 시간대가 사용됩니다. [`String`](/ko/reference/data-types/string)
**반환 값**
유닉스 타임스탬프를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
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;
```
```response title=Response theme={null}
행 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인수 형식을 사용하면 주가 일요일에 시작할지 월요일에 시작할지, 그리고 반환값 범위를 `0`~~`53`으로 할지 `1`~~`53`으로 할지 지정할 수 있습니다.
[`toISOWeek()`](#toWeek)는 `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()`](/ko/reference/functions/regular-functions/type-conversion-functions#parseDateTime64BestEffort)에서 지원하는 포맷의 [`String`](/ko/reference/data-types/string)으로도 지정할 수 있습니다. 문자열 인수 지원은 일부 타사 도구가 기대하는 MySQL 호환성을 위해서만 제공됩니다. 문자열 인수 지원은 향후 새로운 MySQL 호환성 설정에 따라 달라질 수 있으며, 문자열 파싱은 일반적으로 느리므로 사용하지 않는 것이 좋습니다.
**구문**
```sql theme={null}
toWeek(datetime[, mode[, time_zone]])
```
**별칭**: `week`
**인수**
* `datetime` — 주 번호를 구할 날짜 또는 날짜/시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime)
* `mode` — 선택 사항입니다. `0`부터 `9`까지의 모드로, 주의 시작 요일과 주 번호의 범위를 결정합니다. 기본값은 `0`입니다. - `time_zone` — 선택 사항입니다. 시간대입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
지정한 모드에 따른 주 번호를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**서로 다른 모드의 주 번호 구하기**
```sql title=Query theme={null}
SELECT toDate('2016-12-27') AS date, toWeek(date) AS week0, toWeek(date,1) AS week1, toWeek(date,9) AS week9
```
```response title=Response theme={null}
┌───────date─┬─week0─┬─week1─┬─week9─┐
│ 2016-12-27 │ 52 │ 52 │ 1 │
└────────────┴───────┴───────┴───────┘
```
## toYYYYMM
도입 버전: v1.1.0
날짜 또는 날짜/시간를 연도와 월 번호(YYYY \* 100 + MM)를 담은 `UInt32` 숫자로 변환합니다.
선택적으로 두 번째 시간대 인수를 받을 수 있습니다. 이 인수를 지정하는 경우 시간대는 문자열 상수여야 합니다.
이 함수는 `YYYYMMDDToDate()` 함수와 반대입니다.
**구문**
```sql theme={null}
toYYYYMM(datetime[, timezone])
```
**인수**
* `datetime` — 변환할 날짜 또는 날짜/시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 선택 사항입니다. 변환에 사용할 시간대입니다. 지정하는 경우 시간대는 문자열 상수여야 합니다. [`String`](/ko/reference/data-types/string)
**반환 값**
연도와 월 번호(YYYY \* 100 + MM)를 포함하는 UInt32 값을 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**현재 날짜를 YYYYMM 포맷으로 변환**
```sql title=Query theme={null}
SELECT toYYYYMM(now(), 'US/Eastern')
```
```response title=Response theme={null}
┌─toYYYYMM(now(), 'US/Eastern')─┐
│ 202303 │
└───────────────────────────────┘
```
## toYYYYMMDD
도입 버전: v1.1.0
날짜 또는 날짜/시간 값을 연, 월, 일 값을 담은 `UInt32` 숫자(YYYY \* 10000 + MM \* 100 + DD)로 변환합니다. 두 번째 선택적 시간대 인수를 받을 수 있습니다. 이 인수가 제공되면 시간대는 문자열 상수여야 합니다.
**구문**
```sql theme={null}
toYYYYMMDD(datetime[, timezone])
```
**인수**
* `datetime` — 변환할 날짜 또는 날짜/시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 선택 사항입니다. 변환에 사용할 시간대입니다. 지정하는 경우 시간대는 문자열 상수여야 합니다. [`String`](/ko/reference/data-types/string)
**반환 값**
연, 월, 일(YYYY \* 10000 + MM \* 100 + DD)을 포함하는 `UInt32` 숫자를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**현재 날짜를 YYYYMMDD 포맷으로 변환**
```sql title=Query theme={null}
SELECT toYYYYMMDD(now(), 'US/Eastern')
```
```response title=Response theme={null}
┌─toYYYYMMDD(now(), 'US/Eastern')─┐
│ 20230302 │
└─────────────────────────────────┘
```
## toYYYYMMDDhhmmss
도입 버전: v1.1.0
날짜 또는 날짜/시간를 연월일시분초를 담은 `UInt64` 숫자(YYYY \* 10000000000 + MM \* 100000000 + DD \* 1000000 + hh \* 10000 + mm \* 100 + ss)로 변환합니다.
선택적 두 번째 시간대 인수를 받을 수 있습니다. 이 인수를 지정하는 경우 시간대는 문자열 상수여야 합니다.
**구문**
```sql theme={null}
toYYYYMMDDhhmmss(datetime[, timezone])
```
**인수**
* `datetime` — 변환할 날짜 또는 날짜/시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
* `timezone` — 선택 사항입니다. 변환에 사용할 시간대입니다. 지정하는 경우 시간대는 문자열 상수여야 합니다. [`String`](/ko/reference/data-types/string)
**반환 값**
연, 월, 일, 시, 분, 초를 포함하는 `UInt64` 숫자를 반환합니다(YYYY \* 10000000000 + MM \* 100000000 + DD \* 1000000 + hh \* 10000 + mm \* 100 + ss). [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**현재 날짜와 시간을 YYYYMMDDhhmmss 포맷으로 변환**
```sql title=Query theme={null}
SELECT toYYYYMMDDhhmmss(now(), 'US/Eastern')
```
```response title=Response theme={null}
┌─toYYYYMMDDhhmmss(now(), 'US/Eastern')─┐
│ 20230302112209 │
└───────────────────────────────────────┘
```
## toYear
도입 버전: v1.1.0
`Date` 또는 `DateTime` 값의 연도 구성 요소(AD)를 반환합니다.
**구문**
```sql theme={null}
toYear(datetime)
```
**별칭**: `YEAR`
**인수**
* `datetime` — 연도를 추출할 날짜 또는 날짜/시간입니다. [`Date`](/ko/reference/data-types/date) 또는 [`Date32`](/ko/reference/data-types/date32) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
주어진 Date 또는 DateTime의 연도를 반환합니다. [`UInt16`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT toYear(toDateTime('2023-04-21 10:20:30'))
```
```response title=Response theme={null}
┌─toYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023 │
└───────────────────────────────────────────┘
```
## toYearNumSinceEpoch
도입 버전: v25.3.0
1970년 이후 경과한 연도 수를 반환합니다
**구문**
```sql theme={null}
toYearNumSinceEpoch(date)
```
**인수**
* `date` — 변환할 날짜 또는 날짜/시간 값입니다. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime) 또는 [`DateTime64`](/ko/reference/data-types/datetime64)
**반환 값**
양의 정수
**예시**
**예시**
```sql title=Query theme={null}
SELECT toYearNumSinceEpoch(toDate('2024-10-01'))
```
```response title=Response theme={null}
54
```
## toYearWeek
도입 버전: v20.1.0
날짜의 연도와 주 번호를 반환합니다. 연도의 첫째 주와 마지막 주에는 결과의 연도가 날짜 인수의 연도와 다를 수 있습니다.
mode 인수는 [`toWeek()`](/ko/reference/functions/regular-functions/date-time-functions#toWeek)의 mode 인수와 동일한 방식으로 동작합니다.
경고: `toYearWeek()`가 반환하는 주 번호는 `toWeek()`의 반환값과 다를 수 있습니다. `toWeek()`는 항상 지정된 연도를 기준으로 주 번호를 반환하며, `toWeek()`가 `0`을 반환하는 경우 `toYearWeek()`는 이전 연도의 마지막 주에 해당하는 값을 반환합니다. 아래 예시의 `prev_yearWeek`를 참조하십시오.
첫 번째 인수는 [`parseDateTime64BestEffort()`](/ko/reference/functions/regular-functions/type-conversion-functions#parseDateTime64BestEffort)에서 지원하는 포맷의 [`String`](/ko/reference/data-types/string)으로도 지정할 수 있습니다. 문자열 인수 지원은 일부 타사 도구에서 기대하는 MySQL 호환성을 위한 것입니다. 다만 문자열 인수 지원은 향후 새로운 MySQL 호환성 설정에 따라 달라질 수 있고, 일반적으로 문자열 파싱은 느리므로 사용하지 않는 것이 좋습니다.
**구문**
```sql theme={null}
toYearWeek(datetime[, mode[, timezone]])
```
**별칭**: `yearweek`
**인수**
* `datetime` — 연도와 주를 가져올 날짜 또는 날짜/시간입니다. [`Date`](/ko/reference/data-types/date) 또는 [`DateTime`](/ko/reference/data-types/datetime)
* `mode` — 선택 사항입니다. `0`부터 `9`까지의 모드는 주의 시작 요일과 주 번호 범위를 결정합니다. 기본값은 `0`입니다. - `timezone` — 선택 사항입니다. 시간대입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
연도와 주 번호를 결합한 정수 값을 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**서로 다른 모드에서 연도-주 조합 가져오기**
```sql title=Query theme={null}
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
```
```response title=Response theme={null}
┌───────date─┬─yearWeek0─┬─yearWeek1─┬─yearWeek9─┬─prev_yearWeek─┐
│ 2016-12-27 │ 201652 │ 201652 │ 201701 │ 202152 │
└────────────┴───────────┴───────────┴───────────┴───────────────┘
```
## today
도입 버전: v1.1.0
쿼리 분석 시점의 현재 날짜를 반환합니다. `toDate(now())`와 동일합니다.
**구문**
```sql theme={null}
today()
```
**별칭**: `curdate`, `current_date`
**인수**
* 없음.
**반환 값**
현재 날짜 [`Date`](/ko/reference/data-types/date)를 반환합니다.
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT today() AS today, curdate() AS curdate, current_date() AS current_date FORMAT Pretty
```
```response title=Response theme={null}
┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ today ┃ curdate ┃ current_date ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-03 │ 2025-03-03 │ 2025-03-03 │
└────────────┴────────────┴──────────────┘
```
**괄호 없는 SQL 표준 구문**
```sql title=Query theme={null}
SELECT TODAY, CURDATE,CURRENT_DATE
```
```response title=Response theme={null}
┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ TODAY ┃ CURDATE ┃ CURRENT_DATE ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-04 │ 2025-03-04 │ 2025-03-04 │
└────────────┴────────────┴──────────────┘
```
## yesterday
도입 버전: v1.1.0
인수를 받지 않으며, 쿼리 분석이 수행되는 시점의 어제 날짜를 반환합니다.
**구문**
```sql theme={null}
yesterday()
```
**인수**
* 없음.
**반환 값**
어제 날짜를 반환합니다. [`Date`](/ko/reference/data-types/date)
**예시**
**어제 날짜를 구합니다**
```sql title=Query theme={null}
SELECT yesterday();
SELECT today() - 1;
```
```response title=Response theme={null}
┌─yesterday()─┐
│ 2025-06-09 │
└─────────────┘
┌─minus(today(), 1)─┐
│ 2025-06-09 │
└───────────────────┘
```