날짜 및 시간 함수

날짜 및 시간 함수 (Date and Time Functions)

모든 PPL 날짜·시간 함수는 UTC 시간대를 사용해요. 입력과 출력 값 모두 UTC로 해석돼요. 예를 들어 '2020-08-26 01:01:01' 같은 입력 타임스탬프 리터럴은 UTC라고 가정하며, now() 함수도 현재 날짜와 시간을 UTC로 반환해요.

출처: 문서

본문

모든 PPL 날짜 및 시간 함수는 UTC 시간대를 사용해요. 입력과 출력 값 모두 UTC로 해석돼요. 예를 들어 '2020-08-26 01:01:01' 같은 입력 타임스탬프 리터럴은 UTC에 있다고 가정하며, now() 함수도 현재 날짜와 시간을 UTC로 반환해요.

PPL에서 지원하는 날짜 및 시간 함수는 다음과 같아요.

ADDDATE

사용법: ADDDATE(date, INTERVAL expr unit), ADDDATE(date, days)

날짜에 간격 또는 일 수를 더해요. 첫 번째 형식은 날짜에 간격을 더하고, 두 번째 형식은 정수인 일 수를 날짜에 더해요. 첫 번째 인수가 TIME이면 오늘 날짜를 사용해요. 첫 번째 인수가 DATE면 자정의 시간이 사용돼요.

매개변수:

date (필수): 수정할 날짜, 타임스탬프 또는 시간 값이에요.
INTERVAL expr unit (첫 번째 형식에서 필수): 날짜에 더할 간격이에요.
days (두 번째 형식에서 필수): 정수로 더할 일 수예요.

반환 타입: 간격 형식은 TIMESTAMP, 정수 일 형식에서 입력이 DATE면 DATE, 입력이 TIMESTAMP 또는 TIME이면 TIMESTAMP.

동의어 (Synonyms): DATE_ADD (간격 형식으로 사용할 때)

예제

source=people
| eval `'2020-08-26' + 1h` = ADDDATE(DATE('2020-08-26'), INTERVAL 1 HOUR), `'2020-08-26' + 1` = ADDDATE(DATE('2020-08-26'), 1), `ts '2020-08-26 01:01:01' + 1` = ADDDATE(TIMESTAMP('2020-08-26 01:01:01'), 1)
| fields `'2020-08-26' + 1h`, `'2020-08-26' + 1`, `ts '2020-08-26 01:01:01' + 1`

쿼리는 다음과 같은 결과를 반환해요:

'2020-08-26' + 1h | '2020-08-26' + 1 | ts '2020-08-26 01:01:01' + 1
2020-08-26 01:00:00 | 2020-08-27 | 2020-08-27 01:01:01

ADDTIME

사용법: ADDTIME(expr1, expr2)

두 번째 표현식을 첫 번째 표현식에 더하고 결과를 반환해요. 인수가 TIME이면 오늘 날짜를 사용해요. 인수가 DATE면 자정의 시간이 사용돼요.

매개변수:

expr1 (필수): 기본 날짜, 타임스탬프 또는 시간 값이에요.
expr2 (필수): 첫 번째 표현식에 더할 날짜, 타임스탬프 또는 시간 값이에요.

반환 타입: 첫 번째 인수가 DATE 또는 TIMESTAMP면 TIMESTAMP, 첫 번째 인수가 TIME이면 TIME.

예제

다음 예제는 두 DATE 값을 더하는 방법을 보여줘요:

source=people
| eval `'2008-12-12' + 0` = ADDTIME(DATE('2008-12-12'), DATE('2008-11-15'))
| fields `'2008-12-12' + 0`

쿼리는 다음과 같은 결과를 반환해요:

'2008-12-12' + 0
2008-12-12 00:00:00

다음 예제는 TIME과 DATE 값을 더하는 방법을 보여줘요:

source=people
| eval `'23:59:59' + 0` = ADDTIME(TIME('23:59:59'), DATE('2004-01-01'))
| fields `'23:59:59' + 0`

쿼리는 다음과 같은 결과를 반환해요:

'23:59:59' + 0
23:59:59

다음 예제는 DATE와 TIME을 결합해 타임스탬프를 만드는 방법을 보여줘요:

source=people
| eval `'2004-01-01' + '23:59:59'` = ADDTIME(DATE('2004-01-01'), TIME('23:59:59'))
| fields `'2004-01-01' + '23:59:59'`

쿼리는 다음과 같은 결과를 반환해요:

'2004-01-01' + '23:59:59'
2004-01-01 23:59:59

다음 예제는 두 TIME 값을 더하는 방법을 보여줘요:

source=people
| eval `'10:20:30' + '00:05:42'` = ADDTIME(TIME('10:20:30'), TIME('00:05:42'))
| fields `'10:20:30' + '00:05:42'`

쿼리는 다음과 같은 결과를 반환해요:

'10:20:30' + '00:05:42'
10:26:12

다음 예제는 두 TIMESTAMP 값을 더하는 방법을 보여줘요:

source=people
| eval `'2007-02-28 10:20:30' + '20:40:50'` = ADDTIME(TIMESTAMP('2007-02-28 10:20:30'), TIMESTAMP('2002-03-04 20:40:50'))
| fields `'2007-02-28 10:20:30' + '20:40:50'`

쿼리는 다음과 같은 결과를 반환해요:

'2007-02-28 10:20:30' + '20:40:50'
2007-03-01 07:01:20

CONVERT_TZ

사용법: CONVERT_TZ(timestamp, from_timezone, to_timezone)

원본 시간대에서 대상 시간대로 변환된 로컬 타임스탬프를 구성해요. 세 함수 인수 중 하나라도 유효하지 않으면 NULL을 반환해요: 타임스탬프가 yyyy-MM-dd HH:mm:ss 형식이 아니거나, 시간대가 (+/-)HH:mm 형식이 아니거나, 날짜가 유효하지 않거나(예: 2월 30일), 시간대가 유효 범위 -13:59에서 +14:00을 벗어나는 경우예요.

매개변수:

timestamp (필수): yyyy-MM-dd HH:mm:ss 형식으로 변환할 타임스탬프 또는 문자열이에요.
from_timezone (필수): (+/-)HH:mm 형식의 원본 시간대예요.
to_timezone (필수): (+/-)HH:mm 형식의 대상 시간대예요.

반환 타입: TIMESTAMP

예제

source=people
| eval `convert_tz('2008-05-15 12:00:00','+00:00','+10:00')` = convert_tz('2008-05-15 12:00:00','+00:00','+10:00')
| fields `convert_tz('2008-05-15 12:00:00','+00:00','+10:00')`

쿼리는 다음과 같은 결과를 반환해요:

convert_tz('2008-05-15 12:00:00','+00:00','+10:00')
2008-05-15 22:00:00

convert_tz의 유효 시간대 범위는 (-13:59, +14:00)을 포함해요. 범위를 벗어나는 시간대(다음 예제의 +15:00 같은)는 NULL을 반환해요:

source=people
| eval `convert_tz('2008-05-15 12:00:00','+00:00','+15:00')` = convert_tz('2008-05-15 12:00:00','+00:00','+15:00')
| fields `convert_tz('2008-05-15 12:00:00','+00:00','+15:00')`

쿼리는 다음과 같은 결과를 반환해요:

convert_tz('2008-05-15 12:00:00','+00:00','+15:00')
null

다음 예제는 날짜선을 넘는 양수 시간대에서 음수 시간대로의 변환을 보여줘요:

source=people
| eval `convert_tz('2008-05-15 12:00:00','+03:30','-10:00')` = convert_tz('2008-05-15 12:00:00','+03:30','-10:00')
| fields `convert_tz('2008-05-15 12:00:00','+03:30','-10:00')`

쿼리는 다음과 같은 결과를 반환해요:

convert_tz('2008-05-15 12:00:00','+03:30','-10:00')
2008-05-14 22:30:00

convert_tz에는 유효한 날짜가 필요해요. 4월 31일(그레고리력에는 없는 날짜) 같은 유효하지 않은 날짜에는 NULL이 반환돼요:

source=people
| eval `convert_tz('2008-04-31 12:00:00','+03:30','-10:00')` = convert_tz('2008-04-31 12:00:00','+03:30','-10:00')
| fields `convert_tz('2008-04-31 12:00:00','+03:30','-10:00')`

쿼리는 다음과 같은 결과를 반환해요:

convert_tz('2008-04-31 12:00:00','+03:30','-10:00')
null

다음 예제는 2월 30일도 NULL을 반환함을 보여줘요:

source=people
| eval `convert_tz('2008-02-30 12:00:00','+03:30','-10:00')` = convert_tz('2008-02-30 12:00:00','+03:30','-10:00')
| fields `convert_tz('2008-02-30 12:00:00','+03:30','-10:00')`

쿼리는 다음과 같은 결과를 반환해요:

convert_tz('2008-02-30 12:00:00','+03:30','-10:00')
null

2008년 2월 29일은 윤년이므로 유효한 날짜예요:

source=people
| eval `convert_tz('2008-02-29 12:00:00','+03:30','-10:00')` = convert_tz('2008-02-29 12:00:00','+03:30','-10:00')
| fields `convert_tz('2008-02-29 12:00:00','+03:30','-10:00')`

쿼리는 다음과 같은 결과를 반환해요:

convert_tz('2008-02-29 12:00:00','+03:30','-10:00')
2008-02-28 22:30:00

다음 예제는 2007년은 윤년이 아니므로 2007년 2월 29일이 NULL을 반환함을 보여줘요:

source=people
| eval `convert_tz('2007-02-29 12:00:00','+03:30','-10:00')` = convert_tz('2007-02-29 12:00:00','+03:30','-10:00')
| fields `convert_tz('2007-02-29 12:00:00','+03:30','-10:00')`

쿼리는 다음과 같은 결과를 반환해요:

convert_tz('2007-02-29 12:00:00','+03:30','-10:00')
null

