Функции Map

​

extractKeyValuePairs

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

• 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} и начинает со следующего символа. Значение по умолчанию — PROMOTE

• Извлечённые пары «ключ-значение» в Map(String, String).

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

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

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

SELECT extractKeyValuePairs('name"abc:5', ':', ' ,;', '\"', 'INVALID') AS kv;

┌─kv────────────────┐
│ {'abc':'5'}       │
└───────────────────┘

SELECT extractKeyValuePairs('name"abc":5', ':', ' ,;', '\"', 'INVALID') AS kv;

┌─kv──┐
│ {}  │
└─────┘

SELECT extractKeyValuePairs('name"abc:5', ':', ' ,;', '\"', 'ACCEPT') AS kv;

┌─kv────────────────┐
│ {'name"abc':'5'}  │
└───────────────────┘

SELECT extractKeyValuePairs('name"abc":5', ':', ' ,;', '\"', 'ACCEPT') AS kv;

┌─kv─────────────────┐
│ {'name"abc"':'5'}  │
└────────────────────┘

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

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

• Отсутствуют.

​

extractKeyValuePairsWithEscaping

• Предварительное экранирование: в этом случае результат будет таким: a: "aaaa"bbb", а затем extractKeyValuePairs вернет: a: aaaa
• Последующее экранирование: extractKeyValuePairs вернет a: aaaa\, а последующее экранирование оставит это без изменений.

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

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

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

• Отсутствуют.

​

map

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

• key_n — Ключи элементов типа Map. Any
• value_n — Значения элементов типа Map. Any

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

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

​

mapAdd

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

• arg1[, arg2, ...] — объекты типа Map или Tuple из двух массивов, в которых элементы первого массива представляют ключи, а второй массив содержит значения для каждого ключа. Map(K, V) или Tuple(Array(T), Array(T))

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

mapAll([func,] map)

• func — лямбда-функция. лямбда-функция
• map — проверяемый Map. Map(K, V)

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

0

​

mapApply

mapApply(func, map)

• func — Лямбда-функция. Лямбда-функция
• map — Map, к которому нужно применить функцию. Map(K, V)

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

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

​

mapConcat

mapConcat(maps)

• maps — Произвольное количество значений типа Map. Map

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

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

​

mapContainsKey

mapContainsKey(map, key)

• map — Объект Map, в котором выполняется поиск. Map(K, V)
• key — Ключ, который нужно найти. Тип должен совпадать с типом ключа в Map. Any

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

1

​

mapContainsKeyLike

mapContainsKeyLike(map, pattern)

• map — Map, в котором выполняется поиск. Map(K, V)
• pattern — Шаблон регулярного выражения, с которым сопоставляются ключи. const String

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

​

mapContainsKeyValue

mapContainsKeyValue(map, key, value)

• map — Map, в котором выполняется поиск. Map(K, V)
• key — Искомый ключ. Тип должен совпадать с типом ключей Map. Any
• value — Искомое значение. Тип должен совпадать с типом значений Map. Any

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

1

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

0

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

1	0

​

mapContainsValue

mapContainsValue(map, value)

• map — Map, в которой выполняется поиск. Map(K, V)
• value — Искомое значение. Тип должен совпадать с типом значений в map. Any

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

1

​

mapContainsValueLike

mapContainsValueLike(map, pattern)

• map — Map, в которой выполняется поиск. Map(K, V)
• pattern — Шаблон регулярного выражения для сопоставления со значениями. const String

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

​

mapEntries

mapEntries(map)

• map — Map, из которого извлекаются записи. Map(K, V)

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

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

​

mapExists

mapExists([func,] map)

• func — Необязательный. Лямбда-функция. лямбда-функция
• map — Проверяемое значение типа Map. Map(K, V)

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

1

​

mapExtractKeyLike

mapExtractKeyLike(map, pattern)

• map — Map, из которого извлекаются данные. Map(K, V)
• pattern — Шаблон регулярного выражения, с которым сопоставляются ключи. const String

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

mapExtractValueLike(map, pattern)

• map — Map, из которого извлекаются данные. Map(K, V)
• pattern — Шаблон регулярного выражения для сопоставления со значениями. const String

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

mapFilter(func, map)

• func — лямбда-функция. лямбда-функция
• map — Map, который нужно отфильтровать. Map(K, V)

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

{'k2':2}

​

mapFromArrays

mapFromArrays(keys, values)

• keys — Массив или Map ключей, из которых создаётся карта. Array или Map
• values — Массив или Map значений, из которых создаётся карта. Array или Map

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

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

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

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

​

mapKeys

mapKeys(map)

• map — Map, из которого извлекаются ключи. Map(K, V)

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

['k1','k2']

​

mapPartialReverseSort

mapPartialReverseSort([func,] limit, map)

• func — Необязательный параметр. Лямбда-функция. Лямбда-функция
• limit — Сортируются элементы в диапазоне [1..limit]. (U)Int*
• map — Сортируемый Map. Map(K, V)

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

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

​

mapPartialSort

mapPartialSort([func,] limit, map)

• func — Необязательный. Лямбда-функция. лямбда-функция
• limit — Сортируются элементы в диапазоне [1..limit]. (U)Int*
• map — Сортируемое значение типа Map. Map(K, V)

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

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

​

mapPopulateSeries

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

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])

​

mapRemove

mapRemove(map, key)

• map — Map, из которого удаляются записи с совпадающим ключом. Map(K, V)
• key — ключ, записи с которым удаляются. Его тип должен быть сопоставим с типом ключей Map. Any

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

{'k2':2}

​

mapReverseSort

mapReverseSort([func,] map)

• func — Необязательный. Лямбда-функция. Лямбда-функция
• map — Map, который нужно отсортировать. Map(K, V)

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

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

​

mapSort

mapSort([func,] map)

• func — Необязательный. Лямбда-функция. Лямбда-функция
• map — Map, которую нужно отсортировать. Map(K, V)

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

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

​

mapSubtract

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

• arg1[, arg2, ...] — Map или Tuple из двух массивов, где элементы первого массива представляют собой ключи, а второй массив содержит значения для каждого ключа. Map(K, V) или Tuple(Array(T), Array(T))

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

mapUpdate(map1, map2)

• map1 — Map, который нужно обновить. Map(K, V)
• map2 — Map, значения из которого используются для обновления. Map(K, V)

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

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

​

mapValues

mapValues(map)

• map — объект Map, из которого извлекаются значения. Map(K, V)

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

['v1','v2']