دوال المصفوفات

أُضيف في: v1.1.0

ينشئ مصفوفة من وسيطات الدالة.

يجب أن تكون الوسيطات ثوابت، وأن تكون أنواعها قابلة للاشتراك في نوع أعلى مشترك. يجب تمرير وسيطة واحدة على الأقل، لأن نوع المصفوفة المطلوب إنشاؤها لن يكون واضحًا بخلاف ذلك. وهذا يعني أنه لا يمكنك استخدام هذه الدالة لإنشاء مصفوفة فارغة. ولتنفيذ ذلك، استخدم الدالة emptyArray*.

استخدم العامل [ ] للحصول على الوظيفة نفسها.

الصيغة

array(x1 [, x2, ..., xN])

الوسيطات

• x1 — قيمة ثابتة من أي نوع T. إذا تم توفير هذا الوسيط فقط، فستكون المصفوفة من النوع T. - [, x2, ..., xN] — N قيم ثابتة إضافية لها نوع أعلى مشترك مع x1

القيمة المُعادة

تعيد مصفوفة، حيث إن 'T' هو أصغر نوع مشترك بين الوسيطات المُمرَّرة. Array(T)

أمثلة

استخدام صحيح

SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)

┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32)  │
└─────────┴───────────────┘

استخدام غير صحيح

SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)

┌─a───────────────────────────┬─toTypeName(a)─────────────────────────┐
│ [5,'1998-06-16 00:00:00',5] │ Array(Variant(DateTime, Int32, Int8)) │
└─────────────────────────────┴───────────────────────────────────────┘

أُضيفت في: v20.4.0

تحسب المساحة تحت منحنى الدقة والاستدعاء (PR). يُنشأ منحنى الدقة والاستدعاء برسم الدقة على المحور y والاستدعاء على المحور x عبر جميع العتبات. تتراوح القيمة الناتجة بين 0 و1، وتشير القيمة الأعلى إلى أداء أفضل للنموذج. تكون PR AUC مفيدة بشكل خاص مع مجموعات البيانات غير المتوازنة، إذ توفّر مقارنة أوضح للأداء من ROC AUC في هذه الحالات. لمزيد من التفاصيل، يُرجى الاطلاع على هنا، وهنا، وهنا.

الصيغة

arrayAUCPR(scores, labels[, partial_offsets])

الأسماء البديلة: arrayPRAUC

الوسائط

• cores — الدرجات التي ينتجها نموذج التنبؤ. Array((U)Int*) أو Array(Float*)
• labels — تسميات العينات، وعادةً ما تكون 1 للعينة الإيجابية و0 للعينة السلبية. Array((U)Int*) أو Array(Enum)
• partial_offsets —
• اختياري. مصفوفة Array(T) تتكوّن من ثلاثة أعداد صحيحة غير سالبة لحساب مساحة جزئية تحت منحنى PR (وهو ما يعادل شريطًا رأسيًا في فضاء PR) بدلًا من حساب AUC بالكامل. يفيد هذا الخيار في الحساب الموزّع لـ PR AUC. يجب أن تحتوي المصفوفة على العناصر التالية [higher_partitions_tp, higher_partitions_fp, total_positives].
  • higher_partitions_tp: عدد التسميات الإيجابية في الأقسام ذات الدرجات الأعلى.
  • higher_partitions_fp: عدد التسميات السلبية في الأقسام ذات الدرجات الأعلى.
  • total_positives: العدد الإجمالي للعينات الإيجابية في مجموعة البيانات بأكملها.

القيمة المُعادة

تعيد المساحة تحت منحنى الدقة-الاستدعاء (PR). Float64

أمثلة

مثال على الاستخدام

SELECT arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);

┌─arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│                              0.8333333333333333 │
└─────────────────────────────────────────────────┘

أُضيف في: v1.1.0

يعيد 1 إذا أرجعت الدالة lambda ‏func(x [, y1, y2, ... yN]) القيمة true لجميع العناصر. وإلا، فيعيد 0.

البنية

arrayAll(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

الوسيطات

• func(x[, y1, ..., yN]) — دالة لامبدا تعمل على عناصر مصفوفة المصدر (x) ومصفوفات الشرط (y). Lambda function
• source_arr — مصفوفة المصدر المراد معالجتها. Array(T)
• cond1_arr, ... — اختياري. عدد N من مصفوفات الشرط التي توفّر وسيطات إضافية لدالة لامبدا. Array(T)

القيمة المعادة

تعيد 1 إذا كانت دالة لامبدا تُرجع true لجميع العناصر، وإلا فتُرجع 0 UInt8

أمثلة

جميع العناصر تستوفي الشرط

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])

1

لا تتطابق جميع العناصر

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])

0

أُضيفت في: v26.4.0

يحسب الارتباط الذاتي لمصفوفة. إذا تم توفير max_lag، فسيحسب الارتباط فقط لقيم التأخر ضمن النطاق [0, max_lag). إذا لم يتم توفير max_lag، فسيحسبه لجميع قيم التأخر الممكنة.

الصيغة

arrayAutocorrelation(arr, [max_lag])

الوسيطات

• arr — مصفوفة من الأرقام. Array(T)
• max_lag — اختياري. الحد الأقصى لعدد فترات التأخر المطلوب حسابها. يجب أن يكون عددًا صحيحًا غير سالب. Integer

القيمة المُعادة

يعيد مصفوفة من نوع Float64. ويعيد NaN إذا كان التباين يساوي 0. Array(Float64)

أمثلة

خطي

SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);

[1,0.4,-0.1,-0.4,-0.4]

متناظر

SELECT arrayAutocorrelation([10, 20, 10]);

[1,-0.6666666666666669,0.16666666666666674]

ثابت

SELECT arrayAutocorrelation([5, 5, 5]);

[nan,nan,nan]

محدود

SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);

[1,0.4]

قُدِّمت في: v21.1.0

يعيد متوسط عناصر المصفوفة المصدر.

إذا تم تحديد دالة لامدا func، فسيُعاد متوسط عناصر النتائج الناتجة عن اللامدا.

الصيغة

arrayAvg([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

الوسيطات

• func(x[, y1, ..., yN]) — اختياري. دالة لامبدا تعمل على عناصر مصفوفة المصدر (x) ومصفوفات الشرط (y). Lambda function
• source_arr — مصفوفة المصدر المطلوب معالجتها. Array(T)
• [, cond1_arr, ... , condN_arr] — اختياري. N من مصفوفات الشرط التي توفّر وسيطات إضافية لدالة لامبدا. Array(T)

القيمة المعادة

تعيد متوسط عناصر مصفوفة المصدر، أو متوسط عناصر ناتج دالة لامبدا إذا تم توفيرها. Float64

أمثلة

مثال أساسي

SELECT arrayAvg([1, 2, 3, 4]);

2.5

الاستخدام مع دالة لامدا

SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;

6.5

أُضيفت في: v26.6.0

تعيد مصفوفة تضم أصغر K عنصرًا من مصفوفة الإدخال، مرتبة بترتيب تصاعدي. إذا تم تحديد دالة لامدا f، فتُقارَن العناصر بناءً على نتيجة تطبيق f على كل عنصر. إذا كانت f تقبل عدة وسائط، فستُمرَّر مصفوفات إضافية إلى arrayBottomK، وتكون عناصرها مطابقةً لوسائط f.

يتم تخطي قيم NULL ولا تظهر في النتيجة. ويكون حجم النتيجة بحد أقصى K وقد يكون أصغر إذا كانت مصفوفة الإدخال تحتوي على عدد من العناصر غير NULL أقل من K. ويكون نوع عنصر النتيجة هو النظير غير القابل لأن تكون قيمته NULL لنوع عنصر الإدخال.

arrayBottomK هي دالة عالية الرتبة.

انظر أيضًا:

• arrayTopK، التي تعيد أكبر K عنصرًا بدلًا من ذلك.
• arrayPartialSort، التي تنتج عناصر K نفسها في المواضع [1..K] ولكن تُبقي أيضًا العناصر المتبقية بترتيب غير محدد، ولا تتخطى القيم الفارغة.

الصياغة

arrayBottomK([f,] K, arr [, arr1, ... ,arrN])

الوسيطات

• f(arr[, arr1, ... ,arrN]) — اختياري. دالة لامدا لحساب مفتاح الفرز لكل عنصر. دالة لامدا
• K — عدد أصغر العناصر المطلوب إرجاعها. (U)Int8/16/32/64
• arr — مصفوفة. Array(T)
• arr1, ... ,arrN — N من المصفوفات الإضافية، في حال كانت f تقبل عدة وسيطات. Array(T)

القيمة المعادة

يعيد ما يصل إلى K من عناصر arr الأصغر قيمةً (أو أصغر نتائج لامدا)، مرتبة بترتيب تصاعدي. يتم تخطي قيم NULL. وتكون المصفوفة المعادة من نوع العنصر T حتى عندما يكون الإدخال من النوع Nullable(T).

أمثلة

simple_int

SELECT arrayBottomK(3, [1, 5, 2, 7, 3])

[1,2,3]

skip_nulls

SELECT arrayBottomK(3, [1, NULL, 5, 2, NULL, 7])

[1,2,5]

fewer_than_k

SELECT arrayBottomK(5, [1, NULL, 2])

[1,2]

lambda_simple

SELECT arrayBottomK((x) -> -x, 2, [5, 9, 1, 3])

[9,5]

lambda_multi

SELECT arrayBottomK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])

['b','c']

أُضيفت في: v20.1.0

تزيل العناصر المكررة المتتالية من المصفوفة، بما في ذلك قيم null. ويُحدَّد ترتيب القيم في المصفوفة الناتجة بحسب ترتيبها في المصفوفة المُدخلة.

الصيغة

arrayCompact(arr)

المعاملات

• arr — مصفوفة تُزال منها القيم المكررة. Array(T)

القيمة المعادة

تُرجع مصفوفةً من دون قيم مكررة Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);

[1,nan,2,3]

ظهر لأول مرة في: v1.1.0

يدمج المصفوفات المُمرَّرة كوسيطات.

البنية

arrayConcat(arr1 [, arr2, ... , arrN])

الوسيطات

• arr1 [, arr2, ... , arrN] — عدد N من المصفوفات المراد ضمّها. Array(T)

القيمة المُعادة

تُرجع مصفوفة واحدة مدمجة من وسيطات المصفوفات المُدخلة. Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res

[1,2,3,4,5,6]

أُضيفت في: v1.1.0

تعيد عدد العناصر التي تُرجِع func(arr1[i], ..., arrN[i]) القيمة true لها. إذا لم يتم تحديد func، فإنها تعيد عدد العناصر غير الصفرية في Array.

تُعد arrayCount دالة عالية الرتبة.

الصياغة

arrayCount([func, ] arr1, ...)

المعاملات

• func — اختياري. الدالة المراد تطبيقها على كل عنصر في المصفوفة (أو المصفوفات). دالة لامبدا
• arr1, ..., arrN — عددها N من المصفوفات. Array(T)

القيمة المُعادة

تعيد عدد العناصر التي تُرجع func لها القيمة true. وإلا، تعيد عدد العناصر غير الصفرية في المصفوفة. UInt32

أمثلة

مثال على الاستخدام

SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)

5

تم تقديمها في: v1.1.0

تعيد مصفوفة تحتوي على المجاميع الجزئية (التراكمية) لعناصر مصفوفة الإدخال. إذا جرى تحديد دالة لامبدا، فيُحسب المجموع بتطبيق دالة لامبدا على عناصر المصفوفة في كل موضع.

البنية

arrayCumSum([func,] arr1[, arr2, ... , arrN])

الوسائط

• func — اختياري. دالة لامبدا تُطبَّق على عناصر المصفوفة عند كل موضع. Lambda function
• arr1 — مصفوفة المصدر للقيم الرقمية. Array(T)
• [arr2, ..., arrN] — اختياري. مصفوفات إضافية بالحجم نفسه، تُمرَّر كوسائط إلى دالة لامبدا إذا جرى تحديدها. Array(T)

القيمة المُعادة

تعيد مصفوفة من المجاميع الجزئية لعناصر مصفوفة المصدر. يتطابق نوع النتيجة مع النوع الرقمي لمصفوفة الإدخال. Array(T)

أمثلة

الاستخدام الأساسي

SELECT arrayCumSum([1, 1, 1, 1]) AS res

[1,2,3,4]

باستخدام دالة لامبدا

SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res

[2,6,12]

أُضيف في: v18.12.0

يعيد مصفوفة من المجاميع الجزئية (التراكمية) لعناصر مصفوفة المصدر، مع استبدال أي مجموع تراكمي سالب بالصفر. إذا جرى تحديد دالة لامبدا، يُحتسب المجموع عبر تطبيق دالة لامبدا على عناصر المصفوفة عند كل موضع.

البنية

arrayCumSumNonNegative([func,] arr1[, arr2, ... , arrN])

الوسائط

