Movatterモバイル変換

Table 14.17 Bit Functions and Operators

• |

  Bitwise OR.

  The result type depends on whether the arguments are evaluated as binary strings or numbers:

  • Binary-string evaluation occurs when the arguments have a binary string type, and at least one of them is not a hexadecimal literal, bit literal, orNULL literal. Numeric evaluation occurs otherwise, with argument conversion to unsigned 64-bit integers as necessary.

  • Binary-string evaluation produces a binary string of the same length as the arguments. If the arguments have unequal lengths, anER_INVALID_BITWISE_OPERANDS_SIZE error occurs. Numeric evaluation produces an unsigned 64-bit integer.

  For more information, see the introductory discussion in this section.

  mysql> SELECT 29 | 15;        -> 31mysql> SELECT _binary X'40404040' | X'01020304';        -> 'ABCD'

  If bitwise OR is invoked from within themysql client, binary string results display using hexadecimal notation, depending on the value of the--binary-as-hex. For more information about that option, seeSection 6.5.1, “mysql — The MySQL Command-Line Client”.

• &

  Bitwise AND.

  The result type depends on whether the arguments are evaluated as binary strings or numbers:

  • Binary-string evaluation occurs when the arguments have a binary string type, and at least one of them is not a hexadecimal literal, bit literal, orNULL literal. Numeric evaluation occurs otherwise, with argument conversion to unsigned 64-bit integers as necessary.

  • Binary-string evaluation produces a binary string of the same length as the arguments. If the arguments have unequal lengths, anER_INVALID_BITWISE_OPERANDS_SIZE error occurs. Numeric evaluation produces an unsigned 64-bit integer.

  For more information, see the introductory discussion in this section.

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

  If bitwise AND is invoked from within themysql client, binary string results display using hexadecimal notation, depending on the value of the--binary-as-hex. For more information about that option, seeSection 6.5.1, “mysql — The MySQL Command-Line Client”.

• ^

  Bitwise XOR.

  The result type depends on whether the arguments are evaluated as binary strings or numbers:

  • Binary-string evaluation occurs when the arguments have a binary string type, and at least one of them is not a hexadecimal literal, bit literal, orNULL literal. Numeric evaluation occurs otherwise, with argument conversion to unsigned 64-bit integers as necessary.

  • Binary-string evaluation produces a binary string of the same length as the arguments. If the arguments have unequal lengths, anER_INVALID_BITWISE_OPERANDS_SIZE error occurs. Numeric evaluation produces an unsigned 64-bit integer.

  For more information, see the introductory discussion in this section.

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

  If bitwise XOR is invoked from within themysql client, binary string results display using hexadecimal notation, depending on the value of the--binary-as-hex. For more information about that option, seeSection 6.5.1, “mysql — The MySQL Command-Line Client”.

• <<

  Shifts a longlong (BIGINT) number or binary string to the left.

  The result type depends on whether the bit argument is evaluated as a binary string or number:

  • Binary-string evaluation occurs when the bit argument has a binary string type, and is not a hexadecimal literal, bit literal, orNULL literal. Numeric evaluation occurs otherwise, with argument conversion to an unsigned 64-bit integer as necessary.

  • Binary-string evaluation produces a binary string of the same length as the bit argument. Numeric evaluation produces an unsigned 64-bit integer.

  Bits shifted off the end of the value are lost without warning, regardless of the argument type. In particular, if the shift count is greater or equal to the number of bits in the bit argument, all bits in the result are 0.

  For more information, see the introductory discussion in this section.

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

  If a bit shift is invoked from within themysql client, binary string results display using hexadecimal notation, depending on the value of the--binary-as-hex. For more information about that option, seeSection 6.5.1, “mysql — The MySQL Command-Line Client”.

• >>

  Shifts a longlong (BIGINT) number or binary string to the right.

  The result type depends on whether the bit argument is evaluated as a binary string or number:

  • Binary-string evaluation occurs when the bit argument has a binary string type, and is not a hexadecimal literal, bit literal, orNULL literal. Numeric evaluation occurs otherwise, with argument conversion to an unsigned 64-bit integer as necessary.

  • Binary-string evaluation produces a binary string of the same length as the bit argument. Numeric evaluation produces an unsigned 64-bit integer.

  Bits shifted off the end of the value are lost without warning, regardless of the argument type. In particular, if the shift count is greater or equal to the number of bits in the bit argument, all bits in the result are 0.

  For more information, see the introductory discussion in this section.

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

  If a bit shift is invoked from within themysql client, binary string results display using hexadecimal notation, depending on the value of the--binary-as-hex. For more information about that option, seeSection 6.5.1, “mysql — The MySQL Command-Line Client”.

