マップ関数

map

キーと値のペアから、Map(key, value) 型の値を作成します。

構文

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

引数

key_n — マップエントリのキー。Map のキー型としてサポートされる任意の型。
value_n — マップエントリの値。Map の値型としてサポートされる任意の型。

返り値

key:value ペアを含むマップ。Map(key, value)。

例

クエリ:

SELECT map('key1', number, 'key2', number * 2) FROM numbers(3);

結果：

┌─map('key1', number, 'key2', multiply(number, 2))─┐
│ {'key1':0,'key2':0}                              │
│ {'key1':1,'key2':2}                              │
│ {'key1':2,'key2':4}                              │
└──────────────────────────────────────────────────┘

mapFromArrays

キーの配列またはマップと値の配列またはマップから map を作成します。

この関数は、構文 CAST([...], 'Map(key_type, value_type)') の便利な代替手段です。たとえば、次のように記述する代わりに

CAST((['aa', 'bb'], [4, 5]), 'Map(String, UInt32)') や
CAST([('aa',4), ('bb',5)], 'Map(String, UInt32)')

mapFromArrays(['aa', 'bb'], [4, 5]) と記述できます。

構文

mapFromArrays(keys, values)

Alias: MAP_FROM_ARRAYS(keys, values)

引数

keys — マップを作成するためのキーの配列またはマップ。Array または Map 型です。keys が配列の場合、その型として Array(Nullable(T)) または Array(LowCardinality(Nullable(T))) を、NULL 値を含まない限り使用できます。
values - マップを作成するための値の配列またはマップ。Array または Map 型です。

戻り値

キー配列および値配列/マップから構築されたマップ。

例

クエリ:

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

結果:

┌─mapFromArrays(['a', 'b', 'c'], [1, 2, 3])─┐
│ {'a':1,'b':2,'c':3}                       │
└───────────────────────────────────────────┘

mapFromArrays は、Map 型の引数も受け付けます。これらは、実行時にタプルの配列にキャストされます。

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

結果：

┌─mapFromArrays([1, 2, 3], map('a', 1, 'b', 2, 'c', 3))─┐
│ {1:('a',1),2:('b',2),3:('c',3)}                       │
└───────────────────────────────────────────────────────┘

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

結果：

┌─mapFromArrays(map('a', 1, 'b', 2, 'c', 3), [1, 2, 3])─┐
│ {('a',1):1,('b',2):2,('c',3):3}                       │
└───────────────────────────────────────────────────────┘

extractKeyValuePairs

キーと値のペアからなる文字列を Map(String, String) に変換します。パース処理は（ログファイルなどの）ノイズに対して寛容です。入力文字列中のキーと値のペアは、キー、キーと値の区切り文字、それに続く値から構成されます。キーと値のペア同士は、ペア区切り文字で区切られます。キーと値は引用符で囲むことができます。

構文

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

Alias:

str_to_map
mapFromString

引数

data - キーと値のペアを抽出する対象の文字列。String または FixedString。
key_value_delimiter - キーと値を区切る 1 文字の区切り文字。デフォルトは :。String または FixedString。
pair_delimiters - ペア同士を区切る文字の集合。デフォルトは、,、;。String または FixedString。
quoting_character - クオート文字として使われる 1 文字。デフォルトは ". String または FixedString。
unexpected_quoting_character_strategy - read_key と read_value フェーズで、予期しない位置に現れたクオート文字をどのように扱うかの戦略。指定可能な値: invalid, accept, promote。invalid はキー／値を破棄し、WAITING_KEY 状態に戻る。accept は通常の文字として扱う。promote は READ_QUOTED_{KEY/VALUE} 状態に遷移し、次の文字から読み取りを再開する。

返り値

キーと値のペアの集合。型: Map(String, String)

使用例

クエリ

SELECT extractKeyValuePairs('name:neymar, age:31 team:psg,nationality:brazil') AS kv

結果：

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

引用文字としてシングルクォート（'）を使用する場合:

SELECT extractKeyValuePairs('name:\'neymar\';\'age\':31;team:psg;nationality:brazil,last_key:last_value', ':', ';,', '\'') AS kv

結果：

┌─kv───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ {'name':'neymar','age':'31','team':'psg','nationality':'brazil','last_key':'last_value'}                                 │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

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

エスケープシーケンス（エスケープシーケンス非対応環境向け）:

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

結果：

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

toString でシリアライズされた map の文字列キーと値のペアを復元するには、次のようにします。

SELECT
    map('John', '33', 'Paula', '31') AS m,
    toString(m) AS map_serialized,
    extractKeyValuePairs(map_serialized, ':', ',', '\'') AS map_restored
FORMAT Vertical;

結果：

行 1:
──────
m:              {'John':'33','Paula':'31'}
map_serialized: {'John':'33','Paula':'31'}
map_restored:   {'John':'33','Paula':'31'}

extractKeyValuePairsWithEscaping

extractKeyValuePairs と同様ですが、エスケープシーケンスに対応しています。

