MySQL 中的运算符(关系型数据库)

1、算数运算符

  • MySQL 支持的算术运算符包括加、减、乘、除和模运算。
运算符 作用
+ 加法,获得一个或多个值的和
- 减法,从一个值中减去另一个值
* 乘法,得到两个或多个值的乘积
/,div 商运算,用一个值除以另一个值得到商
%,mod 模运算,用一个值除以另外一个值得到余数
  • 1)在除法运算和模运算中,如果除数为 0,将是非法除数,返回结果为 NULL。

    1
    2
    3
    4
    5
    6
    7
    8
    > select 1/0, 100%0;

    +------+-------+
    | 1/0 | 100%0 |
    +------+-------+
    | NULL | NULL |
    +------+-------+
    1 row in set, 2 warnings (0.00 sec)
  • 2)对于除法运算,还有另一种表达方式,使用 a div b 函数,从除法结果中舍弃小数点右侧的小数部分。

    1
    2
    3
    4
    5
    6
    7
    8
    > select 5/2, 5 div 2;

    +--------+---------+
    | 5/2 | 5 div 2 |
    +--------+---------+
    | 2.5000 | 2 |
    +--------+---------+
    1 row in set (0.00 sec)
  • 3)对于模运算,还有另一种表达方式,使用 mod(a,b) 函数与 a%b 效果一样。

    1
    2
    3
    4
    5
    6
    7
    8
    > select 5%2, mod(5, 2);

    +------+-----------+
    | 5%2 | mod(5, 2) |
    +------+-----------+
    | 1 | 1 |
    +------+-----------+
    1 row in set (0.00 sec)

2、比较运算符

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

  • 比较运算符可以用于比较数字、字符串和表达式。数字作为浮点数比较,而字符串以不区分大小写的方式进行比较。

运算符 作用
= 等于,用于比较运算符两侧的操作数是否相等,相等返回 1,否则为 0,null 不能用 “=” 比较
<>、!= 不等于,和 “=” 相反,不等返回 1,否则为 0,null 不能用 “<>” 比较
<=> null 安全的等于 (null-safe),和 “=” 类似,相等返回 1,可以比较 null
< 小于
<= 小于等于
> 大于
>= 大于等于
between 存在于指定范围,a BETWEEN min AND max,当 a 大于等于 min 并且小于等于 max,则返回值为 1,否则返回0;操作数 a、min、max 类型相同时,此表达式等价于(a >= min and a <= max),当操作数类型不同时,比较时会遵循类型转换原则进行转换后,再进行比较运算
in 存在于指定集合,a IN (value1, value2, …),当 a 的值存在于列表中时,则整个比较表达式返回的值为 1,否则返回 0
is null 为 null,a IS NULL,当 a 的值为 null,则返回值为 1,否则返回 0
is not null 不为 null,a IS NOT NULL,和 “is null” 相反,当 a 的值不为 NULL,则返回值为 1,否则返回 0
like 通配符匹配,a LIKE %123%,当 a 中含有字符串 “123” 时,则返回值为 1,否则返回 0
regexp、rlike 正则表达式,str REGEXP str_pat,当 str 字符串中含有 str_pat 相匹配的字符串时,则返回值为 1,否则返回 0
  • 示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    > select 1 = 0, 1 = 1, NULL = NULL;

    +-------+-------+-------------+
    | 1 = 0 | 1 = 1 | NULL = NULL |
    +-------+-------+-------------+
    | 0 | 1 | NULL |
    +-------+-------+-------------+
    1 row in set (0.00 sec)

    > select 1 = 0, 1 = 1, NULL = NULL;

    +-------+-------+-------------+
    | 1 = 0 | 1 = 1 | NULL = NULL |
    +-------+-------+-------------+
    | 0 | 1 | NULL |
    +-------+-------+-------------+
    1 row in set (0.00 sec)

    > select 1 <=> 1, 2 <=> 0, 0 <=> 0, NULL <=> NULL;

    +---------+---------+---------+---------------+
    | 1 <=> 1 | 2 <=> 0 | 0 <=> 0 | NULL <=> NULL |
    +---------+---------+---------+---------------+
    | 1 | 0 | 1 | 1 |
    +---------+---------+---------+---------------+
    1 row in set (0.00 sec)

    > select 'a '< 'b', 'a' < 'a', 'a' < 'c', 1 < 2;

    +-----------+-----------+-----------+-------+
    | 'a '< 'b' | 'a' < 'a' | 'a' < 'c' | 1 < 2 |
    +-----------+-----------+-----------+-------+
    | 1 | 0 | 1 | 1 |
    +-----------+-----------+-----------+-------+
    1 row in set (0.00 sec)

    > select 'bdf' <= 'b', 'b' <= 'b', 0 < 1;

    +--------------+------------+-------+
    | 'bdf' <= 'b' | 'b' <= 'b' | 0 < 1 |
    +--------------+------------+-------+
    | 0 | 1 | 1 |
    +--------------+------------+-------+
    1 row in set (0.00 sec)

    > select 'a' > 'b', 'abc' > 'a', 1 > 0;

    +-----------+-------------+-------+
    | 'a' > 'b' | 'abc' > 'a' | 1 > 0 |
    +-----------+-------------+-------+
    | 0 | 1 | 1 |
    +-----------+-------------+-------+
    1 row in set (0.00 sec)

    > select 'a' >= 'b', 'abc' >= 'a', 1 >= 0, 1 >= 1;

    +------------+--------------+--------+--------+
    | 'a' >= 'b' | 'abc' >= 'a' | 1 >= 0 | 1 >= 1 |
    +------------+--------------+--------+--------+
    | 0 | 1 | 1 | 1 |
    +------------+--------------+--------+--------+
    1 row in set (0.00 sec)

    > select 10 between 10 and 20, 9 between 10 and 20;

    +----------------------+---------------------+
    | 10 between 10 and 20 | 9 between 10 and 20 |
    +----------------------+---------------------+
    | 1 | 0 |
    +----------------------+---------------------+
    1 row in set (0.00 sec)

    > select 1 in (1, 2, 3), 't' in ('t', 'a', 'b', 'l', 'e'), 0 in (1, 2);

    +----------------+----------------------------------+-------------+
    | 1 in (1, 2, 3) | 't' in ('t', 'a', 'b', 'l', 'e') | 0 in (1, 2) |
    +----------------+----------------------------------+-------------+
    | 1 | 1 | 0 |
    +----------------+----------------------------------+-------------+
    1 row in set (0.00 sec)

    > select 0 is null, null is null;

    +-----------+--------------+
    | 0 is null | null is null |
    +-----------+--------------+
    | 0 | 1 |
    +-----------+--------------+
    1 row in set (0.00 sec)

    > select 0 is not null, null is not null;

    +---------------+------------------+
    | 0 is not null | null is not null |
    +---------------+------------------+
    | 1 | 0 |
    +---------------+------------------+
    1 row in set (0.00 sec)

    > select 123456 like '123%', 123456 like '%123%', 123456 like '%321%';

    +--------------------+---------------------+---------------------+
    | 123456 like '123%' | 123456 like '%123%' | 123456 like '%321%' |
    +--------------------+---------------------+---------------------+
    | 1 | 1 | 0 |
    +--------------------+---------------------+---------------------+
    1 row in set (0.00 sec)

    > select 'abcdef' regexp 'ab', 'abcdefg' regexp 'k';

    +----------------------+----------------------+
    | 'abcdef' regexp 'ab' | 'abcdefg' regexp 'k' |
    +----------------------+----------------------+
    | 1 | 0 |
    +----------------------+----------------------+
    1 row in set (0.01 sec)

3、逻辑运算符

  • 逻辑运算符又称为布尔运算符,用来确认表达式的真和假。
运算符 作用
not、! 逻辑非,返回和操作数相反的结果:0(假)返回值为 1,否则值为 0。NOT NULL 的返回值为 NULL
and、&& 逻辑与,当所有操作数均为非零值并且不为 NULL 时,计算所得结果为 1,当一个或多个操作数为 0 时,所得结果为 0,操作数中有任何一个为 NULL 则返回值为 NULL
or、\\ 逻辑或,当两个操作数均为非 NULL 值时,如有任意一个操作数为非零值,则结果为 1,否则结果为 0。当有一个操作数为 NULL 时,如另一个操作数为非零值,则结果为 1,否则结果为 NULL。假如两个操作数均为 NULL,则所得结果为 NULL
xor 逻辑异或,任意一个操作数为 NULL 时,返回值为 NULL。对于非 NULL 的操作数,如果两个的逻辑真假值相异,则返回结果 1,否则返回 0
  • 示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    > select not 0, not 1, not null;

    +-------+-------+----------+
    | not 0 | not 1 | not null |
    +-------+-------+----------+
    | 1 | 0 | NULL |
    +-------+-------+----------+
    1 row in set (0.00 sec)

    > select 1 and 1, 0 and 1, 3 and 1, 1 and null;

    +---------+---------+---------+------------+
    | 1 and 1 | 0 and 1 | 3 and 1 | 1 and null |
    +---------+---------+---------+------------+
    | 1 | 0 | 1 | NULL |
    +---------+---------+---------+------------+
    1 row in set (0.00 sec)

    > select 1 or 0, 0 or 0, 1 or null, 1 or 1, null or null;

    +--------+--------+-----------+--------+--------------+
    | 1 or 0 | 0 or 0 | 1 or null | 1 or 1 | null or null |
    +--------+--------+-----------+--------+--------------+
    | 1 | 0 | 1 | 1 | NULL |
    +--------+--------+-----------+--------+--------------+
    1 row in set (0.00 sec)

    > select 1 xor 1, 0 xor 0, 1 xor 0, 0 xor 1, null xor 1;

    +---------+---------+---------+---------+------------+
    | 1 xor 1 | 0 xor 0 | 1 xor 0 | 0 xor 1 | null xor 1 |
    +---------+---------+---------+---------+------------+
    | 0 | 0 | 1 | 1 | NULL |
    +---------+---------+---------+---------+------------+
    1 row in set (0.00 sec)

4、位运算符

  • 位运算是将给定的操作数转化为二进制后,对各个操作数每一位都进行指定的逻辑运算,得到的二进制结果转换为十进制数后就是位运算的结果。
运算符 作用
& 位与(位 and),对多个操作数的二进制位做逻辑与操作
\ 位或(位 or),对多个操作数的二进制位做逻辑或操作
^ 位异或(位 xor),对操作数的二进制位做异或操作
~ 位取反,对操作数的二进制位做 not 操作,这里的操作数只能是一位
>> 位右移,左操作数向右移动右操作数指定的位数,左边补 0
<< 位左移,右操作数向左移动左操作数指定的位数。右边补 0
  • 示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    > select 2&3&4;

    +-------+
    | 2&3&4 |
    +-------+
    | 0 |
    +-------+
    1 row in set (0.00 sec)

    > select 2|3;

    +-----+
    | 2|3 |
    +-----+
    | 3 |
    +-----+
    1 row in set (0.00 sec)

    > select 2^3;

    +-----+
    | 2^3 |
    +-----+
    | 1 |
    +-----+

    > select ~1 , ~18446744073709551614;

    +----------------------+------------------------+
    | ~1 | ~ 18446744073709551614 |
    +----------------------+------------------------+
    | 18446744073709551614 | 1 |
    +----------------------+------------------------+
    1 row in set (0.00 sec)

    > select 100 >> 3;

    +----------+
    | 100 >> 3 |
    +----------+
    | 12 |
    +----------+
    1 row in set (0.00 sec)

    > select 100 << 3;

    +----------+
    | 100 << 3 |
    +----------+
    | 800 |
    +----------+
    1 row in set (0.00 sec)

5、运算符的优先级

  • 优先级顺序
优先级顺序 运算符
1 :=
2 \\, OR, XOR
3 &&, AND
4 NOT
5 BETWEEN, CASE, WHEN, THEN, ELSE
6 =, <=>, >=, >, <=, <, <>, !=, IS, LIKE, REGEXP, IN
7 \
8 &
9 <<, >>
10 -, +
11 *, /, DIV, %, MOD
12 ^
13 - (unary minus), ~ (unary bit inversion)
14 !
  • 实际上,很少有人能将这些优先级熟练记忆,很多情况下我们都是用 “()” 来将需要优先的操作括起来,这样既起到了优先的作用,又使得其他用户看起来更易于理解。
文章目录
  1. 1. 1、算数运算符
  2. 2. 2、比较运算符
  3. 3. 3、逻辑运算符
  4. 4. 4、位运算符
  5. 5. 5、运算符的优先级
隐藏目录