14.12 Bit Functions and Operators — MySQL 8.4

14.12 Битовые функции и операторы

Таблица 14.17 Битовые функции и операторы

Таблица 14.17 Битовые функции и операторы
Имя	Описание
`&`	Битовое И
`>>`	Сдвиг вправо
`<<`	Сдвиг влево
`^`	Битовое ИСКЛЮЧАЮЩЕЕ ИЛИ
`BIT_COUNT()`	Возвращает количество установленных битов
`\|`	Битовое ИЛИ
`~`	Инвертирование битов

В следующем списке описаны доступные битовые функции и операторы:

|

Побитовое ИЛИ.

Результирующий тип зависит от того, интерпретируются ли аргументы как двоичные строки или числа:
- Вычисление двоичных строк происходит, когда аргументы имеют тип двоичной строки, и хотя бы один из них не является шестнадцатеричным литералом, битовым литералом или NULL литералом. В противном случае происходит численное вычисление с преобразованием аргументов в беззнаковые 64-битные целые числа по мере необходимости.
- Вычисление двоичных строк создает двоичную строку той же длины, что и аргументы. Если аргументы имеют разную длину, возникает ошибка. Численное вычисление создает беззнаковое 64-битное целое число.
Для получения дополнительной информации см. вводное обсуждение в этом разделе.
```
mysql> SELECT 29 | 15;
        -> 31
mysql> SELECT _binary X'40404040' | X'01020304';
        -> 'ABCD'
```
Если побитовое ИЛИ вызывается из клиента mysql, результаты в виде двоичных строк отображаются в шестнадцатеричной нотации в зависимости от значения --binary-as-hex. Для получения дополнительной информации об этом параметре см. Раздел 6.5.1, «mysql — The MySQL Command-Line Client».
&

Побитовое И.

Результирующий тип зависит от того, интерпретируются ли аргументы как двоичные строки или числа:
- Вычисление двоичных строк происходит, когда аргументы имеют тип двоичной строки, и хотя бы один из них не является шестнадцатеричным литералом, битовым литералом или NULL литералом. В противном случае происходит численное вычисление с преобразованием аргументов в беззнаковые 64-битные целые числа по мере необходимости.
- Вычисление двоичных строк создает двоичную строку той же длины, что и аргументы. Если аргументы имеют разную длину, возникает ошибка. Численное вычисление создает беззнаковое 64-битное целое число.
Для получения дополнительной информации см. вводное обсуждение в этом разделе.
```
mysql> SELECT 29 & 15;
        -> 13
mysql> SELECT HEX(_binary X'FF' & b'11110000');
        -> 'F0'
```
Если побитовое И вызывается из клиента mysql, результаты в виде двоичных строк отображаются в шестнадцатеричной нотации в зависимости от значения --binary-as-hex. Для получения дополнительной информации об этом параметре см. Раздел 6.5.1, «mysql — The MySQL Command-Line Client».
^

Побитовое XOR.

Результирующий тип зависит от того, интерпретируются ли аргументы как двоичные строки или числа:
- Вычисление двоичных строк происходит, когда аргументы имеют тип двоичной строки, и хотя бы один из них не является шестнадцатеричным литералом, битовым литералом или NULL литералом. В противном случае происходит численное вычисление с преобразованием аргументов в беззнаковые 64-битные целые числа по мере необходимости.
- Вычисление двоичных строк создает двоичную строку той же длины, что и аргументы. Если аргументы имеют разную длину, возникает ошибка. Численное вычисление создает беззнаковое 64-битное целое число.
Для получения дополнительной информации см. вводное обсуждение в этом разделе.
```
mysql> SELECT 1 ^ 1;
        -> 0
mysql> SELECT 1 ^ 0;
        -> 1
mysql> SELECT 11 ^ 3;
        -> 8
mysql> SELECT HEX(_binary X'FEDC' ^ X'1111');
        -> 'EFCD'
```
Если побитовое XOR вызывается из клиента mysql, результаты в виде двоичных строк отображаются в шестнадцатеричной нотации в зависимости от значения --binary-as-hex. Для получения дополнительной информации об этом параметре см. Раздел 6.5.1, «mysql — The MySQL Command-Line Client».
<<

Сдвигает число longlong (BIGINT) или двоичную строку влево.