サポートされるエスケープシーケンス: \x, \N, \a, \b, \e, \f, \n, \r, \t, \v, \0。標準的でないエスケープシーケンスは、次のいずれかの場合を除き、そのまま（バックスラッシュを含めて）返されます: \\, ', ", backtick, /, = または ASCII 制御文字 (c <= 31)。

この関数は、事前エスケープや事後エスケープでは対処できないユースケースに適しています。たとえば、次の入力文字列を考えます: a: "aaaa\"bbb"。期待される出力は: a: aaaa\"bbbb です。

事前エスケープ: 事前エスケープすると出力は a: "aaaa"bbb" となり、その後 extractKeyValuePairs は a: aaaa を出力します
事後エスケープ: extractKeyValuePairs は a: aaaa\ を出力し、事後エスケープではそれをそのまま保持します。

キー内の先頭のエスケープシーケンスはスキップされ、値に対しては無効とみなされます。

例

エスケープシーケンスのサポートを有効にした場合の動作例:

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

結果：

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

mapAdd

すべてのキーを集めて、それぞれに対応する値を合計します。

構文

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

引数

引数は、2 つの配列から構成されるmapまたはtupleであり、最初の配列の要素がキーを表し、2 番目の配列に各キーに対応する値が含まれます。すべてのキー配列は同じ型でなければならず、すべての値配列は 1 つの型（Int64、UInt64、または Float64）へと昇格可能な要素を含んでいる必要があります。共通の昇格後の型が、結果配列の型として使用されます。

戻り値

引数に応じて、最初の配列にソート済みのキーを含み、2 番目の配列に値を含む map または tuple を 1 つ返します。

例

Map 型を使ったクエリ:

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

結果：

┌─mapAdd(map(1, 1), map(1, 1))─┐
│ {1:2}                        │
└──────────────────────────────┘

タプルを用いたクエリ：

SELECT mapAdd(([toUInt8(1), 2], [1, 1]), ([toUInt8(1), 2], [1, 1])) AS res, toTypeName(res) AS type;

結果：

┌─res───────────┬─type───────────────────────────────┐
│ ([1,2],[2,2]) │ Tuple(Array(UInt8), Array(UInt64)) │
└───────────────┴────────────────────────────────────┘

mapSubtract

すべてのキーを集約し、対応する値の差を取ります。

構文

mapSubtract(Tuple(Array, Array), Tuple(Array, Array) [, ...])

引数

引数は 2 つの配列から構成される map または tuple であり、1 つ目の配列の要素がキーを表し、2 つ目の配列が各キーに対応する値を含みます。すべてのキー配列は同じ型である必要があり、すべての値配列は 1 つの共通の型（Int64、UInt64、または Float64）へ昇格される要素を含んでいる必要があります。この共通の昇格後の型が、結果配列の型として使用されます。

戻り値

引数に応じて 1 つの map または tuple を返し、1 つ目の配列にはソートされたキーが、2 つ目の配列には値が含まれます。

例

Map 型を使用したクエリ:

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

結果：

┌─mapSubtract(map(1, 1), map(1, 1))─┐
│ {1:0}                             │
└───────────────────────────────────┘

タプルマップを使用したクエリ：

SELECT mapSubtract(([toUInt8(1), 2], [toInt32(1), 1]), ([toUInt8(1), 2], [toInt32(2), 1])) AS res, toTypeName(res) AS type;

結果：

┌─res────────────┬─type──────────────────────────────┐
│ ([1,2],[-1,0]) │ Tuple(Array(UInt8), Array(Int64)) │
└────────────────┴───────────────────────────────────┘

mapPopulateSeries

整数キーを持つマップで、欠損しているキーと値のペアを補完します。最大値を超えてキーを拡張できるように、最大キーを指定することができます。より正確には、この関数は、キーが最小キーから最大キー（指定されていれば引数 max）までステップ幅 1 の数列を成し、それぞれに対応する値を持つマップを返します。あるキーに対して値が指定されていない場合、そのキーの値としてデフォルト値が使用されます。キーが重複している場合、そのキーには（出現順に）最初の値のみが対応付けられます。

構文

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

配列引数の場合、各行ごとに keys と values の要素数は同じでなければなりません。

Arguments

引数は Maps か、または 2 つの Arrays で、1 つ目と 2 つ目の配列にはそれぞれキーと、その各キーに対応する値が含まれます。

マップされた配列:

map — 整数キーを持つ Map。 Map。

または

keys — キーの配列。 Array(Int)。
values — 値の配列。 Array(Int)。
max — キーの最大値。省略可能。 Int8, Int16, Int32, Int64, Int128, Int256。

Returned value

引数に応じて、Map または 2 つの Arrays からなる Tuple が返されます。前者はソート済みのキー、後者はそれぞれのキーに対応する値です。

Example

Map 型を使ったクエリ:

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

結果：