convert_tz의 유효 시간대 범위는 [-13:59, +14:00]을 포함해요. 범위를 벗어나는 시간대(다음 예제의 +14:01 같은)는 NULL을 반환해요:

source=people
| eval `convert_tz('2008-02-01 12:00:00','+14:01','+00:00')` = convert_tz('2008-02-01 12:00:00','+14:01','+00:00')
| fields `convert_tz('2008-02-01 12:00:00','+14:01','+00:00')`

쿼리는 다음과 같은 결과를 반환해요:

convert_tz('2008-02-01 12:00:00','+14:01','+00:00')
null

convert_tz의 유효 시간대 범위는 (-13:59, +14:00)을 포함해요. 범위 안의 시간대(다음 예제의 +14:00 같은)는 올바르게 변환된 datetime 객체를 반환해요:

source=people
| eval `convert_tz('2008-02-01 12:00:00','+14:00','+00:00')` = convert_tz('2008-02-01 12:00:00','+14:00','+00:00')
| fields `convert_tz('2008-02-01 12:00:00','+14:00','+00:00')`

쿼리는 다음과 같은 결과를 반환해요:

convert_tz('2008-02-01 12:00:00','+14:00','+00:00')
2008-01-31 22:00:00

다음 예제는 -14:00(유효 범위 밖)이 NULL을 반환함을 보여줘요:

source=people
| eval `convert_tz('2008-02-01 12:00:00','-14:00','+00:00')` = convert_tz('2008-02-01 12:00:00','-14:00','+00:00')
| fields `convert_tz('2008-02-01 12:00:00','-14:00','+00:00')`

쿼리는 다음과 같은 결과를 반환해요:

convert_tz('2008-02-01 12:00:00','-14:00','+00:00')
null

convert_tz의 유효 시간대 범위는 [-13:59, +14:00]을 포함해요. 범위의 하한 경계인 -13:59 같은 시간대는 유효하며 변환된 결과를 반환해요:

source=people
| eval `convert_tz('2008-02-01 12:00:00','-13:59','+00:00')` = convert_tz('2008-02-01 12:00:00','-13:59','+00:00')
| fields `convert_tz('2008-02-01 12:00:00','-13:59','+00:00')`

쿼리는 다음과 같은 결과를 반환해요:

convert_tz('2008-02-01 12:00:00','-13:59','+00:00')
2008-02-02 01:59:00

CURDATE

사용법: CURDATE()

현재 날짜를 YYYY-MM-DD 형식의 값으로 반환해요. 이 함수는 문이 실행되는 시점의 UTC 현재 날짜를 반환해요.

매개변수: 없음

반환 타입: DATE

예제

source=people
| eval `CURDATE()` = CURDATE()
| fields `CURDATE()`

쿼리는 다음과 같은 결과를 반환해요:

CURDATE()
2025-08-02

CURRENT_DATE

사용법: CURRENT_DATE()

CURDATE()의 동의어예요.

매개변수: 없음

반환 타입: DATE

예제

source=people
| eval `CURRENT_DATE()` = CURRENT_DATE()
| fields `CURRENT_DATE()`

쿼리는 다음과 같은 결과를 반환해요:

CURRENT_DATE()
2025-08-02

CURRENT_TIME

사용법: CURRENT_TIME()

CURTIME()의 동의어예요.

매개변수: 없음

반환 타입: TIME

예제

source=people
| eval `CURRENT_TIME()` = CURRENT_TIME()
| fields `CURRENT_TIME()`

쿼리는 다음과 같은 결과를 반환해요:

CURRENT_TIME()
15:39:05

CURRENT_TIMESTAMP

사용법: CURRENT_TIMESTAMP()

NOW()의 동의어예요.

매개변수: 없음

반환 타입: TIMESTAMP

예제

source=people
| eval `CURRENT_TIMESTAMP()` = CURRENT_TIMESTAMP()
| fields `CURRENT_TIMESTAMP()`

쿼리는 다음과 같은 결과를 반환해요:

CURRENT_TIMESTAMP()
2025-08-02 15:54:19

CURTIME

사용법: CURTIME()

UTC 시간대에서 현재 시간을 hh:mm:ss 형식의 값으로 반환해요. CURTIME()은 NOW()처럼 문이 실행을 시작한 시점의 시간을 반환해요.

매개변수: 없음

반환 타입: TIME

예제

source=people
| eval `value_1` = CURTIME(), `value_2` = CURTIME()
| fields `value_1`, `value_2`

쿼리는 다음과 같은 결과를 반환해요:

value_1 | value_2
15:39:05 | 15:39:05

DATE

사용법: DATE(expr)

입력 문자열 expr에서 date 타입을 구성해요. 인수가 date 또는 timestamp면 표현식에서 날짜 값 부분을 추출해요.

매개변수:

expr (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: DATE

예제

다음 예제는 문자열에서 날짜를 추출해요:

source=people
| eval `DATE('2020-08-26')` = DATE('2020-08-26')
| fields `DATE('2020-08-26')`

쿼리는 다음과 같은 결과를 반환해요:

DATE('2020-08-26')
2020-08-26

다음 예제는 타임스탬프에서 날짜를 추출해요:

source=people
| eval `DATE(TIMESTAMP('2020-08-26 13:49:00'))` = DATE(TIMESTAMP('2020-08-26 13:49:00'))
| fields `DATE(TIMESTAMP('2020-08-26 13:49:00'))`

쿼리는 다음과 같은 결과를 반환해요:

DATE(TIMESTAMP('2020-08-26 13:49:00'))
2020-08-26

다음 예제는 날짜와 시간을 모두 포함하는 문자열에서 날짜를 추출해요:

source=people
| eval `DATE('2020-08-26 13:49')` = DATE('2020-08-26 13:49')
| fields `DATE('2020-08-26 13:49')`

쿼리는 다음과 같은 결과를 반환해요:

DATE('2020-08-26 13:49')
2020-08-26

DATE_ADD

사용법: DATE_ADD(date, INTERVAL expr unit)

간격 expr을 date에 더해요. 첫 번째 인수가 TIME이면 오늘 날짜를 사용해요. 첫 번째 인수가 DATE면 자정의 시간이 사용돼요.

매개변수:

date (필수): DATE, TIMESTAMP, 또는 TIME 값이에요.
INTERVAL expr unit (필수): INTERVAL 표현식이에요.

반환 타입: TIMESTAMP

동의어 (Synonyms): ADDDATE 반의어 (Antonyms): DATE_SUB

예제

source=people
| eval `'2020-08-26' + 1h` = DATE_ADD(DATE('2020-08-26'), INTERVAL 1 HOUR), `ts '2020-08-26 01:01:01' + 1d` = DATE_ADD(TIMESTAMP('2020-08-26 01:01:01'), INTERVAL 1 DAY)
| fields `'2020-08-26' + 1h`, `ts '2020-08-26 01:01:01' + 1d`

쿼리는 다음과 같은 결과를 반환해요:

'2020-08-26' + 1h | ts '2020-08-26 01:01:01' + 1d
2020-08-26 01:00:00 | 2020-08-27 01:01:01

DATE_FORMAT

사용법: DATE_FORMAT(date, format)

format 인수의 지정자(specifier)를 사용해 date 인수를 포맷해요. TIME 타입의 인수가 제공되면 로컬 날짜가 사용돼요.

매개변수:

date (필수): STRING, DATE, TIME, 또는 TIMESTAMP 값이에요.
format (필수): 형식 지정자를 포함하는 STRING이에요.

반환 타입: STRING

다음 표는 사용 가능한 형식 지정자를 설명해요.

지정자	설명
`%a`	축약된 요일 이름 (Sun..Sat)
`%b`	축약된 월 이름 (Jan..Dec)
`%c`	월, 숫자 (0..12)
`%D`	영어 접미사가 붙은 날 (0th, 1st, 2nd, 3rd, …)
`%d`	월의 일, 숫자 (00..31)
`%e`	월의 일, 숫자 (0..31)
`%f`	마이크로초 (000000..999999)
`%H`	시간 (00..23)
`%h`	시간 (01..12)
`%I`	시간 (01..12)
`%i`	분, 숫자 (00..59)
`%j`	연중 일 (001..366)
`%k`	시간 (0..23)
`%l`	시간 (1..12)
`%M`	월 이름 (January..December)
`%m`	월, 숫자 (00..12)
`%p`	AM 또는 PM
`%r`	시간, 12시간제 (hh:mm:ss 뒤에 AM 또는 PM)
`%S`	초 (00..59)
`%s`	초 (00..59)
`%T`	시간, 24시간제 (hh:mm:ss)
`%U`	주 (00..53), 일요일이 주의 첫 날; `WEEK()` 모드 0
`%u`	주 (00..53), 월요일이 주의 첫 날; `WEEK()` 모드 1
`%V`	주 (01..53), 일요일이 주의 첫 날; `WEEK()` 모드 2; `%X`와 함께 사용
`%v`	주 (01..53), 월요일이 주의 첫 날; `WEEK()` 모드 3; `%x`와 함께 사용
`%W`	요일 이름 (Sunday..Saturday)
`%w`	요일 (0=Sunday..6=Saturday)
`%X`	일요일이 주의 첫 날인 주의 연도, 숫자, 네 자리; `%V`와 함께 사용
`%x`	월요일이 주의 첫 날인 주의 연도, 숫자, 네 자리; `%v`와 함께 사용
`%Y`	연도, 숫자, 네 자리
`%y`	연도, 숫자 (두 자리)
`%%`	리터럴 `%` 문자
`x`	`[aydmshiHIMYDSEL]`을 제외한 모든 소문자/대문자 알파벳의 x

예제

source=people
| eval `DATE_FORMAT('1998-01-31 13:14:15.012345', '%T.%f')` = DATE_FORMAT('1998-01-31 13:14:15.012345', '%T.%f'), `DATE_FORMAT(TIMESTAMP('1998-01-31 13:14:15.012345'), '%Y-%b-%D %r')` = DATE_FORMAT(TIMESTAMP('1998-01-31 13:14:15.012345'), '%Y-%b-%D %r')
| fields `DATE_FORMAT('1998-01-31 13:14:15.012345', '%T.%f')`, `DATE_FORMAT(TIMESTAMP('1998-01-31 13:14:15.012345'), '%Y-%b-%D %r')`

쿼리는 다음과 같은 결과를 반환해요:

DATE_FORMAT('1998-01-31 13:14:15.012345', '%T.%f') | DATE_FORMAT(TIMESTAMP('1998-01-31 13:14:15.012345'), '%Y-%b-%D %r')
13:14:15.012345 | 1998-Jan-31st 01:14:15 PM

DATETIME

사용법: DATETIME(timestamp) 또는 DATETIME(date, to_timezone)

datetime을 새 시간대로 변환해요.

매개변수:

timestamp (필수): TIMESTAMP 또는 STRING 값이에요.
to_timezone (선택): STRING 시간대 값이에요.

반환 타입: TIMESTAMP

예제

다음 예제는 datetime을 다른 시간대로 변환해요:

source=people
| eval `DATETIME('2004-02-28 23:00:00-10:00', '+10:00')` = DATETIME('2004-02-28 23:00:00-10:00', '+10:00')
| fields `DATETIME('2004-02-28 23:00:00-10:00', '+10:00')`

쿼리는 다음과 같은 결과를 반환해요:

DATETIME('2004-02-28 23:00:00-10:00', '+10:00')
2004-02-29 19:00:00

유효 시간대 범위는 (-13:59, +14:00)을 포함해요. 다음 예제는 이 범위를 벗어나는 시간대가 NULL을 반환함을 보여줘요:

source=people
| eval  `DATETIME('2008-01-01 02:00:00', '-14:00')` = DATETIME('2008-01-01 02:00:00', '-14:00')
| fields `DATETIME('2008-01-01 02:00:00', '-14:00')`

쿼리는 다음과 같은 결과를 반환해요:

DATETIME('2008-01-01 02:00:00', '-14:00')
null

DATE_SUB

사용법: DATE_SUB(date, INTERVAL expr unit)

date에서 간격 expr을 빼요. 첫 번째 인수가 TIME이면 오늘 날짜를 사용해요. 첫 번째 인수가 DATE면 자정의 시간이 사용돼요.

매개변수:

date (필수): DATE, TIMESTAMP, 또는 TIME 값이에요.
INTERVAL expr unit (필수): INTERVAL 표현식이에요.

반환 타입: TIMESTAMP

동의어 (Synonyms): SUBDATE 반의어 (Antonyms): DATE_ADD

예제

source=people
| eval `'2008-01-02' - 31d` = DATE_SUB(DATE('2008-01-02'), INTERVAL 31 DAY), `ts '2020-08-26 01:01:01' + 1h` = DATE_SUB(TIMESTAMP('2020-08-26 01:01:01'), INTERVAL 1 HOUR)
| fields `'2008-01-02' - 31d`, `ts '2020-08-26 01:01:01' + 1h`

쿼리는 다음과 같은 결과를 반환해요:

'2008-01-02' - 31d | ts '2020-08-26 01:01:01' + 1h
2007-12-02 00:00:00 | 2020-08-26 00:01:01

DATEDIFF

사용법: DATEDIFF(date1, date2)

주어진 값들의 날짜 부분 차이를 계산해요. 첫 번째 인수가 TIME이면 오늘 날짜를 사용해요.

매개변수:

date1 (필수): DATE, TIMESTAMP, 또는 TIME 값이에요.
date2 (필수): DATE, TIMESTAMP, 또는 TIME 값이에요.

반환 타입: LONG

예제

source=people
| eval `'2000-01-02' - '2000-01-01'` = DATEDIFF(TIMESTAMP('2000-01-02 00:00:00'), TIMESTAMP('2000-01-01 23:59:59')), `'2001-02-01' - '2004-01-01'` = DATEDIFF(DATE('2001-02-01'), TIMESTAMP('2004-01-01 00:00:00')), `today - today` = DATEDIFF(TIME('23:59:59'), TIME('00:00:00'))
| fields `'2000-01-02' - '2000-01-01'`, `'2001-02-01' - '2004-01-01'`, `today - today`

쿼리는 다음과 같은 결과를 반환해요:

'2000-01-02' - '2000-01-01' | '2001-02-01' - '2004-01-01' | today - today
1 | -1064 | 0

DAY

사용법: DAY(date)

date의 월의 일을 1부터 31 범위로 추출해요.

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): DAYOFMONTH, DAY_OF_MONTH

