날짜·시간 함수

날짜·시간 함수 (DateTime Functions)

Apache Pinot의 날짜·시간 함수들은 에포크 밀리초 타임스탬프를 다른 시간 단위로 변환하거나, 특정 날짜/시간 구성 요소를 추출하고, 시간대를 처리하는 등의 다양한 기능을 제공해요.

출처: 문서

본문

에포크 밀리초를 다른 시간 단위로 변환하기 (Convert Epoch Milliseconds to other Time Granular)

toEpochSeconds

에포크 밀리초를 에포크 초로 변환해요.

문법 (Syntax)

toEpochSeconds(millis)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프

반환값 (Returns)

  • LONG: 에포크 초 단위 타임스탬프

예시 (Example)

SELECT toEpochSeconds(1700000000000) FROM myTable
-- Returns 1700000000

toEpochSecondsMV

에포크 밀리초 배열을 에포크 초 배열로 변환해요.

문법 (Syntax)

toEpochSecondsMV(millisArray)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열

반환값 (Returns)

  • LONG[]: 에포크 초 단위 타임스탬프 배열

toEpochMinutes

에포크 밀리초를 에포크 분으로 변환해요.

문법 (Syntax)

toEpochMinutes(millis)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프

반환값 (Returns)

  • LONG: 에포크 분 단위 타임스탬프

예시 (Example)

SELECT toEpochMinutes(1700000000000) FROM myTable
-- Returns 28333333

toEpochMinutesMV

에포크 밀리초 배열을 에포크 분 배열로 변환해요.

문법 (Syntax)

toEpochMinutesMV(millisArray)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열

반환값 (Returns)

  • LONG[]: 에포크 분 단위 타임스탬프 배열

toEpochHours

에포크 밀리초를 에포크 시로 변환해요.

문법 (Syntax)

toEpochHours(millis)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프

반환값 (Returns)

  • LONG: 에포크 시 단위 타임스탬프

예시 (Example)

SELECT toEpochHours(1700000000000) FROM myTable
-- Returns 472222

toEpochHoursMV

에포크 밀리초 배열을 에포크 시 배열로 변환해요.

문법 (Syntax)

toEpochHoursMV(millisArray)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열

반환값 (Returns)

  • LONG[]: 에포크 시 단위 타임스탬프 배열

toEpochDays

에포크 밀리초를 에포크 일로 변환해요.

문법 (Syntax)

toEpochDays(millis)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프

반환값 (Returns)

  • LONG: 에포크 일 단위 타임스탬프

예시 (Example)

SELECT toEpochDays(1700000000000) FROM myTable
-- Returns 1967

toEpochDaysMV

에포크 밀리초 배열을 에포크 일 배열로 변환해요.

문법 (Syntax)

toEpochDaysMV(millisArray)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열

반환값 (Returns)

  • LONG[]: 에포크 일 단위 타임스탬프 배열

에포크 밀리초를 다른 시간 단위로 반올림하기 (Round Epoch Milliseconds to other Time Granular)

toEpochSecondsRounded

에포크 밀리초를 에포크 초로 변환한 후, 지정한 버킷 크기로 내림 반올림해요.

문법 (Syntax)

toEpochSecondsRounded(millis, roundToNearest)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프
  • roundToNearest (LONG): 반올림에 사용할 초 단위 버킷 크기

반환값 (Returns)

  • LONG: 초 단위로 반올림된 에포크 시간

예시 (Example)

SELECT toEpochSecondsRounded(1700000001234, 60) FROM myTable
-- Returns 1700000000

toEpochSecondsRoundedMV

에포크 밀리초 배열을 에포크 초로 변환한 후, 각각을 지정한 버킷 크기로 반올림해요.

문법 (Syntax)

toEpochSecondsRoundedMV(millisArray, roundToNearest)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열
  • roundToNearest (LONG): 반올림에 사용할 초 단위 버킷 크기

반환값 (Returns)

  • LONG[]: 초 단위로 반올림된 에포크 타임스탬프 배열

toEpochMinutesRounded

에포크 밀리초를 에포크 분으로 변환한 후, 지정한 버킷 크기로 내림 반올림해요.

문법 (Syntax)

toEpochMinutesRounded(millis, roundToNearest)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프
  • roundToNearest (LONG): 반올림에 사용할 분 단위 버킷 크기

반환값 (Returns)

  • LONG: 분 단위로 반올림된 에포크 시간

예시 (Example)

SELECT toEpochMinutesRounded(1700000001234, 15) FROM myTable
-- Returns 28333320

toEpochMinutesRoundedMV

에포크 밀리초 배열을 에포크 분으로 변환한 후, 각각을 지정한 버킷 크기로 반올림해요.

문법 (Syntax)

toEpochMinutesRoundedMV(millisArray, roundToNearest)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열
  • roundToNearest (LONG): 반올림에 사용할 분 단위 버킷 크기

반환값 (Returns)

  • LONG[]: 분 단위로 반올림된 에포크 타임스탬프 배열

toEpochHoursRounded

에포크 밀리초를 에포크 시로 변환한 후, 지정한 버킷 크기로 내림 반올림해요.

문법 (Syntax)

toEpochHoursRounded(millis, roundToNearest)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프
  • roundToNearest (LONG): 반올림에 사용할 시 단위 버킷 크기

반환값 (Returns)

  • LONG: 시 단위로 반올림된 에포크 시간

예시 (Example)

SELECT toEpochHoursRounded(1700000001234, 2) FROM myTable
-- Returns 472222

toEpochHoursRoundedMV

에포크 밀리초 배열을 에포크 시로 변환한 후, 각각을 지정한 버킷 크기로 반올림해요.

문법 (Syntax)

toEpochHoursRoundedMV(millisArray, roundToNearest)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열
  • roundToNearest (LONG): 반올림에 사용할 시 단위 버킷 크기

반환값 (Returns)

  • LONG[]: 시 단위로 반올림된 에포크 타임스탬프 배열

toEpochDaysRounded

에포크 밀리초를 에포크 일로 변환한 후, 지정한 버킷 크기로 내림 반올림해요.