┌─mapPopulateSeries(map(1, 10, 5, 20), 6)─┐
│ {1:10,2:0,3:0,4:0,5:20,6:0}             │
└─────────────────────────────────────────┘

マッピングされた配列に対するクエリ：

SELECT mapPopulateSeries([1,2,4], [11,22,44], 5) AS res, toTypeName(res) AS type;

結果：

┌─res──────────────────────────┬─type──────────────────────────────┐
│ ([1,2,3,4,5],[11,22,0,44,0]) │ Tuple(Array(UInt8), Array(UInt8)) │
└──────────────────────────────┴───────────────────────────────────┘

mapKeys

指定された map のキーを返します。

この関数は、setting optimize_functions_to_subcolumns を有効にすることで最適化できます。この setting を有効にすると、この関数は map 全体ではなく keys サブカラムだけを読み取ります。クエリ SELECT mapKeys(m) FROM table は SELECT m.keys FROM table に変換されます。

構文

mapKeys(map)

引数

map — マップ。Map。

返される値

map に含まれるすべてのキーを含む配列。Array。

例

クエリ：

CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;

INSERT INTO tab VALUES ({'name':'eleven','age':'11'}), ({'number':'twelve','position':'6.0'});

SELECT mapKeys(a) FROM tab;

結果:

┌─mapKeys(a)────────────┐
│ ['name','age']        │
│ ['number','position'] │
└───────────────────────┘

mapContains

指定したマップに指定したキーが含まれているかどうかを返します。

構文

mapContains(map, key)

エイリアス: mapContainsKey(map, key)

引数

map — マップ。Map。
key — キー。型は map のキー型と一致している必要があります。

返り値

map に key が含まれていれば 1、含まれていなければ 0。UInt8。

例

クエリ:

CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;

INSERT INTO tab VALUES ({'name':'eleven','age':'11'}), ({'number':'twelve','position':'6.0'});

SELECT mapContains(a, 'name') FROM tab;

結果：

┌─mapContains(a, 'name')─┐
│                      1 │
│                      0 │
└────────────────────────┘

mapContainsKeyLike

構文

mapContainsKeyLike(map, pattern)

引数

map — Map 型。Map。
pattern - マッチさせる文字列パターン。

戻り値

map が指定されたパターンにマッチする key を含む場合は 1、含まない場合は 0。

例

クエリ:

CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;

INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});

SELECT mapContainsKeyLike(a, 'a%') FROM tab;

結果：

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

mapExtractKeyLike

文字列キーを持つ Map と LIKE パターンが与えられると、この関数はキーがそのパターンに一致する要素のみを含む Map を返します。

構文

mapExtractKeyLike(map, pattern)

引数

map — Map 型。Map。
pattern - マッチさせる文字列パターン。

戻り値

指定したパターンに一致するキーを持つ要素のみを含む Map。一致する要素がない場合は、空の Map が返されます。

例

クエリ：

CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;

INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});

SELECT mapExtractKeyLike(a, 'a%') FROM tab;

結果：

┌─mapExtractKeyLike(a, 'a%')─┐
│ {'abc':'abc'}              │
│ {}                         │
└────────────────────────────┘

mapValues

指定された map の値を返します。

この関数は、設定 optimize_functions_to_subcolumns を有効にすることで最適化できます。この設定を有効にすると、関数は map 全体ではなく、values サブカラムのみを読み取ります。クエリ SELECT mapValues(m) FROM table は SELECT m.values FROM table に変換されます。

構文

mapValues(map)

引数

map — Map 型。Map。

戻り値

map に含まれるすべての値を格納した配列。Array。

例

クエリ：

CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;

INSERT INTO tab VALUES ({'name':'eleven','age':'11'}), ({'number':'twelve','position':'6.0'});

SELECT mapValues(a) FROM tab;

結果：

┌─mapValues(a)─────┐
│ ['eleven','11']  │
│ ['twelve','6.0'] │
└──────────────────┘

mapContainsValue

指定した map に指定したキーが含まれているかどうかを返します。

構文

mapContainsValue(map, value)

別名: mapContainsValue(map, value)

引数

map — マップ。Map。
value — 値。型は map の値の型と一致している必要があります。

戻り値

map に value が含まれていれば 1、含まれていなければ 0。UInt8。

例

クエリ:

CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;

INSERT INTO tab VALUES ({'name':'eleven','age':'11'}), ({'number':'twelve','position':'6.0'});

SELECT mapContainsValue(a, '11') FROM tab;

結果：

┌─mapContainsValue(a, '11')─┐
│                         1 │
│                         0 │
└───────────────────────────┘

mapContainsValueLike

構文

mapContainsValueLike(map, pattern)

引数

map — Map。 Map。
pattern - 照合する文字列パターン。

返り値

map に、指定したパターンにマッチする value が含まれていれば 1、含まれていなければ 0。

例

クエリ:

CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;

INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});

SELECT mapContainsValueLike(a, 'a%') FROM tab;

結果：

