世界上没有相同的落叶，每个人都有自己的生活副本 我们总是被时间催促，匆匆忙忙，匆匆忙忙， 没有时间去理解为什么而活，却发现自己已经聪明地度过了一生。 人生最难得的就是保持人间清醒余生 愿你这样生活： 四季三餐，人间有味，是清华的余生。 愿你活得简单，痛苦，大多来自于对世界的不满， 充满诱惑，过于追求，自然难得的幸福与拥有多少财富无关 人生如逆旅，我也是行人，天地广阔，有什么不能过余生？ 活得坦荡洒脱，该放手就放手，不属于子的东西不强求 人总是要往前看，何必不停地回头！ 愿你按照自己的愿望过上美好的生活                                  ————————————  心灵庙语禅 

• , - ，*，/，%

• 这些算术运算符基本上与其他算术运算符相同 C语言，Java 是一样的，不同的是，SQL 多了一种特殊，

  那就是 NULL ,它很特别，很有趣，需要大家多加注意，正是因为它的存在，让我们的SQL 增加乐趣，难度

SELECT 100, 100   0, 100 - 0,100   50,100 - 50 FROM DUAL; -- DUAL 意思是伪表 

• 结果:

• 整数值与浮点数相加，自动提升 浮点数 显示出来

 SELECT 100   35.5, 100 - 35.5 FROM DUAL; -- DUAL表示伪表 

• 结果:

• 使用除法时，通常会显示有一些保留有效位数的值 ，因为一般都是除不尽的

 SELECT 100 * 2, 100 / 2, 100 / 2.0 , 100 / 3
FROM DUAL; -- DUAL表示的是伪表

• 结果:

• 需要注意的是我们的除数不可以为 0 ，就是 0 不可以作为分母 ，这个大家都是知道的，非要的话结果就是 NULL

SELECT 100 / 0 
FROM DUAL; -- DUAL表示的是伪表

• 结果:

• 取模运算，就是取其中的余数,

  取模后的结果的符号(+ ,- 正负)，是由被除数的 正负 决定的

SELECT 100 % 5, 100 % 3,100 % -3, -100 % 3, -100 % -3
FROM DUAL; -- DUAL表示的是伪表

• 结果:

• 存在NULL 的值的运算，结果都为 NULL ,对于 NULL / 0 ，以 0 作为分母，也不能例外，其结果都是 NULL

SELECT 100 - NULL, 100 + NULL, 100 / NULL, 100 * NULL ,100 % NULL,NULL / 0
FROM DUAL; -- DUAL表示的是伪表

• 结果:

• 算术运算中的隐式转换：

  当一个整数与一个字符型数据计算时，若该字符无法被转化的，默认会是数值 0

  在 Java （ + ） 在一定的打印显示的情况下是：作为连接符的使用的，而在SQL 中就是作为

  简单的算术加法使用的，字符转化为对应的数值，无法转化时，默认是 0 数值

SELECT 100 + '1', 100 - '1', 100 + 'a', 100 - 'a'
FROM DUAL; -- DUAL表示的是伪表

• 结果:

SELECT 100 * '1', 100 / '1', 100 * 'a', 100 / 'a' /* 注意这里的 ‘a’ 无法转化，默认数值为 0*/
FROM DUAL;                                        /*而分母不能作为 0 ,运算结果为 NULL*/

• 结果:

• 一个整数类型的值对整数进行加法和减法操作，结果还是一个整数
• 一个整数类型的值对浮点数进行加法和减法操作，结果还是一个浮点数
• 一个整数类型的值对浮点数或者是整数进行除法操作，结果会保留有效数值4位
• 在Java中，‘+’ 的左右两边如果有字符串，那么表示字符串的拼接，但是在Mysql中+只表示数值相加。如果遇到非数值类型，会先尝试是否可以转化位数值，如果不能，就默认是 0 来计算的，（补充一点在Mysql中字符串的拼接是要使用字符串函数CONCAT() 实现的

• 比较运算符，配合 WHERE 使用，可以实现对数据的筛选，提高查询效率
• < , <= , = ，<=>, > , >= , <> !=, 基本上是和其他网络编程语言C语言，Java 都是差不多的
• 不过，需要注意的是 我们SQL 语言中的等于是 单个的等于号(=) 不是双个等于号(==).这点容易弄混，
• 还有，我们的Mysql 是多了，一种比较运算符，<=>(安全等于)
• 其判断的返回结果与C语言相同，但又有所不同，其结果：真为 1 ，假为 0，和C语言一样，但是比C语言多了一种结果 NULL ,需要多多注意；

