30 KiB
| slug | sidebar_position | sidebar_label |
|---|---|---|
| /ja/sql-reference/functions/tuple-map-functions | 120 | マップ |
map
キーと値のペアからMap(key, value)型の値を作成します。
構文
map(key1, value1[, key2, value2, ...])
引数
返される値
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
キーの配列またはマップと値の配列またはマップからマップを作成します。
この関数は、構文 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)
別名: 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]]])
別名:
str_to_mapmapFromString
引数
data- キーと値のペアを抽出するための文字列。String または FixedString。key_value_delimiter- キーと値を区切る単一文字。デフォルトは:。String または FixedString。pair_delimiters- ペアを区切る文字のセット。デフォルトは,および;。String または FixedString。quoting_character- 引用符として使う単一文字。デフォルトは"。String または FixedString。
返される値
- キーと値のペア。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'} │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
エスケープシーケンスをサポートしない場合:
SELECT extractKeyValuePairs('age:a\\x0A\\n\\0') AS kv
結果:
┌─kv─────────────────────┐
│ {'age':'a\\x0A\\n\\0'} │
└────────────────────────┘
toStringでシリアライズされたマップ文字列のキーと値のペアを復元するには:
SELECT
map('John', '33', 'Paula', '31') AS m,
toString(m) as map_serialized,
extractKeyValuePairs(map_serialized, ':', ',', '\'') AS map_restored
FORMAT Vertical;
結果:
Row 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つの配列のタプルまたはマップで、最初の配列のアイテムがキーを表し、2つ目の配列が各キーの値を含みます。すべてのキー配列は同じ型を持ち、すべての値配列は、1つの型 (Int64、UInt64 または Float64) に昇格される項目を含む必要があります。共通の昇格型が結果配列の型として使用されます。
返される値
例
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つの配列のタプルまたはマップで、最初の配列のアイテムがキーを表し、2つ目の配列が各キーの値を含みます。すべてのキー配列は同じ型を持ち、すべての値配列は、1つの型 (Int64、UInt64 または Float64) に昇格される項目を含む必要があります。共通の昇格型が結果配列の型として使用されます。
返される値
例
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 の各行内の要素数は同じである必要があります。
引数
引数は、整数キーを持つマップまたは2つの配列で、最初と2番目の配列が各キーのキーと値を含みます。
マップされた配列:
map— 整数キーを持つマップ。Map。
または
keys— キーの配列。Array(Int)。values— 値の配列。Array(Int)。max— 最大キー値。オプション。Int8, Int16, Int32, Int64, Int128, Int256。
返される値
例
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)) │
└──────────────────────────────┴───────────────────────────────────┘
mapContains
指定されたキーが指定されたマップに含まれているかどうかを返します。
構文
mapContains(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 │
└────────────────────────┘
mapKeys
指定されたマップのキーを返します。
この関数は、設定 optimize_functions_to_subcolumns を有効にすることで最適化できます。
設定を有効にすると、関数はマップ全体の代わりに 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'] │
└───────────────────────┘
mapValues
指定されたマップの値を返します。
この関数は、設定 optimize_functions_to_subcolumns を有効にすることで最適化できます。
設定を有効にすると、関数はマップ全体の代わりに values サブカラムのみを読み取ります。
クエリ SELECT mapValues(m) FROM table は SELECT m.values FROM table に変換されます。
構文
mapValues(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'] │
└──────────────────┘
mapContainsKeyLike
構文
mapContainsKeyLike(map, pattern)
引数
map— マップ。Map。pattern- マッチングする文字列パターン。
返される値
- 指定したパターンにマッチする
keyがmapに含まれている場合は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
文字列キーを持つマップとLIKEパターンを与えると、この関数はキーがパターンと一致する要素を持つマップを返します。
構文
mapExtractKeyLike(map, pattern)
引数
map— マップ。Map。pattern- マッチングする文字列パターン。
返される値
- 指定したパターンに一致するキーを持つ要素を含むマップ。一致する要素がない場合は、空のマップが返されます。
例
クエリ:
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'} │
│ {} │
└────────────────────────────┘
mapApply
マップの各要素に関数を適用します。
構文
mapApply(func, 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(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)
引数
返される値
- map2の対応キーに対する値が更新されたmap1を返します。
例
クエリ:
SELECT mapUpdate(map('key1', 0, 'key3', 0), map('key1', 10, 'key2', 10)) AS map;
結果:
┌─map────────────────────────────┐
│ {'key3':0,'key1':10,'key2':10} │
└────────────────────────────────┘
mapConcat
キーの等価性に基づいて複数のマップを連結します。
同じキーを持つ要素が複数の入力マップに存在する場合、すべての要素が結果マップに追加されますが、演算子 [] を介してアクセスできるのは最初の要素だけです。
構文
mapConcat(maps)
引数
maps– 任意の数のマップ。
返される値
- 引数として渡されたマップを連結したマップを返します。
例
クエリ:
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を返します。
:::note
mapExists は 高次関数です。
最初の引数としてラムダ関数を渡すことができます。
:::
例
クエリ:
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を返します。
:::note
mapAll は 高次関数です。
最初の引数としてラムダ関数を渡すことができます。
:::
例
クエリ:
SELECT mapAll((k, v) -> (v = 1), map('k1', 1, 'k2', 2)) AS res
結果:
┌─res─┐
│ 0 │
└─────┘
mapSort([func,], map)
マップの要素を昇順にソートします。
func 関数が指定された場合、マップのキーと値に適用された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
部分的なソートを許可する limit 引数を追加して、昇順にマップの要素をソートします。
func 関数が指定された場合、マップのキーと値に適用されたfunc関数の結果によってソート順が決まります。
構文
mapPartialSort([func,] limit, 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)
引数
返される値
- 部分的にソートされたマップ。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} │
└──────────────────────────────────────────────────────────────────────────────────┘