Funciones de mapa

extractKeyValuePairs

Introducido en: v23.4.0 Extrae pares clave-valor de cualquier cadena. La cadena no necesita estar estructurada al 100% en formato de par clave-valor; Puede contener ruido (p. ej., archivos de log). El formato de par clave-valor que se desea interpretar debe especificarse mediante los argumentos de la función. Un par clave-valor consiste en una clave seguida de un key_value_delimiter y un valor. También se admiten claves y valores entre comillas. Los pares clave-valor deben separarse mediante delimitadores de par. Sintaxis

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

Argumentos

data - Cadena de la que se extraen pares clave-valor. String o FixedString.
key_value_delimiter - Carácter que se usará como delimitador entre la clave y el valor. El valor predeterminado es :. String o FixedString.
pair_delimiters - Conjunto de caracteres que se usarán como delimitadores entre pares. El valor predeterminado es \space, , y ;. String o FixedString.
quoting_character - Carácter que se usará como carácter de cita. El valor predeterminado es ". String o FixedString.
unexpected_quoting_character_strategy - Estrategia para manejar caracteres de cita en ubicaciones inesperadas durante la fase de read_key y read_value. Valores posibles: invalid, accept y promote. invalid descartará la clave o el valor y volverá al estado WAITING_KEY. accept lo tratará como un carácter normal. promote cambiará al estado READ_QUOTED_{KEY/VALUE} y comenzará desde el siguiente carácter. El valor predeterminado es PROMOTE

Valores devueltos

Los pares clave-valor extraídos en formato Map(String, String).

Ejemplos Consulta: Caso simple

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

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

Comilla simple como carácter de cita

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'}                                 │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

Ejemplos de 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'}  │
└──────────────┘

Secuencias de escape sin soporte para secuencias de escape

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

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

Sintaxis

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

Alias: mapFromString, str_to_map Argumentos

Ninguno.

Valor devuelto Ejemplos

extractKeyValuePairsWithEscaping

Introducido en: v23.4.0 Igual que extractKeyValuePairs, pero con soporte para secuencias de escape. Secuencias de escape admitidas: \x, \N, \a, \b, \e, \f, \n, \r, \t, \v y \0. Las secuencias de escape no estándar se devuelven tal cual (incluida la barra invertida), a menos que sean una de las siguientes: \\, ', ", backtick, /, = o caracteres de control ASCII (c <= 31). Esta función cubre los casos en los que el escape previo y el escape posterior no resultan adecuados. Por ejemplo, considere la siguiente cadena de entrada: a: "aaaa\"bbb". La salida esperada es: a: aaaa\"bbbb.

Escape previo: al aplicarlo, la salida será: a: "aaaa"bbb" y luego extractKeyValuePairs devolverá: a: aaaa
Escape posterior: extractKeyValuePairs devolverá a: aaaa\ y el escape posterior lo conservará tal cual.

Las secuencias de escape iniciales se omitirán en las claves y se considerarán no válidas en los valores. Secuencias de escape con el soporte para secuencias de escape activado

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

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

Sintaxis

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

Argumentos

Ninguno.

Valor devuelto Ejemplos

map

Introducido en: v21.1.0 Crea un valor de tipo Map(key, value) a partir de pares clave-valor. Sintaxis

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

Argumentos

key_n — Las claves de las entradas del mapa. Any
value_n — Los valores de las entradas del mapa. Any

Valor devuelto Devuelve un mapa que contiene pares clave-valor. Map(Any, Any) Ejemplos Ejemplo de uso

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

Introducido en: v20.7.0 Recopila todas las claves y suma los valores correspondientes. Sintaxis

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

Argumentos

arg1[, arg2, ...] — mapas o tuplas de dos arrays en los que los elementos del primer array representan claves y el segundo array contiene los valores de cada clave. Map(K, V) o Tuple(Array(T), Array(T))

Valor devuelto Devuelve un mapa o una tupla, donde el primer array contiene las claves ordenadas y el segundo array contiene los valores. Map(K, V) o Tuple(Array(T), Array(T)) Ejemplos Con el tipo Map

Query

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

Response

{1:2}

Con tupla

Query

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

Response

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

mapAll

Introducido en: v23.4.0 Comprueba si una condición se cumple para todos los pares clave-valor de un mapa. mapAll es una función de orden superior. Puede recibir una función lambda como primer argumento. Sintaxis