문법 (Syntax)

toEpochDaysRounded(millis, roundToNearest)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프
  • roundToNearest (LONG): 반올림에 사용할 일 단위 버킷 크기

반환값 (Returns)

  • LONG: 일 단위로 반올림된 에포크 시간

예시 (Example)

SELECT toEpochDaysRounded(1700000001234, 7) FROM myTable
-- Returns 1967

toEpochDaysRoundedMV

에포크 밀리초 배열을 에포크 일로 변환한 후, 각각을 지정한 버킷 크기로 반올림해요.

문법 (Syntax)

toEpochDaysRoundedMV(millisArray, roundToNearest)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열
  • roundToNearest (LONG): 반올림에 사용할 일 단위 버킷 크기

반환값 (Returns)

  • LONG[]: 일 단위로 반올림된 에포크 타임스탬프 배열

에포크 밀리초를 다른 시간 단위로 변환한 뒤 버킷으로 나누기 (Convert Epoch Milliseconds to other Time Granular then into Buckets)

toEpochSecondsBucket

에포크 밀리초를 에포크 초로 변환한 후, 버킷으로 나누어 에포크 이후의 버킷 수를 계산해요.

문법 (Syntax)

toEpochSecondsBucket(millis, bucket)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프
  • bucket (LONG): 초 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG: 에포크 이후 버킷 크기 초의 개수

예시 (Example)

SELECT toEpochSecondsBucket(1700000001234, 60) FROM myTable
-- Returns 28333333

toEpochSecondsBucketMV

에포크 밀리초 배열을 에포크 초로 변환한 후, 각각을 버킷으로 나눠요.

문법 (Syntax)

toEpochSecondsBucketMV(millisArray, bucket)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열
  • bucket (LONG): 초 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG[]: 에포크 이후 버킷 크기 초 배열

toEpochMinutesBucket

에포크 밀리초를 에포크 분으로 변환한 후, 버킷으로 나누어 에포크 이후의 버킷 수를 계산해요.

문법 (Syntax)

toEpochMinutesBucket(millis, bucket)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프
  • bucket (LONG): 분 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG: 에포크 이후 버킷 크기 분의 개수

예시 (Example)

SELECT toEpochMinutesBucket(1700000001234, 5) FROM myTable
-- Returns 5666666

toEpochMinutesBucketMV

에포크 밀리초 배열을 에포크 분으로 변환한 후, 각각을 버킷으로 나눠요.

문법 (Syntax)

toEpochMinutesBucketMV(millisArray, bucket)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열
  • bucket (LONG): 분 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG[]: 에포크 이후 버킷 크기 분 배열

toEpochHoursBucket

에포크 밀리초를 에포크 시로 변환한 후, 버킷으로 나누어 에포크 이후의 버킷 수를 계산해요.

문법 (Syntax)

toEpochHoursBucket(millis, bucket)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프
  • bucket (LONG): 시 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG: 에포크 이후 버킷 크기 시의 개수

예시 (Example)

SELECT toEpochHoursBucket(1700000001234, 4) FROM myTable
-- Returns 118055

toEpochHoursBucketMV

에포크 밀리초 배열을 에포크 시로 변환한 후, 각각을 버킷으로 나눠요.

문법 (Syntax)

toEpochHoursBucketMV(millisArray, bucket)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열
  • bucket (LONG): 시 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG[]: 에포크 이후 버킷 크기 시 배열

toEpochDaysBucket

에포크 밀리초를 에포크 일로 변환한 후, 버킷으로 나누어 에포크 이후의 버킷 수를 계산해요.

문법 (Syntax)

toEpochDaysBucket(millis, bucket)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프
  • bucket (LONG): 일 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG: 에포크 이후 버킷 크기 일의 개수

예시 (Example)

SELECT toEpochDaysBucket(1700000001234, 7) FROM myTable
-- Returns 281

toEpochDaysBucketMV

에포크 밀리초 배열을 에포크 일로 변환한 후, 각각을 버킷으로 나눠요.

문법 (Syntax)

toEpochDaysBucketMV(millisArray, bucket)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열
  • bucket (LONG): 일 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG[]: 에포크 이후 버킷 크기 일 배열

임의 시간 단위를 에포크 밀리초로 변환하기 (Any Time Granular to Epoch Milliseconds)

fromEpochSeconds

에포크 초를 에포크 밀리초로 변환해요.

문법 (Syntax)

fromEpochSeconds(seconds)

매개변수 (Parameters)

  • seconds (LONG): 에포크 초 단위 타임스탬프

반환값 (Returns)

  • LONG: 에포크 밀리초 단위 타임스탬프

예시 (Example)

SELECT fromEpochSeconds(1700000000) FROM myTable
-- Returns 1700000000000

fromEpochSecondsMV

에포크 초 배열을 에포크 밀리초 배열로 변환해요.

문법 (Syntax)

fromEpochSecondsMV(secondsArray)

매개변수 (Parameters)

  • secondsArray (LONG[]): 에포크 초 단위 타임스탬프 배열

반환값 (Returns)

  • LONG[]: 에포크 밀리초 단위 타임스탬프 배열

fromEpochMinutes

에포크 분을 에포크 밀리초로 변환해요.

문법 (Syntax)

fromEpochMinutes(minutes)

매개변수 (Parameters)

  • minutes (LONG): 에포크 분 단위 타임스탬프

반환값 (Returns)

  • LONG: 에포크 밀리초 단위 타임스탬프

예시 (Example)

SELECT fromEpochMinutes(28333333) FROM myTable
-- Returns 1700000000000

fromEpochMinutesMV

에포크 분 배열을 에포크 밀리초 배열로 변환해요.

문법 (Syntax)

fromEpochMinutesMV(minutesArray)

매개변수 (Parameters)

  • minutesArray (LONG[]): 에포크 분 단위 타임스탬프 배열

반환값 (Returns)

  • LONG[]: 에포크 밀리초 단위 타임스탬프 배열

fromEpochHours

에포크 시를 에포크 밀리초로 변환해요.