• func — اختياري. دالة لامبدا تُطبَّق على عناصر المصفوفة عند كل موضع. Lambda function
• arr1 — مصفوفة المصدر للقيم الرقمية. Array(T)
• [arr2, ..., arrN] — اختياري. مصفوفات إضافية بالحجم نفسه، تُمرَّر كوسائط إلى دالة لامبدا إذا جرى تحديدها. Array(T)

القيمة المعادة

تعيد مصفوفة من المجاميع الجزئية لعناصر مصفوفة المصدر، مع استبدال أي مجموع تراكمي سالب بالصفر. يطابق نوع النتيجة النوع الرقمي لمصفوفة الإدخال. Array(T)

أمثلة

الاستخدام الأساسي

SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res

[1,2,0,1]

باستخدام دالة لامبدا

SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res

[2,0,6]

أُضيف في: v1.1.0

يحسب مصفوفة من الفروق بين عناصر المصفوفة المتجاورة. سيكون العنصر الأول في المصفوفة الناتجة هو 0، والثاني arr[1] - arr[0]، والثالث arr[2] - arr[1]، وهكذا. يُحدَّد نوع العناصر في المصفوفة الناتجة وفقًا لقواعد استدلال النوع الخاصة بالطرح (على سبيل المثال UInt8 - UInt8 = Int16).

البنية

arrayDifference(arr)

الوسائط

• arr — المصفوفة التي تُحسَب لها الفروق بين العناصر المتجاورة. Array(T)

القيمة المُعادة

يعيد مصفوفة تحتوي على الفروق بين العناصر المتجاورة في المصفوفة UInt*

أمثلة

مثال على الاستخدام

SELECT arrayDifference([1, 2, 3, 4]);

[0,1,1,1]

مثال على تجاوز السعة بسبب نوع النتيجة Int64

SELECT arrayDifference([0, 10000000000000000000]);

┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616]                   │
└────────────────────────────────────────────┘

أُضيفت في: v1.1.0

تُرجع مصفوفة لا تحتوي إلا على العناصر الفريدة في المصفوفة.

البنية

arrayDistinct(arr)

الوسائط

• arr — المصفوفة التي تُستخرج منها العناصر الفريدة. Array(T)

القيمة المعادة

تُرجِع مصفوفة تحتوي على العناصر الفريدة Array(T)

أمثلة

مثال للاستخدام

SELECT arrayDistinct([1, 2, 2, 3, 1]);

[1,2,3]

ظهر في: v23.5.0

يعيد الجداء النقطي لمصفوفتين.

البنية

arrayDotProduct(v1, v2)

الوسائط

• v1 — المتجه الأول. Array((U)Int* | Float* | BFloat16 | Decimal) أو Tuple((U)Int* | Float* | Decimal)
• v2 — المتجه الثاني. Array((U)Int* | Float* | BFloat16 | Decimal) أو Tuple((U)Int* | Float* | Decimal)

القيمة المُعادة

الجداء النقطي للمتجهين.

(U)Int* أو Float* أو Decimal

أمثلة

مثال على Array

SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);

32	UInt16

مثال على Tuple

SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);

32	Float64

أُضيف في: v1.1.0

تُرجِع عنصر المصفوفة المُعطاة عند الفهرس n، حيث يمكن أن يكون n أي نوع من الأعداد الصحيحة. إذا كان الفهرس خارج حدود المصفوفة، فستُرجِع قيمة افتراضية (0 للأرقام، وسلسلة فارغة للنصوص، وما إلى ذلك)، باستثناء وسيطات مصفوفة غير ثابتة وفهرس ثابت قيمته 0. في هذه الحالة سيظهر الخطأ Array indices are 1-based.

عندما تكون n مصفوفة من الأعداد الصحيحة، تُرجِع مصفوفة بالعناصر الموجودة في المواضع المحددة (عملية تجميع). وهذا مكافئ لـ arrayMap(i -> arr[i], n)، ولكنه يتمتع بتنفيذ منفصل أكثر كفاءة. تُنتج المواضع خارج الحدود القيمة الافتراضية، كما في حالة الفهرس المفرد. يمكن أن تكون عناصر الفهرس قابلة لأن تكون NULL. يُنتج الفهرس NULL القيمة NULL (ويجعل نوع عنصر النتيجة قابلاً لأن يكون NULL) عندما يمكن تغليف نوع العنصر في Nullable؛ أما أنواع العناصر التي لا يمكن أن تكون داخل Nullable (مثل Array وMap)، فيُنتج الفهرس NULL القيمة الافتراضية بدلاً من ذلك. وهذا هو السلوك نفسه لفهرس NULL المفرد.

الفهارس السالبة مدعومة. في هذه الحالة، يُختار العنصر المقابل بعد العد من النهاية. على سبيل المثال، arr[-1] هو العنصر الأخير في المصفوفة.

يوفّر العامل [n] الوظيفة نفسها.

يمكن أن تكون الوسيطة الأولى أيضًا QBit: يُعاد بناء عنصر المتجه رقم n بالدقة الكاملة لنوع عنصر QBit، مع قراءة مستويات البت الخاصة بمجموعة stride التي تحتويه فقط.

الصيغة

arrayElement(arr, n)

وسيطات الدالة

• arr — المصفوفة المراد البحث فيها. Array(T) أو QBit. - n — موضع العنصر المراد الحصول عليه، أو مصفوفة من المواضع. يمكن أن تكون المواضع قابلة لأن تكون NULL. (U)Int* أو Array((U)Int*).

القيمة المُعادة

عندما يكون n قيمة قياسية، يعيد عنصرًا من النوع T. وعندما يكون n مصفوفة، يعيد Array(Nullable(T)) إذا كانت عناصر الفهرس قابلة لأن تكون NULL وكان يمكن تغليف T في Nullable، وإلا يعيد Array(T). Any أو Array(T) أو Array(Nullable(T))

أمثلة

مثال على الاستخدام

SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

2

الفهرسة بالمؤشرات السالبة

SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

3

استخدام الصيغة [n]

SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)

2

الفهرس خارج نطاق المصفوفة

SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

0

مصفوفة من الفهارس

SELECT [10, 20, 30, 40][[2, 4, 1]]

[20,40,10]

أُضيف في: v1.1.0

تسترجع العنصر من المصفوفة المحددة عند الفهرس n، حيث يمكن أن يكون n من أي نوع عدد صحيح. إذا كان الفهرس خارج حدود المصفوفة، فستُعاد NULL بدلًا من القيمة الافتراضية، ما دام نوع النتيجة قابلاً لأن يكون Nullable. بالنسبة إلى أنواع العناصر التي ليست قابلة لـ NULL أصلًا ولا يمكن وضعها داخل Nullable (مثل Array وMap)، تُعاد القيمة الافتراضية لنوع العنصر بدلًا من ذلك.

عندما يكون n مصفوفة من الأعداد الصحيحة، تُرجِع مصفوفة من العناصر الموجودة في المواضع المحددة. وهذا مكافئ لـ arrayMap(i -> arrayElementOrNull(arr, i), n)، لكنه يمتلك تنفيذًا منفصلًا وأكثر كفاءة. تُنتج المواضع خارج الحدود وفهارس NULL قيم NULL في مصفوفة النتيجة، وفقًا للقاعدة نفسها المتبعة مع الفهرس القياسي.

الفهارس السالبة مدعومة. في هذه الحالة، يُختار العنصر المقابل عند العد من النهاية. على سبيل المثال، arr[-1] هو آخر عنصر في المصفوفة.

الصيغة

arrayElementOrNull(arr, n)

وسيطات الدالة

• arr — المصفوفة المطلوب البحث فيها. Array(T). - n — موضع العنصر المطلوب الحصول عليه، أو مصفوفة من المواضع. يمكن أن تقبل المواضع القيم الفارغة. (U)Int* أو Array((U)Int*).

القيمة المُعادة

عندما يكون n قيمةً قياسية، تُرجع Nullable(T) إذا أمكن تضمين T في Nullable، وإلا فتُرجع T. عندما يكون n مصفوفة، تُرجع Array(Nullable(T)) إذا أمكن تضمين T في Nullable، وإلا فتُرجع Array(T). Any أو Nullable(T) أو Array(T) أو Array(Nullable(T))

أمثلة

مثال على الاستخدام

SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

2

الفهرسة بالمؤشرات السالبة

SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

3

الفهرس خارج نطاق المصفوفة

SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

\N

مصفوفة من الفهارس

SELECT arrayElementOrNull([10, 20, 30], [1, 5, 2])

[10,NULL,20]

أُضيفت في: v1.1.0

يُرجع المصفوفة [1, 2, 3, ..., length (arr)]

تُستخدم هذه الدالة عادةً مع عبارة ARRAY JOIN. وهي تتيح احتساب شيءٍ ما مرة واحدة فقط لكل مصفوفة بعد تطبيق ARRAY JOIN. ويمكن أيضًا استخدام هذه الدالة في الدوال عالية الرتبة. على سبيل المثال، يمكنك استخدامها للحصول على فهارس عناصر المصفوفة التي تطابق شرطًا.

الصياغة

arrayEnumerate(arr)

المعاملات

• arr — المصفوفة المطلوب تعداد عناصرها. Array

القيمة المعادة

تُرجِع المصفوفة [1, 2, 3, ..., length (arr)]. Array(UInt32)

أمثلة

مثال أساسي مع ARRAY JOIN

CREATE TABLE test
(
    `id` UInt8,
    `tag` Array(String),
    `version` Array(String)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO test VALUES (1, ['release-stable', 'dev', 'security'], ['2.4.0', '2.6.0-alpha', '2.4.0-sec1']);

SELECT
    id,
    tag,
    version,
    seq
FROM test
ARRAY JOIN
    tag,
    version,
    arrayEnumerate(tag) AS seq

┌─id─┬─tag────────────┬─version─────┬─seq─┐
│  1 │ release-stable │ 2.4.0       │   1 │
│  1 │ dev            │ 2.6.0-alpha │   2 │
│  1 │ security       │ 2.4.0-sec1  │   3 │
└────┴────────────────┴─────────────┴─────┘

استُحدثت في: v18.12.0

تعيد مصفوفة بالحجم نفسه مثل المصفوفة المصدر، وتُشير إلى موضع أول ظهور لكل عنصر في المصفوفة المصدر.

البنية

arrayEnumerateDense(arr)

الوسائط

• arr — المصفوفة المطلوب ترقيم عناصرها. Array(T)

القيمة المُعادة

يعيد مصفوفة بنفس حجم arr، وتشير إلى الموضع الذي يظهر فيه كل عنصر لأول مرة في المصفوفة الأصلية Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayEnumerateDense([10, 20, 10, 30])

[1,2,1,3]

أُضيفت في: v20.1.0

تُرجِع مصفوفة بالحجم نفسه مثل المصفوفة المصدر، مع الإشارة إلى الموضع الذي يظهر فيه كل عنصر لأول مرة في المصفوفة المصدر. وتتيح تعداد مصفوفة متعددة الأبعاد مع إمكانية تحديد مدى العمق المطلوب النظر إليه داخل المصفوفة.

البنية

arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)

المعاملات

• clear_depth — عدِّد العناصر في المستوى المحدد كلٌّ على حدة. يجب أن تكون قيمته أقل من أو تساوي max_arr_depth. UInt*
• arr — مصفوفة متعددة الأبعاد N المطلوب تعدادها. Array(T)
• max_array_depth — الحد الأقصى للعمق الفعّال. يجب أن يكون أقل من أو يساوي عمق arr. UInt*

القيمة المُعادة

تُعيد مصفوفةً تُبيّن موضع الظهور الأول لكل عنصر في المصفوفة المصدر Array

أمثلة

الاستخدام الأساسي

-- With clear_depth=1 and max_array_depth=1, the result is identical to what arrayEnumerateDense would give.

SELECT arrayEnumerateDenseRanked(1,[10, 20, 10, 30],1);

[1,2,1,3]

الاستخدام مع مصفوفة متعددة الأبعاد

-- In this example, arrayEnumerateDenseRanked is used to obtain an array indicating, for each element of the
-- multidimensional array, what its position is among elements of the same value.
-- For the first row of the passed array, [10, 10, 30, 20], the corresponding first row of the result is [1, 1, 2, 3],
-- indicating that 10 is the first number encountered in position 1 and 2, 30 the second number encountered in position 3
-- and 20 is the third number encountered in position 4.
-- For the second row, [40, 50, 10, 30], the corresponding second row of the result is [4,5,1,2], indicating that 40
-- and 50 are the fourth and fifth numbers encountered in position 1 and 2 of that row, that another 10
-- (the first encountered number) is in position 3 and 30 (the second number encountered) is in the last position.

SELECT arrayEnumerateDenseRanked(1,[[10,10,30,20],[40,50,10,30]],2);

[[1,1,2,3],[4,5,1,2]]

مثال مع زيادة قيمة clear_depth

-- Changing clear_depth=2 results in the enumeration occurring separately for each row anew.