mapAll([func,] map)

Argumentos

func — Función lambda. Función lambda
map — mapa que se debe comprobar. Map(K, V)

Valor devuelto Devuelve 1 si todos los pares clave-valor cumplen la condición; en caso contrario, 0. UInt8 Ejemplos Ejemplo de uso

Query

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

Response

mapApply

Introducido en: v22.3.0 Aplica una función a cada elemento de un mapa. Sintaxis

mapApply(func, map)

Argumentos

func — Función lambda. Función lambda
map — mapa al que se aplica la función. Map(K, V)

Valor devuelto Devuelve un nuevo mapa obtenido del mapa original al aplicar func a cada elemento. Map(K, V) Ejemplos Ejemplo de uso

Query

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

Response

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

mapConcat

Introducido en: v23.4.0 Concatena varios mapas según la igualdad de sus claves. Si hay elementos con la misma clave en más de un mapa de entrada, todos los elementos se añaden al mapa resultante, pero solo se puede acceder al primero mediante el operador []. Sintaxis

mapConcat(maps)

Argumentos

maps — Una cantidad arbitraria de mapas. Map

Valor devuelto Devuelve un mapa con los mapas concatenados que se pasan como argumentos. Map Ejemplos Ejemplo de uso

Query

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

Response

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

mapContainsKey

Introducido en: v21.2.0 Determina si un mapa contiene una clave. Sintaxis

mapContainsKey(map, key)

Alias: mapContains Argumentos

map — Mapa en el que se va a buscar. Map(K, V)
key — Clave que se va a buscar. El tipo debe coincidir con el tipo de clave del mapa. Any

Valor devuelto Devuelve 1 si el mapa contiene la clave y 0 en caso contrario. UInt8 Ejemplos Ejemplo de uso

Query

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

Response

mapContainsKeyLike

Introducido en: v23.4.0 Comprueba si el mapa contiene una clave que coincida con el patrón LIKE especificado. Sintaxis

mapContainsKeyLike(map, pattern)

Argumentos

map — Mapa en el que buscar. Map(K, V)
pattern — Patrón con el que se comparan las claves. const String

Valor devuelto Devuelve 1 si map contiene una clave que coincide con pattern; en caso contrario, 0. UInt8 Ejemplos Ejemplo de uso

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 │
└─────────────────────────────┘

mapContainsKeyValue

Introducida en: v26.9.0 Indica si el mapa contiene una entrada con la clave y el valor indicados. Cuando los argumentos no son NULL, equivale a arrayExists((k, v) -> k = key AND v = value, mapKeys(map), mapValues(map)). Un NULL solo coincide con otro NULL, como en mapContainsKey y mapContainsValue, en lugar de producir un resultado desconocido al compararlos, como ocurre con =. Se tienen en cuenta todas las entradas, a diferencia de map[key] = value, que solo compara el valor de la primera aparición de key. Un índice de texto con el tokenizador keyValuePairs permite resolver esta función mediante el índice. Sintaxis

mapContainsKeyValue(map, key, value)

Argumentos

map — El mapa en el que se realiza la búsqueda. Map(K, V)
key — La clave que se busca. Su tipo debe coincidir con el de las claves del mapa. Any
value — El valor que se busca. Su tipo debe coincidir con el de los valores del mapa. Any

Valor devuelto Devuelve 1 si el mapa contiene una entrada con la clave y el valor indicados; de lo contrario, devuelve 0. UInt8 Ejemplos Uso básico

Query

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

Response

Clave y valor de distintas entradas

Query

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

Response

Clave duplicada

Query

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

Response

1	0

mapContainsValue

Introducido en: v25.6.0 Determina si un mapa contiene un valor. Sintaxis

mapContainsValue(map, value)

Argumentos

map — Mapa en el que buscar. Map(K, V)
value — Valor que se va a buscar. El tipo debe coincidir con el tipo de valor de map. Any

Valor devuelto Devuelve 1 si map contiene el valor, 0 si no. UInt8 Ejemplos Ejemplo de uso

Query

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

Response

mapContainsValueLike

Introducido en: v25.5.0 Comprueba si un mapa contiene un valor que coincide con el patrón especificado mediante LIKE. Sintaxis