문법 (Syntax)

fromEpochHours(hours)

매개변수 (Parameters)

  • hours (LONG): 에포크 시 단위 타임스탬프

반환값 (Returns)

  • LONG: 에포크 밀리초 단위 타임스탬프

예시 (Example)

SELECT fromEpochHours(472222) FROM myTable
-- Returns 1700000000000

fromEpochHoursMV

에포크 시 배열을 에포크 밀리초 배열로 변환해요.

문법 (Syntax)

fromEpochHoursMV(hoursArray)

매개변수 (Parameters)

  • hoursArray (LONG[]): 에포크 시 단위 타임스탬프 배열

반환값 (Returns)

  • LONG[]: 에포크 밀리초 단위 타임스탬프 배열

fromEpochDays

에포크 일을 에포크 밀리초로 변환해요.

문법 (Syntax)

fromEpochDays(days)

매개변수 (Parameters)

  • days (LONG): 에포크 일 단위 타임스탬프

반환값 (Returns)

  • LONG: 에포크 밀리초 단위 타임스탬프

예시 (Example)

SELECT fromEpochDays(1967) FROM myTable
-- Returns 1700000000000

fromEpochDaysMV

에포크 일 배열을 에포크 밀리초 배열로 변환해요.

문법 (Syntax)

fromEpochDaysMV(daysArray)

매개변수 (Parameters)

  • daysArray (LONG[]): 에포크 일 단위 타임스탬프 배열

반환값 (Returns)

  • LONG[]: 에포크 밀리초 단위 타임스탬프 배열

임의 버킷화 시간 단위를 에포크 밀리초로 변환하기 (Any Bucketed Time Granular to Epoch Milliseconds)

버킷화된 에포크 초 개수를 에포크 밀리초로 다시 변환해요.

문법 (Syntax)

fromEpochSecondsBucket(nSecondsSinceEpoch, bucket)

매개변수 (Parameters)

  • nSecondsSinceEpoch (LONG): 버킷으로 나눈 에포크 이후 초 수
  • bucket (LONG): 초 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG: 에포크 밀리초 단위 타임스탬프

예시 (Example)

SELECT fromEpochSecondsBucket(28333333, 60) FROM myTable
-- Returns 1700000000000

fromEpochSecondsBucketMV

버킷화된 에포크 초 배열을 에포크 밀리초 배열로 다시 변환해요.

문법 (Syntax)

fromEpochSecondsBucketMV(nSecondsArray, bucket)

매개변수 (Parameters)

  • nSecondsArray (LONG[]): 버킷화된 에포크 초 배열
  • bucket (LONG): 초 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG[]: 에포크 밀리초 단위 타임스탬프 배열

fromEpochMinutesBucket

버킷화된 에포크 분 개수를 에포크 밀리초로 다시 변환해요.

문법 (Syntax)

fromEpochMinutesBucket(nMinutesSinceEpoch, bucket)

매개변수 (Parameters)

  • nMinutesSinceEpoch (LONG): 버킷으로 나눈 에포크 이후 분 수
  • bucket (LONG): 분 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG: 에포크 밀리초 단위 타임스탬프

예시 (Example)

SELECT fromEpochMinutesBucket(5666666, 5) FROM myTable
-- Returns 1700000000000

fromEpochMinutesBucketMV

버킷화된 에포크 분 배열을 에포크 밀리초 배열로 다시 변환해요.

문법 (Syntax)

fromEpochMinutesBucketMV(nMinutesArray, bucket)

매개변수 (Parameters)

  • nMinutesArray (LONG[]): 버킷화된 에포크 분 배열
  • bucket (LONG): 분 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG[]: 에포크 밀리초 단위 타임스탬프 배열

fromEpochHoursBucket

버킷화된 에포크 시 개수를 에포크 밀리초로 다시 변환해요.

문법 (Syntax)

fromEpochHoursBucket(nHoursSinceEpoch, bucket)

매개변수 (Parameters)

  • nHoursSinceEpoch (LONG): 버킷으로 나눈 에포크 이후 시 수
  • bucket (LONG): 시 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG: 에포크 밀리초 단위 타임스탬프

fromEpochHoursBucketMV

버킷화된 에포크 시 배열을 에포크 밀리초 배열로 다시 변환해요.

문법 (Syntax)

fromEpochHoursBucketMV(nHoursArray, bucket)

매개변수 (Parameters)

  • nHoursArray (LONG[]): 버킷화된 에포크 시 배열
  • bucket (LONG): 시 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG[]: 에포크 밀리초 단위 타임스탬프 배열

fromEpochDaysBucket

버킷화된 에포크 일 개수를 에포크 밀리초로 다시 변환해요.

문법 (Syntax)

fromEpochDaysBucket(nDaysSinceEpoch, bucket)

매개변수 (Parameters)

  • nDaysSinceEpoch (LONG): 버킷으로 나눈 에포크 이후 일 수
  • bucket (LONG): 일 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG: 에포크 밀리초 단위 타임스탬프

fromEpochDaysBucketMV

버킷화된 에포크 일 배열을 에포크 밀리초 배열로 다시 변환해요.

문법 (Syntax)

fromEpochDaysBucketMV(nDaysArray, bucket)

매개변수 (Parameters)

  • nDaysArray (LONG[]): 버킷화된 에포크 일 배열
  • bucket (LONG): 일 단위 각 시간 버킷의 크기

반환값 (Returns)

  • LONG[]: 에포크 밀리초 단위 타임스탬프 배열

ISO 8601 변환 함수 (ISO 8601 Conversion Functions)

이 함수들은 ISO 8601 날짜·시간 문자열과 에포크 밀리초 타임스탬프 사이를 변환할 수 있게 해줘요.

fromIso8601

ISO 8601 날짜·시간 문자열을 에포크 밀리초로 변환해요.

문법 (Syntax)

fromIso8601(iso8601)

매개변수 (Parameters)

  • iso8601 (STRING): ISO 8601 형식의 타임스탬프 (예: '2023-08-20T13:00:00Z')

