맵 함수 - ClickHouse Documentation

extractKeyValuePairs

도입 버전: v23.4.0 임의의 문자열에서 key-value 쌍을 추출합니다. 문자열이 반드시 100% key-value 쌍 형식으로 구조화되어 있을 필요는 없습니다. 노이즈(예: 로그 파일)가 포함될 수 있습니다. 해석할 키-값 쌍 포맷은 함수 인수를 통해 지정해야 합니다. 키-값 쌍은 키, key_value_delimiter, 값 순서로 구성됩니다. 따옴표로 묶인 키와 값도 지원됩니다. 키-값 쌍은 쌍 구분 기호(pair delimiter)로 구분해야 합니다. 구문

extractKeyValuePairs(data, [key_value_delimiter], [pair_delimiter], [quoting_character])

인수

data - 키-값 쌍을 추출할 대상 문자열입니다. String 또는 FixedString입니다.
- key_value_delimiter - 키와 값을 구분하는 데 사용하는 문자입니다. 기본값은 :입니다. String 또는 FixedString입니다.
- pair_delimiters - 각 쌍을 구분하는 데 사용하는 문자 집합입니다. 기본값은 \space, ,, ;입니다. String 또는 FixedString입니다.
- quoting_character - 인용 문자로 사용하는 문자입니다. 기본값은 "입니다. String 또는 FixedString입니다.
- unexpected_quoting_character_strategy - read_key 및 read_value 단계에서 예상하지 못한 위치에 있는 인용 문자를 처리하는 전략입니다. 가능한 값은 invalid, accept, promote입니다. invalid는 키/값을 버리고 WAITING_KEY 상태로 다시 전환합니다. accept는 이를 일반 문자로 처리합니다. promote는 READ_QUOTED_{KEY/VALUE} 상태로 전환한 뒤 다음 문자부터 시작합니다. 기본값은 INVALID입니다.

반환 값

Map(String, String) 형식으로 추출된 key-value 쌍입니다.

예시 쿼리: 간단한 예시

arthur :) select extractKeyValuePairs('name:neymar, age:31 team:psg,nationality:brazil') as kv

            SELECT extractKeyValuePairs('name:neymar, age:31 team:psg,nationality:brazil') as kv

            Query id: f9e0ca6f-3178-4ee2-aa2c-a5517abb9cee

            ┌─kv──────────────────────────────────────────────────────────────────────┐
            │ {'name':'neymar','age':'31','team':'psg','nationality':'brazil'}        │
            └─────────────────────────────────────────────────────────────────────────┘

인용 문자로서의 작은따옴표

arthur :) select extractKeyValuePairs('name:\'neymar\';\'age\':31;team:psg;nationality:brazil,last_key:last_value', ':', ';,', '\'') as kv

            SELECT extractKeyValuePairs('name:\'neymar\';\'age\':31;team:psg;nationality:brazil,last_key:last_value', ':', ';,', '\'') as kv

            Query id: 0e22bf6b-9844-414a-99dc-32bf647abd5e

            ┌─kv───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
            │ {'name':'neymar','age':'31','team':'psg','nationality':'brazil','last_key':'last_value'}                                 │
            └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

unexpected_quoting_character_strategy 예시: unexpected_quoting_character_strategy=invalid

SELECT extractKeyValuePairs('name"abc:5', ':', ' ,;', '\"', 'INVALID') as kv;

┌─kv────────────────┐
            │ {'abc':'5'}  │
            └───────────────────┘

SELECT extractKeyValuePairs('name"abc":5', ':', ' ,;', '\"', 'INVALID') as kv;

┌─kv──┐
            │ {}  │
            └─────┘

unexpected_quoting_character_strategy=accept

SELECT extractKeyValuePairs('name"abc:5', ':', ' ,;', '\"', 'ACCEPT') as kv;

┌─kv────────────────┐
            │ {'name"abc':'5'}  │
            └───────────────────┘

            SELECT extractKeyValuePairs('name"abc":5', ':', ' ,;', '\"', 'ACCEPT') as kv;

            ┌─kv─────────────────┐
            │ {'name"abc"':'5'}  │
            └────────────────────┘

unexpected_quoting_character_strategy=promote

            SELECT extractKeyValuePairs('name"abc:5', ':', ' ,;', '\"', 'PROMOTE') as kv;

            ┌─kv──┐
            │ {}  │
            └─────┘

            SELECT extractKeyValuePairs('name"abc":5', ':', ' ,;', '\"', 'PROMOTE') as kv;

            ┌─kv───────────┐
            │ {'abc':'5'}  │
            └──────────────┘