SELECT arrayEnumerateDenseRanked(2,[[10,10,30,20],[40,50,10,30]],2);

[[1,1,2,3],[1,2,3,4]]

قُدِّمت في: v1.1.0

تعيد مصفوفة بالحجم نفسه لمصفوفة المصدر، بحيث تبيّن لكل عنصر ترتيبه بين العناصر ذات القيمة نفسها.

تكون هذه الدالة مفيدة عند استخدام ARRAY JOIN وتجميع عناصر المصفوفة.

يمكن للدالة قبول عدة مصفوفات بالحجم نفسه كوسيطات. في هذه الحالة، يُحدَّد التفرد وفقًا لـ Tuple المكوَّن من العناصر الواقعة في المواضع نفسها عبر جميع المصفوفات.

الصيغة

arrayEnumerateUniq(arr1[, arr2, ... , arrN])

الوسائط

• arr1 — المصفوفة الأولى المراد معالجتها. Array(T)
• arr2, ... — اختياري. مصفوفات إضافية بالحجم نفسه للتفرّد بحسب الـ tuple. Array(UInt32)

القيمة المعادة

يعيد مصفوفة يكون كل عنصر فيها هو ترتيبه بين العناصر ذات القيمة نفسها أو الـ tuple نفسه. Array(T)

أمثلة

الاستخدام الأساسي

SELECT arrayEnumerateUniq([10, 20, 10, 30]);

[1,1,2,1]

مصفوفات متعددة

SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);

[1,2,1,1,2,1]

التجميع باستخدام ARRAY JOIN

-- Each goal ID has a calculation of the number of conversions (each element in the Goals nested data structure is a goal that was reached, which we refer to as a conversion)
-- and the number of sessions. Without ARRAY JOIN, we would have counted the number of sessions as sum(Sign). But in this particular case,
-- the rows were multiplied by the nested Goals structure, so in order to count each session one time after this, we apply a condition to the
-- value of the arrayEnumerateUniq(Goals.ID) function.

CREATE TABLE visits (CounterID UInt32, Sign Int8, Goals Nested(ID UInt32)) ENGINE = Memory;

INSERT INTO visits VALUES
    (160656, 1, [53225, 53225, 56600]),
    (160656, 1, [53225, 2825062]),
    (160656, 1, [56600, 56600, 2825062]),
    (160657, 1, [53225]);

SELECT
    Goals.ID AS GoalID,
    sum(Sign) AS Reaches,
    sumIf(Sign, num = 1) AS Visits
FROM visits
ARRAY JOIN
    Goals,
    arrayEnumerateUniq(Goals.ID) AS num
WHERE CounterID = 160656
GROUP BY GoalID
ORDER BY Reaches DESC, GoalID
LIMIT 10

┌──GoalID─┬─Reaches─┬─Visits─┐
│   53225 │       3 │      2 │
│   56600 │       3 │      2 │
│ 2825062 │       2 │      2 │
└─────────┴─────────┴────────┘

قُدِّمت في: v20.1.0

تُرجع مصفوفة (أو مصفوفة متعددة الأبعاد) بالأبعاد نفسها مثل المصفوفة المصدر، وتوضّح، لكل عنصر، ترتيبه بين العناصر ذات القيمة نفسها. وتتيح تعداد مصفوفة متعددة الأبعاد مع إمكانية تحديد عمق البحث داخل المصفوفة.

الصيغة

arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)

الوسيطات

• clear_depth — رقّم العناصر في المستوى المحدد كلٌّ على حدة. عدد صحيح موجب أصغر من أو يساوي max_arr_depth. UInt*
• arr — مصفوفة متعددة الأبعاد المطلوب ترقيمها. Array(T)
• max_array_depth — الحد الأقصى للعمق الفعّال. عدد صحيح موجب أصغر من أو يساوي عمق arr. UInt*

القيمة المعادة

تعيد مصفوفة متعددة الأبعاد لها الحجم نفسه الذي لـ arr، بحيث يبيّن كل عنصر موضعه بالنسبة إلى العناصر الأخرى ذات القيمة نفسها. Array(T)

أمثلة

المثال 1

-- With clear_depth=1 and max_array_depth=1, the result of arrayEnumerateUniqRanked
-- is identical to that which arrayEnumerateUniq would give for the same array.

SELECT arrayEnumerateUniqRanked(1, [1, 2, 1], 1);

[1,1,2]

مثال 2

-- with clear_depth=1 and max_array_depth=1, the result of arrayEnumerateUniqRanked
-- is identical to that which arrayEnumerateUniqwould give for the same array.

SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);

[[1,1,1],[2,3,2],[2]]

مثال 3

-- In this example, arrayEnumerateUniqRanked is used to obtain an array indicating,
-- for each element of the multidimensional array, what its position is among elements
-- of the same value. For the first row of the passed array, [1, 2, 3], the corresponding
-- result is [1, 1, 1], indicating that this is the first time 1, 2 and 3 are encountered.
-- For the second row of the provided array, [2, 2, 1], the corresponding result is [2, 3, 3],
-- indicating that 2 is encountered for a second and third time, and 1 is encountered
-- for the second time. Likewise, for the third row of the provided array [3] the
-- corresponding result is [2] indicating that 3 is encountered for the second time.

SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);

[[1,1,1],[2,3,2],[2]]

مثال 4

-- Changing clear_depth=2, results in elements being enumerated separately for each row.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);

[[1,1,1],[1,2,1],[1]]

أُضيف في: v25.9.0

يُرجع مصفوفة تحتوي على العناصر الموجودة في source وغير الموجودة في except، مع الحفاظ على ترتيبها الأصلي.

تُجري هذه الدالة عملية فرق بين مصفوفتين. ولكل عنصر في source، تتحقق مما إذا كان هذا العنصر موجودًا في except (باستخدام مقارنة تامة). وإذا لم يكن موجودًا، فسيُدرج في النتيجة.

تحافظ هذه العملية على الخصائص التالية:

1. يُحفَظ ترتيب العناصر القادمة من source
2. تُحفَظ العناصر المكررة في source إذا لم تكن موجودة في except
3. يُتعامل مع NULL بوصفه قيمة مستقلة

الصياغة

arrayExcept(source, except)

الوسائط

• source — مصفوفة المصدر التي تحتوي على العناصر المطلوب تصفيتها. Array(T)
• except — المصفوفة التي تحتوي على العناصر المطلوب استبعادها من النتيجة. Array(T)

القيمة المعادة

تعيد مصفوفة من النوع نفسه لمصفوفة الإدخال، وتحتوي على عناصر من source لم يُعثر عليها في except. Array(T)

أمثلة

أساسي

SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])

[1,2,2,4]

with_nulls1

SELECT arrayExcept([1, NULL, 2, NULL], [2])

[1,NULL,NULL]

with_nulls2

SELECT arrayExcept([1, NULL, 2, NULL], [NULL, 2, NULL])

[1]

السلاسل النصية

SELECT arrayExcept(['apple', 'banana', 'cherry'], ['banana', 'date'])

['apple','cherry']

قُدِّم في: v1.1.0

يعيد 1 إذا وُجد عنصر واحد على الأقل في المصفوفة المصدر بحيث تُعيد func(x[, y1, y2, ... yN]) القيمة true. وإلا، يعيد 0.

البنية

arrayExists(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

الوسيطات

• func(x[, y1, ..., yN]) — دالة لامدا تعمل على عناصر المصفوفة المصدر (x) ومصفوفات الشرط (y). Lambda function
• source_arr — المصفوفة المصدر المطلوب معالجتها. Array(T)
• [, cond1_arr, ... , condN_arr] — اختياري. عدد N من مصفوفات الشرط التي توفّر وسيطات إضافية لدالة لامدا. Array(T)

القيمة المعادة

تعيد 1 إذا أعادت دالة لامدا القيمة true لعنصر واحد على الأقل، و0 خلاف ذلك UInt8

أمثلة

مثال للاستخدام

SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])

0

أُضيفت في: v20.1.0

تعالج الدالة arrayFill مصفوفة المصدر بالتسلسل من العنصر الأول إلى العنصر الأخير، مع تقييم شرط دالة lambda عند كل موضع باستخدام عناصر من مصفوفة المصدر ومصفوفات الشرط. عندما يُقيَّم شرط دالة lambda إلى false عند الموضع i، تستبدل الدالة ذلك العنصر بالعنصر الموجود عند الموضع i-1 من الحالة الحالية للمصفوفة. ويُحفَظ العنصر الأول دائمًا بغضّ النظر عن أي شرط.

البنية

arrayFill(func(x [, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

الوسائط

• func(x [, y1, ..., yN]) — دالة لامدا func(x [, y1, y2, ... yN]) → F(x [, y1, y2, ... yN]) تعمل على عناصر المصفوفة المصدر (x) ومصفوفات الشروط (y). دالة لامدا
• source_arr — المصفوفة المصدر المطلوب معالجتها. دالة لامدا
• [, cond1_arr, ... , condN_arr] — اختياري. عدد N من مصفوفات الشروط التي توفّر وسائط إضافية لدالة لامدا. Array(T)

القيمة المُعادة

تعيد مصفوفة Array(T)

أمثلة

مثال باستخدام مصفوفة واحدة

SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res

[1,1,2,2]

مثال على مصفوفتين

SELECT arrayFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res

[5,5,6,6]

متوفّرة منذ: v1.1.0

تُرجع مصفوفة تحتوي فقط على العناصر في المصفوفة المصدر التي تُرجع لها دالة لامبدا القيمة true.

البنية

arrayFilter(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])]

الوسائط

• func(x[, y1, ..., yN]) — دالة لامبدا تعمل على عناصر مصفوفة المصدر (x) ومصفوفات الشرط (y). Lambda function
• source_arr — مصفوفة المصدر المراد معالجتها. Array(T)
• [, cond1_arr, ... , condN_arr] — اختياري. عدد N من مصفوفات الشرط التي توفّر وسائط إضافية لدالة لامبدا. Array(T)

القيمة المُعادة

تعيد مجموعة فرعية من مصفوفة المصدر Array(T)

أمثلة

مثال 1

SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res

['abc World']

مثال 2

SELECT
    arrayFilter(
        (i, x) -> x LIKE '%World%',
        arrayEnumerate(arr),
        ['Hello', 'abc World'] AS arr)
    AS res

[2]

قُدِّمت في: v1.1.0

تُعيد أول عنصر في المصفوفة المصدر تُرجع له func(x[, y1, y2, ... yN]) القيمة true، وإلا فتُعيد القيمة الافتراضية.

الصيغة

arrayFirst(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

الوسائط

• func(x[, y1, ..., yN]) — دالة لامدا تعمل على عناصر مصفوفة المصدر (x) ومصفوفات الشرط (y). دالة لامدا. - source_arr — مصفوفة المصدر المطلوب معالجتها. Array(T). - [, cond1_arr, ... , condN_arr] — اختياري. عدد N من مصفوفات الشرط التي توفّر وسائط إضافية لدالة لامدا. Array(T).

القيمة المُعادة

تعيد أول عنصر من مصفوفة المصدر تتحقق له λ، وإلا تُعيد القيمة الافتراضية لـ T.

أمثلة

مثال على الاستخدام

SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

b

لا توجد مطابقة

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

0	UInt8

أُضيفت في: v1.1.0

تُرجِع فهرس أول عنصر في مصفوفة المصدر تُرجِع له func(x[, y1, y2, ... yN]) القيمة true، وإلا فتُرجِع '0'.

الصيغة

arrayFirstIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

المعاملات

• func(x[, y1, ..., yN]) — دالة لامبدا تعمل على عناصر المصفوفة المصدر (x) ومصفوفات الشرط (y). دالة لامبدا. - source_arr — المصفوفة المصدر المطلوب معالجتها. Array(T). - [, cond1_arr, ... , condN_arr] — اختياري. عدد N من مصفوفات الشرط التي توفّر معاملات إضافية لدالة لامبدا. Array(T).

القيمة المُعادة

يعيد فهرس أول عنصر في المصفوفة المصدر تكون فيه func مساوية لـ true، وإلا يعيد 0 UInt32

أمثلة

مثال على الاستخدام

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

2

لا يوجد تطابق

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])

0

أُضيفت في: v1.1.0

تُرجع أول عنصر في مصفوفة المصدر تُرجع له الدالة func(x[, y1, y2, ... yN]) القيمة true، وإلا فتُرجع NULL.

البنية

arrayFirstOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

الوسيطات

• func(x[, y1, ..., yN]) — دالة لامبدا تعمل على عناصر المصفوفة المصدر (x) والمصفوفات الشرطية (y). Lambda function
• source_arr — المصفوفة المصدر المطلوب معالجتها. Array(T)
• [, cond1_arr, ... , condN_arr] — اختياري. عدد N من المصفوفات الشرطية التي توفّر وسيطات إضافية لدالة لامبدا. Array(T)

القيمة المعادة

يعيد العنصر الأول من المصفوفة المصدر الذي تكون func بالنسبة إليه true، وإلا فيعيد NULL.