반환값 (Returns)

  • LONG: 에포크 밀리초 단위 타임스탬프

예시 (Example)

SELECT fromIso8601('2023-08-20T13:00:00Z') FROM myTable
-- Returns 1692536400000

fromIso8601MV

ISO 8601 날짜·시간 문자열 배열을 에포크 밀리초 배열로 변환해요.

문법 (Syntax)

fromIso8601MV(iso8601Array)

매개변수 (Parameters)

  • iso8601Array (STRING[]): ISO 8601 형식 날짜·시간 문자열 배열

반환값 (Returns)

  • LONG[]: 에포크 밀리초 단위 타임스탬프 배열

toIso8601

에포크 밀리초를 ISO 8601 형식 문자열로 변환해요.

문법 (Syntax)

toIso8601(millis)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프

반환값 (Returns)

  • STRING: ISO 8601 형식 날짜·시간 문자열

예시 (Example)

SELECT toIso8601(1692536400000) FROM myTable
-- Returns '2023-08-20T13:00:00Z'

toIso8601MV

에포크 밀리초 배열을 ISO 8601 형식 문자열 배열로 변환해요.

문법 (Syntax)

toIso8601MV(millisArray)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열

반환값 (Returns)

  • STRING[]: ISO 8601 형식 날짜·시간 문자열 배열

타임스탬프 변환 함수 (Timestamp Conversion Functions)

이 함수들은 Java Timestamp 객체와 에포크 밀리초 타임스탬프 사이를 변환할 수 있게 해줘요. 주로 SQL 호환 UDF나 Pinot의 타임스탬프 타입 컬럼과 연동할 때 유용해요.

toTimestamp

에포크 밀리초를 Java Timestamp 객체로 변환해요.

문법 (Syntax)

toTimestamp(millis)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프

반환값 (Returns)

  • TIMESTAMP: 주어진 에포크 시간을 나타내는 Java Timestamp 객체

예시 (Example)

SELECT toTimestamp(1700000000000) FROM myTable
-- Returns TIMESTAMP '2023-11-14 22:13:20.000'

toTimestampMV

에포크 밀리초 배열을 Java Timestamp 객체 배열로 변환해요.

문법 (Syntax)

toTimestampMV(millisArray)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 밀리초 단위 타임스탬프 배열

반환값 (Returns)

  • TIMESTAMP[]: Java Timestamp 객체 배열

fromTimestamp

Java Timestamp를 에포크 밀리초로 변환해요.

문법 (Syntax)

fromTimestamp(timestamp)

매개변수 (Parameters)

  • timestamp (TIMESTAMP): Java Timestamp 객체

반환값 (Returns)

  • LONG: 에포크 밀리초 단위 타임스탬프

예시 (Example)

SELECT fromTimestamp(TIMESTAMP '2023-11-14 22:13:20.000') FROM myTable
-- Returns 1700000000000

fromTimestampMV

Java Timestamp 객체 배열을 에포크 밀리초 배열로 변환해요.

문법 (Syntax)

fromTimestampMV(timestampArray)

매개변수 (Parameters)

  • timestampArray (TIMESTAMP[]): Java Timestamp 객체 배열

반환값 (Returns)

  • LONG[]: 에포크 밀리초 단위 타임스탬프 배열

패턴 기반 날짜·시간 변환 함수 (Pattern-Based DateTime Conversion Functions)

이 함수들은 사용자 지정 패턴과 선택적 시간대를 사용해 에포크 타임스탬프와 형식화된 날짜·시간 문자열 사이를 변환해요. 패턴은 Java DateTimeFormatter 문법을 따라야 해요.

toDateTime

에포크 밀리초를 지정한 패턴을 사용해 DateTime 문자열로 변환해요.

문법 (Syntax)

toDateTime(millis, pattern)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프
  • pattern (STRING): DateTime 형식 패턴

반환값 (Returns)

  • STRING: 형식화된 DateTime 문자열

예시 (Example)

SELECT toDateTime(1700000000000, 'yyyy-MM-dd HH:mm:ss') FROM myTable
-- Returns '2023-11-14 22:13:20'

toDateTimeMV

패턴을 사용해 에포크 밀리초 배열을 형식화된 DateTime 문자열 배열로 변환해요.

문법 (Syntax)

toDateTimeMV(millisArray, pattern)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 타임스탬프 배열
  • pattern (STRING): DateTime 형식 패턴

반환값 (Returns)

  • STRING[]: 형식화된 DateTime 문자열 배열

toDateTime (시간대 포함, with Time Zone)

에포크 밀리초를 지정한 패턴과 시간대를 사용해 DateTime 문자열로 변환해요.

문법 (Syntax)

toDateTime(millis, pattern, timezoneId)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프
  • pattern (STRING): DateTime 형식 패턴
  • timezoneId (STRING): 시간대 ID (예: 'UTC', 'America/Los_Angeles')

반환값 (Returns)

  • STRING: 지정한 시간대의 형식화된 DateTime 문자열

예시 (Example)

SELECT toDateTime(1700000000000, 'yyyy-MM-dd HH:mm:ss', 'America/New_York') FROM myTable
-- Returns '2023-11-14 17:13:20'

toDateTimeMV (시간대 포함, with Time Zone)

패턴과 시간대를 사용해 에포크 밀리초 배열을 형식화된 DateTime 문자열 배열로 변환해요.

문법 (Syntax)

toDateTimeMV(millisArray, pattern, timezoneId)

매개변수 (Parameters)

  • millisArray (LONG[]): 에포크 타임스탬프 배열
  • pattern (STRING): DateTime 형식 패턴
  • timezoneId (STRING): 시간대 ID

반환값 (Returns)

  • STRING[]: 형식화된 DateTime 문자열 배열

fromDateTime

패턴에 따라 형식화된 DateTime 문자열을 에포크 밀리초로 파싱해요.

문법 (Syntax)

fromDateTime(dateTimeString, pattern)

매개변수 (Parameters)

  • dateTimeString (STRING): 입력 DateTime 문자열
  • pattern (STRING): DateTime 형식 패턴

