배열 함수와 연산자

배열 함수와 연산자 (Array functions and operators)

이 문서는 Trino의 배열 함수와 연산자를 설명합니다. 배열 접근, 연결, 정렬, 변환, 집계 등 다양한 배열 조작 기능을 배울 수 있어요.

출처: 문서

본문

배열 함수와 연산자는 ARRAY 유형을 사용합니다. 데이터 유형 생성자로 배열을 만듭니다.

정수 배열 만들기:

SELECT ARRAY[1, 2, 4];
-- [1, 2, 4]

문자 값 배열 만들기:

SELECT ARRAY['foo', 'bar', 'bazz'];
-- [foo, bar, bazz]

배열 요소는 같은 유형이거나 공통 유형으로 강제 변환 가능해야 합니다. 다음 예제는 정수와 십진수 값을 사용하며 결과 배열은 십진수를 포함합니다:

SELECT ARRAY[1, 1.2, 4];
-- [1.0, 1.2, 4.0]

null 값이 허용됩니다:

SELECT ARRAY[1, 2, NULL, -4, NULL];
-- [1, 2, NULL, -4, NULL]

부분 문자열 연산자: [] (Subscript operator)

[] 연산자는 배열의 요소에 접근하는 데 사용되며 1부터 인덱싱됩니다:

SELECT my_array[1] AS first_element

다음 예제는 배열을 구성한 뒤 두 번째 요소에 접근합니다:

SELECT ARRAY[1, 1.2, 4][2];
-- 1.2

연결 연산자: || (Concatenation operator)

|| 연산자는 배열을 배열 또는 같은 유형의 요소와 연결하는 데 사용됩니다:

SELECT ARRAY[1] || ARRAY[2];
-- [1, 2]

SELECT ARRAY[1] || 2;
-- [1, 2]

SELECT 2 || ARRAY[1];
-- [2, 1]

배열 함수 (Array functions)

all_match(array(T), function(T, boolean)) → boolean

배열의 모든 요소가 주어진 조건과 일치하는지 여부를 반환합니다. 모든 요소가 조건과 일치하면 true(배열이 비어 있는 경우가 특수 케이스), 하나 이상의 요소가 일치하지 않으면 false, 조건 함수가 하나 이상의 요소에 대해 NULL을 반환하고 나머지 모든 요소에 대해 true이면 NULL.

any_match(array(T), function(T, boolean)) → boolean

배열의 어떤 요소가 주어진 조건과 일치하는지 여부를 반환합니다. 하나 이상의 요소가 일치하면 true, 어떤 요소도 일치하지 않으면 false(배열이 비어 있는 경우가 특수 케이스), 조건 함수가 하나 이상의 요소에 대해 NULL을 반환하고 나머지 모든 요소에 대해 false이면 NULL.

array_distinct(x) → array

배열 x에서 중복 값을 제거합니다.

array_intersect(x, y) → array

x와 y의 교집합 요소의 배열을 중복 없이 반환합니다.

array_union(x, y) → array

x와 y의 합집합 요소의 배열을 중복 없이 반환합니다.

array_except(x, y) → array

x에는 있지만 y에는 없는 요소의 배열을 중복 없이 반환합니다.

array_first(array(E)) → E

array의 첫 번째 요소를 반환합니다. 배열이 비어 있으면 NULL을 반환하는데, 이러한 경우 부분 문자열 연산자는 실패할 것입니다.

array_first(array(E), function(E, boolean)) → E

조건과 일치하는 array의 첫 번째 요소를 반환합니다. 배열이 비어 있거나 일치하는 것이 없으면 NULL을 반환합니다.

array_histogram(x) → map<K, bigint>

키가 입력 배열 x의 고유 요소이고 값이 각 요소가 x에 나타나는 횟수인 맵을 반환합니다. null 값은 무시됩니다.

SELECT array_histogram(ARRAY[42, 7, 42, NULL]);
-- {42=2, 7=1}

입력 배열에 null이 아닌 요소가 없으면 빈 맵을 반환합니다.

SELECT array_histogram(ARRAY[NULL, NULL]);
-- {}

array_join(x, delimiter) → varchar

구분자를 사용해 주어진 배열의 요소를 연결합니다. null 요소는 결과에서 생략됩니다.

array_join(x, delimiter, null_replacement) → varchar

구분자와 null을 대체할 선택적 문자열을 사용해 주어진 배열의 요소를 연결합니다.

array_last(array(E)) → E