أمثلة

مثال على الاستخدام

SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

b

لا يوجد تطابق

SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

\N	Nullable(UInt8)

أُضيفت في: v20.1.0

تحوّل مصفوفة من المصفوفات إلى مصفوفة مسطّحة.

الدالة:

• تنطبق على أي مستوى من تداخل المصفوفات.
• لا تغيّر المصفوفات المسطّحة أصلًا.

تحتوي المصفوفة المسطّحة على جميع العناصر من كل المصفوفات المُدخلة.

البنية

arrayFlatten(arr)

الأسماء البديلة: flatten

الوسيطات

• arr — مصفوفة متعددة الأبعاد. Array(Array(T))

القيمة المُعادة

تُرجع مصفوفة مُسطَّحة من المصفوفة متعددة الأبعاد Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayFlatten([[[1]], [[2], [3]]]);

[1,2,3]

تم تقديمه في: v23.10.0

يطبّق دالة لامدا على مصفوفة واحدة أو أكثر من المصفوفات متساوية الحجم، ويجمع النتيجة في مُراكِم.

الصيغة

arrayFold(λ

الوسيطات

• λ(x, x1 [, x2, x3, ... xN]) — دالة لامدا λ(acc, x1 [, x2, x3, ... xN]) → F(acc, x1 [, x2, x3, ... xN])، حيث تمثل F عمليةً تُطبَّق على acc وعلى قيم المصفوفة من x، مع إعادة استخدام الناتج في acc. Lambda function
• arr1 [, arr2, arr3, ... arrN] — عدد N من المصفوفات التي تُطبَّق عليها العملية. Array(T)
• acc — قيمة المُجمِّع، ويكون نوعها مطابقًا لنوع الإرجاع الخاص بدالة لامدا.

القيمة المعادة

تُرجع القيمة النهائية acc.

أمثلة

مثال على الاستخدام

SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;

23

متتالية فيبوناتشي

SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);

┌─fibonacci─┐
│         0 │
│         1 │
│         1 │
│         2 │
│         3 │
│         5 │
│         8 │
│        13 │
│        21 │
│        34 │
└───────────┘

مثال على استخدام عدة مصفوفات

SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;

300

قُدِّمت في: v1.1.0

تأخذ عدة مصفوفات وتُرجِع مصفوفة تضم العناصر الموجودة في جميع المصفوفات المصدر. ولا تحتوي النتيجة إلا على قيم فريدة.

البنية

arrayIntersect(arr, arr1, ..., arrN)

الوسيطات

• arrN — ‏N من المصفوفات التي تُنشأ منها المصفوفة الجديدة. Array(T).

القيمة المعادة

تعيد مصفوفة تحتوي على عناصر مميزة موجودة في جميع المصفوفات N Array(T)

أمثلة

مثال على الاستخدام

SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection

┌─empty_intersection─┬─non_empty_intersection─┐
│ []                 │ [1]                    │
└────────────────────┴────────────────────────┘

أُضيف في: v23.7.0

يعيد مؤشر Jaccard لمصفوفتين.

البنية

arrayJaccardIndex(arr_x, arr_y)

الوسائط

• arr_x — المصفوفة الأولى. Array(T)
• arr_y — المصفوفة الثانية. Array(T)

القيمة المعادة

تعيد قيمة مؤشر جاكارد لـ arr_x وarr_y من النوع Float64

أمثلة

مثال على الاستخدام

SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res

0.3333333333333333

أُضيفت في: v1.1.0

تأخذ الدالة arrayJoin صفًا يحتوي على مصفوفة وتبسطه إلى عدة صفوف، بحيث يقابل كل عنصر في المصفوفة صفٌّ واحد. وهذا بخلاف الدوال العادية في ClickHouse التي تربط قيم الإدخال بقيم الإخراج داخل الصف نفسه، والدوال التجميعية التي تأخذ مجموعة من الصفوف وتقوم "بضغطها" أو "اختزالها" إلى صف تلخيصي واحد (أو إلى قيمة واحدة داخل صف تلخيصي إذا استُخدمت مع GROUP BY).

تُنسخ جميع القيم في الأعمدة كما هي، باستثناء القيم الموجودة في العمود الذي تُطبَّق عليه هذه الدالة؛ إذ تُستبدل هذه القيم بقيمة العنصر المقابل في المصفوفة.

يُعد unnest (منذ الإصدار 26.5) اسمًا مستعارًا غير حساس لحالة الأحرف لـ arrayJoin بصيغة استدعاء الدالة (SELECT unnest(arr)). لا تُدعم صيغة PostgreSQL لمصدر الجدول (FROM unnest(...) وCROSS JOIN UNNEST(...) وLATERAL). استخدم عبارة ARRAY JOIN لهذه الاستعلامات.

لا يمكن استخدام arrayJoin، بما في ذلك عبر اسمها المستعار unnest، في شرط JOIN ON يُقيَّم أثناء الربط، لأن مثل هذا الشرط يجب أن يحافظ على عدد الصفوف. ويُستخرج قبل الربط الشرط الذي ينطبق على جانب واحد فقط، وكذلك مفتاح المساواة المعتمد على arrayJoin، ولا يتأثر أيٌّ منهما بذلك. كما لا يتأثر شرط ALL INNER JOIN الذي لا يتضمن OR، لأن الشرط يُطبَّق هناك بعد الربط بدلًا من ذلك. عندما يعتمد التوسيع على جانب واحد فقط، انقله إلى ARRAY JOIN في استعلام فرعي قبل الربط؛ أما الشرط الذي تقرأ وسيطة arrayJoin فيه أعمدة من كلا الجانبين فيجب إعادة هيكلته.

بنية

arrayJoin(arr)

اسم بديل: unnest

الوسيطة

• arr — مصفوفة يُراد فردها. Array(T)

القيمة المعادة

تُرجِع مجموعة من الصفوف الناتجة عن فرد arr.

أمثلة

الاستخدام الأساسي

SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src

┌─dst─┬─'Hello'─┬─src─────┐
│   1 │ Hello   │ [1,2,3] │
│   2 │ Hello   │ [1,2,3] │
│   3 │ Hello   │ [1,2,3] │
└─────┴─────────┴─────────┘

arrayJoin يؤثر في جميع أجزاء الاستعلام

-- The arrayJoin function affects all sections of the query, including the WHERE section. Notice the result 2, even though the subquery returned 1 row.

SELECT sum(1) AS impressions
FROM
(
    SELECT ['Istanbul', 'Berlin', 'Bobruisk'] AS cities
)
WHERE arrayJoin(cities) IN ['Istanbul', 'Berlin'];

┌─impressions─┐
│           2 │
└─────────────┘

استخدام دوال arrayJoin متعددة

-- A query can use multiple arrayJoin functions. In this case, the transformation is performed multiple times and the rows are multiplied.

SELECT
    sum(1) AS impressions,
    arrayJoin(cities) AS city,
    arrayJoin(browsers) AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3
ORDER BY
    city,
    browser

┌─impressions─┬─city─────┬─browser─┐
│           2 │ Berlin   │ Chrome  │
│           1 │ Berlin   │ Firefox │
│           2 │ Bobruisk │ Chrome  │
│           1 │ Bobruisk │ Firefox │
│           2 │ Istanbul │ Chrome  │
│           1 │ Istanbul │ Firefox │
└─────────────┴──────────┴─────────┘

نتائج غير متوقعة بسبب التحسينات

-- Using multiple arrayJoin with the same expression may not produce the expected result due to optimizations.
-- For these cases, consider modifying the repeated array expression with extra operations that do not affect join result.
-- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))

SELECT
    arrayJoin(dice) as first_throw,
    /* arrayJoin(dice) as second_throw */ -- is technically correct, but will annihilate result set
    arrayJoin(arrayConcat(dice, [])) as second_throw -- intentionally changed expression to force re-evaluation
FROM (
    SELECT [1, 2, 3, 4, 5, 6] as dice
);

┌─first_throw─┬─second_throw─┐
│           1 │            1 │
│           1 │            2 │
│           1 │            3 │
│           1 │            4 │
│           1 │            5 │
│           1 │            6 │
│           2 │            1 │
│           2 │            2 │
│           2 │            3 │
│           2 │            4 │
│           2 │            5 │
│           2 │            6 │
│           3 │            1 │
│           3 │            2 │
│           3 │            3 │
│           3 │            4 │
│           3 │            5 │
│           3 │            6 │
│           4 │            1 │
│           4 │            2 │
│           4 │            3 │
│           4 │            4 │
│           4 │            5 │
│           4 │            6 │
│           5 │            1 │
│           5 │            2 │
│           5 │            3 │
│           5 │            4 │
│           5 │            5 │
│           5 │            6 │
│           6 │            1 │
│           6 │            2 │
│           6 │            3 │
│           6 │            4 │
│           6 │            5 │
│           6 │            6 │
└─────────────┴──────────────┘

استخدام بنية ARRAY JOIN

-- Note the ARRAY JOIN syntax in the `SELECT` query below, which provides broader possibilities.
-- ARRAY JOIN allows you to convert multiple arrays with the same number of elements at a time.

SELECT
    sum(1) AS impressions,
    city,
    browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
ARRAY JOIN
    cities AS city,
    browsers AS browser
GROUP BY
    2,
    3
ORDER BY
    2,
    3

┌─impressions─┬─city─────┬─browser─┐
│           1 │ Berlin   │ Chrome  │
│           1 │ Bobruisk │ Chrome  │
│           1 │ Istanbul │ Firefox │
└─────────────┴──────────┴─────────┘

استخدام Tuple

-- You can also use Tuple

SELECT
    sum(1) AS impressions,
    (arrayJoin(arrayZip(cities, browsers)) AS t).1 AS city,
    t.2 AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3
ORDER BY
    2,
    3

┌─impressions─┬─city─────┬─browser─┐
│           1 │ Berlin   │ Chrome  │
│           1 │ Bobruisk │ Chrome  │
│           1 │ Istanbul │ Firefox │
└─────────────┴──────────┴─────────┘

أُضيفت في: v1.1.0

تُرجِع آخر عنصر في المصفوفة المصدر تُرجِع له دالة لامبدا func(x [, y1, y2, ... yN]) القيمة true، وإلا فتُرجِع قيمة افتراضية.

الصياغة

arrayLast(func(x[, y1, ..., yN]), source[, cond1, ... , condN_arr])

الوسيطات

• func(x[, y1, ..., yN]) — دالة لامبدا تُطبَّق على عناصر المصفوفة المصدر (x) ومصفوفات الشرط (y). دالة لامبدا. - source — المصفوفة المصدر المطلوب معالجتها. Array(T). - [, cond1, ... , condN] — اختياري. N من مصفوفات الشرط التي توفّر وسيطات إضافية لدالة لامبدا. Array(T).

القيمة المُعادة

تعيد آخر عنصر من المصفوفة المصدر تكون func صحيحةً له، وإلا فتعيد القيمة الافتراضية لـ T.

أمثلة

مثال على الاستخدام

SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

c

لا يوجد تطابق

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

0	UInt8

أُضيفت في: v1.1.0

تُرجع فهرس آخر عنصر في المصفوفة المصدر تُرجع الدالة func(x[, y1, y2, ... yN]) له القيمة true، وإلا فتُرجع '0'.

البنية

arrayLastIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

الوسيطات

• func(x[, y1, ..., yN]) — دالة لامبدا تعمل على عناصر مصفوفة المصدر (x) ومصفوفات الشرط (y). Lambda function
• source_arr — مصفوفة المصدر المطلوب معالجتها. Array(T)
• [, cond1_arr, ... , condN_arr] — اختياري. عدد N من مصفوفات الشرط التي توفّر وسيطات إضافية لدالة لامبدا. Array(T)

القيمة المعادة

يعيد فهرس آخر عنصر في مصفوفة المصدر تكون الدالة func صحيحة له، وإلا يعيد 0 UInt32

أمثلة

مثال على الاستخدام

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);

3

لا توجد مطابقة

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);

0

أُضيف في: v1.1.0

يعيد آخر عنصر في المصفوفة الأصلية تُرجع له دالة lambda func(x [, y1, y2, ... yN]) القيمة true، وإلا فيُرجع NULL.

البنية

arrayLastOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

الوسيطات

• func(x [, y1, ..., yN]) — دالة لامبدا تعمل على عناصر المصفوفة المصدر (x) ومصفوفات الشرط (y). دالة لامبدا. - source_arr — المصفوفة المصدر المراد معالجتها. Array(T). - [, cond1_arr, ... , condN_arr] — اختياري. عدد N من مصفوفات الشرط التي توفّر وسيطات إضافية لدالة لامبدا. Array(T).

القيمة المعادة

تعيد آخر عنصر من المصفوفة المصدر لا تكون قيمة λ له true، وإلا فتعيد NULL.

أمثلة

مثال على الاستخدام

SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

c

لا يوجد تطابق

SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

\N	Nullable(UInt8)

