> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> توثيق دوال البت

# دوال البت

تعمل دوال البت مع أي زوج من الأنواع `UInt8` و`UInt16` و`UInt32` و`UInt64` و`Int8` و`Int16` و`Int32` و`Int64` و`Float32` و`Float64`. كما تدعم بعض الدوال النوعين `String` و`FixedString`.

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

{/*AUTOGENERATED_START*/}

<div id="bitAnd">
  ## bitAnd
</div>

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

يُجري عملية AND على مستوى البت بين قيمتين.

**الصياغة**

```sql theme={null}
bitAnd(a, b)
```

**المعاملات**

* `a` — القيمة الأولى. [`(U)Int*`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float)
* `b` — القيمة الثانية. [`(U)Int*`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float)

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

تُرجع ناتج العملية البتية `a AND b`

**أمثلة**

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

```sql title=Query theme={null}
CREATE TABLE bits
(
    `a` UInt8,
    `b` UInt8
)
ENGINE = Memory;

INSERT INTO bits VALUES (0, 0), (0, 1), (1, 0), (1, 1);

SELECT
    a,
    b,
    bitAnd(a, b)
FROM bits
```

```response title=Response theme={null}
┌─a─┬─b─┬─bitAnd(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            0 │
│ 1 │ 0 │            0 │
│ 1 │ 1 │            1 │
└───┴───┴──────────────┘
```

<div id="bitCount">
  ## bitCount
</div>

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

تحسب عدد البِتّات التي تساوي 1 في التمثيل الثنائي لعدد.

**الصيغة**

```sql theme={null}
bitCount(x)
```

**الوسيطات**

* `x` — قيمة عدد صحيح أو عدد فاصلة عائمة. [`(U)Int*`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float)

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

تعيد عدد البتات المعيّنة إلى واحد في `x`. [`UInt8`](/ar/reference/data-types/int-uint).

