Map 함수와 연산자

Map 함수와 연산자

키-값 쌍으로 데이터를 저장하는 MAP 타입을 다루는 함수와 연산자예요. 맵을 만들고 조회·변환할 때 써요.

출처: 문서

본문

Map 함수와 연산자는 MAP 타입을 사용해요. 데이터 타입 생성자로 키 배열과 같은 순서의 값 배열을 사용해 맵을 만들어요. 키는 문자 기반이어야 하고 null일 수 없어요.

정수 값을 가진 배열 만들기:

SELECT MAP(ARRAY['key1', 'key2', 'key3' ], ARRAY[2373, 3463, 45837]);
-- {key1=2373, key2=3463, key3=45837}

문자 값을 가진 배열 만들기:

SELECT MAP(ARRAY['key1', 'key2', 'key3' ], ARRAY['v1', 'v2', 'v3']);
-- {key1=v1, key2=v2, key3=v3}

값들은 같은 타입이거나 공통 타입으로 강제 변환할 수 있어야 해요. 다음 예제는 정수와 decimal 값을 사용하며 결과 배열은 decimal을 담아요.

SELECT MAP(ARRAY['key1', 'key2', 'key3' ], ARRAY[23, 34.63, 45.837]);
-- {key1=23.000, key2=34.630, key3=45.837}

null 값은 허용돼요.

SELECT MAP(ARRAY['key1', 'key2', 'key3' ], ARRAY['v1', NULL, 'v3']);
-- {key1=v1, key2=NULL, key3=v3}

첨자 연산자: []

[] 연산자는 맵에서 주어진 키에 해당하는 값을 검색하는 데 사용해요. 이 연산자는 키가 맵에 없으면 오류를 던져요. 그런 경우 NULL을 반환하는 element_at 함수도 참고하세요.

SELECT name_to_age_map['Bob'] AS bob_age;

다음 예제는 맵을 만들고 키 key2의 요소에 접근해요.

SELECT MAP(ARRAY['key1', 'key2', 'key3' ], ARRAY['v1', 'v2', 'v3'])['key2'];
-- v2

Map 함수 (Map functions)

cardinality(x) → bigint

맵 x의 카디널리티(크기)를 반환해요.

element_at(map(K, V), key) → V

주어진 key에 대한 값을 반환하고, 키가 맵에 없으면 NULL을 반환해요.

map() → map<unknown, unknown>

빈 맵을 반환해요.

SELECT map();
-- {}

map(array(K), array(V)) -> map(K, V)

주어진 키/값 배열을 사용해 만든 맵을 반환해요.

SELECT map(ARRAY[1,3], ARRAY[2,4]);
-- {1 -> 2, 3 -> 4}

집계로 맵을 만드는 map_agg()와 multimap_agg()도 참고하세요.

map_from_entries(array(row(K, V))) -> map(K, V)

주어진 항목(entries) 배열에서 만든 맵을 반환해요.

SELECT map_from_entries(ARRAY[(1, 'x'), (2, 'y')]);
-- {1 -> 'x', 2 -> 'y'}

multimap_from_entries(array(row(K, V))) -> map(K, array(V))

주어진 항목 배열에서 만든 멀티맵(multimap)을 반환해요. 각 키는 여러 값과 연결될 수 있어요.

SELECT multimap_from_entries(ARRAY[(1, 'x'), (2, 'y'), (1, 'z')]);
-- {1 -> ['x', 'z'], 2 -> ['y']}

map_entries(map(K, V)) -> array(row(K, V))

주어진 맵의 모든 항목 배열을 반환해요.

SELECT map_entries(MAP(ARRAY[1, 2], ARRAY['x', 'y']));
-- [ROW(1, 'x'), ROW(2, 'y')]

map_concat(map1(K, V), map2(K, V), ..., mapN(K, V)) -> map(K, V)

주어진 모든 맵의 합집합을 반환해요. 키가 여러 맵에 있으면 결과 맵의 그 키 값은 그중 마지막 맵의 값이 돼요.

map_filter(map(K, V), function(K, V, boolean)) -> map(K, V)

function이 true를 반환하는 map의 항목들로 맵을 구성해요.

SELECT map_filter(MAP(ARRAY[], ARRAY[]), (k, v) -> true);
-- {}

SELECT map_filter(MAP(ARRAY[10, 20, 30], ARRAY['a', NULL, 'c']),
                  (k, v) -> v IS NOT NULL);
-- {10 -> a, 30 -> c}

