1. 算数运算符
2. 比较运算符
3. 逻辑运算符
4. 位操作运算符
| 运算符 | 作用 |
| + | 加法运算 |
| - | 减法运算 |
| * | 乘法运算 |
| / | 除法运算，返回商 |
| % | 求余运算，返回余数 |
【例】 创建表 tmp1， 定义数据类型为 INT 的字段 num ，插入值 64，对 num 值进行算数运算。
首先创建表 tmp1 ，语句如下：
mysql> create table tmp1( num int);
向字段 num 插入数据64：
mysql> insert into tmp1 value (64);
对 num 值进行运算：
mysql> select num ,num+10, num-3+5,num+36.5,num*2,num/2,num/3,num%3 from tmp1; +------+--------+---------+----------+-------+---------+---------+-------+ | num | num+10 | num-3+5 | num+36.5 | num*2 | num/2 | num/3 | num%3 | +------+--------+---------+----------+-------+---------+---------+-------+ | 64 | 74 | 66 | 100.5 | 128 | 32.0000 | 21.3333 | 1 | +------+--------+---------+----------+-------+---------+---------+-------+
用 0 除 num：
mysql> select num, num/0, num%0 from tmp1; +------+-------+-------+ | num | num/0 | num%0 | +------+-------+-------+ | 64 | NULL | NULL | +------+-------+-------+
【注】对 0 进行求商和求余运算的结果均为 NULL
2. 比较运算符
| 运算符 | 作用 |
| = | 等于 |
| <=> | 安全等于 |
| <> (!=) | 不等于 |
| <= | 小于等于 |
| >= | 大于等于 |
| > | 大于 |
| IS NULL | 判断一个值是否为 NULL |
| IS NOT NULL | 判断一个值是否不为 NULL |
| LEAST | 在有两个或多个参数时，返回最小值 |
| GREATEST | 当有两个或多个参数时，返回最大值 |
| BETWEEN AND | 判断一个值是否落在两个值之间 |
| ISNULL | 于 IS NULL 的作用相同 |
| IN | 判断一个值 IN 列表中的值 |
| NOT IN | 判断一个值不是 IN 列表中的值 |
| LIKE | 通配符匹配 |
| REGEXP | 正则表达式匹配 |
a. 等于运算符（=）
等号(=) 用来判断数字、字符串和表达式是否相等，如果相等，返回值为 1，否则返回值为0。
【例】使用“=”进行相等判断，SOL 语句如下:
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) 若有一个或两个参数为NULL，则比较运算的结果为NULL。
(2) 若同一个比较运算中的两个参数都是字符串，则按照字符串进行比较。
(3) 若两个参数均为整数，则按照整数进行比较。
(4) 若一个字符串和数字进行相等判断，则MySQL 可以自动将字符串转换为数字。
b. 安全等于运算符(<=>)
这个操作符和 = 操作符执行相同的比较操作，不过<=>可以用来判断NULL 值。在两个操作数均为NULL 时，其返回值为1而不为NULL; 而当一个操作数为NULL 时，其返回值为 0 而不为 NULL.
【例】使用<=>进行相等的判断，soL 语句如下：
mysql> select 1<=>0,'2'<=>2, 2<=>2,'0.02'<=>0,'b'<=>'b',(1+3)<=>(2+2),NUll<=>NUll ,0 <=> NULL; +-------+---------+-------+------------+-----------+---------------+-------------+------------+ | 1<=>0 | '2'<=>2 | 2<=>2 | '0.02'<=>0 | 'b'<=>'b' | (1+3)<=>(2+2) | NUll<=>NUll | 0 <=> NULL | +-------+---------+-------+------------+-----------+---------------+-------------+------------+ | 0 | 1 | 1 | 0 | 1 | 1 | 1 | 0 | +-------+---------+-------+------------+-----------+---------------+-------------+------------+
c. 不等于运算符(<>或者 !=)
<>或者 != 用于数字、字符串、表达式不相等的判断。如果不相等，返回值为1; 否则返0。这两个运算符不能用于判断空值NULL。
【例】使用 <> 和 != 进行不相等的判断，SQL 语句如下:
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 | +---------------+------+-------+--------+--------------+------------+
d. 小于或等于运算符（<=）
<=用来判断左边的操作数是否小于或者等于右边的操作数。如果小于或者等于，返回值为1，否则返回值为0。<=不能用于判断空值NULL。
【例】使用<=进行比较判断，SQL语句如下:
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 | +---------------+------+------+-------+--------------+------------+
e. 小于运算符
< 运算符用来判断左边的操作数是否小于右边的操作数，如果小于，返回值为1; 否则返回值为0。<不能用于判斯空值NULL。
【例】使用<进行比较判断，SQL语句如下:
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 | +--------------+-----+-----+-------+-------------+-----------+
f. 大于或等于运算符(>=)
>=用来判断左边的操作数是否大于或者等于右边的操作数，如果大于或者等于，返回值为1；否则返回值为0。>=不能用于判断空值NULL。
【例】使用>=进行比较判断，SQL语句如下:
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 | +---------------+------+------+--------+--------------+------------+
g. 大于运算符(>)
>运算符用来判断左边的操作数是否大于右边的操作数，如果大于，返回值为1; 否则返回值为0。>不能用于判断空值NULL。
【例】使用>进行比较判断，SQL语句如下:
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 | +--------------+-----+-----+-------+-------------+-----------+
h. IS NULL(ISNULL)和 IS NOT NULL 运算符
IS NULL 和 ISNULL检验一个值是否为 NULL，如果为NULL，返回值为1； 否则返回值为O。 IS NOT NULL 检验一个值是否非 NULL，如果非NULL，返回值为1，否则返回值为0.
【例】 使用 IS NULL 、ISNULL 和 IS NOT NULL 判断 NULL值和非 NULL值，SQL语句如下：
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 |
+--------------+--------------+------------+------------------+
可以看到，IS NUL L和ISNULL的作用相同，只是格式不同。ISNULL和IS NOT NULL的返回值正好相反。
i. BETWEEN AND 运算符
语法格式为 expr BETWEEN min AND max。假如 expr 大于或等于min 且小于或等于max，则 BETWEEN 的返回值为1，否则返回值为0。
mysql> SELECT 4 BETWEEN 4 AND 6, 4 BETWEEN 4 AND 6, 12 BETWEEN 9 AND 10; +-------------------+-------------------+---------------------+ | 4 BETWEEN 4 AND 6 | 4 BETWEEN 4 AND 6 | 12 BETWEEN 9 AND 10 | +-------------------+-------------------+---------------------+ | 1 | 1 | 0 | +-------------------+-------------------+---------------------+
mysql> SELECT 'X' BETWEEN 'F' AND 'G','b' BETWEEN 'a' AND 'c'; +--------------------------+-------------------------+ | 'X' BETWEEN 'F' AND 'G' | 'b' BETWEEN 'a' AND 'c' | +--------------------------+-------------------------+ | 0 | 1 | +--------------------------+-------------------------+
j. LEAST 运算符
语法格式为LEAST(值1,值2, ... ,值n)，其中值n 表示参数列表中有n 个值。在有两个或多个参数的情况下，返回最小值。假如任意一个自变量为 NULL，则 LEAST( )的返回值为 NULL。
【例】 使用 LEAST 运算符进行大小判断，SQL 语句如下：
mysql> SELECT least(2,0),least(20.0,3.0,100.5),least('a','c','b'),least(10,NULL);
+------------+-----------------------+--------------------+----------------+
| least(2,0) | least(20.0,3.0,100.5) | least('a','c','b') | least(10,NULL) |
+------------+-----------------------+--------------------+----------------+
| 0 | 3.0 | a | NULL |
+------------+-----------------------+--------------------+----------------+
1 row in set (0.00 sec)
由结果可以看到，当参数是整数或者浮点数时，LEAST 将返其中最小的值；当参数为字符串时，返回字母表中顺序最靠前的字符；当比较值列表中有NULL 时，不能判断大小，返同值为NULL。
k. GREATEST (value1,value2, ... )
语法格式为GREATEST(值1,值2, ... ,值n)，其中值n 表示参数列表中有n 个值。在有两个或多个参数的情况下，返回最大值。假如任意一个自变量为 NULL，则 GREATEST( )的返回值为 NULL。
【例】 使用 LEAST 运算符进行大小判断，SQL 语句如下：
mysql> SELECT greatest(2,0),greatest(20.0,3.0,100.5),greatest('a','c','b'),greatest(10,NULL);
+---------------+--------------------------+-----------------------+-------------------+
| greatest(2,0) | greatest(20.0,3.0,100.5) | greatest('a','c','b') | greatest(10,NULL) |
+---------------+--------------------------+-----------------------+-------------------+
| 2 | 100.5 | c | NULL |
+---------------+--------------------------+-----------------------+-------------------+
由结果可以看到，当参数是整数或者浮点数时，GREATEST 将返其中最大的值；当参数为字符串时，返回字母表中顺序最靠后的字符；当比较值列表中有NULL 时，不能判断大小，返同值为NULL。
L. IN、NOT IN 运算符
IN运算符用来判断操作数是否为 IN 列表中的一个值，如果是，返回值为1；否则返回只为0；
NOT IN 运算符用来判断表达式是否不是 IN 列表中的一个值，如果不是，返回值为1;否则返回值为O。
【例】 使用 IN、 NOT IN 运算符进行判断，SQL语句如下：
mysql> select 2 in (1,3,5,'thks'),'thks' in(1,3,5,'thks'), 2 not in (1,3,5,'thks'),'thks' not in(1,3,5,'thks'); +---------------------+-------------------------+-------------------------+-----------------------------+ | 2 in (1,3,5,'thks') | 'thks' in(1,3,5,'thks') | 2 not in (1,3,5,'thks') | 'thks' not in(1,3,5,'thks') | +---------------------+-------------------------+-------------------------+-----------------------------+ | 0 | 1 | 1 | 0 | +---------------------+-------------------------+-------------------------+-----------------------------+由结果可以看到，IN 和NOT IN的返回值正好相反。
【例】 存在 NULL 值时的 IN 查询，SQL语句如下：
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 | +-------------------------+--------------------------+在左侧表达式为 NULL 的情况下，或是表中找不到匹配项并且表中有一个表达式为 NULL 的情况下，IN 的返回值均为NULL。
m. LIKE
LIKE 运算符用来匹配字符串，语法格式为“expr LIKE 匹配条件”。如果 expr 满足匹配条件，则返回值为 1(TRUE); 如果不匹配，则返回值为 0(FALSE)。 若 expr 或匹配条件中任何一个为 NULL,则结果为NULL。
LIKE 运算符在进行匹配运算时，可以使用下面两种通配符。
(1) %: 匹配任意数目的字符，甚至包括零字符。
(2) _: 只能匹配一个字符。
【例】使用运算符 LIKE 进行字符串匹配运算，SQL语句如下:
mysql> select 'stud' LIKE 'stud','stud' LIKE 'stu_', 'stud' LIKE '%d', 'stud' LIKE 't___','s' LIKE NULL; +----------------------+----------------------+--------------------+----------------------+-----------------+ | 'stud' LIKE 'stud' | 'stud' LIKE 'stu_' | 'stud' LIKE '%d' | 'stud' LIKE 't___' | 's' LIKE NULL | +----------------------+----------------------+--------------------+----------------------+-----------------+ | 1 | 1 | 1 | 0 | NULL | +----------------------+----------------------+--------------------+----------------------+-----------------+
由结果可以看到，指定匹配字符串为 stud. stud 表示直接匹配 stud 字符串，满足匹配条足匹配条件，返回1；stu_表示匹配以 stu 开头的长度为 4 个字符的字符串，stud 正好是4 个字符， 满足匹配条件，因此匹配成功，返回1; %d 表示匹配以字母d 结尾的字符串，stud 满足匹配条件，匹配成功，返回1; t_ _ _表示匹配以开头的长度为4个字符的字符串，stud 不满足匹配条件，因此返回0；当字符s 与NULL 匹配时，结果为NULL。
n. REGEXP
REGEXP 运算符用来匹配字符串，语法格式为“expr REGEXP 匹配条件”。如果expr满足儿条件，返回1; 如果不满足，则返回0; 若 expr 或匹配条件中任意一个为 NULL，则结果为NULL。
REGEXP 运算符在进行匹配运算时，常用的有下面几种通配符。
(1) ^: 匹配以该字符后面的字符开头的字符串。
(2) $: 匹配以该字符后面的字符结尾的字符串。
(3) .: 匹配任何一个单字符。
(4)[...]: 匹配在方括号内的任意字符。例如，[abc]匹配a、b或c 。为了命名字符的范围，使用一个-。[a-z]匹配任意字母，而[0-9]匹配任意数字。
(5)*匹配一个或多个在它前面的字符。例如，x*匹配任意数量的 x 字符，[0-9]*匹配任意数量的数字，而 .* 匹配任意数量的任意字符。
mysql> SELECT 'ssky' REGEXP '^s' , 'ssky' REGEXP 'y$','ssky' REGEXP '.sky','ssky' REGEXP '[ab]'; +--------------------+--------------------+----------------------+----------------------+ | 'ssky' REGEXP '^s' | 'ssky' REGEXP 'y$' | 'ssky' REGEXP '.sky' | 'ssky' REGEXP '[ab]' | +--------------------+--------------------+----------------------+----------------------+ | 1 | 1 | 1 | 0 | +--------------------+--------------------+----------------------+----------------------+ 1 row in set (0.00 sec)
由结果可以看到，指定匹配字符串为 ssky。^s 表示匹配任意以字母 s 开头的字符串，因此满足匹配条件，返回1; y$表示任意以字母 y 结尾的字符串，因此满足匹配条件，返回1； .sky 匹配任意以sky结尾，字符长度为4 的字符串，满足匹配条件，返回1; [ab]匹配任意包含字母 a 或者 b 的字符串，指定字符串中没有字母 a 也没有字母 b，因此不满足匹配条件，返回0。
正则表达式是一个可以进行复杂查询的强大工具，相对于 LIKE 字符串匹配，它可以使用更多的通配符类型，查询结果更加灵活。
3. 逻辑运算符
在SQL 中，所有逻辑运算符的求值结果均为 TRUE、FALSE 成 NULL。在MySQL 中，它们体现为1(TRUE)、0(FALSE )和NULL。
| 运算符 | 作用 |
| NOT 或者 ! | 逻辑非 |
| AND 或者 && | 逻辑与 |
| OR 或者 || | 逻辑或 |
| XOR | 逻辑异或 |
a. NOT 或者 !
逻辑非运算符 NOT 或者 ! 表示当操作数为 0 时，所得值为 1；当操作数为非零值时，所得值为0；当操作数为 NULL 时，所得的返回值为NULL。
【例】使非运算符 NOT 和！进行逻辑判断，SQL语句如下:
mysql> SELECT NOT 10, NOT (1-1), ! -5, !NULL,! 1+1 ,NOT(1+1); +--------+-----------+------+-------+-------+----------+ | NOT 10 | NOT (1-1) | ! -5 | !NULL | ! 1+1 | NOT(1+1) | +--------+-----------+------+-------+-------+----------+ | 0 | 1 | 0 | NULL | 1 | 0 | +--------+-----------+------+-------+-------+----------+
为什么会出现不同的值呢?
这是因为 NOT 与 ！的优先级不同。NOT 的优先级低于 +，因此"NOT 1+1”相当于NOT(1+1)，先计算1+1，然后再进行NOT 运算，因为操作数不为0，因此NOT 1+1的结果是0；相反，由于！的优先级别要高于 + 运算，因此 ！1+1相当 (！1)+1，先计算 !1 结果为0，再加1，最后结果为1。
【注】 在使用运算符运算时，一定要注意不同运算符的优先级不同，如果不能确定计算顺序，最好使用括号，以保证运算结果的正确。
b. AND 或者 &&
逻辑与运算符 AND 成者 && 表示当所有操作数均为非零值、并且不为 NULL 时，计算所得结果为1；当一个或多个操作数为0时，所得结为0；其余情况返回值为NULL。
mysql> SELECT 1 AND -1, 1 AND 0, 1 && NULL , 0 && NULL; +----------+---------+-----------+-----------+ | 1 AND -1 | 1 AND 0 | 1 && NULL | 0 && NULL | +----------+---------+-----------+-----------+ | 1 | 0 | NULL | 0 | +----------+---------+-----------+-----------+
c. OR 或者 ||
逻辑或运算符 OR 和 || 表示当两个操作数均为非NULL 值，且任意一个操作数为非零值时，结果为1，否则结果为0； 当有一个操作数为NULL，且另一个操作数为非零值时，则结果为1，否则结果为NULL；当两个操作数均为NULL时，所得结果为NULL。
【例】 使用或运算符进行逻辑判断，SQL 语句如下:
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 | +--------------+--------+-----------+-----------+---------------+
d. XOR
逻辑异或运算符 XOR 表示当任意一个操作数为 NULL 时，返回值为 NULL； 对于非 NULL 为操作数，如果两个操作数都是非 0 值或者都是 0 值，则返回结果为0； 如果一个为0 值，另一个为非 0 值，返回结果为 1。
【例】 使用异或运算符 XOR 进行逻辑判断，SQL语句如下:
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 XOR 1 XOR 1”中有多个操作数，运算符相同，因此运算顺序从左到右依次计算，“1 XOR 1”的结果为 0,再与 1 进行异或运算，因此结果为1。
4. 位运算符
位运算符是用来对二进制字节中的位进行测试、移位或者测试处理，MySQL 中提供的位运算符有按位或(|)、按位与(&)、按位异或(^)、按位左移(<<)、按位右移(>>)、按位取反(~)。
| 运算符 | 作用 |
| | | 位或 |
| & | 位与 |
| ^ | 位异或 |
| << | 位左移 |
| >> | 位右移 |
| ~ | 位取反，翻转所有比特 |
a. 位或运算符（|）
位或运算的实质是将参与运算的两个数据，按对应的二进制数逐位进行逻辑或运算。对应的二进制位有一个或两个为 1 则该位的运算结果为1，否则为0.
【例】 使用位或运算符进行运算，SQL 语句如下：
mysql> SELECT 10 | 15, 9| 4| 2; +---------+---------+ | 10 | 15 | 9| 4| 2 | +---------+---------+ | 15 | 15 | +---------+---------+10 的二进制数值为1010，15 的二进制数值为1111，按位或运算之后，结果为111,即整数15; 9 的二进制数值为1001，4 的二进制数值为0100，2 的二进制数值为 0010，按位或运算之后，结果为1111，即也是整数15。其结果为一个64位无符号整数。
b. 位与运算符(&)
位与运算的实质是将参与运算的两个操作数，按对应的二进制数逐位进行逻辑与运算。对应的二进制位都为1，则该位的运算结果为1，否则为0。
【例】使用位与运算符进行运算，SQL语句如下:
mysql> SELECT 10 & 15, 9 & 4 & 2; +---------+-----------+ | 10 & 15 | 9 & 4 & 2 | +---------+-----------+ | 10 | 0 | +---------+-----------+
10 的二进制数值为1010，15 的一进制数值为 1111 按位与运算之后，结果为1010 ，即整数10； 9的二进制数值为1001，4的进制教值为 0100 ，2的二进制数值为0010，按位与运算之后，结果为 0000， 即整数 0 。其结果为一个64位无符号整数。
c. 位异或运算符(^)
位异或运算的实质是将参与运算的两个数据，按对应的二进制数逐位进行逻辑异或运算。对应位的二进制数不同时，对应位的结果才为1，如果两个对应位数都为 0 或者都为 1，则对应位结果为0.
【例】使用位异或运算符进行运算，SQL语句如下，
mysql> SELECT 10 ^ 15 , 1^0 , 1^1; +---------+-----+-----+ | 10 ^ 15 | 1^0 | 1^1 | +---------+-----+-----+ | 5 | 1 | 0 | +---------+-----+-----+
10 的二进制数值为 1010, 15 的二进制数值为1111，按位与运算之后，结果为0101, 即整数5；1 的二进制数值为 0001, 0 的二进制数值为0000，按位与运算之后，结果为0001；1 和 1 本身二进制位完全相同，因此结果为0。
d. 位左移运算符(<<)
位左移运算符可以使指定的二进制值的所有位都左移指定的位数。左移指定位数之后，左边高位的数值将被移出并丢弃，右边低位空出的位置用 0 补齐。语法格式为 expr<< n。这里 n 表示值 expr 要移位的位数。【例】使用位左移运算符进行运算，SQL语句如下:
mysql> SELECT 1 << 2, 4 << 2; +--------+--------+ | 1 << 2 | 4 << 2 | +--------+--------+ | 4 | 16 | +--------+--------+
1 的二进制值为0000 0001，左移两位之后变成 0000 0100, 即十进制整数4； 十进制 4 左移两位之后变成 0001 0000 即变成十进制的16。
e. 位右移运算符( >>)
位右移运算符可以使指定的二进制值的所有位都右移指定的位数。右移指定位数之后，右边低位的数值将被移出并丢弃，左边高位空出的位置用 0 补齐。语法格式为 expr >> n。这里 n 表示值 expr 要移位的位数。
【例】使用位左移运算符进行运算，SQL语句如下:
mysql> SELECT 1>>1, 16>>2; +------+-------+ | 1>>1 | 16>>2 | +------+-------+ | 0 | 4 | +------+-------+
1的二进制值 0000 0001 右移1位之后变成 0000 0000，即十进制整数0；16 的二进制为 0001 0000，右移两位之后变成 0000 0100,即变成十进制的4。
f. 位取反运算符(~)
位取反运算的实质是将参与运算的数据，按对应的二进制数逐位反转，即1 取反后变为0, 0 取反后变为1。
【例】使用位取反运算符进行运算，SQL语句如下：
mysql> SELECT 5 & ~1; +--------+ | 5 & ~1 | +--------+ | 4 | +--------+
辑运算 5&~1 中，由于位取反运算符(~)的级别高于位与运算符(&)，因此先对1取反操作。取反之后，只有最低位为 0 而其他们都为1，然后再与十进制数值 5 进行与运算，结果为0100，即整数4。
【注】 在MySQL 中经过位运算之后的数值是一个 64 位的无符号整数。1 的二进制数值只有最右边位为1.其他位均为 0: 取反操作之后，除了最低位，其他位均变为1。可以使用BIN（）函数查看1取反之后的结果，SQL 语句如下:
mysql> SELECT BIN ( ~1); +------------------------------------------------------------------+ | BIN ( ~1) | +------------------------------------------------------------------+ | 1111111111111111111111111111111111111111111111111111111111111110 | +------------------------------------------------------------------+
5. 运算符的优先级
| 优先级 | 运算符 |
| 1 | =(赋值运算） := |
| 2 | || , OR |
| 3 | XOR |
| 4 | && , AND |
| 5 | NOT |
| 6 | BETWEEN, CASE ,WHEN ,THEN, ELSE |
| 7 | =(比较运算），<=>,>=,>,<=,<,<>,!=,IS, LIKE, REGEXP,IN |
| 8 | | |
| 9 | & |
| 10 | << ,>> |
| 11 | -, + |
| 12 | * , /(DIV), %(MOD) |
| 13 | ^ |
| 14 | -(负号），~(位反转） |
| 15 | ！ |