mapContainsValueLike(map, pattern)

Argumentos

map — Mapa donde buscar. Map(K, V)
pattern — Patrón con el que comparar los valores. const String

Valor devuelto Devuelve 1 si map contiene un valor que coincide con pattern; de lo contrario, 0. UInt8 Ejemplos Ejemplo de uso

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

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

mapEntries

Introducido en: v26.10.0 Devuelve los pares clave-valor de un mapa como un array de tuplas con nombre, con los campos key y value. Se conservan las claves duplicadas. Sintaxis

mapEntries(map)

Argumentos

map — Mapa del que se extraen las entradas. Map(K, V)

Valor devuelto Devuelve un array con los pares clave-valor del mapa. Array(Tuple(key K, value V)) Ejemplos Ejemplo de uso

Query

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

Response

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

mapExists

Introducido en: v23.4.0 Comprueba si se cumple una condición para al menos un par clave-valor de un mapa. mapExists es una función de orden superior. Puede pasar una función lambda como primer argumento. Sintaxis

mapExists([func,] map)

Argumentos

func — Opcional. Función lambda. Función lambda
map — Mapa que se va a comprobar. Map(K, V)

Valor devuelto Devuelve 1 si al menos un par clave-valor cumple la condición; 0 en caso contrario. UInt8 Ejemplos Ejemplo de uso

Query

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

Response

mapExtractKeyLike

Introducido en: v23.4.0 Dado un mapa con claves de tipo cadena y un patrón LIKE, esta función devuelve un mapa con los elementos cuya clave coincide con el patrón. Sintaxis

mapExtractKeyLike(map, pattern)

Argumentos

map — Mapa del que extraer. Map(K, V)
pattern — Patrón con el que comparar las claves. const String

Valor devuelto Devuelve un mapa que contiene los elementos cuya clave coincide con el patrón especificado. Si ningún elemento coincide con el patrón, se devuelve un mapa vacío. Map(K, V) Ejemplos Ejemplo de uso

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

Introducido en: v25.5.0 Dado un mapa con valores de tipo cadena y un patrón LIKE, esta función devuelve un mapa con los elementos cuyo valor coincide con el patrón. Sintaxis

mapExtractValueLike(map, pattern)

Argumentos

map — Mapa del que se extrae. Map(K, V)
pattern — Patrón con el que comparar los valores. const String

Valor devuelto Devuelve un mapa que contiene los elementos cuyo valor coincide con el patrón especificado. Si ningún elemento coincide con el patrón, se devuelve un mapa vacío. Map(K, V) Ejemplos Ejemplo de uso

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

Introducido en: v22.3.0 Filtra un mapa aplicando una función a cada elemento del mapa. Sintaxis

mapFilter(func, map)

Argumentos

func — Función lambda. Función lambda
map — Mapa que se va a filtrar. Map(K, V)

Valor devuelto Devuelve un mapa que contiene solo los elementos para los que func devuelve un valor distinto de 0. Map(K, V) Ejemplos Ejemplo de uso

Query

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

Response

{'k2':2}

mapFromArrays

Introducido en: v23.3.0 Crea un mapa a partir de un array o un mapa de claves y de un array o un mapa de valores. La función es una alternativa práctica a la sintaxis CAST([...], 'Map(key_type, value_type)'). Sintaxis

mapFromArrays(keys, values)

Alias: MAP_FROM_ARRAYS Argumentos

keys — Array o mapa de claves a partir del cual se crea el mapa. Array o Map
values — Array o mapa de valores a partir del cual se crea el mapa. Array o Map

Valor devuelto Devuelve un mapa con claves y valores construidos a partir del array de claves y del array o mapa de valores. Map Ejemplos Uso básico

Query

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

Response

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

Con entradas de tipo Map

Query

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

Response

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

mapKeys

Introducido en: v21.2.0 Devuelve las claves de un mapa. Esta función puede optimizarse al habilitar el SETTING optimize_functions_to_subcolumns. Con este SETTING habilitado, la función solo lee la subcolumna keys en lugar del mapa completo. La consulta SELECT mapKeys(m) FROM table se transforma en SELECT m.keys FROM table. Sintaxis

mapKeys(map)

Argumentos

map — Mapa del que extraer las claves. Map(K, V)