• ~

  Invert all bits.

  The result type depends on whether the bit argument is evaluated as a binary string or number:

  • Binary-string evaluation occurs when the bit argument has a binary string type, and is not a hexadecimal literal, bit literal, orNULL literal. Numeric evaluation occurs otherwise, with argument conversion to an unsigned 64-bit integer as necessary.

  • Binary-string evaluation produces a binary string of the same length as the bit argument. Numeric evaluation produces an unsigned 64-bit integer.

  For more information, see the introductory discussion in this section.

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

  If bitwise inversion is invoked from within themysql client, binary string results display using hexadecimal notation, depending on the value of the--binary-as-hex. For more information about that option, seeSection 6.5.1, “mysql — The MySQL Command-Line Client”.

• BIT_COUNT(N)

  Returns the number of bits that are set in the argumentN as an unsigned 64-bit integer, orNULL if the argument isNULL.

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

• Bit Operations Prior to MySQL 8.0

• Bit Operations in MySQL 8.0

• Binary String Bit-Operation Examples

• Bitwise AND, OR, and XOR Operations

• Bitwise Complement and Shift Operations

• BIT_COUNT() Operations

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

• Special Handling of Hexadecimal Literals, Bit Literals, and NULLLiterals

• Bit-Operation Incompatibilities with MySQL 5.7

Bit operations prior to MySQL 8.0 handle only unsigned 64-bit integer argument and result values (that is, unsignedBIGINT values). Conversion of arguments of other types toBIGINT occurs as necessary. Examples:

MySQL 8.0 extends bit operations to handle binary string arguments directly (without conversion) and produce binary string results. (Arguments that are not integers or binary strings are still converted to integers, as before.) This extension enhances bit operations in the following ways:

For example, consider UUID values and IPv6 addresses, which have human-readable text formats like this:

UUID: 6ccd780c-baba-1026-9564-5b8c656024dbIPv6: fe80::219:d1ff:fe91:1a72

It is cumbersome to operate on text strings in those formats. An alternative is convert them to fixed-length binary strings without delimiters.UUID_TO_BIN() andINET6_ATON() each produce a value of data typeBINARY(16), a binary string 16 bytes (128 bits) long. The following statements illustrate this (HEX() is used to produce displayable values):

mysql> SELECT HEX(UUID_TO_BIN('6ccd780c-baba-1026-9564-5b8c656024db'));+----------------------------------------------------------+| HEX(UUID_TO_BIN('6ccd780c-baba-1026-9564-5b8c656024db')) |+----------------------------------------------------------+| 6CCD780CBABA102695645B8C656024DB                         |+----------------------------------------------------------+mysql> SELECT HEX(INET6_ATON('fe80::219:d1ff:fe91:1a72'));+---------------------------------------------+| HEX(INET6_ATON('fe80::219:d1ff:fe91:1a72')) |+---------------------------------------------+| FE800000000000000219D1FFFE911A72            |+---------------------------------------------+

Those binary values are easily manipulable with bit operations to perform actions such as extracting the timestamp from UUID values, or extracting the network and host parts of IPv6 addresses. (For examples, see later in this discussion.)

Arguments that count as binary strings include column values, routine parameters, local variables, and user-defined variables that have a binary string type:BINARY,VARBINARY, or one of theBLOB types.

What about hexadecimal literals and bit literals? Recall that those are binary strings by default in MySQL, but numbers in numeric context. How are they handled for bit operations in MySQL 8.0? Does MySQL continue to evaluate them in numeric context, as is done prior to MySQL 8.0? Or do bit operations evaluate them as binary strings, now that binary strings can be handled“natively” without conversion?

Answer: It has been common to specify arguments to bit operations using hexadecimal literals or bit literals with the intent that they represent numbers, so MySQL continues to evaluate bit operations in numeric context when all bit arguments are hexadecimal or bit literals, for backward compatbility. If you require evaluation as binary strings instead, that is easily accomplished: Use the_binary introducer for at least one literal.

Although the bit operations in both statements produce a result with a numeric value of 65, the second statement operates in binary-string context, for which 65 is ASCIIA.

In numeric evaluation context, permitted values of hexadecimal literal and bit literal arguments have a maximum of 64 bits, as do results. By contrast, in binary-string evaluation context, permitted arguments (and results) can exceed 64 bits:

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

There are several ways to refer to a hexadecimal literal or bit literal in a bit operation to cause binary-string evaluation:

_binaryliteralBINARYliteralCAST(literal AS BINARY)

Another way to produce binary-string evaluation of hexadecimal literals or bit literals is to assign them to user-defined variables, which results in variables that have a binary string type:

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         |+-----------+-----------+

In binary-string context, bitwise operation arguments must have the same length or anER_INVALID_BITWISE_OPERANDS_SIZE error occurs:

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

