دوال البت | ClickHouse Docs

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

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

bitAnd

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

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

الصياغة

bitAnd(a, b)

المعاملات

a — القيمة الأولى. (U)Int* أو Float*
b — القيمة الثانية. (U)Int* أو Float*

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

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

أمثلة

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

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

┌─a─┬─b─┬─bitAnd(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            0 │
│ 1 │ 0 │            0 │
│ 1 │ 1 │            1 │
└───┴───┴──────────────┘

bitCount

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

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

الصياغة

bitCount(x)

المعاملات

x — قيمة عدد صحيح أو عدد فاصلة عائمة. (U)Int* أو Float*

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

تعيد عدد البتات المعيّنة إلى واحد في x. UInt8.

أمثلة

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

SELECT bin(333), bitCount(333);

┌─bin(333)─────────┬─bitCount(333)─┐
│ 0000000101001101 │             5 │
└──────────────────┴───────────────┘

bitHammingDistance

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

تُرجع مسافة هامنغ بين تمثيلي البِتّ لعددين. يمكن استخدامها مع دوال SimHash لاكتشاف السلاسل شبه المتطابقة. كلما صغرت المسافة، زاد التشابه بين السلاسل.

الصيغة

bitHammingDistance(x, y)

المعاملات

x — العدد الأول لحساب مسافة هامينغ. (U)Int* أو Float*
y — العدد الثاني لحساب مسافة هامينغ. (U)Int* أو Float*

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

تُرجع مسافة هامينغ بين x وy من النوع UInt8

أمثلة

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

SELECT bitHammingDistance(111, 121);

┌─bitHammingDistance(111, 121)─┐
│                            3 │
└──────────────────────────────┘

bitNot

أُضيف في: v1.1.0

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

الصيغة

bitNot(a)

الوسيطات

a — القيمة التي تُطبَّق عليها عملية النفي على مستوى البتات. (U)Int* أو Float* أو String

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

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

أمثلة

مثال استخدام

SELECT
    CAST('5', 'UInt8') AS original,
    bin(original) AS original_binary,
    bitNot(original) AS result,
    bin(bitNot(original)) AS result_binary;

┌─original─┬─original_binary─┬─result─┬─result_binary─┐
│        5 │ 00000101        │    250 │ 11111010      │
└──────────┴─────────────────┴────────┴───────────────┘

bitOr

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

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

البنية

bitOr(a, b)

المعاملات

a — القيمة الأولى. (U)Int* أو Float*
b — القيمة الثانية. (U)Int* أو Float*

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

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

أمثلة

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

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;

┌─a─┬─b─┬─bitOr(a, b)─┐
│ 0 │ 0 │           0 │
│ 0 │ 1 │           1 │
│ 1 │ 0 │           1 │
│ 1 │ 1 │           1 │
└───┴───┴─────────────┘

bitRotateLeft

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

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

الصياغة

bitRotateLeft(a, N)

الوسيطات

a — قيمة يُراد تدويرها. (U)Int8/16/32/64
N — عدد المواضع المراد التدوير إلى اليسار بمقداره. UInt8/16/32/64

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

تعيد القيمة بعد تدويرها، ويكون نوعها مساويًا لنوع a. (U)Int8/16/32/64

أمثلة

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

SELECT 99 AS a, bin(a), bitRotateLeft(a, 2) AS a_rotated, bin(a_rotated);

┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       141 │ 10001101       │
└────┴──────────┴───────────┴────────────────┘

bitRotateRight

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

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

الصيغة

bitRotateRight(a, N)

الوسيطات

a — قيمة لتدويرها. (U)Int8/16/32/64
N — عدد المواضع المطلوب تدويرها إلى اليمين. UInt8/16/32/64

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

تُرجِع القيمة بعد تدويرها، ويكون نوعها مساويًا لنوع a. (U)Int8/16/32/64

أمثلة

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

SELECT 99 AS a, bin(a), bitRotateRight(a, 2) AS a_rotated, bin(a_rotated);

┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       216 │ 11011000       │
└────┴──────────┴───────────┴────────────────┘

bitShiftLeft

أُضيف في: v1.1.0

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

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

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

الصياغة

bitShiftLeft(a, N)

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

a — قيمة يُراد إزاحتها. (U)Int* أو String أو FixedString
N — عدد المواضع المراد إزاحتها. UInt8/16/32/64

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

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

أمثلة

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

SELECT 99 AS a, bin(a), bitShiftLeft(a, 2) AS a_shifted, bin(a_shifted);

┌──a─┬─bin(a)───┬─a_shifted─┬─bin(a_shifted)─┐
│ 99 │ 01100011 │       140 │ 10001100       │
└────┴──────────┴───────────┴────────────────┘

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

-- The shifted value is binary, so it is shown with `hex`.
SELECT 'abc' AS a, hex(a), hex(bitShiftLeft(a, 4)) AS a_shifted;

┌─a───┬─hex(a)─┬─a_shifted─┐
│ abc │ 616263 │ 06162630  │
└─────┴────────┴───────────┘

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

SELECT toFixedString('abc', 3) AS a, hex(a), hex(bitShiftLeft(a, 4)) AS a_shifted;

┌─a───┬─hex(a)─┬─a_shifted─┐
│ abc │ 616263 │ 162630    │
└─────┴────────┴───────────┘

bitShiftRight

أُضيف في: v1.1.0

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

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

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

الصياغة

bitShiftRight(a, N)

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

a — قيمة يُراد إزاحتها. (U)Int* أو String أو FixedString
N — عدد المواضع المطلوب الإزاحة بمقدارها. UInt8/16/32/64

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

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

أمثلة

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

SELECT 101 AS a, bin(a), bitShiftRight(a, 2) AS a_shifted, bin(a_shifted);

┌───a─┬─bin(a)───┬─a_shifted─┬─bin(a_shifted)─┐
│ 101 │ 01100101 │        25 │ 00011001       │
└─────┴──────────┴───────────┴────────────────┘

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

-- The shifted value is binary, so it is shown with `hex`.
SELECT 'abc' AS a, hex(a), hex(bitShiftRight(a, 12)) AS a_shifted;

┌─a───┬─hex(a)─┬─a_shifted─┐
│ abc │ 616263 │ 0616      │
└─────┴────────┴───────────┘

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

SELECT toFixedString('abc', 3) AS a, hex(a), hex(bitShiftRight(a, 12)) AS a_shifted;

┌─a───┬─hex(a)─┬─a_shifted─┐
│ abc │ 616263 │ 000616    │
└─────┴────────┴───────────┘

bitSlice

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

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

الصياغة

bitSlice(s, offset[, length])

المعاملات

s — قيمة String أو Fixed String المراد اقتطاع جزء منها. String أو FixedString
offset — موضع البت الابتدائي (بفهرسة تبدأ من 1).
القيم الموجبة: يبدأ العد من بداية السلسلة النصية.
القيم السالبة: يبدأ العد من نهاية السلسلة النصية. (U)Int8/16/32/64 أو Float*
length — اختياري. عدد البتات المطلوب استخراجها.
القيم الموجبة: استخرج length بت.
القيم السالبة: استخرج من الإزاحة حتى (string_length - |length|).
عند حذفه: استخرج من الإزاحة حتى نهاية السلسلة النصية.
إذا لم يكن الطول مضاعفًا للعدد 8، فستُستكمل النتيجة بأصفار من الجهة اليمنى. (U)Int8/16/32/64 أو Float*

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

يعيد سلسلة نصية تحتوي على البتات المستخرجة، ممثلةً كتسلسل ثنائي. وتُستكمل النتيجة دائمًا حتى حدود البايت (مضاعفات 8 بتات) String

أمثلة

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

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

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

bitTest

متاح منذ: v1.1.0

يأخذ أي عدد ويحوّله إلى تمثيل ثنائي، ثم يُرجع قيمة البت عند موضع محدد. ويجري العد من اليمين إلى اليسار، بدءًا من 0.

الصياغة

bitTest(a, i)

الوسيطات

a — الرقم المراد تحويله. (U)Int8/16/32/64 أو Float*
i — موضع البت المطلوب إرجاعه. (U)Int8/16/32/64 أو Float*

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

تُرجِع قيمة البت عند الموضع i في التمثيل الثنائي لـ a UInt8

أمثلة

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

SELECT bin(2), bitTest(2, 1);

┌─bin(2)───┬─bitTest(2, 1)─┐
│ 00000010 │             1 │
└──────────┴───────────────┘

bitTestAll

أُضيف في: v1.1.0

تعيد نتيجة الاقتران المنطقي (المعامل AND) لجميع البتات عند المواضع المحددة. يُحتسب العد من اليمين إلى اليسار، بدءًا من 0.

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

الصياغة

bitTestAll(a, index1[, index2, ... , indexN])

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

a — قيمة عدد صحيح. (U)Int8/16/32/64
index1, ... — موضع واحد أو عدة مواضع للبتات. (U)Int8/16/32/64

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

تُرجع نتيجة الاقتران المنطقي من النوع UInt8

أمثلة

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

SELECT bitTestAll(43, 0, 1, 3, 5);

┌─bitTestAll(43, 0, 1, 3, 5)─┐
│                          1 │
└────────────────────────────┘

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

SELECT bitTestAll(43, 0, 1, 3, 5, 2);

┌─bitTestAll(43, 0, 1, 3, 5, 2)─┐
│                             0 │
└───────────────────────────────┘

bitTestAny

أُضيف في: v1.1.0

يعيد ناتج الفصل المنطقي (المعامل OR) لجميع البتات في المواضع المحددة داخل عدد. يُحتسب من اليمين إلى اليسار، بدءًا من 0.

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

الصياغة

bitTestAny(a, index1[, index2, ... , indexN])

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

a — قيمة عدد صحيح. (U)Int8/16/32/64
index1, ... — موضع واحد أو عدة مواضع للبتات. (U)Int8/16/32/64

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

يُرجع نتيجة عملية «أو» المنطقية UInt8

أمثلة

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

SELECT bitTestAny(43, 0, 2);

┌─bitTestAny(43, 0, 2)─┐
│                    1 │
└──────────────────────┘

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

SELECT bitTestAny(43, 4, 2);

┌─bitTestAny(43, 4, 2)─┐
│                    0 │
└──────────────────────┘

bitXor

أُضيف في: v1.1.0

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

الصياغة

bitXor(a, b)

المعاملات

a — القيمة الأولى. (U)Int* أو Float*
b — القيمة الثانية. (U)Int* أو Float*

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

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

أمثلة

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

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;

┌─a─┬─b─┬─bitXor(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            1 │
│ 1 │ 0 │            1 │
│ 1 │ 1 │            0 │
└───┴───┴──────────────┘