반환값 (Returns)

  • LONG: 에포크 밀리초 단위 타임스탬프

예시 (Example)

SELECT fromDateTime('2023-11-14 22:13:20', 'yyyy-MM-dd HH:mm:ss') FROM myTable
-- Returns 1700000000000

fromDateTimeMV

형식화된 DateTime 문자열 배열을 에포크 밀리초 배열로 파싱해요.

문법 (Syntax)

fromDateTimeMV(dateTimeArray, pattern)

매개변수 (Parameters)

  • dateTimeArray (STRING[]): DateTime 문자열 배열
  • pattern (STRING): DateTime 형식 패턴

반환값 (Returns)

  • LONG[]: 에포크 타임스탬프 배열

fromDateTime (시간대 포함, with Time Zone)

지정한 시간대를 사용해 DateTime 문자열을 에포크 밀리초로 파싱해요.

문법 (Syntax)

fromDateTime(dateTimeString, pattern, timeZoneId)

매개변수 (Parameters)

  • dateTimeString (STRING): 입력 DateTime 문자열
  • pattern (STRING): DateTime 형식 패턴
  • timeZoneId (STRING): 시간대 ID

반환값 (Returns)

  • LONG: 에포크 밀리초 단위 타임스탬프

fromDateTime (시간대와 기본값 포함, with Time Zone and Default Value)

시간대를 사용해 DateTime 문자열을 에포크 밀리초로 파싱하고, 파싱에 실패하면 기본값을 반환해요.

문법 (Syntax)

fromDateTime(dateTimeString, pattern, timeZoneId, defaultVal)

매개변수 (Parameters)

  • dateTimeString (STRING): 입력 DateTime 문자열
  • pattern (STRING): DateTime 형식 패턴
  • timeZoneId (STRING): 시간대 ID
  • defaultVal (LONG): 파싱 실패 시 사용할 기본값(밀리초)

반환값 (Returns)

  • LONG: 에포크 밀리초, 실패 시 defaultVal

fromDateTimeMV (시간대 포함, with Time Zone)

시간대를 사용해 형식화된 DateTime 문자열 배열을 에포크 밀리초 배열로 파싱해요.

문법 (Syntax)

fromDateTimeMV(dateTimeArray, pattern, timeZoneId)

매개변수 (Parameters)

  • dateTimeArray (STRING[]): DateTime 문자열 배열
  • pattern (STRING): DateTime 형식 패턴
  • timeZoneId (STRING): 시간대 ID

반환값 (Returns)

  • LONG[]: 에포크 타임스탬프 배열

일반 시간 반올림 함수 (Generic Time Rounding Functions)

이 함수들은 시간 값을 주어진 단위의 가장 가까운 배수로 반올림해요. 사용자 지정 버킷화나 정렬에 유용해요.

round

주어진 시간 값을 roundToNearest의 가장 가까운 배수로 내림 반올림해요.

문법 (Syntax)

round(timeValue, roundToNearest)

매개변수 (Parameters)

  • timeValue (LONG): 시간 값 (주로 밀리초, 초 등)
  • roundToNearest (LONG): 반올림 단위 (예: 60, 1000 등)

반환값 (Returns)

  • LONG: roundToNearest의 가장 가까운 배수로 내림 반올림된 원래 값

예시 (Example)

SELECT round(1700000000123, 1000) FROM myTable
-- Returns 1700000000000

roundMV

시간 값 배열의 각 값을 roundToNearest의 가장 가까운 배수로 반올림해요.

문법 (Syntax)

roundMV(timeArray, roundToNearest)

매개변수 (Parameters)

  • timeArray (LONG[]): 시간 값 배열
  • roundToNearest (LONG): 반올림 단위

반환값 (Returns)

  • LONG[]: 반올림된 값 배열

now()와 ago()를 위한 시간 유틸리티 함수 (Time Utility Functions for now() and ago())

이 스칼라 함수들은 현재 시스템 시간이나 기간을 기반으로 타임스탬프를 반환하거나 조작해요. 디버깅, 시간 기반 필터, 동적 비교에 유용해요.

now

현재 시스템 시간을 에포크 밀리초로 반환해요.

문법 (Syntax)

now()

매개변수 (Parameters)

  • 없음 (None)

반환값 (Returns)

  • LONG: 에포크 이후 경과한 밀리초 단위 현재 시간

예시 (Example)

SELECT now() FROM myTable
-- Returns something like 1700000000000

sleep

주어진 밀리초 동안 현재 스레드를 대기시킨 후, 같은 값을 반환해요.

이 함수는 assertion이 활성화된 경우에만 동작하며, 주로 디버깅과 테스트를 위한 것이에요.

문법 (Syntax)

sleep(millis)

매개변수 (Parameters)

  • millis (LONG): 대기할 기간 (밀리초)

반환값 (Returns)

  • LONG: 대기가 끝난 후 같은 millis 값을 반환해요.

ago

now로부터 주어진 ISO-8601 기간만큼 이전의 시간을 나타내는 에포크 밀리초를 반환해요.

문법 (Syntax)

ago(periodString)

매개변수 (Parameters)

  • periodString (STRING): ISO-8601 형식의 기간 문자열 (예: 'PT10H', 'P2DT3H4M')

반환값 (Returns)

  • LONG: now에서 주어진 기간을 뺀 에포크 밀리초 시간

예시 (Example)

SELECT ago('PT1H') FROM myTable
-- Returns current time minus one hour in millis

agoMV

ISO-8601 기간 문자열 배열에 ago() 로직을 적용해요.

문법 (Syntax)

agoMV(periodArray)

매개변수 (Parameters)

  • periodArray (STRING[]): ISO-8601 형식 기간 문자열 배열

반환값 (Returns)

  • LONG[]: 각 기간을 현재 시간에서 뺀 에포크 밀리초 시간 배열

시간대 오프셋 함수 (Time Zone Offset Functions)

이 함수들은 시간대 ID를 기반으로 UTC에서의 시간대 오프셋의 시간 또는 분 구성 요소를 반환해요. 고정(현재 오프셋) 및 동적(특정 타임스탬프에서의 오프셋) 평가를 지원하며, 서머타임(DST) 조정을 포함해요.