Результирующий тип зависит от того, интерпретируется ли битовый аргумент как двоичная строка или число:
- Вычисление двоичных строк происходит, когда битовый аргумент имеет тип двоичной строки и не является шестнадцатеричным литералом, битовым литералом или NULL литералом. В противном случае происходит численное вычисление с преобразованием аргумента в беззнаковое 64-битное целое число по мере необходимости.
- Вычисление двоичных строк создает двоичную строку той же длины, что и битовый аргумент. Численное вычисление создает беззнаковое 64-битное целое число.
Биты, сдвинутые за пределы значения, теряются без предупреждения, независимо от типа аргумента. В частности, если счетчик сдвига больше или равен количеству битов в битовом аргументе, все биты в результате равны 0.

Для получения дополнительной информации см. вводное обсуждение в этом разделе.
```
mysql> SELECT 1 << 2;
        -> 4
mysql> SELECT HEX(_binary X'00FF00FF00FF' << 8);
        -> 'FF00FF00FF00'
```
Если битовый сдвиг вызывается из клиента mysql, результаты в виде двоичных строк отображаются в шестнадцатеричной нотации в зависимости от значения --binary-as-hex. Для получения дополнительной информации об этом параметре см. Раздел 6.5.1, «mysql — The MySQL Command-Line Client».
>>

Сдвигает число longlong (BIGINT) или двоичную строку вправо.

Результирующий тип зависит от того, интерпретируется ли битовый аргумент как двоичная строка или число:
- Вычисление двоичных строк происходит, когда битовый аргумент имеет тип двоичной строки и не является шестнадцатеричным литералом, битовым литералом или NULL литералом. В противном случае происходит численное вычисление с преобразованием аргумента в беззнаковое 64-битное целое число по мере необходимости.
- Вычисление двоичных строк создает двоичную строку той же длины, что и битовый аргумент. Численное вычисление создает беззнаковое 64-битное целое число.
Биты, сдвинутые за пределы значения, теряются без предупреждения, независимо от типа аргумента. В частности, если счетчик сдвига больше или равен количеству битов в битовом аргументе, все биты в результате равны 0.

Для получения дополнительной информации см. вводное обсуждение в этом разделе.
```
mysql> SELECT 4 >> 2;
        -> 1
mysql> SELECT HEX(_binary X'00FF00FF00FF' >> 8);
        -> '0000FF00FF00'
```
Если битовый сдвиг вызывается из клиента mysql, результаты в виде двоичных строк отображаются в шестнадцатеричной нотации в зависимости от значения --binary-as-hex. Для получения дополнительной информации об этом параметре см. Раздел 6.5.1, «mysql — The MySQL Command-Line Client».
~

Инвертирует все биты.

Результирующий тип зависит от того, интерпретируется ли битовый аргумент как двоичная строка или число:
- Вычисление двоичных строк происходит, когда битовый аргумент имеет тип двоичной строки и не является шестнадцатеричным литералом, битовым литералом или NULL литералом. В противном случае происходит численное вычисление с преобразованием аргумента в беззнаковое 64-битное целое число по мере необходимости.
- Вычисление двоичных строк создает двоичную строку той же длины, что и битовый аргумент. Численное вычисление создает беззнаковое 64-битное целое число.
Для получения дополнительной информации см. вводное обсуждение в этом разделе.
```
mysql> SELECT 5 & ~1;
        -> 4
mysql> SELECT HEX(~X'0000FFFF1111EEEE');
        -> 'FFFF0000EEEE1111'
```
Если побитовая инверсия вызывается из клиента mysql, результаты в виде двоичных строк отображаются в шестнадцатеричной нотации в зависимости от значения --binary-as-hex. Для получения дополнительной информации об этом параметре см. Раздел 6.5.1, «mysql — The MySQL Command-Line Client».

BIT_COUNT(N)

Возвращает количество установленных битов в аргументе N как беззнаковое 64-битное целое число или NULL, если аргумент является NULL.

mysql> SELECT BIT_COUNT(64), BIT_COUNT(BINARY 64);
        -> 1, 7
mysql> SELECT BIT_COUNT('64'), BIT_COUNT(_binary '64');
        -> 1, 7
mysql> SELECT BIT_COUNT(X'40'), BIT_COUNT(_binary X'40');
        -> 1, 1

Функции и операторы битовых операций включают BIT_COUNT(), BIT_AND(), BIT_OR(), BIT_XOR(), &, |, ^, ~, << и >>. (Функции агрегирования BIT_AND(), BIT_OR() и BIT_XOR() описаны в разделе 14.19.1 «Описание функций агрегирования».)

