Skip to content
ClickHouse Docs
ClickHouse DocsClickHouse Docs
49.6kGet Started

Fonctions Map

View as MarkdownEdit this pageReport an issueSet up docs MCP

extractKeyValuePairs

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

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

Arguments

  • data - Chaîne dont extraire des paires clé-valeur. String ou FixedString.
  • key_value_delimiter - Caractère utilisé comme délimiteur entre la clé et la valeur. La valeur par défaut est :. String ou FixedString.
  • pair_delimiters - Ensemble de caractères utilisés comme délimiteurs entre les paires. La valeur par défaut est \space, , et ;. String ou FixedString.
  • quoting_character - Caractère utilisé comme caractère de guillemet. La valeur par défaut est ". String ou 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 PROMOTE

Valeurs renvoyées

  • Les paires clé-valeur extraites sous forme de Map(String, String).

Exemples

Requête :

Cas simple

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

┌

Apostrophe comme caractère de guillemet

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

┌

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

Séquences d’échappement sans prise en charge de l’échappement

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

┌

Syntaxe

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

Alias : str_to_map, mapFromString

Arguments

  • Aucun.

Valeur renvoyée

Exemples

extractKeyValuePairsWithEscaping

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

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

┌

Syntaxe

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

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

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

Arguments

  • key_n — Les clés des entrées de la map. Any
  • value_n — Les valeurs des entrées de la map. Any

Valeur renvoyée

Renvoie une map contenant des paires clé:valeur. Map(Any, Any)

Exemples

Exemple d'utilisation

SELECT map('key1', number, 'key2', number * 2) FROM numbers(3)
{'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

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) ou Tuple(Array(T), Array(T))

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) ou Tuple(Array(T), Array(T))

Exemples

Avec le type map

SELECT mapAdd(map(1, 1), map(1, 1))
{1:2}

Avec un tuple

SELECT mapAdd(([toUInt8(1), 2], [1, 1]), ([toUInt8(1), 2], [1, 1]))
([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

mapAll([func,] map)

Arguments

Valeur renvoyée

Renvoie 1 si toutes les paires clé-valeur respectent la condition, 0 sinon. UInt8

Exemples

Exemple d’utilisation

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

mapApply

Introduit dans : v22.3.0

Applique une fonction à chaque élément d’une map.

Syntaxe

mapApply(func, map)

Arguments

Valeur renvoyée

Renvoie une nouvelle map obtenue à partir de la map d’origine en appliquant func à chaque élément. Map(K, V)

Exemples

Exemple d’utilisation

SELECT mapApply((k, v) -> (k, v * 2), map('k1', 1, 'k2', 2))
{'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

mapConcat(maps)

Arguments

  • maps — Un nombre quelconque de maps. Map

Valeur renvoyée

Renvoie une map résultant de la concaténation des maps fournies en argument. Map

Exemples

Exemple d'utilisation

SELECT mapConcat(map('k1', 'v1'), map('k2', 'v2'))
{'k1':'v1','k2':'v2'}

mapContainsKey

Introduit dans : v21.2.0

Indique si une clé est présente dans une map.

Syntaxe

mapContainsKey(map, key)

Alias : mapContains

Arguments

  • map — Map dans laquelle rechercher. Map(K, V)
  • key — Clé à rechercher. Le type doit correspondre au type de clé de la Map. Any

Valeur renvoyée

Renvoie 1 si la Map contient la clé, 0 sinon. UInt8

Exemples

Exemple d'utilisation

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

mapContainsKeyLike

Introduit dans : v23.4.0

Vérifie si la map contient une clé correspondant au motif spécifié par LIKE.

Syntaxe

mapContainsKeyLike(map, pattern)

Arguments

  • map — Map dans laquelle rechercher. Map(K, V)
  • pattern — Motif auquel comparer les clés. const String

Valeur renvoyée

Renvoie 1 si map contient une clé correspondant à pattern, sinon 0. UInt8

Exemples

Exemple d'utilisation

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

mapContainsValue

Introduit dans : v25.6.0

Indique si une valeur est présente dans une map.

Syntaxe

mapContainsValue(map, value)

Arguments

  • map — Map dans laquelle rechercher. Map(K, V)
  • value — Valeur à rechercher. Le type doit correspondre au type des valeurs de la map. Any

Valeur renvoyée

Renvoie 1 si la map contient la valeur, 0 sinon. UInt8

Exemples

Exemple d'utilisation

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

mapContainsValueLike

Introduit dans : v25.5.0

Vérifie si une map contient une valeur correspondant au motif spécifié avec LIKE.

Syntaxe

mapContainsValueLike(map, pattern)

Arguments

  • map — Map dans laquelle effectuer la recherche. Map(K, V)
  • pattern — Motif auquel comparer les valeurs. const String

Valeur renvoyée

Renvoie 1 si map contient une valeur correspondant à pattern, sinon 0. UInt8

Exemples

Exemple d'utilisation

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

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

mapExists([func,] map)

Arguments

Valeur renvoyée

Renvoie 1 si au moins une paire clé-valeur remplit la condition, 0 sinon. UInt8

Exemples

Exemple d'utilisation

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

mapExtractKeyLike

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

mapExtractKeyLike(map, pattern)

Arguments

  • map — Map à partir de laquelle extraire. Map(K, V)
  • pattern — Motif auquel les clés doivent correspondre. const 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)

Exemples

Exemple d'utilisation

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

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

mapExtractValueLike(map, pattern)

Arguments

  • map — Map à partir de laquelle effectuer l'extraction. Map(K, V)
  • pattern — Motif auquel les valeurs doivent correspondre. const 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)

Exemples

Exemple d'utilisation

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

Introduit dans : v22.3.0

Filtre une map en appliquant une fonction à chaque élément.

Syntaxe

mapFilter(func, map)

Arguments

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)