array의 마지막 요소를 반환합니다. 배열이 비어 있으면 NULL을 반환합니다.

array_max(x) → x

입력 배열의 최댓값을 반환합니다.

array_min(x) → x

입력 배열의 최솟값을 반환합니다.

array_position(x, element) → bigint

배열 x에서 element의 첫 번째 발생 위치를 반환합니다(없으면 0).

array_remove(x, element) → array

배열 x에서 element와 같은 모든 요소를 제거합니다.

array_sort(x) → array

배열 x를 정렬해 반환합니다. x의 요소는 정렬 가능해야 합니다. null 요소는 반환 배열의 끝에 배치됩니다.

array_sort(array(T), function(T, T, int)) → array(T)

주어진 비교 function에 따라 array를 정렬해 반환합니다. 비교자는 배열의 두 null 가능 요소를 나타내는 두 null 가능 인수를 받습니다. 첫 번째 null 가능 요소가 두 번째보다 작으면 -1, 같으면 0, 크면 1을 반환합니다. 비교자 함수가 다른 값(NULL 포함)을 반환하면 쿼리가 실패하고 오류를 발생시킵니다.

SELECT array_sort(ARRAY[3, 2, 5, 1, 2],
                  (x, y) -> IF(x < y, 1, IF(x = y, 0, -1)));
-- [5, 3, 2, 2, 1]

SELECT array_sort(ARRAY['bc', 'ab', 'dc'],
                  (x, y) -> IF(x < y, 1, IF(x = y, 0, -1)));
-- ['dc', 'bc', 'ab']

SELECT array_sort(ARRAY[3, 2, null, 5, null, 1, 2],
                  -- 내림차순으로 null을 먼저 정렬
                  (x, y) -> CASE WHEN x IS NULL THEN -1
                                 WHEN y IS NULL THEN 1
                                 WHEN x < y THEN 1
                                 WHEN x = y THEN 0
                                 ELSE -1 END);
-- [null, null, 5, 3, 2, 2, 1]

SELECT array_sort(ARRAY[3, 2, null, 5, null, 1, 2],
                  -- 내림차순으로 null을 마지막에 정렬
                  (x, y) -> CASE WHEN x IS NULL THEN 1
                                 WHEN y IS NULL THEN -1
                                 WHEN x < y THEN 1
                                 WHEN x = y THEN 0
                                 ELSE -1 END);
-- [5, 3, 2, 2, 1, null, null]

SELECT array_sort(ARRAY['a', 'abcd', 'abc'],
                  -- 문자열 길이로 정렬
                  (x, y) -> IF(length(x) < length(y), -1,
                               IF(length(x) = length(y), 0, 1)));
-- ['a', 'abc', 'abcd']

SELECT array_sort(ARRAY[ARRAY[2, 3, 1], ARRAY[4, 2, 1, 4], ARRAY[1, 2]],
                  -- 배열 길이로 정렬
                  (x, y) -> IF(cardinality(x) < cardinality(y), -1,
                               IF(cardinality(x) = cardinality(y), 0, 1)));
-- [[1, 2], [2, 3, 1], [4, 2, 1, 4]]

arrays_overlap(x, y) → boolean

배열 x와 y에 공통의 null이 아닌 요소가 있는지 검사합니다. 공통의 null이 아닌 요소는 없지만 한 배열이 null을 포함하면 null을 반환합니다.

cardinality(x) → bigint

배열 x의 카디널리티(크기)를 반환합니다.

concat(array1, array2, ..., arrayN) → array

배열 array1, array2, ..., arrayN을 연결합니다. 이 함수는 SQL 표준 연결 연산자(||)와 같은 기능을 제공합니다.

combinations(array(T), n) → array(array(T))

입력 배열의 n-요소 하위 그룹을 반환합니다. 입력 배열에 중복이 없으면 combinations는 n-요소 부분 집합을 반환합니다.

SELECT combinations(ARRAY['foo', 'bar', 'baz'], 2);
-- [['foo', 'bar'], ['foo', 'baz'], ['bar', 'baz']]

SELECT combinations(ARRAY[1, 2, 3], 2);
-- [[1, 2], [1, 3], [2, 3]]

SELECT combinations(ARRAY[1, 2, 2], 2);
-- [[1, 2], [1, 2], [2, 2]]

하위 그룹의 순서는 결정적이지만 지정되지 않습니다. 하위 그룹 내 요소 순서도 결정적이지만 지정되지 않습니다. n은 5보다 크면 안 되고, 생성된 하위 그룹의 총 크기는 100,000보다 작아야 합니다.

