Funções de map

​

extractKeyValuePairs

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

• data - String da qual serão extraídos pares chave-valor. String ou FixedString.
• key_value_delimiter - Caractere a ser usado como delimitador entre a chave e o valor. O padrão é :. String ou FixedString.
• pair_delimiters - Conjunto de caracteres a ser usado como delimitadores entre pares. O padrão é \space, , e ;. String ou FixedString.
• quoting_character - Caractere a ser usado para delimitar aspas. O padrão é ". String ou FixedString.
• unexpected_quoting_character_strategy - Estratégia para lidar com caracteres de aspas em posições inesperadas durante a fase read_key e read_value. Valores possíveis: invalid, accept e promote. invalid descartará a chave ou o valor e fará a transição de volta para o estado WAITING_KEY. accept o tratará como um caractere normal. promote fará a transição para o estado READ_QUOTED_{KEY/VALUE} e começará a partir do próximo caractere. O valor padrão é PROMOTE

• Os pares chave-valor extraídos em um Map(String, String).

SELECT extractKeyValuePairs('name:neymar, age:34 team:santos,nationality:brazil') AS kv;

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

SELECT extractKeyValuePairs('name:\'neymar\';\'age\':34;team:santos;nationality:brazil,last_key:last_value', ':', ';,', '\'') AS kv;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• Nenhum.

​

extractKeyValuePairsWithEscaping

• Pre-escaping: ao aplicar pre-escaping, a saída será: a: "aaaa"bbb" e extractKeyValuePairs então produzirá: a: aaaa
• Post-escaping: extractKeyValuePairs produzirá a: aaaa\ e o post-escaping o manterá como está.

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

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

extractKeyValuePairsWithEscaping(data, [key_value_delimiter], [pair_delimiter], [quoting_character], [unexpected_quoting_character_strategy])

• Nenhum.

​

map

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

• key_n — As chaves das entradas do map. Any
• value_n — Os valores das entradas do map. Any

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

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

​

mapAdd

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

• arg1[, arg2, ...] — maps ou tuplas de dois arrays, nos quais os itens do primeiro array representam chaves, e o segundo array contém os valores de cada chave. Map(K, V) ou Tuple(Array(T), Array(T))

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

{1:2}

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

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

​

mapAll

mapAll([func,] map)

• func — Função lambda. Função lambda
• map — map a ser verificado. Map(K, V)

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

0

​

mapApply

mapApply(func, map)

• func — Função lambda. Função lambda
• map — map ao qual a função será aplicada. Map(K, V)

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

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

​

mapConcat

mapConcat(maps)

• maps — Uma quantidade arbitrária de maps. Map

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

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

​

mapContainsKey

mapContainsKey(map, key)

• map — map em que pesquisar. Map(K, V)
• key — chave a ser pesquisada. O tipo deve corresponder ao tipo da chave do map. Any

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

1

​

mapContainsKeyLike

mapContainsKeyLike(map, pattern)

• map — map onde pesquisar. Map(K, V)
• pattern — Padrão para correspondência das chaves. const String

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;

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

​

mapContainsKeyValue

mapContainsKeyValue(map, key, value)

• map — O map em que a busca será feita. Map(K, V)
• key — A chave a ser buscada. Seu tipo deve corresponder ao tipo das chaves do map. Any
• value — O valor a ser buscado. Seu tipo deve corresponder ao tipo dos valores do map. Any

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

1

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

0

SELECT mapContainsKeyValue(map('k', 'v1', 'k', 'v2'), 'k', 'v2'), map('k', 'v1', 'k', 'v2')['k'] = 'v2'

1	0

​

mapContainsValue

mapContainsValue(map, value)

• map — map em que a busca será realizada. Map(K, V)
• value — Valor a ser buscado. O tipo deve corresponder ao tipo de valor do map. Any

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

1

​

mapContainsValueLike

mapContainsValueLike(map, pattern)

• map — map em que será feita a busca. Map(K, V)
• pattern — Padrão usado para corresponder aos valores. const String

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;

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

​

mapEntries

mapEntries(map)

• map — Map do qual as entradas serão extraídas. Map(K, V)

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

[('k1','v1'),('k2','v2')]

​

mapExists

mapExists([func,] map)

• func — Opcional. Função lambda. Função lambda
• map — map a ser verificado. Map(K, V)

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

1

​

mapExtractKeyLike

mapExtractKeyLike(map, pattern)

• map — map do qual extrair. Map(K, V)
• pattern — padrão com o qual comparar as chaves. const String

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;

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

​

mapExtractValueLike

mapExtractValueLike(map, pattern)

• map — Map do qual extrair. Map(K, V)
• pattern — Padrão com o qual os valores são comparados. const String

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;

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

​

mapFilter

mapFilter(func, map)

• func — Função lambda. Função lambda
• map — map a ser filtrado. Map(K, V)

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

{'k2':2}

​

mapFromArrays

mapFromArrays(keys, values)

• keys — Array ou map de chaves a partir do qual criar o map. Array ou Map
• values — Array ou map de valores a partir do qual criar o map. Array ou Map

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

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

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

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

​

mapKeys

mapKeys(map)

• map — map do qual as chaves serão extraídas. Map(K, V)

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

['k1','k2']

​

mapPartialReverseSort

mapPartialReverseSort([func,] limit, map)

• func — Opcional. Função lambda. Função lambda
• limit — Os elementos no intervalo [1..limit] são ordenados. (U)Int*
• map — map a ser ordenado. Map(K, V)

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

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

​

mapPartialSort

mapPartialSort([func,] limit, map)

• func — Opcional. Função lambda. Função lambda
• limit — Os elementos no intervalo [1..limit] são ordenados. (U)Int*
• map — map a ser ordenado. Map(K, V)

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

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

​

mapPopulateSeries

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

• map — Map com chaves inteiras. Map((U)Int*, V)
• keys — Array de chaves. Array(T)
• values — Array de valores. Array(T)
• max — Opcional. Valor máximo da chave. Int8 ou Int16 ou Int32 ou Int64 ou Int128 ou Int256

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

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

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

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

​

mapRemove

mapRemove(map, key)

• map — Map do qual as entradas correspondentes serão removidas. Map(K, V)
• key — Chave cujas entradas correspondentes serão removidas. O tipo deve ser comparável ao tipo da chave do map. Any

SELECT mapRemove(map('k1', 1, 'k2', 2), 'k1')

{'k2':2}

​

mapReverseSort

mapReverseSort([func,] map)

• func — Opcional. Função lambda. Função lambda
• map — map a ser ordenado. Map(K, V)

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

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

​

mapSort

mapSort([func,] map)

• func — Opcional. Função lambda. Função lambda
• map — map a ser ordenado. Map(K, V)

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

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

​

mapSubtract

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

• arg1[, arg2, ...] — maps ou tuplas de dois arrays, em que os itens do primeiro array representam as chaves, e o segundo array contém os valores de cada chave. Map(K, V) ou Tuple(Array(T), Array(T))

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

{1:0}

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

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

​

mapUpdate

mapUpdate(map1, map2)

• map1 — O map a ser atualizado. Map(K, V)
• map2 — O map usado na atualização. Map(K, V)

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

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

​

mapValues

mapValues(map)

• map — Map de onde extrair os valores. Map(K, V)

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

['v1','v2']