قُدِّمت في: v25.4.0

تحسب مسافة Levenshtein بين مصفوفتين.

البنية

arrayLevenshteinDistance(from, to)

الوسيطات

• from — المصفوفة الأولى. Array(T). - to — المصفوفة الثانية. Array(T).

القيمة المعادة

مسافة Levenshtein بين المصفوفتين الأولى والثانية. Float64

أمثلة

مثال للاستخدام

SELECT arrayLevenshteinDistance([1, 2, 4], [1, 2, 3])

1

قُدِّمت في: v25.4.0

تحسب مسافة ليفنشتاين لمصفوفتين باستخدام أوزان مخصصة لكل عنصر. يجب أن يتطابق عدد عناصر المصفوفة مع عدد الأوزان الخاصة بها.

الصيغة

arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)

الوسيطات

• from — المصفوفة الأولى. Array(T). - to — المصفوفة الثانية. Array(T). - from_weights — أوزان المصفوفة الأولى. Array((U)Int*|Float*)
• to_weights — أوزان المصفوفة الثانية. Array((U)Int*|Float*)

القيمة المُعادة

مسافة Levenshtein بين المصفوفتين الأولى والثانية مع أوزان مخصّصة لكل عنصر Float64

أمثلة

مثال استخدام

SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])

14

أُضيفت في: v1.1.0

تُرجِع مصفوفةً ناتجةً من المصفوفات الأصلية بتطبيق دالة لامدا على كل عنصر.

البنية

arrayMap(func, arr)

الوسائط

• func — دالة لامبدا تعمل على عناصر المصفوفة المصدر (x) ومصفوفات الشرط (y). Lambda function
• arr — عدد N من المصفوفات المطلوب معالجتها. Array(T)

القيمة المُعادة

تعيد مصفوفة من نتائج دالة لامبدا Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;

[3,4,5]

إنشاء tuple من عناصر مأخوذة من مصفوفات مختلفة

SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res

[(1,4),(2,5),(3,6)]

قُدِّمت في: v21.1.0

تُرجع أكبر عنصر في مصفوفة الإدخال.

إذا جرى تحديد دالة لامدا func، فتُرجع أكبر عنصر من نتائج دالة لامدا.

الصياغة

arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

الوسيطات

• func(x[, y1, ..., yN]) — اختياري. دالة لامدا تعمل على عناصر المصفوفة المصدر (x) ومصفوفات الشروط (y). دالة لامدا
• source_arr — المصفوفة المصدر المطلوب معالجتها. Array(T)
• [, cond1_arr, ... , condN_arr] — اختياري. N من مصفوفات الشروط التي توفّر وسيطات إضافية لدالة لامدا. Array(T)

القيمة المُعادة

تعيد أكبر عنصر في المصفوفة المصدر، أو أكبر عنصر من نتائج دالة لامدا إذا تم توفيرها.

أمثلة

مثال أساسي

SELECT arrayMax([5, 3, 2, 7]);

7

الاستخدام مع دالة Lambda

SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

12

ظهر لأول مرة في: v21.1.0

يُرجع أصغر عنصر في المصفوفة المصدر.

إذا تم تحديد دالة لامبدا func، فسيُرجع أصغر عنصر من نتائج دالة لامبدا.

البنية

arrayMin([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

الوسائط

• func(x[, y1, ..., yN]) — اختياري. دالة لامبدا تعمل على عناصر مصفوفة المصدر (x) ومصفوفات الشرط (y). دالة لامبدا
• source_arr — مصفوفة المصدر المطلوب معالجتها. Array(T)
• cond1_arr, ... — اختياري. عدد N من مصفوفات الشرط التي توفّر معاملات إضافية لدالة لامبدا. Array(T)

القيمة المُعادة

تعيد أصغر عنصر في مصفوفة المصدر، أو أصغر عنصر من نتائج دالة لامبدا إذا تم توفيرها.

أمثلة

مثال أساسي

SELECT arrayMin([5, 3, 2, 7]);

2

الاستخدام مع دالة lambda

SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

4

قُدِّم في: v25.1.0

يحسب معامل جيني المُطبَّع.

الصيغة

arrayNormalizedGini(predicted, label)

الوسيطات

• predicted — القيمة المتوقعة. Array(T)
• label — القيمة الفعلية. Array(T)

القيمة المُعادة

Tuple يحتوي على معاملات جيني للقيم المتوقعة، ومعامل جيني للقيم المُطبَّعة، ومعامل جيني المُطبَّع (= نسبة معاملي جيني السابقين) Tuple(Float64, Float64, Float64)

أمثلة

مثال على الاستخدام

SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7],[6, 1, 0, 2]);

(0.18055555555555558,0.2638888888888889,0.6842105263157896)

أُضيفت في: v23.2.0

هذه الدالة مماثلة لـ arrayReverseSort، ولكنها تتضمن وسيطة limit إضافية تتيح الفرز الجزئي.

البنية

arrayPartialReverseSort([f,] limit, arr [, arr1, ... ,arrN])

الوسائط

• f(arr[, arr1, ... ,arrN]) — دالة لامبدا المطلوب تطبيقها على عناصر المصفوفة x. Lambda function
• limit — قيمة الفهرس التي يُجرى الفرز حتى الوصول إليها. (U)Int*
• arr — المصفوفة المطلوب فرزها. Array(T)
• arr1, ... ,arrN — N من المصفوفات الإضافية، في حال كانت f تقبل عدة وسائط. Array(T)

القيمة المعادة

تعيد مصفوفةً بالحجم نفسه للمصفوفة الأصلية، بحيث تكون العناصر ضمن النطاق [1..limit] مرتبة ترتيبًا تنازليًا. أما العناصر المتبقية (limit..N] فتكون بترتيب غير محدد.

أمثلة

simple_int

SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])

[9,5,1,3]

simple_string

SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])

['lasso','gladly','expenses','embolism']

retain_sorted

SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)

[9,5]

lambda_simple

SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])

[1,3,5,9]

lambda_complex

SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

[0,1,2]

أُضيف في: v23.2.0

تعيد هذه الدالة مصفوفة بالحجم نفسه للمصفوفة الأصلية، بحيث تكون العناصر ضمن النطاق [1..limit] مجموعة فرعية عشوائية من المصفوفة الأصلية. أما العناصر المتبقية ضمن (limit..n] فتحتوي على العناصر غير الموجودة في النطاق [1..limit] بترتيب غير محدد. يجب أن تكون قيمة limit ضمن النطاق [1..n]. أما القيم الواقعة خارج هذا النطاق فتعادل تنفيذ arrayShuffle بالكامل:

الصياغة

arrayPartialShuffle(arr [, limit[, seed]])

الوسائط

• arr — المصفوفة المراد خلط عناصرها. Array(T)
• seed — اختياري. البذرة المستخدمة في توليد الأرقام العشوائية. وإذا لم تُوفَّر، تُستخدم بذرة عشوائية. (U)Int*
• limit — اختياري. العدد الذي يُستخدم لتقييد عدد تبديلات العناصر، ضمن النطاق [1..N]. (U)Int*

القيمة المُعادة

مصفوفة عناصرها مخلوطة جزئيًا. Array(T)

أمثلة

no_limit1

SELECT arrayPartialShuffle([1, 2, 3, 4], 0)

[2, 4, 3, 1]

no_limit2

SELECT arrayPartialShuffle([1, 2, 3, 4])

[2,3,4,1]

random_seed

SELECT arrayPartialShuffle([1, 2, 3, 4], 2)

[3, 4, 1, 2]

explicit_seed

SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)

[3,2,1,4]

materialize

SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)

┌─arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42)─┬─arrayPartialShuffle([1, 2, 3], 2, 42)─┐
│ [3,2,1,4]                                             │ [3,2,1]                               │
│ [3,2,1,4]                                             │ [3,1,2]                               │
│ [4,3,2,1]                                             │ [1,3,2]                               │
│ [1,4,3,2]                                             │ [2,1,3]                               │
│ [3,4,1,2]                                             │ [3,2,1]                               │
│ [1,2,3,4]                                             │ [3,2,1]                               │
│ [1,4,3,2]                                             │ [1,2,3]                               │
│ [1,4,3,2]                                             │ [3,2,1]                               │
│ [3,1,2,4]                                             │ [3,2,1]                               │
│ [1,3,2,4]                                             │ [2,1,3]                               │
└───────────────────────────────────────────────────────┴───────────────────────────────────────┘

تم تقديمها في: v23.2.0

هذه الدالة مماثلة لـ arraySort، ولكنها تتضمن وسيطة limit إضافية تتيح الفرز الجزئي.

الصياغة

arrayPartialSort([f,] limit, arr [, arr1, ... ,arrN])

الوسائط

• f(arr[, arr1, ... ,arrN]) — دالة لامبدا المُطبَّقة على عناصر المصفوفة x. Lambda function
• limit — قيمة الفهرس التي سيجري الفرز حتى الوصول إليها. (U)Int*
• arr — المصفوفة المطلوب فرزها. Array(T)
• arr1, ... ,arrN — عدد N من المصفوفات الإضافية، في حال كانت f تقبل عدة وسائط. Array(T)

القيمة المُعادة

تُعيد مصفوفة بالحجم نفسه للمصفوفة الأصلية، بحيث تكون العناصر ضمن النطاق [1..limit] مرتبة ترتيبًا تصاعديًا. أما العناصر المتبقية (limit..N] فتكون بترتيب غير محدد.

أمثلة

simple_int

SELECT arrayPartialSort(2, [5, 9, 1, 3])

[1,3,5,9]

simple_string

SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])

['embolism','expenses','gladly','lasso']

retain_sorted

SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)

[1,3]

lambda_simple

SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])

[9,5,1,3]

lambda_complex

SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

[2,1,0]

تم تقديمه في: v1.1.0

يزيل العنصر الأخير من المصفوفة.

الصيغة

arrayPopBack(arr)

الوسائط

• arr — المصفوفة التي يُزال منها العنصر الأخير. Array(T)

القيمة المعادة

يعيد مصفوفة مطابقة لـ arr ولكن من دون العنصر الأخير منها Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayPopBack([1, 2, 3]) AS res;

[1,2]

أُضيفت في: v1.1.0

يزيل العنصر الأول من المصفوفة.

الصياغة

arrayPopFront(arr)

الوسائط

• arr — المصفوفة التي يُزال منها العنصر الأول. Array(T)

القيمة المُعادة

يُرجع مصفوفة مطابقة لـ arr ولكن من دون العنصر الأول فيها Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayPopFront([1, 2, 3]) AS res;

[2,3]

مُقدَّم في: v21.1.0

يُرجِع حاصل ضرب عناصر المصفوفة المصدر.

إذا جرى تحديد دالة لامبدا func، فإنه يُرجِع حاصل ضرب عناصر نتائج اللامبدا.

الصياغة