이스케이프 시퀀스 지원이 없는 경우의 이스케이프 시퀀스

            arthur :) select extractKeyValuePairs('age:a\\x0A\\n\\0') as kv

            SELECT extractKeyValuePairs('age:a\\x0A\\n\\0') AS kv

            Query id: e9fd26ee-b41f-4a11-b17f-25af6fd5d356

            ┌─kv────────────────────┐
            │ {'age':'a\\x0A\\n\\0'} │
            └───────────────────────┘

구문

extractKeyValuePairs(input)

별칭: str_to_map, mapFromString 인수

없음.

반환 값 예시

extractKeyValuePairsWithEscaping

도입 버전: v23.4.0 extractKeyValuePairs와 동일하지만 이스케이프를 지원합니다. 지원되는 이스케이프 시퀀스: \x, \N, \a, \b, \e, \f, \n, \r, \t, \v, \0. 표준이 아닌 이스케이프 시퀀스는 다음 중 하나에 해당하지 않는 한 원래대로 반환됩니다(백슬래시 포함): \\, ', ", backtick, /, = 또는 ASCII 제어 문자(c <= 31). 이 함수는 사전 이스케이프와 사후 이스케이프가 적합하지 않은 경우에 유용합니다. 예를 들어, 다음과 같은 입력 문자열을 생각해 보겠습니다: a: "aaaa\"bbb". 예상 출력은 a: aaaa\"bbbb입니다.

사전 이스케이프: 사전 이스케이프를 적용하면 a: "aaaa"bbb"가 출력되고, 이후 extractKeyValuePairs는 a: aaaa를 출력합니다
- 사후 이스케이프: extractKeyValuePairs는 a: aaaa\를 출력하고, 사후 이스케이프는 이를 그대로 유지합니다.

선행 이스케이프 시퀀스는 키에서는 건너뛰며, 값에서는 유효하지 않은 것으로 간주됩니다. 이스케이프 시퀀스 지원이 활성화된 상태의 이스케이프 시퀀스

            arthur :) select extractKeyValuePairsWithEscaping('age:a\\x0A\\n\\0') as kv

            SELECT extractKeyValuePairsWithEscaping('age:a\\x0A\\n\\0') AS kv

            Query id: 44c114f0-5658-4c75-ab87-4574de3a1645

            ┌─kv───────────────┐
            │ {'age':'a\n\n\0'} │
            └──────────────────┘

구문

extractKeyValuePairsWithEscaping(input)

인수

없음.

반환 값 예시

map

도입 버전: v21.1.0 key-value 쌍에서 Map(key, value) 타입의 값을 생성합니다. 구문

map(key1, value1[, key2, value2, ...])

인수

key_n — 맵 항목의 키입니다. Any
value_n — 맵 항목의 값입니다. Any

반환 값 키:값 쌍이 포함된 맵을 반환합니다. Map(Any, Any) 예시 사용 예시

Query

SELECT map('key1', number, 'key2', number * 2) FROM numbers(3)

Response

{'key1':0,'key2':0}
{'key1':1,'key2':2}
{'key1':2,'key2':4}

mapAdd

도입 버전: v20.7.0 모든 키를 모아 해당하는 값들을 합산합니다. 구문

mapAdd(arg1[, arg2, ...])

인수

arg1[, arg2, ...] — 첫 번째 배열의 항목이 키를 나타내고, 두 번째 배열에 각 키의 값이 들어 있는 맵 또는 두 개의 배열로 구성된 튜플입니다. Map(K, V) 또는 Tuple(Array(T), Array(T))

반환 값 맵 또는 튜플을 반환합니다. 첫 번째 배열에는 정렬된 키가 들어 있고, 두 번째 배열에는 값이 들어 있습니다. Map(K, V) 또는 Tuple(Array(T), Array(T)) 예시 맵(Map) 타입 사용

Query

SELECT mapAdd(map(1, 1), map(1, 1))

Response

{1:2}

Tuple 사용

Query

SELECT mapAdd(([toUInt8(1), 2], [1, 1]), ([toUInt8(1), 2], [1, 1]))

Response

([1, 2], [2, 2])

mapAll

도입 버전: v23.4.0 맵의 모든 key-value 쌍에 대해 조건이 성립하는지 확인합니다. mapAll은 고차 함수입니다. 첫 번째 인수로 람다 함수를 전달할 수 있습니다. 구문