예제

source=people
| eval `DAY(DATE('2020-08-26'))` = DAY(DATE('2020-08-26'))
| fields `DAY(DATE('2020-08-26'))`

쿼리는 다음과 같은 결과를 반환해요:

DAY(DATE('2020-08-26'))
26

DAYNAME

사용법: DAYNAME(date)

date의 요일 이름을 반환해요.

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: STRING

예제

source=people
| eval `DAYNAME(DATE('2020-08-26'))` = DAYNAME(DATE('2020-08-26'))
| fields `DAYNAME(DATE('2020-08-26'))`

쿼리는 다음과 같은 결과를 반환해요:

DAYNAME(DATE('2020-08-26'))
Wednesday

DAYOFMONTH

사용법: DAYOFMONTH(date)

date의 월의 일을 1부터 31 범위로 추출해요.

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): DAY, DAY_OF_MONTH

예제

source=people
| eval `DAYOFMONTH(DATE('2020-08-26'))` = DAYOFMONTH(DATE('2020-08-26'))
| fields `DAYOFMONTH(DATE('2020-08-26'))`

쿼리는 다음과 같은 결과를 반환해요:

DAYOFMONTH(DATE('2020-08-26'))
26

DAY_OF_MONTH

사용법: DAY_OF_MONTH(date)

date의 월의 일을 1부터 31 범위로 추출해요.

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): DAY, DAYOFMONTH

예제

source=people
| eval `DAY_OF_MONTH(DATE('2020-08-26'))` = DAY_OF_MONTH(DATE('2020-08-26'))
| fields `DAY_OF_MONTH(DATE('2020-08-26'))`

쿼리는 다음과 같은 결과를 반환해요:

DAY_OF_MONTH(DATE('2020-08-26'))
26

DAYOFWEEK

사용법: DAYOFWEEK(date)

date의 요일 인덱스를 반환해요 (1 = Sunday, 2 = Monday, …, 7 = Saturday).

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): DAY_OF_WEEK

예제

source=people
| eval `DAYOFWEEK(DATE('2020-08-26'))` = DAYOFWEEK(DATE('2020-08-26'))
| fields `DAYOFWEEK(DATE('2020-08-26'))`

쿼리는 다음과 같은 결과를 반환해요:

DAYOFWEEK(DATE('2020-08-26'))
4

DAY_OF_WEEK

사용법: DAY_OF_WEEK(date)

date의 요일 인덱스를 반환해요 (1 = Sunday, 2 = Monday, …, 7 = Saturday).

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): DAYOFWEEK

예제

source=people
| eval `DAY_OF_WEEK(DATE('2020-08-26'))` = DAY_OF_WEEK(DATE('2020-08-26'))
| fields `DAY_OF_WEEK(DATE('2020-08-26'))`

쿼리는 다음과 같은 결과를 반환해요:

DAY_OF_WEEK(DATE('2020-08-26'))
4

DAYOFYEAR

사용법: DAYOFYEAR(date)

date의 연중 일을 1부터 366 범위로 반환해요.

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): DAY_OF_YEAR

예제

source=people
| eval `DAYOFYEAR(DATE('2020-08-26'))` = DAYOFYEAR(DATE('2020-08-26'))
| fields `DAYOFYEAR(DATE('2020-08-26'))`

쿼리는 다음과 같은 결과를 반환해요:

DAYOFYEAR(DATE('2020-08-26'))
239

DAY_OF_YEAR

사용법: DAY_OF_YEAR(date)

date의 연중 일을 1부터 366 범위로 반환해요.

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): DAYOFYEAR

예제

source=people
| eval `DAY_OF_YEAR(DATE('2020-08-26'))` = DAY_OF_YEAR(DATE('2020-08-26'))
| fields `DAY_OF_YEAR(DATE('2020-08-26'))`

쿼리는 다음과 같은 결과를 반환해요:

DAY_OF_YEAR(DATE('2020-08-26'))
239

EXTRACT

사용법: EXTRACT(part FROM date)

주어진 part 인수에 따라 순서대로 숫자를 포함하는 LONG을 반환해요. 반환된 LONG의 구체적인 형식은 다음 표에 따라 결정돼요.

매개변수:

part (필수): part 토큰 (다음 표 참고)이에요.
date (필수): STRING, DATE, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: LONG

이 표의 형식 지정자는 DATE_FORMAT 함수에 있는 것과 동일해요. 다음 표는 part를 특정 형식에 매핑하는 방법을 설명해요.

part	Format
`MICROSECOND`	`%f`
`SECOND`	`%s`
`MINUTE`	`%i`
`HOUR`	`%H`
`DAY`	`%d`
`WEEK`	`%X`
`MONTH`	`%m`
`YEAR`	`%V`
`SECOND_MICROSECOND`	`%s%f`
`MINUTE_MICROSECOND`	`%i%s%f`
`MINUTE_SECOND`	`%i%s`
`HOUR_MICROSECOND`	`%H%i%s%f`
`HOUR_SECOND`	`%H%i%s`
`HOUR_MINUTE`	`%H%i`
`DAY_MICROSECOND`	`%d%H%i%s%f`
`DAY_SECOND`	`%d%H%i%s`
`DAY_MINUTE`	`%d%H%i`
`DAY_HOUR`	`%d%H%`
`YEAR_MONTH`	`%V%m`

예제

source=people
| eval `extract(YEAR_MONTH FROM "2023-02-07 10:11:12")` = extract(YEAR_MONTH FROM "2023-02-07 10:11:12")
| fields `extract(YEAR_MONTH FROM "2023-02-07 10:11:12")`