Valor devuelto Devuelve un array con todas las claves del mapa. Array(T) Ejemplos Ejemplo de uso

Query

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

Response

['k1','k2']

mapPartialReverseSort

Introducido en: v23.4.0 Ordena los elementos de un mapa en orden descendente con un argumento de límite adicional que permite una ordenación parcial. Si se especifica la función func, el orden de clasificación viene determinado por el resultado de la función func aplicada a las claves y los valores del mapa. Sintaxis

mapPartialReverseSort([func,] limit, map)

Argumentos

func — Opcional. Función lambda. Función lambda
limit — Se ordenan los elementos del intervalo [1..limit]. (U)Int*
map — Mapa que se va a ordenar. Map(K, V)

Valor devuelto Devuelve un mapa parcialmente ordenado en orden descendente. Map(K, V) Ejemplos Ejemplo de uso

Query

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

Response

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

mapPartialSort

Introducido en: v23.4.0 Ordena los elementos de un mapa en orden ascendente con un argumento adicional de límite que permite una ordenación parcial. Si se especifica la función func, el orden se determina por el resultado de la función func aplicada a las claves y los valores del mapa. Sintaxis

mapPartialSort([func,] limit, map)

Argumentos

func — Opcional. Función lambda. Función lambda
limit — Se ordenan los elementos del rango [1..limit]. (U)Int*
map — mapa que se ordenará. Map(K, V)

Valor devuelto Devuelve un mapa parcialmente ordenado. Map(K, V) Ejemplos Ejemplo de uso

Query

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

Response

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

mapPopulateSeries

Introducido en: v20.10.0 Completa los pares clave-valor que faltan en un mapa con claves enteras. Para poder extender las claves más allá del valor máximo, se puede especificar una clave máxima. Más concretamente, la función devuelve un mapa en el que las claves forman una serie desde la clave más pequeña hasta la más grande (o el argumento max, si se especifica), con un paso de 1 y sus valores correspondientes. Si no se especifica ningún valor para una clave, se usa un valor predeterminado. Si las claves se repiten, solo el primer valor (en orden de aparición) se asocia a la clave. Sintaxis

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

Argumentos

map — mapa con claves de tipo entero. Map((U)Int*, V)
keys — Array de claves. Array(T)
values — Array de valores. Array(T)
max — Opcional. Valor máximo de la clave. Int8 o Int16 o Int32 o Int64 o Int128 o Int256

Valor devuelto Devuelve un mapa o una Tuple de dos arrays, donde el primero contiene las claves en orden y el segundo los valores correspondientes a esas claves. Map(K, V) o Tuple(Array(UInt*), Array(Any)) Ejemplos Con tipo Map

Query

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

Response

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

Con arrays asignados

Query

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

Response

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

mapRemove

Introducido en: v26.10.0 Elimina de un mapa todas las entradas cuya clave sea igual a la clave especificada. Si varias entradas tienen la misma clave, se eliminan todas las entradas coincidentes. Los valores NULL se comparan como valores: una clave de eliminación NULL no coincide con una clave que no sea NULL, y los componentes NULL de las claves compuestas coinciden con otros componentes NULL. Para tipos de clave con un supertipo común, las claves NaN siguen la semántica de búsqueda en mapas, por lo que una clave de eliminación NaN coincide con una clave NaN del mapa. Sintaxis

mapRemove(map, key)

Argumentos

map — Mapa del que se eliminarán las entradas coincidentes. Map(K, V)
key — Clave cuyas entradas coincidentes se eliminarán. El tipo debe ser comparable con el tipo de clave del mapa. Any

Valor devuelto Devuelve el mapa con todas las entradas cuya clave no coincide con la clave especificada. Map(K, V) Ejemplos Ejemplo de uso

Query

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

Response

{'k2':2}

mapReverseSort

Introducido en: v23.4.0 Ordena los elementos de un mapa en orden descendente. Si se especifica la función func, el orden se determina por el resultado de aplicar la función func a las claves y los valores del mapa. Sintaxis

mapReverseSort([func,] map)

Argumentos

func — Opcional. Función lambda. Función lambda
map — Mapa que se va a ordenar. Map(K, V)

Valor devuelto Devuelve un mapa ordenado de forma descendente. Map(K, V) Ejemplos Ejemplo de uso

Query

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

Response

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