┌─mapContainsV⋯ke(a, 'a%')─┐
│                        1 │
│                        0 │
└──────────────────────────┘

mapExtractValueLike

文字列値を持つ Map と LIKE パターンを指定すると、この関数は値がパターンにマッチする要素のみを含む Map を返します。

構文

mapExtractValueLike(map, pattern)

引数

map — Map。Map。
pattern - 照合する文字列パターン。

返り値

値が指定したパターンに一致する要素を含む map。パターンに一致する要素がない場合は、空の map が返されます。

例

クエリ:

CREATE TABLE tab (a Map(String, String)) ENGINE = Memory;

INSERT INTO tab VALUES ({'abc':'abc','def':'def'}), ({'hij':'hij','klm':'klm'});

SELECT mapExtractValueLike(a, 'a%') FROM tab;

結果：

┌─mapExtractValueLike(a, 'a%')─┐
│ {'abc':'abc'}                │
│ {}                           │
└──────────────────────────────┘

mapApply

map の各要素に関数を適用します。

構文

mapApply(func, map)

引数

func — ラムダ関数。
map — Map。

返り値

各要素に対して func(map1[i], ..., mapN[i]) を適用することで、元のマップから得られるマップを返します。

例

クエリ:

SELECT mapApply((k, v) -> (k, v * 10), _map) AS r
FROM
(
    SELECT map('key1', number, 'key2', number * 2) AS _map
    FROM numbers(3)
)

結果：

┌─r─────────────────────┐
│ {'key1':0,'key2':0}   │
│ {'key1':10,'key2':20} │
│ {'key1':20,'key2':40} │
└───────────────────────┘

mapFilter

マップの各要素に関数を適用してフィルタリングします。

構文

mapFilter(func, map)

引数

func - ラムダ関数。
map — Map。

戻り値

func(map1[i], ..., mapN[i]) が 0 以外の値を返す要素のみを含む map を返します。

例

クエリ:

SELECT mapFilter((k, v) -> ((v % 2) = 0), _map) AS r
FROM
(
    SELECT map('key1', number, 'key2', number * 2) AS _map
    FROM numbers(3)
)

結果：

┌─r───────────────────┐
│ {'key1':0,'key2':0} │
│ {'key2':2}          │
│ {'key1':2,'key2':4} │
└─────────────────────┘

mapUpdate

構文

mapUpdate(map1, map2)

引数

map1 Map。
map2 Map。

戻り値

map2 の対応するキーの値で値を更新した map1 を返します。

例

クエリ:

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

結果:

┌─map────────────────────────────┐
│ {'key3':0,'key1':10,'key2':10} │
└────────────────────────────────┘

mapConcat

キーの一致に基づいて複数の map を連結します。同じキーを持つ要素が複数の入力 map に存在する場合、すべての要素が結果の map に追加されますが、[] 演算子でアクセスできるのは最初の要素のみです。

構文

mapConcat(maps)

引数

maps – 任意数のMap。

返される値

引数として渡された Map を連結した結果の Map を返します。

例

クエリ:

SELECT mapConcat(map('key1', 1, 'key3', 3), map('key2', 2)) AS map;

結果：

┌─map──────────────────────────┐
│ {'key1':1,'key3':3,'key2':2} │
└──────────────────────────────┘

クエリ：

SELECT mapConcat(map('key1', 1, 'key2', 2), map('key1', 3)) AS map, map['key1'];

結果：

┌─map──────────────────────────┬─elem─┐
│ {'key1':1,'key2':2,'key1':3} │    1 │
└──────────────────────────────┴──────┘

mapExists([func,], map)

map 内の少なくとも1つのキーと値のペアについて、func(key, value) が0以外を返す場合は1を返します。そうでない場合は0を返します。

注記

mapExists は高階関数です。第1引数としてラムダ関数を渡すことができます。

例

クエリ:

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

結果：

┌─res─┐
│   1 │
└─────┘

mapAll([func,] map)

map 内のすべてのキーと値のペアに対して func(key, value) が 0 以外の値を返す場合は 1 を返し、そうでない場合は 0 を返します。

注記

mapAll は高階関数です。第 1 引数としてラムダ関数を渡すことができます。

例

クエリ:

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

結果：

┌─res─┐
│   0 │
└─────┘

mapSort([func,], map)

map の要素を昇順に並べ替えます。 func 関数が指定されている場合、map のキーと値に func 関数を適用した結果によって並べ替え順が決定されます。

例

SELECT mapSort(map('key2', 2, 'key3', 1, 'key1', 3)) AS map;

┌─map──────────────────────────┐
│ {'key1':3,'key2':2,'key3':1} │
└──────────────────────────────┘

SELECT mapSort((k, v) -> v, map('key2', 2, 'key3', 1, 'key1', 3)) AS map;

┌─map──────────────────────────┐
│ {'key3':1,'key2':2,'key1':3} │
└──────────────────────────────┘

詳細については、arraySort 関数のリファレンスを参照してください。

mapPartialSort