쿼리는 다음과 같은 결과를 반환해요:

extract(YEAR_MONTH FROM "2023-02-07 10:11:12")
202302

FROM_DAYS

사용법: FROM_DAYS(N)

일 번호 N이 주어졌을 때 날짜 값을 반환해요.

매개변수:

N (필수): INTEGER 또는 LONG 값이에요.

반환 타입: DATE

예제

source=people
| eval `FROM_DAYS(733687)` = FROM_DAYS(733687)
| fields `FROM_DAYS(733687)`

쿼리는 다음과 같은 결과를 반환해요:

FROM_DAYS(733687)
2008-10-07

FROM_UNIXTIME

사용법: FROM_UNIXTIME(timestamp) 또는 FROM_UNIXTIME(timestamp, format)

인수를 타임스탬프 또는 문자 문자열 값으로 나타낸 표현을 반환해요. UNIX_TIMESTAMP 함수의 역변환을 수행해요. 두 번째 인수가 제공되면 DATE_FORMAT 함수에 사용된 형식 문자열과 같은 방식으로 결과를 포맷하는 데 사용돼요. 타임스탬프가 1970-01-01 00:00:00 – 3001-01-18 23:59:59.999999 범위(에포크 시간 0에서 32536771199.999999) 밖이면 NULL을 반환해요.

매개변수:

timestamp (필수): Unix 타임스탬프를 나타내는 DOUBLE 값이에요.
format (선택): STRING 형식 지정자예요.

반환 타입: TIMESTAMP (format 없음), STRING (format 포함)

예제

source=people
| eval `FROM_UNIXTIME(1220249547)` = FROM_UNIXTIME(1220249547)
| fields `FROM_UNIXTIME(1220249547)`

쿼리는 다음과 같은 결과를 반환해요:

FROM_UNIXTIME(1220249547)
2008-09-01 06:12:27

source=people
| eval `FROM_UNIXTIME(1220249547, '%T')` = FROM_UNIXTIME(1220249547, '%T')
| fields `FROM_UNIXTIME(1220249547, '%T')`

쿼리는 다음과 같은 결과를 반환해요:

FROM_UNIXTIME(1220249547, '%T')
06:12:27

GET_FORMAT

사용법: GET_FORMAT(type, format)

입력 인수에 따라 문자열 형식 지정자를 포함하는 문자열 값을 반환해요.

매개변수:

type (필수): DATE, TIME, TIMESTAMP 토큰 중 하나예요.
format (필수): USA, JIS, ISO, EUR, INTERNAL 중 하나여야 하는 STRING이에요.

반환 타입: STRING

예제

source=people
| eval `GET_FORMAT(DATE, 'USA')` = GET_FORMAT(DATE, 'USA')
| fields `GET_FORMAT(DATE, 'USA')`

쿼리는 다음과 같은 결과를 반환해요:

GET_FORMAT(DATE, 'USA')
%m.%d.%Y

HOUR

사용법: HOUR(time)

time의 시간 값을 추출해요. 하루 중 시간 값과 달리 time 값은 범위가 넓고 23보다 클 수 있으므로 HOUR(time)의 반환 값도 23보다 클 수 있어요.

매개변수:

time (필수): STRING, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): HOUR_OF_DAY

예제

source=people
| eval `HOUR(TIME('01:02:03'))` = HOUR(TIME('01:02:03'))
| fields `HOUR(TIME('01:02:03'))`

쿼리는 다음과 같은 결과를 반환해요:

HOUR(TIME('01:02:03'))
1

HOUR_OF_DAY

사용법: HOUR_OF_DAY(time)

time의 시간 값을 추출해요. 하루 중 시간 값과 달리 time 값은 범위가 넓고 23보다 클 수 있으므로 HOUR_OF_DAY(time)의 반환 값도 23보다 클 수 있어요.

매개변수:

time (필수): STRING, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): HOUR

예제

source=people
| eval `HOUR_OF_DAY(TIME('01:02:03'))` = HOUR_OF_DAY(TIME('01:02:03'))
| fields `HOUR_OF_DAY(TIME('01:02:03'))`

쿼리는 다음과 같은 결과를 반환해요:

HOUR_OF_DAY(TIME('01:02:03'))
1

LAST_DAY

사용법: LAST_DAY(date)

유효한 인수에 대해 월의 마지막 날을 DATE로 반환해요.

매개변수:

date (필수): DATE, STRING, TIMESTAMP, 또는 TIME 값이에요.

반환 타입: DATE

예제

source=people
| eval `last_day('2023-02-06')` = last_day('2023-02-06')
| fields `last_day('2023-02-06')`

쿼리는 다음과 같은 결과를 반환해요:

last_day('2023-02-06')
2023-02-28

LOCALTIMESTAMP

사용법: LOCALTIMESTAMP()

LOCALTIMESTAMP()는 NOW()의 동의어예요.

매개변수: 없음

반환 타입: TIMESTAMP

예제

source=people
| eval `LOCALTIMESTAMP()` = LOCALTIMESTAMP()
| fields `LOCALTIMESTAMP()`

쿼리는 다음과 같은 결과를 반환해요:

LOCALTIMESTAMP()
2025-08-02 15:54:19

LOCALTIME

사용법: LOCALTIME()

LOCALTIME()은 NOW()의 동의어예요.

매개변수: 없음

반환 타입: TIMESTAMP

예제

source=people
| eval `LOCALTIME()` = LOCALTIME()
| fields `LOCALTIME()`

쿼리는 다음과 같은 결과를 반환해요:

LOCALTIME()
2025-08-02 15:54:19

MAKEDATE

사용법: MAKEDATE(year, dayofyear)

year와 day-of-year 값이 주어졌을 때 날짜를 반환해요. dayofyear는 0보다 커야 하며, 그렇지 않으면 결과는 NULL이에요. 두 인수 중 하나라도 NULL이면 결과도 NULL이에요. 인수는 정수로 반올림돼요.

매개변수:

year (필수): 연도에 대한 DOUBLE 값이에요.
dayofyear (필수): 연중 일에 대한 DOUBLE 값이에요.

반환 타입: DATE

제한 사항:

0 연도는 2000으로 해석돼요
음수 연도는 허용되지 않아요
day-of-year는 0보다 커야 해요
day-of-year는 365/366보다 클 수 있으며, 계산은 다음 해로 넘어가요 (예제 참고)

예제

source=people
| eval `MAKEDATE(1945, 5.9)` = MAKEDATE(1945, 5.9), `MAKEDATE(1984, 1984)` = MAKEDATE(1984, 1984)
| fields `MAKEDATE(1945, 5.9)`, `MAKEDATE(1984, 1984)`

쿼리는 다음과 같은 결과를 반환해요:

MAKEDATE(1945, 5.9) | MAKEDATE(1984, 1984)
1945-01-06 | 1989-06-06

MAKETIME

사용법: MAKETIME(hour, minute, second)

hour, minute, second 인수에서 계산된 시간 값을 반환해요. 인수 중 하나라도 NULL이면 NULL을 반환해요. second 인수는 소수 부분을 가질 수 있고, 나머지 인수는 정수로 반올림돼요.

매개변수:

hour (필수): 시간에 대한 DOUBLE 값이에요.
minute (필수): 분에 대한 DOUBLE 값이에요.
second (필수): 초에 대한 DOUBLE 값이에요.

반환 타입: TIME

제한 사항:

24시간제가 사용되며, 사용 가능한 시간 범위는 [00:00:00.0 – 23:59:59.(9)]이에요
초의 소수 부분은 최대 9자리까지 사용돼요 (나노초 정밀도)

예제

source=people
| eval `MAKETIME(20, 30, 40)` = MAKETIME(20, 30, 40), `MAKETIME(20.2, 49.5, 42.100502)` = MAKETIME(20.2, 49.5, 42.100502)
| fields `MAKETIME(20, 30, 40)`, `MAKETIME(20.2, 49.5, 42.100502)`

쿼리는 다음과 같은 결과를 반환해요:

MAKETIME(20, 30, 40) | MAKETIME(20.2, 49.5, 42.100502)
20:30:40 | 20:50:42.100502

MICROSECOND

사용법: MICROSECOND(expr)

시간 또는 타임스탬프 표현식 expr에서 마이크로초를 0부터 999999 범위의 숫자로 반환해요.

매개변수:

expr (필수): STRING, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

예제

source=people
| eval `MICROSECOND(TIME('01:02:03.123456'))` = MICROSECOND(TIME('01:02:03.123456'))
| fields `MICROSECOND(TIME('01:02:03.123456'))`

쿼리는 다음과 같은 결과를 반환해요:

MICROSECOND(TIME('01:02:03.123456'))
123456

MINUTE

사용법: MINUTE(time)

time의 분을 0부터 59 범위로 반환해요.

매개변수:

time (필수): STRING, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): MINUTE_OF_HOUR

예제

source=people
| eval `MINUTE(TIME('01:02:03'))` =  MINUTE(TIME('01:02:03'))
| fields `MINUTE(TIME('01:02:03'))`

쿼리는 다음과 같은 결과를 반환해요:

MINUTE(TIME('01:02:03'))
2

MINUTE_OF_DAY

사용법: MINUTE_OF_DAY(time)

하루의 분 단위 양을 0부터 1439 범위로 반환해요.

매개변수:

time (필수): STRING, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

예제

source=people
| eval `MINUTE_OF_DAY(TIME('01:02:03'))` = MINUTE_OF_DAY(TIME('01:02:03'))
| fields `MINUTE_OF_DAY(TIME('01:02:03'))`

쿼리는 다음과 같은 결과를 반환해요:

MINUTE_OF_DAY(TIME('01:02:03'))
62

MINUTE_OF_HOUR

사용법: MINUTE_OF_HOUR(time)

time의 분을 0부터 59 범위로 반환해요.

매개변수:

time (필수): STRING, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): MINUTE

예제

source=people
| eval `MINUTE_OF_HOUR(TIME('01:02:03'))` =  MINUTE_OF_HOUR(TIME('01:02:03'))
| fields `MINUTE_OF_HOUR(TIME('01:02:03'))`