ℹ️ timezoneId는 Joda-Time 시간대 ID를 따라야 해요 (예: 'America/Los_Angeles', 'UTC', 'Asia/Kolkata').

timezoneHour

에포크(UTC)에서 지정한 시간대의 시간 오프셋을 반환해요.

문법 (Syntax)

timezoneHour(timezoneId)

매개변수 (Parameters)

  • timezoneId (STRING): Joda-Time 호환 시간대 ID

반환값 (Returns)

  • INT: UTC로부터의 시간 오프셋 (예: -8, 0, 5)

예시 (Example)

SELECT timezoneHour('America/New_York') FROM myTable
-- Returns -5 or -4 depending on DST

timezoneHourMV

시간대 ID 배열에 대한 UTC 시간 오프셋을 반환해요.

문법 (Syntax)

timezoneHourMV(timezoneIdArray)

매개변수 (Parameters)

  • timezoneIdArray (STRING[]): 시간대 ID 배열

반환값 (Returns)

  • INT[]: UTC 시간 오프셋 배열

timezoneHour (타임스탬프 기준, at timestamp)

특정 UTC 타임스탬프(밀리초)에서 시간대의 시간 오프셋을 반환해요. 서머타임을 존중해요.

문법 (Syntax)

timezoneHour(timezoneId, millis)

매개변수 (Parameters)

  • timezoneId (STRING): Joda-Time 호환 시간대 ID
  • millis (LONG): UTC 밀리초 단위 타임스탬프

반환값 (Returns)

  • INT: 그 시점의 UTC 시간 오프셋

timezoneHourMV (타임스탬프 기준, at timestamp)

주어진 각 타임스탬프에서 지정한 시간대 ID의 시간 오프셋을 반환해요.

문법 (Syntax)

timezoneHourMV(timezoneId, millisArray)

매개변수 (Parameters)

  • timezoneId (STRING): Joda-Time 호환 시간대 ID
  • millisArray (LONG[]): UTC 밀리초 단위 타임스탬프 배열

반환값 (Returns)

  • INT[]: 해당 타임스탬프에서의 시간 오프셋 배열

timezoneMinute

에포크(UTC)에서 지정한 시간대의 분 오프셋을 반환해요.

문법 (Syntax)

timezoneMinute(timezoneId)

매개변수 (Parameters)

  • timezoneId (STRING): Joda-Time 호환 시간대 ID

반환값 (Returns)

  • INT: 시간대 오프셋의 분 구성 요소 (예: IST는 30, UTC는 0)

timezoneMinuteMV

시간대 ID 배열에 대한 UTC 분 오프셋을 반환해요.

문법 (Syntax)

timezoneMinuteMV(timezoneIdArray)

매개변수 (Parameters)

  • timezoneIdArray (STRING[]): 시간대 ID 배열

반환값 (Returns)

  • INT[]: UTC 오프셋의 분 구성 요소 배열

timezoneMinute (타임스탬프 기준, at timestamp)

특정 UTC 타임스탬프(밀리초)에서 시간대의 분 오프셋을 반환해요. DST를 고려해요.

문법 (Syntax)

timezoneMinute(timezoneId, millis)

매개변수 (Parameters)

  • timezoneId (STRING): Joda-Time 호환 시간대 ID
  • millis (LONG): UTC 밀리초 단위 타임스탬프

반환값 (Returns)

  • INT: 주어진 타임스탬프에서의 UTC 분 오프셋

timezoneMinuteMV (타임스탬프 기준, at timestamp)

각 타임스탬프에서 지정한 시간대 ID의 분 오프셋을 반환해요.

문법 (Syntax)

timezoneMinuteMV(timezoneId, millisArray)

매개변수 (Parameters)

  • timezoneId (STRING): Joda-Time 호환 시간대 ID
  • millisArray (LONG[]): UTC 타임스탬프 배열

반환값 (Returns)

  • INT[]: UTC 분 오프셋 배열

날짜·시간 구성 요소 함수 (Date and Time Component Functions)

이 함수들은 에포크 밀리초 타임스탬프에서 특정 구성 요소(년, 월, 일, 시 등)를 추출해요. UTC(기본값)와 Joda-Time 존 ID를 사용한 사용자 지정 시간대를 모두 지원해요. MV 변형은 타임스탬프 배열에 같은 로직을 적용해요.

year(millis)

UTC에서 달력 연도를 반환해요.

문법 (Syntax)

year(millis)

매개변수 (Parameters)

  • millis (LONG): 에포크 밀리초 단위 타임스탬프

반환값 (Returns)

  • INT: 연도 (예: 2024)

year(millis, timezoneId)

지정한 시간대에서 달력 연도를 반환해요.

문법 (Syntax)

year(millis, timezoneId)

매개변수 (Parameters)

  • timezoneId (STRING): Joda-Time 호환 시간대 ID

반환값 (Returns)

  • INT: 연도 (예: 2024)

yearMV(millisArray) / yearMV(millisArray, timezoneId)

타임스탬프 배열에서 연도를 반환해요.

반환값 (Returns)

  • INT[]: 연도 배열

yearOfWeek(millis) / yow(millis)

UTC에서 ISO 주 기반 연도를 반환해요.

반환값 (Returns)

  • INT: 주 기반 연도 (예: 2024)

yearOfWeek(millis, timezoneId)

지정한 시간대에서 ISO 주 기반 연도를 반환해요.

yearOfWeekMV(...) / yowMV(...)

다중 값 변형이에요.

quarter(millis[, timezoneId])

연도의 분기를 반환해요 (1~4).

반환값 (Returns)

  • INT: 1 = Q1, 2 = Q2, 3 = Q3, 4 = Q4

month(millis[, timezoneId]) / monthOfYear(...)

연도의 월을 반환해요 (1~12).

week(millis[, timezoneId]) / weekOfYear(...)

연도의 ISO 주를 반환해요 (1~53).

dayOfYear(millis[, timezoneId]) / doy(...)

