تعمل دوال البت مع أي زوج من الأنواع UInt8 وUInt16 وUInt32 وUInt64 وInt8 وInt16 وInt32 وInt64 وFloat32 وFloat64. كما تدعم بعض الدوال النوعين String وFixedString.
نوع النتيجة عدد صحيح يساوي عددُ بتاته الحدَّ الأقصى لعدد البتات في وسيطاته. وإذا كان أحد الوسيطات على الأقل موقّعًا، فستكون النتيجة عددًا موقّعًا. وإذا كان أحد الوسيطات عددًا بفاصلة عائمة، فسيُحوَّل إلى Int64.
تم تقديمه في: v1.1.0
يُجري عملية AND على مستوى البت بين قيمتين.
الصياغة
المعاملات
القيمة المُعادة
تُرجع ناتج العملية البتية 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 │
└───┴───┴──────────────┘
x. UInt8.
لا تحوّل الدالة قيمة الإدخال إلى نوع أكبر (توسيع الإشارة).
على سبيل المثال: bitCount(toUInt8(-1)) = 8. SELECT bin(333), bitCount(333);
┌─bin(333)─────────┬─bitCount(333)─┐
│ 0000000101001101 │ 5 │
└──────────────────┴───────────────┘
SimHash لاكتشاف السلاسل شبه المتطابقة.
كلما صغرت المسافة، زاد التشابه بين السلاسل.
الصيغة
المعاملات
القيمة المُعادة
تُرجع مسافة هامينغ بين x وy من النوع UInt8
أمثلة
مثال للاستخدام
SELECT bitHammingDistance(111, 121);
┌─bitHammingDistance(111, 121)─┐
│ 3 │
└──────────────────────────────┘
~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 │
└──────────┴─────────────────┴────────┴───────────────┘
OR على مستوى البت بين قيمتين.
البنية
المعاملات
القيمة المُعادة
تُرجع ناتج عملية 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 │
└───┴───┴─────────────┘
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 │
└────┴──────────┴───────────┴────────────────┘
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 │
└────┴──────────┴───────────┴────────────────┘
FixedString أو String على أنها قيمة واحدة متعددة البايتات.
تُفقَد بتات قيمة FixedString عند خروجها نتيجة الإزاحة.
أما قيمة String فتُوسَّع بإضافة بايتات أخرى، لذلك لا تُفقَد أي بتات.
البنية
الوسائط
القيمة المعادة
تُرجِع القيمة المُزاحة بنوع يطابق نوع a.
أمثلة
مثال على الاستخدام مع الترميز الثنائي
SELECT 99 AS a, bin(a), bitShiftLeft(a, 2) AS a_shifted, bin(a_shifted);
┌──a─┬─bin(99)──┬─a_shifted─┬─bin(bitShiftLeft(99, 2))─┐
│ 99 │ 01100011 │ 140 │ 10001100 │
└────┴──────────┴───────────┴──────────────────────────┘
SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftLeft('abc', 4))─┐
│ abc │ 616263 │ &0 │ 06162630 │
└─────┴────────────┴───────────┴─────────────────────────────┘
SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftLeft(toFixedString('abc', 3), 4))─┐
│ abc │ 616263 │ &0 │ 162630 │
└─────┴──────────────────────────────┴───────────┴───────────────────────────────────────────────┘
FixedString وString على أنه قيمة واحدة متعددة البايتات.
تُفقد بِتات قيمة FixedString عند خروجها نتيجة الإزاحة.
وعلى النقيض من ذلك، تُوسَّع قيمة String ببايتات إضافية، لذا لا تُفقد أي بِتات.
البنية
المعاملات
القيمة المُعادة
يعيد القيمة المُزاحة بنوع مطابق لنوع a.
أمثلة
مثال استخدام مع الترميز الثنائي
SELECT 101 AS a, bin(a), bitShiftRight(a, 2) AS a_shifted, bin(a_shifted);
┌───a─┬─bin(101)─┬─a_shifted─┬─bin(bitShiftRight(101, 2))─┐
│ 101 │ 01100101 │ 25 │ 00011001 │
└─────┴──────────┴───────────┴────────────────────────────┘
SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftRight('abc', 12))─┐
│ abc │ 616263 │ │ 0616 │
└─────┴────────────┴───────────┴───────────────────────────────┘
SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftRight(a, 12) AS a_shifted, hex(a_shifted);
┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftRight(toFixedString('abc', 3), 12))─┐
│ abc │ 616263 │ │ 000616 │
└─────┴──────────────────────────────┴───────────┴─────────────────────────────────────────────────┘
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 │
└──────────────────────────────────────────┴───────────────────────────────┘
i في التمثيل الثنائي لـ a UInt8
أمثلة
مثال على الاستخدام
SELECT bin(2), bitTest(2, 1);
┌─bin(2)───┬─bitTest(2, 1)─┐
│ 00000010 │ 1 │
└──────────┴───────────────┘
bitTestAll(a, index1[, index2, ... , indexN])
UInt8
أمثلة
مثال على الاستخدام 1
SELECT bitTestAll(43, 0, 1, 3, 5);
┌─bin(43)──┬─bitTestAll(43, 0, 1, 3, 5)─┐
│ 00101011 │ 1 │
└──────────┴────────────────────────────┘
SELECT bitTestAll(43, 0, 1, 3, 5, 2);
┌─bin(43)──┬─bitTestAll(4⋯1, 3, 5, 2)─┐
│ 00101011 │ 0 │
└──────────┴──────────────────────────┘
true إذا كانت قيمة بت إدخال واحد على الأقل true.
البنية
bitTestAny(a, index1[, index2, ... , indexN])
UInt8
أمثلة
مثال استخدام 1
SELECT bitTestAny(43, 0, 2);
┌─bin(43)──┬─bitTestAny(43, 0, 2)─┐
│ 00101011 │ 1 │
└──────────┴──────────────────────┘
SELECT bitTestAny(43, 4, 2);
┌─bin(43)──┬─bitTestAny(43, 4, 2)─┐
│ 00101011 │ 0 │
└──────────┴──────────────────────┘
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 │
└───┴───┴──────────────┘
آخر تعديل في ٢٥ يونيو ٢٠٢٦