arrayProduct([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

الوسائط

• func(x[, y1, ..., yN]) — اختياري. دالة لامدا تعمل على عناصر مصفوفة المصدر (x) ومصفوفات الشرط (y). Lambda function
• source_arr — مصفوفة المصدر المراد معالجتها. Array(T)
• [, cond1_arr, ... , condN_arr] — اختياري. ‏N من مصفوفات الشرط التي توفّر وسائط إضافية لدالة لامدا. Array(T)

القيمة المعادة

تعيد حاصل ضرب العناصر في مصفوفة المصدر، أو حاصل ضرب العناصر الناتجة عن دالة لامدا إذا تم توفيرها. Float64

أمثلة

مثال أساسي

SELECT arrayProduct([1, 2, 3, 4]);

24

الاستخدام مع دالة lambda

SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;

16

أُضيفت في: v1.1.0

تُضيف عنصرًا واحدًا إلى نهاية المصفوفة.

الصيغة

arrayPushBack(arr, x)

الوسيطات

• arr — المصفوفة التي تُضاف القيمة x إلى نهايتها. Array(T)
• x —
• قيمة واحدة تُضاف إلى نهاية المصفوفة. Array(T).

القيمة المُعادة

تعيد مصفوفة مطابقة لـ arr ولكن مع إضافة القيمة x إلى نهاية المصفوفة Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayPushBack(['a'], 'b') AS res;

['a','b']

أُضيفت في: v1.1.0

تضيف عنصرًا واحدًا إلى بداية المصفوفة.

الصياغة

arrayPushFront(arr, x)

الوسيطات

• arr — المصفوفة التي تُضاف القيمة x إلى نهايتها. Array(T). - x —
• قيمة مفردة تُضاف إلى بداية المصفوفة. Array(T).

القيمة المُعادة

تعيد مصفوفة مطابقة لـ arr، ولكن مع قيمة إضافية x في بداية المصفوفة Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayPushFront(['b'], 'a') AS res;

['a','b']

استُحدث في: v20.4.0

يحسب المساحة تحت منحنى خصائص تشغيل المستقبِل (ROC). يُنشأ منحنى ROC برسم معدل الإيجابيات الحقيقية (TPR) على المحور y ومعدل الإيجابيات الكاذبة (FPR) على المحور x عبر جميع العتبات. وتتراوح القيمة الناتجة بين صفر وواحد، وتشير القيمة الأعلى إلى أداء أفضل للنموذج.

يُعد ROC AUC (ويُعرف أيضًا اختصارًا باسم AUC) مفهومًا في تعلّم الآلة. لمزيد من التفاصيل، يُرجى الاطلاع هنا، وهنا، وهنا.

الصيغة

arrayROCAUC(scores, labels[, scale[, partial_offsets]])

الأسماء البديلة: arrayAUC

الوسائط

• scores — الدرجات التي ينتجها نموذج التنبؤ. Array((U)Int*) أو Array(Float*)
• labels — تسميات العينات، وعادةً تكون 1 للعينة الإيجابية و0 للعينة السلبية. Array((U)Int*) أو Enum
• scale — اختياري. يحدد ما إذا كان سيُرجِع المساحة المُطبَّعة. إذا كانت القيمة false، فسيُرجِع بدلًا من ذلك المساحة تحت منحنى TP (الإيجابيات الحقيقية) × FP (الإيجابيات الكاذبة). القيمة الافتراضية: true. Bool
• partial_offsets —
• مصفوفة من أربعة أعداد صحيحة غير سالبة تُستخدم لحساب مساحة جزئية تحت منحنى ROC (وهو ما يعادل شريطًا رأسيًا في فضاء ROC) بدلًا من AUC بالكامل. يفيد هذا الخيار في الحساب الموزع لـ ROC AUC. يجب أن تحتوي المصفوفة على العناصر التالية [higher_partitions_tp, higher_partitions_fp, total_positives, total_negatives]. Array من Integers غير سالبة. اختياري.
  • higher_partitions_tp: عدد التسميات الإيجابية في الأقسام ذات الدرجات الأعلى.
  • higher_partitions_fp: عدد التسميات السلبية في الأقسام ذات الدرجات الأعلى.
  • total_positives: العدد الإجمالي للعينات الإيجابية في مجموعة البيانات بالكامل.
  • total_negatives: العدد الإجمالي للعينات السلبية في مجموعة البيانات بالكامل.

القيمة المُعادة

تُرجِع المساحة تحت منحنى خصائص تشغيل المستقبِل (ROC). Float64

أمثلة

مثال على الاستخدام

SELECT arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);

0.75

أُضيفت في: v23.10.0

تعيد مجموعة فرعية تضم samples عنصرًا عشوائيًا من مصفوفة الإدخال. وإذا كانت قيمة samples أكبر من حجم مصفوفة الإدخال، فسيُقتصر حجم العيّنة على حجم المصفوفة، أي ستُعاد جميع عناصر المصفوفة، ولكن من دون ضمان ترتيبها. ويمكن للدالة التعامل مع كلٍّ من المصفوفات المسطحة والمصفوفات المتداخلة.

البنية

arrayRandomSample(arr, samples)

الوسيطات

• arr — مصفوفة الإدخال أو المصفوفة متعددة الأبعاد التي تُؤخذ منها عيّنة من العناصر. Array(T)
• samples — عدد العناصر التي ستُدرج في العيّنة العشوائية. (U)Int*

القيمة المعادة

مصفوفة تحتوي على عيّنة عشوائية من عناصر مصفوفة الإدخال Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;

['cherry','apple']

استخدام مصفوفة متعددة الأبعاد

SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;

[[3,4],[5,6]]

أُضيفت في: v1.1.0

تُطبِّق دالة تجميع على عناصر المصفوفة وتُرجِع ناتجها. يُمرَّر اسم دالة التجميع كسلسلة نصية بين علامتَي اقتباس مفردتَين 'max'، 'sum'. عند استخدام الدوال التجميعية ذات المعلمات، تُحدَّد المعلمة بعد اسم الدالة بين قوسين 'uniqUpTo(6)'.

البنية

arrayReduce(agg_f, arr1[, arr2, ... , arrN])

الوسيطات

• agg_f — اسم دالة تجميع، ويجب أن يكون قيمة ثابتة. String
• arr1[, arr2, ... , arrN] — N مصفوفات تقابل وسيطات agg_f. Array(T)

القيمة المُعادة

تعيد ناتج دالة التجميع

أمثلة

مثال على الاستخدام

SELECT arrayReduce('max', [1, 2, 3]);

┌─arrayReduce('max', [1, 2, 3])─┐
│                             3 │
└───────────────────────────────┘

مثال على استخدام دالة تجميعية بعدة وسيطات

--If an aggregate function takes multiple arguments, then this function must be applied to multiple arrays of the same size.

SELECT arrayReduce('maxIf', [3, 5], [1, 0]);

┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│                                    3 │
└──────────────────────────────────────┘

مثال على دالة تجميع مُعامِلية

SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│                                                           4 │
└─────────────────────────────────────────────────────────────┘

قُدِّمت في: v20.4.0

تُطبِّق دالةً تجميعية على عناصر المصفوفة ضمن النطاقات المحددة، وتُرجِع مصفوفةً تتضمن النتيجة المقابلة لكل نطاق. تُرجِع الدالة النتيجة نفسها كما لو استُخدم arrayReduce(agg_func, arraySlice(arr1, index, length), ...) عدة مرات.

الصياغة

arrayReduceInRanges(agg_f, ranges, arr1[, arr2, ... ,arrN])

الوسيطات

• agg_f — اسم الدالة التجميعية المراد استخدامها. String
• ranges — النطاق الذي سيُجرى عليه التجميع. وهي مصفوفة من قيم Tuple، (i, r)، تحتوي على الفهرس i الذي يبدأ منه التجميع، والنطاق r الذي سيُجرى عليه التجميع. Array(T) أو Tuple(T)
• arr1[, arr2, ... ,arrN] — عدد N من المصفوفات كوسيطات للدالة التجميعية. Array(T)

القيمة المعادة

تعيد مصفوفة تحتوي على نتائج الدالة التجميعية عبر النطاقات المحددة Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayReduceInRanges(
    'sum',
    [(1, 5), (2, 3), (3, 4), (4, 4)],
    [1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res

┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘

أُضيفت في: v25.11.0

تزيل جميع العناصر التي تساوي قيمةً معيّنة من المصفوفة. تُعامل قيم NULL على أنها متساوية.

الصيغة

arrayRemove(arr, elem)

الأسماء البديلة: array_remove

الوسيطات

• arr — Array(T) - elem — T

القيمة المُعادة

تعيد جزءًا فرعيًا من المصفوفة المصدر Array(T)

أمثلة

مثال 1

SELECT arrayRemove([1, 2, 2, 3], 2)

[1,3]

مثال 2

SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)

['a','b']

أُضيف في: v1.1.0

يغيّر طول المصفوفة.

الصياغة

arrayResize(arr, size[, extender])

المعاملات

• arr — المصفوفة المطلوب تغيير حجمها. Array(T)
• size — -الطول الجديد للمصفوفة. إذا كانت size أصغر من الحجم الأصلي للمصفوفة، فسيتم اقتطاع المصفوفة من اليمين. إذا كانت size أكبر من الحجم الأصلي للمصفوفة، فسيتم تمديد المصفوفة إلى اليمين باستخدام قيم extender أو القيم الافتراضية لنوع بيانات عناصر المصفوفة.
• extender — القيمة المستخدمة لتمديد المصفوفة. يمكن أن تكون NULL.

القيمة المعادة

مصفوفة بطول size. Array(T)

أمثلة

مثال 1

SELECT arrayResize([1], 3);

[1,0,0]

المثال 2

SELECT arrayResize([1], 3, NULL);

[1,NULL,NULL]

أُضيف في: v1.1.0

يعكس ترتيب عناصر المصفوفة المعطاة.

الصيغة

arrayReverse(arr)

الوسائط

• arr — المصفوفة المراد عكسها. Array(T)

القيمة المُعادة

تعيد مصفوفة بالحجم نفسه للمصفوفة الأصلية، وتحتوي على العناصر بترتيب عكسي. Array(T)

أمثلة

مثال للاستخدام

SELECT arrayReverse([1, 2, 3])

[3,2,1]

قُدِّمت في: v20.1.0

تعالج الدالة arrayReverseFill مصفوفة المصدر تسلسليًا من العنصر الأخير إلى الأول، مع تقييم شرط lambda عند كل موضع باستخدام عناصر من مصفوفة المصدر ومصفوفات الشرط. عندما يُقيَّم الشرط إلى القيمة false عند الموضع i، تستبدل الدالة ذلك العنصر بالعنصر الموجود عند الموضع i+1 من الحالة الحالية للمصفوفة. ويُحفَظ العنصر الأخير دائمًا بغض النظر عن أي شرط.

البنية

arrayReverseFill(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

الوسائط

• func(x[, y1, ..., yN]) — دالة لامبدا تعمل على عناصر المصفوفة المصدر (x) ومصفوفات الشرط (y). دالة لامبدا
• source_arr — المصفوفة المصدر المراد معالجتها. Array(T)
• [, cond1_arr, ... , condN_arr] — اختياري. N من مصفوفات الشرط التي توفّر وسائط إضافية لدالة لامبدا. Array(T)

القيمة المُعادة

تعيد مصفوفةً تُستبدل فيها عناصر المصفوفة المصدر بنتائج دالة لامبدا. Array(T)

أمثلة

مثال باستخدام مصفوفة واحدة

SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res

[1,2,2,NULL]

مثال على مصفوفتين

SELECT arrayReverseFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res;

[5,6,6,2]

أُضيفت في: v1.1.0

ترتّب عناصر المصفوفة ترتيبًا تنازليًا. إذا جرى تحديد الدالة f، فستُرتَّب المصفوفة المعطاة وفقًا لنتيجة تطبيق الدالة على عناصر المصفوفة، ثم تُعكس المصفوفة بعد ترتيبها. إذا كانت f تقبل عدة وسائط، فستُمرَّر عدة مصفوفات إلى الدالة arrayReverseSort بحيث تقابل وسائط func هذه المصفوفات.

إذا كانت المصفوفة المطلوب ترتيبها تحتوي على -Inf أو NULL أو NaN أو Inf، فسيكون ترتيبها كما يلي:

1. -Inf
2. Inf
3. NaN
4. NULL

تُعد arrayReverseSort دالة عالية الرتبة.

الصياغة

arrayReverseSort([f,] arr [, arr1, ... ,arrN])

الوسيطات

• f(y1[, y2 ... yN]) — دالة لامبدا تُطبَّق على عناصر المصفوفة x. - arr — مصفوفة مطلوب فرزها. Array(T) - arr1, ..., arrN — اختياري. عدد N من المصفوفات الإضافية، في حال كانت f تقبل عدة وسيطات.

القيمة المعادة

تعيد المصفوفة x مرتبةً ترتيبًا تنازليًا إذا لم يتم توفير دالة لامبدا، وإلا فتعيد مصفوفة مرتبة وفقًا لمنطق دالة لامبدا المقدَّمة، ثم معكوسة. Array(T).

أمثلة

مثال 1

SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;

[5,3,4]

مثال 2

SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;

[4,3,5]

تم تقديمه في: v20.1.0

قسّم مصفوفة المصدر إلى عدة مصفوفات. عندما تُرجِع func(x[, y1, ..., yN]) قيمة غير صفرية، تُقسَّم المصفوفة إلى يمين ذلك العنصر. ولا تُقسَّم المصفوفة بعد العنصر الأخير.

الصياغة

arrayReverseSplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

الوسائط

• func(x[, y1, ..., yN]) — دالة لامدا تعمل على عناصر المصفوفة المصدر (x) ومصفوفات الشرط (y). Lambda function
• source_arr — المصفوفة المصدر المطلوب معالجتها. Lambda function
• [, cond1_arr, ... , condN_arr] — اختياري. عدد N من مصفوفات الشرط التي توفّر وسائط إضافية لدالة لامدا. Array(T)

القيمة المُعادة

تعيد مصفوفة من المصفوفات. Array(Array(T))

أمثلة

مثال على الاستخدام

SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res

[[1],[2,3,4],[5]]

أُضيف في: v23.8.0

يُدوِّر مصفوفة إلى اليسار بعدد العناصر المحدد. وتُعامَل القيم السالبة لـ n على أنها تدوير إلى اليمين بمقدار القيمة المطلقة للتدوير.

الصياغة

arrayRotateLeft(arr, n)

الوسيطات

• arr — المصفوفة التي تُدوَّر عناصرها.Array(T). - n — عدد العناصر المراد تدويرها. (U)Int8/16/32/64.

القيمة المُعادة

مصفوفة بعد تدويرها إلى اليسار بعدد العناصر المحدد Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;

[3,4,5,6,1,2]

القيمة السالبة لـ n

SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;

[5,6,1,2,3,4]

تم تقديمه في: v23.8.0

يُدوِّر مصفوفة إلى اليمين بعدد العناصر المحدد. وتُعامَل القيم السالبة لـ n على أنها تدوير إلى اليسار بمقدار القيمة المطلقة.

البنية

arrayRotateRight(arr, n)

الوسيطات

• arr — المصفوفة المطلوب تدوير عناصرها.Array(T). - n — عدد العناصر المطلوب تدويرها. (U)Int8/16/32/64.

القيمة المُعادة

مصفوفة جرى تدويرها إلى اليمين بعدد العناصر المحدد Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;

[5,6,1,2,3,4]

عندما تكون قيمة n سالبة

SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;

[3,4,5,6,1,2]

أُضيف في: v23.8.0

تُزاح المصفوفة إلى اليسار بعدد العناصر المحدد. تُملأ العناصر الجديدة بالوسيطة المُمرَّرة أو بالقيمة الافتراضية لنوع عنصر المصفوفة. إذا كان عدد العناصر سالبًا، تُزاح المصفوفة إلى اليمين.

الصياغة

arrayShiftLeft(arr, n[, default])

المعاملات

• arr — المصفوفة المطلوب إزاحة عناصرها.Array(T). - n — عدد العناصر المطلوب إزاحتها.(U)Int8/16/32/64. - default — اختياري. القيمة الافتراضية للعناصر الجديدة.

القيمة المُعادة

مصفوفة مزاحة إلى اليسار بعدد العناصر المحدد Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;

[3,4,5,6,0,0]

القيمة السالبة لـ n

SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;

[0,0,1,2,3,4]

استخدام قيمة افتراضية

SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;

[3,4,5,6,42,42]

أُضيف في: v23.8.0

يُزيح مصفوفة إلى اليمين بعدد العناصر المحدد. تُملأ العناصر الجديدة بالوسيطة المُمرَّرة أو بالقيمة الافتراضية لنوع عنصر المصفوفة. إذا كان عدد العناصر سالبًا، فتُزاح المصفوفة إلى اليسار.

البنية

arrayShiftRight(arr, n[, default])

الوسيطات

• arr — المصفوفة المطلوب إزاحة عناصرها. Array(T)
• n — عدد العناصر المراد إزاحتها. (U)Int8/16/32/64
• default — اختياري. القيمة الافتراضية للعناصر الجديدة.

القيمة المُعادة

مصفوفة مُزاحة إلى اليمين بعدد العناصر المحدد. Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2) as res;

[0,0,1,2,3,4]

القيمة السالبة لـ n

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], -2) as res;