쿼리는 다음과 같은 결과를 반환해요:

MINUTE_OF_HOUR(TIME('01:02:03'))
2

MONTH

사용법: MONTH(date)

date의 월을 1월부터 12월까지 1에서 12 범위로 반환해요.

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): MONTH_OF_YEAR

예제

source=people
| eval `MONTH(DATE('2020-08-26'))` =  MONTH(DATE('2020-08-26'))
| fields `MONTH(DATE('2020-08-26'))`

쿼리는 다음과 같은 결과를 반환해요:

MONTH(DATE('2020-08-26'))
8

MONTH_OF_YEAR

사용법: MONTH_OF_YEAR(date)

date의 월을 1월부터 12월까지 1에서 12 범위로 반환해요.

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): MONTH

예제

source=people
| eval `MONTH_OF_YEAR(DATE('2020-08-26'))` =  MONTH_OF_YEAR(DATE('2020-08-26'))
| fields `MONTH_OF_YEAR(DATE('2020-08-26'))`

쿼리는 다음과 같은 결과를 반환해요:

MONTH_OF_YEAR(DATE('2020-08-26'))
8

MONTHNAME

사용법: MONTHNAME(date)

date의 전체 월 이름을 반환해요.

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: STRING

예제

source=people
| eval `MONTHNAME(DATE('2020-08-26'))` = MONTHNAME(DATE('2020-08-26'))
| fields `MONTHNAME(DATE('2020-08-26'))`

쿼리는 다음과 같은 결과를 반환해요:

MONTHNAME(DATE('2020-08-26'))
August

NOW

사용법: NOW()

현재 날짜와 시간을 'YYYY-MM-DD hh:mm:ss' 형식의 값으로 반환해요. 값은 UTC 시간대로 표시돼요. NOW()는 문이 실행을 시작한 시점을 나타내는 상수 시간을 반환해요. 이것은 정확히 실행되는 시점을 반환하는 SYSDATE()의 동작과 다르다는 점을 유의하세요.

매개변수: 없음

반환 타입: TIMESTAMP

예제

source=people
| eval `value_1` = NOW(), `value_2` = NOW()
| fields `value_1`, `value_2`

쿼리는 다음과 같은 결과를 반환해요:

value_1 | value_2
2025-08-02 15:39:05 | 2025-08-02 15:39:05

PERIOD_ADD

사용법: PERIOD_ADD(P, N)

기간 P(YYMM 또는 YYYYMM 형식)에 N개월을 더해요. YYYYMM 형식의 값을 반환해요.

매개변수:

P (필수): YYMM 또는 YYYYMM 형식의 기간을 나타내는 INTEGER 값이에요.
N (필수): 더할 월 수인 INTEGER예요.

반환 타입: INTEGER

예제

source=people
| eval `PERIOD_ADD(200801, 2)` = PERIOD_ADD(200801, 2), `PERIOD_ADD(200801, -12)` = PERIOD_ADD(200801, -12)
| fields `PERIOD_ADD(200801, 2)`, `PERIOD_ADD(200801, -12)`

쿼리는 다음과 같은 결과를 반환해요:

PERIOD_ADD(200801, 2) | PERIOD_ADD(200801, -12)
200803 | 200701

PERIOD_DIFF

사용법: PERIOD_DIFF(P1, P2)

YYMM 또는 YYYYMM 형식으로 주어진 기간 P1과 P2 사이의 월 수를 반환해요.

매개변수:

P1 (필수): YYMM 또는 YYYYMM 형식의 기간을 나타내는 INTEGER 값이에요.
P2 (필수): YYMM 또는 YYYYMM 형식의 기간을 나타내는 INTEGER 값이에요.

반환 타입: INTEGER

예제

source=people
| eval `PERIOD_DIFF(200802, 200703)` = PERIOD_DIFF(200802, 200703), `PERIOD_DIFF(200802, 201003)` = PERIOD_DIFF(200802, 201003)
| fields `PERIOD_DIFF(200802, 200703)`, `PERIOD_DIFF(200802, 201003)`

쿼리는 다음과 같은 결과를 반환해요:

PERIOD_DIFF(200802, 200703) | PERIOD_DIFF(200802, 201003)
11 | -25

QUARTER

사용법: QUARTER(date)

date의 연도 분기를 1부터 4 범위로 반환해요.

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

예제

source=people
| eval `QUARTER(DATE('2020-08-26'))` = QUARTER(DATE('2020-08-26'))
| fields `QUARTER(DATE('2020-08-26'))`

쿼리는 다음과 같은 결과를 반환해요:

QUARTER(DATE('2020-08-26'))
3

SEC_TO_TIME

사용법: SEC_TO_TIME(number)

HH:mm:ss[.nnnnnn] 형식의 시간을 반환해요. 이 함수는 00:00:00과 23:59:59 사이의 시간을 반환함을 유의하세요. 입력 값이 너무 크면(86399보다 크면) 함수는 00:00:00부터 다시 반환하기 시작하며 순환(wrap around)해요. 입력 값이 너무 작으면(0보다 작으면) 함수는 23:59:59부터 거꾸로 세기 시작하며 순환해요.

매개변수:

number (필수): INTEGER, LONG, DOUBLE, 또는 FLOAT 값이에요.

반환 타입: TIME

예제

source=people
| eval `SEC_TO_TIME(3601)` = SEC_TO_TIME(3601)
| eval `SEC_TO_TIME(1234.123)` = SEC_TO_TIME(1234.123)
| fields `SEC_TO_TIME(3601)`, `SEC_TO_TIME(1234.123)`

쿼리는 다음과 같은 결과를 반환해요:

SEC_TO_TIME(3601) | SEC_TO_TIME(1234.123)
01:00:01 | 00:20:34.123

SECOND

사용법: SECOND(time)

time의 초를 0부터 59 범위로 반환해요.

매개변수:

time (필수): STRING, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): SECOND_OF_MINUTE

예제

source=people
| eval `SECOND(TIME('01:02:03'))` = SECOND(TIME('01:02:03'))
| fields `SECOND(TIME('01:02:03'))`

쿼리는 다음과 같은 결과를 반환해요:

SECOND(TIME('01:02:03'))
3

SECOND_OF_MINUTE

사용법: SECOND_OF_MINUTE(time)

time의 초를 0부터 59 범위로 반환해요.

매개변수:

time (필수): STRING, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

동의어 (Synonyms): SECOND

예제

source=people
| eval `SECOND_OF_MINUTE(TIME('01:02:03'))` = SECOND_OF_MINUTE(TIME('01:02:03'))
| fields `SECOND_OF_MINUTE(TIME('01:02:03'))`

쿼리는 다음과 같은 결과를 반환해요:

SECOND_OF_MINUTE(TIME('01:02:03'))
3

STRFTIME

버전: 3.3.0

사용법: STRFTIME(time, format)

UNIX 타임스탬프(초)를 받아 지정된 형식을 사용해 문자열로 렌더링해요. 숫자 입력의 경우 UNIX 시간은 초 단위여야 해요. 100000000000보다 큰 값은 자동으로 밀리초로 간주되어 초로 변환돼요. strftime 함수로 시간 형식 변수를 사용할 수 있어요. 이 함수는 UNIX_TIMESTAMP의 역연산을 수행하며, POSIX 스타일 형식 지정자를 사용한다는 점을 제외하면 FROM_UNIXTIME과 유사해요.

매개변수:

time (필수): INTEGER, LONG, DOUBLE, 또는 TIMESTAMP 값이에요.
format (필수): STRING 형식 지정자예요.

반환 타입: STRING

참고:

Calcite 엔진이 활성화된 경우에만 사용 가능해요
모든 타임스탬프는 UTC 시간대로 해석돼요
텍스트 포맷은 언어 중립적인 Locale.ROOT를 사용해요 (요일과 월 이름이 축약 형태로 나타남)
문자열 입력은 지원되지 않아요 - 먼저 unix_timestamp()를 사용해 문자열을 변환하세요
날짜/시간 값을 반환하는 함수(예: date(), now(), timestamp())는 지원돼요

다음 표는 사용 가능한 지정자 인수를 설명해요.

지정자	설명
`%a`	축약된 요일 이름 (Mon..Sun)
`%A`	요일 이름 (Mon..Sun) - 참고: `Locale.ROOT`는 축약 형태를 사용
`%b`	축약된 월 이름 (Jan..Dec)
`%B`	월 이름 (Jan..Dec) - 참고: `Locale.ROOT`는 축약 형태를 사용
`%c`	날짜와 시간 (예: Mon Jul 18 09:30:00 2019)
`%C`	세기, 2자리 10진수
`%d`	월의 일, 0으로 채움 (01..31)
`%e`	월의 일, 공백으로 채움 ( 1..31)
`%Ez`	UTC로부터의 시간대 오프셋(분) (예: UTC는 +0, IST는 +330, EST는 -300)
`%f`	마이크로초, 10진수 (000000..999999)
`%F`	ISO 8601 날짜 형식 (`%Y-%m-%d`)
`%g`	세기가 없는 ISO 8601 연도 (00..99)
`%G`	세기가 있는 ISO 8601 연도
`%H`	시간 (24시간제) (00..23)
`%I`	시간 (12시간제) (01..12)
`%j`	연중 일 (001..366)
`%k`	시간 (24시간제), 공백으로 채움 ( 0..23)
`%m`	월, 10진수 (01..12)
`%M`	분 (00..59)
`%N`	초 이하 자릿수 (기본 `%9N` = 나노초). 1-9의 정밀도 값을 허용해요 (예: `%3N` = 3자리, `%5N` = 5자리, `%9N` = 9자리). 정밀도가 표시되는 자릿수를 직접 제어해요
`%p`	AM 또는 PM
`%Q`	초 이하 구성 요소 (기본 밀리초). 정밀도를 지정할 수 있어요: `%3Q` = 밀리초, `%6Q` = 마이크로초, `%9Q` = 나노초. 다른 정밀도 값(예: `%5Q`)은 `%3Q`로 기본 설정돼요
`%s`	UNIX 에포크 타임스탬프(초)
`%S`	초 (00..59)
`%T`	24시간 표기 시간 (`%H:%M:%S`)
`%U`	0부터 시작하는 연중 주 (00..53)
`%V`	ISO 주 번호 (01..53)
`%w`	요일, 10진수 (0=Sunday..6=Saturday)
`%x`	MM/dd/yyyy 형식의 날짜 (예: 07/13/2019)
`%X`	HH:mm:ss 형식의 시간 (예: 09:30:00)
`%y`	세기가 없는 연도 (00..99)
`%Y`	세기가 있는 연도
`%z`	시간대 오프셋 (+hhmm 또는 -hhmm)
`%:z`	콜론이 있는 시간대 오프셋 (+hh:mm 또는 -hh:mm)
`%::z`	콜론이 있는 시간대 오프셋 (+hh:mm:ss)
`%:::z`	시간만 있는 시간대 오프셋 (+hh 또는 -hh)
`%Z`	시간대 약어 (예: EST, PDT)
`%%`	리터럴 `%` 문자

