데브러너 (DevRunner)

14.12 Bit Functions and Operators

Table 14.17 Bit Functions and Operators

Name	Description
`&`	비트 단위 AND
`>>`	오른쪽 시프트
`<<`	왼쪽 시프트
`^`	비트 단위 XOR
`BIT_COUNT()`	설정된 비트의 개수 반환
[`	`](https://dev.mysql.com/doc/refman/9.5/en/bit-functions.html#operator_bitwise-or)
`~`	비트 반전

다음 목록은 사용 가능한 비트 함수와 연산자를 설명합니다:

비트 단위 OR.

결과 타입은 인자가 바이너리 문자열로 평가되는지 숫자로 평가되는지에 따라 달라집니다:

바이너리 문자열 평가가 발생하는 경우: 인자가 바이너리 문자열 타입이고, 그중 적어도 하나가 16진수 리터럴, 비트 리터럴, 또는 NULL 리터럴이 아닐 때입니다. 그렇지 않은 경우에는 숫자 평가가 발생하며, 필요하다면 인자를 부호 없는 64비트 정수로 변환합니다.
바이너리 문자열 평가는 인자와 같은 길이의 바이너리 문자열을 생성합니다. 인자의 길이가 서로 다르면 ER_INVALID_BITWISE_OPERANDS_SIZE 에러가 발생합니다. 숫자 평가는 부호 없는 64비트 정수를 생성합니다.

자세한 내용은 이 섹션의 도입부 설명을 참조하십시오.

1mysql> SELECT 29 | 15;
2        -> 31
3mysql> SELECT _binary X'40404040' | X'01020304';
4        -> 'ABCD'

비트 단위 OR가 mysql 클라이언트 내에서 호출되면, 바이너리 문자열 결과는 --binary-as-hex 값에 따라 16진수 표기법으로 표시됩니다. 해당 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”을 참조하십시오.

비트 단위 AND.

결과 타입은 인자가 바이너리 문자열로 평가되는지 숫자로 평가되는지에 따라 달라집니다:

바이너리 문자열 평가가 발생하는 경우: 인자가 바이너리 문자열 타입이고, 그중 적어도 하나가 16진수 리터럴, 비트 리터럴, 또는 NULL 리터럴이 아닐 때입니다. 그렇지 않은 경우에는 숫자 평가가 발생하며, 필요하다면 인자를 부호 없는 64비트 정수로 변환합니다.
바이너리 문자열 평가는 인자와 같은 길이의 바이너리 문자열을 생성합니다. 인자의 길이가 서로 다르면 ER_INVALID_BITWISE_OPERANDS_SIZE 에러가 발생합니다. 숫자 평가는 부호 없는 64비트 정수를 생성합니다.

자세한 내용은 이 섹션의 도입부 설명을 참조하십시오.

1mysql> SELECT 29 & 15;
2        -> 13
3mysql> SELECT HEX(_binary X'FF' & b'11110000');
4        -> 'F0'

비트 단위 AND가 mysql 클라이언트 내에서 호출되면, 바이너리 문자열 결과는 --binary-as-hex 값에 따라 16진수 표기법으로 표시됩니다. 해당 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”을 참조하십시오.

비트 단위 XOR.

결과 타입은 인자가 바이너리 문자열로 평가되는지 숫자로 평가되는지에 따라 달라집니다:

바이너리 문자열 평가가 발생하는 경우: 인자가 바이너리 문자열 타입이고, 그중 적어도 하나가 16진수 리터럴, 비트 리터럴, 또는 NULL 리터럴이 아닐 때입니다. 그렇지 않은 경우에는 숫자 평가가 발생하며, 필요하다면 인자를 부호 없는 64비트 정수로 변환합니다.
바이너리 문자열 평가는 인자와 같은 길이의 바이너리 문자열을 생성합니다. 인자의 길이가 서로 다르면 ER_INVALID_BITWISE_OPERANDS_SIZE 에러가 발생합니다. 숫자 평가는 부호 없는 64비트 정수를 생성합니다.

자세한 내용은 이 섹션의 도입부 설명을 참조하십시오.

1mysql> SELECT 1 ^ 1;
2        -> 0
3mysql> SELECT 1 ^ 0;
4        -> 1
5mysql> SELECT 11 ^ 3;
6        -> 8
7mysql> SELECT HEX(_binary X'FEDC' ^ X'1111');
8        -> 'EFCD'

비트 단위 XOR가 mysql 클라이언트 내에서 호출되면, 바이너리 문자열 결과는 --binary-as-hex 값에 따라 16진수 표기법으로 표시됩니다. 해당 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”을 참조하십시오.

<<

longlong (BIGINT) 숫자 또는 바이너리 문자열을 왼쪽으로 시프트합니다.

결과 타입은 비트 인자가 바이너리 문자열로 평가되는지 숫자로 평가되는지에 따라 달라집니다:

바이너리 문자열 평가가 발생하는 경우: 비트 인자가 바이너리 문자열 타입이고, 16진수 리터럴, 비트 리터럴, 또는 NULL 리터럴이 아닐 때입니다. 그렇지 않은 경우에는 숫자 평가가 발생하며, 필요하다면 인자를 부호 없는 64비트 정수로 변환합니다.
바이너리 문자열 평가는 비트 인자와 같은 길이의 바이너리 문자열을 생성합니다. 숫자 평가는 부호 없는 64비트 정수를 생성합니다.

시프트되는 값의 끝에서 밀려나간 비트는 인자 타입에 관계없이 경고 없이 폐기됩니다. 특히, 시프트 횟수가 비트 인자의 비트 수보다 크거나 같으면, 결과의 모든 비트는 0이 됩니다.

자세한 내용은 이 섹션의 도입부 설명을 참조하십시오.

1mysql> SELECT 1 << 2;
2        -> 4
3mysql> SELECT HEX(_binary X'00FF00FF00FF' << 8);
4        -> 'FF00FF00FF00'

비트 시프트가 mysql 클라이언트 내에서 호출되면, 바이너리 문자열 결과는 --binary-as-hex 값에 따라 16진수 표기법으로 표시됩니다. 해당 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”을 참조하십시오.

>>

longlong (BIGINT) 숫자 또는 바이너리 문자열을 오른쪽으로 시프트합니다.

결과 타입은 비트 인자가 바이너리 문자열로 평가되는지 숫자로 평가되는지에 따라 달라집니다:

바이너리 문자열 평가가 발생하는 경우: 비트 인자가 바이너리 문자열 타입이고, 16진수 리터럴, 비트 리터럴, 또는 NULL 리터럴이 아닐 때입니다. 그렇지 않은 경우에는 숫자 평가가 발생하며, 필요하다면 인자를 부호 없는 64비트 정수로 변환합니다.
바이너리 문자열 평가는 비트 인자와 같은 길이의 바이너리 문자열을 생성합니다. 숫자 평가는 부호 없는 64비트 정수를 생성합니다.

자세한 내용은 이 섹션의 도입부 설명을 참조하십시오.

1mysql> SELECT 4 >> 2;
2        -> 1
3mysql> SELECT HEX(_binary X'00FF00FF00FF' >> 8);
4        -> '0000FF00FF00'

모든 비트를 반전합니다.

결과 타입은 비트 인자가 바이너리 문자열로 평가되는지 숫자로 평가되는지에 따라 달라집니다:

바이너리 문자열 평가가 발생하는 경우: 비트 인자가 바이너리 문자열 타입이고, 16진수 리터럴, 비트 리터럴, 또는 NULL 리터럴이 아닐 때입니다. 그렇지 않은 경우에는 숫자 평가가 발생하며, 필요하다면 인자를 부호 없는 64비트 정수로 변환합니다.
바이너리 문자열 평가는 비트 인자와 같은 길이의 바이너리 문자열을 생성합니다. 숫자 평가는 부호 없는 64비트 정수를 생성합니다.

자세한 내용은 이 섹션의 도입부 설명을 참조하십시오.

1mysql> SELECT 5 & ~1;
2        -> 4
3mysql> SELECT HEX(~X'0000FFFF1111EEEE');
4        -> 'FFFF0000EEEE1111'

비트 반전이 mysql 클라이언트 내에서 호출되면, 바이너리 문자열 결과는 --binary-as-hex 값에 따라 16진수 표기법으로 표시됩니다. 해당 옵션에 대한 자세한 내용은 Section 6.5.1, “mysql — The MySQL Command-Line Client”을 참조하십시오.

BIT_COUNT(N)

인자 N 에 설정된 비트의 수를 부호 없는 64비트 정수로 반환하며, 인자가 NULL이면 NULL을 반환합니다.

1mysql> SELECT BIT_COUNT(64), BIT_COUNT(BINARY 64);
2          -> 1, 7
3mysql> SELECT BIT_COUNT('64'), BIT_COUNT(_binary '64');
4          -> 1, 7
5mysql> SELECT BIT_COUNT(X'40'), BIT_COUNT(_binary X'40');
6          -> 1, 1

비트 함수와 연산자에는 BIT_COUNT(), BIT_AND(), BIT_OR(), BIT_XOR(), &, |, ^, ~, <<, 그리고 >>가 포함됩니다. (BIT_AND(), BIT_OR(), BIT_XOR() 집계 함수는 Section 14.19.1, “Aggregate Function Descriptions”에서 설명합니다.)

비트 함수와 연산자는 바이너리 문자열 타입 인자를 허용하며 (BINARY, VARBINARY, 및 BLOB 타입) 같은 타입의 값을 반환합니다. 논바이너리 문자열 인자는 BIGINT로 변환됩니다.

Bit Operations

MySQL 9.5는 바이너리 문자열 인자를 직접 처리하며 (변환 없이) 바이너리 문자열 결과를 생성합니다. 정수가 아니거나 바이너리 문자열이 아닌 인자는 정수로 변환됩니다.

바이너리 문자열로 간주되는 인자에는 컬럼 값, 루틴 파라미터, 로컬 변수, 그리고 바이너리 문자열 타입을 가지는 사용자 정의 변수가 포함됩니다: BINARY, VARBINARY, 또는 BLOB 타입 중 하나입니다.

16진수 리터럴 또는 비트 리터럴을 비트 연산의 인자로 지정하면서 그것들이 숫자를 나타낸다고 의도할 수 있습니다. 모든 비트 인자가 16진수 리터럴 또는 비트 리터럴인 경우 MySQL은 비트 연산을 숫자 컨텍스트에서 평가합니다.

대신 바이너리 문자열로 평가하려면 리터럴 값 중 적어도 하나에 대해 _binary 인트로듀서를 사용하십시오.

다음 비트 연산은 16진수 리터럴 및 비트 리터럴을 정수로 평가합니다:

1mysql> SELECT X'40' | X'01', b'11110001' & b'01001111';
2+---------------+---------------------------+
3| X'40' | X'01' | b'11110001' & b'01001111' |
4+---------------+---------------------------+
5|            65 |                        65 |
6+---------------+---------------------------+

다음 비트 연산은 _binary 인트로듀서로 인해 16진수 리터럴 및 비트 리터럴을 바이너리 문자열로 평가합니다:

1mysql> SELECT _binary X'40' | X'01', b'11110001' & _binary b'01001111';
2+-----------------------+-----------------------------------+
3| _binary X'40' | X'01' | b'11110001' & _binary b'01001111' |
4+-----------------------+-----------------------------------+
5| A                     | A                                 |
6+-----------------------+-----------------------------------+

두 스테이트먼트의 비트 연산 결과는 모두 숫자 값 65를 생성하지만, 두 번째 스테이트먼트는 바이너리 문자열 컨텍스트에서 동작하며, 이 컨텍스트에서 65는 ASCII A입니다.

숫자 평가 컨텍스트에서 허용되는 16진수 리터럴과 비트 리터럴 인자의 값은 최대 64비트이며, 결과도 마찬가지입니다. 반대로, 바이너리 문자열 평가 컨텍스트에서는 허용되는 인자(및 결과)가 64비트를 초과할 수 있습니다:

1mysql> SELECT _binary X'4040404040404040' | X'0102030405060708';
2+---------------------------------------------------+
3| _binary X'4040404040404040' | X'0102030405060708' |
4+---------------------------------------------------+
5| ABCDEFGH                                          |
6+---------------------------------------------------+

비트 연산에서 16진수 리터럴 또는 비트 리터럴을 참조하여 바이너리 문자열 평가를 유도하는 방법은 여러 가지가 있습니다:

1_binary literal
2BINARY literal
3CAST(literal AS BINARY)

16진수 리터럴 또는 비트 리터럴의 바이너리 문자열 평가를 생성하는 또 다른 방법은 그것들을 사용자 정의 변수에 할당하는 것입니다. 이 경우 해당 변수는 바이너리 문자열 타입을 갖게 됩니다:

1mysql> SET @v1 = X'40', @v2 = X'01', @v3 = b'11110001', @v4 = b'01001111';
2mysql> SELECT @v1 | @v2, @v3 & @v4;
3+-----------+-----------+
4| @v1 | @v2 | @v3 & @v4 |
5+-----------+-----------+
6| A         | A         |
7+-----------+-----------+

바이너리 문자열 컨텍스트에서는 비트 연산 인자의 길이가 동일해야 하며, 그렇지 않으면 ER_INVALID_BITWISE_OPERANDS_SIZE 에러가 발생합니다:

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

길이 동일 조건을 만족하려면 더 짧은 값을 앞쪽에 0 digit를 추가하여 패딩하거나, 더 긴 값이 앞쪽에 0 digit를 가지고 있고 더 짧은 결과 값이 허용된다면, 그 0을 제거하십시오:

1mysql> SELECT _binary X'0040' | X'0001';
2+---------------------------+
3| _binary X'0040' | X'0001' |
4+---------------------------+
5|  A                        |
6+---------------------------+
7mysql> SELECT _binary X'40' | X'01';
8+-----------------------+
9| _binary X'40' | X'01' |
10+-----------------------+
11| A                     |
12+-----------------------+

패딩 또는 제거는 LPAD(), RPAD(), SUBSTR(), CAST() 같은 함수를 사용하여 수행할 수도 있습니다. 이러한 경우 표현식 인자는 더 이상 모두 리터럴이 아니므로 _binary는 필요하지 않습니다. 예:

1mysql> SELECT LPAD(X'40', 2, X'00') | X'0001';
2+---------------------------------+
3| LPAD(X'40', 2, X'00') | X'0001' |
4+---------------------------------+
5|  A                              |
6+---------------------------------+
7mysql> SELECT X'40' | SUBSTR(X'0001', 2, 1);
8+-------------------------------+
9| X'40' | SUBSTR(X'0001', 2, 1) |
10+-------------------------------+
11| A                             |
12+-------------------------------+

또한 Special Handling of Hexadecimal Literals, Bit Literals, and NULL Literals을 참조하십시오.

Binary String Bit-Operation Examples

다음 예제는 UUID 값의 일부를 추출하기 위해 비트 연산을 사용하는 방법을 보여줍니다. 이 경우 타임스탬프와 IEEE 802 노드 번호입니다. 이 기법에는 추출되는 각 부분에 대한 비트마스크가 필요합니다.

텍스트 UUID를 이에 해당하는 16바이트 바이너리 값으로 변환하여 바이너리 문자열 컨텍스트에서 비트 연산을 사용해 조작할 수 있도록 합니다:

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

값의 타임스탬프 및 노드 번호 부분에 대한 비트마스크를 구성합니다. 타임스탬프는 처음 세 부분(64비트, 비트 0에서 63까지)으로 구성되며, 노드 번호는 마지막 부분(48비트, 비트 80에서 127까지)입니다:

1mysql> SET @ts_mask = CAST(X'FFFFFFFFFFFFFFFF' AS BINARY(16));
2mysql> SET @node_mask = CAST(X'FFFFFFFFFFFF' AS BINARY(16)) >> 80;
3mysql> SELECT HEX(@ts_mask);
4+----------------------------------+
5| HEX(@ts_mask)                    |
6+----------------------------------+
7| FFFFFFFFFFFFFFFF0000000000000000 |
8+----------------------------------+
9mysql> SELECT HEX(@node_mask);
10+----------------------------------+
11| HEX(@node_mask)                  |
12+----------------------------------+
13| 00000000000000000000FFFFFFFFFFFF |
14+----------------------------------+

여기서는 마스크가 적용 대상인 UUID 값과 동일한 길이를 가져야 하기 때문에 CAST(... AS BINARY(16)) 함수를 사용합니다. 동일한 결과는 마스크를 필요한 길이로 패딩하는 다른 함수를 사용하여 생성할 수 있습니다:

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

마스크를 사용하여 타임스탬프 및 노드 번호 부분을 추출합니다:

1mysql> SELECT HEX(@uuid & @ts_mask) AS 'timestamp part';
2+----------------------------------+
3| timestamp part                   |
4+----------------------------------+
5| 6CCD780CBABA10260000000000000000 |
6+----------------------------------+
7mysql> SELECT HEX(@uuid & @node_mask) AS 'node part';
8+----------------------------------+
9| node part                        |
10+----------------------------------+
11| 000000000000000000005B8C656024DB |
12+----------------------------------+

앞선 예제에서는 다음 비트 연산을 사용합니다: 오른쪽 시프트 (>>) 와 비트 단위 AND (&).

참고

UUID_TO_BIN()은 결과 바이너리 UUID 값에서 일부 비트 재배치를 유발하는 플래그를 가집니다. 이 플래그를 사용하는 경우, 추출 마스크를 그에 맞게 수정하십시오.

다음 예제는 IPv6 주소의 네트워크 부분과 호스트 부분을 추출하기 위해 비트 연산을 사용합니다. 네트워크 부분의 길이가 80비트라고 가정합니다. 그러면 호스트 부분의 길이는 128 − 80 = 48비트가 됩니다. 주소의 네트워크와 호스트 부분을 추출하려면, 먼저 주소를 바이너리 문자열로 변환한 다음 바이너리 문자열 컨텍스트에서 비트 연산을 사용합니다.

텍스트 IPv6 주소를 해당 바이너리 문자열로 변환합니다:

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

비트 단위로 네트워크 길이를 정의합니다:

1mysql> SET @net_len = 80;

모든 1 address를 왼쪽 또는 오른쪽으로 시프트하여 네트워크 및 호스트 마스크를 구성합니다. 이를 위해 :: 주소로 시작하는데, 이는 모든 0의 축약형이며, 다음과 같이 바이너리 문자열로 변환하여 확인할 수 있습니다:

1mysql> SELECT HEX(INET6_ATON('::')) AS 'all zeros';
2+----------------------------------+
3| all zeros                        |
4+----------------------------------+
5| 00000000000000000000000000000000 |
6+----------------------------------+

보수 값(모든 1)을 생성하려면 ~ 연산자를 사용해 비트를 반전합니다:

1mysql> SELECT HEX(~INET6_ATON('::')) AS 'all ones';
2+----------------------------------+
3| all ones                         |
4+----------------------------------+
5| FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF |
6+----------------------------------+

모든 1 값을 왼쪽 또는 오른쪽으로 시프트하여 네트워크 및 호스트 마스크를 생성합니다:

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

마스크가 주소의 올바른 부분을 덮는지 확인하기 위해 마스크를 표시합니다:

1mysql> SELECT INET6_NTOA(@net_mask) AS 'network mask';
2+----------------------------+
3| network mask               |
4+----------------------------+
5| ffff:ffff:ffff:ffff:ffff:: |
6+----------------------------+
7mysql> SELECT INET6_NTOA(@host_mask) AS 'host mask';
8+------------------------+
9| host mask              |
10+------------------------+
11| ::ffff:255.255.255.255 |
12+------------------------+

주소의 네트워크 및 호스트 부분을 추출하고 표시합니다:

1mysql> SET @net_part = @ip & @net_mask;
2mysql> SET @host_part = @ip & @host_mask;
3mysql> SELECT INET6_NTOA(@net_part) AS 'network part';
4+-----------------+
5| network part    |
6+-----------------+
7| fe80::219:0:0:0 |
8+-----------------+
9mysql> SELECT INET6_NTOA(@host_part) AS 'host part';
10+------------------+
11| host part        |
12+------------------+
13| ::d1ff:fe91:1a72 |
14+------------------+

앞선 예제에서는 다음 비트 연산을 사용합니다: 보수 (~), 왼쪽 시프트 (<<), 비트 단위 AND (&).

이후 설명에서는 각 비트 연산 그룹에 대한 인자 처리 세부 사항과 비트 연산에서 리터럴 값 처리를 위한 추가 정보를 제공합니다.

Bitwise AND, OR, and XOR Operations

&, |, ^ 비트 연산의 경우, 결과 타입은 인자가 바이너리 문자열로 평가되는지 숫자로 평가되는지에 따라 달라집니다:

바이너리 문자열 평가는 인자가 바이너리 문자열 타입이고, 그중 적어도 하나가 16진수 리터럴, 비트 리터럴, 또는 NULL 리터럴이 아닐 때 발생합니다. 그렇지 않은 경우 숫자 평가가 발생하며, 필요하다면 인자를 부호 없는 64비트 정수로 변환합니다.
바이너리 문자열 평가는 인자와 같은 길이의 바이너리 문자열을 생성합니다. 인자의 길이가 서로 다르면 ER_INVALID_BITWISE_OPERANDS_SIZE 에러가 발생합니다. 숫자 평가는 부호 없는 64비트 정수를 생성합니다.

숫자 평가 예:

1mysql> SELECT 64 | 1, X'40' | X'01';
2+--------+---------------+
3| 64 | 1 | X'40' | X'01' |
4+--------+---------------+
5|     65 |            65 |
6+--------+---------------+

바이너리 문자열 평가 예:

1mysql> SELECT _binary X'40' | X'01';
2+-----------------------+
3| _binary X'40' | X'01' |
4+-----------------------+
5| A                     |
6+-----------------------+
7mysql> SET @var1 = X'40', @var2 = X'01';
8mysql> SELECT @var1 | @var2;
9+---------------+
10| @var1 | @var2 |
11+---------------+
12| A             |
13+---------------+

Bitwise Complement and Shift Operations

~, <<, >> 비트 연산의 경우, 결과 타입은 비트 인자가 바이너리 문자열로 평가되는지 숫자로 평가되는지에 따라 달라집니다:

바이너리 문자열 평가는 비트 인자가 바이너리 문자열 타입이고, 16진수 리터럴, 비트 리터럴, 또는 NULL 리터럴이 아닐 때 발생합니다. 그렇지 않은 경우 숫자 평가가 발생하며, 필요하다면 인자를 부호 없는 64비트 정수로 변환합니다.
바이너리 문자열 평가는 비트 인자와 같은 길이의 바이너리 문자열을 생성합니다. 숫자 평가는 부호 없는 64비트 정수를 생성합니다.

시프트 연산의 경우, 값의 끝에서 밀려나간 비트는 인자 타입에 관계없이 경고 없이 폐기됩니다. 특히, 시프트 횟수가 비트 인자의 비트 수보다 크거나 같으면, 결과의 모든 비트는 0이 됩니다.

숫자 평가 예:

1mysql> SELECT ~0, 64 << 2, X'40' << 2;
2+----------------------+---------+------------+
3| ~0                   | 64 << 2 | X'40' << 2 |
4+----------------------+---------+------------+
5| 18446744073709551615 |     256 |        256 |
6+----------------------+---------+------------+

바이너리 문자열 평가 예:

1mysql> SELECT HEX(_binary X'1111000022220000' >> 16);
2+----------------------------------------+
3| HEX(_binary X'1111000022220000' >> 16) |
4+----------------------------------------+
5| 0000111100002222                       |
6+----------------------------------------+
7mysql> SELECT HEX(_binary X'1111000022220000' << 16);
8+----------------------------------------+
9| HEX(_binary X'1111000022220000' << 16) |
10+----------------------------------------+
11| 0000222200000000                       |
12+----------------------------------------+
13mysql> SET @var1 = X'F0F0F0F0';
14mysql> SELECT HEX(~@var1);
15+-------------+
16| HEX(~@var1) |
17+-------------+
18| 0F0F0F0F    |
19+-------------+

BIT_COUNT() Operations

BIT_COUNT() 함수는 항상 부호 없는 64비트 정수를 반환하며, 인자가 NULL이면 NULL을 반환합니다.

1mysql> SELECT BIT_COUNT(127);
2+----------------+
3| BIT_COUNT(127) |
4+----------------+
5|              7 |
6+----------------+
7mysql> SELECT BIT_COUNT(b'010101'), BIT_COUNT(_binary b'010101');
8+----------------------+------------------------------+
9| BIT_COUNT(b'010101') | BIT_COUNT(_binary b'010101') |
10+----------------------+------------------------------+
11|                    3 |                            3 |
12+----------------------+------------------------------+

BIT_AND(), BIT_OR(), and BIT_XOR() Operations

BIT_AND(), BIT_OR(), BIT_XOR() 비트 함수의 경우, 결과 타입은 함수 인자 값이 바이너리 문자열로 평가되는지 숫자로 평가되는지에 따라 달라집니다:

바이너리 문자열 평가는 인자 값이 바이너리 문자열 타입이고, 인자가 16진수 리터럴, 비트 리터럴, 또는 NULL 리터럴이 아닐 때 발생합니다. 그렇지 않은 경우 숫자 평가가 발생하며, 필요하다면 인자 값을 부호 없는 64비트 정수로 변환합니다.
바이너리 문자열 평가는 인자 값과 같은 길이의 바이너리 문자열을 생성합니다. 인자 값의 길이가 서로 다르면 ER_INVALID_BITWISE_OPERANDS_SIZE 에러가 발생합니다. 인자 크기가 511바이트를 초과하면 ER_INVALID_BITWISE_AGGREGATE_OPERANDS_SIZE 에러가 발생합니다. 숫자 평가는 부호 없는 64비트 정수를 생성합니다.

NULL 값은 모든 값이 NULL인 경우를 제외하면 결과에 영향을 주지 않습니다. 그 경우 결과는 인자 값의 길이와 동일한 길이의 중립 값으로, 모든 비트가 1인 값은 BIT_AND()에서, 모든 비트가 0인 값은 BIT_OR(), BIT_XOR()에서 사용됩니다.

예:

1mysql> CREATE TABLE t (group_id INT, a VARBINARY(6));
2mysql> INSERT INTO t VALUES (1, NULL);
3mysql> INSERT INTO t VALUES (1, NULL);
4mysql> INSERT INTO t VALUES (2, NULL);
5mysql> INSERT INTO t VALUES (2, X'1234');
6mysql> INSERT INTO t VALUES (2, X'FF34');
7mysql> SELECT HEX(BIT_AND(a)), HEX(BIT_OR(a)), HEX(BIT_XOR(a))
8       FROM t GROUP BY group_id;
9+-----------------+----------------+-----------------+
10| HEX(BIT_AND(a)) | HEX(BIT_OR(a)) | HEX(BIT_XOR(a)) |
11+-----------------+----------------+-----------------+
12| FFFFFFFFFFFF    | 000000000000   | 000000000000    |
13| 1234            | FF34           | ED00            |
14+-----------------+----------------+-----------------+

Special Handling of Hexadecimal Literals, Bit Literals, and NULL Literals

MySQL 9.5는 모든 비트 인자가 16진수 리터럴, 비트 리터럴, 또는 NULL 리터럴인 경우, 비트 연산을 숫자 컨텍스트에서 평가합니다. 즉, 바이너리 문자열 비트 인자에 대한 비트 연산은 모든 비트 인자가 수식되지 않은(unadorned) 16진수 리터럴, 비트 리터럴, 또는 NULL 리터럴인 경우 바이너리 문자열 평가를 사용하지 않습니다. (이는 _binary 인트로듀서, BINARY 연산자, 또는 바이너리 문자열임을 명시적으로 지정하는 다른 방법으로 작성된 리터럴에는 적용되지 않습니다.)

예:

다음 비트 연산은 리터럴을 숫자 컨텍스트에서 평가하며 BIGINT 결과를 생성합니다:

1b'0001' | b'0010'
2X'0008' << 8

다음 비트 연산은 NULL을 숫자 컨텍스트에서 평가하며, NULL 값을 가지는 BIGINT 결과를 생성합니다:

1NULL & NULL
2NULL >> 4

인자 중 적어도 하나가 바이너리 문자열임을 명시하여 이러한 연산이 인자를 바이너리 문자열 컨텍스트에서 평가하도록 할 수 있습니다:

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

마지막 두 표현식의 결과는 BINARY 연산자를 사용하지 않은 경우와 마찬가지로 NULL이지만, 결과의 데이터 타입은 정수 타입이 아니라 바이너리 문자열 타입입니다.