[3,4,5,6,0,0]

استخدام قيمة افتراضية

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2, 42) as res;

[42,42,1,2,3,4]

أُضيفت في: v24.1.0

تُنشئ مصفوفة من الشينغلز (على غرار ngrams في السلاسل النصية)، أي مصفوفات فرعية متتالية بطول محدد من مصفوفة الإدخال.

البنية

arrayShingles(arr, l)

الوسائط

• arr — المصفوفة التي سيتم إنشاء مصفوفة من shingles منها. Array(T)
• l — طول كل shingle. (U)Int*

القيمة المُعادة

مصفوفة shingles المُنشأة Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayShingles([1, 2, 3, 4], 3) as res;

[[1,2,3],[2,3,4]]

أُضيفت في: v23.2.0

تعيد مصفوفةً بالحجم نفسه للمصفوفة الأصلية، مع عناصرها بترتيب عشوائي. تُعادُ ترتيب العناصر بحيث يكون لكل ترتيب ممكن لهذه العناصر الاحتمال نفسه للظهور.

الصياغة

arrayShuffle(arr [, seed])

الوسيطات

• arr — المصفوفة المراد خلطها. Array(T)
• seed (optional) — اختياري. البذرة المستخدمة في توليد الأرقام العشوائية. وإذا لم تُوفَّر، تُستخدم بذرة عشوائية. (U)Int*

القيمة المُعادة

مصفوفة بعد خلط عناصرها Array(T)

أمثلة

مثال بدون seed (نتائج غير مستقرة)

SELECT arrayShuffle([1, 2, 3, 4]);

[1,4,2,3]

مثال من دون seed (نتائج ثابتة)

SELECT arrayShuffle([1, 2, 3, 4], 41);

[3,2,1,4]

تم تقديمها في: v25.4.0

تحسب درجة التشابه بين مصفوفتين من 0 إلى 1 استنادًا إلى مسافة Levenshtein الموزونة.

البنية

arraySimilarity(from, to, from_weights, to_weights)

الوسيطات

• from — المصفوفة الأولى Array(T)
• to — المصفوفة الثانية Array(T)
• from_weights — الأوزان الخاصة بالمصفوفة الأولى. Array((U)Int*|Float*)
• to_weights — الأوزان الخاصة بالمصفوفة الثانية. Array((U)Int*|Float*)

القيمة المُعادة

يعيد قيمة التشابه بين المصفوفتين ضمن النطاق 0 إلى 1 استنادًا إلى مسافة Levenshtein الموزونة Float64

أمثلة

مثال على الاستخدام

SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);

0.2222222222222222

أُضيف في: v1.1.0

يعيد جزءًا من المصفوفة، مع تضمين عناصر NULL.

قد تكون الوسيطة الأولى أيضًا QBit: تكون النتيجة QBit على الأبعاد المحددة (إسقاطًا على مجموعة فرعية من الأبعاد). في هذه الحالة، يجب أن يكون offset وlength ثابتين، لأن بُعد QBit جزء من نوعه، ويجب أن تحدد الشريحة بُعدًا واحدًا على الأقل. تحتفظ الشريحة المحاذاة لحدود مجموعات stride في QBit بالـ stride وتعيد استخدام تدفقات مستويات البت المخزنة دون نسخ.

الصياغة

arraySlice(arr, offset [, length])

الوسيطات

• arr — المصفوفة المطلوب أخذ شريحة منها. Array(T) أو QBit
• offset — الإزاحة من طرف المصفوفة. تشير القيمة الموجبة إلى إزاحة من اليسار، وتشير القيمة السالبة إلى إزاحة من اليمين. يبدأ ترقيم عناصر المصفوفة من 1. (U)Int*
• length — طول الشريحة المطلوبة. إذا حددت قيمة سالبة، فستُرجع الدالة شريحة مفتوحة [offset, array_length - length]. وإذا حذفت القيمة، فستُرجع الدالة الشريحة [offset, the_end_of_array]. (U)Int*

القيمة المُعادة

ترجع شريحة من المصفوفة تتكون من length عنصرًا بدءًا من offset المحدد Array(T)

أمثلة

مثال على الاستخدام

SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;

[2,NULL,4]

أُضيفت في: v1.1.0

ترتّب عناصر المصفوفة المُعطاة بترتيب تصاعدي. إذا جرى تحديد دالة لامبدا f، فإن ترتيب الفرز يتحدّد بناءً على نتيجة تطبيق دالة لامبدا على كل عنصر من عناصر المصفوفة. إذا كانت دالة لامبدا تقبل عدة وسائط، فسيُمرَّر إلى الدالة arraySort عدة مصفوفات تقابل وسائط f.

إذا كانت المصفوفة المطلوب فرزها تحتوي على -Inf أو NULL أو NaN أو Inf، فسيجري فرزها بالترتيب التالي:

1. -Inf
2. Inf
3. NaN
4. NULL

arraySort هي دالة عالية الرتبة.

البنية

arraySort([f,] arr [, arr1, ... ,arrN])

الوسائط

• f(y1[, y2 ... yN]) — دالة لامدا تُطبَّق على عناصر المصفوفة x. - arr — المصفوفة المطلوب فرزها. Array(T) - arr1, ..., arrN — اختياري. عدد N من المصفوفات الإضافية، وذلك عندما تقبل f عدة وسائط.

القيمة المُعادة

تُعيد المصفوفة arr مرتبةً ترتيبًا تصاعديًا إذا لم يتم توفير دالة لامدا، وإلا فإنها تُعيد مصفوفة مرتبة وفقًا للمنطق الذي تحدده دالة لامدا المُقدَّمة. Array(T).

أمثلة

مثال 1

SELECT arraySort([1, 3, 3, 0]);

[0,1,3,3]

مثال 2

SELECT arraySort(['hello', 'world', '!']);

['!','hello','world']

مثال 3

SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);

[-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]

استُحدثت في: v20.1.0

قسِّم المصفوفة المصدر إلى عدة مصفوفات. عندما تُرجِع func(x [, y1, ..., yN]) قيمةً غير صفرية، ستُقسَّم المصفوفة إلى يسار ذلك العنصر. لن تُقسَّم المصفوفة قبل العنصر الأول.

الصياغة

arraySplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

الوسائط

• func(x[, y1, ..., yN]) — دالة لامبدا تُطبَّق على عناصر المصفوفة المصدر (x) ومصفوفات الشروط (y).دالة لامبدا. - source_arr — المصفوفة المصدر المطلوب تقسيمها Array(T). - [, cond1_arr, ... , condN_arr] — اختياري. عدد N من مصفوفات الشروط التي توفّر وسائط إضافية لدالة لامبدا. Array(T).

القيمة المعادة

تعيد مصفوفة من المصفوفات Array(Array(T))

أمثلة

مثال على الاستخدام

SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res

[[1,2,3],[4,5]]

تم تقديمه في: v21.1.0

يعيد مجموع عناصر المصفوفة المصدر.

إذا جرى تحديد دالة لامبدا func، فإنه يعيد مجموع عناصر نتائج لامبدا.

البنية

arraySum([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

الوسيطات

• func(x[, y1, ..., yN]) — اختياري. دالة لامبدا تعمل على عناصر المصفوفة المصدر (x) ومصفوفات الشرط (y). دالة لامبدا
• source_arr — المصفوفة المصدر المطلوب معالجتها. Array(T)
• , cond1_arr, ... , condN_arr] — اختياري. عدد N من مصفوفات الشرط التي توفّر وسيطات إضافية لدالة لامبدا. Array(T)

القيمة المُعادة

تعيد مجموع العناصر في المصفوفة المصدر، أو مجموع عناصر نتائج دالة لامبدا إذا تم توفيرها.

أمثلة

مثال أساسي

SELECT arraySum([1, 2, 3, 4]);

10

الاستخدام مع دالة Lambda

SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);

8

أُضيفت في: v25.4.0

تأخذ هذه الدالة عدة مصفوفات وتُرجع مصفوفة بالعناصر غير الموجودة في جميع مصفوفات الإدخال. ولا تتضمن النتيجة إلا قيماً فريدة.

البنية

arraySymmetricDifference(arr1, arr2, ... , arrN)

الوسائط

• arrN — ‏N من المصفوفات التي ستُنشأ منها المصفوفة الجديدة. Array(T).

القيمة المُعادة

يعيد مصفوفة من العناصر المميّزة غير الموجودة في جميع مصفوفات المصدر Array(T)

أمثلة

مثال على الاستخدام

SELECT
arraySymmetricDifference([1, 2], [1, 2], [1, 2]) AS empty_symmetric_difference,
arraySymmetricDifference([1, 2], [1, 2], [1, 3]) AS non_empty_symmetric_difference;

┌─empty_symmetric_difference─┬─non_empty_symmetric_difference─┐
│ []                         │ [3,2]                          │
└────────────────────────────┴────────────────────────────────┘

أُضيفت في: v26.6.0

تُرجِع مصفوفة تحتوي على أكبر K عناصر من مصفوفة الإدخال، مرتبة ترتيبًا تنازليًا. إذا جرى تحديد lambda function ‏f، فتُقارَن العناصر بناءً على ناتج تطبيق f على كل عنصر. إذا كانت f تقبل عدة وسيطات، فستُمرَّر مصفوفات إضافية إلى arrayTopK، وتكون عناصرها مطابقةً لوسيطات f.

تُتخطى القيم NULL ولا تظهر في النتيجة. ويكون حجم النتيجة بحد أقصى K وقد يكون أصغر إذا كانت مصفوفة الإدخال تحتوي على عدد من العناصر غير NULL أقل من K. ويكون نوع عنصر النتيجة هو النظير غير القابل لـ NULL لنوع عنصر الإدخال.

تُعد arrayTopK دالة من الرتبة العليا.

انظر أيضًا إلى arrayBottomK، التي تُرجِع أصغر K عناصر بدلًا من ذلك.

الصياغة

arrayTopK([f,] K, arr [, arr1, ... ,arrN])

الوسائط

• f(arr[, arr1, ... ,arrN]) — اختياري. دالة لامبدا لحساب مفتاح الترتيب لكل عنصر. دالة لامبدا
• K — عدد أكبر العناصر المراد إرجاعها. (U)Int8/16/32/64
• arr — مصفوفة. Array(T)
• arr1, ... ,arrN — ‏N من المصفوفات الإضافية، إذا كانت f تقبل عدة وسائط. Array(T)

القيمة المعادة

تُرجع ما يصل إلى K من عناصر arr ذات القيم الأكبر (أو أكبر نواتج دالة لامبدا)، مرتبة ترتيبًا تنازليًا. تُتخطى قيم NULL. ويكون نوع عنصر المصفوفة المعادة هو T حتى عندما يكون الإدخال من النوع Nullable(T).