Exemples

Exemple d'utilisation

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

mapFromArrays

Introduit dans : v23.3.0

Crée un Map à partir d'un tableau ou d'un Map de clés et d'un tableau ou d'un Map de valeurs. La fonction est une alternative pratique à la syntaxe CAST([...], 'Map(key_type, value_type)').

Syntaxe

mapFromArrays(keys, values)

Alias : MAP_FROM_ARRAYS

Arguments

  • keys — tableau ou map de clés utilisée pour créer la map. tableau ou Map
  • values — tableau ou map de valeurs utilisée pour créer la map. tableau ou 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

Exemples

Utilisation de base

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

Avec des entrées Map

SELECT mapFromArrays([1, 2, 3], map('a', 1, 'b', 2, 'c', 3))
{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. 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

mapKeys(map)

Arguments

  • map — Map dont les clés doivent être extraites. Map(K, V)

Valeur renvoyée

Renvoie un tableau contenant toutes les clés de la map. Array(T)

Exemples

Exemple d'utilisation

SELECT mapKeys(map('k1', 'v1', 'k2', 'v2'))
['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

mapPartialReverseSort([func,] limit, map)

Arguments

  • func — Facultatif. Fonction lambda. Fonction lambda
  • limit — Les éléments de l’intervalle [1..limit] sont triés. (U)Int*
  • map — Map à trier. Map(K, V)

Valeur renvoyée

Renvoie une map partiellement triée par ordre décroissant. Map(K, V)

Exemples

Exemple d'utilisation

SELECT mapPartialReverseSort((k, v) -> v, 2, map('k1', 3, 'k2', 1, 'k3', 2))
{'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

mapPartialSort([func,] limit, map)

Arguments

  • func — Facultatif. Fonction lambda. Fonction lambda
  • limit — Les éléments de la plage [1..limit] sont triés. (U)Int*
  • map — Map à trier. Map(K, V)

Valeur renvoyée

Renvoie une map partiellement triée. Map(K, V)

Exemples

Exemple d'utilisation

SELECT mapPartialSort((k, v) -> v, 2, map('k1', 3, 'k2', 1, 'k3', 2))
{'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

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

Arguments

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) ou Tuple(Array(UInt*), Array(Any))

Exemples

Avec le type Map

SELECT mapPopulateSeries(map(1, 10, 5, 20), 6)
{1:10,2:0,3:0,4:0,5:20,6:0}

Avec des tableaux associés

SELECT mapPopulateSeries([1, 2, 4], [11, 22, 44], 5)
([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

mapReverseSort([func,] map)

Arguments

valeur renvoyée

Renvoie une map triée dans l’ordre décroissant. Map(K, V)

Exemples

Exemple d'utilisation

SELECT mapReverseSort((k, v) -> v, map('k1', 3, 'k2', 1, 'k3', 2))
{'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

mapSort([func,] map)

Arguments

Valeur renvoyée

Renvoie une map triée par ordre croissant. Map(K, V)

Exemples

Exemple d'utilisation

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

mapSubtract

Introduit dans : v20.7.0

Rassemble toutes les clés et soustrait les valeurs correspondantes.

Syntaxe

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) ou Tuple(Array(T), Array(T))

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) ou Tuple(Array(T), Array(T))

Exemples

Avec le type Map

SELECT mapSubtract(map(1, 1), map(1, 1))
{1:0}

Avec une map de tuples

SELECT mapSubtract(([toUInt8(1), 2], [toInt32(1), 1]), ([toUInt8(1), 2], [toInt32(2), 1]))
([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

mapUpdate(map1, map2)

Arguments

  • map1 — La map à mettre à jour. Map(K, V)
  • map2 — La map à utiliser pour la mise à jour. Map(K, V)

Valeur renvoyée

Renvoie map1 avec les valeurs mises à jour à partir des valeurs des clés correspondantes dans map2. Map(K, V)

Exemples

Utilisation de base

SELECT mapUpdate(map('key1', 0, 'key3', 0), map('key1', 10, 'key2', 10))
{'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. 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

mapValues(map)

Arguments

  • map — Map à partir de laquelle extraire les valeurs. Map(K, V)

Valeur renvoyée

Renvoie un tableau contenant toutes les valeurs de la Map. Array(T)

Exemples

Exemple d'utilisation

SELECT mapValues(map('k1', 'v1', 'k2', 'v2'))
['v1','v2']
Navigation