mapAll([func,] map)

인수

func — 람다 함수. 람다 함수
map — 검사할 맵. Map(K, V)

반환 값 모든 key-value 쌍이 조건을 만족하면 1을 반환하고, 그렇지 않으면 0을 반환합니다. UInt8 예시 사용 예시

Query

SELECT mapAll((k, v) -> v = 1, map('k1', 1, 'k2', 2))

Response

mapApply

도입 버전: v22.3.0 맵의 각 요소에 함수를 적용합니다. 구문

mapApply(func, map)

인수

func — 람다 함수. 람다 함수
map — 함수를 적용할 대상 맵. Map(K, V)

반환 값 원본 맵의 각 요소에 func를 적용해 얻은 새로운 맵을 반환합니다. Map(K, V) 예시 사용 예시

Query

SELECT mapApply((k, v) -> (k, v * 2), map('k1', 1, 'k2', 2))

Response

{'k1':2,'k2':4}

mapConcat

도입된 버전: v23.4.0 여러 맵을 키의 동일 여부를 기준으로 이어 붙입니다. 동일한 키를 가진 요소가 둘 이상의 입력 맵에 있으면 모든 요소가 결과 맵에 추가되지만, [] 연산자로는 첫 번째 요소에만 접근할 수 있습니다. 구문

mapConcat(maps)

인수

maps — 개수에 제한 없이 여러 개의 맵. Map

반환 값 인수로 전달된 맵들을 이어 붙인 맵을 반환합니다. Map 예시 사용 예시

Query

SELECT mapConcat(map('k1', 'v1'), map('k2', 'v2'))

Response

{'k1':'v1','k2':'v2'}

mapContainsKey

도입 버전: v21.2.0 맵에 키가 포함되어 있는지 확인합니다. 구문

mapContainsKey(map, key)

별칭: mapContains 인수

map — 검색할 맵입니다. Map(K, V)
key — 찾을 키입니다. 타입은 맵의 키 타입과 일치해야 합니다. Any

반환 값 맵에 키가 있으면 1, 없으면 0을 반환합니다. UInt8 예시 사용 예시

Query

SELECT mapContainsKey(map('k1', 'v1', 'k2', 'v2'), 'k1')

Response

mapContainsKeyLike

도입 버전: v23.4.0 맵에 LIKE로 지정된 패턴과 일치하는 키가 포함되어 있는지 확인합니다. 구문

mapContainsKeyLike(map, pattern)

인수

map — 검색할 맵입니다. Map(K, V)
pattern — 키와 일치하는지 확인할 패턴입니다. const String

반환 값 map에 pattern과 일치하는 키가 있으면 1, 없으면 0을 반환합니다. UInt8 예시 사용 예시

Query

CREATE TABLE tab (a Map(String, String))
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});

SELECT mapContainsKeyLike(a, 'a%') FROM tab;

Response

┌─mapContainsKeyLike(a, 'a%')─┐
│                           1 │
│                           0 │
└─────────────────────────────┘

mapContainsValue

도입 버전: v25.6.0 맵에 값이 포함되어 있는지 판별합니다. 구문

mapContainsValue(map, value)

인수

map — 검색할 맵입니다. Map(K, V)
value — 검색할 값입니다. 타입은 맵의 값 타입과 일치해야 합니다. Any

반환 값 맵에 해당 값이 포함되어 있으면 1을, 없으면 0을 반환합니다. UInt8 예시 사용 예시

Query

SELECT mapContainsValue(map('k1', 'v1', 'k2', 'v2'), 'v1')

Response

mapContainsValueLike

도입된 버전: v25.5.0 맵에 지정된 패턴과 LIKE로 일치하는 값이 포함되어 있는지 확인합니다. 구문

mapContainsValueLike(map, pattern)

인수

map — 검색할 맵입니다. Map(K, V)
pattern — 값과 매칭할 패턴입니다. const String

반환 값 map에 pattern과 일치하는 값이 포함되어 있으면 1을, 그렇지 않으면 0을 반환합니다. UInt8 예시 사용 예시

Query

CREATE TABLE tab (a Map(String, String))
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});

SELECT mapContainsValueLike(a, 'a%') FROM tab;

Response

┌─mapContainsV⋯ke(a, 'a%')─┐
│                        1 │
│                        0 │
└──────────────────────────┘

mapExists

