14.12 Bit Functions and Operators — MySQL 9.2

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 9.2 обрабатывает аргументы двоичных строк непосредственно (без преобразования) и генерирует результаты в виде двоичных строк. Аргументы, которые не являются целыми числами или двоичными строками, преобразуются в целые числа.

К аргументам, которые считаются двоичными строками, относятся значения столбцов, параметры процедур, локальные переменные и переменные, определенные пользователем, имеющие тип двоичной строки: 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 |
+------------------+

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

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

Битовые операции И, ИЛИ и ИСКЛЮЧАЮЩЕЕ ИЛИ

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

Оценка двоичной строки происходит, когда аргументы имеют тип двоичной строки, и по крайней мере один из них не является шестнадцатеричной константой, битовой константой или 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 9.2 оценивает битовые операции в числовом контексте, когда все битовые аргументы являются шестнадцатеричными константами, битовыми константами или 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 оператора, но тип данных результата — тип двоичной строки, а не целочисленный тип.