SELECT  100 > 0 ,100 < 0 , 100 >= 100, 100 <= 100
FROM DUAL;

• 结果

• 同样在比较运算符中，比较的对象有 NULL 结果同样是 NULL,非要使用的话需要使用特殊处理

SELECT 100 > NULL, 100 <> NULL, 100 >= NULL
FROM DUAL;

• 结果:

• 比较运算中存在单个字符，会进行先看看是否可以隐式转化，可以的话比较前，转化为对应的数值再进行比较判断，如果不可以隐式转化，默认数值为 0 ，来比较判断，

SELECT 1 > '2', 1 = '1', 1 = 'a', 0 = 'a'
FROM DUAL; /*这里我们可以发现其中的 0 = ’a‘ 的判断成立的 为真 1*/

• 结果:

• 两边都是字符串的话，会按照对应ANSI编码的标准比较判断的

SELECT 'a' = 'a' , 'ab' = 'ab', 'a' = 'b'
FROM DUAL;

• 结果:

• 对于 NULL是无法单纯的使用 = , > ,< 的符号判断的，不然结果只会有一种，那就是 NULL

SELECT NULL = NULL, NULL != NULL
FROM DUAL;

• 结果:

• 整数与浮点数之间同样可以比较判断的

SELECT 1 = 1.0, 1 >= 1.000, 1 <= 1.000, 1 = 1.00000000000001
FROM DUAL;

• 结果:

• 浮点数与浮点数也可以进行一定精度上的比较判断

SELECT 1.0 = 1.0 , 1.0 > 1.00000006, 1.0 < 1.2,1.0 = 1.000000000000009,1 = 1.00000000000001
FROM DUAL;

• 结果:

• 注意与其他的编程语言不同 这里的Mysql 的等于的表示是用单个 = ，不是双个等号
• 等号运算符（=）判断等号两边的数值，字符串是否相等，如果相等，则为真 1，不相等，则为假 0 这两者都不是就为 NULL
• 如果等号两边的值为字符串 则Mysql会按照字符串进行比较，其比较的是每个字符串中的字符的ANSL 编码是否相等的，比较大小也是一样的
• 如果等号两边的值都是整数 ，则Mysql就会按照整数来进行比较判断两个值的大小
• 如果两个值中一个为整数 ，另一个为字符串，则Mysql 会将字符串隐式转化为对应的数值，再进行比较判断，如果无法隐式转化，就会把该字符**默认为数值 0 ** 进行比较判断，比较大小也是一样的
• 两边为浮点数，和一边为浮点数和一边为整数值，同样可以在一定精度上的比较判断
• 如果等号两边的值中，有NULL 的存在，则比较的结果就为 NULL ,比较大小也是一样的结果

• 安全等于运算符 (<=>) 与 等于运算符的作用是相似的，唯一不同的区别就是 ’<=>‘ 可以用来对 NULL 的判断使用，再两个判断对象相等时，返回 **真为 1 ** ，则返回 **假为 0 ** ，而不是为 NULL
• 这里我们可以把**<=>安全等于运算符** ，可以理解为是专门为判断 NULL 而诞生的，方便记忆

SELECT 1<=> 1, 1 <=> 2 , 1 <=> '1', 1 <=> 'a', 0 <=> 'a'
FROM DUAL;

• 结果:

SELECT NULL <=> NULL ,NULL <=> 1
FROM DUAL;

• 结果:

• 空运算符 IS NULL 、ISNULL() ,判断一个值(属性)，是否等于空，为空**(NULL)** ,返回 真 1，不为空，返回 **假 0 ** ,配合 WHERE 的使用，筛选查询条件，提高查询效率
• 非空运算符 IS NOT NULL ,判断一个值(属性)，是否等于空，不 是空，返回 真 1 ，为空，返回 假 0 ， 配合 WHERE 的使用，筛选查询条件，提高查询效率

• 空运算符 IS NULL ：为空，返回 真 1，不为空，返回 假 0

SELECT last_name,salary, commission_pct
FROM employees
WHERE commission_pct IS NULL ;