Функции и операторы битовых операций допускают аргументы типа бинарной строки (BINARY, VARBINARY и типы BLOB) и возвращают значение такого же типа. Аргументы, являющиеся строками, не являющимися бинарными, преобразуются в BIGINT.

Битовые операции

MySQL 8.4 обрабатывает аргументы бинарных строк непосредственно (без преобразования) и генерирует результаты в виде бинарных строк. Аргументы, которые не являются целыми числами или бинарными строками, преобразуются в целые числа.

К аргументам, считающимся бинарными строками, относятся значения столбцов, параметры процедур, локальные переменные и переменные, определённые пользователем, имеющие тип бинарной строки: BINARY, VARBINARY или один из типов BLOB.

Вы можете указывать аргументы для битовых операций, используя шестнадцатеричные литералы или битовые литералы, предполагая, что они представляют числа; MySQL оценивает битовые операции в числовом контексте, когда все битовые аргументы являются шестнадцатеричными или битовыми литералами. Для оценки как бинарных строк вместо этого используйте префикс _binary хотя бы для одного из значений литерала.

Эти битовые операции оценивают шестнадцатеричные литералы и битовые литералы как целые числа:

mysql> SELECT X'40' | X'01', b'11110001' & b'01001111';
+---------------+---------------------------+
| X'40' | X'01' | b'11110001' & b'01001111' |
+---------------+---------------------------+
|            65 |                        65 |
+---------------+---------------------------+

Эти битовые операции оценивают шестнадцатеричные литералы и битовые литералы как бинарные строки из-за префикса _binary:

mysql> SELECT _binary X'40' | X'01', b'11110001' & _binary b'01001111';
+-----------------------+-----------------------------------+
| _binary X'40' | X'01' | b'11110001' & _binary b'01001111' |
+-----------------------+-----------------------------------+
| A                     | A                                 |
+-----------------------+-----------------------------------+

Хотя битовые операции в обоих утверждениях производят результат с числовым значением 65, второе утверждение работает в контексте бинарных строк, для которого 65 является ASCII A.

В контексте числовой оценки допустимые значения шестнадцатеричных литералов и битовых литералов аргументов имеют максимальное значение 64 бита, как и результаты. В отличие от этого, в контексте оценки бинарных строк допустимые аргументы (и результаты) могут превышать 64 бита:

mysql> SELECT _binary X'4040404040404040' | X'0102030405060708';
+---------------------------------------------------+
| _binary X'4040404040404040' | X'0102030405060708' |
+---------------------------------------------------+
| ABCDEFGH                                          |
+---------------------------------------------------+

Существует несколько способов указать шестнадцатеричный литерал или битовый литерал в битовой операции, чтобы вызвать оценку бинарной строки:

_binary literal
BINARY literal
CAST(literal AS BINARY)

Другой способ получения оценки шестнадцатеричных литералов или битовых литералов в виде бинарных строк заключается в присвоении им значений переменным, определённых пользователем, что приводит к переменным, имеющим тип бинарной строки:

mysql> SET @v1 = X'40', @v2 = X'01', @v3 = b'11110001', @v4 = b'01001111';
mysql> SELECT @v1 | @v2, @v3 & @v4;
+-----------+-----------+
| @v1 | @v2 | @v3 & @v4 |
+-----------+-----------+
| A         | A         |
+-----------+-----------+

В контексте бинарных строк аргументы битовой операции должны иметь одинаковую длину, иначе произойдёт ошибка:

mysql> SELECT _binary X'40' | X'0001';
ERROR 3513 (HY000): Binary operands of bitwise
operators must be of equal length

Для удовлетворения требования о равенстве длин дополните значение меньшей длины ведущими нулями или, если значение большего размера начинается с ведущих нулей, а приемлемо значение меньшей длины, удалите их:

mysql> SELECT _binary X'0040' | X'0001';
+---------------------------+
| _binary X'0040' | X'0001' |
+---------------------------+
|  A                        |
+---------------------------+
mysql> SELECT _binary X'40' | X'01';
+-----------------------+
| _binary X'40' | X'01' |
+-----------------------+
| A                     |
+-----------------------+

Заполнение нулями или удаление нулей также можно выполнить с помощью функций, таких как LPAD(), RPAD(), SUBSTR() или CAST(). В таких случаях аргументы выражения больше не являются литералами, и _binary больше не требуется. Примеры:

mysql> SELECT LPAD(X'40', 2, X'00') | X'0001';
+---------------------------------+
| LPAD(X'40', 2, X'00') | X'0001' |
+---------------------------------+
|  A                              |
+---------------------------------+
mysql> SELECT X'40' | SUBSTR(X'0001', 2, 1);
+-------------------------------+
| X'40' | SUBSTR(X'0001', 2, 1) |
+-------------------------------+
| A                             |
+-------------------------------+

См. также Специальная обработка шестнадцатеричных литералов, битовых литералов и литералов NULL.

Примеры битовых операций со строками

Следующий пример иллюстрирует использование битовых операций для извлечения частей значения UUID, в данном случае метки времени и номера узла IEEE 802. Этот метод требует битовых масок для каждой извлекаемой части.

Преобразуйте текстовое значение UUID в соответствующее 16-байтовое двоичное значение, чтобы можно было манипулировать им с помощью битовых операций в контексте бинарных строк:

mysql> SET @uuid = UUID_TO_BIN('6ccd780c-baba-1026-9564-5b8c656024db');
mysql> SELECT HEX(@uuid);
+----------------------------------+
| HEX(@uuid)                       |
+----------------------------------+
| 6CCD780CBABA102695645B8C656024DB |
+----------------------------------+

Создайте битовые маски для частей метки времени и номера узла значения. Метка времени состоит из первых трёх частей (64 бита, биты 0–63), а номер узла — из последней части (48 бит, биты 80–127):

mysql> SET @ts_mask = CAST(X'FFFFFFFFFFFFFFFF' AS BINARY(16));
mysql> SET @node_mask = CAST(X'FFFFFFFFFFFF' AS BINARY(16)) >> 80;
mysql> SELECT HEX(@ts_mask);
+----------------------------------+
| HEX(@ts_mask)                    |
+----------------------------------+
| FFFFFFFFFFFFFFFF0000000000000000 |
+----------------------------------+
mysql> SELECT HEX(@node_mask);
+----------------------------------+
| HEX(@node_mask)                  |
+----------------------------------+
| 00000000000000000000FFFFFFFFFFFF |
+----------------------------------+

Здесь используется функция CAST(... AS BINARY(16)), потому что маски должны иметь такую же длину, как и значение UUID, к которому они применяются. Тот же результат можно получить, используя другие функции для дополнения масок до требуемой длины:

SET @ts_mask= RPAD(X'FFFFFFFFFFFFFFFF' , 16, X'00');
SET @node_mask = LPAD(X'FFFFFFFFFFFF', 16, X'00') ;

Используйте маски для извлечения частей метки времени и номера узла:

mysql> SELECT HEX(@uuid & @ts_mask) AS 'timestamp part';
+----------------------------------+
| timestamp part                   |
+----------------------------------+
| 6CCD780CBABA10260000000000000000 |
+----------------------------------+
mysql> SELECT HEX(@uuid & @node_mask) AS 'node part';
+----------------------------------+
| node part                        |
+----------------------------------+
| 000000000000000000005B8C656024DB |
+----------------------------------+

В предыдущем примере используются следующие битовые операции: сдвиг вправо (>>) и побитовое И (&).

Примечание

UUID_TO_BIN() принимает флаг, который вызывает некоторую перестановку битов в результирующем двоичном значении UUID. Если вы используете этот флаг, измените маски извлечения соответственно.

Следующий пример использует битовые операции для извлечения сетевой и узловой частей адреса IPv6. Предположим, что сетевая часть имеет длину 80 бит. Тогда узловая часть имеет длину 128 − 80 = 48 бит. Чтобы извлечь сетевую и узловую части адреса, преобразуйте его в двоичную строку, а затем используйте битовые операции в контексте бинарных строк.

Преобразуйте текстовый адрес IPv6 в соответствующую двоичную строку:

mysql> SET @ip = INET6_ATON('fe80::219:d1ff:fe91:1a72');

Определите длину сетевой части в битах:

mysql> SET @net_len = 80;

Создайте маски сети и узла, сдвигая адрес со всеми единицами влево или вправо. Для этого начните с адреса ::, который является сокращением для всех нулей, как вы можете увидеть, преобразовав его в двоичную строку так:

mysql> SELECT HEX(INET6_ATON('::')) AS 'all zeros';
+----------------------------------+
| all zeros                        |
+----------------------------------+
| 00000000000000000000000000000000 |
+----------------------------------+

Для получения дополнительного значения (все единицы) используйте оператор ~ для инвертирования битов:

mysql> SELECT HEX(~INET6_ATON('::')) AS 'all ones';
+----------------------------------+
| all ones                         |
+----------------------------------+
| FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF |
+----------------------------------+

Сдвиньте значение со всеми единицами влево или вправо, чтобы получить маски сети и узла:

mysql> SET @net_mask = ~INET6_ATON('::') << (128 - @net_len);
mysql> SET @host_mask = ~INET6_ATON('::') >> @net_len;

Отобразите маски, чтобы убедиться, что они охватывают правильные части адреса:

mysql> SELECT INET6_NTOA(@net_mask) AS 'network mask';
+----------------------------+
| network mask               |
+----------------------------+
| ffff:ffff:ffff:ffff:ffff:: |
+----------------------------+
mysql> SELECT INET6_NTOA(@host_mask) AS 'host mask';
+------------------------+
| host mask              |
+------------------------+
| ::ffff:255.255.255.255 |
+------------------------+

Извлеките и отобразите сетевую и узловую части адреса:

mysql> SET @net_part = @ip & @net_mask;
mysql> SET @host_part = @ip & @host_mask;
mysql> SELECT INET6_NTOA(@net_part) AS 'network part';
+-----------------+
| network part    |
+-----------------+
| fe80::219:0:0:0 |
+-----------------+
mysql> SELECT INET6_NTOA(@host_part) AS 'host part';
+------------------+
| host part        |
+------------------+
| ::d1ff:fe91:1a72 |
+------------------+

В предыдущем примере используются следующие битовые операции: Дополнение (~), сдвиг влево (<<) и побитовое И (&).

Остальная часть обсуждения содержит подробности обработки аргументов для каждой группы битовых операций и дополнительную информацию о обработке значений литералов в битовых операциях.

Побитовые операции AND, OR и XOR

Для &, | и ^ побитовых операций тип результата зависит от того, оцениваются ли аргументы как двоичные строки или числа:

Оценка в виде двоичной строки происходит, когда аргументы имеют тип двоичной строки, и по крайней мере один из них не является шестнадцатеричной, битовой или NULL литеральной константой. В противном случае происходит числовая оценка с преобразованием аргументов в целые беззнаковые 64-битные числа по необходимости.
Оценка в виде двоичной строки даёт двоичную строку той же длины, что и аргументы. Если аргументы имеют различную длину, возникает ошибка. Числовая оценка даёт целое беззнаковое 64-битное число.

Примеры числовой оценки:

mysql> SELECT 64 | 1, X'40' | X'01';
+--------+---------------+
| 64 | 1 | X'40' | X'01' |
+--------+---------------+
|     65 |            65 |
+--------+---------------+

Примеры оценки в виде двоичной строки:

mysql> SELECT _binary X'40' | X'01';
+-----------------------+
| _binary X'40' | X'01' |
+-----------------------+
| A                     |
+-----------------------+
mysql> SET @var1 = X'40', @var2 = X'01';
mysql> SELECT @var1 | @var2;
+---------------+
| @var1 | @var2 |
+---------------+
| A             |
+---------------+

Побитовые операции дополнения и сдвига

Для ~, << и >> побитовых операций тип результата зависит от того, оценивается ли битовый аргумент как двоичная строка или число:

Оценка в виде двоичной строки происходит, когда битовый аргумент имеет тип двоичной строки и не является шестнадцатеричной, битовой или NULL литеральной константой. В противном случае происходит числовая оценка с преобразованием аргумента в целое беззнаковое 64-битное число по необходимости.
Оценка в виде двоичной строки даёт двоичную строку той же длины, что и битовый аргумент. Числовая оценка даёт целое беззнаковое 64-битное число.

Для операций сдвига биты, сдвинутые за пределы значения, теряются без предупреждения, независимо от типа аргумента. В частности, если счётчик сдвига больше или равен числу битов в битовом аргументе, все биты результата равны 0.

Примеры числовой оценки:

mysql> SELECT ~0, 64 << 2, X'40' << 2;
+----------------------+---------+------------+
| ~0                   | 64 << 2 | X'40' << 2 |
+----------------------+---------+------------+
| 18446744073709551615 |     256 |        256 |
+----------------------+---------+------------+

Примеры оценки в виде двоичной строки:

mysql> SELECT HEX(_binary X'1111000022220000' >> 16);
+----------------------------------------+
| HEX(_binary X'1111000022220000' >> 16) |
+----------------------------------------+
| 0000111100002222                       |
+----------------------------------------+
mysql> SELECT HEX(_binary X'1111000022220000' << 16);
+----------------------------------------+
| HEX(_binary X'1111000022220000' << 16) |
+----------------------------------------+
| 0000222200000000                       |
+----------------------------------------+
mysql> SET @var1 = X'F0F0F0F0';
mysql> SELECT HEX(~@var1);
+-------------+
| HEX(~@var1) |
+-------------+
| 0F0F0F0F    |
+-------------+

Операции BIT_COUNT()

Функция BIT_COUNT() всегда возвращает целое беззнаковое 64-битное число или NULL, если аргумент имеет значение NULL.

mysql> SELECT BIT_COUNT(127);
+----------------+
| BIT_COUNT(127) |
+----------------+
|              7 |
+----------------+
mysql> SELECT BIT_COUNT(b'010101'), BIT_COUNT(_binary b'010101');
+----------------------+------------------------------+
| BIT_COUNT(b'010101') | BIT_COUNT(_binary b'010101') |
+----------------------+------------------------------+
|                    3 |                            3 |
+----------------------+------------------------------+

Операции BIT_AND(), BIT_OR() и BIT_XOR()

Для побитовых функций BIT_AND(), BIT_OR() и BIT_XOR() тип результата зависит от того, оцениваются ли значения аргументов как двоичные строки или числа:

Оценка в виде двоичной строки происходит, когда значения аргументов имеют тип двоичной строки, и аргумент не является шестнадцатеричной, битовой или NULL литеральной константой. В противном случае происходит числовая оценка с преобразованием значений аргументов в целые беззнаковые 64-битные числа по необходимости.
Оценка в виде двоичной строки даёт двоичную строку той же длины, что и значения аргументов. Если значения аргументов имеют различную длину, возникает ошибка. Если размер аргумента превышает 511 байтов, возникает ошибка. Числовая оценка даёт целое беззнаковое 64-битное число.

Значения NULL не влияют на результат, если все значения являются NULL. В этом случае результат представляет собой нейтральное значение, имеющее такую же длину, как и значения аргументов (все биты 1 для BIT_AND(), все биты 0 для BIT_OR() и BIT_XOR()).

Пример:

mysql> CREATE TABLE t (group_id INT, a VARBINARY(6));
mysql> INSERT INTO t VALUES (1, NULL);
mysql> INSERT INTO t VALUES (1, NULL);
mysql> INSERT INTO t VALUES (2, NULL);
mysql> INSERT INTO t VALUES (2, X'1234');
mysql> INSERT INTO t VALUES (2, X'FF34');
mysql> SELECT HEX(BIT_AND(a)), HEX(BIT_OR(a)), HEX(BIT_XOR(a))
       FROM t GROUP BY group_id;
+-----------------+----------------+-----------------+
| HEX(BIT_AND(a)) | HEX(BIT_OR(a)) | HEX(BIT_XOR(a)) |
+-----------------+----------------+-----------------+
| FFFFFFFFFFFF    | 000000000000   | 000000000000    |
| 1234            | FF34           | ED00            |
+-----------------+----------------+-----------------+

Специальная обработка шестнадцатеричных, битовых и NULL-литералов

MySQL 8.4 оценивает побитовые операции в числовом контексте, когда все битовые аргументы являются шестнадцатеричными, битовыми или NULL литералами. То есть, побитовые операции над битовыми аргументами в виде двоичных строк не используют оценку в виде двоичных строк, если все битовые аргументы являются немодифицированными шестнадцатеричными, битовыми или NULL литералами. (Это не относится к таким литералам, если они написаны с _binary префиксом, оператором BINARY или другим способом явного указания как двоичных строк.)

Примеры:

Эти побитовые операции оценивают литералы в числовом контексте и дают BIGINT результат:
```
b'0001' | b'0010'
X'0008' << 8
```
Эти побитовые операции оценивают NULL в числовом контексте и дают BIGINT результат, который имеет NULL значение:
```
NULL & NULL
NULL >> 4
```

Вы можете заставить эти операции оценивать аргументы в контексте двоичных строк, явно указав, что по крайней мере один аргумент является двоичной строкой:

_binary b'0001' | b'0010'
_binary X'0008' << 8
BINARY NULL & NULL
BINARY NULL >> 4

Результат последних двух выражений — NULL, точно так же, как без оператора BINARY, но тип данных результата — тип двоичной строки, а не тип целого числа.