map の要素を昇順にソートします。limit 引数によって部分ソートを指定できます。 func 関数が指定された場合、map のキーおよび値に func 関数を適用した結果に基づいてソート順が決定されます。

構文

mapPartialSort([func,] limit, map)

引数

func – map のキーと値に適用する任意の関数。Lambda function。
limit – 範囲 [1..limit] の要素がソートされます。(U)Int。
map – ソートする map。Map。

戻り値

部分的にソートされた map。Map。

例

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

┌─mapPartialSort(lambda(tuple(k, v), v), 2, map('k1', 3, 'k2', 1, 'k3', 2))─┐
│ {'k2':1,'k3':2,'k1':3}                                                    │
└───────────────────────────────────────────────────────────────────────────┘

mapReverseSort([func,], map)

マップの要素を降順にソートします。 func 関数が指定されている場合、マップのキーおよび値に func 関数を適用した結果に基づいてソートされます。

例

SELECT mapReverseSort(map('key2', 2, 'key3', 1, 'key1', 3)) AS map;

┌─map──────────────────────────┐
│ {'key3':1,'key2':2,'key1':3} │
└──────────────────────────────┘

SELECT mapReverseSort((k, v) -> v, map('key2', 2, 'key3', 1, 'key1', 3)) AS map;

┌─map──────────────────────────┐
│ {'key1':3,'key2':2,'key3':1} │
└──────────────────────────────┘

詳細は、関数 arrayReverseSort を参照してください。

mapPartialReverseSort

追加の limit 引数により、マップの要素を降順に部分ソートします。 func 関数が指定されている場合は、マップのキーおよび値に func 関数を適用した結果に基づいてソート順が決定されます。

構文

mapPartialReverseSort([func,] limit, map)

引数

func – map のキーと値に適用する任意の関数。Lambda 関数。
limit – 範囲 [1..limit] 内の要素をソートします。(U)Int。
map – ソート対象の map。Map。

戻り値

部分的にソートされた map。Map。

例

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

┌─mapPartialReverseSort(lambda(tuple(k, v), v), 2, map('k1', 3, 'k2', 1, 'k3', 2))─┐
│ {'k1':3,'k3':2,'k2':1}                                                           │
└──────────────────────────────────────────────────────────────────────────────────┘

extractKeyValuePairs

導入バージョン: v

任意の文字列からキーと値のペアを抽出します。文字列は 100% キー・バリュー形式で構造化されている必要はありません。

ノイズ（例: ログファイル）を含んでいても問題ありません。解釈対象となるキー・バリュー形式は、関数の引数で指定する必要があります。

キーと値のペアは、キーに続いて key_value_delimiter と値が並ぶ形で構成されます。引用符付きのキーおよび値にも対応しています。キーと値のペア同士は、ペア区切り文字で区切られている必要があります。

構文

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

引数

data - キーと値のペアを抽出する対象の文字列。String または FixedString。
- key_value_delimiter - キーと値の間の区切り文字として使用する文字。デフォルトは :。型は String または FixedString。
- pair_delimiters - ペア間の区切り文字として使用する文字の集合。デフォルトは \space、,、;。型は String または FixedString。
- quoting_character - クオート文字として使用する文字。デフォルトは ". 型は String または FixedString。
- unexpected_quoting_character_strategy - read_key および read_value フェーズ中に想定外の位置に現れたクオート文字を処理するための戦略。指定可能な値: invalid、accept、promote。invalid はキー/値を破棄して WAITING_KEY 状態に戻ります。accept は通常の文字として扱います。promote は READ_QUOTED_{KEY/VALUE} 状態へ遷移し、次の文字から処理を開始します。デフォルト値は INVALID です。

戻り値

抽出されたキーと値のペアを Map(String, String) 型のマップとして返します。

例

クエリ:

単純な例

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

引用文字としての単一引用符

            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

            クエリ ID: 0e22bf6b-9844-414a-99dc-32bf647abd5e

            ┌─kv───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
            │ {'name':'neymar','age':'31','team':'psg','nationality':'brazil','last_key':'last_value'}                                 │
            └──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

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

エスケープシーケンス非対応環境でのエスケープ

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

構文

別名: str_to_map, mapFromString

引数

なし。

戻り値

例

extractKeyValuePairsWithEscaping

導入バージョン: v

extractKeyValuePairs と同じですが、エスケープシーケンスに対応しています。

サポートされるエスケープシーケンス: \x, \N, \a, \b, \e, \f, \n, \r, \t, \v, \0。標準外のエスケープシーケンスは、次のいずれかに該当しない限り、そのまま（バックスラッシュを含めて）返されます: \\, ', ", backtick, /, = または ASCII 制御文字 (c <= 31)。

この関数は、事前エスケープおよび事後エスケープが適さないユースケースに適しています。例えば、次の入力文字列を考えます: a: "aaaa\"bbb"。期待される出力は a: aaaa\"bbbb です。