도입 버전: v23.4.0 맵에서 하나 이상의 키-값 쌍이 조건을 만족하는지 확인합니다. mapExists는 고차 함수입니다. 첫 번째 인수로 람다 함수를 전달할 수 있습니다. 구문

mapExists([func,] map)

인수

func — 선택 사항입니다. 람다 함수입니다. 람다 함수
map — 검사할 맵입니다. Map(K, V)

반환 값 하나 이상의 키-값 쌍이 조건을 만족하면 1을 반환하고, 그렇지 않으면 0을 반환합니다. UInt8 예시 사용 예시

Query

SELECT mapExists((k, v) -> v = 1, map('k1', 1, 'k2', 2))

Response

mapExtractKeyLike

도입 버전: v23.4.0 문자열 키를 가진 맵과 LIKE 패턴이 주어지면, 키가 해당 패턴과 일치하는 요소만 포함된 맵을 반환합니다. 구문

mapExtractKeyLike(map, pattern)

인수

map — 값을 추출할 대상 맵입니다. Map(K, V)
pattern — 키와 일치 여부를 비교할 패턴입니다. const String

반환 값 지정된 패턴과 일치하는 키를 가진 요소를 포함하는 맵을 반환합니다. 패턴과 일치하는 요소가 없으면 빈 맵이 반환됩니다. Map(K, V) 예시 사용 예시

Query

CREATE TABLE tab (a Map(String, String))
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});

SELECT mapExtractKeyLike(a, 'a%') FROM tab;

Response

┌─mapExtractKeyLike(a, 'a%')─┐
│ {'abc':'abc'}              │
│ {}                         │
└────────────────────────────┘

mapExtractValueLike

도입 버전: v25.5.0 문자열 값을 가진 맵과 LIKE 패턴이 주어지면, 이 함수는 값이 해당 패턴과 일치하는 요소만 포함한 맵을 반환합니다. 구문

mapExtractValueLike(map, pattern)

인수

map — 추출할 대상 맵입니다. Map(K, V)
pattern — 값이 일치하는지 확인할 패턴입니다. const String

반환 값 값이 지정된 패턴과 일치하는 요소를 포함한 맵을 반환합니다. 패턴과 일치하는 요소가 없으면 빈 맵이 반환됩니다. Map(K, V) 예시 사용 예시

Query

CREATE TABLE tab (a Map(String, String))
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});

SELECT mapExtractValueLike(a, 'a%') FROM tab;

Response

┌─mapExtractValueLike(a, 'a%')─┐
│ {'abc':'abc'}                │
│ {}                           │
└──────────────────────────────┘

mapFilter

도입 버전: v22.3.0 맵의 각 요소에 함수를 적용해 필터링합니다. 구문

mapFilter(func, map)

인수

func — 람다 함수. 람다 함수
map — 필터링할 맵. Map(K, V)

반환 값 func가 0이 아닌 값을 반환한 요소만 포함하는 맵을 반환합니다. Map(K, V) 예시 사용 예시

Query

SELECT mapFilter((k, v) -> v > 1, map('k1', 1, 'k2', 2))

Response

{'k2':2}

mapFromArrays

도입 버전: v23.3.0 키 배열 또는 키 맵과 값 배열 또는 값 맵으로부터 맵을 생성합니다. 이 함수는 CAST([...], 'Map(key_type, value_type)') 구문의 편리한 대안입니다. 구문

mapFromArrays(keys, values)

별칭: MAP_FROM_ARRAYS 인수

keys — 맵을 생성하는 데 사용할 키 배열 또는 맵입니다. Array 또는 Map
values — 맵을 생성하는 데 사용할 값 배열 또는 맵입니다. Array 또는 Map

반환 값 키 배열과 값 배열/맵으로 구성된 키와 값을 포함하는 맵을 반환합니다. Map 예시 기본 사용법

Query

SELECT mapFromArrays(['a', 'b', 'c'], [1, 2, 3])

Response

{'a':1,'b':2,'c':3}

맵 입력을 사용할 때

Query

SELECT mapFromArrays([1, 2, 3], map('a', 1, 'b', 2, 'c', 3))

Response

{1:('a', 1), 2:('b', 2), 3:('c', 3)}

mapKeys

도입 버전: v21.2.0 주어진 맵의 키를 반환합니다. 이 함수는 설정 optimize_functions_to_subcolumns을 활성화하면 최적화됩니다. 이 설정이 활성화되면 전체 맵 대신 keys 서브컬럼만 읽습니다. 쿼리 SELECT mapKeys(m) FROM table는 SELECT m.keys FROM table로 변환됩니다. 구문