SELECT map_filter(MAP(ARRAY['k1', 'k2', 'k3'], ARRAY[20, 3, 15]),
                  (k, v) -> v > 10);
-- {k1 -> 20, k3 -> 15}

map_keys(x(K, V)) -> array(K)

맵 x의 모든 키를 반환해요.

map_values(x(K, V)) -> array(V)

맵 x의 모든 값을 반환해요.

map_zip_with(map(K, V1), map(K, V2), function(K, V1, V2, V3)) -> map(K, V3)

같은 키를 가진 값 쌍에 function을 적용해 두 맵을 하나로 병합해요. 한 쪽 맵에만 있는 키는, 없는 쪽 값에 NULL이 전달돼요.

SELECT map_zip_with(MAP(ARRAY[1, 2, 3], ARRAY['a', 'b', 'c']),
                    MAP(ARRAY[1, 2, 3], ARRAY['d', 'e', 'f']),
                    (k, v1, v2) -> concat(v1, v2));
-- {1 -> ad, 2 -> be, 3 -> cf}

SELECT map_zip_with(MAP(ARRAY['k1', 'k2'], ARRAY[1, 2]),
                    MAP(ARRAY['k2', 'k3'], ARRAY[4, 9]),
                    (k, v1, v2) -> (v1, v2));
-- {k1 -> ROW(1, null), k2 -> ROW(2, 4), k3 -> ROW(null, 9)}

SELECT map_zip_with(MAP(ARRAY['a', 'b', 'c'], ARRAY[1, 8, 27]),
                    MAP(ARRAY['a', 'b', 'c'], ARRAY[1, 2, 3]),
                    (k, v1, v2) -> k || CAST(v1 / v2 AS VARCHAR));
-- {a -> a1, b -> b4, c -> c9}

transform_keys(map(K1, V), function(K1, V, K2)) -> map(K2, V)

function을 map의 각 항목에 적용해 키를 변환한 맵을 반환해요.

SELECT transform_keys(MAP(ARRAY[], ARRAY[]), (k, v) -> k + 1);
-- {}

SELECT transform_keys(MAP(ARRAY [1, 2, 3], ARRAY ['a', 'b', 'c']),
                      (k, v) -> k + 1);
-- {2 -> a, 3 -> b, 4 -> c}

SELECT transform_keys(MAP(ARRAY ['a', 'b', 'c'], ARRAY [1, 2, 3]),
                      (k, v) -> v * v);
-- {1 -> 1, 4 -> 2, 9 -> 3}

SELECT transform_keys(MAP(ARRAY ['a', 'b'], ARRAY [1, 2]),
                      (k, v) -> k || CAST(v as VARCHAR));
-- {a1 -> 1, b2 -> 2}

SELECT transform_keys(MAP(ARRAY [1, 2], ARRAY [1.0, 1.4]),
                      (k, v) -> MAP(ARRAY[1, 2], ARRAY['one', 'two'])[k]);
-- {one -> 1.0, two -> 1.4}

transform_values(map(K, V1), function(K, V1, V2)) -> map(K, V2)

function을 map의 각 항목에 적용해 값을 변환한 맵을 반환해요.

SELECT transform_values(MAP(ARRAY[], ARRAY[]), (k, v) -> v + 1);
-- {}

SELECT transform_values(MAP(ARRAY [1, 2, 3], ARRAY [10, 20, 30]),
                        (k, v) -> v + k);
-- {1 -> 11, 2 -> 22, 3 -> 33}

SELECT transform_values(MAP(ARRAY [1, 2, 3], ARRAY ['a', 'b', 'c']),
                        (k, v) -> k * k);
-- {1 -> 1, 2 -> 4, 3 -> 9}

SELECT transform_values(MAP(ARRAY ['a', 'b'], ARRAY [1, 2]),
                        (k, v) -> k || CAST(v as VARCHAR));
-- {a -> a1, b -> b2}

SELECT transform_values(MAP(ARRAY [1, 2], ARRAY [1.0, 1.4]),
                        (k, v) -> MAP(ARRAY[1, 2], ARRAY['one', 'two'])[k]
                          || '_' || CAST(v AS VARCHAR));
-- {1 -> one_1.0, 2 -> two_1.4}

더 알아보기 (Learn more)

맵을 집계로 만들 때는 집계 함수 문서의 map_agg(), multimap_agg()를 참고해 보세요. MAP 타입 자체는 타입 문서에서 확인할 수 있어요.