연도의 일을 반환해요 (1~366).

dayOfMonth(millis[, timezoneId]) / day(...)

월의 일을 반환해요 (1~31).

dayOfWeek(millis[, timezoneId]) / dow(...)

요일을 반환해요 (1 = 월요일 ~ 7 = 일요일).

hour(millis[, timezoneId])

시간을 반환해요 (0~23).

minute(millis[, timezoneId])

분을 반환해요 (0~59).

second(millis[, timezoneId])

초를 반환해요 (0~59).

millisecond(millis[, timezoneId])

초의 밀리초를 반환해요 (0~999).

MV 변형 (MV Variants)

위의 모든 함수에는 에포크 타임스탬프 배열에 대해 동작하며 해당 추출 값 배열을 반환하는 MV 대응 함수가 있어요.

예시 (Example)

SELECT dayOfWeekMV([1700000000000, 1700003600000], 'America/Los_Angeles')
-- Returns [3, 3] if both fall on the same Wednesday in that time zone.

일반화된 날짜/시간 추출 함수 (Generalized Date/Time Extraction Function)

이 함수는 유연한 문자열 기반 간격 지정자를 사용해 타임스탬프에서 특정 구성 요소(예: 연, 월, 일, 시)를 추출해요.

extract(interval, timestamp)

주어진 에포크 타임스탬프에서 지정한 날짜/시간 구성 요소를 반환해요.

문법 (Syntax)

extract(interval, timestamp)

매개변수 (Parameters)

  • interval (STRING): 추출할 구성 요소. 지원 값은 DateTimeUtils.ExtractFieldType에 따르며 주로 다음을 포함해요:

    • YEAR, QUARTER, MONTH, WEEK, DAY, DOY, DOW,

      HOUR, MINUTE, SECOND, MILLISECOND

  • timestamp (LONG): 밀리초 단위 에포크 시간

반환값 (Returns)

  • INT: 정수로 추출된 구성 요소

예시 (Examples)

SELECT extract('YEAR', 1700000000000)
-- Returns: 2023

SELECT extract('MONTH', 1700000000000)
-- Returns: 11

SELECT extract('DOW', 1700000000000)
-- Returns: 3 (Wednesday, if using ISO standard)

ℹ️ 이 함수는 추출할 필드가 동적으로 결정될 때 전용 year(), month(), hour() 등의 함수에 대한 유연한 대안을 제공해요.

타임스탬프 절단(DateTrunc) 함수 (Timestamp Truncation(DateTrunc) Functions)

이 함수들은 지정한 시간 단위(예: 시, 일, 월의 시작)로 타임스탬프를 내림(절단)해요. 유연한 입력/출력 단위와 선택적 시간대 처리를 지원해요.

dateTrunc(unit, timeValue)

UTC에서 지정한 단위의 시작으로 타임스탬프를 절단하고, 에포크 이후 밀리초를 반환해요.

문법 (Syntax)

dateTrunc(unit, timeValue)

매개변수 (Parameters)

  • unit (STRING): millisecond, second, minute, hour, day, week, month, quarter, year 중 하나
  • timeValue (LONG): 밀리초 단위 타임스탬프

반환값 (Returns)

  • LONG: 밀리초 단위로 절단된 타임스탬프

예시 (Example)

SELECT dateTrunc('minute', 1700001234567)
-- Returns 1700001180000 (start of the minute)

SELECT dateTrunc('day', 1700001234567)
-- Returns 1700000000000 (start of the day in UTC)

dateTrunc(unit, timeValue, inputTimeUnit)

입력 단위(예: 초, 시)를 사용해 타임스탬프를 절단해요. 출력은 같은 단위로 유지돼요.

문법 (Syntax)

dateTrunc(unit, timeValue, inputTimeUnit)

매개변수 (Parameters)

  • inputTimeUnit (STRING): timeValue의 시간 단위. MILLISECONDS, SECONDS, MINUTES 등이 포함돼요.

예시 (Example)

SELECT dateTrunc('hour', 1700000000, 'SECONDS')
-- Returns 1700000000 (start of hour in seconds)

SELECT dateTrunc('day', 1700000000, 'SECONDS')
-- Returns: 1699910400 (start of day in seconds)

dateTrunc(unit, timeValue, inputTimeUnit, timezone)

시간대 오프셋과 DST를 고려해 타임스탬프를 단위로 절단해요.

문법 (Syntax)

dateTrunc(unit, timeValue, inputTimeUnit, timezone)

매개변수 (Parameters)

  • timezone (STRING): 시간대 ID (예: America/Los_Angeles)

예시 (Example)

SELECT dateTrunc('day', 1700000000000, 'MILLISECONDS', 'Asia/Kolkata')
-- Returns start of day in IST.

dateTrunc(unit, timeValue, inputTimeUnit, timezone, outputTimeUnit)

입력·출력 단위와 시간대 변환을 모두 포함한 완전한 기능의 절단이에요.

문법 (Syntax)

dateTrunc(unit, timeValue, inputTimeUnit, timezone, outputTimeUnit)

예시 (Example)

SELECT dateTrunc('month', 1700000000, 'SECONDS', 'America/New_York', 'SECONDS')
-- Returns start of the month in New York in seconds.

dateTruncMV(...)

위의 모든 변형에는 해당하는 다중 값(MV) 형태가 있어요:

  • dateTruncMV(unit, timeArray)
  • dateTruncMV(unit, timeArray, inputTimeUnit)
  • dateTruncMV(unit, timeArray, inputTimeUnit, timeZone)
  • dateTruncMV(unit, timeArray, inputTimeUnit, timeZone, outputTimeUnit)

반환값 (Returns)

  • LONG[]: 절단된 타임스탬프 배열

예시 (Example)

SELECT dateTruncMV('minute', [1700001234567, 1700001288888])
-- Returns [1700001180000, 1700001240000]

날짜 비닝 함수 (Date Binning Functions)