mapKeys(map)

인수

map — 키를 추출할 맵입니다. Map(K, V)

반환 값 맵의 모든 키가 포함된 배열을 반환합니다. Array(T) 예시 사용 예시

Query

SELECT mapKeys(map('k1', 'v1', 'k2', 'v2'))

Response

['k1','k2']

mapPartialReverseSort

도입 버전: v23.4.0 맵의 요소를 내림차순으로 정렬하며, 추가된 limit 인수를 사용해 부분 정렬도 수행할 수 있습니다. func 함수가 지정되면 정렬 순서는 맵의 키와 값에 func 함수를 적용한 결과로 결정됩니다. 구문

mapPartialReverseSort([func,] limit, map)

인수

func — 선택 사항입니다. 람다 함수입니다. 람다 함수
limit — [1..limit] 범위의 요소를 정렬합니다. (U)Int*
map — 정렬할 맵입니다. Map(K, V)

반환 값 부분적으로 내림차순 정렬된 맵을 반환합니다. Map(K, V) 예시 사용 예시

Query

SELECT mapPartialReverseSort((k, v) -> v, 2, map('k1', 3, 'k2', 1, 'k3', 2))

Response

{'k1':3,'k3':2,'k2':1}

mapPartialSort

도입 버전: v23.4.0 맵의 요소를 오름차순으로 정렬하며, 추가된 limit 인수를 사용해 부분 정렬도 수행할 수 있습니다. func 함수가 지정되면 정렬 순서는 맵의 키와 값에 func 함수를 적용한 결과로 결정됩니다. 구문

mapPartialSort([func,] limit, map)

인수

func — 선택 사항입니다. 람다 함수입니다. 람다 함수
limit — [1..limit] 범위의 요소를 정렬합니다. (U)Int*
map — 정렬할 맵입니다. Map(K, V)

반환 값 부분 정렬된 맵을 반환합니다. Map(K, V) 예시 사용 예시

Query

SELECT mapPartialSort((k, v) -> v, 2, map('k1', 3, 'k2', 1, 'k3', 2))

Response

{'k2':1,'k3':2,'k1':3}

mapPopulateSeries

도입 버전: v20.10.0 정수 키를 사용하는 맵에서 누락된 key-value 쌍을 채웁니다. 가장 큰 값을 넘어 키를 확장할 수 있도록 최대 키를 지정할 수 있습니다. 보다 구체적으로, 이 함수는 키가 가장 작은 키부터 가장 큰 키(또는 지정된 경우 max 인수)까지 1의 간격으로 이어지고, 이에 대응하는 값을 포함하는 맵을 반환합니다. 키에 값이 지정되지 않으면 기본값이 사용됩니다. 키가 중복되면 등장 순서상 첫 번째 값만 해당 키에 연결됩니다. 구문

mapPopulateSeries(map[, max]) | mapPopulateSeries(keys, values[, max])

인수

map — 정수 키를 갖는 맵입니다. Map((U)Int*, V)
keys — 키 배열입니다. Array(T)
values — 값 배열입니다. Array(T)
max — 선택 사항입니다. 키의 최댓값입니다. Int8 또는 Int16 또는 Int32 또는 Int64 또는 Int128 또는 Int256

반환 값 맵 또는 2개의 배열로 이루어진 튜플을 반환합니다. 첫 번째 배열에는 정렬된 순서의 키가 들어 있고, 두 번째 배열에는 각 키에 대응하는 값이 들어 있습니다. Map(K, V) 또는 Tuple(Array(UInt*), Array(Any)) 예시 맵(Map) 타입 사용

Query

SELECT mapPopulateSeries(map(1, 10, 5, 20), 6)

Response

{1:10, 2:0, 3:0, 4:0, 5:20, 6:0}

매핑된 배열 사용

Query

SELECT mapPopulateSeries([1, 2, 4], [11, 22, 44], 5)

Response

([1, 2, 3, 4, 5], [11, 22, 0, 44, 0])

mapReverseSort

출시 버전: v23.4.0 맵의 요소를 내림차순으로 정렬합니다. func 함수를 지정하면 정렬 순서는 맵의 키와 값에 func 함수를 적용한 결과로 결정됩니다. 구문

mapReverseSort([func,] map)

인수

func — 선택 사항입니다. 람다 함수입니다. 람다 함수
map — 정렬할 맵입니다. Map(K, V)

반환 값 내림차순으로 정렬된 맵을 반환합니다. Map(K, V) 예시 사용 예시

