> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-parallel-read-in-order-multi-part.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. > توثيق المعاملات # المعاملات يحوّل ClickHouse المعاملات إلى الدوال المقابلة لها في مرحلة تحليل الاستعلام وفقًا لأولويتها وأسبقيتها وترابطها.

معاملات الوصول

`a[N]` – الوصول إلى عنصر في مصفوفة. دالة `arrayElement(a, N)`. يمكن أن تكون `N` أيضًا مصفوفة من الأعداد الصحيحة، وعندئذٍ تُعاد العناصر الموجودة في جميع هذه المواضع ضمن مصفوفة، كما في `arrayMap(i -> a[i], N)`. يمكن أن تكون المواضع قابلة للقيم الخالية. يؤدي الموضع `NULL` إلى إنتاج `NULL` عندما يكون نوع العنصر قابلًا للتغليف ضمن `Nullable`؛ أما أنواع العناصر التي لا يمكن أن تكون داخل `Nullable` (مثل `Array` و`Map`)، فتنتج القيمة الافتراضية لنوع العنصر، كما هو الحال مع فهرس `NULL` قياسي. `a.N` – الوصول إلى عنصر في tuple. دالة `tupleElement(a, N)`.

معامل النفي العددي

`-a` – الدالة `negate (a)`. لنفي `tuple`: [tupleNegate](/ar/reference/functions/regular-functions/tuple-functions#tupleNegate).

معاملات الضرب والقسمة

`a * b` – الدالة `multiply (a, b)`. لضرب Tuple في عدد: [tupleMultiplyByNumber](/ar/reference/functions/regular-functions/tuple-functions#tupleMultiplyByNumber)، ولحساب حاصل الضرب القياسي: [dotProduct](/ar/reference/functions/regular-functions/array-functions#arrayDotProduct). `a / b` – الدالة `divide(a, b)`. لقسمة Tuple على عدد: [tupleDivideByNumber](/ar/reference/functions/regular-functions/tuple-functions#tupleDivideByNumber). `a % b` – الدالة `modulo(a, b)`.

معاملات الجمع والطرح

`a + b` – الدالة `plus(a, b)`. لجمع قيم Tuple: [tuplePlus](/ar/reference/functions/regular-functions/tuple-functions#tuplePlus). `a - b` – الدالة `minus(a, b)`. لطرح قيم Tuple: [tupleMinus](/ar/reference/functions/regular-functions/tuple-functions#tupleMinus).

معاملات المقارنة

دالة equals

`a = b` – دالة `equals(a, b)`. `a == b` – دالة `equals(a, b)`.

دالة notEquals

`a != b` – الدالة `notEquals(a, b)`. `a <> b` – الدالة `notEquals(a, b)`.

دالة lessOrEquals

`a <= b` – هي الدالة `lessOrEquals(a, b)`.

دالة greaterOrEquals

`a >= b` – تمثلها الدالة `greaterOrEquals(a, b)`.

دالة less

`a < b` – الدالة `less(a, b)`.

الدالة greater

`a > b` – الدالة `greater(a, b)`.

الدالة like

`a LIKE b` – الدالة `like(a, b)`.

دالة notLike

`a NOT LIKE b` – الدالة `notLike(a, b)`.

دالة ilike

`a ILIKE b` – هي الدالة `ilike(a, b)`.

دالة match

`a REGEXP b` – دالة `match(a, b)`. `a ~ b` – دالة `match(a, b)` (مطابقة باستخدام تعبير نمطي على نمط PostgreSQL).

دالة notMatch

`a !~ b` – الدالة `notMatch(a, b)` (تتحقق من أن `a` لا يتطابق مع التعبير النمطي `b`).

دالة matchCaseInsensitive

`a ~* b` – الدالة `matchCaseInsensitive(a, b)` (مطابقة تعبير نمطي غير حساسة لحالة الأحرف).

دالة notMatchCaseInsensitive

`a !~* b` – دالة `notMatchCaseInsensitive(a, b)` (تتحقق من أن `a` لا يطابق التعبير النمطي `b` بغض النظر عن حالة الأحرف).

دالة BETWEEN

`a BETWEEN b AND c` – تعادل `a >= b AND a <= c`. `a NOT BETWEEN b AND c` – تعادل `a < b OR a > c`.

معامل "ليس مختلفًا عن" (`<=>`)

اعتبارًا من الإصدار 25.10، يمكنك استخدام `<=>` بالطريقة نفسها التي تستخدم بها أي معامل آخر. قبل الإصدار 25.10، لم يكن بالإمكان استخدامه إلا في تعبيرات JOIN، على سبيل المثال: ```sql theme={null} CREATE TABLE a (x String) ENGINE = Memory; INSERT INTO a VALUES ('ClickHouse'); SELECT * FROM a AS a1 JOIN a AS a2 ON a1.x <=> a2.x; ┌─x──────────┬─a2.x───────┐ │ ClickHouse │ ClickHouse │ └────────────┴────────────┘ ``` المعامل `<=>` هو معامل مساواة آمن مع `NULL`، وهو مكافئ لـ `IS NOT DISTINCT FROM`. وهو يعمل مثل معامل المساواة العادي (`=`)، لكنه يتعامل مع قيم `NULL` على أنها قابلة للمقارنة. تُعدّ قيمتا `NULL` متساويتين، كما أن مقارنة `NULL` بأي قيمة غير `NULL` تُرجع 0 (`false`) بدلًا من `NULL`. ```sql theme={null} SELECT 'ClickHouse' <=> NULL, NULL <=> NULL ``` ```response theme={null} ┌─isNotDistinc⋯use', NULL)─┬─isNotDistinc⋯NULL, NULL)─┐ │ 0 │ 1 │ └──────────────────────────┴──────────────────────────┘ ```

المعاملات الخاصة بالتعامل مع السلاسل النصية

OVERLAY

* `OVERLAY(string PLACING replacement FROM offset)` - الدالة `overlay(string, replacement, offset)`. * `OVERLAY(string PLACING replacement FROM offset FOR length)` - الدالة `overlay(string, replacement, offset, length)`. * `OVERLAYUTF8(string PLACING replacement FROM offset)` - الدالة `overlayUTF8(string, replacement, offset)`. * `OVERLAYUTF8(string PLACING replacement FROM offset FOR length)` - الدالة `overlayUTF8(string, replacement, offset, length)`.

المعاملات الخاصة بالعمل مع مجموعات البيانات

راجع [معاملات IN](/ar/reference/statements/in) و[المعامل EXISTS](/ar/reference/operators/exists).

الدالة in

`a IN ...` – الدالة `in(a, b)`.

دالة notIn

`a NOT IN ...` – الدالة `notIn(a, b)`.

دالة globalIn

`a GLOBAL IN ...` – الدالة `globalIn(a, b)`.

دالة globalNotIn

`a GLOBAL NOT IN ...` – الدالة `globalNotIn(a, b)`.

دالة in للاستعلامات الفرعية

`a = ANY (subquery)` – وهي الدالة `in(a, subquery)`.

notIn استعلام فرعي function

`a != ANY (subquery)` – وهو مماثل لـ `a NOT IN (SELECT singleValueOrNull(*) FROM subquery)`.

دالة in استعلام فرعي

`a = ALL (subquery)` – هي نفسها `a IN (SELECT singleValueOrNull(*) FROM subquery)`.

دالة notIn للاستعلام الفرعي

`a != ALL (subquery)` – الدالة `notIn(a, subquery)`. **أمثلة** استعلام باستخدام ALL: ```sql title="Query" theme={null} SELECT number AS a FROM numbers(10) WHERE a > ALL (SELECT number FROM numbers(3, 3)); ``` ```text title="Response" theme={null} ┌─a─┐ │ 6 │ │ 7 │ │ 8 │ │ 9 │ └───┘ ``` استعلام باستخدام ANY: ```sql title="Query" theme={null} SELECT number AS a FROM numbers(10) WHERE a > ANY (SELECT number FROM numbers(3, 3)); ``` ```text title="Response" theme={null} ┌─a─┐ │ 4 │ │ 5 │ │ 6 │ │ 7 │ │ 8 │ │ 9 │ └───┘ ```

`SOME` / `ALL` على المصفوفات

بالإضافة إلى صيغة الاستعلام الفرعي الموضحة أعلاه، يمكن أن يكون الطرف الأيمن من `SOME` / `ALL` تعبيرَ مصفوفة (قيمة حرفية لمصفوفة، أو عمودًا من نوع مصفوفة، أو أي تعبير يُرجع مصفوفة). هذه هي صيغة مكمِّم المصفوفة بأسلوب PostgreSQL. ويُتعرَّف عليها أثناء التحليل وتُعاد كتابتها إلى دوال المصفوفات، لذلك لا حاجة إلى إعادة كتابتها يدويًا: | الصياغة | تُعاد كتابتها إلى | | - | - | | `expr = SOME(arr)` | `has(arr, expr)` | | `expr <> ALL(arr)` | `NOT has(arr, expr)` | | `expr OP SOME(arr)` (أي معامل مدعوم آخر) | `arrayExists(x -> expr OP x, arr)` | | `expr OP ALL(arr)` (أي معامل مدعوم آخر) | `arrayAll(x -> expr OP x, arr)` | يمثل `SOME` المكمِّم الوجودي (وهو المرادف في SQL لـ `ANY`). وتُعامَل `=` و `<>` كحالتين خاصتين وتُحوَّلان إلى `has` / `NOT has` لأن لهما تنفيذًا مُحسَّنًا؛ أما الصيغة العامة فتعتمد على الدالتين الأعلى ترتيبًا `arrayExists` / `arrayAll`. يُتعرَّف على صيغة المصفوفة مع معاملات المقارنة `=`, `==`, `!=`, `<>`, `<=>`, `<`, `<=`, `>`, `>=`، ومع مسندات المقارنة بالكلمات المفتاحية `IS DISTINCT FROM` و `IS NOT DISTINCT FROM`، ومع مسندات البحث في السلاسل `LIKE` و `ILIKE` و `NOT LIKE` و `NOT ILIKE` و `REGEXP`. ولا يُتعرَّف على مسندات المقارنة بالكلمات المفتاحية ومسندات البحث في السلاسل إلا في صيغة المصفوفة، وليس في صيغة الاستعلام الفرعي (التي تُخفَّض إلى `IN`/`NOT IN`). أما المعاملات التي لا تحمل معنى مكمِّم المصفوفة — مثل `IN` نفسها — فلا **تُعاد** كتابتها وتحتفظ بمعناها المعتاد. تعمل مسندات البحث في السلاسل لأن `MatchImpl` (التنفيذ الكامن وراء `LIKE` / `ILIKE` / `REGEXP`) يدعم `haystack` ثابتًا مع `needle` غير ثابتة. على سبيل المثال، يُعاد كتابة `'abc' LIKE SOME(['a%', 'b%'])` إلى `arrayExists(x -> 'abc' LIKE x, ['a%', 'b%'])`، كما يُعاد كتابة `'abc' NOT LIKE ALL(['x%', 'y%'])` إلى `arrayAll(x -> 'abc' NOT LIKE x, ['x%', 'y%'])`. وهذا يطابق سلسلة واحدة مع عدة أنماط؛ أما إذا أردت المطابقة بتمرير موحّد واحد فلا يزال بإمكانك استخدام دالة بحث متعددة الأنماط مثل `multiMatchAny` (التعبيرات النمطية) أو `multiSearchAny` (السلاسل الفرعية). **`ANY` غير مدعومة في صيغة المصفوفة** لا يقبل الطرف الأيمن كمصفوفة إلا `SOME` و `ALL`. تُستبعَد `ANY` لأن `any` هي أيضًا دالة تجميع، لذلك يحتفظ التعبير بالشكل `expr = any(x)` بمعنى استدعاء الدالة. استخدم `SOME` لمكمِّم المصفوفة. ```sql title="Query" theme={null} SELECT 3 = SOME([1, 2, 3, 4]) AS in_array, 5 < SOME([1, 2, 6]) AS less_than_some, 5 > ALL([1, 2, 3]) AS greater_than_all, 'abc' LIKE SOME(['a%', 'z%']) AS like_some; ``` ```text title="Response" theme={null} ┌─in_array─┬─less_than_some─┬─greater_than_all─┬─like_some─┐ │ 1 │ 1 │ 1 │ 1 │ └──────────┴────────────────┴──────────────────┴───────────┘ ``` **تختلف معالجة `NULL` عن صيغة الاستعلام الفرعي** لأن صيغة المصفوفة يُعادَت صياغتها في المحلّل النحوي (حيث لا تكون إعدادات الاستعلام مثل `transform_null_in` متاحة، كما أن عمود المصفوفة على مستوى الصف لا يمكنه استخدام مسار `IN` الآمن مع `NULL` في المحلّل)، فإنها تستخدم الدلالات ثنائية القيمة لكل من `has` (مع `=` / `<>`) و `arrayExists` / `arrayAll` (اللذين يختزلان نتيجة مقارنة `NULL` غير المعروفة إلى `0`). وقد يختلف ذلك عن صيغة الاستعلام الفرعي، إذ تُعالَج فيها `NULL` عبر `IN` / `NOT IN` وتعتمد على `transform_null_in`: ```sql theme={null} SELECT NULL = SOME([NULL]); -- has([NULL], NULL) -> 1 SELECT NULL <> ALL([NULL]); -- NOT has([NULL], NULL) -> 0 SELECT NULL < SOME([1]); -- arrayExists(x -> NULL < x, [1]) -> 0 SELECT NULL > ALL([1]); -- arrayAll(x -> NULL > x, [1]) -> 0 ```

المعاملات للعمل مع التواريخ والأوقات

EXTRACT

```sql theme={null} EXTRACT(part FROM date); ``` استخرج أجزاء من تاريخ معيّن. على سبيل المثال، يمكنك استخراج شهر من تاريخ معيّن، أو ثانية من وقت معيّن. تحدِّد المعلمة `part` أي جزء من التاريخ يجب استخراجه. القيم التالية متاحة: * `NANOSECOND` — النانوثانية. القيم الممكنة: 0–999999999. * `MICROSECOND` — الميكروثانية. القيم الممكنة: 0–999999. * `MILLISECOND` — الميلي ثانية. القيم الممكنة: 0–999. * `SECOND` — الثانية. القيم الممكنة: 0–59. * `MINUTE` — الدقيقة. القيم الممكنة: 0–59. * `HOUR` — الساعة. القيم الممكنة: 0–23. * `DAY` — يوم الشهر. القيم الممكنة: 1–31. * `WEEK` — رقم الأسبوع وفق معيار ISO 8601. القيم الممكنة: 1–53. * `MONTH` — رقم الشهر. القيم الممكنة: 1–12. * `QUARTER` — الربع. القيم الممكنة: 1–4. * `YEAR` — السنة. * `EPOCH` — الطابع الزمني لـ Unix (الثواني منذ 1970-01-01 00:00:00 UTC). ملاحظة: بالنسبة إلى `DateTime64`، يُقتطع الجزء الأقل من الثانية. * `DOW` — يوم الأسبوع (متوافق مع PostgreSQL). 0 = الأحد، 6 = السبت. * `DOY` — يوم السنة. القيم الممكنة: 1–366. * `ISODOW` — يوم الأسبوع وفق ISO. 1 = الاثنين، 7 = الأحد. * `ISOYEAR` — سنة ترقيم الأسابيع وفق ISO 8601. * `CENTURY` — القرن. على سبيل المثال، السنة 2024 تقع في القرن الحادي والعشرين. * `DECADE` — العقد (السنة مقسومة على 10). على سبيل المثال، السنة 2024 عقدها 202. * `MILLENNIUM` — الألفية. على سبيل المثال، السنة 2024 تقع في الألفية الثالثة. * `TIMEZONE_HOUR` — جزء الساعات الموقَّع من إزاحة UTC للمنطقة الزمنية الخاصة بالمعامل. على سبيل المثال، `+5:30` تُرجع `5`، و`-3:30` تُرجع `-3`. * `TIMEZONE_MINUTE` — جزء الدقائق الموقَّع من إزاحة UTC للمنطقة الزمنية الخاصة بالمعامل. على سبيل المثال، `+5:30` تُرجع `30`، و`-3:30` تُرجع `-30`. المعلمة `part` غير حساسة لحالة الأحرف. تحدِّد المعلمة `date` القيمة المطلوب معالجتها. الأنواع [Date](/ar/reference/data-types/date) و[Date32](/ar/reference/data-types/date32) و[DateTime](/ar/reference/data-types/datetime) و[DateTime64](/ar/reference/data-types/datetime64) و[Interval](/ar/reference/data-types/special-data-types/interval) مدعومة. عندما تكون `date` من النوع `Interval`، يجب أن يطابق `part` المطلوب النوع المخزَّن في الـ interval (على سبيل المثال، يُسمح بـ `EXTRACT(DAY FROM INTERVAL 5 DAY)`؛ ويُرفَض `EXTRACT(HOUR FROM INTERVAL 5 DAY)`، لأن فواصل ClickHouse تكون من نوع واحد فقط). تكون نتيجة معامل `Interval` من النوع `Int64`. أمثلة: ```sql theme={null} SELECT EXTRACT(DAY FROM toDate('2017-06-15')); SELECT EXTRACT(MONTH FROM toDate('2017-06-15')); SELECT EXTRACT(YEAR FROM toDate('2017-06-15')); SELECT EXTRACT(EPOCH FROM toDateTime('2024-01-15 12:30:45', 'UTC')); SELECT EXTRACT(DOW FROM toDate('2024-01-15')); SELECT EXTRACT(CENTURY FROM toDate('2024-01-01')); SELECT EXTRACT(TIMEZONE_HOUR FROM toDateTime('2024-01-15 12:00:00', 'Asia/Kolkata')); -- 5 SELECT EXTRACT(TIMEZONE_MINUTE FROM toDateTime('2024-01-15 12:00:00', 'Asia/Kolkata')); -- 30 SELECT EXTRACT(DAY FROM INTERVAL 40 DAY); -- 40 SELECT EXTRACT(MONTH FROM INTERVAL 7 MONTH); -- 7 ``` في المثال التالي، نُنشئ جدولًا ونُدرِج فيه قيمة من نوع `DateTime`. ```sql theme={null} CREATE TABLE test.Orders ( OrderId UInt64, OrderName String, OrderDate DateTime ) ENGINE = MergeTree ORDER BY (); ``` ```sql theme={null} INSERT INTO test.Orders VALUES (1, 'Jarlsberg Cheese', toDateTime('2008-10-11 13:23:44')); ``` ```sql theme={null} SELECT toYear(OrderDate) AS OrderYear, toMonth(OrderDate) AS OrderMonth, toDayOfMonth(OrderDate) AS OrderDay, toHour(OrderDate) AS OrderHour, toMinute(OrderDate) AS OrderMinute, toSecond(OrderDate) AS OrderSecond FROM test.Orders; ``` ```text theme={null} ┌─OrderYear─┬─OrderMonth─┬─OrderDay─┬─OrderHour─┬─OrderMinute─┬─OrderSecond─┐ │ 2008 │ 10 │ 11 │ 13 │ 23 │ 44 │ └───────────┴────────────┴──────────┴───────────┴─────────────┴─────────────┘ ``` يمكنك الاطلاع على المزيد من الأمثلة في [الاختبارات](https://github.com/ClickHouse/ClickHouse/blob/master/tests/queries/0_stateless/00619_extract.sql).

INTERVAL

ينشئ قيمة من نوع [Interval](/ar/reference/data-types/special-data-types/interval) ينبغي استخدامها في العمليات الحسابية مع قيم من النوعين [Date](/ar/reference/data-types/date) و[DateTime](/ar/reference/data-types/datetime). أنواع الفواصل الزمنية: * `SECOND` * `MINUTE` * `HOUR` * `DAY` * `WEEK` * `MONTH` * `QUARTER` * `YEAR` يمكنك أيضًا استخدام قيمة حرفية نصية عند تعيين قيمة `INTERVAL`. على سبيل المثال، `INTERVAL 1 HOUR` مكافئ لـ `INTERVAL '1 hour'` أو `INTERVAL '1' hour`. لا يمكن دمج الفواصل الزمنية ذات الأنواع المختلفة. لا يمكنك استخدام تعبيرات مثل `INTERVAL 4 DAY 1 HOUR`. حدِّد الفواصل الزمنية بوحدات أصغر من أصغر وحدة في الفاصل الزمني أو مساوية لها، على سبيل المثال `INTERVAL 25 HOUR`. ويمكنك استخدام عمليات متتالية، كما في المثال أدناه. أمثلة: ```sql theme={null} SELECT now() AS current_date_time, current_date_time + INTERVAL 4 DAY + INTERVAL 3 HOUR; ``` ```text theme={null} ┌───current_date_time─┬─plus(plus(now(), toIntervalDay(4)), toIntervalHour(3))─┐ │ 2020-11-03 22:09:50 │ 2020-11-08 01:09:50 │ └─────────────────────┴────────────────────────────────────────────────────────┘ ``` ```sql theme={null} SELECT now() AS current_date_time, current_date_time + INTERVAL '4 day' + INTERVAL '3 hour'; ``` ```text theme={null} ┌───current_date_time─┬─plus(plus(now(), toIntervalDay(4)), toIntervalHour(3))─┐ │ 2020-11-03 22:12:10 │ 2020-11-08 01:12:10 │ └─────────────────────┴────────────────────────────────────────────────────────┘ ``` ```sql theme={null} SELECT now() AS current_date_time, current_date_time + INTERVAL '4' day + INTERVAL '3' hour; ``` ```text theme={null} ┌───current_date_time─┬─plus(plus(now(), toIntervalDay('4')), toIntervalHour('3'))─┐ │ 2020-11-03 22:33:19 │ 2020-11-08 01:33:19 │ └─────────────────────┴────────────────────────────────────────────────────────────┘ ``` يُفضَّل دائمًا استخدام صيغة `INTERVAL` أو الدالة `addDays`. أمّا الجمع أو الطرح البسيط (بصيغة مثل `now() + ...`) فلا يأخذ إعدادات التوقيت في الحسبان، مثل التوقيت الصيفي. أمثلة: ```sql theme={null} SELECT toDateTime('2014-10-26 00:00:00', 'Asia/Istanbul') AS time, time + 60 * 60 * 24 AS time_plus_24_hours, time + toIntervalDay(1) AS time_plus_1_day; ``` ```text theme={null} ┌────────────────time─┬──time_plus_24_hours─┬─────time_plus_1_day─┐ │ 2014-10-26 00:00:00 │ 2014-10-26 23:00:00 │ 2014-10-27 00:00:00 │ └─────────────────────┴─────────────────────┴─────────────────────┘ ``` **راجع أيضًا** * [Interval](/ar/reference/data-types/special-data-types/interval) نوع البيانات * [toInterval](/ar/reference/functions/regular-functions/type-conversion-functions#toIntervalYear) دوال تحويل الأنواع

إضافة التاريخ والوقت

يمكن إضافة قيمة [Date](/ar/reference/data-types/date) أو [Date32](/ar/reference/data-types/date32) إلى قيمة [Time](/ar/reference/data-types/time) أو [Time64](/ar/reference/data-types/time64) باستخدام المعامل `+`. وتكون النتيجة [DateTime](/ar/reference/data-types/datetime) أو [DateTime64](/ar/reference/data-types/datetime64)، وتمثل التاريخ عند الوقت المحدد من اليوم. هذه العملية إبدالية. يعتمد نوع النتيجة على نوعَي المعاملين: | المعامل الأيسر | المعامل الأيمن | نوع النتيجة | | - | - | - | | `Date` | `Time` | `DateTime` | | `Date` | `Time64(s)` | `DateTime64(s)` | | `Date32` | `Time` | `DateTime64(0)` | | `Date32` | `Time64(s)` | `DateTime64(s)` | تستخدم النتيجة [المنطقة الزمنية للجلسة](/ar/reference/settings/session-settings/other#session_timezone) (أو المنطقة الزمنية الافتراضية للخادوم إذا لم يتم تعيين منطقة زمنية للجلسة). ويتحكم الإعداد [`date_time_overflow_behavior`](/ar/reference/settings/formats/date-time#date_time_overflow_behavior) في ما يحدث عندما تكون النتيجة خارج النطاق القابل للتمثيل. أمثلة: ```sql theme={null} SET use_legacy_to_time = 0; SELECT toDate('2024-07-15') + toTime('14:30:25') AS dt, toTypeName(dt); ``` ```text theme={null} ┌──────────────────dt─┬─toTypeName(dt)─┐ │ 2024-07-15 14:30:25 │ DateTime │ └─────────────────────┴────────────────┘ ``` ```sql theme={null} SELECT toDate('2024-07-15') + toTime64('14:30:25.123456', 6) AS dt, toTypeName(dt); ``` ```text theme={null} ┌─────────────────────────dt─┬─toTypeName(dt)─┐ │ 2024-07-15 14:30:25.123456 │ DateTime64(6) │ └────────────────────────────┴────────────────┘ ``` ```sql theme={null} SELECT toTime64('23:59:59.999', 3) + toDate32('2024-07-15') AS dt, toTypeName(dt); ``` ```text theme={null} ┌──────────────────────dt─┬─toTypeName(dt)─┐ │ 2024-07-15 23:59:59.999 │ DateTime64(3) │ └─────────────────────────┴────────────────┘ ```

AT TIME ZONE وAT LOCAL

تحوِّل المعاملات اللاحقة `AT TIME ZONE` و`AT LOCAL` قيمة من النوع `DateTime` أو `DateTime64` إلى منطقة زمنية مختلفة. وهما اختصار نحوي للدالة الحالية [`toTimeZone`](/ar/reference/functions/regular-functions/date-time-functions#toTimezone): | Syntax | Equivalent | | - | - | | `expr AT TIME ZONE zone` | `toTimeZone(expr, zone)` | | `expr AT LOCAL` | `toTimeZone(expr, timeZone())` | يمكن أن تكون `zone` أي تعبير سلسلة ثابت يُقيَّم إلى اسم منطقة زمنية صالح (مثل `'America/Denver'` أو `'UTC'` أو `concat('America', '/', 'Denver')`). وبما أن `AT TIME ZONE` تُختزل إلى `toTimeZone`، فإن قواعد وسيط المنطقة الزمنية نفسها تنطبق هنا: فالتعبيرات غير الثابتة، مثل الإشارة إلى عمود، تتطلب [`allow_nonconst_timezone_arguments = 1`](/ar/reference/settings/session-settings/allow#allow_nonconst_timezone_arguments). يستخدم `AT LOCAL` [المنطقة الزمنية الحالية للجلسة](/ar/reference/settings/session-settings/other#session_timezone) (أو المنطقة الزمنية الافتراضية للخادم إذا لم يتم تعيين منطقة زمنية للجلسة). في جداول `Distributed`، يجب تعيين `session_timezone` صراحةً؛ وعندما تكون فارغة، تكون `timeZone()` محلية على مستوى shard ولا يمكن استخدامها كوسيط ثابت للدالة `toTimeZone`، مما يؤدي إلى الاستثناء `ILLEGAL_COLUMN`. بخلاف PostgreSQL، حيث إن `timestamp without time zone AT TIME ZONE zone` يعيد تفسير قيمة الوقت الظاهر على أنها ضمن المنطقة الزمنية المحددة قبل التحويل، فإن ClickHouse يحتفظ دائمًا بنفس النقطة الزمنية المطلقة ولا يغيّر سوى تسمية المنطقة الزمنية المستخدمة للعرض. وكلتا الصيغتين مكافئتان لـ `toTimeZone` ولا تغيّران قيمة `timestamp` الأساسية. تبلغ أسبقية المعامل `AT TIME ZONE` القيمة 13 (أعلى من `*`/`/`/`%` عند 12، وأعلى من `+`/`-` عند 11)، بما يتوافق مع PostgreSQL. وهذا يعني أن `a * ts AT TIME ZONE 'tz'` يُفسَّر على أنه `a * (ts AT TIME ZONE 'tz')`، وأن `ts + interval AT TIME ZONE 'tz'` يُفسَّر على أنه `ts + (interval AT TIME ZONE 'tz')`. لتطبيق تحويل المنطقة الزمنية بعد العمليات الحسابية، استخدم أقواسًا صريحة: ```sql theme={null} -- Explicit parens required to add first, then convert timezone SELECT (TIMESTAMP '2001-02-16 20:38:40' + INTERVAL 1 HOUR) AT TIME ZONE 'America/Denver'; -- Equivalent to: SELECT toTimeZone(TIMESTAMP '2001-02-16 20:38:40' + INTERVAL 1 HOUR, 'America/Denver'); ``` أمثلة: ```sql theme={null} SET session_timezone = 'UTC'; SELECT TIMESTAMP '2001-02-16 20:38:40' AT TIME ZONE 'America/Denver'; ``` ```text theme={null} ┌─toTimeZone(toDateTime('2001-02-16 20:38:40'), 'America/Denver')─┐ │ 2001-02-16 13:38:40 │ └──────────────────────────────────────────────────────────────────┘ ``` ```sql theme={null} SELECT TIMESTAMP '2001-02-16 20:38:40' AT LOCAL; ``` ```text theme={null} ┌─toTimeZone(toDateTime('2001-02-16 20:38:40'), timeZone())─┐ │ 2001-02-16 20:38:40 │ └────────────────────────────────────────────────────────────┘ ``` **انظر أيضًا** * [`toTimeZone`](/ar/reference/functions/regular-functions/date-time-functions#toTimezone) * [`timeZone`](/ar/reference/functions/regular-functions/date-time-functions#timezone)

المعامل المنطقي AND

الصياغة `SELECT a AND b` — تحسب الاقتران المنطقي لـ `a` و`b` باستخدام الدالة [and](/ar/reference/functions/regular-functions/logical-functions#and).

معامل OR المنطقي

الصياغة `SELECT a OR b` — يحسب الفصل المنطقي لـ `a` و`b` باستخدام الدالة [or](/ar/reference/functions/regular-functions/logical-functions#or).

معامل النفي المنطقي

الصياغة `SELECT NOT a` — تحسب النفي المنطقي لـ `a` باستخدام الدالة [not](/ar/reference/functions/regular-functions/logical-functions#not).

المعامل الشرطي

`a ? b : c` – الدالة `if(a, b, c)`. ملاحظة: يحسب المعامل الشرطي قيمتَي b و c، ثم يتحقق مما إذا كان الشرط a متحققًا، ثم يعيد القيمة المقابلة. إذا كانت `b` أو `C` دالة [arrayJoin()](/ar/reference/functions/regular-functions/array-join)، فسيُكرَّر كل صف بغض النظر عن الشرط "a".

التعبير الشرطي

```sql theme={null} CASE [x] WHEN a THEN b [WHEN ... THEN ...] [ELSE c] END ``` إذا كان `x` محددًا، فستُستخدم الدالة `transform(x, [a, ...], [b, ...], c)`. وإلا فستُستخدم `multiIf(a, b, ..., c)`. إذا لم تتضمن expression عبارة `ELSE c`، فستكون القيمة الافتراضية هي `NULL`. لا تعمل الدالة `transform` مع `NULL`.

معامل ربط السلاسل

`s1 || s2` – دالة `concat(s1, s2)`.

معامل إنشاء Lambda

`x -> expr` – الدالة `lambda(x, expr)`. لا أولوية للمعاملات التالية لأنها أقواس:

معامل إنشاء المصفوفة

`[x1, ...]` – الدالة `array(x1, ...)`.

معامل إنشاء Tuple

`(x1, x2, ...)` – الدالة `tuple(x2, x2, ...)`.

الترابطية

تتمتع جميع المعاملات الثنائية بترابطية يسارية. على سبيل المثال، يُحوَّل `1 + 2 + 3` إلى `plus(plus(1, 2), 3)`. وأحيانًا لا يعمل ذلك بالطريقة التي قد تتوقعها. فعلى سبيل المثال، تكون نتيجة `SELECT 4 > 2 > 3` هي 0. ولتحسين الكفاءة، تقبل الدالتان `and` و`or` أي عدد من الوسائط. وتُحوَّل سلاسل المعاملات `AND` و`OR` المقابلة إلى استدعاء واحد لهاتين الدالتين.

التحقق من وجود `NULL`

يدعم ClickHouse العاملين `IS NULL` و`IS NOT NULL`.

IS NULL

* بالنسبة إلى القيم من النوع [Nullable](/ar/reference/data-types/nullable)، يعيد المعامل `IS NULL` ما يلي: * `1` إذا كانت القيمة `NULL`. * `0` بخلاف ذلك. * بالنسبة إلى القيم الأخرى، يعيد المعامل `IS NULL` دائمًا القيمة `0`. يمكن تحسين ذلك بتمكين الإعداد [optimize\_functions\_to\_subcolumns](/ar/reference/settings/session-settings/optimize#optimize_functions_to_subcolumns). عند ضبط `optimize_functions_to_subcolumns = 1`، تقرأ الدالة العمود الفرعي [null](/ar/reference/data-types/nullable#finding-null) فقط بدلًا من قراءة بيانات العمود بالكامل ومعالجتها. ويتحوّل الاستعلام `SELECT n IS NULL FROM table` إلى `SELECT n.null != 0 FROM TABLE`. ```sql theme={null} SELECT x+100 FROM t_null WHERE y IS NULL ``` ```text theme={null} ┌─plus(x, 100)─┐ │ 101 │ └──────────────┘ ```

IS NOT NULL

* بالنسبة إلى القيم من النوع [Nullable](/ar/reference/data-types/nullable)، يعيد المعامل `IS NOT NULL` ما يلي: * `0` إذا كانت القيمة `NULL`. * `1` في غير ذلك. * بالنسبة إلى القيم الأخرى، يعيد المعامل `IS NOT NULL` دائمًا `1`. ```sql theme={null} SELECT * FROM t_null WHERE y IS NOT NULL ``` ```text theme={null} ┌─x─┬─y─┐ │ 2 │ 3 │ └───┴───┘ ``` يمكن تحسين ذلك عبر تفعيل إعداد [optimize\_functions\_to\_subcolumns](/ar/reference/settings/session-settings/optimize#optimize_functions_to_subcolumns). عند ضبط `optimize_functions_to_subcolumns = 1`، لا تقرأ الدالة سوى العمود الفرعي [null](/ar/reference/data-types/nullable#finding-null) بدلًا من قراءة بيانات العمود بالكامل ومعالجتها. ويتحوّل الاستعلام `SELECT n IS NOT NULL FROM table` إلى `SELECT NOT n.null FROM TABLE`.

التحقق من القيم المنطقية

يدعم ClickHouse المعاملات `IS TRUE` و`IS FALSE` و`IS UNKNOWN` و`IS NOT TRUE` و`IS NOT FALSE` و`IS NOT UNKNOWN`. تُستخدم هذه المعاملات مع تعبيرات [Bool](/ar/reference/data-types/boolean) و`Nullable(Bool)`. * يعيد `expr IS TRUE` القيمة `1` فقط إذا كانت قيمة `expr` هي `true`. * يعيد `expr IS FALSE` القيمة `1` فقط إذا كانت قيمة `expr` هي `false`. * يعيد `expr IS UNKNOWN` القيمة `1` فقط إذا كانت قيمة `expr` هي `NULL`. * يعيد `expr IS NOT TRUE` القيمة `1` إذا كانت قيمة `expr` هي `false` أو `NULL`. * يعيد `expr IS NOT FALSE` القيمة `1` إذا كانت قيمة `expr` هي `true` أو `NULL`. * يعيد `expr IS NOT UNKNOWN` القيمة `1` إذا لم تكن قيمة `expr` هي `NULL`. بالنسبة إلى التعبيرات المنطقية، فإن `IS UNKNOWN` تكافئ `IS NULL`، و`IS NOT UNKNOWN` تكافئ `IS NOT NULL`. ```sql theme={null} CREATE TABLE t_bool (x Nullable(Bool)) ENGINE = Memory; INSERT INTO t_bool VALUES (true), (false), (NULL); SELECT x, x IS TRUE, x IS FALSE, x IS UNKNOWN, x IS NOT TRUE, x IS NOT FALSE, x IS NOT UNKNOWN FROM t_bool; ```