> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentación de las funciones de Tuple y mapa
# Funciones de mapa
{/*AUTOGENERATED_START*/}
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 pares 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**
```sql theme={null}
extractKeyValuePairs(data, [key_value_delimiter], [pair_delimiter], [quoting_character])
```
**Argumentos**
* `data` - Cadena de la que se extraen pares de clave-valor. [String](/es/reference/data-types/string) o [FixedString](/es/reference/data-types/fixedstring).
* `key_value_delimiter` - Carácter que se usará como delimitador entre la clave y el valor. El valor predeterminado es `:`. [String](/es/reference/data-types/string) o [FixedString](/es/reference/data-types/fixedstring).
* `pair_delimiters` - Conjunto de caracteres que se usarán como delimitadores entre pares. El valor predeterminado es `\space`, `,` y `;`. [String](/es/reference/data-types/string) o [FixedString](/es/reference/data-types/fixedstring).
* `quoting_character` - Carácter que se usará para entrecomillar. El valor predeterminado es `"`. [String](/es/reference/data-types/string) o [FixedString](/es/reference/data-types/fixedstring).
* `unexpected_quoting_character_strategy` - Estrategia para manejar caracteres de comillas 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 `INVALID`
**Valores devueltos**
* Los pares clave-valor extraídos en formato Map(String, String).
**Ejemplos**
Consulta:
**Caso simple**
```sql theme={null}
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'} │
└─────────────────────────────────────────────────────────────────────────┘
```
**Comilla simple como carácter de cita**
```sql theme={null}
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'} │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
Ejemplos de unexpected\_quoting\_character\_strategy:
unexpected\_quoting\_character\_strategy=invalid
```sql theme={null}
SELECT extractKeyValuePairs('name"abc:5', ':', ' ,;', '\"', 'INVALID') as kv;
```
```text theme={null}
┌─kv────────────────┐
│ {'abc':'5'} │
└───────────────────┘
```
```sql theme={null}
SELECT extractKeyValuePairs('name"abc":5', ':', ' ,;', '\"', 'INVALID') as kv;
```
```text theme={null}
┌─kv──┐
│ {} │
└─────┘
```
unexpected\_quoting\_character\_strategy=accept
```sql theme={null}
SELECT extractKeyValuePairs('name"abc:5', ':', ' ,;', '\"', 'ACCEPT') as kv;
```
```text theme={null}
┌─kv────────────────┐
│ {'name"abc':'5'} │
└───────────────────┘
```
```sql theme={null}
SELECT extractKeyValuePairs('name"abc":5', ':', ' ,;', '\"', 'ACCEPT') as kv;
```
```text theme={null}
┌─kv─────────────────┐
│ {'name"abc"':'5'} │
└────────────────────┘
```
unexpected\_quoting\_character\_strategy=promote
```sql theme={null}
SELECT extractKeyValuePairs('name"abc:5', ':', ' ,;', '\"', 'PROMOTE') as kv;
```
```text theme={null}
┌─kv──┐
│ {} │
└─────┘
```
```sql theme={null}
SELECT extractKeyValuePairs('name"abc":5', ':', ' ,;', '\"', 'PROMOTE') as kv;
```
```text theme={null}
┌─kv───────────┐
│ {'abc':'5'} │
└──────────────┘
```
**Secuencias de escape sin soporte para secuencias de escape**
```sql theme={null}
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'} │
└───────────────────────┘
```
**Sintaxis**
```sql theme={null}
extractKeyValuePairs(input)
```
**Alias**: `str_to_map`, `mapFromString`
**Argumentos**
* Ninguno.
**Valor devuelto**
**Ejemplos**
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**
```sql theme={null}
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'} │
└──────────────────┘
```
**Sintaxis**
```sql theme={null}
extractKeyValuePairsWithEscaping(input)
```
**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**
```sql theme={null}
map(key1, value1[, key2, value2, ...])
```
**Argumentos**
* `key_n` — Las claves de las entradas del mapa. [`Any`](/es/reference/data-types)
* `value_n` — Los valores de las entradas del mapa. [`Any`](/es/reference/data-types)
**Valor devuelto**
Devuelve un mapa que contiene pares clave-valor. [`Map(Any, Any)`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT map('key1', number, 'key2', number * 2) FROM numbers(3)
```
```response title=Response theme={null}
{'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**
```sql theme={null}
mapAdd(arg1[, arg2, ...])
```
**Argumentos**
* `arg1[, arg2, ...]` — Maps 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)`](/es/reference/data-types/map) o [`Tuple(Array(T), Array(T))`](/es/reference/data-types/tuple)
**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)`](/es/reference/data-types/map) o [`Tuple(Array(T), Array(T))`](/es/reference/data-types/tuple)
**Ejemplos**
**Con el tipo Map**
```sql title=Query theme={null}
SELECT mapAdd(map(1, 1), map(1, 1))
```
```response title=Response theme={null}
{1:2}
```
**Con tupla**
```sql title=Query theme={null}
SELECT mapAdd(([toUInt8(1), 2], [1, 1]), ([toUInt8(1), 2], [1, 1]))
```
```response title=Response theme={null}
([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**
```sql theme={null}
mapAll([func,] map)
```
**Argumentos**
* `func` — Función lambda. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `map` — mapa que se debe comprobar. [`Map(K, V)`](/es/reference/data-types/map)
**Valor devuelto**
Devuelve `1` si todos los pares clave-valor cumplen la condición; en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT mapAll((k, v) -> v = 1, map('k1', 1, 'k2', 2))
```
```response title=Response theme={null}
0
```
## mapApply
Introducido en: v22.3.0
Aplica una función a cada elemento de un mapa.
**Sintaxis**
```sql theme={null}
mapApply(func, map)
```
**Argumentos**
* `func` — Función lambda. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `map` — mapa al que se aplica la función. [`Map(K, V)`](/es/reference/data-types/map)
**Valor devuelto**
Devuelve un nuevo mapa obtenido del mapa original al aplicar `func` a cada elemento. [`Map(K, V)`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT mapApply((k, v) -> (k, v * 2), map('k1', 1, 'k2', 2))
```
```response title=Response theme={null}
{'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**
```sql theme={null}
mapConcat(maps)
```
**Argumentos**
* `maps` — Una cantidad arbitraria de mapas. [`Map`](/es/reference/data-types/map)
**Valor devuelto**
Devuelve un mapa con los mapas concatenados que se pasan como argumentos. [`Map`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT mapConcat(map('k1', 'v1'), map('k2', 'v2'))
```
```response title=Response theme={null}
{'k1':'v1','k2':'v2'}
```
## mapContainsKey
Introducido en: v21.2.0
Determina si un mapa contiene una clave.
**Sintaxis**
```sql theme={null}
mapContainsKey(map, key)
```
**Alias**: `mapContains`
**Argumentos**
* `map` — Mapa en el que se va a buscar. [`Map(K, V)`](/es/reference/data-types/map)
* `key` — Clave que se va a buscar. El tipo debe coincidir con el tipo de clave del mapa. [`Any`](/es/reference/data-types)
**Valor devuelto**
Devuelve 1 si el mapa contiene la clave y 0 en caso contrario. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT mapContainsKey(map('k1', 'v1', 'k2', 'v2'), 'k1')
```
```response title=Response theme={null}
1
```
## mapContainsKeyLike
Introducido en: v23.4.0
Comprueba si el mapa contiene una clave que coincida con el patrón `LIKE` especificado.
**Sintaxis**
```sql theme={null}
mapContainsKeyLike(map, pattern)
```
**Argumentos**
* `map` — Mapa en el que buscar. [`Map(K, V)`](/es/reference/data-types/map)
* `pattern` — Patrón con el que se comparan las claves. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si `map` contiene una clave que coincide con `pattern`; en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─mapContainsKeyLike(a, 'a%')─┐
│ 1 │
│ 0 │
└─────────────────────────────┘
```
## mapContainsValue
Introducido en: v25.6.0
Determina si un mapa contiene un valor.
**Sintaxis**
```sql theme={null}
mapContainsValue(map, value)
```
**Argumentos**
* `map` — Mapa en el que buscar. [`Map(K, V)`](/es/reference/data-types/map)
* `value` — Valor que se va a buscar. El tipo debe coincidir con el tipo de valor de `map`. [`Any`](/es/reference/data-types)
**Valor devuelto**
Devuelve `1` si `map` contiene el valor, `0` si no. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT mapContainsValue(map('k1', 'v1', 'k2', 'v2'), 'v1')
```
```response title=Response theme={null}
1
```
## mapContainsValueLike
Introducido en: v25.5.0
Comprueba si un mapa contiene un valor que coincide con el patrón especificado mediante `LIKE`.
**Sintaxis**
```sql theme={null}
mapContainsValueLike(map, pattern)
```
**Argumentos**
* `map` — Mapa donde buscar. [`Map(K, V)`](/es/reference/data-types/map)
* `pattern` — Patrón con el que comparar los valores. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si `map` contiene un valor que coincide con `pattern`; de lo contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─mapContainsV⋯ke(a, 'a%')─┐
│ 1 │
│ 0 │
└──────────────────────────┘
```
## 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**
```sql theme={null}
mapExists([func,] map)
```
**Argumentos**
* `func` — Opcional. Función lambda. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `map` — Mapa que se va a comprobar. [`Map(K, V)`](/es/reference/data-types/map)
**Valor devuelto**
Devuelve `1` si al menos un par clave-valor cumple la condición; `0` en caso contrario. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT mapExists((k, v) -> v = 1, map('k1', 1, 'k2', 2))
```
```response title=Response theme={null}
1
```
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**
```sql theme={null}
mapExtractKeyLike(map, pattern)
```
**Argumentos**
* `map` — Mapa del que extraer. [`Map(K, V)`](/es/reference/data-types/map)
* `pattern` — Patrón con el que comparar las claves. [`const String`](/es/reference/data-types/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)`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─mapExtractKeyLike(a, 'a%')─┐
│ {'abc':'abc'} │
│ {} │
└────────────────────────────┘
```
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**
```sql theme={null}
mapExtractValueLike(map, pattern)
```
**Argumentos**
* `map` — Mapa del que se extrae. [`Map(K, V)`](/es/reference/data-types/map)
* `pattern` — Patrón con el que comparar los valores. [`const String`](/es/reference/data-types/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)`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─mapExtractValueLike(a, 'a%')─┐
│ {'abc':'abc'} │
│ {} │
└──────────────────────────────┘
```
## mapFilter
Introducido en: v22.3.0
Filtra un mapa aplicando una función a cada elemento del mapa.
**Sintaxis**
```sql theme={null}
mapFilter(func, map)
```
**Argumentos**
* `func` — Función lambda. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `map` — Mapa que se va a filtrar. [`Map(K, V)`](/es/reference/data-types/map)
**Valor devuelto**
Devuelve un mapa que contiene solo los elementos para los que `func` devuelve un valor distinto de `0`. [`Map(K, V)`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT mapFilter((k, v) -> v > 1, map('k1', 1, 'k2', 2))
```
```response title=Response theme={null}
{'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**
```sql theme={null}
mapFromArrays(keys, values)
```
**Alias**: `MAP_FROM_ARRAYS`
**Argumentos**
* `keys` — Array o mapa de claves a partir del cual se crea el mapa. [`Array`](/es/reference/data-types/array) o [`Map`](/es/reference/data-types/map)
* `values` — Array o mapa de valores a partir del cual se crea el mapa. [`Array`](/es/reference/data-types/array) o [`Map`](/es/reference/data-types/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`](/es/reference/data-types/map)
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT mapFromArrays(['a', 'b', 'c'], [1, 2, 3])
```
```response title=Response theme={null}
{'a':1,'b':2,'c':3}
```
**Con entradas de tipo Map**
```sql title=Query theme={null}
SELECT mapFromArrays([1, 2, 3], map('a', 1, 'b', 2, 'c', 3))
```
```response title=Response theme={null}
{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 ajuste [`optimize_functions_to_subcolumns`](/es/reference/settings/session-settings#optimize_functions_to_subcolumns).
Con este ajuste 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**
```sql theme={null}
mapKeys(map)
```
**Argumentos**
* `map` — Mapa del que extraer las claves. [`Map(K, V)`](/es/reference/data-types/map)
**Valor devuelto**
Devuelve un array con todas las claves del mapa. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT mapKeys(map('k1', 'v1', 'k2', 'v2'))
```
```response title=Response theme={null}
['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**
```sql theme={null}
mapPartialReverseSort([func,] limit, map)
```
**Argumentos**
* `func` — Opcional. Función lambda. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `limit` — Se ordenan los elementos del intervalo `[1..limit]`. [`(U)Int*`](/es/reference/data-types/int-uint)
* `map` — Mapa que se va a ordenar. [`Map(K, V)`](/es/reference/data-types/map)
**Valor devuelto**
Devuelve un mapa parcialmente ordenado en orden descendente. [`Map(K, V)`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT mapPartialReverseSort((k, v) -> v, 2, map('k1', 3, 'k2', 1, 'k3', 2))
```
```response title=Response theme={null}
{'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**
```sql theme={null}
mapPartialSort([func,] limit, map)
```
**Argumentos**
* `func` — Opcional. Función lambda. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `limit` — Se ordenan los elementos del rango `[1..limit]`. [`(U)Int*`](/es/reference/data-types/int-uint)
* `map` — mapa que se ordenará. [`Map(K, V)`](/es/reference/data-types/map)
**Valor devuelto**
Devuelve un mapa parcialmente ordenado. [`Map(K, V)`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT mapPartialSort((k, v) -> v, 2, map('k1', 3, 'k2', 1, 'k3', 2))
```
```response title=Response theme={null}
{'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**
```sql theme={null}
mapPopulateSeries(map[, max]) | mapPopulateSeries(keys, values[, max])
```
**Argumentos**
* `map` — mapa con claves de tipo entero. [`Map((U)Int*, V)`](/es/reference/data-types/map)
* `keys` — Array de claves. [`Array(T)`](/es/reference/data-types/array)
* `values` — Array de valores. [`Array(T)`](/es/reference/data-types/array)
* `max` — Opcional. Valor máximo de la clave. [`Int8`](/es/reference/data-types/int-uint) o [`Int16`](/es/reference/data-types/int-uint) o [`Int32`](/es/reference/data-types/int-uint) o [`Int64`](/es/reference/data-types/int-uint) o [`Int128`](/es/reference/data-types/int-uint) o [`Int256`](/es/reference/data-types/int-uint)
**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)`](/es/reference/data-types/map) o [`Tuple(Array(UInt*), Array(Any))`](/es/reference/data-types/tuple)
**Ejemplos**
**Con tipo Map**
```sql title=Query theme={null}
SELECT mapPopulateSeries(map(1, 10, 5, 20), 6)
```
```response title=Response theme={null}
{1:10, 2:0, 3:0, 4:0, 5:20, 6:0}
```
**Con arrays transformados**
```sql title=Query theme={null}
SELECT mapPopulateSeries([1, 2, 4], [11, 22, 44], 5)
```
```response title=Response theme={null}
([1, 2, 3, 4, 5], [11, 22, 0, 44, 0])
```
## 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**
```sql theme={null}
mapReverseSort([func,] map)
```
**Argumentos**
* `func` — Opcional. Función lambda. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `map` — Mapa que se va a ordenar. [`Map(K, V)`](/es/reference/data-types/map)
**Valor devuelto**
Devuelve un mapa ordenado de forma descendente. [`Map(K, V)`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT mapReverseSort((k, v) -> v, map('k1', 3, 'k2', 1, 'k3', 2))
```
```response title=Response theme={null}
{'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**
```sql theme={null}
mapSort([func,] map)
```
**Argumentos**
* `func` — Opcional. Función lambda. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `map` — Mapa que se va a ordenar. [`Map(K, V)`](/es/reference/data-types/map)
**Valor devuelto**
Devuelve un mapa ordenado en orden ascendente. [`Map(K, V)`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT mapSort((k, v) -> v, map('k1', 3, 'k2', 1, 'k3', 2))
```
```response title=Response theme={null}
{'k2':1,'k3':2,'k1':3}
```
## mapSubtract
Introducido en: v20.7.0
Reúne todas las claves y resta los valores correspondientes.
**Sintaxis**
```sql theme={null}
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)`](/es/reference/data-types/map) o [`Tuple(Array(T), Array(T))`](/es/reference/data-types/tuple)
**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)`](/es/reference/data-types/map) o [`Tuple(Array(T), Array(T))`](/es/reference/data-types/tuple)
**Ejemplos**
**Con el tipo mapa**
```sql title=Query theme={null}
SELECT mapSubtract(map(1, 1), map(1, 1))
```
```response title=Response theme={null}
{1:0}
```
**Con mapa de tuplas**
```sql title=Query theme={null}
SELECT mapSubtract(([toUInt8(1), 2], [toInt32(1), 1]), ([toUInt8(1), 2], [toInt32(2), 1]))
```
```response title=Response theme={null}
([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**
```sql theme={null}
mapUpdate(map1, map2)
```
**Argumentos**
* `map1` — El mapa que se actualizará. [`Map(K, V)`](/es/reference/data-types/map)
* `map2` — El mapa que se utilizará para la actualización. [`Map(K, V)`](/es/reference/data-types/map)
**Valor devuelto**
Devuelve `map1` con los valores actualizados según los valores de las claves correspondientes en `map2`. [`Map(K, V)`](/es/reference/data-types/map)
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT mapUpdate(map('key1', 0, 'key3', 0), map('key1', 10, 'key2', 10))
```
```response title=Response theme={null}
{'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 configuración [`optimize_functions_to_subcolumns`](/es/reference/settings/session-settings#optimize_functions_to_subcolumns).
Con esta configuración 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**
```sql theme={null}
mapValues(map)
```
**Argumentos**
* `map` — Mapa del que extraer los valores. [`Map(K, V)`](/es/reference/data-types/map)
**Valor devuelto**
Devuelve un array que contiene todos los valores del mapa. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT mapValues(map('k1', 'v1', 'k2', 'v2'))
```
```response title=Response theme={null}
['v1','v2']
```