예제

source=people | eval `strftime(1521467703, "%Y-%m-%dT%H:%M:%S")` = strftime(1521467703, "%Y-%m-%dT%H:%M:%S") | fields `strftime(1521467703, "%Y-%m-%dT%H:%M:%S")`

| strftime(1521467703, "%Y-%m-%dT%H:%M:%S") | | — | | 2018-03-19T13:55:03 |

source=people | eval `strftime(1521467703, "%F %T")` = strftime(1521467703, "%F %T") | fields `strftime(1521467703, "%F %T")`

strftime(1521467703, "%Y-%m-%dT%H:%M:%S")
2018-03-19T13:55:03

source=people | eval `strftime(1521467703, "%a %b %d, %Y")` = strftime(1521467703, "%a %b %d, %Y") | fields `strftime(1521467703, "%a %b %d, %Y")`

| strftime(1521467703, "%a %b %d, %Y") | | — | | Mon Mar 19, 2018 |

source=people | eval `strftime(1521467703, "%%Y")` = strftime(1521467703, "%%Y") | fields `strftime(1521467703, "%%Y")`

| strftime(1521467703, "%%Y") | | — | | %Y |

source=people | eval `strftime(date('2020-09-16'), "%Y-%m-%d")` = strftime(date('2020-09-16'), "%Y-%m-%d") | fields `strftime(date('2020-09-16'), "%Y-%m-%d")`

  
fetched rows / total rows = 1/1
+----------------------------------------+
| strftime(date('2020-09-16'), "%Y-%m-%d") |
|-----------------------------------------|
| 2020-09-16                             |
  
+----------------------------------------+

  
source=people | eval `strftime(timestamp('2020-09-16 14:30:00'), "%F %T")` = strftime(timestamp('2020-09-16 14:30:00'), "%F %T") | fields `strftime(timestamp('2020-09-16 14:30:00'), "%F %T")`

  
fetched rows / total rows = 1/1
+--------------------------------------------------+
| strftime(timestamp('2020-09-16 14:30:00'), "%F %T") |
|---------------------------------------------------|
| 2020-09-16 14:30:00                              |
  
+--------------------------------------------------+

  
source=people | eval `strftime(now(), "%Y-%m-%d %H:%M:%S")` = strftime(now(), "%Y-%m-%d %H:%M:%S") | fields `strftime(now(), "%Y-%m-%d %H:%M:%S")`

  
fetched rows / total rows = 1/1
+------------------------------------+
| strftime(now(), "%Y-%m-%d %H:%M:%S") |
|-------------------------------------|
| 2025-09-03 12:30:45                |
  
+------------------------------------+

STR_TO_DATE

사용법: STR_TO_DATE(string, format)

두 번째 인수 문자열에 지정된 형식을 사용해 첫 번째 인수 문자열에서 TIMESTAMP를 추출해요. 입력 인수는 DATE, TIMESTAMP, 또는 TIME으로 파싱될 수 있을 만큼 충분한 정보를 가져야 해요. 허용 가능한 문자열 형식 지정자는 DATE_FORMAT 함수에 사용된 것과 동일해요. 유효하지 않은 인수 쌍으로 인해 문을 파싱할 수 없거나 어떤 DATE 필드에 0이 제공된 경우 NULL을 반환해요. 그 외에는 파싱된 값으로 TIMESTAMP를 반환해요 (파싱되지 않은 필드에는 기본 값이 사용돼요).

매개변수:

string (필수): 파싱할 STRING 값이에요.
format (필수): STRING 형식 지정자예요.

반환 타입: TIMESTAMP

예제

  
source=people
| eval `str_to_date("01,5,2013", "%d,%m,%Y")` = str_to_date("01,5,2013", "%d,%m,%Y")
| fields `str_to_date("01,5,2013", "%d,%m,%Y")`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+--------------------------------------+
| str_to_date("01,5,2013", "%d,%m,%Y") |
|--------------------------------------|
| 2013-05-01 00:00:00                  |
  
+--------------------------------------+

SUBDATE

사용법: SUBDATE(date, INTERVAL expr unit) 또는 SUBDATE(date, days)

date에서 간격 expr을 빼거나, 두 번째 인수를 정수 일 수로 date에서 빼요. 첫 번째 인수가 TIME이면 오늘 날짜를 사용해요. 첫 번째 인수가 DATE면 자정의 시간이 사용돼요.

매개변수:

date (필수): DATE, TIMESTAMP, 또는 TIME 값이에요.
expr (필수): INTERVAL 표현식 또는 LONG 일 수 중 하나예요.

반환 타입: TIMESTAMP (INTERVAL 포함), DATE (LONG을 포함한 DATE), TIMESTAMP (LONG을 포함한 TIMESTAMP/TIME)

동의어 (Synonyms): 두 번째 인수의 INTERVAL 형식으로 호출할 때 DATE_SUB 반의어 (Antonyms): ADDDATE

예제

  
source=people
| eval `'2008-01-02' - 31d` = SUBDATE(DATE('2008-01-02'), INTERVAL 31 DAY), `'2020-08-26' - 1` = SUBDATE(DATE('2020-08-26'), 1), `ts '2020-08-26 01:01:01' - 1` = SUBDATE(TIMESTAMP('2020-08-26 01:01:01'), 1)
| fields `'2008-01-02' - 31d`, `'2020-08-26' - 1`, `ts '2020-08-26 01:01:01' - 1`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+---------------------+------------------+------------------------------+
| '2008-01-02' - 31d  | '2020-08-26' - 1 | ts '2020-08-26 01:01:01' - 1 |
|---------------------+------------------+------------------------------|
| 2007-12-02 00:00:00 | 2020-08-25       | 2020-08-25 01:01:01          |
  
+---------------------+------------------+------------------------------+

SUBTIME

사용법: SUBTIME(expr1, expr2)

expr2를 expr1에서 빼고 결과를 반환해요. 인수가 TIME이면 오늘 날짜를 사용해요. 인수가 DATE면 자정의 시간이 사용돼요.

매개변수:

expr1 (필수): DATE, TIMESTAMP, 또는 TIME 값이에요.
expr2 (필수): DATE, TIMESTAMP, 또는 TIME 값이에요.

반환 타입: TIMESTAMP (DATE/TIMESTAMP와 DATE/TIMESTAMP/TIME), TIME (TIME과 DATE/TIMESTAMP/TIME)

반의어 (Antonyms): ADDTIME

예제

  
source=people
| eval `'2008-12-12' - 0` = SUBTIME(DATE('2008-12-12'), DATE('2008-11-15'))
| fields `'2008-12-12' - 0`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+---------------------+
| '2008-12-12' - 0    |
|---------------------|
| 2008-12-12 00:00:00 |
  
+---------------------+

  
source=people
| eval `'23:59:59' - 0` = SUBTIME(TIME('23:59:59'), DATE('2004-01-01'))
| fields `'23:59:59' - 0`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+----------------+
| '23:59:59' - 0 |
|----------------|
| 23:59:59       |
  
+----------------+

  
source=people
| eval `'2004-01-01' - '23:59:59'` = SUBTIME(DATE('2004-01-01'), TIME('23:59:59'))
| fields `'2004-01-01' - '23:59:59'`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+---------------------------+
| '2004-01-01' - '23:59:59' |
|---------------------------|
| 2003-12-31 00:00:01       |
  
+---------------------------+

  
source=people
| eval `'10:20:30' - '00:05:42'` = SUBTIME(TIME('10:20:30'), TIME('00:05:42'))
| fields `'10:20:30' - '00:05:42'`

쿼리는 다음과 같은 결과를 반환해요:

fetched rows / total rows = 1/1
+-------------------------+
| '10:20:30' - '00:05:42' |
|-------------------------|
| 10:14:48                |
  
+-------------------------+

source=people
| eval `'2007-03-01 10:20:30' - '20:40:50'` = SUBTIME(TIMESTAMP('2007-03-01 10:20:30'), TIMESTAMP('2002-03-04 20:40:50'))
| fields `'2007-03-01 10:20:30' - '20:40:50'`

쿼리는 다음과 같은 결과를 반환해요:

fetched rows / total rows = 1/1
+------------------------------------+
| '2007-03-01 10:20:30' - '20:40:50' |
|------------------------------------|
| 2007-02-28 13:39:40                |
  
+------------------------------------+

SYSDATE

사용법: SYSDATE() 또는 SYSDATE(precision)

현재 날짜와 시간을 'YYYY-MM-DD hh:mm:ss[.nnnnnn]' 값으로 반환해요. SYSDATE()는 UTC에서 실행되는 시점의 날짜와 시간을 반환해요. 이것은 문이 실행을 시작한 시점을 나타내는 상수 시간을 반환하는 NOW()의 동작과 다르다는 점을 유의하세요. 인수가 주어지면 0부터 6까지의 소수 초 정밀도를 지정하며, 반환 값에 그 자리수만큼의 소수 초 부분이 포함돼요.