事前エスケープ: 事前エスケープすると、出力は a: "aaaa"bbb" となり、その後 extractKeyValuePairs は a: aaaa を出力します。
- 事後エスケープ: extractKeyValuePairs は a: aaaa\ を出力し、事後エスケープを行ってもそのまま保持されます。

先頭のエスケープシーケンスはキーではスキップされ、値に対しては不正とみなされます。

エスケープシーケンス対応が有効な場合のエスケープシーケンス

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

構文

引数

なし。

戻り値

例

map

導入バージョン: v21.1

キーと値のペアから、Map(key, value) 型の値を作成します。

構文

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

引数

key_n — マップエントリのキー。Any
value_n — マップエントリの値。Any

返り値

キーと値のペアを含むマップを返します。Map(Any, Any)

例

使用例

SELECT map('key1', number, 'key2', number * 2) FROM numbers(3)

{'key1':0,'key2':0}
{'key1':1,'key2':2}
{'key1':2,'key2':4}

mapAdd

導入バージョン: v20.7

すべてのキーを集約し、それぞれのキーに対応する値を合計します。

構文

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

引数

arg1[, arg2, ...] — 2 つの配列からなる Map またはタプルであり、1 つ目の配列の要素がキー、2 つ目の配列の要素が各キーに対応する値になります。Map(K, V) または Tuple(Array(T), Array(T))

戻り値

Map またはタプルを返します。1 つ目の配列にはソート済みのキーが含まれ、2 つ目の配列には対応する値が含まれます。Map(K, V) または Tuple(Array(T), Array(T))

例

Map 型での使用例

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

{1:2}

タプルを使用する場合

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

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

mapAll

導入バージョン: v23.4

マップ内のすべてのキーと値のペアに対して、ある条件が成り立つかどうかを判定します。 mapAll は高階関数です。第1引数としてラムダ関数を渡すことができます。

構文

mapAll([func,] map)

引数

func — ラムダ関数。Lambda function
map — 検査対象のマップ。Map(K, V)

返り値

すべてのキーと値のペアが条件を満たす場合は 1、それ以外の場合は 0 を返します。UInt8

例

使用例

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

mapApply

導入バージョン: v22.3

関数を map の各要素に適用します。

構文

mapApply(func, map)

引数

func — ラムダ関数。Lambda function
map — 関数を適用する対象の Map。Map(K, V)

戻り値

元の Map の各要素に func を適用して得られる新しい Map を返します。Map(K, V)

例

使用例

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

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

mapConcat

導入バージョン: v23.4

複数の map を、そのキーの等値性に基づいて連結します。同じキーを持つ要素が複数の入力 map に存在する場合、すべての要素が結果の map に追加されますが、演算子 [] で参照できるのは最初の要素のみです。

構文

mapConcat(maps)

引数

maps — 任意個の Map。Map

返り値

引数として渡された Map を連結した Map を返します。Map

例

使用例

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

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

mapContainsKey

導入バージョン: v21.2

マップにキーが含まれているかどうかを判定します。

構文

mapContains(map, key)

エイリアス: mapContains

引数

map — 検索対象のマップ。Map(K, V)
key — 検索するキー。型はマップのキー型と一致している必要があります。Any

戻り値

マップにキーが含まれていれば 1、含まれていなければ 0 を返します。UInt8

例

使用例

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

mapContainsKeyLike

導入バージョン: v23.4

マップに、LIKE で指定したパターンに一致するキーが含まれているかを判定します。

構文

mapContainsKeyLike(map, pattern)

引数

map — 検索対象のマップ。Map(K, V)
pattern — キーと照合するパターン。const String

戻り値

map に pattern に一致するキーが含まれていれば 1、そうでなければ 0 を返します。UInt8

例

使用例

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

導入バージョン: v25.6

マップに指定した値が含まれているかどうかを判定します。

構文

mapContainsValue(map, value)

引数

map — 検索対象のマップ。Map(K, V)
value — 検索する値。型は map の値の型と一致している必要があります。Any

戻り値

map に値が含まれていれば 1、含まれていなければ 0 を返します。UInt8

例

使用例

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

mapContainsValueLike

導入バージョン: v25.5

マップに、指定したパターンに対して LIKE マッチする値が含まれているかをチェックします。

構文

mapContainsValueLike(map, pattern)

引数

map — 検索対象のマップ。Map(K, V)
pattern — 値と照合するパターン。const String

戻り値

map に pattern と一致する値が含まれている場合は 1、それ以外は 0 を返します。UInt8

例

使用例

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;

┌─mapContainsV⋯ke(a, 'a%')─┐
│                        1 │
│                        0 │
└──────────────────────────┘

mapExists

導入バージョン: v23.4

マップ内の少なくとも 1 つのキーと値のペアについて、条件が成り立つかどうかをテストします。 mapExists は高階関数です。第 1 引数としてラムダ関数を渡すことができます。

構文

mapExists([func,] map)

引数

func — 省略可能。ラムダ関数。Lambda function
map — チェック対象のマップ。Map(K, V)

