> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentation des fonctions Map et Tuple
# Fonctions Map
{/*AUTOGENERATED_START*/}
Introduit dans : v23.4.0
Extrait des paires clé-valeur depuis n'importe quelle chaîne. La chaîne n'a pas besoin d'être structurée à 100 % au format de paires clé-valeur ;
Il peut contenir du bruit (par exemple, des fichiers de log). Le format des paires clé-valeur à interpréter doit être spécifié via les arguments de la fonction.
Une paire clé-valeur est composée d'une clé suivie d'un `key_value_delimiter` et d'une valeur. Les clés et valeurs entre guillemets sont également prises en charge. Les paires clé-valeur doivent être séparées par des délimiteurs de paires.
**Syntaxe**
```sql theme={null}
extractKeyValuePairs(data, [key_value_delimiter], [pair_delimiter], [quoting_character])
```
**Arguments**
* `data` - Chaîne dont extraire des paires clé-valeur. [String](/fr/reference/data-types/string) ou [FixedString](/fr/reference/data-types/fixedstring).
* `key_value_delimiter` - Caractère utilisé comme délimiteur entre la clé et la valeur. La valeur par défaut est `:`. [String](/fr/reference/data-types/string) ou [FixedString](/fr/reference/data-types/fixedstring).
* `pair_delimiters` - Ensemble de caractères utilisés comme délimiteurs entre les paires. La valeur par défaut est `\space`, `,` et `;`. [String](/fr/reference/data-types/string) ou [FixedString](/fr/reference/data-types/fixedstring).
* `quoting_character` - Caractère utilisé comme caractère de guillemet. La valeur par défaut est `"`. [String](/fr/reference/data-types/string) ou [FixedString](/fr/reference/data-types/fixedstring).
* `unexpected_quoting_character_strategy` - Stratégie de gestion des caractères de guillemet lorsqu'ils apparaissent à des emplacements inattendus pendant les phases `read_key` et `read_value`. Valeurs possibles : `invalid`, `accept` et `promote`. Invalid supprimera la clé/valeur et reviendra à l'état `WAITING_KEY`. Accept le traitera comme un caractère normal. Promote passera à l'état `READ_QUOTED_{KEY/VALUE}` et commencera à partir du caractère suivant. La valeur par défaut est `INVALID`
**Valeurs renvoyées**
* Les paires clé-valeur extraites sous forme de Map(String, String).
**Exemples**
Requête :
**Cas 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'} │
└─────────────────────────────────────────────────────────────────────────┘
```
**Apostrophe comme caractère de délimitation**
```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'} │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
Exemples 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'} │
└──────────────┘
```
**Séquences d’échappement sans prise en charge de l’échappement**
```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'} │
└───────────────────────┘
```
**Syntaxe**
```sql theme={null}
extractKeyValuePairs(input)
```
**Alias** : `str_to_map`, `mapFromString`
**Arguments**
* Aucun.
**Valeur renvoyée**
**Exemples**
Introduit dans : v23.4.0
Identique à `extractKeyValuePairs`, mais avec la prise en charge de l'échappement.
Séquences d'échappement prises en charge : `\x`, `\N`, `\a`, `\b`, `\e`, `\f`, `\n`, `\r`, `\t`, `\v` et `\0`.
Les séquences d'échappement non standard sont renvoyées telles quelles (y compris le backslash), sauf si elles correspondent à l'une des suivantes :
`\\`, `'`, `"`, `backtick`, `/`, `=` ou des caractères de contrôle ASCII (`c <= 31`).
Cette fonction couvre le cas d'usage où le pré-échappement et le post-échappement ne conviennent pas. Par exemple, considérons la
chaîne d'entrée suivante : `a: "aaaa\"bbb"`. La sortie attendue est : `a: aaaa\"bbbb`.
* Pré-échappement : en appliquant le pré-échappement, on obtient `a: "aaaa"bbb"` et `extractKeyValuePairs` renverra alors `a: aaaa`
* Post-échappement : `extractKeyValuePairs` renverra `a: aaaa\` et le post-échappement le conservera tel quel.
Les séquences d'échappement en tête seront ignorées dans les clés et considérées comme invalides pour les valeurs.
**Séquences d'échappement avec la prise en charge de l'échappement activée**
```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'} │
└──────────────────┘
```
**Syntaxe**
```sql theme={null}
extractKeyValuePairsWithEscaping(input)
```
**Arguments**
* Aucun.
**valeur renvoyée**
**Exemples**
## map
Introduit dans : v21.1.0
Crée une valeur de type `Map(key, value)` à partir de paires clé-valeur.
**Syntaxe**
```sql theme={null}
map(key1, value1[, key2, value2, ...])
```
**Arguments**
* `key_n` — Les clés des entrées de la map. [`Any`](/fr/reference/data-types/index)
* `value_n` — Les valeurs des entrées de la map. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie une map contenant des paires clé:valeur. [`Map(Any, Any)`](/fr/reference/data-types/map)
**Exemples**
**Exemple d'utilisation**
```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
Introduit dans : v20.7.0
Rassemble toutes les clés et additionne les valeurs correspondantes.
**Syntaxe**
```sql theme={null}
mapAdd(arg1[, arg2, ...])
```
**Arguments**
* `arg1[, arg2, ...]` — Objets map ou tuples composés de deux tableaux, dans lesquels les éléments du premier tableau représentent les clés et le second tableau contient les valeurs associées à chaque clé. [`Map(K, V)`](/fr/reference/data-types/map) ou [`Tuple(Array(T), Array(T))`](/fr/reference/data-types/tuple)
**Valeur renvoyée**
Renvoie un objet map ou un tuple, dans lequel le premier tableau contient les clés triées et le second tableau contient les valeurs. [`Map(K, V)`](/fr/reference/data-types/map) ou [`Tuple(Array(T), Array(T))`](/fr/reference/data-types/tuple)
**Exemples**
**Avec le type map**
```sql title=Query theme={null}
SELECT mapAdd(map(1, 1), map(1, 1))
```
```response title=Response theme={null}
{1:2}
```
**Avec un tuple**
```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
Disponible à partir de : v23.4.0
Vérifie si une condition est remplie pour toutes les paires clé-valeur d'une map.
`mapAll` est une fonction d'ordre supérieur.
Vous pouvez lui passer une fonction lambda en premier argument.
**Syntaxe**
```sql theme={null}
mapAll([func,] map)
```
**Arguments**
* `func` — Fonction lambda. [`Fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `map` — Map à vérifier. [`Map(K, V)`](/fr/reference/data-types/map)
**Valeur renvoyée**
Renvoie `1` si toutes les paires clé-valeur respectent la condition, `0` sinon. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT mapAll((k, v) -> v = 1, map('k1', 1, 'k2', 2))
```
```response title=Response theme={null}
0
```
## mapApply
Introduit dans : v22.3.0
Applique une fonction à chaque élément d’une map.
**Syntaxe**
```sql theme={null}
mapApply(func, map)
```
**Arguments**
* `func` — Fonction lambda. [`Fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `map` — Map sur laquelle appliquer la fonction. [`Map(K, V)`](/fr/reference/data-types/map)
**Valeur renvoyée**
Renvoie une nouvelle map obtenue à partir de la map d’origine en appliquant `func` à chaque élément. [`Map(K, V)`](/fr/reference/data-types/map)
**Exemples**
**Exemple d’utilisation**
```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
Introduit dans : v23.4.0
Concatène plusieurs maps en fonction de l'égalité de leurs clés.
Si des éléments ayant la même clé existent dans plusieurs maps d'entrée, tous les éléments sont ajoutés à la map de résultat, mais seul le premier est accessible via l'opérateur \[].
**Syntaxe**
```sql theme={null}
mapConcat(maps)
```
**Arguments**
* `maps` — Un nombre quelconque de maps. [`Map`](/fr/reference/data-types/map)
**Valeur renvoyée**
Renvoie une map résultant de la concaténation des maps fournies en argument. [`Map`](/fr/reference/data-types/map)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT mapConcat(map('k1', 'v1'), map('k2', 'v2'))
```
```response title=Response theme={null}
{'k1':'v1','k2':'v2'}
```
## mapContainsKey
Introduit dans : v21.2.0
Indique si une clé est présente dans une map.
**Syntaxe**
```sql theme={null}
mapContainsKey(map, key)
```
**Alias** : `mapContains`
**Arguments**
* `map` — Map dans laquelle rechercher. [`Map(K, V)`](/fr/reference/data-types/map)
* `key` — Clé à rechercher. Le type doit correspondre au type de clé de la Map. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie 1 si la Map contient la clé, 0 sinon. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT mapContainsKey(map('k1', 'v1', 'k2', 'v2'), 'k1')
```
```response title=Response theme={null}
1
```
## mapContainsKeyLike
Introduit dans : v23.4.0
Vérifie si la map contient une clé correspondant au motif spécifié par `LIKE`.
**Syntaxe**
```sql theme={null}
mapContainsKeyLike(map, pattern)
```
**Arguments**
* `map` — Map dans laquelle rechercher. [`Map(K, V)`](/fr/reference/data-types/map)
* `pattern` — Motif auquel comparer les clés. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si `map` contient une clé correspondant à `pattern`, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```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
Introduit dans : v25.6.0
Indique si une valeur est présente dans une map.
**Syntaxe**
```sql theme={null}
mapContainsValue(map, value)
```
**Arguments**
* `map` — Map dans laquelle rechercher. [`Map(K, V)`](/fr/reference/data-types/map)
* `value` — Valeur à rechercher. Le type doit correspondre au type des valeurs de la map. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie `1` si la map contient la valeur, `0` sinon. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT mapContainsValue(map('k1', 'v1', 'k2', 'v2'), 'v1')
```
```response title=Response theme={null}
1
```
## mapContainsValueLike
Introduit dans : v25.5.0
Vérifie si une map contient une valeur correspondant au motif spécifié avec `LIKE`.
**Syntaxe**
```sql theme={null}
mapContainsValueLike(map, pattern)
```
**Arguments**
* `map` — Map dans laquelle effectuer la recherche. [`Map(K, V)`](/fr/reference/data-types/map)
* `pattern` — Motif auquel comparer les valeurs. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si `map` contient une valeur correspondant à `pattern`, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```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
Introduit dans : v23.4.0
Teste si une condition est vérifiée pour au moins une paire clé-valeur dans une Map.
`mapExists` est une fonction d’ordre supérieur.
Vous pouvez lui passer une fonction lambda comme premier argument.
**Syntaxe**
```sql theme={null}
mapExists([func,] map)
```
**Arguments**
* `func` — Facultatif. Fonction lambda. [`Fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `map` — Map à tester. [`Map(K, V)`](/fr/reference/data-types/map)
**Valeur renvoyée**
Renvoie `1` si au moins une paire clé-valeur remplit la condition, `0` sinon. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT mapExists((k, v) -> v = 1, map('k1', 1, 'k2', 2))
```
```response title=Response theme={null}
1
```
Introduit dans : v23.4.0
Étant donné une Map avec des clés de type chaîne et un motif `LIKE`, cette fonction renvoie une Map contenant les éléments dont la clé correspond au motif.
**Syntaxe**
```sql theme={null}
mapExtractKeyLike(map, pattern)
```
**Arguments**
* `map` — Map à partir de laquelle extraire. [`Map(K, V)`](/fr/reference/data-types/map)
* `pattern` — Motif auquel les clés doivent correspondre. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Map contenant les éléments dont la clé correspond au motif spécifié. Si aucun élément ne correspond au motif, une map vide est renvoyée. [`Map(K, V)`](/fr/reference/data-types/map)
**Exemples**
**Exemple d'utilisation**
```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'} │
│ {} │
└────────────────────────────┘
```
Introduit dans : v25.5.0
Étant donné une map dont les valeurs sont des chaînes de caractères et un motif `LIKE`, cette fonction renvoie une map contenant les éléments dont la valeur correspond au motif.
**Syntaxe**
```sql theme={null}
mapExtractValueLike(map, pattern)
```
**Arguments**
* `map` — Map à partir de laquelle effectuer l'extraction. [`Map(K, V)`](/fr/reference/data-types/map)
* `pattern` — Motif auquel les valeurs doivent correspondre. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une map contenant les éléments dont la valeur correspond au motif spécifié. Si aucun élément ne correspond au motif, une map vide est renvoyée. [`Map(K, V)`](/fr/reference/data-types/map)
**Exemples**
**Exemple d'utilisation**
```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
Introduit dans : v22.3.0
Filtre une map en appliquant une fonction à chaque élément.
**Syntaxe**
```sql theme={null}
mapFilter(func, map)
```
**Arguments**
* `func` — Fonction lambda. [`Fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `map` — Map à filtrer. [`Map(K, V)`](/fr/reference/data-types/map)
**Valeur renvoyée**
Renvoie une `Map` ne contenant que les éléments pour lesquels `func` renvoie une valeur différente de `0`. [`Map(K, V)`](/fr/reference/data-types/map)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT mapFilter((k, v) -> v > 1, map('k1', 1, 'k2', 2))
```
```response title=Response theme={null}
{'k2':2}
```
## mapFromArrays
Introduit dans : v23.3.0
Crée un Map à partir d'un Array ou d'un Map de clés et d'un Array ou d'un Map de valeurs.
La fonction est une alternative pratique à la syntaxe `CAST([...], 'Map(key_type, value_type)')`.
**Syntaxe**
```sql theme={null}
mapFromArrays(keys, values)
```
**Alias** : `MAP_FROM_ARRAYS`
**Arguments**
* `keys` — Array ou map de clés utilisée pour créer la map. [`Array`](/fr/reference/data-types/array) ou [`Map`](/fr/reference/data-types/map)
* `values` — Array ou map de valeurs utilisée pour créer la map. [`Array`](/fr/reference/data-types/array) ou [`Map`](/fr/reference/data-types/map)
**Valeur renvoyée**
Renvoie une map dont les clés et les valeurs sont construites à partir du tableau de clés et du tableau ou de la map de valeurs. [`Map`](/fr/reference/data-types/map)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT mapFromArrays(['a', 'b', 'c'], [1, 2, 3])
```
```response title=Response theme={null}
{'a':1,'b':2,'c':3}
```
**Avec des entrées 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
Introduit dans : v21.2.0
Renvoie les clés de la map donnée.
Cette fonction peut être optimisée en activant le paramètre [`optimize_functions_to_subcolumns`](/fr/reference/settings/session-settings#optimize_functions_to_subcolumns).
Lorsque ce paramètre est activé, la fonction lit uniquement la sous-colonne `keys` au lieu de lire la map entière.
La requête `SELECT mapKeys(m) FROM table` est transformée en `SELECT m.keys FROM table`.
**Syntaxe**
```sql theme={null}
mapKeys(map)
```
**Arguments**
* `map` — Map dont les clés doivent être extraites. [`Map(K, V)`](/fr/reference/data-types/map)
**Valeur renvoyée**
Renvoie un tableau contenant toutes les clés de la map. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT mapKeys(map('k1', 'v1', 'k2', 'v2'))
```
```response title=Response theme={null}
['k1','k2']
```
## mapPartialReverseSort
Introduit dans : v23.4.0
Trie les éléments d'une map par ordre décroissant, avec un argument de limite supplémentaire permettant un tri partiel.
Si la fonction func est spécifiée, l'ordre de tri est déterminé par le résultat de la fonction func appliquée aux clés et aux valeurs de la map.
**Syntaxe**
```sql theme={null}
mapPartialReverseSort([func,] limit, map)
```
**Arguments**
* `func` — Facultatif. Fonction lambda. [`Fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `limit` — Les éléments de l’intervalle `[1..limit]` sont triés. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `map` — Map à trier. [`Map(K, V)`](/fr/reference/data-types/map)
**Valeur renvoyée**
Renvoie une map partiellement triée par ordre décroissant. [`Map(K, V)`](/fr/reference/data-types/map)
**Exemples**
**Exemple d'utilisation**
```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
Introduit dans : v23.4.0
Trie les éléments d'une map par ordre croissant, avec un argument limit supplémentaire permettant un tri partiel.
Si la fonction func est spécifiée, l'ordre de tri est déterminé par le résultat de la fonction func appliquée aux clés et aux valeurs de la map.
**Syntaxe**
```sql theme={null}
mapPartialSort([func,] limit, map)
```
**Arguments**
* `func` — Facultatif. Fonction lambda. [`Fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `limit` — Les éléments de la plage `[1..limit]` sont triés. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `map` — Map à trier. [`Map(K, V)`](/fr/reference/data-types/map)
**Valeur renvoyée**
Renvoie une map partiellement triée. [`Map(K, V)`](/fr/reference/data-types/map)
**Exemples**
**Exemple d'utilisation**
```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
Introduite dans : v20.10.0
Remplit les paires clé-valeur manquantes dans une map à clés entières.
Pour permettre d’étendre les clés au-delà de la valeur la plus élevée, une clé maximale peut être spécifiée.
Plus précisément, la fonction renvoie une map dans laquelle les clés forment une série allant de la plus petite à la plus grande clé (ou jusqu’à l’argument max, s’il est spécifié), avec un pas de 1, ainsi que les valeurs correspondantes.
Si aucune valeur n’est spécifiée pour une clé, une valeur par défaut est utilisée.
Si des clés sont répétées, seule la première valeur (dans l’ordre d’apparition) est associée à la clé.
**Syntaxe**
```sql theme={null}
mapPopulateSeries(map[, max]) | mapPopulateSeries(keys, values[, max])
```
**Arguments**
* `map` — Map à clés entières. [`Map((U)Int*, V)`](/fr/reference/data-types/map)
* `keys` — Tableau de clés. [`Array(T)`](/fr/reference/data-types/array)
* `values` — Tableau de valeurs. [`Array(T)`](/fr/reference/data-types/array)
* `max` — Facultatif. Valeur de clé maximale. [`Int8`](/fr/reference/data-types/int-uint) ou [`Int16`](/fr/reference/data-types/int-uint) ou [`Int32`](/fr/reference/data-types/int-uint) ou [`Int64`](/fr/reference/data-types/int-uint) ou [`Int128`](/fr/reference/data-types/int-uint) ou [`Int256`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie une map ou un tuple de deux tableaux, dans lequel le premier contient les clés dans l’ordre trié et le second les valeurs correspondant à ces clés. [`Map(K, V)`](/fr/reference/data-types/map) ou [`Tuple(Array(UInt*), Array(Any))`](/fr/reference/data-types/tuple)
**Exemples**
**Avec le type 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}
```
**Avec des tableaux transformés**
```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
Introduit dans : v23.4.0
Trie les éléments d’une map par ordre décroissant.
Si la fonction func est spécifiée, l’ordre de tri est déterminé par le résultat de la fonction func appliquée aux clés et aux valeurs de la map.
**Syntaxe**
```sql theme={null}
mapReverseSort([func,] map)
```
**Arguments**
* `func` — Facultatif. Fonction lambda. [`Fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `map` — Map à trier. [`Map(K, V)`](/fr/reference/data-types/map)
**valeur renvoyée**
Renvoie une map triée dans l’ordre décroissant. [`Map(K, V)`](/fr/reference/data-types/map)
**Exemples**
**Exemple d'utilisation**
```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
Introduit dans : v23.4.0
Trie les éléments d'une map par ordre croissant.
Si la fonction func est spécifiée, l'ordre de tri est déterminé par le résultat de la fonction func appliquée aux clés et aux valeurs de la map.
**Syntaxe**
```sql theme={null}
mapSort([func,] map)
```
**Arguments**
* `func` — Facultatif. Fonction lambda. [`Fonction lambda`](/fr/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `map` — Map à trier. [`Map(K, V)`](/fr/reference/data-types/map)
**Valeur renvoyée**
Renvoie une map triée par ordre croissant. [`Map(K, V)`](/fr/reference/data-types/map)
**Exemples**
**Exemple d'utilisation**
```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
Introduit dans : v20.7.0
Rassemble toutes les clés et soustrait les valeurs correspondantes.
**Syntaxe**
```sql theme={null}
mapSubtract(arg1[, arg2, ...])
```
**Arguments**
* `arg1[, arg2, ...]` — Des Map ou des tuples de deux tableaux, dans lesquels les éléments du premier tableau représentent des clés et le second tableau contient les valeurs associées à chaque clé. [`Map(K, V)`](/fr/reference/data-types/map) ou [`Tuple(Array(T), Array(T))`](/fr/reference/data-types/tuple)
**Valeur renvoyée**
Renvoie une Map ou un tuple, dans lesquels le premier tableau contient les clés triées et le second tableau contient les valeurs. [`Map(K, V)`](/fr/reference/data-types/map) ou [`Tuple(Array(T), Array(T))`](/fr/reference/data-types/tuple)
**Exemples**
**Avec le type Map**
```sql title=Query theme={null}
SELECT mapSubtract(map(1, 1), map(1, 1))
```
```response title=Response theme={null}
{1:0}
```
**Avec une map de tuples**
```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
Introduit dans : v22.3.0
Pour deux maps, renvoie la première map avec les valeurs mises à jour à partir des valeurs des clés correspondantes dans la seconde map.
**Syntaxe**
```sql theme={null}
mapUpdate(map1, map2)
```
**Arguments**
* `map1` — La map à mettre à jour. [`Map(K, V)`](/fr/reference/data-types/map)
* `map2` — La map à utiliser pour la mise à jour. [`Map(K, V)`](/fr/reference/data-types/map)
**Valeur renvoyée**
Renvoie `map1` avec les valeurs mises à jour à partir des valeurs des clés correspondantes dans `map2`. [`Map(K, V)`](/fr/reference/data-types/map)
**Exemples**
**Utilisation de base**
```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
Introduit dans : v21.2.0
Renvoie les valeurs de la map donnée.
Cette fonction peut être optimisée en activant le paramètre [`optimize_functions_to_subcolumns`](/fr/reference/settings/session-settings#optimize_functions_to_subcolumns).
Lorsque ce paramètre est activé, la fonction lit uniquement la sous-colonne `values` au lieu de lire la map entière.
La requête `SELECT mapValues(m) FROM table` est transformée en `SELECT m.values FROM table`.
**Syntaxe**
```sql theme={null}
mapValues(map)
```
**Arguments**
* `map` — Map à partir de laquelle extraire les valeurs. [`Map(K, V)`](/fr/reference/data-types/map)
**Valeur renvoyée**
Renvoie un tableau contenant toutes les valeurs de la Map. [`Array(T)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT mapValues(map('k1', 'v1', 'k2', 'v2'))
```
```response title=Response theme={null}
['v1','v2']
```