매개변수:

precision (선택): 소수 초 정밀도에 대한 0부터 6까지의 INTEGER 값이에요.

반환 타입: TIMESTAMP

예제

  
source=people
| eval `value_1` = SYSDATE(), `value_2` = SYSDATE(6)
| fields `value_1`, `value_2`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+---------------------+----------------------------+
| value_1             | value_2                    |
|---------------------+----------------------------|
| 2025-08-02 15:39:05 | 2025-08-02 15:39:05.123456 |
  
+---------------------+----------------------------+

TIME

사용법: TIME(expr)

입력 문자열 expr을 시간으로 하는 time 타입을 구성해요. 인수가 date/time/timestamp이면 표현식에서 시간 값 부분을 추출해요.

매개변수:

expr (필수): STRING, DATE, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: TIME

예제

  
source=people
| eval `TIME('13:49:00')` = TIME('13:49:00')
| fields `TIME('13:49:00')`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+------------------+
| TIME('13:49:00') |
|------------------|
| 13:49:00         |
  
+------------------+

  
source=people
| eval `TIME('13:49')` = TIME('13:49')
| fields `TIME('13:49')`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+---------------+
| TIME('13:49') |
|---------------|
| 13:49:00      |
  
+---------------+

  
source=people
| eval `TIME('2020-08-26 13:49:00')` = TIME('2020-08-26 13:49:00')
| fields `TIME('2020-08-26 13:49:00')`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+-----------------------------+
| TIME('2020-08-26 13:49:00') |
|-----------------------------|
| 13:49:00                    |
  
+-----------------------------+

  
source=people
| eval `TIME('2020-08-26 13:49')` = TIME('2020-08-26 13:49')
| fields `TIME('2020-08-26 13:49')`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+--------------------------+
| TIME('2020-08-26 13:49') |
|--------------------------|
| 13:49:00                 |
  
+--------------------------+

TIME_FORMAT

사용법: TIME_FORMAT(time, format)

format 인수의 지정자를 사용해 time 인수를 포맷해요. 이 함수는 DATE_FORMAT 함수에 사용할 수 있는 시간 형식 지정자의 일부를 지원해요. DATE_FORMAT이 지원하는 날짜 형식 지정자를 사용하면 0 또는 NULL이 반환돼요. 허용 가능한 형식 지정자는 다음 표에 나열돼요. DATE 타입의 인수가 전달되면 자정(즉, 00:00:00)의 타임스탬프로 취급돼요.

매개변수:

time (필수): STRING, DATE, TIME, 또는 TIMESTAMP 값이에요.
format (필수): STRING 형식 지정자예요.

반환 타입: STRING

다음 표는 사용 가능한 지정자 인수를 설명해요.

지정자	설명
`%f`	마이크로초 (000000..999999)
`%H`	시간 (00..23)
`%h`	시간 (01..12)
`%I`	시간 (01..12)
`%i`	분, 숫자 (00..59)
`%p`	AM 또는 PM
`%r`	시간, 12시간제 (hh:mm:ss 뒤에 AM 또는 PM)
`%S`	초 (00..59)
`%s`	초 (00..59)
`%T`	시간, 24시간제 (hh:mm:ss)

예제

  
source=people
| eval `TIME_FORMAT('1998-01-31 13:14:15.012345', '%f %H %h %I %i %p %r %S %s %T')` = TIME_FORMAT('1998-01-31 13:14:15.012345', '%f %H %h %I %i %p %r %S %s %T')
| fields `TIME_FORMAT('1998-01-31 13:14:15.012345', '%f %H %h %I %i %p %r %S %s %T')`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+----------------------------------------------------------------------------+
| TIME_FORMAT('1998-01-31 13:14:15.012345', '%f %H %h %I %i %p %r %S %s %T') |
|----------------------------------------------------------------------------|
| 012345 13 01 01 14 PM 01:14:15 PM 15 15 13:14:15                           |
  
+----------------------------------------------------------------------------+

TIME_TO_SEC

사용법: TIME_TO_SEC(time)

time 인수를 초로 변환해 반환해요.

매개변수:

time (필수): STRING, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: LONG

예제

  
source=people
| eval `TIME_TO_SEC(TIME('22:23:00'))` = TIME_TO_SEC(TIME('22:23:00'))
| fields `TIME_TO_SEC(TIME('22:23:00'))`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+-------------------------------+
| TIME_TO_SEC(TIME('22:23:00')) |
|-------------------------------|
| 80580                         |
  
+-------------------------------+

TIMEDIFF

사용법: TIMEDIFF(time1, time2)

두 시간 표현식의 차이를 시간으로 반환해요.

매개변수:

time1 (필수): TIME 값이에요.
time2 (필수): TIME 값이에요.

반환 타입: TIME

예제

  
source=people
| eval `TIMEDIFF('23:59:59', '13:00:00')` = TIMEDIFF('23:59:59', '13:00:00')
| fields `TIMEDIFF('23:59:59', '13:00:00')`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+----------------------------------+
| TIMEDIFF('23:59:59', '13:00:00') |
|----------------------------------|
| 10:59:59                         |
  
+----------------------------------+

TIMESTAMP

사용법: TIMESTAMP(expr) 또는 TIMESTAMP(expr1, expr2)

입력 문자열 expr을 타임스탬프로 하는 timestamp 타입을 구성해요. 인수가 문자열이 아니면 기본 시간대 UTC로 expr을 timestamp 타입으로 캐스팅해요. 인수가 시간이면 캐스팅 전에 오늘 날짜를 적용해요. 두 인수를 사용하면 시간 표현식 expr2를 날짜 또는 타임스탬프 표현식 expr1에 더하고 결과를 timestamp 값으로 반환해요.

매개변수:

expr (필수): STRING, DATE, TIME, 또는 TIMESTAMP 값이에요.
expr2 (선택): STRING, DATE, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: TIMESTAMP

예제

  
source=people
| eval `TIMESTAMP('2020-08-26 13:49:00')` = TIMESTAMP('2020-08-26 13:49:00'), `TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))` = TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))
| fields `TIMESTAMP('2020-08-26 13:49:00')`, `TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+----------------------------------+----------------------------------------------------+
| TIMESTAMP('2020-08-26 13:49:00') | TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42')) |
|----------------------------------+----------------------------------------------------|
| 2020-08-26 13:49:00              | 2020-08-27 02:04:42                                |
  
+----------------------------------+----------------------------------------------------+

TIMESTAMPADD

사용법: TIMESTAMPADD(interval, count, datetime)

전달된 DATE/TIME/TIMESTAMP/STRING 인수와, 더할 시간의 양을 결정하는 INTERVAL 및 INTEGER 인수를 기반으로 TIMESTAMP 값을 반환해요. 세 번째 인수가 STRING이면 유효한 TIMESTAMP 형식이어야 해요. TIME만 제공되면 DATE 부분이 현재 날짜로 채워진 TIMESTAMP가 여전히 반환돼요. 세 번째 인수가 DATE면 자동으로 TIMESTAMP로 변환돼요.

매개변수:

interval (필수): MICROSECOND, SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, YEAR 중 하나예요.
count (필수): 더할 간격 수인 INTEGER예요.
datetime (필수): DATE, TIME, TIMESTAMP, 또는 STRING 값이에요.

반환 타입: TIMESTAMP

예제

  
source=people
| eval `TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00')` = TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00')
| eval `TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00')` = TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00')
| fields `TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00')`, `TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00')`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+----------------------------------------------+--------------------------------------------------+
| TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00') | TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00') |
|----------------------------------------------+--------------------------------------------------|
| 2000-01-18 00:00:00                          | 1999-10-01 00:00:00                              |
  
+----------------------------------------------+--------------------------------------------------+

TIMESTAMPDIFF

사용법: TIMESTAMPDIFF(interval, start, end)

start와 end 날짜/시간의 차이를 interval 단위로 반환해요. 인수로 TIME이 제공되면 DATE 부분이 현재 날짜로 채워진 TIMESTAMP로 변환돼요. 인수는 적절할 때 자동으로 TIME/TIMESTAMP로 변환돼요. STRING인 인수는 유효한 TIMESTAMP 형식이어야 해요.

매개변수:

interval (필수): MICROSECOND, SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, YEAR 중 하나예요.
start (필수): DATE, TIME, TIMESTAMP, 또는 STRING 값이에요.
end (필수): DATE, TIME, TIMESTAMP, 또는 STRING 값이에요.

반환 타입: LONG

예제

  
source=people
| eval `TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00')` = TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00')
| eval `TIMESTAMPDIFF(SECOND, time('00:00:23'), time('00:00:00'))` = TIMESTAMPDIFF(SECOND, time('00:00:23'), time('00:00:00'))
| fields `TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00')`, `TIMESTAMPDIFF(SECOND, time('00:00:23'), time('00:00:00'))`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+-------------------------------------------------------------------+-----------------------------------------------------------+
| TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00') | TIMESTAMPDIFF(SECOND, time('00:00:23'), time('00:00:00')) |
|-------------------------------------------------------------------+-----------------------------------------------------------|
| 4                                                                 | -23                                                       |
  
+-------------------------------------------------------------------+-----------------------------------------------------------+

TO_DAYS

사용법: TO_DAYS(date)

주어진 날짜의 일 번호(0년 이후의 일 수)를 반환해요. date가 유효하지 않으면 NULL을 반환해요.

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: LONG

예제

  
source=people
| eval `TO_DAYS(DATE('2008-10-07'))` = TO_DAYS(DATE('2008-10-07'))
| fields `TO_DAYS(DATE('2008-10-07'))`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+-----------------------------+
| TO_DAYS(DATE('2008-10-07')) |
|-----------------------------|
| 733687                      |
  
+-----------------------------+

TO_SECONDS

사용법: TO_SECONDS(date)