Query

SELECT mapReverseSort((k, v) -> v, map('k1', 3, 'k2', 1, 'k3', 2))

Response

{'k1':3,'k3':2,'k2':1}

mapSort

도입 버전: v23.4.0 맵의 요소를 오름차순으로 정렬합니다. func 함수가 지정되면, 정렬 순서는 맵의 키와 값에 func 함수를 적용한 결과로 결정됩니다. 구문

mapSort([func,] map)

인수

func — 선택 사항. 람다 함수. 람다 함수
map — 정렬할 맵. Map(K, V)

반환 값 오름차순으로 정렬된 맵을 반환합니다. Map(K, V) 예시 사용 예시

Query

SELECT mapSort((k, v) -> v, map('k1', 3, 'k2', 1, 'k3', 2))

Response

{'k2':1,'k3':2,'k1':3}

mapSubtract

도입 버전: v20.7.0 모든 키를 모아 해당 값을 뺍니다. 구문

mapSubtract(arg1[, arg2, ...])

인수

arg1[, arg2, ...] — 첫 번째 배열의 항목이 키를 나타내고, 두 번째 배열에 각 키의 값이 들어 있는 맵 또는 두 개의 배열로 이루어진 튜플입니다. Map(K, V) 또는 Tuple(Array(T), Array(T))

반환 값 첫 번째 배열에는 정렬된 키가, 두 번째 배열에는 값이 들어 있는 맵 또는 튜플 하나를 반환합니다. Map(K, V) 또는 Tuple(Array(T), Array(T)) 예시 맵(Map) 타입 사용 시

Query

SELECT mapSubtract(map(1, 1), map(1, 1))

Response

{1:0}

Tuple 맵과 함께 사용

Query

SELECT mapSubtract(([toUInt8(1), 2], [toInt32(1), 1]), ([toUInt8(1), 2], [toInt32(2), 1]))

Response

([1, 2], [-1, 0])

mapUpdate

도입 버전: v22.3.0 두 개의 맵이 주어지면, 두 번째 맵의 해당 키 값을 반영해 첫 번째 맵의 값을 업데이트한 맵을 반환합니다. 구문

mapUpdate(map1, map2)

인수

map1 — 업데이트할 맵. Map(K, V)
map2 — 업데이트에 사용할 맵. Map(K, V)

반환 값 map2의 해당 키에 대응하는 값으로 업데이트된 map1을 반환합니다. Map(K, V) 예시 기본 사용법

Query

SELECT mapUpdate(map('key1', 0, 'key3', 0), map('key1', 10, 'key2', 10))

Response

{'key3':0,'key1':10,'key2':10}

mapValues

도입 버전: v21.2.0 주어진 맵의 값을 반환합니다. 이 함수는 optimize_functions_to_subcolumns 설정을 활성화하면 최적화할 수 있습니다. 이 설정을 활성화하면 함수는 전체 맵 대신 values 서브컬럼만 읽습니다. 쿼리 SELECT mapValues(m) FROM table는 SELECT m.values FROM table로 변환됩니다. 구문

mapValues(map)

인수

map — 값을 추출할 대상 맵입니다. Map(K, V)

반환 값 맵의 모든 값을 포함하는 배열을 반환합니다. Array(T) 예시 사용 예시

Query

SELECT mapValues(map('k1', 'v1', 'k2', 'v2'))

Response

['v1','v2']

​extractKeyValuePairs

​extractKeyValuePairsWithEscaping

​map

​mapAdd

​mapAll

​mapApply

​mapConcat

​mapContainsKey

​mapContainsKeyLike

​mapContainsValue

​mapContainsValueLike

​mapExists

​mapExtractKeyLike

​mapExtractValueLike

​mapFilter

​mapFromArrays

​mapKeys

​mapPartialReverseSort

​mapPartialSort

​mapPopulateSeries

​mapReverseSort

​mapSort

​mapSubtract

​mapUpdate

​mapValues

extractKeyValuePairs

extractKeyValuePairsWithEscaping

map

mapAdd

mapAll

mapApply

mapConcat

mapContainsKey

mapContainsKeyLike

mapContainsValue

mapContainsValueLike

mapExists

mapExtractKeyLike

mapExtractValueLike

mapFilter

mapFromArrays

mapKeys

mapPartialReverseSort

mapPartialSort

mapPopulateSeries

mapReverseSort

mapSort

mapSubtract

mapUpdate

mapValues