contains(x, element) → boolean

배열 x에 element가 포함되어 있으면 true를 반환합니다.

contains_sequence(x, seq) → boolean

배열 x가 배열 seq의 모든 값을 하위 시퀀스(모든 값이 같은 연속 순서)로 포함하면 true를 반환합니다.

element_at(array(E), index) → E

주어진 index의 array 요소를 반환합니다. index > 0이면 이 함수는 SQL 표준 부분 문자열 연산자([])와 같은 기능을 제공하지만, 배열 길이보다 큰 index에 접근하면 연산자는 실패하는 반면 함수는 NULL을 반환합니다. index < 0이면 배열 끝에서부터 세는 요소를 반환합니다.

filter(array(T), function(T, boolean)) → array(T)

function이 true를 반환하는 array의 요소들로 배열을 구성합니다:

SELECT filter(ARRAY[], x -> true);
-- []

SELECT filter(ARRAY[5, -6, NULL, 7], x -> x > 0);
-- [5, 7]

SELECT filter(ARRAY[5, NULL, 7, NULL], x -> x IS NOT NULL);
-- [5, 7]

flatten(x) → array

포함된 배열을 연결해 array(array(T))를 array(T)로 평탄화합니다.

ngrams(array(T), n) → array(array(T))

array에 대한 n-그램(인접한 n 요소의 하위 시퀀스)을 반환합니다. 결과의 n-그램 순서는 지정되지 않습니다.

SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 2);
-- [['foo', 'bar'], ['bar', 'baz'], ['baz', 'foo']]

SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 3);
-- [['foo', 'bar', 'baz'], ['bar', 'baz', 'foo']]

SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 4);
-- [['foo', 'bar', 'baz', 'foo']]

SELECT ngrams(ARRAY['foo', 'bar', 'baz', 'foo'], 5);
-- [['foo', 'bar', 'baz', 'foo']]

SELECT ngrams(ARRAY[1, 2, 3, 4], 2);
-- [[1, 2], [2, 3], [3, 4]]

none_match(array(T), function(T, boolean)) → boolean

배열의 어떤 요소도 주어진 조건과 일치하지 않는지 여부를 반환합니다. 어떤 요소도 일치하지 않으면 true(배열이 비어 있는 경우가 특수 케이스), 하나 이상의 요소가 일치하면 false, 조건 함수가 하나 이상의 요소에 대해 NULL을 반환하고 나머지 모든 요소에 대해 false이면 NULL.

reduce(array(T), initialState S, inputFunction(S, T, S), outputFunction(S, R)) → R

array에서 축소된 단일 값을 반환합니다. inputFunction은 array의 각 요소에 대해 순서대로 호출됩니다. 요소를 받는 것에 더해 inputFunction은 현재 상태(초기에는 initialState)를 받아 새 상태를 반환합니다. outputFunction은 최종 상태를 결과 값으로 바꾸는 데 호출됩니다. 항등 함수(i -> i)일 수 있습니다.

SELECT reduce(ARRAY[], 0,
              (s, x) -> s + x,
              s -> s);
-- 0

SELECT reduce(ARRAY[5, 20, 50], 0,
              (s, x) -> s + x,
              s -> s);
-- 75

SELECT reduce(ARRAY[5, 20, NULL, 50], 0,
              (s, x) -> s + x,
              s -> s);
-- NULL

SELECT reduce(ARRAY[5, 20, NULL, 50], 0,
              (s, x) -> s + coalesce(x, 0),
              s -> s);
-- 75

SELECT reduce(ARRAY[5, 20, NULL, 50], 0,
              (s, x) -> IF(x IS NULL, s, s + x),
              s -> s);
-- 75

SELECT reduce(ARRAY[2147483647, 1], BIGINT '0',
              (s, x) -> s + x,
              s -> s);
-- 2147483648

-- 산술 평균 계산
SELECT reduce(ARRAY[5, 6, 10, 20],
              CAST(ROW(0.0, 0) AS ROW(sum DOUBLE, count INTEGER)),
              (s, x) -> CAST(ROW(x + s.sum, s.count + 1) AS
                             ROW(sum DOUBLE, count INTEGER)),
              s -> IF(s.count = 0, NULL, s.sum / s.count));
-- 10.25

repeat(element, count) → array

element를 count번 반복합니다.

reverse(x) → array

배열 x의 역순 배열을 반환합니다.

sequence(start, stop)