주어진 값의 0년 이후의 초 수를 반환해요. 값이 유효하지 않으면 NULL을 반환해요. LONG 타입의 인수를 사용할 수 있어요. YMMDD, YYMMDD, YYYMMDD, 또는 YYYYMMDD 형식이어야 해요. LONG 타입 인수는 8진수 체계로 파싱되므로 앞에 0을 가질 수 없다는 점을 유의하세요.

매개변수:

date (필수): STRING, LONG, DATE, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: LONG

예제

  
source=people
| eval `TO_SECONDS(DATE('2008-10-07'))` = TO_SECONDS(DATE('2008-10-07'))
| eval `TO_SECONDS(950228)` = TO_SECONDS(950228)
| fields `TO_SECONDS(DATE('2008-10-07'))`, `TO_SECONDS(950228)`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+--------------------------------+--------------------+
| TO_SECONDS(DATE('2008-10-07')) | TO_SECONDS(950228) |
|--------------------------------+--------------------|
| 63390556800                    | 62961148800        |
  
+--------------------------------+--------------------+

UNIX_TIMESTAMP

사용법: UNIX_TIMESTAMP() 또는 UNIX_TIMESTAMP(date)

주어진 인수를 Unix 시간(에포크 이후의 초 - 1970년 초)으로 변환해요. 인수가 없으면 현재 Unix 시간을 반환해요. date 인수는 DATE, 또는 TIMESTAMP 문자열, 또는 YYMMDD, YYMMDDhhmmss, YYYYMMDD, YYYYMMDDhhmmss 형식의 숫자일 수 있어요. 인수에 시간 부분이 포함되면 선택적으로 소수 초 부분을 포함할 수 있어요. 인수가 유효하지 않은 형식이거나 1970-01-01 00:00:00 – 3001-01-18 23:59:59.999999 (에포크 시간 0에서 32536771199.999999) 범위 밖이면 NULL을 반환해요. 역변환을 수행하려면 FROM_UNIXTIME을 사용할 수 있어요.

매개변수:

date (선택): DOUBLE, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: DOUBLE

예제

  
source=people
| eval `UNIX_TIMESTAMP(double)` = UNIX_TIMESTAMP(20771122143845), `UNIX_TIMESTAMP(timestamp)` = UNIX_TIMESTAMP(TIMESTAMP('1996-11-15 17:05:42'))
| fields `UNIX_TIMESTAMP(double)`, `UNIX_TIMESTAMP(timestamp)`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+------------------------+---------------------------+
| UNIX_TIMESTAMP(double) | UNIX_TIMESTAMP(timestamp) |
|------------------------+---------------------------|
| 3404817525.0           | 848077542.0               |
  
+------------------------+---------------------------+

UTC_DATE

사용법: UTC_DATE()

현재 UTC 날짜를 YYYY-MM-DD 형식의 값으로 반환해요.

매개변수: 없음

반환 타입: DATE

예제

  
source=people
| eval `UTC_DATE()` = UTC_DATE()
| fields `UTC_DATE()`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+------------+
| UTC_DATE() |
|------------|
| 2025-10-03 |
  
+------------+

UTC_TIME

사용법: UTC_TIME()

현재 UTC 시간을 'hh:mm:ss'로 반환해요.

매개변수: 없음

반환 타입: TIME

예제

  
source=people
| eval `UTC_TIME()` = UTC_TIME()
| fields `UTC_TIME()`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+------------+
| UTC_TIME() |
|------------|
| 17:54:27   |
  
+------------+

UTC_TIMESTAMP

사용법: UTC_TIMESTAMP()

현재 UTC 타임스탬프를 'YYYY-MM-DD hh:mm:ss'로 반환해요.

매개변수: 없음

반환 타입: TIMESTAMP

예제

  
source=people
| eval `UTC_TIMESTAMP()` = UTC_TIMESTAMP()
| fields `UTC_TIMESTAMP()`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+---------------------+
| UTC_TIMESTAMP()     |
|---------------------|
| 2025-10-03 17:54:28 |
  
+---------------------+

WEEK

사용법: WEEK(date) 또는 WEEK(date, mode)

date의 주 번호를 반환해요. mode 인수를 생략하면 기본 모드 0이 사용돼요.

매개변수:

date (필수): DATE, TIMESTAMP, 또는 STRING 값이에요.
mode (선택): INTEGER 모드 값 (0–7)이에요.

반환 타입: INTEGER

동의어 (Synonyms): WEEK_OF_YEAR

다음 표는 mode 매개변수의 작동 방식을 설명해요.

Mode	주의 첫 날	범위	Week 1은 첫 주 ...
0	Sunday	0–53	올해에 일요일이 있는 주
1	Monday	0–53	올해에 4일 이상이 있는 주
2	Sunday	1–53	올해에 일요일이 있는 주
3	Monday	1–53	올해에 4일 이상이 있는 주
4	Sunday	0–53	올해에 4일 이상이 있는 주
5	Monday	0–53	올해에 월요일이 있는 주
6	Sunday	1–53	올해에 4일 이상이 있는 주
7	Monday	1–53	올해에 월요일이 있는 주

예제

  
source=people
| eval `WEEK(DATE('2008-02-20'))` = WEEK(DATE('2008-02-20')), `WEEK(DATE('2008-02-20'), 1)` = WEEK(DATE('2008-02-20'), 1)
| fields `WEEK(DATE('2008-02-20'))`, `WEEK(DATE('2008-02-20'), 1)`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+--------------------------+-----------------------------+
| WEEK(DATE('2008-02-20')) | WEEK(DATE('2008-02-20'), 1) |
|--------------------------+-----------------------------|
| 7                        | 8                           |
  
+--------------------------+-----------------------------+

WEEKDAY

사용법: WEEKDAY(date)

date의 요일 인덱스를 반환해요 (0 = Monday, 1 = Tuesday, …, 6 = Sunday). DAYOFWEEK 함수와 유사하지만 각 요일에 다른 인덱스를 반환해요.

매개변수:

date (필수): STRING, DATE, TIME, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

예제

  
source=people
| eval `weekday(DATE('2020-08-26'))` = weekday(DATE('2020-08-26'))
| eval `weekday(DATE('2020-08-27'))` = weekday(DATE('2020-08-27'))
| fields `weekday(DATE('2020-08-26'))`, `weekday(DATE('2020-08-27'))`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+-----------------------------+-----------------------------+
| weekday(DATE('2020-08-26')) | weekday(DATE('2020-08-27')) |
|-----------------------------+-----------------------------|
| 2                           | 3                           |
  
+-----------------------------+-----------------------------+

WEEK_OF_YEAR

사용법: WEEK_OF_YEAR(date) 또는 WEEK_OF_YEAR(date, mode)

date의 주 번호를 반환해요. mode 인수를 생략하면 기본 모드 0이 사용돼요.

매개변수:

date (필수): DATE, TIMESTAMP, 또는 STRING 값이에요.
mode (선택): INTEGER 모드 값 (0–7)이에요.

반환 타입: INTEGER

동의어 (Synonyms): WEEK

다음 표는 mode 인수의 작동 방식을 설명해요:

Mode	주의 첫 날	범위	Week 1은 첫 주 ...
0	Sunday	0–53	올해에 일요일이 있는 주
1	Monday	0–53	올해에 4일 이상이 있는 주
2	Sunday	1–53	올해에 일요일이 있는 주
3	Monday	1–53	올해에 4일 이상이 있는 주
4	Sunday	0–53	올해에 4일 이상이 있는 주
5	Monday	0–53	올해에 월요일이 있는 주
6	Sunday	1–53	올해에 4일 이상이 있는 주
7	Monday	1–53	올해에 월요일이 있는 주

예제

  
source=people
| eval `WEEK_OF_YEAR(DATE('2008-02-20'))` = WEEK(DATE('2008-02-20')), `WEEK_OF_YEAR(DATE('2008-02-20'), 1)` = WEEK_OF_YEAR(DATE('2008-02-20'), 1)
| fields `WEEK_OF_YEAR(DATE('2008-02-20'))`, `WEEK_OF_YEAR(DATE('2008-02-20'), 1)`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+----------------------------------+-------------------------------------+
| WEEK_OF_YEAR(DATE('2008-02-20')) | WEEK_OF_YEAR(DATE('2008-02-20'), 1) |
|----------------------------------+-------------------------------------|
| 7                                | 8                                   |
  
+----------------------------------+-------------------------------------+

YEAR

사용법: YEAR(date)

date의 연도를 1000부터 9999 범위로 반환하거나, "zero" 날짜에 대해서는 0을 반환해요.

매개변수:

date (필수): STRING, DATE, 또는 TIMESTAMP 값이에요.

반환 타입: INTEGER

예제

  
source=people
| eval `YEAR(DATE('2020-08-26'))` = YEAR(DATE('2020-08-26'))
| fields `YEAR(DATE('2020-08-26'))`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+--------------------------+
| YEAR(DATE('2020-08-26')) |
|--------------------------|
| 2020                     |
  
+--------------------------+

YEARWEEK

사용법: YEARWEEK(date) 또는 YEARWEEK(date, mode)

date의 연도와 주를 정수로 반환해요. WEEK 함수에서 사용 가능한 것과 정렬된 선택적 mode 인수를 받아요.

매개변수:

date (필수): STRING, DATE, TIME, 또는 TIMESTAMP 값이에요.
mode (선택): INTEGER 모드 값 (0–7)이에요.

반환 타입: INTEGER

예제

  
source=people
| eval `YEARWEEK('2020-08-26')` = YEARWEEK('2020-08-26')
| eval `YEARWEEK('2019-01-05', 1)` = YEARWEEK('2019-01-05', 1)
| fields `YEARWEEK('2020-08-26')`, `YEARWEEK('2019-01-05', 1)`

쿼리는 다음과 같은 결과를 반환해요:

  
fetched rows / total rows = 1/1
+------------------------+---------------------------+
| YEARWEEK('2020-08-26') | YEARWEEK('2019-01-05', 1) |
|------------------------+---------------------------|
| 202034                 | 201901                    |
  
+------------------------+---------------------------+