<Note>
  لا تحوّل الدالة قيمة الإدخال إلى نوع أكبر ([توسيع الإشارة](https://en.wikipedia.org/wiki/Sign_extension)).
  على سبيل المثال: `bitCount(toUInt8(-1)) = 8`.
</Note>

**أمثلة**

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

```sql title=Query theme={null}
SELECT bin(333), bitCount(333);
```

```response title=Response theme={null}
┌─bin(333)─────────┬─bitCount(333)─┐
│ 0000000101001101 │             5 │
└──────────────────┴───────────────┘
```

<div id="bitHammingDistance">
  ## bitHammingDistance
</div>

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

تُرجع [مسافة هامنغ](https://en.wikipedia.org/wiki/Hamming_distance) بين تمثيلي البِتّ لعددين.
يمكن استخدامها مع دوال [`SimHash`](/ar/reference/functions/regular-functions/hash-functions#ngramSimHash) لاكتشاف السلاسل شبه المتطابقة.
كلما صغرت المسافة، زاد التشابه بين السلاسل.

**الصيغة**

```sql theme={null}
bitHammingDistance(x, y)
```

**المعاملات**

* `x` — العدد الأول لحساب مسافة هامينغ. [`(U)Int*`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float)
* `y` — العدد الثاني لحساب مسافة هامينغ. [`(U)Int*`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float)

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

تُرجع مسافة هامينغ بين `x` و`y` من النوع [`UInt8`](/ar/reference/data-types/int-uint)

**أمثلة**

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

```sql title=Query theme={null}
SELECT bitHammingDistance(111, 121);
```

```response title=Response theme={null}
┌─bitHammingDistance(111, 121)─┐
│                            3 │
└──────────────────────────────┘
```

<div id="bitNot">
  ## bitNot
</div>

أُضيف في: v1.1.0

ينفّذ عملية النفي على مستوى البتات.

**الصيغة**

```sql theme={null}
bitNot(a)
```

**الوسيطات**

* `a` — القيمة التي تُطبَّق عليها عملية النفي على مستوى البتات. [`(U)Int*`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float) أو [`String`](/ar/reference/data-types/string)

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

تعيد نتيجة `~a`، أي `a` بعد قلب البتات.

**أمثلة**

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

```sql title=Query theme={null}
SELECT
    CAST('5', 'UInt8') AS original,
    bin(original) AS original_binary,
    bitNot(original) AS result,
    bin(bitNot(original)) AS result_binary;
```

```response title=Response theme={null}
┌─original─┬─original_binary─┬─result─┬─result_binary─┐
│        5 │ 00000101        │    250 │ 11111010      │
└──────────┴─────────────────┴────────┴───────────────┘
```

<div id="bitOr">
  ## bitOr
</div>

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

تُجري عملية `OR` على مستوى البت بين قيمتين.

**البنية**

```sql theme={null}
bitOr(a, b)
```

**المعاملات**

* `a` — القيمة الأولى. [`(U)Int*`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float)
* `b` — القيمة الثانية. [`(U)Int*`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float)

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

تُرجع ناتج عملية OR على مستوى البتات `a OR b`

**أمثلة**

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

```sql title=Query theme={null}
CREATE TABLE bits
(
    `a` UInt8,
    `b` UInt8
)
ENGINE = Memory;

INSERT INTO bits VALUES (0, 0), (0, 1), (1, 0), (1, 1);

SELECT
    a,
    b,
    bitOr(a, b)
FROM bits;
```

```response title=Response theme={null}
┌─a─┬─b─┬─bitOr(a, b)─┐
│ 0 │ 0 │           0 │
│ 0 │ 1 │           1 │
│ 1 │ 0 │           1 │
│ 1 │ 1 │           1 │
└───┴───┴─────────────┘
```

<div id="bitRotateLeft">
  ## bitRotateLeft
</div>

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

دوِّر البِتّات إلى اليسار بعدد معيّن من المواضع. وتلتفّ البِتّات الخارجة لتظهر مجددًا على اليمين.

**الصياغة**

```sql theme={null}
bitRotateLeft(a, N)
```

**الوسيطات**

* `a` — قيمة يُراد تدويرها. [`(U)Int8/16/32/64`](/ar/reference/data-types/int-uint)
* `N` — عدد المواضع المراد التدوير إلى اليسار بمقداره. [`UInt8/16/32/64`](/ar/reference/data-types/int-uint)

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

تعيد القيمة بعد تدويرها، ويكون نوعها مساويًا لنوع `a`. [`(U)Int8/16/32/64`](/ar/reference/data-types/int-uint)

**أمثلة**

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

```sql title=Query theme={null}
SELECT 99 AS a, bin(a), bitRotateLeft(a, 2) AS a_rotated, bin(a_rotated);
```

```response title=Response theme={null}
┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       141 │ 10001101       │
└────┴──────────┴───────────┴────────────────┘
```

<div id="bitRotateRight">
  ## bitRotateRight
</div>

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

أدر البتات إلى اليمين بعدد معيّن من المواضع. وتلتف البتات الخارجة لتعود من جهة اليسار.

**الصيغة**

```sql theme={null}
bitRotateRight(a, N)
```

**الوسيطات**

* `a` — قيمة لتدويرها. [`(U)Int8/16/32/64`](/ar/reference/data-types/int-uint)
* `N` — عدد المواضع المطلوب تدويرها إلى اليمين. [`UInt8/16/32/64`](/ar/reference/data-types/int-uint)

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

تُرجِع القيمة بعد تدويرها، ويكون نوعها مساويًا لنوع `a`. [`(U)Int8/16/32/64`](/ar/reference/data-types/int-uint)

**أمثلة**

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

```sql title=Query theme={null}
SELECT 99 AS a, bin(a), bitRotateRight(a, 2) AS a_rotated, bin(a_rotated);
```

```response title=Response theme={null}
┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       216 │ 11011000       │
└────┴──────────┴───────────┴────────────────┘
```

<div id="bitShiftLeft">
  ## bitShiftLeft
</div>

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

تُزيح التمثيل الثنائي لقيمة ما إلى اليسار بعدد محدد من مواضع البت.

تُعامَل `FixedString` أو `String` على أنها قيمة واحدة متعددة البايتات.

تُفقَد بتات قيمة `FixedString` عند خروجها نتيجة الإزاحة.
أما قيمة `String` فتُوسَّع بإضافة بايتات أخرى، لذلك لا تُفقَد أي بتات.

**البنية**

```sql theme={null}
bitShiftLeft(a, N)
```

**الوسائط**

* `a` — قيمة يُراد إزاحتها. [`(U)Int*`](/ar/reference/data-types/int-uint) أو [`String`](/ar/reference/data-types/string) أو [`FixedString`](/ar/reference/data-types/fixedstring)
* `N` — عدد المواضع المراد إزاحتها. [`UInt8/16/32/64`](/ar/reference/data-types/int-uint)

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

تُرجِع القيمة المُزاحة بنوع يطابق نوع `a`.

**أمثلة**

**مثال على الاستخدام مع الترميز الثنائي**

```sql title=Query theme={null}
SELECT 99 AS a, bin(a), bitShiftLeft(a, 2) AS a_shifted, bin(a_shifted);
```

```response title=Response theme={null}
┌──a─┬─bin(99)──┬─a_shifted─┬─bin(bitShiftLeft(99, 2))─┐
│ 99 │ 01100011 │       140 │ 10001100                 │
└────┴──────────┴───────────┴──────────────────────────┘
```

**مثال على الاستخدام مع الترميز السداسي العشري**

```sql title=Query theme={null}
SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftLeft('abc', 4))─┐
│ abc │ 616263     │ &0        │ 06162630                    │
└─────┴────────────┴───────────┴─────────────────────────────┘
```

**مثال استخدام مع ترميز Fixed String**

```sql title=Query theme={null}
SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftLeft(toFixedString('abc', 3), 4))─┐
│ abc │ 616263                       │ &0        │ 162630                                        │
└─────┴──────────────────────────────┴───────────┴───────────────────────────────────────────────┘
```

<div id="bitShiftRight">
  ## bitShiftRight
</div>

أُضيف في: v1.1.0

يُزيح التمثيل الثنائي لقيمة ما إلى اليمين بعدد محدد من مواضع البِت.

يُعامَل كل من `FixedString` و`String` على أنه قيمة واحدة متعددة البايتات.

تُفقد بِتات قيمة `FixedString` عند خروجها نتيجة الإزاحة.
وعلى النقيض من ذلك، تُوسَّع قيمة `String` ببايتات إضافية، لذا لا تُفقد أي بِتات.

**البنية**

```sql theme={null}
bitShiftRight(a, N)
```

**المعاملات**

* `a` — قيمة يُراد إزاحتها. [`(U)Int*`](/ar/reference/data-types/int-uint) أو [`String`](/ar/reference/data-types/string) أو [`FixedString`](/ar/reference/data-types/fixedstring)
* `N` — عدد المواضع المطلوب الإزاحة بمقدارها. [`UInt8/16/32/64`](/ar/reference/data-types/int-uint)

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

يعيد القيمة المُزاحة بنوع مطابق لنوع `a`.

**أمثلة**

**مثال استخدام مع الترميز الثنائي**

```sql title=Query theme={null}
SELECT 101 AS a, bin(a), bitShiftRight(a, 2) AS a_shifted, bin(a_shifted);
```

```response title=Response theme={null}
┌───a─┬─bin(101)─┬─a_shifted─┬─bin(bitShiftRight(101, 2))─┐
│ 101 │ 01100101 │        25 │ 00011001                   │
└─────┴──────────┴───────────┴────────────────────────────┘
```

**مثال على الاستخدام مع الترميز السداسي العشري**

```sql title=Query theme={null}
SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftRight('abc', 12))─┐
│ abc │ 616263     │           │ 0616                          │
└─────┴────────────┴───────────┴───────────────────────────────┘
```

**مثال استخدام مع ترميز Fixed String**

```sql title=Query theme={null}
SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftRight(a, 12) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftRight(toFixedString('abc', 3), 12))─┐
│ abc │ 616263                       │           │ 000616                                          │
└─────┴──────────────────────────────┴───────────┴─────────────────────────────────────────────────┘
```

<div id="bitSlice">
  ## bitSlice
</div>

تم تقديمه في: v22.2.0

يعيد سلسلة فرعية تبدأ من البت عند الموضع 'offset' ويبلغ طولها 'length' بتًا.

**الصياغة**

```sql theme={null}
bitSlice(s, offset[, length])
```

**الوسيطات**

* `s` — قيمة `String` أو `Fixed String` المراد اقتطاع جزء منها. [`String`](/ar/reference/data-types/string) أو [`FixedString`](/ar/reference/data-types/fixedstring)
* `offset` —
  موضع البت الابتدائي (بفهرسة تبدأ من 1).
* القيم الموجبة: يبدأ العد من بداية السلسلة النصية.
* القيم السالبة: يبدأ العد من نهاية السلسلة النصية.

  [`(U)Int8/16/32/64`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float)
* `length` —
  اختياري. عدد البتات المطلوب استخراجها.
* القيم الموجبة: استخرج `length` بت.
* القيم السالبة: استخرج من الإزاحة حتى `(string_length - |length|)`.
* عند حذفه: استخرج من الإزاحة حتى نهاية السلسلة النصية.
* إذا لم يكن الطول مضاعفًا للعدد 8، فستُستكمل النتيجة بأصفار من الجهة اليمنى.
  [`(U)Int8/16/32/64`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float)

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

يعيد سلسلة نصية تحتوي على البتات المستخرجة، ممثلةً كتسلسل ثنائي. وتُستكمل النتيجة دائمًا حتى حدود البايت (مضاعفات 8 بتات) [`String`](/ar/reference/data-types/string)

**أمثلة**

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

```sql title=Query theme={null}
SELECT bin('Hello'), bin(bitSlice('Hello', 1, 8));
SELECT bin('Hello'), bin(bitSlice('Hello', 1, 2));
SELECT bin('Hello'), bin(bitSlice('Hello', 1, 9));
SELECT bin('Hello'), bin(bitSlice('Hello', -4, 8));
```

```response title=Response theme={null}
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', 1, 8))─┐
│ 0100100001100101011011000110110001101111 │ 01001000                     │
└──────────────────────────────────────────┴──────────────────────────────┘
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', 1, 2))─┐
│ 0100100001100101011011000110110001101111 │ 01000000                     │
└──────────────────────────────────────────┴──────────────────────────────┘
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', 1, 9))─┐
│ 0100100001100101011011000110110001101111 │ 0100100000000000             │
└──────────────────────────────────────────┴──────────────────────────────┘
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', -4, 8))─┐
│ 0100100001100101011011000110110001101111 │ 11110000                      │
└──────────────────────────────────────────┴───────────────────────────────┘
```

<div id="bitTest">
  ## bitTest
</div>

متاح منذ: v1.1.0

يأخذ أي عدد ويحوّله إلى [تمثيل ثنائي](https://en.wikipedia.org/wiki/Binary_number)، ثم يُرجع قيمة البت عند موضع محدد. ويجري العد من اليمين إلى اليسار، بدءًا من 0.

**الصياغة**

```sql theme={null}
bitTest(a, i)
```

**الوسيطات**

* `a` — الرقم المراد تحويله. [`(U)Int8/16/32/64`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float)
* `i` — موضع البت المطلوب إرجاعه. [`(U)Int8/16/32/64`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float)

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

تُرجِع قيمة البت عند الموضع `i` في التمثيل الثنائي لـ `a` [`UInt8`](/ar/reference/data-types/int-uint)

**أمثلة**

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

```sql title=Query theme={null}
SELECT bin(2), bitTest(2, 1);
```

```response title=Response theme={null}
┌─bin(2)───┬─bitTest(2, 1)─┐
│ 00000010 │             1 │
└──────────┴───────────────┘
```

<div id="bitTestAll">
  ## bitTestAll
</div>

طُرحت في: v1.1.0

تعيد نتيجة [الاقتران المنطقي](https://en.wikipedia.org/wiki/Logical_conjunction) (المعامل AND) لجميع البتات عند المواضع المحددة.
يُحتسب العد من اليمين إلى اليسار، بدءًا من 0.

يكون AND المنطقي بين بتّين true إذا وفقط إذا كانت بتّا الإدخال كلتاهما true.

**الصياغة**

```sql theme={null}
bitTestAll(a, index1[, index2, ... , indexN])
```

**الوسائط**

* `a` — قيمة عددية صحيحة. [`(U)Int8/16/32/64`](/ar/reference/data-types/int-uint)
* `index1, ...` — موضع واحد أو عدة مواضع للبتات. [`(U)Int8/16/32/64`](/ar/reference/data-types/int-uint)

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

تُرجع نتيجة الاقتران المنطقي من النوع [`UInt8`](/ar/reference/data-types/int-uint)

**أمثلة**

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

```sql title=Query theme={null}
SELECT bitTestAll(43, 0, 1, 3, 5);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAll(43, 0, 1, 3, 5)─┐
│ 00101011 │                          1 │
└──────────┴────────────────────────────┘
```

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

```sql title=Query theme={null}
SELECT bitTestAll(43, 0, 1, 3, 5, 2);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAll(4⋯1, 3, 5, 2)─┐
│ 00101011 │                        0 │
└──────────┴──────────────────────────┘
```

<div id="bitTestAny">
  ## bitTestAny
</div>

أُضيف في: v1.1.0

يعيد ناتج [الفصل المنطقي](https://en.wikipedia.org/wiki/Logical_disjunction) (المعامل OR) لجميع البتات في المواضع المحددة داخل عدد.
يُحتسب من اليمين إلى اليسار، بدءًا من 0.

تكون عملية OR المنطقية بين بتين `true` إذا كانت قيمة بت إدخال واحد على الأقل `true`.

**البنية**

```sql theme={null}
bitTestAny(a, index1[, index2, ... , indexN])
```

**المعاملات**

* `a` — قيمة صحيحة. [`(U)Int8/16/32/64`](/ar/reference/data-types/int-uint)
* `index1, ...` — موضع واحد أو عدة مواضع للبتات. [`(U)Int8/16/32/64`](/ar/reference/data-types/int-uint)

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

يُرجع نتيجة عملية «أو» المنطقية [`UInt8`](/ar/reference/data-types/int-uint)

**أمثلة**

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

```sql title=Query theme={null}
SELECT bitTestAny(43, 0, 2);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAny(43, 0, 2)─┐
│ 00101011 │                    1 │
└──────────┴──────────────────────┘
```

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

```sql title=Query theme={null}
SELECT bitTestAny(43, 4, 2);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAny(43, 4, 2)─┐
│ 00101011 │                    0 │
└──────────┴──────────────────────┘
```

<div id="bitXor">
  ## bitXor
</div>

أُضيف في: v1.1.0

ينفّذ عملية «أو» الحصري على مستوى البتات (XOR) بين قيمتين.

**الصياغة**

```sql theme={null}
bitXor(a, b)
```

**المعاملات**

* `a` — القيمة الأولى. [`(U)Int*`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float)
* `b` — القيمة الثانية. [`(U)Int*`](/ar/reference/data-types/int-uint) أو [`Float*`](/ar/reference/data-types/float)

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

تُرجع ناتج العملية البتية `a XOR b`

**أمثلة**

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

```sql title=Query theme={null}
CREATE TABLE bits
(
    `a` UInt8,
    `b` UInt8
)
ENGINE = Memory;

INSERT INTO bits VALUES (0, 0), (0, 1), (1, 0), (1, 1);

SELECT
    a,
    b,
    bitXor(a, b)
FROM bits;
```

```response title=Response theme={null}
┌─a─┬─b─┬─bitXor(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            1 │
│ 1 │ 0 │            1 │
│ 1 │ 1 │            0 │
└───┴───┴──────────────┘
```