返される値

少なくとも 1 つのキーと値の組が条件を満たす場合は 1 を返し、それ以外の場合は 0 を返します。UInt8

例

使用例

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

mapExtractKeyLike

導入: v23.4

文字列キーを持つ map と LIKE パターンを引数に取り、この関数はキーがそのパターンにマッチする要素のみを含む map を返します。

構文

mapExtractKeyLike(map, pattern)

引数

map — 抽出元となるマップ。Map(K, V)
pattern — キーと照合するためのパターン。const String

戻り値

キーが指定したパターンにマッチする要素のみを含むマップを返します。パターンに一致する要素がない場合は、空のマップを返します。Map(K, V)

例

使用例

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

導入バージョン: v25.5

文字列値を持つマップと LIKE パターンを指定すると、この関数は値がそのパターンに一致する要素のみを含むマップを返します。

構文

mapExtractValueLike(map, pattern)

引数

map — 抽出対象とするマップ。Map(K, V)
pattern — 値と照合するパターン。const String

戻り値

指定したパターンにマッチする値を持つ要素だけを含むマップを返します。パターンにマッチする要素がない場合は、空のマップが返されます。Map(K, V)

例

使用例

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

導入バージョン: v22.3

マップの各要素に関数を適用し、その結果に基づいてマップをフィルタリングします。

構文

mapFilter(func, map)

引数

func — ラムダ関数。Lambda function
map — フィルタ対象の Map。Map(K, V)

戻り値

func が 0 以外の値を返す要素だけを含む Map を返します。Map(K, V)

例

使用例

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

{'k2':2}

mapFromArrays

v23.3 で導入。

キーの配列（またはマップ）と値の配列（またはマップ）からマップを作成します。この関数は、構文 CAST([...], 'Map(key_type, value_type)') の便利な代替手段です。

構文

mapFromArrays(keys, values)

別名: MAP_FROM_ARRAYS

引数

keys — マップを作成するためのキーの配列またはマップ。Array または Map
values — マップを作成するための値の配列またはマップ。Array または Map

戻り値

キー配列および値の配列/マップから構成されるキーと値を持つマップを返します。Map

例

基本的な使い方

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

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

map 型を入力とする場合

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

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

mapKeys

導入バージョン: v21.2

指定されたマップのキーを返します。この関数は、設定 optimize_functions_to_subcolumns を有効にすることで最適化できます。この設定を有効にすると、関数はマップ全体ではなく keys サブカラムだけを読み取ります。クエリ SELECT mapKeys(m) FROM table は SELECT m.keys FROM table に変換されます。

構文

mapKeys(map)

引数

map — キーを抽出する対象のマップ。Map(K, V)

戻り値

マップ内のすべてのキーを含む配列を返します。Array(T)

例

使用例

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

['k1','k2']

mapPartialReverseSort

導入バージョン: v23.4

map の要素を降順にソートし、追加の limit 引数によって先頭の一部だけをソートできます。 func 関数が指定されている場合、map のキーと値に func 関数を適用した結果に基づいてソート順が決まります。

構文

mapPartialReverseSort([func,] limit, map)

引数

func — 省略可能。ラムダ関数。Lambda function
limit — 範囲 [1..limit] 内の要素がソートされます。(U)Int*
map — ソート対象のマップ。Map(K, V)

返される値

降順で部分的にソートされたマップを返します。Map(K, V)

例

使用例

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

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

mapPartialSort

導入バージョン: v23.4

map の要素を昇順にソートします。追加の limit 引数を指定することで、一部のみを対象とした「部分ソート」が可能です。 func 関数が指定されている場合は、map のキーおよび値に func 関数を適用した結果に基づいてソート順が決定されます。

構文

mapPartialSort([func,] limit, map)

引数

func — 省略可能。Lambda 関数。Lambda function
limit — 範囲 [1..limit] 内の要素がソートされます。(U)Int*
map — ソート対象の Map。Map(K, V)

戻り値

部分的にソートされた Map を返します。Map(K, V)

例

使用例

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

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

mapPopulateSeries

導入バージョン: v20.10

整数キーを持つマップにおいて、欠けているキーと値のペアを補完します。既存の最大値より大きいキーも拡張できるように、最大キーを指定できます。より正確には、この関数は、キーが最小キーから最大キー（指定されている場合は max 引数）までステップ幅 1 の数列を形成し、それに対応する値を持つマップを返します。あるキーに値が指定されていない場合、そのキーの値としてデフォルト値が使用されます。キーが重複している場合、先に出現した値のみがそのキーに関連付けられます。

構文

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

引数

map — 整数キーを持つ Map 型。Map((U)Int*, V)
keys — キーの配列。Array(T)
values — 値の配列。Array(T)
max — オプション。キーの最大値を指定します。Int8 または Int16 または Int32 または Int64 または Int128 または Int256

返される値

