Fonctions Map

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

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

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

Apostrophe comme caractère de guillemet

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

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

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

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

Syntaxe

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

Alias : mapFromString, str_to_map 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

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

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

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

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

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

Query

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

Response

{1:2}

Avec un tuple

Query

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

Response

([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

func — Fonction lambda. Fonction lambda
map — Map à vérifier. Map(K, V)

Valeur renvoyée Renvoie 1 si toutes les paires clé-valeur respectent la condition, 0 sinon. UInt8 Exemples Exemple d’utilisation

Query

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

Response

mapApply

Introduit dans : v22.3.0 Applique une fonction à chaque élément d’une map. Syntaxe

mapApply(func, map)

Arguments

func — Fonction lambda. Fonction lambda
map — Map sur laquelle appliquer la fonction. Map(K, V)

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

Query

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

Response

{'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

Query

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

Response

{'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

Query

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

Response

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

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

Introduit dans : v26.9.0 Indique si la map contient une entrée ayant la clé et la valeur indiquées. Pour les arguments qui ne sont pas NULL, cela équivaut à arrayExists((k, v) -> k = key AND v = value, mapKeys(map), mapValues(map)). Une valeur NULL ne correspond qu’à une autre valeur NULL, comme dans mapContainsKey et mapContainsValue, au lieu de donner lieu à une comparaison dont le résultat est inconnu, comme avec l’opérateur =. Toutes les entrées sont prises en compte, contrairement à map[key] = value, qui ne compare que la valeur de la première occurrence de key. Un index de texte utilisant le tokeniseur keyValuePairs permet d’évaluer cette fonction directement à partir de l’index. Syntaxe

mapContainsKeyValue(map, key, value)

Arguments

map — La map dans laquelle effectuer la recherche. Map(K, V)
key — La clé à rechercher. Son type doit correspondre à celui des clés de la map. Any
value — La valeur à rechercher. Son type doit correspondre à celui des valeurs de la map. Any

Valeur renvoyée Renvoie 1 si la map contient une entrée associant la clé et la valeur, 0 sinon. UInt8 Exemples Utilisation de base

Query

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

Response

Clé et valeur appartenant à des entrées différentes

Query

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

Response

Clé en double

Query

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

Response

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

Query

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

Response

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

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

Introduit dans : v26.10.0 Renvoie les paires clé-valeur d’une map sous la forme d’un tableau de tuples nommés comportant les champs key et value. Les clés en double sont conservées. Syntaxe

mapEntries(map)

Arguments

map — Map dont extraire les entrées. Map(K, V)

Valeur renvoyée Renvoie un tableau contenant les paires clé-valeur de la map. Array(Tuple(key K, value V)) Exemples Exemple d’utilisation

Query

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

Response

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

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

func — Facultatif. Fonction lambda. Fonction lambda
map — Map à tester. Map(K, V)

Valeur renvoyée Renvoie 1 si au moins une paire clé-valeur remplit la condition, 0 sinon. UInt8 Exemples Exemple d’utilisation

Query

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

Response

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

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

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

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

Introduit dans : v22.3.0 Filtre une map en appliquant une fonction à chaque élément. Syntaxe

mapFilter(func, map)

Arguments

func — Fonction lambda. Fonction lambda
map — Map à filtrer. Map(K, V)

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

Query

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

Response

{'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

Query

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

Response

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

Avec des entrées 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

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

Query

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

Response

['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

Query

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

Response

{'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

Query

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

Response

{'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

map — Map à clés entières. Map((U)Int*, V)
keys — Tableau de clés. Array(T)
values — Tableau de valeurs. Array(T)
max — Facultatif. Valeur de clé maximale. Int8 ou Int16 ou Int32 ou Int64 ou Int128 ou Int256

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

Query

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

Response

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

Avec des tableaux associés

Query

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

Response

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

mapRemove

Introduit dans : v26.10.0 Supprime d’une map toutes les entrées dont la clé est égale à la clé spécifiée. Si plusieurs entrées partagent la même clé, elles sont toutes supprimées. Les valeurs NULL sont comparées comme des valeurs ordinaires : une clé de suppression NULL ne correspond pas à une clé non NULL, et les composants NULL des clés composites correspondent aux autres composants NULL. Pour les types de clés ayant un supertype commun, les clés NaN suivent la sémantique du lookup dans une map : une clé de suppression NaN correspond donc à une clé NaN de la map. Syntaxe

mapRemove(map, key)

Arguments

map — Map dont les entrées correspondantes doivent être supprimées. Map(K, V)
key — Clé dont les entrées correspondantes sont supprimées. Son type doit être comparable au type des clés de la map. Any

Valeur renvoyée Renvoie la map contenant toutes les entrées dont la clé ne correspond pas à la clé spécifiée. Map(K, V) Exemples Exemple d’utilisation

Query

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

Response

{'k2':2}

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

func — Facultatif. Fonction lambda. Fonction lambda
map — Map à trier. Map(K, V)

valeur renvoyée Renvoie une map triée dans l’ordre décroissant. Map(K, V) Exemples Exemple d’utilisation

Query

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

Response

{'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

func — Facultatif. Fonction lambda. Fonction lambda
map — Map à trier. Map(K, V)

Valeur renvoyée Renvoie une map triée par ordre croissant. Map(K, V) Exemples Exemple d’utilisation

Query

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

Response

{'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

Query

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

Response

{1:0}

Avec une map de tuples

Query

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

Response

([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

Query

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

Response

{'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

Query

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

Response

['v1','v2']

Référence SQL

Types de données

Moteurs

Fonctions

Formats

Paramètres

Tables système

Lacs de données

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