• 结果:

• 空运算符 ：ISNULL( ) ：为空，返回 真 1，不为空，返回 假 0

SELECT last_name ,salary,commission_pct
FROM employees
WHERE ISNULL(commission_pct);

• 结果:

• 使用==<=>安全等于运算符== 可以达到同样的效果

SELECT last_name , salary , commission_pct
FROM employees
WHERE commission_pct <=> NULL;

• 结果:

• 非空运算符：IS NOT NULL ：不是空，返回 真为 1 ，是空 ，返回 假 0

SELECT last_name, salary, commission_pct
FROM employees
WHERE commission_pct IS NOT NULL ;

• 结果:

• 或者是利用<=>安全等于运算符 加上 NOT 同样可以达到效果

SELECT last_name , salary , commission_pct
FROM employees
WHERE NOT commission_pct <=> NULL;

• 结果:

• 最小值运算符 语法格式：LEAST(值1，值2，… , 值n ). 其中，“值N" 表示参数列表中有 n 个值，在有两个或多个参数的情况下，选出其中最小的值 ，但是注意: 无法对包含有NULL 的参数(属性)，进行判断的，存在NULL ,无法返回最小值 ，而是NULL

• 最大值运算符 语法格式为：GREATEST(值1，值2，…，值n)。其中，“值n”表示参数列表中有n个值。在有 两个或多个参数的情况下，返回最大值 ，同样注意:,当该属性(参数)中存在NULL ,其结果就是返回 NULL ,而不再是最大值 了

• LEAST 最小值运算符 ，可以对整数，浮点数，字符，同时可以即包含整数,浮点数和字符， 返回其对应的最小值

SELECT LEAST(1,2,3,4,5),LEAST(1.0,2.0,3.0),LEAST('a','b','c'),LEAST(2,'a',1.0),LEAST(NULL,1,2)
FROM DUAL;  -- LEAST 最小值

• 结果:

• GREATEST 最大值运算符 ，同样和LEAST 是一样的，可以对整数，浮点数，字符，同时可以即包含整数,浮点数和字符， 返回其对应的最大值；

SELECT GREATEST(1,2,3,4,6), GREATEST(1.0,2.0,3.0),GREATEST('a','b','c'), GREATEST(2,'a',1.0),GREATEST(NULL,1,2)
FROM DUAL; -- GREATEST 最大值

• 结果:

• &&(AND) 、 ||(OR) 、!(NOT)、XOR(异或)
• 这里的逻辑运算符同C语言的差不多，稍微不同的一个地方就是这里我们这里的Mysql多了 NULL 特殊的
• 通过逻辑运算符，可以将多个查询条件进行组合使用，配合WHERE 使用，可以提高查询效率

• && 可以写成是AND ,逻辑与运算：当其两侧的表达式为真，整个逻辑与运算 才为 真 ，否则为假 意思就相当于是**’‘且’‘** 的意思，注意: ,它不可以对NULL ，进行运算的，存在NULL ,返回的不是真假 ，而是 NULL

  SELECT (1 = 1) AND (1 > 2) ,(1 = 1) && (1 < 2),(1 = 1) AND (1 <> NULL)
  FROM DUAL;
  

  • 结果:

• || 可以写成是OR ,逻辑或运算：当两侧中的其中一侧的表达式为真，整个逻辑或运算 就为 真 ，两侧为假 才为假 意思就相当于是**’‘或者’‘** 的意思，注意:它不可以对NULL ，进行运算的，存在NULL ,返回的不是真假 ，而是 NULL ，

SELECT (1 = 1) OR (1 > 2) , (1 <> 1) || (1 > 2), (1 = 1) OR ( 1 <> NULL)
FROM DUAL;

• 结果:

• 我们都是知道无论是在C语言 中还是在Java中 这两个逻辑运算符都存在着一定的短路的现象，我们的

  的Mysql 也是没有例外的

• 想要了解其他网络语言上的短路：大家可以看看🔜🔜🔜: 逻辑运算符的探究

&&(AND) 当两个表达式中，存在一个为假，下一个表达式就不会执行判断了，我们可以实验看看

SELECT (1 > 2) AND (1 / 0), (1 = 1) AND (1 / 0)
FROM DUAL;

结果:

• 首先我们是知道：1 / 0 ，0是不可以作为分母使用的，返回的值也是 NULL , 逻辑运算是无法对NULL 的结果进行运算的，运算的话其返回结果就为 NULL
• 而我们从结果上可以看出 (1 > 2) AND (1 / 0) 的结果并不是 NULL 而是 0假
  • 为什么？？？
  • 这就是短路，因为当 (1 > 2) AND (1 / 0) 进行逻辑运算时，首先从左往右运算：第一个表达式1 (1 > 2) 为假 ，根据 AND 逻辑与运算的特征:两个为真，才为真，就已经可以知道结果是假 的了，所以就偷懒了，表达式2 (1 / 0) ，这个结果为NULL的的表达式，就既不判断也不执行了。 所以也就没有对 NULL 进行逻辑与运算 ，自然就没有出现结果为 NULL 的现象
• 而对比==(1 = 1) AND (1 / 0)== ，从左往右执行：第一个表达式1 (1 = 1) 的结果为真， 则会继续执行并判断第二个表达式2 ( 1 / 0) 结果为 NULL ，对NULL进行对应的**&&(AND)** 运算其结果为 NULL

||(OR) 当两表达式中，第一表达式为真 ，第二个表达式就为不会执行判断了，实验看看

SELECT (1 < 2) OR (1 / 0), (1 > 2) OR ( 1 / 0)
FROM DUAL;

结果:

• 首先我们是知道：1 / 0 ，0是不可以作为分母使用的，返回的值也是 NULL , 逻辑运算是无法对NULL 的结果进行运算的，运算的话其返回结果就为 NULL
• 而我们从结果上可以看出 (1 < 2) OR (1 / 0) 的结果并不是 NULL 而是 1真
  • 为什么 ? ? ?
  • 这是因为发生了有关于**||(OR)逻辑或的短路现象** ，当在对==(1 < 2) OR (1 / 0)== 进行逻辑或的运算的时候，首先从左往右运算： 第一个表达式1 (1 < 2) 为 真 ，根据 OR 逻辑或运算的特点：一个为真，其结果就为真 ，所以我们已经可以知道该逻辑或运算 的结果就是 1真 了，所以就又偷懒了，表达式2 (1 / 0) 这个结果为: NULL 的表达式就，既不执行也不判断了。所以就没有出现对 NULL 的逻辑或运算，也就不会出现 NULL 的结果。这就是 有关于 (|| OR)逻辑或上的短路
• 而同样我们对比 (1 > 2) OR ( 1 / 0)，从左往右执行: 第一个表达式1 (1 > 2) 的结果为假， 则会继续执行并判断第二个表达式2 ( 1 / 0) 结果为 NULL ，对NULL进行对应的**||(OR)** 运算,其结果自然就无法避免是 NULL 了

• OR 与 AND 注意事项

• 在同时运用 OR 和 AND 逻辑运算时
• AND 的优先级是比 OR 的优先级是更 高 的，因此执行时会先 对AND两边的操作数进行操作，再与OR中的操作数结合
• 所以在同时使用这两个逻辑运算时，带上括号，不要因为AND 的优先级的原因，导致，结果不符合，你所需要的要求。

• NOT 非否定运算符，不能单独使用的，需要配合其他查询条件组合起来使用的
• NOT 运算符是用来否定某一条件的，但是不能滥用的

SELECT last_name,salary,commission_pct
FROM employees
WHERE NOT commission_pct <=> NULL;

• 结果:

• 逻辑异或 (XOR) :运算符是当给定的值中任意一个值为NULL 时，则返回NULL ,如果两个非NULL 的值都是 0 或者都不等于 0 时，则返回 0 ；如果其中的一个值为 0 ，另外一个值不为 0 时，则返回 1；

  说白了就是：一个为 1(真)，另一个为 0(假)，则返回 1真，如果两个都是 1(真),或者 都是 0(假)，则返回 0(假)

• 逻辑异或（XOR）运算符是当给定的值中任意一个值为NULL时，则返回NULL；如果 两个非NULL的值都是0或者都不等于0时，则返回0；如果一个值为0，另一个值不为0时，则返回1。

SELECT ( 1 = 1) XOR (1 < 0) , (1 > 2) XOR (1 < 0) ,(1 = 1) XOR (2 = 2)
FROM DUAL;

• 结果:

SELECT 1 XOR 0 , 1 XOR 1 , 0 XOR 0 , 1 XOR NULL, NULL XOR NULL
FROM DUAL;

• 结果:

SELECT 1 XOR 1 XOR 0, 0 XOR 1 XOR 0, 1 XOR 1 XOR 1, 0 XOR 0 XOR 0 , 0 XOR 0 XOR 1
FROM DUAL; 
/* 解析: 1 XOR 1 XOR 0 : 首先 1 XOR 1 结果为:0(假) 再与 XOR 0 计算:也就是: 0 XOR 0 结果为 0(假) 0 XOR 1 XOR 0 : 首先 0 XOR 1 结果为: 1(真) 再与 XOR 0 计算:也就是: 1 XOR 0 结果为 1(真) 剩下的都是同理，计算： */

• 结果:

• |(或)、&(与)、^(异或)、>>(右移)、<<(左移)、~(取反)
• 这些位运算符 主要是在二进制中进行计算的运算符，位运算符将会操作数变成二进制数 然后进行位运算，最后将计算出的结果从二进制转化为对应的十进制数显示出来
• 这些位运算符，和其他的网络编程语言上是差不多一样的:他家可以参考🔜🔜🔜:Java 二进制符号位运算

• | 按位或运算符，二进制中：有 1 就为1，没有就为 0
• & 按位与运算符，二进制中：两者都为 1 ，才为 1 ，否则就为 0

SELECT 1 | 10 , 20 | 30 , 1 & 10, 20 & 30
FROM DUAL;

• 结果:

• ^ 按位异或运算，二进制中：一个为 1 ,另一个为 0 ,结果才为 1 ，其他相同 (都是 0 或 1)，其结果为 0
• ~ 按位取反运算，二进制中： 把对应的 1 ，取反变为 0 ，最后转为对应的十进制，显示出来

SELECT 1 ^ 10, 20 ^ 30, ~1, ~10
FROM DUAL;

• 结果:

• >> n 按位向右移动 n 个比特位(bit)，其实就是 除以n个2
• << n 按位向左移动 n 个比特位(bit),其实就是 乘以n个2

SELECT 6 >> 2, 1 << 3
FROM DUAL;

• 结果:

• BETWEEN AND 运算符的格式:

SELECT xxx
FROM xxx
WHERE BETWEEN 数值1 AND 数值2;

• 其 作用: 是选取在 [数值1,数值2] 满足它们数值之间的范围的取值

• 注意:

  1. 取值的范围是闭区间的：>=数值1 <=数值2 的范围：当数值 >= 数值1 并且 <= 数值2 结果就返回 1(真) ，否则返回 0(假)

  它和 x >= 数值1 AND x <= 数值2 的逻辑与运算是一样的，只不过它更简写一点

  2. 数值1：也就是左侧的数值要 小于 数值2：也就是右侧的数值

-- 查询工资在 13000 到 24000 的员工的信息
SELECT employee_id ,last_name,salary
FROM employees
WHERE salary BETWEEN 13000 AND 24000; 

• 结果:

• 或者是:使用逻辑与运算符 可以达到同样的效果

-- 查询工资在 13000 到 24000 的员工的信息
SELECT employee_id, last_name ,salary
FROM employees
WHERE salary >= 13000 AND salary <= 24000;

• 结果:

• IN ( ) 运算符作用： 用来判断给定的值是否存在于IN ( 的列表中的某一个值 )，如果存在，则返回 1(真)

  否则，如果不存在，返回 0(假)

  当然其功能也是可以通过 逻辑或运算符 达到同样的查询效果的

• NOT IN( ) 运算符作用：简单就是于 IN( ) 相反：用来判断给定的值是否存在于IN ( 的列表中的某一个值 )，如果不存在，则返回 0(真)， 否则，如果存在，返回 0(假)

• 注意: 如果给定的值中为 NULL ,或者在 IN 的列表中存在 NULL ，则结果返回的是 NULL

• IN( ) 运算符：

-- 查询工资是 10000 或者是 9000 的员工的信息
SELECT employee_id, last_name, salary
FROM employees
WHERE salary IN(10000,9000); 

• 结果:

• 或者 使用逻辑或运算符

-- 查询工资是 10000 或者是 9000 的员工的信息
SELECT employee_id, last_name,salary
FROM employees
WHERE salary = 9000 OR salary = 10000;

• 结果: