MySQL运算符

2020-04-19

字数统计: 6.2k | 阅读时长≈ 27 分钟

MySQL 所提供的运算符可以直接对表中数据或字段进行运算，进而实现用户的新需求，增强了 MySQL 的功能。

MySQL 支持 4 种运算符：

算术运算符：加、减、乘、除和取余运算。
比较运算符：包括大于、小于、等于或不等于、等等。主要用于数值的比较、字符串的匹配等方面。
逻辑运算符：包括与、或、非和异或、等逻辑运算符。其返回值为布尔型，真值（1 或true）和假值（0 或false）。
位运算符：包括按位与、按位或、按位取反、按位异或、按位左移和按位右移等位运算符。位运算必须先将数据转换为补码，然后在根据数据的补码进行操作。运算完成后，将得到的值转换为原来的类型（十进制数），返回给用户。

算术运算符

运算符	作用	使用方法
+	加法运算	用于获得一个或多个值的和
-	减法运算	用于从一个值中减去另一个值
*	乘法运算	使数字相乘，得到两个或多个值的乘积
/	除法运算，返回商	用一个值除以另一个值得到商
%，MOD	求余运算，返回余数	用一个值除以另一个值得到余数

CREATE TABLE temp(num INT);
INSERT INTO temp VALUE (64);

mysql> SELECT num, num+10, num-3+5, num+36.5 FROM temp;
+------+--------+---------+----------+
| num  | num+10 | num-3+5 | num+36.5 |
+------+--------+---------+----------+
|   64 |     74 |      66 |    100.5 |
+------+--------+---------+----------+
1 row in set (0.01 sec)

mysql> SELECT num, num*2, num/2, num/3, num%3 FROM temp;
+------+-------+---------+---------+-------+
| num  | num*2 | num/2   | num/3   | num%3 |
+------+-------+---------+---------+-------+
|   64 |   128 | 32.0000 | 21.3333 |     1 |
+------+-------+---------+---------+-------+
1 row in set (0.00 sec)

由上面计算结果可以看出，对num进行除法运算时，由于 64 无法被 3 整除，因此 MySQL 对num/3求商的结果保存到了小数点后面四位，结果为 21.3333；64 除以 3 的余数为 1，因此取余运算num%3的结果为 1。

对于取余运算，还可以使用MOD(a, b)函数，MOD(a, b)相当于a%b：

mysql> SELECT MOD(num,3) FROM temp;
+-------------+
| MOD(num,3) |
+-------------+
|           1 |
+-------------+
1 row in set (0.00 sec)

数学运算中，除数为 0 的除法是没有意义的。所以在除法运算和取余运算中，如果除数为 0，那么返回结果为NULL。

mysql> SELECT num, num/0, num%0 FROM temp;
+------+-------+-------+
| num  | num/0 | num%0 |
+------+-------+-------+
|   64 |  NULL |  NULL |
+------+-------+-------+
1 row in set (0.00 sec)

逻辑运算符

逻辑运算符又称为布尔运算符，用来确定表达式的真和假。

运算符	作用
NOT 或者 !	逻辑非
AND 或者 &&	逻辑与
OR 和 `\|\|`	逻辑或
XOR	逻辑异或

逻辑非运算（NOT 或者 !）

NOT和!都是逻辑非运算符，返回和操作数相反的结果：

当操作数为 0（假）时，返回值为 1；
当操作数为非零值时，返回值为 0；
当操作数为NULL时，返回值为NULL。

mysql> SELECT NOT 10, NOT(1-1), NOT-5, NOT NULL, NOT 1+1;
+--------+----------+-------+----------+---------+
| NOT 10 | NOT(1-1) | NOT-5 | NOT NULL | NOT 1+1 |
+--------+----------+-------+----------+---------+
|      0 |        1 |     0 |     NULL |       0 |
+--------+----------+-------+----------+---------+
1 row in set (0.00 sec)

mysql> SELECT !10, !(1-1), !-5, !NULL, !1+1;
+-----+--------+-----+-------+------+
| !10 | !(1-1) | !-5 | !NULL | !1+1 |
+-----+--------+-----+-------+------+
|   0 |      1 |   0 |  NULL |    1 |
+-----+--------+-----+-------+------+
1 row in set (0.00 sec)

mysql> SELECT !1+1;
+------+
| !1+1 |
+------+
|    1 |
+------+
1 row in set (0.00 sec)

由运行结果可以看出，NOT 1+1和!1+1的返回值不同，这是因为NOT与!的优先级不同：

NOT的优先级低于+，因此NOT 1+1相当于NOT(1+1)，先计算1+1，然后再进行NOT运算，由于操作数不为 0，因此NOT 1+1的结果是 0；
相反，!的优先级别要高于+，因此! 1+1相当于(!1)+1，先计算!1结果为 0，再加 1，最后结果为 1。

在使用运算符运算时，一定要注意运算符的优先级，如果不能确定计算顺序，最好使用括号，以保证运算结果的正确。

逻辑与运算符（AND 或者 &&）

AND和&&都是逻辑与运算符：

当所有操作数都为非零值并且不为NULL时，返回值为 1；
当一个或多个操作数为 0 时，返回值为 0；
操作数中有任何一个为NULL时，返回值为NULL。

mysql> SELECT 1 AND -1, 1 AND 0, 1 AND NULL, 0 AND NULL;
+----------+---------+------------+------------+
| 1 AND -1 | 1 AND 0 | 1 AND NULL | 0 AND NULL |
+----------+---------+------------+------------+
|        1 |       0 |       NULL |          0 |
+----------+---------+------------+------------+
1 row in set (0.00 sec)

mysql> SELECT 1 && -1, 1&&0, 1&&NULL, 0&&NULL;
+---------+------+---------+---------+
| 1 && -1 | 1&&0 | 1&&NULL | 0&&NULL |
+---------+------+---------+---------+
|       1 |    0 |    NULL |       0 |
+---------+------+---------+---------+
1 row in set (0.00 sec)

由结果可以看到，AND和&&的作用相同。1 AND -1中没有 0 或者NULL，所以返回值为 1；1 AND 0中有操作数 0，所以返回值为 0；1 AND NULL有NULL，所以返回值为NULL。

注意：AND运算符可以有多个操作数，但要注意多个操作数运算时，AND两边一定要使用空格隔开，不然会影响结果的正确性。

逻辑或运算符（OR 或者 ||）

OR和||都是逻辑或运算符：

当两个操作数都为非NULL值时，如果有任意一个操作数为非零值，则返回值为 1，否则结果为 0；
当有一个操作数为NULL时，如果另一个操作数为非零值，则返回值为 1，否则结果为NULL；
假如两个操作数均为NULL时，则返回值为NULL。

mysql> SELECT 1 OR -1 OR 0,1 OR 2,1 OR NULL, 0 OR NULL, NULL OR NULL;
+--------------+--------+-----------+-----------+--------------+
| 1 OR -1 OR 0 | 1 OR 2 | 1 OR NULL | 0 OR NULL | NULL OR NULL |
+--------------+--------+-----------+-----------+--------------+
|            1 |      1 |         1 |      NULL |         NULL |
+--------------+--------+-----------+-----------+--------------+
1 row in set (0.00 sec)

mysql> SELECT 1 || -1 || 0, 1||2, 1||NULL, 0||NULL, NULL||NULL;
+--------------+------+---------+---------+------------+
| 1 || -1 || 0 | 1||2 | 1||NULL | 0||NULL | NULL||NULL |
+--------------+------+---------+---------+------------+
|            1 |    1 |       1 |    NULL |       NULL |
+--------------+------+---------+---------+------------+
1 row in set (0.00 sec)

由结果可以看到，OR和||的作用相同。下面是对各个结果的解析：

1 OR -1 OR 0含有 0，但同时包含有非 0 的值 1 和 -1，所以返回结果为 1；
1 OR 2中没有操作数 0，所以返回结果为 1；
1 OR NULL虽然有NULL，但是有操作数 1，所以返回结果为 1；
0 OR NULL中没有非 0 值，并且有NULL，所以返回值为NULL；
NULL OR NULL中只有NULL，所以返回值为NULL。

异或运算（XOR 运算符）

XOR表示逻辑异或：

当任意一个操作数为NULL时，返回值为NULL；
对于非NULL的操作数，如果两个操作数都是非 0 值或者都是 0 值，则返回值为 0；
如果一个为 0 值，另一个为非 0 值，返回值为 1。

mysql> SELECT 1 XOR 1, 0 XOR 0, 1 XOR 0, 1 XOR NULL, 1 XOR 1 XOR 1;
+---------+---------+---------+------------+---------------+
| 1 XOR 1 | 0 XOR 0 | 1 XOR 0 | 1 XOR NULL | 1 XOR 1 XOR 1 |
+---------+---------+---------+------------+---------------+
|       0 |       0 |       1 |       NULL |             1 |
+---------+---------+---------+------------+---------------+
1 row in set (0.00 sec)

由结果可以看到：

1 XOR 1和0 XOR 0中运算符两边的操作数都为非零值，或者都是零值，因此返回 0；
1 XOR 0中两边的操作数，一个为 0 值，另一个为非 0 值，所以返回值为 1；
1 XOR NULL中有一个操作数为NULL，所以返回值为NULL；
1 XOR 1 XOR 1中有多个操作数，运算符相同，因此运算顺序从左到右依次计算，1 XOR 1的结果为 0，再与 1 进行异或运算，所以返回值为 1。

提示：a XOR b的计算等同于(a AND (NOT b))或者((NOT a) AND b)。

比较运算符

当使用SELECT语句进行查询时，MySQL 允许用户对表达式的左边操作数和右边操作数进行比较，比较结果为真，则返回 1，为假则返回 0，比较结果不确定则返回NULL。

运算符	作用
=	等于
<=>	安全的等于
<> 或者 !=	不等于
<=	小于等于
<	小于
>=	大于等于
>	大于
IS NULL 或者 ISNULL	判断一个值是否为空
IS NOT NULL	判断一个值是否不为空
BETWEEN AND	判断一个值是否落在两个值之间

比较运算符可以用于比较数字、字符串和表达式的值。注意，字符串的比较是不区分大小写的。

等于运算（=）

=运算符用来比较两边的操作数是否相等，相等的话返回 1，不相等的话返回 0：

若有一个或两个操作数为NULL，则比较运算的结果为NULL。
若两个操作数都是字符串，则按照字符串进行比较。
若两个操作数均为整数，则按照整数进行比较。
若一个操作数为字符串，另一个操作数为数字，则 MySQL 可以自动将字符串转换为数字。

注意：NULL不能用于=比较。如果字符串转换数值不成功则转成 0。

mysql> SELECT 1=0, '2'=2, 2=2, '0.02'=0, 'b'='b', (1+3)=(2+2), NULL=NULL;
+-----+-------+-----+----------+---------+-------------+-----------+
| 1=0 | '2'=2 | 2=2 | '0.02'=0 | 'b'='b' | (1+3)=(2+2) | NULL=NULL |
+-----+-------+-----+----------+---------+-------------+-----------+
|   0 |     1 |   1 |        0 |       1 |           1 |      NULL |
+-----+-------+-----+----------+---------+-------------+-----------+
1 row in set (0.01 sec)

安全等于运算符（<=>）

<=>操作符和=操作符类似，不过<=>可以用来判断NULL值：

当两个操作数均为NULL时，其返回值为 1 而不为NULL；
而当一个操作数为NULL时，其返回值为 0 而不为NULL。

mysql> SELECT 1<=>0,'2'<=>2, 2<=>2, '0.02'<=>0, 'b'<=>'b', (1+3) <=> (2+1), NULL<=>NULL;
+-------+---------+-------+------------+-----------+-----------------+-------------+
| 1<=>0 | '2'<=>2 | 2<=>2 | '0.02'<=>0 | 'b'<=>'b' | (1+3) <=> (2+1) | NULL<=>NULL |
+-------+---------+-------+------------+-----------+-----------------+-------------+
|     0 |       1 |     1 |          0 |         1 |               0 |           1 |
+-------+---------+-------+------------+-----------+-----------------+-------------+
1 row in set (0.00 sec)

由结果可以看到，<=>在执行比较操作时和=的作用是相似的，唯一的区别是<=>可以用来对NULL进行判断，两者都为NULL时返回值为 1。

不等于运算符（<> 或者 !=）

与=的作用相反，<>和!=用于判断数字、字符串、表达式是否不相等。对于<>和!=，如果两侧操作数不相等，返回值为 1，否则返回值为 0；如果两侧操作数有一个是NULL，那么返回值也是NULL。

mysql> SELECT 'good'<>'god', 1<>2, 4!=4, 5.5!=5, (1+3)!=(2+1), NULL<>NULL;
+---------------+------+------+--------+--------------+------------+
| 'good'<>'god' | 1<>2 | 4!=4 | 5.5!=5 | (1+3)!=(2+1) | NULL<>NULL |
+---------------+------+------+--------+--------------+------------+
|             1 |    1 |    0 |      1 |            1 |       NULL |
+---------------+------+------+--------+--------------+------------+
1 row in set (0.00 sec)

由结果可以看到，两个不等于运算符作用相同，都可以进行数字、字符串、表达式的比较判断。

小于等于运算符（<=）

<=是小于等于运算符，用来判断左边的操作数是否小于或者等于右边的操作数；如果小于或者等于，返回值为 1，否则返回值为 0；如果两侧操作数有一个是NULL，那么返回值也是NULL。

mysql> SELECT 'good'<='god', 1<=2, 4<=4, 5.5<=5, (1+3)<=(2+1), NULL<=NULL;
+---------------+------+------+--------+--------------+------------+
| 'good'<='god' | 1<=2 | 4<=4 | 5.5<=5 | (1+3)<=(2+1) | NULL<=NULL |
+---------------+------+------+--------+--------------+------------+
|             0 |    1 |    1 |      0 |            0 |       NULL |
+---------------+------+------+--------+--------------+------------+
1 row in set (0.00 sec)

小于运算符（<）

<是小于运算符，用来判断左边的操作数是否小于右边的操作数；如果小于，返回值为 1，否则返回值为 0；如果两侧操作数有一个是NULL，那么返回值也是NULL。

mysql> SELECT 'good'<'god', 1<2, 4<4, 5.5<5, (1+3)<(2+1), NULL<NULL；
+--------------+-----+-----+-------+-------------+-----------+
| 'good'<'god' | 1<2 | 4<4 | 5.5<5 | (1+3)<(2+1) | NULL<NULL |
+--------------+-----+-----+-------+-------------+-----------+
|            0 |   1 |   0 |     0 |           0 |      NULL |
+--------------+-----+-----+-------+-------------+-----------+
1 row in set (0.02 sec)

大于等于运算符（>=）

>=是大于等于运算符，用来判断左边的操作数是否大于或者等于右边的操作数；如果大于或者等于，返回值为 1，否则返回值为 0；如果两侧操作数有一个是NULL，那么返回值也是NULL。

mysql> SELECT 'good'>='god', 1>=2, 4>=4, 5.5>=5, (1+3)>=(2+1), NULL>=NULL；
+---------------+------+------+--------+--------------+------------+
| 'good'>='god' | 1>=2 | 4>=4 | 5.5>=5 | (1+3)>=(2+1) | NULL>=NULL |
+---------------+------+------+--------+--------------+------------+
|             1 |    0 |    1 |      1 |            1 |       NULL |
+---------------+------+------+--------+--------------+------------+
1 row in set (0.00 sec)

大于运算符（>）

>是大于运算符，用来判断左边的操作数是否大于右边的操作数；如果大于，返回值为 1，否则返回值为 0；如果两侧操作数有一个是NULL，那么返回值也是NULL。

mysql> SELECT 'good'>'god', 1>2, 4>4, 5.5>5, (1+3)>(2+1), NULL>NULL；
+--------------+-----+-----+-------+-------------+-----------+
| 'good'>'god' | 1>2 | 4>4 | 5.5>5 | (1+3)>(2+1) | NULL>NULL |
+--------------+-----+-----+-------+-------------+-----------+
|            1 |   0 |   0 |     1 |           1 |      NULL |
+--------------+-----+-----+-------+-------------+-----------+
1 row in set (0.00 sec)

IS NULL(ISNULL) 和 IS NOT NULL 运算符

IS NULL或ISNULL运算符用来检测一个值是否为NULL，如果为NULL，返回值为 1，否则返回值为 0。ISNULL可以认为是IS NULL的简写，去掉了一个空格而已，两者的作用和用法都是完全相同的。

IS NOT NULL运算符用来检测一个值是否为非NULL，如果是非NULL，返回值为 1，否则返回值为 0。

mysql> SELECT NULL IS NULL, ISNULL(NULL), ISNULL(10), 10 IS NOT NULL;
+--------------+--------------+------------+----------------+
| NULL IS NULL | ISNULL(NULL) | ISNULL(10) | 10 IS NOT NULL |
+--------------+--------------+------------+----------------+
|            1 |            1 |          0 |              1 |
+--------------+--------------+------------+----------------+
1 row in set (0.01 sec)

由结果可以看到，IS NULL和ISNULL的作用相同，只是写法略有不同。ISNULL和IS NOT NULL的返回值正好相反。

BETWEEN AND 运算符

BETWEEN AND运算符用来判断表达式的值是否位于两个数之间，或者说是否位于某个范围内。

1	expr BETWEEN min AND max

expr表示要判断的表达式，min表示最小值，max表示最大值。如果expr大于等于min并且小于等于max，那么返回值为 1，否则返回值为 0。

mysql> SELECT 4 BETWEEN 2 AND 5, 4 BETWEEN 4 AND 6, 12 BETWEEN 9 AND 10;
+-------------------+-------------------+---------------------+
| 4 BETWEEN 2 AND 5 | 4 BETWEEN 4 AND 6 | 12 BETWEEN 9 AND 10 |
+-------------------+-------------------+---------------------+
|                 1 |                 1 |                   0 |
+-------------------+-------------------+---------------------+
1 row in set (0.00 sec)

对于字符串类型的比较，按字母表中字母顺序进行比较，x不在指定的字母区间内，因此返回值为 0，而b位于指定字母区间内，因此返回值为 1。

使用比较运算符时需要注意空值NULL，大部分比较运算符遇到NULL时也会返回NULL。

位运算符

所谓位运算，就是按照内存中的比特位（Bit）进行操作，这是计算机能够支持的最小单位的运算。程序中所有的数据在内存中都是以二进制形式存储的，位运算就是对这些二进制数据进行操作。

位运算一般用于操作整数，对整数进行位运算才有实际的意义。整数在内存中是以补码形式存储的，正数的补码形式和原码形式相同，而负数的补码形式和它的原码形式是不一样的，这一点大家要特别注意；这意味着，对负数进行位运算时，操作的是它的补码，而不是它的原码。

MySQL 中的整数字面量（常量整数，也就是直接书写出来的整数）默认以 8 个字节（Byte）来表示，也就是 64 位（Bit）。例如，5 的二进制形式为：0000 0000 ... 0000 0101

省略号部分都是 0，101 前面总共有 61 个 0。

MySQL 中的位运算符：

运算符	说明使用形式	举例
`	`	位或 a
&	位与 a & b	5 & 8
^	位异或 a ^ b	5 ^ 8
~	位取反 ~a	~5
<<	位左移 a << b	5 << 2，表示整数 5 按位左移 2 位
>>	位右移 a >> b	5 >> 2，表示整数 5 按位右移 2 位

位运算中的&、|、~和逻辑运算中的&&、||、!非常相似。

位或运算符 |

参与|运算的两个二进制位有一个为 1 时，结果就为 1，两个都为 0 时结果才为 0。例如1|1结果为 1，0|0结果为0，1|0结果为1，这和逻辑运算中的||非常类似。

mysql> SELECT 10|15, 9|4|2;
+-------+-------+
| 10|15 | 9|4|2 |
+-------+-------+
|    15 |    15 |
+-------+-------+
1 row in set (0.00 sec)

10 的补码为 1010，15 的补码为 1111，按位或运算之后，结果为 1111，即整数 15；9 的补码为 1001，4 的补码为 0100，2 的补码为 0010，按位或运算之后，结果为 111，即整数 15。

mysql> SELECT -7|-1;
+----------------------+
| -7|-1                |
+----------------------+
| 18446744073709551615 |
+----------------------+
1 row in set (0.00 sec)

-7 的补码为 60 个 1 加 1001，-1 的补码为 64 个 1，按位或运算之后，结果为 64 个 1，即整数18446744073709551615。

可以发现，任何数和 -1 进行位或运算时，最终结果都是 -1 的十进制数。

位与运算符 &

参与&运算的两个二进制位都为 1 时，结果就为 1，否则为 0。例如1&1结果为 1，0&0结果为 0，1&0结果为 0，这和逻辑运算中的&&非常类似。

mysql> SELECT 10 & 15, 9 & 4 & 2;
+---------+-----------+
| 10 & 15 | 9 & 4 & 2 |
+---------+-----------+
|      10 |         0 |
+---------+-----------+
1 row in set (0.00 sec)

10 的补码为 1010，15 的补码为 1111，按位与运算之后，结果为 1010，即整数 10；9 的补码为 1001，4 的补码为 0100，2 的补码为 0010，按位与运算之后，结果为 0000，即整数 0。

mysql> SELECT -7&-1;
+----------------------+
| -7&-1                |
+----------------------+
| 18446744073709551609 |
+----------------------+
1 row in set (0.01 sec)

-7 的补码为 60 个 1 加 1001，-1 的补码为 64 个 1，按位与运算之后，结果为 60 个 1 加 1001，即整数18446744073709551609。

可以发现，任何数和 -1 进行位与运算时，最终结果都为任何数本身的十进制数。

位异或运算符 ^

参与^运算的两个二进制位不同时，结果为 1，相同时，结果为 0。例如1^1结果为 0，0^0结果为 0，1^0结果为 1。

mysql> SELECT 10^15, 1^0, 1^1;
+-------+-----+-----+
| 10^15 | 1^0 | 1^1 |
+-------+-----+-----+
|     5 |   1 |   0 |
+-------+-----+-----+
1 row in set (0.00 sec)

10 的补码为 1010，15 的补码为 111，按位异或运算之后，结果为 0101，即整数 5；1 的补码为 0001，0 的补码为 0000，按位异或运算之后，结果为 0001；1 和 1 本身二进制位完全相同，因此结果为 0。

mysql> SELECT -7^-1;
+-------+
| -7^-1 |
+-------+
|     6 |
+-------+
1 row in set (0.00 sec)

-7 的补码为 60 个 1 加 1001，-1 的补码为 64 个 1，按位异或运算之后，结果为 110，即整数 6。

位左移运算符 <<

位左移是按指定值的补码形式进行左移，左移指定位数之后，左边高位的数值被移出并丢弃，右边低位空出的位置用 0 补齐。

expr << n

其中，n指定值expr要移位的位数，n必须为非负数。

mysql> SELECT 1<<2, 4<<2;
+------+------+
| 1<<2 | 4<<2 |
+------+------+
|    4 |   16 |
+------+------+
1 row in set (0.00 sec)

1 的补码为 0000 0001，左移两位之后变成 0000 0100，即整数 4；4 的补码为 0000 0100，左移两位之后变成 0001 0000，即整数 16。

mysql> SELECT -7<<2;
+----------------------+
| -7<<2                |
+----------------------+
| 18446744073709551588 |
+----------------------+
1 row in set (0.00 sec)

-7 的补码为 60 个 1 加 1001，左移两位之后变成 56 个 1 加 1110 0100，即整数18446744073709551588。

位右移运算符 >>

位右移是按指定值的补码形式进行右移，右移指定位数之后，右边低位的数值被移出并丢弃，左边高位空出的位置用 0 补齐。

expr >> n

其中，n指定值expr要移位的位数，n必须为非负数。

mysql> SELECT 1>>1, 16>>2;
+------+-------+
| 1>>1 | 16>>2 |
+------+-------+
|    0 |     4 |
+------+-------+
1 row in set (0.00 sec)

1 的补码为 0000 0001，右移 1 位之后变成 0000 0000，即整数 0；16 的补码为 0001 0000，右移两位之后变成 0000 0100，即整数 4。

mysql> SELECT -7>>2;
+---------------------+
| -7>>2               |
+---------------------+
| 4611686018427387902 |
+---------------------+
1 row in set (0.00 sec)

-7 的补码为 60 个 1 加 1001，右移两位之后变成 0011 加 56 个 1 加 1110，即整数4611686018427387902。

位取反运算符 ~

位取反是将参与运算的数据按对应的补码进行反转，也就是做NOT操作，即 1 取反后变 0，0 取反后变为 1。

mysql> SELECT ~1, ~18446744073709551614;
+----------------------+-----------------------+
| ~1                   | ~18446744073709551614 |
+----------------------+-----------------------+
| 18446744073709551614 |                     1 |
+----------------------+-----------------------+
1 row in set (0.00 sec)

常量 1 的补码为 63 个 0 加 1 个 1，位取反后就是 63 个 1 加一个 0，转换为二进制后就是18446744073709551614。

可以使用BIN()函数查看 1 取反之后的结果，BIN()函数的作用是将一个十进制数转换为二进制数:

mysql> SELECT BIN(~1);
+------------------------------------------------------------------+
| BIN(~1)                                                          |
+------------------------------------------------------------------+
| 1111111111111111111111111111111111111111111111111111111111111110 |
+------------------------------------------------------------------+
1 row in set (0.01 sec)

1 的补码表示为最右边位为 1，其他位均为 0，取反操作之后，除了最低位，其他位均变为 1。

mysql> SELECT 5 & ~1;
+--------+
| 5 & ~1 |
+--------+
|      4 |
+--------+
1 row in set (0.00 sec)

逻辑运算5&~1中，由于位取反运算符~的级别高于位与运算符&，因此先对 1 进行取反操作，结果为 63 个 1 加一个 0，然后再与整数 5 进行与运算，结果为 0100，即整数 4。

运算符的优先级

运算符的优先级决定了不同的运算符在表达式中计算的先后顺序，下表列出了 MySQL 中的各类运算符及其优先级。

优先级由低到高排列	运算符
1	=(赋值运算)、:=
2	II、OR
3	XOR
4	&&、AND
5	NOT
6	BETWEEN、CASE、WHEN、THEN、ELSE
7	=(比较运算)、<=>、>=、>、<=、<、<>、!=、 IS、LIKE、REGEXP、IN
8
9	&
10	<<、>>
11	-(减号)、+
12	*、/、%
13	^
14	-(负号)、〜（位反转）
15	!

可以看出，不同运算符的优先级是不同的。一般情况下，级别高的运算符优先进行计算，如果级别相同，MySQL 按表达式的顺序从左到右依次计算。

另外，在无法确定优先级的情况下，可以使用圆括号()来改变优先级，并且这样会使计算过程更加清晰。

IN和NOT IN用法

MySQL 中的IN运算符用来判断表达式的值是否位于给出的列表中；如果是，返回值为 1，否则返回值为 0。

NOT IN的作用和IN恰好相反，NOT IN用来判断表达式的值是否不存在于给出的列表中；如果不是，返回值为 1，否则返回值为 0。

1 2	expr IN ( value1, value2, value3 ... valueN ) expr NOT IN ( value1, value2, value3 ... valueN )

expr表示要判断的表达式，value1, value2, value3 ... valueN表示列表中的值。MySQL 会将expr的值和列表中的值逐一对比。

mysql> SELECT 2 IN (1,3,5,'thks'), 'thks' IN (1,3,5, 'thks');
+---------------------+---------------------------+
| 2 IN (1,3,5,'thks') | 'thks' IN (1,3,5, 'thks') |
+---------------------+---------------------------+
|                   0 |                         1 |
+---------------------+---------------------------+
1 row in set, 2 warnings (0.00 sec)

mysql> SELECT 2 NOT IN (1,3,5,'thks'), 'thks' NOT IN (1,3,5, 'thks');
+-------------------------+-------------------------------+
| 2 NOT IN (1,3,5,'thks') | 'thks' NOT IN (1,3,5, 'thks') |
+-------------------------+-------------------------------+
|                       1 |                             0 |
+-------------------------+-------------------------------+
1 row in set, 2 warnings (0.00 sec)

由结果可以看到，IN和NOT IN的返回值正好相反。

对空值 NULL 的处理

当IN运算符的两侧有一个为空值NULL时，如果找不到匹配项，则返回值为NULL；如果找到了匹配项，则返回值为 1。

mysql> SELECT NULL IN (1,3,5,'thks'), 10 IN (1,3,NULL,'thks');
+------------------------+-------------------------+
| NULL IN (1,3,5,'thks') | 10 IN (1,3,NULL,'thks') |
+------------------------+-------------------------+
|                   NULL |                    NULL |
+------------------------+-------------------------+
1 row in set, 1 warning (0.00 sec)

mysql>  SELECT NULL IN (1,3,5,'thks'), 10 IN (1,10,NULL,'thks');
+------------------------+--------------------------+
| NULL IN (1,3,5,'thks') | 10 IN (1,10,NULL,'thks') |
+------------------------+--------------------------+
|                   NULL |                        1 |
+------------------------+--------------------------+
1 row in set (0.00 sec)

NOT IN恰好相反，当NOT IN运算符的两侧有一个为空值NULL时，如果找不到匹配项，则返回值为NULL；如果找到了匹配项，则返回值为 0。

mysql>  SELECT NULL NOT IN (1,3,5,'thks'), 10 NOT IN (1,0,NULL,'thks');
+----------------------------+-----------------------------+
| NULL NOT IN (1,3,5,'thks') | 10 NOT IN (1,0,NULL,'thks') |
+----------------------------+-----------------------------+
|                       NULL |                        NULL |
+----------------------------+-----------------------------+
1 row in set, 1 warning (0.00 sec)

mysql>  SELECT NULL NOT IN (1,3,5,'thks'), 10 NOT IN (1,10,NULL,'thks');
+----------------------------+------------------------------+
| NULL NOT IN (1,3,5,'thks') | 10 NOT IN (1,10,NULL,'thks') |
+----------------------------+------------------------------+
|                       NULL |                            0 |
+----------------------------+------------------------------+
1 row in set (0.00 sec)

打赏