ソート済みのキーを持つ Map、または 1 つ目にソート済みのキー、2 つ目に対応する値を持つ 2 つの配列からなるタプルを返します。Map(K, V) または Tuple(Array(UInt*), Array(Any))

例

Map 型を使用する場合

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

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

マップされた配列を使う場合

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

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

mapReverseSort

導入バージョン: v23.4

map の要素を降順に並べ替えます。 func 関数が指定されている場合、map のキーおよび値に func 関数を適用した結果によってソート順が決まります。

構文

mapReverseSort([func,] map)

引数

func — オプションのラムダ関数。Lambda function
map — ソート対象のマップ。Map(K, V)

戻り値

降順にソートされたマップを返します。Map(K, V)

例

使用例

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

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

mapSort

Introduced in: v23.4

マップの要素を昇順で並べ替えます。 func 関数が指定されている場合、マップのキーと値に func 関数を適用した結果によってソート順が決まります。

構文

mapSort([func,] map)

引数

func — 任意。ラムダ関数。Lambda function
map — ソート対象のマップ。Map(K, V)

戻り値

昇順にソートされたマップを返します。Map(K, V)

例

使用例

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

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

mapSubtract

導入バージョン: v20.7

すべてのキーを取得し、対応する値同士の差を計算します。

構文

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

引数

arg1[, arg2, ...] — 2 つの配列からなる Map またはタプル。1 つ目の配列の要素がキーを表し、2 つ目の配列には各キーに対応する値が含まれます。Map(K, V) または Tuple(Array(T), Array(T))

戻り値

戻り値は 1 つの Map またはタプルで、1 つ目の配列にはソート済みのキーが含まれ、2 つ目の配列には値が含まれます。Map(K, V) または Tuple(Array(T), Array(T))

例

Map 型の場合

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

{1:0}

タプルマップを使用する場合

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

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

mapUpdate

導入バージョン: v22.3

2つのマップを受け取り、2つ目のマップの対応するキーの値で値を更新した1つ目のマップを返します。

構文

mapUpdate(map1, map2)

引数

map1 — 更新対象のマップ。Map(K, V)
map2 — 更新に使用するマップ。Map(K, V)

返される値

map2 に含まれる同じキーの値で更新された map1 を返します。Map(K, V)

使用例

基本的な使い方

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

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

mapValues

導入バージョン: v21.2

指定された map の値を返します。この関数は、optimize_functions_to_subcolumns の設定を有効にすることで最適化できます。設定を有効にすると、この関数は map 全体ではなく values サブカラムのみを読み取ります。クエリ SELECT mapValues(m) FROM table は SELECT m.values FROM table に変換されます。

構文

mapValues(map)

引数

map — 値を抽出する対象のマップ。Map(K, V)

戻り値

マップ内のすべての値を含む配列を返します。Array(T)

例

使用例

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

['v1','v2']

map​

mapFromArrays​

extractKeyValuePairs​

extractKeyValuePairsWithEscaping​

mapAdd​

mapSubtract​

mapPopulateSeries​

mapKeys​

mapContains​

mapContainsKeyLike​

mapExtractKeyLike​

mapValues​

mapContainsValue​

mapContainsValueLike​

mapExtractValueLike​

mapApply​

mapFilter​

mapUpdate​

mapConcat​

mapExists([func,], map)​

mapAll([func,] map)​

mapSort([func,], map)​

mapPartialSort​

mapReverseSort([func,], map)​

mapPartialReverseSort​

extractKeyValuePairs​

extractKeyValuePairsWithEscaping​

map​

mapAdd​

mapAll​

mapApply​

mapConcat​

mapContainsKey​

mapContainsKeyLike​

mapContainsValue​

mapContainsValueLike​

mapExists​

mapExtractKeyLike​

mapExtractValueLike​

mapFilter​

mapFromArrays​

mapKeys​

mapPartialReverseSort​

mapPartialSort​

mapPopulateSeries​

mapReverseSort​

mapSort​

mapSubtract​

mapUpdate​

mapValues​

map

mapFromArrays

extractKeyValuePairs

extractKeyValuePairsWithEscaping

mapAdd

mapSubtract

mapPopulateSeries

mapKeys

mapContains

mapContainsKeyLike

mapExtractKeyLike

mapValues

mapContainsValue

mapContainsValueLike

mapExtractValueLike

mapApply

mapFilter

mapUpdate

mapConcat

mapExists([func,], map)

mapAll([func,] map)

mapSort([func,], map)

mapPartialSort

mapReverseSort([func,], map)

mapPartialReverseSort

extractKeyValuePairs

extractKeyValuePairsWithEscaping

map

mapAdd

mapAll

mapApply

mapConcat

mapContainsKey

mapContainsKeyLike

mapContainsValue

mapContainsValueLike

mapExists

mapExtractKeyLike

mapExtractValueLike

mapFilter

mapFromArrays

mapKeys

mapPartialReverseSort

mapPartialSort

mapPopulateSeries

mapReverseSort

mapSort

mapSubtract

mapUpdate

mapValues