To satisfy the equal-length requirement, pad the shorter value with leading zero digits or, if the longer value begins with leading zero digits and a shorter result value is acceptable, strip them:

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                     |+-----------------------+

Padding or stripping can also be accomplished using functions such asLPAD(),RPAD(),SUBSTR(), orCAST(). In such cases, the expression arguments are no longer all literals and_binary becomes unnecessary. Examples:

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                             |+-------------------------------+

The following example illustrates use of bit operations to extract parts of a UUID value, in this case, the timestamp and IEEE 802 node number. This technique requires bitmasks for each extracted part.

Convert the text UUID to the corresponding 16-byte binary value so that it can be manipulated using bit operations in binary-string context:

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

Construct bitmasks for the timestamp and node number parts of the value. The timestamp comprises the first three parts (64 bits, bits 0 to 63) and the node number is the last part (48 bits, bits 80 to 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 |+----------------------------------+

TheCAST(... AS BINARY(16)) function is used here because the masks must be the same length as the UUID value against which they are applied. The same result can be produced using other functions to pad the masks to the required length:

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

Use the masks to extract the timestamp and node number parts:

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

The preceding example uses these bit operations: right shift (>>) and bitwise AND (&).

The next example uses bit operations to extract the network and host parts of an IPv6 address. Suppose that the network part has a length of 80 bits. Then the host part has a length of 128 − 80 = 48 bits. To extract the network and host parts of the address, convert it to a binary string, then use bit operations in binary-string context.

Convert the text IPv6 address to the corresponding binary string:

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

Define the network length in bits:

mysql> SET @net_len = 80;

Construct network and host masks by shifting the all-ones address left or right. To do this, begin with the address::, which is shorthand for all zeros, as you can see by converting it to a binary string like this:

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

To produce the complementary value (all ones), use the~ operator to invert the bits:

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

Shift the all-ones value left or right to produce the network and host masks:

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

Display the masks to verify that they cover the correct parts of the address:

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 |+------------------------+

Extract and display the network and host parts of the address:

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 |+------------------+

The preceding example uses these bit operations: Complement (~), left shift (<<), and bitwise AND (&).

The remaining discussion provides details on argument handling for each group of bit operations, more information about literal-value handling in bit operations, and potential incompatibilities between MySQL 8.0 and older MySQL versions.

For&,|, and^ bit operations, the result type depends on whether the arguments are evaluated as binary strings or numbers:

Examples of numeric evaluation:

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

Examples of binary-string evaluation:

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             |+---------------+

For~,<<, and>> bit operations, the result type depends on whether the bit argument is evaluated as a binary string or number:

For shift operations, bits shifted off the end of the value are lost without warning, regardless of the argument type. In particular, if the shift count is greater or equal to the number of bits in the bit argument, all bits in the result are 0.

Examples of numeric evaluation:

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

Examples of binary-string evaluation:

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    |+-------------+

TheBIT_COUNT() function always returns an unsigned 64-bit integer, orNULL if the argument isNULL.

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 |+----------------------+------------------------------+

For theBIT_AND(),BIT_OR(), andBIT_XOR() bit functions, the result type depends on whether the function argument values are evaluated as binary strings or numbers:

NULL values do not affect the result unless all values areNULL. In that case, the result is a neutral value having the same length as the length of the argument values (all bits 1 forBIT_AND(), all bits 0 forBIT_OR(), andBIT_XOR()).

Example:

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            |+-----------------+----------------+-----------------+

For backward compatibility, MySQL 8.0 evaluates bit operations in numeric context when all bit arguments are hexadecimal literals, bit literals, orNULL literals. That is, bit operations on binary-string bit arguments do not use binary-string evaluation if all bit arguments are unadorned hexadecimal literals, bit literals, orNULL literals. (This does not apply to such literals if they are written with a_binary introducer,BINARY operator, or other way of specifying them explicitly as binary strings.)

The literal handling just described is the same as prior to MySQL 8.0. Examples:

In MySQL 8.0, you can cause those operations to evaluate the arguments in binary-string context by indicating explicitly that at least one argument is a binary string:

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

The result of the last two expressions isNULL, just as without theBINARY operator, but the data type of the result is a binary string type rather than an integer type.

Because bit operations can handle binary string arguments natively in MySQL 8.0, some expressions produce a different result in MySQL 8.0 than in 5.7. The five problematic expression types to watch out for are:

nonliteral_binary { & | ^ }binarybinary  { & | ^ }nonliteral_binarynonliteral_binary { << >> }anything~nonliteral_binaryAGGR_BIT_FUNC(nonliteral_binary)

Those expressions returnBIGINT in MySQL 5.7, binary string in 8.0.

Explanation of notation:

For information about how to prepare in MySQL 5.7 for potential incompatibilities between MySQL 5.7 and 8.0, seeBit Functions and Operators, inMySQL 5.7 Reference Manual.