mapSort

Introducido en: v23.4.0 Ordena los elementos de un mapa en orden ascendente. Si se especifica la función func, el orden de clasificación se determina a partir del resultado de aplicar la función func a las claves y los valores del mapa. Sintaxis

mapSort([func,] map)

Argumentos

func — Opcional. Función lambda. Función lambda
map — Mapa que se va a ordenar. Map(K, V)

Valor devuelto Devuelve un mapa ordenado en orden ascendente. Map(K, V) Ejemplos Ejemplo de uso

Query

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

Response

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

mapSubtract

Introducido en: v20.7.0 Reúne todas las claves y resta los valores correspondientes. Sintaxis

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

Argumentos

arg1[, arg2, ...] — Valores de tipo mapa o tuplas de dos arrays, en los que los elementos del primer array representan claves y el segundo array contiene los valores correspondientes a cada clave. Map(K, V) o Tuple(Array(T), Array(T))

Valor devuelto Devuelve un valor de tipo mapa o una tupla, donde el primer array contiene las claves ordenadas y el segundo array contiene los valores. Map(K, V) o Tuple(Array(T), Array(T)) Ejemplos Con el tipo Map

Query

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

Response

{1:0}

Con mapa de tuplas

Query

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

Response

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

mapUpdate

Introducido en: v22.3.0 Dados dos mapas, devuelve el primero con los valores actualizados a partir de los valores de las claves correspondientes del segundo mapa. Sintaxis

mapUpdate(map1, map2)

Argumentos

map1 — El mapa que se actualizará. Map(K, V)
map2 — El mapa que se utilizará para la actualización. Map(K, V)

Valor devuelto Devuelve map1 con los valores actualizados según los valores de las claves correspondientes en map2. Map(K, V) Ejemplos Uso básico

Query

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

Response

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

mapValues

Introducida en: v21.2.0 Devuelve los valores de un mapa dado. Esta función se puede optimizar al habilitar la SETTING optimize_functions_to_subcolumns. Con esta SETTING habilitada, la función solo lee la subcolumna values en lugar del mapa completo. La consulta SELECT mapValues(m) FROM table se transforma en SELECT m.values FROM table. Sintaxis

mapValues(map)

Argumentos

map — Mapa del que extraer los valores. Map(K, V)

Valor devuelto Devuelve un array que contiene todos los valores del mapa. Array(T) Ejemplos Ejemplo de uso

Query

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

Response

['v1','v2']

Referencia de SQL

Tipos de datos

Motores

Funciones

Formatos

Configuración

Tablas del sistema

Lagos de datos

extractKeyValuePairs

extractKeyValuePairsWithEscaping

map

mapAdd

mapAll

mapApply

mapConcat

mapContainsKey

mapContainsKeyLike

mapContainsKeyValue

mapContainsValue

mapContainsValueLike

mapEntries

mapExists

mapExtractKeyLike

mapExtractValueLike

mapFilter

mapFromArrays

mapKeys

mapPartialReverseSort

mapPartialSort

mapPopulateSeries

mapRemove

mapReverseSort

mapSort

mapSubtract

mapUpdate

mapValues

​extractKeyValuePairs

​extractKeyValuePairsWithEscaping

​map

​mapAdd

​mapAll

​mapApply

​mapConcat

​mapContainsKey

​mapContainsKeyLike

​mapContainsKeyValue

​mapContainsValue

​mapContainsValueLike

​mapEntries

​mapExists

​mapExtractKeyLike

​mapExtractValueLike

​mapFilter

​mapFromArrays

​mapKeys

​mapPartialReverseSort

​mapPartialSort

​mapPopulateSeries

​mapRemove

​mapReverseSort

​mapSort

​mapSubtract

​mapUpdate

​mapValues

extractKeyValuePairs

extractKeyValuePairsWithEscaping

map

mapAdd

mapAll

mapApply

mapConcat

mapContainsKey

mapContainsKeyLike

mapContainsKeyValue

mapContainsValue

mapContainsValueLike

mapEntries

mapExists

mapExtractKeyLike

mapExtractValueLike

mapFilter

mapFromArrays

mapKeys

mapPartialReverseSort

mapPartialSort

mapPopulateSeries

mapRemove

mapReverseSort

mapSort

mapSubtract

mapUpdate

mapValues