دوال 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 — مفاتيح عناصر الخريطة. Any
• value_n — قيم عناصر الخريطة. 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 — دالة لامدا. Lambda function
• map — قيمة Map المراد التحقق منها. Map(K, V)

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

0

​

mapApply

mapApply(func, map)

• func — دالة لامدا. دالة لامدا
• 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

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

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

​

mapContainsKey

mapContainsKey(map, key)

• map — الخريطة المراد البحث فيها. Map(K, V)
• key — المفتاح المراد البحث عنه. يجب أن يطابق نوعه نوع المفتاح في الخريطة. Any

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

1

​

mapContainsKeyLike

mapContainsKeyLike(map, pattern)

• 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(K, V)
• key — المفتاح المراد البحث عنه. يجب أن يطابق نوعه نوع مفاتيح الخريطة. Any
• value — القيمة المراد البحث عنها. يجب أن يطابق نوعها نوع قيم الخريطة. 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 — اختياري. دالة لامدا. Lambda function
• map — قيمة Map المراد التحقق منها. Map(K, V)

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

1

​

mapExtractKeyLike

mapExtractKeyLike(map, pattern)

• 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(K, V)

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

{'k2':2}

​

mapFromArrays

mapFromArrays(keys, values)

• keys — Array أو Map من المفاتيح لإنشاء الـ Map منه. Array أو Map
• values — Array أو Map من القيم لإنشاء الـ 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 — اختياري. دالة لامبدا. Lambda function
• limit — تُرتَّب العناصر ضمن النطاق [1..limit]. (U)Int*
• 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 — اختياري. دالة لامبدا. Lambda function
• limit — تُفرَز العناصر ضمن النطاق [1..limit]. (U)Int*
• 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 — اختياري. دالة لامبدا. Lambda function
• 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, ...] — خرائط أو قيم من نوع 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(K, V)
• map2 — الخريطة المُستخدمة في التحديث. 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']