이 함수들은 지정한 기간과 원점(origin) 타임스탬프를 기반으로 주어진 타임스탬프를 가장 가까운 고정 폭 시간 빈(bin)에 정렬해요. 윈도우 집계, 히스토그램, 시간 기반 버킷화에 유용해요.

dateBin(binWidthStr, sourceTimestamp, originTimestamp)

sourceTimestamp를 지정한 originTimestamp에서 시작하는 주어진 binWidthStr의 가장 가까운 하한 빈 경계에 정렬해요.

문법 (Syntax)

dateBin(binWidthStr, sourceTimestamp, originTimestamp)

매개변수 (Parameters)

  • binWidthStr (STRING): 기간 문자열로 표현된 빈 너비. 지원 형식은 다음과 같아요:
    • ISO-8601 기간 (예: 15분은 'PT15M', 1일은 'P1D')
    • TimeUtils.convertPeriodToMillis가 지원하는 축약형 (예: '15m', '2h', '1d')
  • sourceTimestamp (TIMESTAMP): 정렬할 타임스탬프
  • originTimestamp (TIMESTAMP): 빈 정렬의 원점(시작) 시간

반환값 (Returns)

  • TIMESTAMP: 해당 빈의 시작에 해당하는 정렬된 타임스탬프

예시 (Examples)

-- Align 2024-01-01 12:37:00 to the nearest 15-minute bin from 2024-01-01 00:00:00
SELECT dateBin('PT15M', TIMESTAMP '2024-01-01 12:37:00', TIMESTAMP '2024-01-01 00:00:00')
-- Returns: TIMESTAMP '2024-01-01 12:30:00'

-- Align a time to the start of its 2-day bin
SELECT dateBin('P2D', TIMESTAMP '2024-01-03 10:00:00', TIMESTAMP '2024-01-01 00:00:00')
-- Returns: TIMESTAMP '2024-01-03 00:00:00'

-- Align to 1-hour bins from a non-midnight origin
SELECT dateBin('PT1H', TIMESTAMP '2024-01-01 11:47:00', TIMESTAMP '2024-01-01 06:15:00')
-- Returns: TIMESTAMP '2024-01-01 11:15:00'

타임스탬프 산술 함수 (Timestamp Arithmetic Functions)

이 함수들은 에포크 밀리초 타임스탬프에 대한 산술 연산을 지원해요—예를 들어 타임스탬프에 기간을 더하거나 두 타임스탬프 사이의 차이를 계산하는 것처럼요.

다중 값(MV) 변형은 타임스탬프 배열에 대해 동작해요.

timestampAdd(unit, interval, timestamp)

별칭: dateAdd

타임스탬프에 지정한 양의 시간을 더해요.

문법 (Syntax)

timestampAdd(unit, interval, timestamp)

매개변수 (Parameters)

  • unit (STRING): 더할 시간 단위. 지원 값은 다음과 같아요:

    milliseconds, seconds, minutes, hours, days, weeks, months, quarters, years.

  • interval (LONG): 더할 시간의 양. 음수는 빼기를 의미해요.

  • timestamp (LONG): 에포크 밀리초 단위 입력 타임스탬프

반환값 (Returns)

  • LONG: 역시 에포크 밀리초 단위인 결과 타임스탬프

예시 (Examples)

-- Add 3 days to the given timestamp
SELECT timestampAdd('days', 3, 1700000000000)

-- Subtract 6 hours
SELECT timestampAdd('hours', -6, 1700000000000)

timestampAddMV(unit, interval, timestampArray)

별칭: dateAddMV

timestampAdd의 벡터화 버전으로, 타임스탬프 배열에 연산을 적용해요.

매개변수 (Parameters)

  • timestampArray (LONG[]): 입력 타임스탬프 배열

반환값 (Returns)

  • LONG[]: 결과 타임스탬프 배열

예시 (Example)

SELECT timestampAddMV('days', 1, [1700000000000, 1700086400000])
-- Returns: [1700086400000, 1700172800000]

timestampDiff(unit, timestamp1, timestamp2)

별칭: dateDiff

timestamp2와 timestamp1 사이의 차이를 지정한 단위로 계산해요.

양수 값은 timestamp2가 timestamp1보다 나중임을 나타내요.

문법 (Syntax)

timestampDiff(unit, timestamp1, timestamp2)

매개변수 (Parameters)

  • unit (STRING): 결과의 시간 단위 (일, 시, 월 등)
  • timestamp1 (LONG): 시작 타임스탬프 (에포크 밀리초)
  • timestamp2 (LONG): 끝 타임스탬프 (에포크 밀리초)

반환값 (Returns)

  • LONG: 주어진 단위의 시간 차이

예시 (Example)

-- Difference between two timestamps in days
SELECT timestampDiff('days', ago('10D'), ago('2D'))
-- Returns: 8

timestampDiffMV(unit, timestampArray1, timestamp2)

별칭: dateDiffMV

첫 번째 배열의 각 타임스탬프와 단일 두 번째 타임스탬프 사이의 차이를 계산해요.

반환값 (Returns)

  • LONG[]: 지정한 단위의 차이 배열

예시 (Example)

SELECT timestampDiffMV('hours', [1700000000000, 1700003600000], 1700010800000)
-- Returns: [3, 2]

timestampDiffMVReverse(unit, timestamp1, timestampArray2)

별칭: dateDiffMVReverse

단일 첫 번째 타임스탬프와 두 번째 배열의 각 타임스탬프 사이의 차이를 계산해요.

반환값 (Returns)

  • LONG[]: 지정한 단위의 차이 배열

예시 (Example)

SELECT timestampDiffMVReverse('days', 1700000000000, [1700086400000, 1700172800000])
-- Returns: [1, 2]

추가 참고 페이지 (Additional Reference Pages)

Function Function
ago DATETIMECONVERT
DATETRUNC day
dayOfWeek dayOfYear
Extract FromDateTime
FromEpoch FromEpochBucket
hour millisecond
minute month
now quarter
second TIMECONVERT
timezoneHour timezoneMinute
ToDateTime ToEpoch
ToEpochBucket ToEpochRounded
week year
yearOfWeek

더 알아보기 (Learn more)