أمثلة

simple_int

SELECT arrayTopK(3, [1, 5, 2, 7, 3])

[7,5,3]

skip_nulls

SELECT arrayTopK(3, [1, NULL, 5, 2, NULL, 7])

[7,5,2]

fewer_than_k

SELECT arrayTopK(5, [1, NULL, 2])

[2,1]

lambda_simple

SELECT arrayTopK((x) -> -x, 2, [5, 9, 1, 3])

[1,3]

lambda_multi

SELECT arrayTopK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])

['a','c']

استُحدث في: v26.4.0

يبدّل صفوف المصفوفة ثنائية الأبعاد وأعمدتها.

يجب أن تكون جميع المصفوفات الداخلية بالطول نفسه.

الصيغة

arrayTranspose(arr)

الوسائط

• arr — مصفوفة ثنائية الأبعاد يُراد نقلها. يجب أن يكون طول جميع المصفوفات الداخلية متماثلًا. Array(Array(T))

القيمة المعادة

مصفوفة ثنائية الأبعاد منقولة، بحيث يكون العنصر [i][j] في النتيجة مساويًا للعنصر [j][i] في المُدخل. Array(Array(T))

أمثلة

مصفوفة مربعة

SELECT arrayTranspose([[1, 2], [3, 4]])

[[1,3],[2,4]]

مصفوفة غير مربعة

SELECT arrayTranspose([[1, 2, 3], [4, 5, 6]])

[[1,4],[2,5],[3,6]]

عناصر من النوع String

SELECT arrayTranspose([['a', 'b'], ['c', 'd']])

[['a','c'],['b','d']]

أُضيف في: v24.10.0

يأخذ عدة مصفوفات ويُرجع مصفوفةً تتضمن جميع العناصر الموجودة في أيٍّ من المصفوفات المصدرية. وتحتوي النتيجة على قيم فريدة فقط.

الصياغة

arrayUnion(arr1, arr2, ..., arrN)

الوسائط

• arrN — عدد N من المصفوفات التي تُنشأ منها المصفوفة الجديدة. Array(T)

القيمة المعادة

تعيد مصفوفة تضم عناصر مميزة من المصفوفات المصدر Array(T)

أمثلة

مثال على الاستخدام

SELECT
arrayUnion([-2, 1], [10, 1], [-2], []) as num_example,
arrayUnion(['hi'], [], ['hello', 'hi']) as str_example,
arrayUnion([1, 3, NULL], [2, 3, NULL]) as null_example

┌─num_example─┬─str_example────┬─null_example─┐
│ [10,-2,1]   │ ['hello','hi'] │ [3,2,1,NULL] │
└─────────────┴────────────────┴──────────────┘

قُدِّمت في: v1.1.0

عند تمرير وسيط واحد، تحسب عدد العناصر المختلفة في المصفوفة. وعند تمرير عدة وسائط، تحسب عدد tuples المختلفة المتكوِّنة من العناصر الموجودة في المواضع المتطابقة عبر عدة مصفوفات.

على سبيل المثال، سيُنشئ SELECT arrayUniq([1,2], [3,4], [5,6]) الـ tuples التالية:

• الموضع 1: (1,3,5)
• الموضع 2: (2,4,6)

بعد ذلك، ستحسب عدد الـ tuples الفريدة. في هذه الحالة تكون القيمة 2.

يجب أن تكون جميع المصفوفات المُمرَّرة بالطول نفسه.

الصياغة

arrayUniq(arr1[, arr2, ..., arrN])

الوسائط

• arr1 — المصفوفة التي يُراد حساب عدد العناصر الفريدة فيها. Array(T)
• [, arr2, ..., arrN] — اختياري. مصفوفات إضافية تُستخدم لحساب عدد Tuples الفريدة المتكوّنة من العناصر الموجودة في المواضع المناظرة عبر عدة مصفوفات. Array(T)

القيمة المُعادة

عند استخدام وسيط واحد، تُرجِع عدد العناصر الفريدة. وعند استخدام عدة وسائط، تُرجِع عدد Tuples الفريدة المتكوّنة من العناصر الموجودة في المواضع المناظرة عبر المصفوفات. UInt32

أمثلة

وسيط واحد

SELECT arrayUniq([1, 1, 2, 2])

2

وسائط متعددة

SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])

3

أُضيفت في: v20.1.0

ينشئ مصفوفة بطول length مملوءة بالقيمة الثابتة x.

الصياغة

arrayWithConstant(N, x)

الوسيطات

• length — عدد العناصر في المصفوفة. (U)Int*
• x — قيمة العناصر N في المصفوفة، ويمكن أن تكون من أي نوع.

القيمة المُعادة

تعيد مصفوفة تضم N عنصرًا، قيمة كل منها x. Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayWithConstant(3, 1)

[1,1,1]

أُضيفت في: v20.1.0

تجمع عدة مصفوفات في مصفوفة واحدة. تحتوي المصفوفة الناتجة على العناصر المناظرة من مصفوفات الإدخال، مجمَّعةً في Tupleات وفق ترتيب الوسيطات المذكور.

الصياغة

arrayZip(arr1, arr2, ... , arrN)

الوسائط

• arr1, arr2, ... , arrN — عدد N من المصفوفات لدمجها في مصفوفة واحدة. Array(T)

القيمة المُعادة

تعيد مصفوفةً تحتوي على عناصر من المصفوفات المصدر، مجمّعةً في Tuples. تكون أنواع البيانات في الـ Tuple هي نفسها أنواع بيانات المصفوفات المُدخلة، وبالترتيب نفسه الذي تُمرَّر به المصفوفات Array(T)

أمثلة

مثال على الاستخدام

SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);

[('a',5),('b',2),('c',1)]

أُضيف في: v20.1.0

يجمع عدة مصفوفات في مصفوفة واحدة، مع دعم المصفوفات غير المتحاذية (أي المصفوفات ذات الأطوال المختلفة). وتحتوي المصفوفة الناتجة على العناصر المناظرة من المصفوفات المصدر، مجمَّعة في Tuples وفق ترتيب الوسيطات المذكور.

البنية

arrayZipUnaligned(arr1, arr2, ..., arrN)

الوسيطات

• arr1, arr2, ..., arrN — عدد N من المصفوفات لدمجها في مصفوفة واحدة. Array(T)

القيمة المعادة

تعيد مصفوفةً تضم عناصر من مصفوفات المصدر مجمّعةً في قيم Tuple. وتكون أنواع البيانات داخل الـ Tuple مطابقةً لأنواع مصفوفات الإدخال وبالترتيب نفسه الذي تُمرَّر به المصفوفات. Array(T) أو Tuple(T1, T2, ...)

أمثلة

مثال على الاستخدام

SELECT arrayZipUnaligned(['a'], [1, 2, 3]);

[('a',1),(NULL,2),(NULL,3)]

تم تقديمها في: v1.1.0

تعيد عدد العناصر في المصفوفة التي تساوي x. وهي مكافئة لـ arrayCount(elem -> elem = x, arr).

تُعامَل عناصر NULL كقيم منفصلة.

البنية

countEqual(arr, x)

الوسائط

• arr — المصفوفة المراد البحث فيها. Array(T)
• x — القيمة المطلوب عدّها في المصفوفة. أي نوع.

القيمة المعادة

يعيد عدد العناصر في المصفوفة التي تساوي x UInt64

أمثلة

مثال على الاستخدام

SELECT countEqual([1, 2, NULL, NULL], NULL)

2

قُدِّم في: v1.1.0

يتحقق مما إذا كانت المصفوفة المُدخلة فارغة.

تُعد المصفوفة فارغة إذا كانت لا تحتوي على أي عناصر.

تعمل هذه الدالة أيضًا مع Strings أو UUIDs.

البنية

empty(arr)

المعاملات

• arr — مصفوفة الإدخال. Array(T)

القيمة المُعادة

يعيد 1 للمصفوفة الفارغة، أو 0 للمصفوفة غير الفارغة UInt8

أمثلة

مثال استخدام

SELECT empty([]);

1

أُضيفت في: v1.1.0

تُرجع مصفوفة Date فارغة

البنية

emptyArrayDate()

الوسيطات

• لا شيء.

القيمة المعادة

مصفوفة Date فارغة. Array(T)

أمثلة

مثال على الاستخدام

SELECT emptyArrayDate()

[]

أُضيفت في: v1.1.0

تُرجع مصفوفة DateTime فارغة

الصياغة

emptyArrayDateTime()

الوسيطات

• لا شيء.

القيمة المُعادة

مصفوفة DateTime فارغة. Array(T)

أمثلة

مثال على الاستخدام

SELECT emptyArrayDateTime()

[]

أُضيف في: v1.1.0

يعيد مصفوفة Float32 فارغة

الصيغة

emptyArrayFloat32()

الوسائط

• لا شيء.

القيمة المعادة

مصفوفة فارغة من نوع Float32. Array(T)

أمثلة

مثال على الاستخدام

SELECT emptyArrayFloat32()

[]

قُدِّم في: v1.1.0

يعيد مصفوفة فارغة من نوع Float64

الصيغة

emptyArrayFloat64()

الوسائط

• لا شيء.

القيمة المُعادة

مصفوفة Float64 فارغة. Array(T)

أمثلة

مثال على الاستخدام

SELECT emptyArrayFloat64()

[]

أُضيف في: v1.1.0

تعيد مصفوفة Int16 فارغة

البنية

emptyArrayInt16()

المعاملات

• لا شيء.

القيمة المُعادة

مصفوفة فارغة من النوع Int16. Array(T)

أمثلة

مثال على الاستخدام

SELECT emptyArrayInt16()

[]

أُضيف في: v1.1.0

يُرجع مصفوفة Int32 فارغة

الصيغة

emptyArrayInt32()

الوسائط

• لا شيء.

القيمة المُعادة

مصفوفة Int32 فارغة. Array(T)

أمثلة

مثال للاستخدام

SELECT emptyArrayInt32()

[]

أُضيف في: v1.1.0

يعيد مصفوفة Int64 فارغة

الصيغة

emptyArrayInt64()

الوسائط

• لا شيء.

القيمة المُعادة

مصفوفة Int64 فارغة. Array(T)

أمثلة

مثال على الاستخدام

SELECT emptyArrayInt64()

[]

أُضيفت في: v1.1.0

تُرجِع مصفوفة Int8 فارغة

الصياغة

emptyArrayInt8()

المعاملات

• لا شيء.

القيمة المُعادة

مصفوفة Int8 فارغة. Array(T)

أمثلة

مثال للاستخدام

SELECT emptyArrayInt8()

[]

أُضيف في: v1.1.0

يعيد مصفوفة String فارغة

الصياغة

emptyArrayString()

الوسيطات

• لا شيء.

القيمة المعادة

مصفوفة فارغة من نوع String. Array(T)

أمثلة

مثال على الاستخدام

SELECT emptyArrayString()

[]

قُدِّمت في: v1.1.0

تقبل مصفوفة فارغة وتُرجع مصفوفة من عنصر واحد تساوي القيمة الافتراضية.

البنية

emptyArrayToSingle(arr)

المعاملات

• arr — مصفوفة فارغة. Array(T)

القيمة المُعادة

مصفوفة تحتوي على قيمة واحدة من النوع الافتراضي للمصفوفة. Array(T)

أمثلة

مثال أساسي

CREATE TABLE test (
  a Array(Int32),
  b Array(String),
  c Array(DateTime)
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO test VALUES ([], [], []);

SELECT emptyArrayToSingle(a), emptyArrayToSingle(b), emptyArrayToSingle(c) FROM test;

┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
│ [0]                   │ ['']                  │ ['1970-01-01 00:00:00'] │
└───────────────────────┴───────────────────────┴─────────────────────────┘

أُضيفت في: v1.1.0

تُرجع مصفوفة UInt16 فارغة

الصيغة

emptyArrayUInt16()

المعاملات

• لا شيء.

القيمة المُعادة

مصفوفة فارغة من نوع UInt16. Array(T)

أمثلة

مثال على الاستخدام

SELECT emptyArrayUInt16()

[]

أُضيفت في: v1.1.0

تعيد مصفوفة UInt32 فارغة

البنية

emptyArrayUInt32()

المعاملات

• لا توجد.

القيمة المُعادة

مصفوفة فارغة من نوع UInt32. Array(T)

أمثلة

مثال على الاستخدام

SELECT emptyArrayUInt32()

[]

أُضيفت في: v1.1.0

تُرجع مصفوفة UInt64 فارغة

البنية

emptyArrayUInt64()

المعاملات

• لا شيء.

القيمة المُعادة

مصفوفة UInt64 فارغة. Array(T)

أمثلة

مثال على الاستخدام

SELECT emptyArrayUInt64()

[]

أُضيف في: v1.1.0

يعيد مصفوفة UInt8 فارغة

البنية

emptyArrayUInt8()

الوسائط