Map 函数

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

Query 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 — Map 条目的键。 Any
value_n — Map 条目的值。 Any

返回值

返回包含键:value对的 map。 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, ...] — Map 或两个数组的元组，其中第一个数组中的项目表示键，第二个数组包含每个键的值。 Map(K, V) 或 Tuple(Array(T), Array(T))

返回值

返回一个 map 或返回一个元组，其中第一个数组包含排序后的键，第二个数组包含值。 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

测试条件是否适用于 map 中的所有键值对。 mapAll 是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。

语法

mapAll([func,] map)

参数

func — Lambda 函数。 Lambda function
map — 要检查的 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 函数。 Lambda function
map — 要应用函数的 map。 Map(K, V)

返回值

返回通过将 func 应用于 map 的每个元素而从原始 map 获得的新 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

确定键是否包含在 map 中。

语法

mapContains(map, key)

别名：mapContains

参数

map — 要搜索的 map。 Map(K, V)
key — 要搜索的键。类型必须与 map 的键类型匹配。 Any

返回值

如果 map 包含键，则返回 1，否则返回 0。 UInt8

示例

使用示例

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

mapContainsKeyLike

引入于：v23.4

检查 map 是否包含与指定模式 LIKE 的键。

语法

mapContainsKeyLike(map, pattern)

参数

map — 要搜索的 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

确定值是否包含在 map 中。

语法

mapContainsValue(map, value)

参数

map — 要搜索的 map。 Map(K, V)
value — 要搜索的值。类型必须与 map 的值类型匹配。 Any

返回值

如果 map 包含该值，则返回 1，否则返回 0。 UInt8

示例

使用示例

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

mapContainsValueLike

引入于：v25.5

检查 map 是否包含与指定模式 LIKE 的值。

语法

mapContainsValueLike(map, pattern)

参数

map — 要搜索的 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

测试条件是否适用于 map 中的至少一个键值对。 mapExists 是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。

语法

mapExists([func,] map)

参数

func — 可选。Lambda 函数。 Lambda function
map — 要检查的 map。 Map(K, V)

返回值

如果至少一个键值对满足条件，则返回 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。 Map(K, V)
pattern — 用于匹配键的模式。 const String

返回值

返回一个包含键与指定模式匹配的元素的 map。如果没有任何元素与模式匹配，则返回一个空 map。 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

给定一个具有字符串值的 map 和 LIKE 模式，此函数返回一个值与模式匹配的 map。

语法

mapExtractValueLike(map, pattern)

参数

map — 要提取的 map。 Map(K, V)
pattern — 用于匹配值的模式。 const String

返回值

返回一个包含值与指定模式匹配的元素的 map。如果没有任何元素与模式匹配，则返回一个空 map。 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

通过将函数应用于 map 的每个元素来过滤 map。

语法

mapFilter(func, map)

参数

func — Lambda 函数。 Lambda function
map — 要过滤的 map。 Map(K, V)

返回值

返回一个包含 map 中 func 返回非 0 值的元素的 map。 Map(K, V)

示例

使用示例

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

{'k2':2}

mapFromArrays

引入于: v23.3

从键数组或 map 和值数组或 map 创建 map。该函数是语法 CAST([...], 'Map(key_type, value_type)') 的便捷替代方案。

语法

mapFromArrays(keys, values)

别名：MAP_FROM_ARRAYS

参数

keys — 用于创建 map 的键数组或 map。 Array 或 Map
values — 用于创建 map 的值数组或 map。 Array 或 Map

返回值

返回一个使用键数组和值数组/map 构建的 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

返回给定 map 的键。通过启用设置 optimize_functions_to_subcolumns 可以优化此函数。启用该设置后，该函数仅读取 keys 子列而不是整个 map。查询 SELECT mapKeys(m) FROM table 将转换为 SELECT m.keys FROM table。

语法

mapKeys(map)

参数

map — 要提取键的 map。 Map(K, V)

返回值

返回包含 map 中所有键的数组。 Array(T)

示例

使用示例

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

['k1','k2']

mapPartialReverseSort

引入于：v23.4

按降序对 map 的元素进行排序，并带有允许部分排序的限制参数。如果指定了 func 函数，则排序顺序由应用于 map 的键和值的 func 函数的结果确定。

语法

mapPartialReverseSort([func,] limit, map)

参数

func — 可选。Lambda 函数。 Lambda function
limit — 范围 [1..limit] 中的元素进行排序。 (U)Int*
map — 要排序的 Map。 Map(K, V)

返回值

返回降序部分排序的 Map。 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 函数，则排序顺序由将 func 函数应用于 Map 的键和值的结果确定。

语法

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

使用整数键填充 Map 中缺失的键值对。为了支持超出最大值的键扩展，可以指定最大键。更具体地说，该函数返回一个 Map，其中键从最小键到最大键（或如果指定了 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 或两个数组的元组，其中第一个数组包含排序后的键，第二个数组包含相应键的值。 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 函数，则排序顺序由将 func 函数应用于 Map 的键和值的结果确定。

语法

mapReverseSort([func,] map)

参数

func — 可选。Lambda 函数。 Lambda function
map — 要排序的 Map。 Map(K, V)

返回值

返回降序排序的 Map。 Map(K, V)

示例

使用示例

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

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

mapSort

引入于：v23.4

对 Map 的元素进行升序排序。如果指定了 func 函数，则排序顺序由将 func 函数应用于 Map 的键和值的结果确定。

语法

mapSort([func,] map)

参数

func — 可选。Lambda 函数。 Lambda function
map — 要排序的 Map。 Map(K, V)

返回值

返回升序排序的 Map。 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, ...] — Map 或两个数组的元组，其中第一个数组中的项目表示键，第二个数组包含每个键的值。 Map(K, V) 或 Tuple(Array(T), Array(T))

返回值

返回一个 Map 或元组，其中第一个数组包含排序后的键，第二个数组包含值。 Map(K, V) 或 Tuple(Array(T), Array(T))

示例

使用 Map 类型

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

{1:0}

使用元组 Map

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

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

mapUpdate

引入于：v22.3

对于两个 Map，返回第一个 Map，其值已根据第二个 Map 中相应键的值进行更新。

语法

mapUpdate(map1, map2)

参数

map1 — 要更新的 Map。 Map(K, V)
map2 — 用于更新的 Map。 Map(K, V)

返回值

返回 map1，其值已根据 map2 中相应键的值进行更新。 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 可以优化此函数。启用该设置后，该函数仅读取 values 子列，而不是整个 Map。查询 SELECT mapValues(m) FROM table 将转换为 SELECT m.values FROM table。

语法

mapValues(map)

参数

map — 要提取值的 Map。 Map(K, V)

返回值

返回包含 Map 中所有值的数组。 Array(T)

示例

使用示例

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

['v1','v2']

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​

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