배열 함수
배열 함수 (Array Functions)
Apache Pinot의 배열 함수는 배열·멀티밸류(Multi-value) 컬럼을 다루기 위한 다양한 변환·집계 함수 모음이에요. 배열을 생성하고, 합치고, 자르고, 정렬하고, 필터링하는 등 데이터를 배열 차원에서 자유롭게 다룰 수 있어요.
출처: 문서
본문
배열 집계 (Array Aggregation)
arrayAgg
설명:
입력 값들을 배열로 연결해요. isDistinct가 true일 때는 선택적으로 중복을 제거해요. 이 함수는 여러 행을 어떤 차원 기준으로 그룹핑해 단일 배열로 집계할 때 흔히 사용돼요.
시그니처:
ARRAY_AGG(dataColumn, 'dataType' [, isDistinct])
인자:
- dataColumn - 집계할 입력 컬럼 또는 표현식. 스칼라 또는 배열 타입일 수 있어요.
- 'dataType' - 결과 배열의 요소 타입. 문자열 리터럴이어야 해요 (예: 'STRING', 'INT', 'LONG', 'DOUBLE', 'BIG_DECIMAL', 'BYTES').
- isDistinct (선택) - 고유한 요소만 포함할지 여부를 나타내는 불리언 플래그. 기본값 false.
반환:
집계된 모든 값을 담은 지정된 dataType의 배열.
예시:
- 스칼라 값들을 배열로 집계
SELECT ARRAY_AGG(firstName, 'STRING', true) AS firstNames
FROM transcript;
결과:
firstNames
-----------
["Bob", "Nick", "Lucy"]
- 행 전체의 배열 값 집계
SELECT ARRAY_AGG(tags, 'STRING') AS allTags
FROM articles;
결과:
allTags
-------------------------------------
["news", "ai", "pinot", "open-source"]
참고:
- 입력 컬럼이 배열이면 집계 전에 모든 하위 배열이 평탄화돼요.
isDistinct가 true면 최종 배열에서 중복 요소가 제거돼요.- 출력 배열의 요소 순서는 보장되지 않아요.
INT,LONG,FLOAT,DOUBLE,BIG_DECIMAL,STRING,BYTES에 대해 스칼라와 배열 입력 타입을 모두 지원해요.
LISTAGG
설명:
선택적 구분자와 함께 입력 값들을 단일 문자열로 연결해요.
ARRAY_AGG와 비슷하지만 배열 대신 문자열을 만들어내요.
LISTAGG는 여러 행에서 쉼표로 구분된 목록이나 다른 구분 문자열을 생성하는 데 유용해요.
시그니처:
LISTAGG(dataColumn [, delimiter] [, isDistinct])
인자:
- dataColumn — 연결할 입력 컬럼 또는 표현식.
- delimiter (선택) — 출력에서 값을 구분하는 문자열. 기본값은 ','.
- isDistinct (선택) — 고유한 요소만 포함할지 여부를 나타내는 불리언 플래그. 기본값 false.
반환:
주어진 구분자로 구분된 모든 값(선택적으로 고유한 값)을 담은 단일 연결 STRING.
예시:
- 이름을 쉼표로 연결
SELECT LISTAGG(firstName, ', ', true) AS allNames
FROM transcript;
결과:
allNames
-------------------
Bob, Nick, Lucy
- 배열 입력 연결
SELECT LISTAGG(tags, '|') AS tagList
FROM articles;
결과:
tagList
------------------------
news|ai|pinot|open-source
참고:
- 입력 컬럼이 배열이면 연결 전에 모든 하위 배열이 평탄화돼요.
isDistinct가 true면 연결 전에 중복 값이 제거돼요.- 요소의 출력 순서는 보장되지 않아요.
- 구분자 인자는 선택이며 기본값은 쉼표 ','예요.
sumArrayLong
설명:
모든 입력 행에 걸쳐 LONG(또는 정수 호환) 값 배열의 모든 요소 합을 계산해요.
지표나 카운터 같은 숫자 배열을 단일 스칼라 값으로 집계할 때 유용해요.
시그니처:
sumArrayLong(arrayColumn)
인자:
- arrayColumn — 숫자(LONG 또는 INT) 값 배열을 담은 입력 컬럼.
반환:
그룹의 모든 배열에 걸쳐 모든 요소의 합을 나타내는 LONG.
예시:
- 행 전체의 배열 요소 합
SELECT sumArrayLong(values) AS totalSum
FROM metrics;
입력:
values
-------
[1, 2, 3]
[4, 5, 6]
결과:
totalSum
---------
21
- GROUP BY와 함께
SELECT category, sumArrayLong(values) AS total
FROM metrics
GROUP BY category;
결과:
category | total
----------|------
A | 15
B | 27
참고:
- NULL과 빈 배열은 무시돼요.
- 합산 전에 모든 숫자 값을 LONG으로 강제 변환해요.
- 어떤 요소가 숫자가 아니면 쿼리가 실패해요.
sumArrayDouble
설명:
모든 입력 행에 걸쳐 DOUBLE(부동소수점) 값 배열의 모든 요소 합을 계산해요.
sumArrayLong의 배정밀도 변형으로, 점수·확률·가중치 같은 소수 값이 있는 숫자 배열을 집계할 때 주로 사용돼요.
시그니처:
sumArrayDouble(arrayColumn)
인자:
- arrayColumn — 숫자(DOUBLE 또는 FLOAT) 값 배열을 담은 입력 컬럼.
반환:
그룹의 모든 배열에 걸쳐 모든 요소의 합을 나타내는 DOUBLE.
예시:
- 행 전체의 배열 요소 합
SELECT sumArrayDouble(weights) AS totalWeight
FROM model_output;
입력:
weights
------------
[1.2, 0.8]
[2.5, 3.0]
결과:
totalWeight
------------
7.5
- GROUP BY와 함께
SELECT experimentId, sumArrayDouble(scores) AS totalScore
FROM results
GROUP BY experimentId;
참고:
- NULL과 빈 배열은 무시돼요.
- 합산 전에 모든 숫자 요소를 DOUBLE로 강제 변환해요.
- 정수 데이터에는 타입 변환 오버헤드를 피하기 위해 sumArrayLong을 사용하세요.
배열 필터링 (Array Filtering)
filterMv
멀티밸류 컬럼의 각 요소를 조건(predicate)에 대해 평가하고, 조건을 만족하는 요소만 담은 필터링된 멀티밸류 배열을 반환해요.
시그니처: filterMv(mvColumn, 'predicate')
지원 연산자: =, !=, >, >=, <, <=, IN, NOT IN, BETWEEN, REGEXP_LIKE, 그리고 논리 연산자 AND, OR, NOT
예시:
SELECT filterMv(stringArrayCol, 'REGEXP_LIKE(v, ''^/api/.*'')')
FROM myTable
LIMIT 10
참고:
- 조건은 평가되는 요소의 자리표시자로
v를 사용해야 해요. CROSS JOIN UNNEST없이 요소 수준 필터링을 하는 데 유용해요.
자세한 내용은 filterMv를 참고하세요.
배열 뒤집기 (Array Reversal)
arrayReverseInt
설명: 정수 배열의 요소 순서를 뒤집어요.
문법: arrayReverseInt(int_array)
예시:
SELECT arrayReverseInt(ARRAY[1, 2, 3, 4, 5]);
-- Result: [5, 4, 3, 2, 1]
arrayReverseString
설명: 문자열 배열의 요소 순서를 뒤집어요.
문법: arrayReverseString(string_array)
예시:
SELECT arrayReverseString(ARRAY['apple', 'banana', 'cherry']);
-- Result: ['cherry', 'banana', 'apple']
배열 정렬 (Array Sorting)
arraySortInt
설명: 정수 배열을 오름차순으로 정렬해요.
문법: arraySortInt(int_array)
예시:
SELECT arraySortInt(ARRAY[4, 1, 3, 5, 2]);
-- Result: [1, 2, 3, 4, 5]
arraySortString
설명: 문자열 배열을 사전식으로 정렬해요.
문법: arraySortString(string_array)
예시:
SELECT arraySortString(ARRAY['banana', 'apple', 'cherry']);
-- Result: ['apple', 'banana', 'cherry']
배열 인덱스 연산 (Array Index Operations)
arrayIndexOfInt
설명: 정수 값의 첫 번째 0 기반 인덱스를 반환해요.
문법: arrayIndexOfInt(int_array, value)
예시:
SELECT arrayIndexOfInt(ARRAY[10, 20, 3, 40], 3);
-- Result: 2
arrayIndexOfString
설명: 문자열 값의 첫 번째 0 기반 인덱스를 반환해요.
문법: arrayIndexOfString(string_array, value)
예시:
SELECT arrayIndexOfString(ARRAY['apple', 'banana', 'cherry'], 'cherry');
-- Result: 2
arrayIndexesOfInt
설명: 정수 값의 모든 인덱스를 반환해요.
문법: arrayIndexesOfInt(int_array, value)
예시:
SELECT arrayIndexesOfInt(ARRAY[5, 3, 5, 2, 5], 5);
-- Result: [0, 2, 4]
arrayIndexesOfLong
설명: long 값의 모든 인덱스를 반환해요.
문법: arrayIndexesOfLong(long_array, value)
예시:
SELECT arrayIndexesOfLong(ARRAY[5000000000, 3000000000, 5000000000], 5000000000);
-- Result: [0, 2]
arrayIndexesOfFloat
설명: float 값의 모든 인덱스를 반환해요.
문법: arrayIndexesOfFloat(float_array, value)
예시:
SELECT arrayIndexesOfFloat(ARRAY[1.5, 3.0, 1.5], 1.5);
-- Result: [0, 2]
arrayIndexesOfDouble
설명: double 값의 모든 인덱스를 반환해요.
문법: arrayIndexesOfDouble(double_array, value)
예시:
SELECT arrayIndexesOfDouble(ARRAY[123.456, 789.012, 123.456], 123.456);
-- Result: [0, 2]
arrayIndexesOfString
설명: 문자열 값의 모든 인덱스를 반환해요.
문법: arrayIndexesOfString(string_array, value)
예시:
SELECT arrayIndexesOfString(ARRAY['a', 'b', 'a'], 'a');
-- Result: [0, 2]
배열 교집합 (Array Intersection)
intersectIndices
설명: 두 정렬된 정수 배열 사이의 공통 인덱스를 반환해요.
문법: intersectIndices(array1, array2)
예시:
SELECT intersectIndices(ARRAY[1, 3, 5], ARRAY[3, 5]);
-- Result: [3, 5]
arraysOverlap
설명:
두 입력 배열에 공통 요소가 하나라도 있으면 true를, 그렇지 않으면 false를 반환해요.
두 배열이 겹치는 값을 공유하는지 확인할 때 유용해요 — 예를 들어 사용자의 할당된 태그가 필터 태그 집합과 교차하는지 검사할 때 써요.\
지원하는 배열 요소 타입: INT, LONG, FLOAT, DOUBLE, BIG_DECIMAL, STRING, BYTES.
문법:
arraysOverlap(array1, array2)\
예시:
SELECT arraysOverlap(ARRAY[1, 3, 5], ARRAY[3, 5]);
-- Result: true
배열 포함 (Array Contains)
arrayContainsInt
설명: 정수 배열이 값을 포함하는지 확인해요.
문법: arrayContainsInt(int_array, value)
예시:
SELECT arrayContainsInt(ARRAY[3, 7, 9], 7);
-- Result: true
arrayContainsString
설명: 문자열 배열이 값을 포함하는지 확인해요.
문법: arrayContainsString(string_array, value)
예시:
SELECT arrayContainsString(ARRAY['apple', 'banana'], 'apple');
-- Result: true
배열 슬라이싱 (Array Slicing)
arraySliceInt
설명: 하위 배열을 추출해요 (시작 포함, 끝 제외).
문법: arraySliceInt(int_array, start, end)
예시:
SELECT arraySliceInt(ARRAY[10, 20, 30, 40], 1, 3);
-- Result: [20, 30]
arraySliceLong
설명: LONG 하위 배열을 추출해요 (시작 포함, 끝 제외).
문법: arraySliceLong(long_array, start, end)
예시:
SELECT arraySliceLong(ARRAY[10000000000, 20000000000, 30000000000, 40000000000], 1, 3);
-- Result: [20000000000, 30000000000]
arraySliceString
설명: 문자열 하위 배열을 추출해요.
문법: arraySliceString(string_array, start, end)
예시:
SELECT arraySliceString(ARRAY['a', 'b', 'c', 'd'], 0, 2);
-- Result: ['a', 'b']
배열 중복 제거 (Array Distinct)
arrayDistinctInt
설명: 중복 정수를 제거해요.
문법: arrayDistinctInt(int_array)
예시:
SELECT arrayDistinctInt(ARRAY[1, 2, 2, 3, 1]);
-- Result: [1, 2, 3]
arrayDistinctString
설명: 중복 문자열을 제거해요.
문법: arrayDistinctString(string_array)
예시:
SELECT arrayDistinctString(ARRAY['apple', 'banana', 'apple']);
-- Result: ['apple', 'banana']
배열 제거 (Array Remove)
arrayRemoveInt
설명: 정수의 첫 번째 발생을 제거해요.
문법: arrayRemoveInt(int_array, value)
예시:
SELECT arrayRemoveInt(ARRAY[2, 4, 2, 6], 2);
-- Result: [4, 2, 6]
arrayRemoveString
설명: 문자열의 첫 번째 발생을 제거해요.
문법: arrayRemoveString(string_array, value)
예시:
SELECT arrayRemoveString(ARRAY['apple', 'banana', 'cherry'], 'banana');
-- Result: ['apple', 'cherry']
배열 합집합 (Array Union)
arrayUnionInt
설명: 고유한 값을 가진 두 정수 배열을 결합해요.
문법: arrayUnionInt(array1, array2)
예시:
SELECT arrayUnionInt(ARRAY[1, 2], ARRAY[2, 3]);
-- Result: [1, 2, 3]
arrayUnionString
설명: 고유한 값을 가진 두 문자열 배열을 결합해요.
문법: arrayUnionString(array1, array2)
예시:
SELECT arrayUnionString(ARRAY['a', 'b'], ARRAY['b', 'c']);
-- Result: ['a', 'b', 'c']
배열 연결 (Array Concatenation)
arrayConcatInt
설명: 두 정수 배열을 연결해요.
문법: arrayConcatInt(array1, array2)
예시:
SELECT arrayConcatInt(ARRAY[1, 2], ARRAY[3, 4]);
-- Result: [1, 2, 3, 4]
arrayConcatLong
설명: 두 long 배열을 연결해요.
문법: arrayConcatLong(array1, array2)
예시:
SELECT arrayConcatLong(ARRAY[1000000000, 2000000000], ARRAY[3000000000]);
-- Result: [1000000000, 2000000000, 3000000000]
arrayConcatFloat
설명: 두 float 배열을 연결해요.
문법: arrayConcatFloat(array1, array2)
예시:
SELECT arrayConcatFloat(ARRAY[1.5, 2.0], ARRAY[3.5]);
-- Result: [1.5, 2.0, 3.5]
arrayConcatDouble
설명: 두 double 배열을 연결해요.
문법: arrayConcatDouble(array1, array2)
예시:
SELECT arrayConcatDouble(ARRAY[123.456], ARRAY[789.012]);
-- Result: [123.456, 789.012]
arrayConcatString
설명: 두 문자열 배열을 연결해요.
문법: arrayConcatString(array1, array2)
예시:
SELECT arrayConcatString(ARRAY['a', 'b'], ARRAY['c']);
-- Result: ['a', 'b', 'c']
배열 푸시 (Array Push)
arrayPushBack
설명: 끝에 요소 하나가 추가된 새 배열을 반환해요.
지원 변형:
arrayPushBackInt(array, element)arrayPushBackLong(array, element)arrayPushBackFloat(array, element)arrayPushBackDouble(array, element)arrayPushBackString(array, element)
예시:
SELECT arrayPushBackInt(intArray, 7)
intArray가 [3, 2, 10, 6, 1, 12]이면 결과는 [3, 2, 10, 6, 1, 12, 7]이에요.
SELECT arrayPushBackString(stringArray, 'x')
stringArray가 ['3', '2', '10', '6', '1', '12']이면 결과는 ['3', '2', '10', '6', '1', '12', 'x']이에요.
arrayPushFront
설명: 앞쪽에 요소 하나가 삽입된 새 배열을 반환해요.
지원 변형:
arrayPushFrontInt(array, element)arrayPushFrontLong(array, element)arrayPushFrontFloat(array, element)arrayPushFrontDouble(array, element)arrayPushFrontString(array, element)
예시:
SELECT arrayPushFrontInt(intArray, 7)
intArray가 [3, 2, 10, 6, 1, 12]이면 결과는 [7, 3, 2, 10, 6, 1, 12]이에요.
SELECT arrayPushFrontString(stringArray, 'x')
stringArray가 ['3', '2', '10', '6', '1', '12']이면 결과는 ['x', '3', '2', '10', '6', '1', '12']이에요.
배열 요소 접근 (Array Element Access)
arrayElementAtInt
설명: 1 기반 인덱스 정수 요소를 반환해요.
문법: arrayElementAtInt(array, index)
예시:
SELECT arrayElementAtInt(ARRAY[10, 20, 30], 2);
-- Result: 20
arrayElementAtLong
설명: 1 기반 인덱스 long 요소를 반환해요.
문법: arrayElementAtLong(array, index)
예시:
SELECT arrayElementAtLong(ARRAY[1000000000, 2000000000], 1);
-- Result: 1000000000
arrayElementAtFloat
설명: 1 기반 인덱스 float 요소를 반환해요.
문법: arrayElementAtFloat(array, index)
예시:
SELECT arrayElementAtFloat(ARRAY[1.5, 2.0], 2);
-- Result: 2.0
arrayElementAtDouble
설명: 1 기반 인덱스 double 요소를 반환해요.
문법: arrayElementAtDouble(array, index)
예시:
SELECT arrayElementAtDouble(ARRAY[123.456, 789.012], 1);
-- Result: 123.456
arrayElementAtString
설명: 1 기반 인덱스 문자열 요소를 반환해요.
문법: arrayElementAtString(array, index)
예시:
SELECT arrayElementAtString(ARRAY['alpha', 'beta', 'gamma'], 1);
-- Result: 'alpha'
배열 합산 (Array Summation)
arraySumInt
설명: 배열의 모든 정수를 합산해요.
문법: arraySumInt(int_array)
예시:
SELECT arraySumInt(ARRAY[1, 2, 3, 4]);
-- Result: 10
arraySumLong
설명: 배열의 모든 long을 합산해요.
문법: arraySumLong(long_array)
예시:
SELECT arraySumLong(ARRAY[1000000000, 2000000000]);
-- Result: 3000000000
배열 생성 (Array Construction)
arrayValueConstructor
설명: 요소들로 배열을 생성해요.
문법: array(element1, element2, ...)
예시:
SELECT array(1, 2, 3) AS int_array, array('a', 'b') AS str_array;
-- Result:
-- int_array = [1, 2, 3]
-- str_array = ['a', 'b']
배열 생성 (Array Generation)
generateIntArray
설명: 정수 수열을 생성해요.
문법: generateIntArray(start, end, increment)
예시:
SELECT generateIntArray(1, 5, 2);
-- Result: [1, 3, 5]
generateLongArray
설명: long 수열을 생성해요.
문법: generateLongArray(start, end, increment)
예시:
SELECT generateLongArray(100, 300, 100);
-- Result: [100, 200, 300]
generateFloatArray
설명: float 수열을 생성해요.
문법: generateFloatArray(start, end, increment)
예시:
SELECT generateFloatArray(0.5, 2.0, 0.5);
-- Result: [0.5, 1.0, 1.5, 2.0]
generateDoubleArray
설명: double 수열을 생성해요.
문법: generateDoubleArray(start, end, increment)
예시:
SELECT generateDoubleArray(1.0, 2.5, 0.5);
-- Result: [1.0, 1.5, 2.0, 2.5]
문자열 변환 (String Conversion)
arrayToString (2-인자)
설명: 요소를 구분자로 결합해요.
문법: arrayToString(string_array, delimiter)
예시:
SELECT arrayToString(ARRAY['red', 'green', 'blue'], ',');
-- Result: 'red,green,blue'
arrayToString (3-인자)
설명: null 대체 값으로 요소를 결합해요.
문법: arrayToString(string_array, delimiter, nullString)
예시:
SELECT arrayToString(ARRAY['foo', NULL, 'bar'], '|', 'NA');
-- Result: 'foo|NA|bar'