start가 stop보다 작거나 같으면 1씩, 그렇지 않으면 -1씩 증가하며 start에서 stop까지 정수 시퀀스를 생성합니다.

sequence(start, stop, step)

step씩 증가하며 start에서 stop까지 정수 시퀀스를 생성합니다.

sequence(start, stop)

start 날짜가 stop 날짜보다 작거나 같으면 1일씩, 그렇지 않으면 -1일씩 증가하며 start 날짜에서 stop 날짜까지 날짜 시퀀스를 생성합니다.

sequence(start, stop, step)

step씩 증가하며 start에서 stop까지 날짜 시퀀스를 생성합니다. step의 유형은 INTERVAL DAY TO SECOND 또는 INTERVAL YEAR TO MONTH일 수 있습니다.

sequence(start, stop, step)

step씩 증가하며 start에서 stop까지 타임스탬프 시퀀스를 생성합니다. step의 유형은 INTERVAL DAY TO SECOND 또는 INTERVAL YEAR TO MONTH일 수 있습니다.

shuffle(x) → array

주어진 배열 x의 무작위 순열을 생성합니다.

slice(x, start, length) → array

인덱스 start(음수면 끝에서부터)에서 시작하는 길이 length의 배열 x 하위 집합을 만듭니다.

trim_array(x, n) → array

배열의 끝에서 n개 요소를 제거합니다:

SELECT trim_array(ARRAY[1, 2, 3, 4], 1);
-- [1, 2, 3]

SELECT trim_array(ARRAY[1, 2, 3, 4], 2);
-- [1, 2]

transform(array(T), function(T, U)) → array(U)

function을 array의 각 요소에 적용한 결과인 배열을 반환합니다:

SELECT transform(ARRAY[], x -> x + 1);
-- []

SELECT transform(ARRAY[5, 6], x -> x + 1);
-- [6, 7]

SELECT transform(ARRAY[5, NULL, 6], x -> coalesce(x, 0) + 1);
-- [6, 1, 7]

SELECT transform(ARRAY['x', 'abc', 'z'], x -> x || '0');
-- ['x0', 'abc0', 'z0']

SELECT transform(ARRAY[ARRAY[1, NULL, 2], ARRAY[3, NULL]],
                 a -> filter(a, x -> x IS NOT NULL));
-- [[1, 2], [3]]

euclidean_distance(array(double), array(double)) → double

유클리드 거리를 계산합니다:

SELECT euclidean_distance(ARRAY[1.0, 2.0], ARRAY[3.0, 4.0]);
-- 2.8284271247461903

dot_product(array(double), array(double)) → double

내적을 계산합니다:

SELECT dot_product(ARRAY[1.0, 2.0], ARRAY[3.0, 4.0]);
-- 11.0

zip(array1, array2[, ...]) → array(row)

주어진 배열들을 요소별로 단일 행 배열로 병합합니다. N번째 인수의 M번째 요소는 M번째 출력 요소의 N번째 필드가 됩니다. 인수 길이가 고르지 않으면 빠진 값은 NULL로 채워집니다.

SELECT zip(ARRAY[1, 2], ARRAY['1b', null, '3b']);
-- [ROW(1, '1b'), ROW(2, null), ROW(null, '3b')]

zip_with(array(T), array(U), function(T, U, R)) → array(R)

function을 사용해 주어진 두 배열을 요소별로 단일 배열로 병합합니다. 한 배열이 더 짧으면 function을 적용하기 전에 더 긴 배열의 길이에 맞춰 끝에 null을 추가합니다.

SELECT zip_with(ARRAY[1, 3, 5], ARRAY['a', 'b', 'c'],
                (x, y) -> (y, x));
-- [ROW('a', 1), ROW('b', 3), ROW('c', 5)]

SELECT zip_with(ARRAY[1, 2], ARRAY[3, 4],
                (x, y) -> x + y);
-- [4, 6]

SELECT zip_with(ARRAY['a', 'b', 'c'], ARRAY['d', 'e', 'f'],
                (x, y) -> concat(x, y));
-- ['ad', 'be', 'cf']

SELECT zip_with(ARRAY['a'], ARRAY['d', null, 'f'],
                (x, y) -> coalesce(x, y));
-- ['a', null, 'f']

더 알아보기 (Learn more)

배열과 밀접하게 연관된 맵 함수와 람다 표현식도 살펴보세요. 배열 요소를 변환/정렬할 때 람다 함수를 자주 활용하게 될 거예요.