2.DQL语言

WhyNotZero_

已于 2022-09-04 18:50:39 修改

阅读量252

点赞数

分类专栏：数据库文章标签： sql 数据库 mysql

于 2021-09-04 03:00:11 首次发布

本文链接：https://blog.csdn.net/shine_my/article/details/120093455

版权

数据库专栏收录该内容

14 篇文章 0 订阅

订阅专栏

基于尚硅谷李玉婷老师的课程：MySQL_基础+高级篇- 数据库 -sql -mysql教程_mysql视频_mysql入门_尚硅谷_哔哩哔哩_bilibili

以下案例用到的sql文件链接链接：https://pan.baidu.com/s/1Y5N8Fd7AbOf5XB2U1XbalQ
提取码：6666

进阶1：基础查询

一、语法：

select 查询列表 from 表名;
类似于：System.out.println(打印东西);

二、特点：

1、查询列表可以是：表中的字段、常量值、表达式、函数
2、查询的结果是一个虚拟的表格

三、案例

USE myemployees;

#1.查询表中的单个字段

select 字段名 from 表名;

eg.

SELECT last_name FROM employees;

#2.查询表中的多个字段

select 字段名，字段名 from 表名;

eg.

SELECT last_name,salary,email FROM employees;

#3.查询表中的所有字段

#方式一：

select 所有字段 from 表名

eg.

SELECT 
    `employee_id`,       # ` `(Esc键下面、1的左边)是转义符，为了区分字段和关键字
    `first_name`,
    `last_name`,
    `phone_number`,
    `last_name`,
    `job_id`,
    `phone_number`,
    `job_id`,
    `salary`,
    `commission_pct`,
    `manager_id`,
    `department_id`,
    `hiredate` 
FROM
    employees ;

# ` `(Esc键下面、1的左边)是转义符，为了区分字段和关键字
#方式二：

select * from 表名

eg.

SELECT * FROM employees;

#4.查询常量值

select 常量值;

eg.

SELECT 100;
 SELECT 'john';

注意：字符型和日期型的常量值必须用单引号引起来，数值型不需要

#5.查询表达式

eg.

 SELECT 100%98;
 SELECT 100/1234;

#6.查询函数
select 函数名(实参列表);

eg.

 SELECT VERSION();

#7.起别名
/*
①便于理解
②如果要查询的字段有重名的情况，使用别名可以区分开来

*/
#方式一：使用as

SELECT 100%98 AS 结果;
SELECT last_name AS 姓,first_name AS 名 FROM employees;

#方式二：使用空格

SELECT last_name 姓,first_name 名 FROM employees;

#案例：查询salary，显示结果为 out put

SELECT salary AS "out put" FROM employees;

#8.去重

select distinct 字段名 from 表名;
#案例：查询员工表中涉及到的所有的部门编号

SELECT DISTINCT department_id FROM employees;

#9.+号的作用

java中的+号：
①运算符，两个操作数都为数值型
②连接符，只要有一个操作数为字符串

mysql中的+号：
仅仅只有一个功能：运算符

作用：做加法运算
select 数值+数值; 直接运算
select 字符+数值;先试图将字符转换成数值，如果转换成功，则继续运算；否则转换成0，再做运算
select null+值;结果都为null

eg.

select 100+90;           #两个操作数都为数值型，则做加法运算
select '123'+90;         #只要其中一方为字符型，试图将字符型数值转换成数值型
                         #如果转换成功，则继续做加法运算
select 'john'+90;        #如果转换失败，则将字符型数值转换成0

select null+10;          #只要其中一方为null，则结果肯定为null

10、【补充】concat函数
功能：拼接字符
select concat(字符1，字符2，字符3,...);

#案例：查询员工名和姓连接成一个字段，并显示为姓名

SELECT CONCAT('a','b','c') AS 结果;

SELECT 
    CONCAT(last_name,' ',first_name) AS 姓名
FROM
    employees;

11、【补充】ifnull函数
功能：判断某字段或表达式是否为null，如果为null 返回指定的值，否则返回原本的值
eg.

select ifnull(commission_pct,0) from employees;

12、【补充】isnull函数
功能：判断某字段或表达式是否为null，如果是，则返回1，否则返回0

PS:SQLyog Ultimate 的SQL语句代码格式化按F12

四、基础查询测试题

#1. 下面的语句是否可以执行成功

SELECT last_name , job_id , salary AS sal
FROM employees;

（可以）

#2.下面的语句是否可以执行成功

SELECT  *  FROM employees;

（可以）
#3.找出下面语句中的错误

SELECT employee_id , last_name,
salary * 12 AS "ANNUAL  SALARY"
FROM employees;

（已改正，注意都是英文标点符号）

#4.显示表departments的结构，并查询其中的全部数据

DESC departments;
SELECT * FROM `departments`;

#5.显示出表employees中的全部job_id（不能重复）

SELECT DISTINCT job_id FROM employees;

#6.显示出表employees的全部列，各个列之间用逗号连接，列头显示成OUT_PUT

SELECT 
    IFNULL(commission_pct,0) AS 奖金率,
    commission_pct
FROM 
    employees;

SELECT
    CONCAT(`first_name`,',',`last_name`,',',`job_id`,',',IFNULL(commission_pct,0)) AS out_put
FROM
    employees;

进阶2：条件查询

一、语法：

select
       查询列表
   from
       表名
   where
       筛选条件;

#执行顺序是先执行from，再执行where，最后执行 select

二、筛选条件的分类

1、按条件表达式筛选

简单条件运算符：> < = != <> >= <=

<=>安全等于

   2、按逻辑表达式筛选
   逻辑运算符：
   作用：用于连接条件表达式
       && || !
       and or not

   &&和and：两个条件都为true，结果为true，反之为false
   ||或or：只要有一个条件为true，结果为true，反之为false
   !或not：如果连接的条件本身为false，结果为true，反之为false

   3、模糊查询
       like:一般搭配通配符使用，可以判断字符型或数值型
通配符：%任意多个字符，_任意单个字符
       between and
       in
       is null /is not null：用于判断null值

   is null PK <=>
           普通类型的数值   null值       可读性
is null       × √ √
<=> √ √ ×

三、案例

#1、按条件表达式筛选

#案例1：查询工资>12000的员工信息

SELECT 
    *
FROM
    employees
WHERE
    salary>12000;

#案例2：查询部门编号不等于90号的员工名和部门编号

SELECT 
    last_name,
    department_id
FROM
    employees
WHERE
    department_id<>90;

#虽然也可以用!=，但还是最好用<>

#2、按逻辑表达式筛选

#案例1：查询工资z在10000到20000之间的员工名、工资以及奖金

SELECT
    last_name,
    salary,
    commission_pct
FROM
    employees
WHERE
    salary>=10000 AND salary<=20000;

#案例2：查询部门编号不是在90到110之间，或者工资高于15000的员工信息

SELECT
    *
FROM
    employees
WHERE
    NOT(department_id>=90 AND  department_id<=110) OR salary>15000;

#3、模糊查询
/*
like
between and
in
is null|is not null

*/
#1.like
/*
特点：
①一般和通配符搭配使用
   通配符：
   % 任意多个字符,包含0个字符
   _ 任意单个字符
*/

#案例1：查询员工名中包含字符a的员工信息

select 
    *
from
    employees
where
    last_name like '%a%';

#案例2：查询员工名中第三个字符为e，第五个字符为a的员工名和工资

select
    last_name,
    salary
FROM
    employees
WHERE
    last_name LIKE '__e_a%';

#案例3：查询员工名中第二个字符为_的员工名

SELECT
    last_name
FROM
    employees
WHERE
    last_name LIKE '_$_%' ESCAPE '$';

#或者last_name LIKE '_\_%';但是还是用$好一些
#2.between and
/*
①使用between and 可以提高语句的简洁度
②包含临界值
③两个临界值不要调换顺序

#案例1：查询员工编号在100到120之间的员工信息

SELECT
    *
FROM
    employees
WHERE
    employee_id >= 100 AND employee_id<=120;

SELECT
    *
FROM
    employees
WHERE
    employee_id BETWEEN 100 AND 120;

#3.in
/*
含义：判断某字段的值是否属于in列表中的某一项
特点：
   ①使用in提高语句简洁度
   ②in列表的值类型必须一致或兼容
   ③in列表中不支持通配符

*/
#案例：查询员工的工种编号是 IT_PROG、AD_VP、AD_PRES中的一个员工名和工种编号

SELECT
    last_name,
    job_id
FROM
    employees
WHERE
    job_id = 'IT_PROT' OR job_id = 'AD_VP' OR JOB_ID ='AD_PRES';

SELECT
    last_name,
    job_id
FROM
    employees
WHERE
    job_id IN( 'IT_PROG' ,'AD_VP','AD_PRES');

#4、is null
/*
=或<>不能用于判断null值
is null或is not null 可以判断null值

#案例1.1：查询没有奖金的员工名和奖金率

SELECT
    last_name,
    commission_pct
FROM
    employees
WHERE
    commission_pct IS NULL;

#案例1.2：查询有奖金的员工名和奖金率

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

#----------以下为错误的

SELECT
    last_name,
    commission_pct
FROM
    employees

WHERE 
    salary IS 12000;

#最后一行必须是salary = 12000;

#安全等于 <=> 用来判断是否等于

#案例1.3：查询没有奖金的员工名和奖金率

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

#案例2：查询工资为12000的员工信息

SELECT
    last_name,
    salary
FROM
    employees

WHERE 
    salary <=> 12000;

#is null pk <=>

IS NULL:仅仅可以判断NULL值，可读性较高，建议使用
<=> :既可以判断NULL值，又可以判断普通的数值，可读性较低

四、条件查询测试题

1. 查询工资大于 12000 的员工姓名和工资

SELECT last_name,salary FROM employees WHERE salary>12000;

2. 查询员工号为 176 的员工的姓名和部门号和年薪

SELECT last_name,department_id,salary*12*(1+IFNULL(commission_pct,0)) AS 年薪 
FROM employees;

3. 选择工资不在 5000 到 12000 的员工的姓名和工资
4. 选择在 20 或 50 号部门工作的员工姓名和部门号
5. 选择公司中没有管理者的员工姓名及 job_id
6. 选择公司中有奖金的员工姓名，工资和奖金级别
7. 选择员工姓名的第三个字母是 a 的员工姓名
8. 选择姓名中有字母 a 和 e 的员工姓名
9. 显示出表 employees 表中 first_name 以 'e'结尾的员工信息
10. 显示出表 employees 部门编号在 80-100 之间的姓名、职位
11. 显示出表 employees 的 manager_id 是 100,101,110 的员工姓名、职位

测试题1

1.查询没有奖金，且工资小于18000的salary,last_name

select salary,last_name from employees where commission_pct is null and salary<18000;

2.查新employees表中，job_id不为'IT'或者工资为12000的员工信息

select * from employees where job_id <>'IT' or salary=12000;

3.查看部门departments表的结构

desc departments;

4.查询部门department表中涉及到了哪些位置编号

select distinct location_id from departments;

5.经典面试题：

试问 select * from employees;和select * from employees where commission_pct like '%%' and last_name like '%%';结果是否一样？并说明原因

不一样，如果判断的字段有null值就不一样，如果没有就一样

select * from employees;

和

select * from employees;和select * from employees where commission_pct like '%%' or last_name like '%%' or employee_id like '%%';

是一样的

进阶3：排序查询

一、语法：

select 查询列表
from 表名
【where 筛选条件】
order by 排序的字段或表达式【asc|desc】;

#执行顺序是先执行from，再执行where，再执行 select，最后执行order by

二、特点：

1、asc代表的是升序，可以省略（如果不写默认升序）
desc代表的是降序

2、order by子句可以支持单个字段、多个字段、表达式、函数、别名

3、order by子句在查询语句的最后面，除了limit子句

三、案例

#1、按单个字段排序

#案例：查询员工信息，要求工资从高到低排序

SELECT * FROM employees ORDER BY salary DESC;

#2、添加筛选条件再排序

#案例：查询部门编号>=90的员工信息，按入职时间的先后进行排序

SELECT *
FROM employees
WHERE department_id>=90
ORDER BY hiredate ASC;

#案例：查询部门编号>=90的员工信息，并按员工编号降序

SELECT *
FROM employees
WHERE department_id>=90
ORDER BY employee_id DESC;

#3、按表达式排序
#案例：查询员工信息按年薪降序

SELECT *,salary*12*(1+IFNULL(commission_pct,0))
FROM employees
ORDER BY salary*12*(1+IFNULL(commission_pct,0)) DESC;

#4、按别名排序
#案例：查询员工信息按年薪升序

SELECT *,salary*12*(1+IFNULL(commission_pct,0)) 年薪
FROM employees
ORDER BY 年薪 ASC;

#5、按函数排序
#案例：查询员工名，并且按名字的长度降序

SELECT LENGTH(last_name),last_name 
FROM employees
ORDER BY LENGTH(last_name) DESC;

#案例：查询员工名，按名字的长度显示员工的姓名和工资

SELECT LENGTH(last_name) 字节长度,last_name,salary 
FROM employees
ORDER BY LENGTH(last_name) DESC;

#6、按多个字段排序

#案例：查询员工信息，要求先按工资降序，再按员工编号升序

SELECT *
FROM employees
ORDER BY salary DESC,employee_id ASC;

四、排序查询测试题

#1.查询员工的姓名和部门号和年薪，按年薪降序按姓名升序

SELECT last_name,department_id,salary*12*(1+IFNULL(commission_pct,0)) 年薪
FROM employees
ORDER BY 年薪 DESC,last_name ASC;

#2.选择工资不在8000到17000的员工的姓名和工资，按工资降序

SELECT last_name,salary
FROM employees

WHERE salary NOT BETWEEN 8000 AND 17000
ORDER BY salary DESC;

#3.查询邮箱中包含e的员工信息，并先按邮箱的字节数降序，再按部门号升序

SELECT *,LENGTH(email)
FROM employees
WHERE email LIKE '%e%'
ORDER BY LENGTH(email) DESC,department_id ASC;

进阶4：常见函数

一、概述

概念：类似于java的方法，将一组逻辑语句封装在方法体中，对外暴露方法名
好处：1、隐藏了实现细节 2、提高代码的重用性
调用：select 函数名(实参列表) 【from 表】;
特点：
①叫什么（函数名）
②干什么（函数功能）

分类：
    1、单行函数
    如 concat、length、ifnull等
    2、分组函数

    功能：做统计使用，又称为统计函数、聚合函数、组函数

二、常见函数：

1.单行函数

字符函数：
   length:获取字节个数(utf-8一个汉字代表3个字节,gbk为2个字节)
   concat:连接
    substr:截取子串
   instr:获取子串第一次出现的索引
   trim:去前后空格
   upper:变大写
   lower:变小写
   lpad：左填充
rpad：右填充
   replace：替换

   数学函数：
  ceil:向上取整
round：四舍五入
    mod:取模
floor：向下取整
truncate:截断
rand:获取随机数，返回0-1之间的小数

日期函数：
now：返回当前日期+时间
curdate:返回当前日期
curtime：返回当前时间
year:返回年
month：返回月
monthname:以英文形式返回月
day:返回日
hour:小时
minute:分钟
second：秒
str_to_date:将字符转换成日期
date_format:将日期转换成字符
datediff:返回两个日期相差的天数

其他函数：
version 当前数据库服务器的版本
database 当前打开的数据库
user当前用户
password('字符')：返回该字符的密码形式
md5('字符'):返回该字符的md5加密形式

流程控制函数

①if(条件表达式，表达式1，表达式2)：如果条件表达式成立，返回表达式1，否则返回表达式2
②case情况1
        case 变量或表达式或字段
        when 常量1 then 值1
        when 常量2 then 值2
        ...
        else 值n
        end

③case情况2
        case
        when 条件1 then 值1
        when 条件2 then 值2
        ...
        else 值n
        end

案例

#一、字符函数

#1.length 获取参数值的字节个数

SELECT LENGTH('john');
SELECT LENGTH('张三丰hahaha');

SHOW VARIABLES LIKE '%char%'

#2.concat 拼接字符串

SELECT CONCAT(last_name,'_',first_name) 姓名 FROM employees;

#3.upper、lower

SELECT UPPER('john');
SELECT LOWER('joHn');

#案例：将姓变大写，名变小写，然后拼接

SELECT CONCAT(UPPER(last_name),LOWER(first_name))  姓名 FROM employees;

#4.substr、substring
注意：索引从1开始
#截取从指定索引处后面所有字符

SELECT SUBSTR('李莫愁爱上了陆展元',7)  out_put;

#截取从指定索引处指定字符长度的字符

SELECT SUBSTR('李莫愁爱上了陆展元',1,3) out_put;

#案例：姓名中首字符大写，其他字符小写然后用_拼接，显示出来

SELECT CONCAT(UPPER(SUBSTR(last_name,1,1)),'_',LOWER(SUBSTR(last_name,2)))  out_put
FROM employees;

#5.instr 返回子串第一次出现的索引，如果找不到返回0

SELECT INSTR('杨不殷六侠悔爱上了殷六侠','殷八侠') AS out_put;

#6.trim 去前后空格

SELECT LENGTH(TRIM('    张翠山    ')) AS out_put;

SELECT TRIM('a' FROM 'aaaaaaaaa张aaaaaaaaaaaa翠山aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')  AS out_put;

#7.lpad 用指定的字符实现左填充指定长度

SELECT LPAD('殷素素',2,'*') AS out_put;

#8.rpad 用指定的字符实现右填充指定长度

SELECT RPAD('殷素素',12,'ab') AS out_put;

#9.replace 替换

SELECT REPLACE('周芷若周芷若周芷若周芷若张无忌爱上了周芷若','周芷若','赵敏') AS out_put;

#二、数学函数

#round 四舍五入

SELECT ROUND(-1.55);
SELECT ROUND(1.567,2);

#ceil 向上取整,返回>=该参数的最小整数

SELECT CEIL(-1.02);

#floor 向下取整，返回<=该参数的最大整数

SELECT FLOOR(-9.99);

#truncate 截断

SELECT TRUNCATE(1.69999,1);

#mod取余
/*
mod(a,b) ： a-a/b*b

mod(-10,-3):-10- (-10)/(-3)*（-3）=-1
*/

SELECT MOD(10,-3);
SELECT 10%3;

#三、日期函数

#now 返回当前系统日期+时间

SELECT NOW();

#curdate 返回当前系统日期，不包含时间

SELECT CURDATE();

#curtime 返回当前时间，不包含日期

SELECT CURTIME();

#可以获取指定的部分，年、月、日、小时、分钟、秒

SELECT YEAR(NOW()) 年;
SELECT YEAR('1998-1-1') 年;

SELECT  YEAR(hiredate) 年 FROM employees;

SELECT MONTH(NOW()) 月;
SELECT MONTHNAME(NOW()) 月;

#str_to_date 将字符通过指定的格式转换成日期

SELECT STR_TO_DATE('1998-3-2','%Y-%c-%d') AS out_put;

#查询入职日期为1992--4-3的员工信息

SELECT * FROM employees WHERE hiredate = '1992-4-3';

SELECT * FROM employees WHERE hiredate = STR_TO_DATE('4-3 1992','%c-%d %Y');

#date_format 将日期转换成字符

SELECT DATE_FORMAT(NOW(),'%y年%m月%d日') AS out_put;

#查询有奖金的员工名和入职日期(xx月/xx日 xx年)

SELECT last_name,DATE_FORMAT(hiredate,'%m月/%d日 %y年') 入职日期
FROM employees
WHERE commission_pct IS NOT NULL;

#四、其他函数

SELECT VERSION();
SELECT DATABASE();
SELECT USER();

#五、流程控制函数
#1.if函数： if else 的效果

SELECT IF(10>5,'大','小');

SELECT last_name,commission_pct,IF(commission_pct IS NULL,'没奖金，呵呵','有奖金，嘻嘻') 备注 
FROM employees;

#2.case函数的使用一： switch case 的效果

/*
java中
switch(变量或表达式){
   case 常量1：语句1;break;
   ...
   default:语句n;break;

}

mysql中

case 要判断的字段或表达式
when 常量1 then 要显示的值1或语句1;
when 常量2 then 要显示的值2或语句2;
...
else 要显示的值n或语句n;
end
*/

/*案例：查询员工的工资，要求

部门号=30，显示的工资为1.1倍
部门号=40，显示的工资为1.2倍
部门号=50，显示的工资为1.3倍
其他部门，显示的工资为原工资

SELECT salary 原始工资,department_id,
CASE department_id
WHEN 30 THEN salary*1.1
WHEN 40 THEN salary*1.2
WHEN 50 THEN salary*1.3
ELSE salary
END AS 新工资
FROM employees;

#3.case 函数的使用二：类似于多重if
/*
java中：
if(条件1){
   语句1；
}else if(条件2){
   语句2；
}
...
else{
   语句n;
}

mysql中：

case
when 条件1 then 要显示的值1或语句1
when 条件2 then 要显示的值2或语句2
。。。
else 要显示的值n或语句n
end
*/

#案例：查询员工的工资的情况
如果工资>20000,显示A级别
如果工资>15000,显示B级别
如果工资>10000，显示C级别
否则，显示D级别

SELECT salary,
CASE 
WHEN salary>20000 THEN 'A'
WHEN salary>15000 THEN 'B'
WHEN salary>10000 THEN 'C'
ELSE 'D'
END AS 工资级别
FROM employees;

测试

#1. 显示系统时间(注：日期+时间)

SELECT NOW();

#2. 查询员工号，姓名，工资，以及工资提高百分之20%后的结果（new salary）

SELECT employee_id,last_name,salary,salary*1.2 "new salary"
FROM employees;

#3. 将员工的姓名按首字母排序，并写出姓名的长度（length）

SELECT LENGTH(last_name) 长度,SUBSTR(last_name,1,1) 首字符,last_name
FROM employees
ORDER BY 首字符;

#4. 做一个查询，产生下面的结果
<last_name> earns <salary> monthly but wants <salary*3>
Dream Salary
King earns 24000 monthly but wants 72000

SELECT CONCAT(last_name,' earns ',salary,' monthly but wants ',salary*3) AS "Dream Salary"
FROM employees
WHERE salary=24000;

#5.   使用case-when，按照下面的条件：
job grade
AD_PRES A
ST_MAN B
IT_PROG C
SA_REP D
ST_CLERK E
产生下面的结果
Last_name   Job_id   Grade
king   AD_PRES   A

SELECT last_name AS Last_name,job_id AS Job_id,
CASE job_id
WHEN 'AD_PRES' THEN 'A'
WHEN 'ST_MAN' THEN 'B'
WHEN 'IT_PROG' THEN 'C'
WHEN 'SA_PRE' THEN 'D'
WHEN 'ST_CLERK' THEN 'E'
END AS Grade
FROM employees
WHERE job_id='AD_PRES';

2.分组函数

功能：用作统计使用，又称为聚合函数或统计函数或组函数

分类：
sum 求和、avg 平均值、max 最大值、min 最小值、count 计算个数

特点：

1、语法

select sum(字段) from 表名;

select avg(字段) from 表名;

select max(字段) from 表名;

select min(字段) from 表名;

select count(字段) from 表名;
2、sum、avg一般用于处理数值型
max、min、count可以处理任何数据类型
3、以上分组函数都忽略null值

4、可以和distinct搭配实现去重的运算

select sum(distinct 字段) from 表;

5、count函数的单独介绍

count(字段)：统计该字段非空值的个数
count(*):统计结果集的行数
案例：查询每个部门的员工个数
1 xx 10
2 dd 20
3 mm 20
4 aa 40
5 hh 40

count(1):统计结果集的行数

效率上：
MyISAM存储引擎，count(*)最高
InnoDB存储引擎，count(*)和count(1)效率>count(字段)

6、和分组函数一同查询的字段要求是group by后的字段

案例

#1、简单的使用

SELECT SUM(salary) FROM employees;
SELECT AVG(salary) FROM employees;
SELECT MIN(salary) FROM employees;
SELECT MAX(salary) FROM employees;
SELECT COUNT(salary) FROM employees;

SELECT SUM(salary) 和,AVG(salary) 平均,MAX(salary) 最高,MIN(salary) 最低,COUNT(salary) 个数
FROM employees;

SELECT SUM(salary) 和,ROUND(AVG(salary),2) 平均,MAX(salary) 最高,MIN(salary) 最低,COUNT(salary) 个数
FROM employees;

#2、参数支持哪些类型

SELECT SUM(last_name) ,AVG(last_name) FROM employees;
SELECT SUM(hiredate) ,AVG(hiredate) FROM employees;

SELECT MAX(last_name),MIN(last_name) FROM employees;

SELECT MAX(hiredate),MIN(hiredate) FROM employees;

SELECT COUNT(commission_pct) FROM employees;
SELECT COUNT(last_name) FROM employees;

#3、是否忽略null

SELECT SUM(commission_pct) ,AVG(commission_pct),SUM(commission_pct)/35,SUM(commission_pct)/107 FROM employees;

SELECT MAX(commission_pct) ,MIN(commission_pct) FROM employees;

SELECT COUNT(commission_pct) FROM employees;
SELECT commission_pct FROM employees;

#4、和distinct搭配

SELECT SUM(DISTINCT salary),SUM(salary) FROM employees;

SELECT COUNT(DISTINCT salary),COUNT(salary) FROM employees;

#5、count函数的详细介绍

SELECT COUNT(salary) FROM employees;

SELECT COUNT(*) FROM employees;

SELECT COUNT(1) FROM employees;

效率：
MYISAM存储引擎下，COUNT(*)的效率高
INNODB存储引擎下，COUNT(*)和COUNT(1)的效率差不多，比COUNT(字段)要高一些

#6、和分组函数一同查询的字段有限制

SELECT AVG(salary),employee_id  FROM employees;

测试

#1.查询公司员工工资的最大值，最小值，平均值，总和

SELECT MAX(salary) 最大值,MIN(salary) 最小值,AVG(salary) 平均值,SUM(salary) 和
FROM employees;

#2.查询员工表中的最大入职时间和最小入职时间的相差天数（DIFFRENCE）

SELECT MAX(hiredate) 最大,MIN(hiredate) 最小,(MAX(hiredate)-MIN(hiredate))/1000/3600/24 DIFFRENCE
FROM employees;

SELECT DATEDIFF(MAX(hiredate),MIN(hiredate)) DIFFRENCE
FROM employees;

SELECT DATEDIFF('1995-2-7','1995-2-6');

#3.查询部门编号为90的员工个数

SELECT COUNT(*) FROM employees WHERE department_id = 90;

进阶5：分组查询

一、语法：

select 分组函数,列表（要求出现在group by的后面）执行顺序 5
from 表                                                                        执行顺序 1
【where 筛选条件】                                                   执行顺序 2
group by 分组的列表                                                   执行顺序 3
【having 分组后的筛选】                                          执行顺序4
【order by 排序的字段】;                                            执行顺序6

二、特点：

1、和分组函数一同查询的字段必须是group by后出现的字段
2、筛选分为两类：分组前筛选和分组后筛选
针对的表位置连接的关键字
分组前筛选   原始表 group by前            where

分组后筛选   group by后的结果集         group by后            having

问题1：分组函数做筛选能不能放在where后面
答：不能，分组函数做条件肯定是放在having子句中

问题2：where——group by——having

一般来讲，能用分组前筛选的，尽量使用分组前筛选，提高效率

3、group by 子句支持单个字段分组，多个字段分组（多个字段之间用逗号隔开，没有顺序要求），表达式或函数（相对用得较少）
4、可以搭配着排序使用（排序放在整个分组查询的最后）

三、案例

#引入：查询每个部门的员工个数

SELECT COUNT(*) FROM employees WHERE department_id=90;

#1.简单的分组

#案例1.1：查询每个工种的员工平均工资

SELECT AVG(salary),job_id
FROM employees
GROUP BY job_id;

#案例1.2：查询每个位置的部门个数

SELECT COUNT(*),location_id
FROM departments
GROUP BY location_id;

#2.可以实现分组前的筛选

#案例2.1：查询邮箱中包含a字符的每个部门的最高工资

SELECT MAX(salary),department_id
FROM employees
WHERE email LIKE '%a%'
GROUP BY department_id;

#案例2.2：查询有奖金的每个领导手下员工的平均工资

SELECT AVG(salary),manager_id
FROM employees
WHERE commission_pct IS NOT NULL
GROUP BY manager_id;

#3.分组后筛选

#案例3.1：查询哪个部门的员工个数>5

#①查询每个部门的员工个数
SELECT COUNT(*),department_id
FROM employees
GROUP BY department_id;

#② 筛选刚才①结果

SELECT COUNT(*),department_id
FROM employees
GROUP BY department_id
HAVING COUNT(*)>5;

#案例3.2：每个工种有奖金的员工的最高工资>12000的工种编号和最高工资

#①查询每个工种有奖金的员工的最高工资
SELECT job_id,MAX(salary)
FROM employees
WHERE commission_pct IS NOT NULL
GROUP BY job_id;

#②根据①结果继续筛选，最高工资>12000
SELECT job_id,MAX(salary)
FROM employees
WHERE commission_pct IS NOT NULL
GROUP BY job_id
HAVING MAX(salary)>12000;

#案例3.3：领导编号>102的每个领导手下的最低工资大于5000的领导编号和最低工资

#①查询每个领导手下的员工最低工资

SELECT MIN(salary),manager_id
FROM employees
GROUP BY manager_id

#②增加筛选条件：编号>102

SELECT MIN(salary),manager_id
FROM employees
WHERE manager_id>102
GROUP BY manager_id

#③增加筛选条件：最低工资>5000

SELECT MIN(salary),manager_id
FROM employees
WHERE manager_id>102
GROUP BY manager_id
HAVING MIN(salary)>5000;

#4.按表达式或函数分组

#案例：按员工姓名的长度分组，查询每一组的员工个数，筛选员工个数>5的有哪些

#①查询每个长度的员工个数
SELECT COUNT(*),LENGTH(last_name) len_name
FROM employees
GROUP BY LENGTH(last_name);

#②增加筛选条件
SELECT COUNT(*),LENGTH(last_name) len_name
FROM employees
GROUP BY LENGTH(last_name)
HAVING COUNT(*)>5;

#或者用别名减少代码长度
SELECT COUNT(*) c,LENGTH(last_name) len_name
FROM employees
GROUP BY len_name
HAVING c>5;

#5.按多个字段分组

#案例：查询每个部门每个工种的员工的平均工资

SELECT AVG(salary),department_id,job_id
FROM employees
GROUP BY department_id,job_id;

#6.添加排序

#案例：每个工种有奖金的员工的最高工资>6000的工种编号和最高工资,按最高工资升序

SELECT job_id,MAX(salary) m
FROM employees
WHERE commission_pct IS NOT NULL
GROUP BY job_id
HAVING m>6000
ORDER BY m ;

#7.按多个字段分组并排序

#案例：查询每个工种每个部门的最低工资,并按最低工资降序

SELECT MIN(salary),job_id,department_id
FROM employees
GROUP BY department_id,job_id   #顺序可以换
ORDER BY MIN(salary) DESC;

四、分组查询测试题

#1.查询各job_id的员工工资的最大值，最小值，平均值，总和，并按job_id升序

SELECT MAX(salary),MIN(salary),AVG(salary),SUM(salary),job_id
FROM employees
GROUP BY job_id
ORDER BY job_id;

#2.查询员工最高工资和最低工资的差距（DIFFERENCE）

SELECT MAX(salary)-MIN(salary) DIFFRENCE
FROM employees;

#3.查询各个管理者手下员工的最低工资，其中最低工资不能低于6000，没有管理者的员工不计算在内

SELECT MIN(salary),manager_id
FROM employees
WHERE manager_id IS NOT NULL
GROUP BY manager_id
HAVING MIN(salary)>=6000;

#4.查询所有部门的编号，员工数量和工资平均值,并按平均工资降序

SELECT department_id,COUNT(*),AVG(salary) a
FROM employees
GROUP BY department_id
ORDER BY a DESC;

#5.查询每个job_id的员工人数

SELECT COUNT(*) 个数,job_id
FROM employees
GROUP BY job_id;

进阶6：连接查询

一、含义：

又称多表查询，当查询的字段来自于多个表时，就会用到连接查询

select 字段1，字段2
from 表1，表2,...;

笛卡尔乘积现象：表1 有m行，表2有n行，结果=m*n行

当查询多个表时，没有添加有效的连接条件，导致多个表所有行实现完全连接

发生原因：没有有效的连接条件
如何避免：添加有效的连接条件

二、分类：

（1）按年代分类：
sql92标准:仅仅支持内连接

等值
非等值
自连接

也支持一部分外连接（用于oracle、sqlserver，mysql不支持）

   sql99标准【推荐】：支持内连接+外连接（左外和右外）+交叉连接
   内连接
           等值
           非等值
           自连接
     外连接
           左外
           右外
           全外（mysql不支持）
     交叉连接

   （2）按功能分类：
       内连接：
           等值连接
           非等值连接
           自连接
       外连接：
           左外连接
           右外连接
           全外连接

       交叉连接

SELECT * FROM beauty;

SELECT * FROM boys;


SELECT NAME,boyName FROM boys,beauty
WHERE beauty.boyfriend_id= boys.id;

三、sql92标准

1、等值连接

（1）语法

select 查询列表
   from 表1 别名,表2 别名
   where 表1.key=表2.key
   【and 筛选条件】
   【group by 分组字段】
   【having 分组后的筛选】
   【order by 排序字段】

（2）特点

① 多表等值连接的结果为多表的交集部分
②n表连接，至少需要n-1个连接条件
③ 多表的顺序没有要求，可以调换
④一般需要为表起别名
⑤可以搭配前面介绍的所有子句使用，比如排序、分组、筛选

（3）案例

#案例1：查询女神名和对应的男神名

SELECT NAME,boyName 
FROM boys,beauty
WHERE beauty.boyfriend_id= boys.id;

#案例2：查询员工名和对应的部门名

SELECT last_name,department_name
FROM employees,departments
WHERE employees.`department_id`=departments.`department_id`;

#2、为表起别名
/*
①提高语句的简洁度
②区分多个重名的字段

注意：如果为表起了别名，则查询的字段就不能使用原来的表名去限定

*/
#查询员工名、工种号、工种名

SELECT e.last_name,e.job_id,j.job_title
FROM employees  e,jobs j
WHERE e.`job_id`=j.`job_id`;

#3、两个表的顺序是否可以调换

#查询员工名、工种号、工种名

SELECT e.last_name,e.job_id,j.job_title
FROM jobs j,employees e
WHERE e.`job_id`=j.`job_id`;

#4、可以加筛选

#案例：查询有奖金的员工名、部门名

SELECT last_name,department_name,commission_pct

FROM employees e,departments d
WHERE e.`department_id`=d.`department_id`
AND e.`commission_pct` IS NOT NULL;

#案例2：查询城市名中第二个字符为o的部门名和城市名

SELECT department_name,city
FROM departments d,locations l
WHERE d.`location_id` = l.`location_id`
AND city LIKE '_o%';

#5、可以加分组

#案例1：查询每个城市的部门个数

SELECT COUNT(*) 个数,city
FROM departments d,locations l
WHERE d.`location_id`=l.`location_id`
GROUP BY city;

#案例2：查询有奖金的每个部门的部门名和部门的领导编号和该部门的最低工资

SELECT department_name,d.`manager_id`,MIN(salary)
FROM departments d,employees e
WHERE d.`department_id`=e.`department_id`
AND commission_pct IS NOT NULL
GROUP BY department_name,d.`manager_id`;

#6、可以加排序

#案例：查询每个工种的工种名和员工的个数，并且按员工个数降序

SELECT job_title,COUNT(*)
FROM employees e,jobs j
WHERE e.`job_id`=j.`job_id`
GROUP BY job_title
ORDER BY COUNT(*) DESC;

#7、可以实现三表连接？

#案例：查询员工名、部门名和所在的城市

SELECT last_name,department_name,city
FROM employees e,departments d,locations l
WHERE e.`department_id`=d.`department_id`
AND d.`location_id`=l.`location_id`
AND city LIKE 's%'

ORDER BY department_name DESC;

2、非等值连接

（1）语法：
   select 查询列表
   from 表1 别名,表2 别名
   where 非等值的连接条件
   【and 筛选条件】
   【group by 分组字段】
   【having 分组后的筛选】
   【order by 排序字段】

（2）案例
#案例1：查询员工的工资和工资级别

SELECT salary,grade_level
FROM employees e,job_grades g
WHERE salary BETWEEN g.`lowest_sal` AND g.`highest_sal`
AND g.`grade_level`='A';

select salary,employee_id from employees;
select * from job_grades;
CREATE TABLE job_grades
(grade_level VARCHAR(3),
 lowest_sal  int,
 highest_sal int);

INSERT INTO job_grades
VALUES ('A', 1000, 2999);

INSERT INTO job_grades
VALUES ('B', 3000, 5999);

INSERT INTO job_grades
VALUES('C', 6000, 9999);

INSERT INTO job_grades
VALUES('D', 10000, 14999);

INSERT INTO job_grades
VALUES('E', 15000, 24999);

INSERT INTO job_grades
VALUES('F', 25000, 40000);

3、自连接

（1）语法：
   select 查询列表
   from 表别名1,表别名2
   where 等值的连接条件
   【and 筛选条件】
   【group by 分组字段】
   【having 分组后的筛选】
   【order by 排序字段】

（2）案例：查询员工名和上级的名称

SELECT e.employee_id,e.last_name,m.employee_id,m.last_name
FROM employees e,employees m
WHERE e.`manager_id`=m.`employee_id`;

测试题2

一、显示员工表的最大工资，工资平均值

SELECT MAX(salary),AVG(salary)
FROM employees;

二、查询员工表的employee_id，job_id，last_name，按department_id降序，salary升序

SELECT employee_id,job_id,last_name
FROM employees
ORDER BY  department_id DESC,salary ASC;

三、查询员工表的job_id中包含a和e的，并且a在e的前面

SELECT job_id 
FROM employees
WHERE job_id LIKE '%a%e%';

四、已知表 student，里面有id（学号），NAME，gradeId（年级编号）
已知表grade，里面有id（年级编号），NAME（年级名）
已知表result，里面有id，score，studentNo（学号）
要求查询姓名，年级名，成绩

SELECT s.name,g.name,r.score
FROM student s,grade g,result r
WHERE s.id=r.studentNo
AND g.id=s.gradeId

五、显示当前日期，以及去前后空格，截取子字符串的函数

select now();
select trim('');
select substr(str,startIndex);
select substr(str,startIndex,length);

四、sql99语法

语法：

select 查询列表
    from 表1 别名
【连接类型】 join 表2 别名 #连接类型比如inner
     on 连接条件
    【where 筛选条件】
    【group by 分组】
    【having 筛选条件】
    【order by 排序列表】
分类：

1.内连接（★）：inner
2.外连接
   左外(★):left 【outer】
   右外(★)：right 【outer】
   全外：full【outer】
3.交叉连接：cross

1.内连接
（1）语法：
select 查询列表
from 表1 别名
【inner】 join 表2 别名 on 连接条件
where 筛选条件
group by 分组列表
having 分组后的筛选
order by 排序列表
limit 子句;

（2）分类：

等值连接
非等值连接
自连接

（3）特点：
①添加排序、分组、筛选
②inner可以省略
③ 筛选条件放在where后面，连接条件放在on后面，提高分离性，便于阅读
④inner join连接和sql92语法中的等值连接效果是一样的，都是查询多表的交集（内连接的结果=多表的交集）

⑤表的顺序可以调换

⑥n表连接至少需要n-1个连接条件

（4.1）等值连接案例
#案例1.查询员工名、部门名

SELECT last_name,department_name
FROM departments d
INNER JOIN  employees e
ON e.`department_id` = d.`department_id`;

或者

SELECT last_name,department_name
FROM employees e
INNER JOIN departments d
ON e.`department_id` = d.`department_id`;

#案例2.查询名字中包含e的员工名和工种名（添加筛选）

SELECT last_name,job_title
FROM employees e
INNER JOIN jobs j
ON e.`job_id`=  j.`job_id`
WHERE e.`last_name` LIKE '%e%';

#3. 查询部门个数>3的城市名和部门个数，（添加分组+筛选）

#①查询每个城市的部门个数
#②在①结果上筛选满足条件的

SELECT city,COUNT(*) 部门个数
FROM departments d
INNER JOIN locations l
ON d.`location_id`=l.`location_id`
GROUP BY city
HAVING COUNT(*)>3;

#案例4.查询哪个部门的员工个数>3的部门名和员工个数，并按个数降序（添加排序）

#①查询每个部门的员工个数

SELECT COUNT(*),department_name
FROM employees e
INNER JOIN departments d
ON e.`department_id`=d.`department_id`
GROUP BY department_name

#② 在①结果上筛选员工个数>3的记录，并排序

SELECT COUNT(*) 个数,department_name
FROM employees e
INNER JOIN departments d
ON e.`department_id`=d.`department_id`
GROUP BY department_name
HAVING COUNT(*)>3
ORDER BY COUNT(*) DESC;

#5.查询员工名、部门名、工种名，并按部门名降序（添加三表连接）

SELECT last_name,department_name,job_title
FROM employees e
INNER JOIN departments d ON e.`department_id`=d.`department_id`
INNER JOIN jobs j ON e.`job_id` = j.`job_id`

ORDER BY department_name DESC;

（4.2）非等值连接案例

#查询员工的工资级别

SELECT salary,grade_level
FROM employees e
 JOIN job_grades g
 ON e.`salary` BETWEEN g.`lowest_sal` AND g.`highest_sal`;

#查询工资级别的个数>20的个数，并且按工资级别降序

SELECT COUNT(*),grade_level
FROM employees e
JOIN job_grades g
ON e.`salary` BETWEEN g.`lowest_sal` AND g.`highest_sal`
GROUP BY grade_level
HAVING COUNT(*)>20
ORDER BY grade_level DESC;

（4.3）自连接案例

#查询员工的名字、上级的名字

 SELECT e.last_name,m.last_name
 FROM employees e
 JOIN employees m
 ON e.`manager_id`= m.`employee_id`;

#查询姓名中包含字符k的员工的名字、上级的名字

SELECT e.last_name,m.last_name
 FROM employees e
 JOIN employees m
 ON e.`manager_id`= m.`employee_id`
 WHERE e.`last_name` LIKE '%k%';

2.外连接

（1）应用场景：用于查询一个表中有，另一个表没有的记录
（2）语法：
select 查询列表
from 表1 别名
left|right|full【outer】 join 表2 别名 on 连接条件
where 筛选条件
group by 分组列表
having 分组后的筛选
order by 排序列表
limit 子句;
（3）特点：
1、外连接的查询结果=主表中的所有记录/所有行
   如果从表中有和它匹配的，则显示匹配的值/匹配行
   如果从表中没有和它匹配的，则显示null
   外连接查询结果=内连接结果+主表中有而从表没有的记录
2、左外连接，left join左边的是主表
右外连接，right join右边的是主表
full join 两边都是主表
3、左外和右外交换两个表的顺序，可以实现同样的效果
4、一般用于查询除了交集部分的剩余的不匹配的行
       全外连接=内连接的结果+表1中有但表2没有的+表2中有但表1没有的

#引入：查询男朋友不在男神表的女神名（首先默认所有女神都有男朋友，只是部分不在男神表）

SELECT * FROM beauty;
SELECT * FROM boys;

#左外连接
SELECT b.name,bo.*
FROM beauty b
LEFT OUTER JOIN boys bo
ON b.`boyfriend_id` = bo.`id`
WHERE bo.`id` IS NULL;

#右外连接
SELECT b.name,bo.*
FROM boys bo
RIGHT OUTER JOIN beauty b
ON b.`boyfriend_id` = bo.`id`
WHERE bo.`id` IS NULL;

先把王语嫣那个对应的男朋友ID改为NULL，然后查询那个男的没有女朋友

SELECT b.*,bo.*
FROM boys bo
LEFT OUTER JOIN beauty b
ON b.`boyfriend_id` = bo.`id`
WHERE b.`id` IS NULL;

结果是段誉

（4.1）左外连接案例

#案例：查询哪个部门没有员工
#左外

 SELECT d.*,e.employee_id
 FROM departments d
 LEFT OUTER JOIN employees e
 ON d.`department_id` = e.`department_id`
 WHERE e.`employee_id` IS NULL;

（4.2）右外连接案例

#案例：查询哪个部门没有员工
#右外

 SELECT d.*,e.employee_id
 FROM employees e
 RIGHT OUTER JOIN departments d
 ON d.`department_id` = e.`department_id`
 WHERE e.`employee_id` IS NULL;

（4.3）全外连接案例

USE girls;
 SELECT b.*,bo.*
 FROM beauty b
 FULL OUTER JOIN boys bo
 ON b.`boyfriend_id` = bo.id;

3.交叉连接

（1）语法：
select 查询列表
from 表1 别名
cross join 表2 别名;

（2）特点：
类似于笛卡尔乘积

SELECT b.*,bo.*
FROM beauty b
CROSS JOIN boys bo;

#sql92和 sql99 pk

功能：sql99支持的较多
可读性：sql99实现连接条件和筛选条件的分离，可读性较高

连接查询总结

SELECT <select_list>

FROM A

LEFT JOIN B

ON A.key=B.key

SELECT <select_list>

FROM A

INNER JOIN B

ON A.key=B.key

SELECT <select_list>

FROM A

RIGHT JOIN B

ON A.key=B.key

SELECT <select_list>

FROM A

LEFT JOIN B

ON A.key=B.key

WHERE B.key is null;

SELECT <select_list>

FROM A

RIGHT JOIN B

ON A.key=B.key

WHERE A.key is null;

SELECT <select_list>

FROM A

FULL JOIN B

ON A.key=B.key

SELECT <select_list>

FROM A

FULL JOIN B

ON A.key=B.key

WHERE A.key is null

OR B.key is null;

五.连接查询测试题

#1.显示所有员工的姓名，部门号和部门名称。

USE myemployees;

SELECT last_name,d.department_id,department_name
FROM employees e,departments d
WHERE e.`department_id` = d.`department_id`;

#2.查询90号部门员工的job_id和90号部门的location_id

SELECT job_id,location_id
FROM employees e,departments d
WHERE e.`department_id`=d.`department_id`
AND e.`department_id`=90;

#3. 选择所有有奖金的员工的

last_name , department_name , location_id , city

SELECT last_name , department_name , l.location_id , city
FROM employees e,departments d,locations l
WHERE e.department_id = d.department_id
AND d.location_id=l.location_id
AND e.commission_pct IS NOT NULL;

#4.选择city在Toronto工作的员工的

last_name , job_id , department_id , department_name

SELECT last_name , job_id , d.department_id , department_name 
FROM employees e,departments d ,locations l
WHERE e.department_id = d.department_id
AND d.location_id=l.location_id
AND city = 'Toronto';

#5.查询每个工种、每个部门的部门名、工种名和最低工资

SELECT department_name,job_title,MIN(salary) 最低工资
FROM employees e,departments d,jobs j
WHERE e.`department_id`=d.`department_id`
AND e.`job_id`=j.`job_id`
GROUP BY department_name,job_title;

#6.查询每个国家下的部门个数大于2的国家编号

SELECT country_id,COUNT(*) 部门个数
FROM departments d,locations l
WHERE d.`location_id`=l.`location_id`
GROUP BY country_id
HAVING 部门个数>2;

#7、选择指定员工的姓名，员工号，以及他的管理者的姓名和员工号，结果类似于下面的格式
employees Emp# manager Mgr#
kochhar 101 king 100

SELECT e.last_name employees,e.employee_id "Emp#",m.last_name manager,m.employee_id "Mgr#"
FROM employees e,employees m
WHERE e.manager_id = m.employee_id
AND e.last_name='kochhar';

六.外连接测试题

#1、查询编号>3的女神的男朋友信息，如果有则列出详细，如果没有，用null填充

SELECT b.id,b.name,bo.*
FROM beauty b
LEFT OUTER JOIN boys bo
ON b.`boyfriend_id` = bo.`id`
WHERE b.`id`>3;

#2、查询哪个城市没有部门

SELECT city
FROM departments d
RIGHT OUTER JOIN locations l 
ON d.`location_id`=l.`location_id`
WHERE  d.`department_id` IS NULL;

#3、查询部门名为SAL或IT的员工信息

SELECT e.*,d.department_name,d.`department_id`
FROM departments  d
LEFT JOIN employees e
ON d.`department_id` = e.`department_id`
WHERE d.`department_name` IN('SAL','IT');


SELECT * FROM departments
WHERE `department_name` IN('SAL','IT');

进阶7：子查询

一.含义：

嵌套在其他语句内部的select语句称为子查询或内查询，
外面的语句可以是insert、update、delete、select等，一般select作为外面语句较多
外面如果为select语句，则此语句称为外查询或主查询

三.案例介绍

（一）where或having后面
1、标量子查询（单行子查询）
2、列子查询（多行子查询）

3、行子查询（多列多行）#用的较少

特点：
①子查询放在小括号内
②子查询一般放在条件的右侧
③标量子查询，一般搭配着单行操作符使用
> < >= <= = <>

列子查询，一般搭配着多行操作符使用
in、any/some、all

④子查询的执行优先于主查询执行，主查询的条件用到了子查询的结果

1.标量子查询★

#引入案例：查询最低工资的员工姓名和工资

#①最低工资
select min(salary) from employees

#②查询员工的姓名和工资，要求工资=①
select last_name,salary
from employees
where salary=(
    select min(salary) from employees
);

#案例1：谁的工资比 Abel 高?

#①查询Abel的工资
SELECT salary
FROM employees
WHERE last_name = 'Abel'

#②查询员工的信息，满足 salary>①结果
SELECT *
FROM employees
WHERE salary>(

    SELECT salary
    FROM employees
    WHERE last_name = 'Abel'

);

#案例2：返回job_id与141号员工相同，salary比143号员工多的员工姓名，job_id 和工资

#①查询141号员工的job_id
SELECT job_id
FROM employees
WHERE employee_id = 141

#②查询143号员工的salary
SELECT salary
FROM employees
WHERE employee_id = 143

#③查询员工的姓名，job_id 和工资，要求job_id=①并且salary>②

SELECT last_name,job_id,salary
FROM employees
WHERE job_id = (
    SELECT job_id
    FROM employees
    WHERE employee_id = 141
) AND salary>(
    SELECT salary
    FROM employees
    WHERE employee_id = 143

);

#案例3：返回公司工资最少的员工的last_name,job_id和salary

#①查询公司的 最低工资
SELECT MIN(salary)
FROM employees

#②查询last_name,job_id和salary，要求salary=①
SELECT last_name,job_id,salary
FROM employees
WHERE salary=(
    SELECT MIN(salary)
    FROM employees
);

#案例4：查询最低工资大于50号部门最低工资的部门id和其最低工资

#①查询50号部门的最低工资
SELECT  MIN(salary)
FROM employees
WHERE department_id = 50

#②查询每个部门的最低工资

SELECT MIN(salary),department_id
FROM employees
GROUP BY department_id

#③ 在②基础上筛选，满足min(salary)>①
SELECT MIN(salary),department_id
FROM employees
GROUP BY department_id
HAVING MIN(salary)>(
    SELECT  MIN(salary)
    FROM employees
    WHERE department_id = 50


);

#非法使用标量子查询情况1

SELECT MIN(salary),department_id
FROM employees
GROUP BY department_id
HAVING MIN(salary)>(            #这里的>是单行操作符，要求下面的括号的查询结果是单行
    SELECT  salary              #这里的结果不是一行一列
    FROM employees
    WHERE department_id = 50   
);

#非法使用标量子查询情况2

SELECT MIN(salary),department_id
FROM employees
GROUP BY department_id
HAVING MIN(salary)>(            #这里的>是单行操作符，要求下面的括号的查询结果是单行
    SELECT  salary              
    FROM employees
    WHERE department_id = 250    #没有这个部门，这里的结果也不是一行一列
);

2.列子查询（多行子查询）★
#引入案例：查询所有是领导的员工姓名

#①查询所有员工的 manager_id
select manager_id
from employees

#②查询姓名，employee_id属于①列表的一个
select last_name
from employees
where employee_id in(
    select manager_id
    from employees
);

#案例1：返回location_id是1400或1700的部门中的所有员工姓名

#①查询location_id是1400或1700的部门编号
USE myemployees;
SELECT DISTINCT department_id
FROM departments
WHERE location_id IN(1400,1700)

#②查询员工姓名，要求部门号是①列表中的某一个
SELECT last_name
FROM employees
WHERE department_id IN(
	SELECT DISTINCT department_id
	FROM departments
	WHERE location_id IN(1400,1700)
);

#或
SELECT last_name
FROM employees
WHERE department_id =ANY(
	SELECT DISTINCT department_id
	FROM departments
	WHERE location_id IN(1400,1700)
);

#拓展如果是NOT IN可以替换为不等于ALL即<>ALL
SELECT last_name
FROM employees
WHERE department_id NOT IN(
	SELECT DISTINCT department_id
	FROM departments
	WHERE location_id IN(1400,1700)
);

SELECT last_name
FROM employees
WHERE department_id <>ALL(
	SELECT DISTINCT department_id
	FROM departments
	WHERE location_id IN(1400,1700)
);

#案例2：返回其它工种中比job_id为‘IT_PROG’工种任一工资低的员工的员工号、姓名、job_id 以及salary

#①查询job_id为‘IT_PROG’部门任一工资

SELECT DISTINCT salary
FROM employees
WHERE job_id = 'IT_PROG'

#②查询员工号、姓名、job_id 以及salary，salary<(①)的任意一个
SELECT last_name,employee_id,job_id,salary
FROM employees
WHERE salary<ANY(
    SELECT DISTINCT salary
    FROM employees
    WHERE job_id = 'IT_PROG'

) AND job_id<>'IT_PROG';

#或
SELECT last_name,employee_id,job_id,salary
FROM employees
WHERE salary<(
    SELECT MAX(salary)
    FROM employees
    WHERE job_id = 'IT_PROG'

) AND job_id<>'IT_PROG';

#案例3：返回其它部门中比job_id为‘IT_PROG’部门所有工资都低的员工的员工号、姓名、job_id 以及salary

SELECT last_name,employee_id,job_id,salary
FROM employees
WHERE salary<ALL(
    SELECT DISTINCT salary
    FROM employees
    WHERE job_id = 'IT_PROG'

) AND job_id<>'IT_PROG';

#或

SELECT last_name,employee_id,job_id,salary
FROM employees
WHERE salary<(
    SELECT MIN( salary)
    FROM employees
    WHERE job_id = 'IT_PROG'

) AND job_id<>'IT_PROG';

3、行子查询（结果集一行多列或多行多列）

#案例：查询员工编号最小并且工资最高的员工信息

SELECT * 
FROM employees
WHERE (employee_id,salary)=(
    SELECT MIN(employee_id),MAX(salary)
    FROM employees
);

 

#①查询最小的员工编号
SELECT MIN(employee_id)
FROM employees


#②查询最高工资
SELECT MAX(salary)
FROM employees


#③查询员工信息
SELECT *
FROM employees
WHERE employee_id=(
    SELECT MIN(employee_id)
    FROM employees
)AND salary=(
    SELECT MAX(salary)
    FROM employees

);

（二）select后面
（）内仅仅支持标量子查询

#案例：查询每个部门的员工个数

SELECT d.*,(

    SELECT COUNT(*)
    FROM employees e
    WHERE e.department_id = d.`department_id`
 ) 个数
 FROM departments d;

#案例2：查询员工号=102的部门名

SELECT (
    SELECT department_name,e.department_id
    FROM departments d
    INNER JOIN employees e
    ON d.department_id=e.department_id
    WHERE e.employee_id=102
    
) 部门名;

（三）from后面

将子查询结果充当一张表，要求必须起别名

#案例：查询每个部门的平均工资的工资等级

#①查询每个部门的平均工资
SELECT AVG(salary),department_id
FROM employees
GROUP BY department_id


SELECT * FROM job_grades;


#②连接①的结果集和job_grades表，筛选条件平均工资 between lowest_sal and highest_sal

SELECT  ag_dep.*,g.`grade_level`
FROM (
    SELECT AVG(salary) ag,department_id
    FROM employees
    GROUP BY department_id
) ag_dep
INNER JOIN job_grades g
ON ag_dep.ag BETWEEN lowest_sal AND highest_sal;

四、exists后面（相关子查询）
语法：
exists(完整的查询语句)
结果：
1或0

#引入：

SELECT EXISTS(SELECT employee_id FROM employees WHERE salary=300000);

#案例1：查询有员工的部门名

#in
SELECT department_name
FROM departments d
WHERE d.`department_id` IN(
    SELECT department_id
    FROM employees

)

#exists

SELECT department_name
FROM departments d
WHERE EXISTS(
    SELECT *
    FROM employees e
    WHERE d.`department_id`=e.`department_id`


);

#案例2：查询没有女朋友的男神信息

#in

SELECT bo.*
FROM boys bo
WHERE bo.id NOT IN(
    SELECT boyfriend_id
    FROM beauty
)

#exists
SELECT bo.*
FROM boys bo
WHERE NOT EXISTS(
    SELECT boyfriend_id
    FROM beauty b
    WHERE bo.`id`=b.`boyfriend_id`

);

四.子查询测试题

#1. 查询和Zlotkey相同部门的员工姓名和工资

#①查询Zlotkey的部门
SELECT department_id
FROM employees
WHERE last_name = 'Zlotkey'

#②查询部门号=①的姓名和工资
SELECT last_name,salary
FROM employees
WHERE department_id = (
    SELECT department_id
    FROM employees
    WHERE last_name = 'Zlotkey'
)

#2.查询工资比公司平均工资高的员工的员工号，姓名和工资。

#①查询平均工资
SELECT AVG(salary)
FROM employees

#②查询工资>①的员工号，姓名和工资。

SELECT last_name,employee_id,salary
FROM employees
WHERE salary>(
    SELECT AVG(salary)
    FROM employees
);

#3.查询各部门中工资比本部门平均工资高的员工的员工号, 姓名和工资

#①查询各部门的平均工资
SELECT AVG(salary),department_id
FROM employees
GROUP BY department_id

#②连接①结果集和employees表，进行筛选
SELECT employee_id,last_name,salary,e.department_id
FROM employees e
INNER JOIN (
    SELECT AVG(salary) ag,department_id
    FROM employees
    GROUP BY department_id
) ag_dep
ON e.department_id = ag_dep.department_id
WHERE salary>ag_dep.ag ;

#4. 查询和姓名中包含字母u的员工在相同部门的员工的员工号和姓名

#①查询姓名中包含字母u的员工的部门

SELECT  DISTINCT department_id
FROM employees
WHERE last_name LIKE '%u%'

#②查询部门号=①中的任意一个的员工号和姓名
SELECT last_name,employee_id
FROM employees
WHERE department_id IN(
    SELECT  DISTINCT department_id
    FROM employees
    WHERE last_name LIKE '%u%'
);

#5. 查询在部门的location_id为1700的部门工作的员工的员工号

#①查询location_id为1700的部门

SELECT DISTINCT department_id
FROM departments 
WHERE location_id  = 1700


#②查询部门号=①中的任意一个的员工号
SELECT employee_id
FROM employees
WHERE department_id =ANY(
    SELECT DISTINCT department_id
    FROM departments 
    WHERE location_id  = 1700
);

#6.查询管理者是King的员工姓名和工资

#①查询姓名为king的员工编号
SELECT employee_id
FROM employees
WHERE last_name  = 'K_ing'

#②查询哪个员工的manager_id = ①
SELECT last_name,salary
FROM employees
WHERE manager_id IN(
    SELECT employee_id
    FROM employees
    WHERE last_name  = 'K_ing'
);

#7.查询工资最高的员工的姓名，要求first_name和last_name显示为一列，列名为姓.名

#①查询最高工资
SELECT MAX(salary)
FROM employees

#②查询工资=①的姓.名

SELECT CONCAT(first_name,last_name) "姓.名"
FROM employees
WHERE salary=(
    SELECT MAX(salary)
    FROM employees
);

进阶8：分页查询 ★

一.应用场景：

当要显示的数据，一页显示不全，需要分页提交sql请求

二.语法：

7 select 查询列表
1 from 表
2【join type join 表2
3 on 连接条件
4 where 筛选条件
5 group by 分组字段
6 having 分组后的筛选
8 order by 排序的字段】
9 limit 【offset,】size;
（上边数字是执行顺序）
offset要显示条目的起始索引（起始索引从0开始）
size 要显示的条目个数

三.特点：

①limit语句放在查询语句的最后
   ②公式
如果要显示的页数 page，每页的条目数size
   select 查询列表
   from 表
   limit (page-1)*size,size;

eg.

    size=10
   page
   1   0
   2    10
   3   20

四.案例

#案例1：查询前五条员工信息

SELECT * FROM  employees LIMIT 0,5;
SELECT * FROM  employees LIMIT 5;

#案例2：查询第11条——第25条

SELECT * FROM  employees LIMIT 10,15;

#案例3：有奖金的员工信息，并且工资较高的前10名显示出来

SELECT 
    * 
FROM
    employees 
WHERE commission_pct IS NOT NULL 
ORDER BY salary DESC 
LIMIT 10 ;

测试题3

已知表 stuinfo
id学号
name 姓名
email 邮箱john@126.com
gradeId 年级编号
sex 性别男女
age年龄

已知表 grade
id 年级编号
gradeName 年级名称

一、查询所有学员的邮箱的用户名（注：邮箱中@前面的字符）

select substr(email,1,instr(email,'@')-1) 用户名
from stuinfo;

二、查询男生和女生的个数

select count(*) 个数,sex
from stuinfo
group by sex;

三、查询年龄>18岁的所有学生的姓名和年级名称

select name,gradeName
from stuinfo s
inner join grade g on s.gradeId = g.id
where age>18;

四、查询哪个年级的学生最小年龄>20岁

#1每个年级的最小年龄
select min(age),gradeId
from stuinfo
group by gradeId

#2在1的结果上筛选
select min(age),gradeId
from stuinfo
group by gradeId
having min(age)>20;

五、试说出查询语句中涉及到的所有的关键字，以及执行先后顺序

7 select 查询列表
1 from 表
2 连接类型 join 表2
3 on 连接条件
4 where 筛选条件
5 group by 分组列表
6 having 分组后的筛选
8 order by 排序列表
9 limit 偏移，条目数

子查询经典案例

1. 查询工资最低的员工信息: last_name, salary

#①查询最低的工资
SELECT MIN(salary)
FROM employees

#②查询last_name,salary，要求salary=①
SELECT last_name,salary
FROM employees
WHERE salary=(
    SELECT MIN(salary)
    FROM employees
);

2. 查询平均工资最低的部门信息

#方式一：
#①各部门的平均工资
SELECT AVG(salary),department_id
FROM employees
GROUP BY department_id
#②查询①结果上的最低平均工资
SELECT MIN(ag)
FROM (
    SELECT AVG(salary) ag,department_id
    FROM employees
    GROUP BY department_id
) ag_dep

#③查询哪个部门的平均工资=②

SELECT AVG(salary),department_id
FROM employees
GROUP BY department_id
HAVING AVG(salary)=(
    SELECT MIN(ag)
    FROM (
        SELECT AVG(salary) ag,department_id
        FROM employees
        GROUP BY department_id
    ) ag_dep

);

#④查询部门信息

SELECT d.*
FROM departments d
WHERE d.`department_id`=(
    SELECT department_id
    FROM employees
    GROUP BY department_id
    HAVING AVG(salary)=(
        SELECT MIN(ag)
        FROM (
            SELECT AVG(salary) ag,department_id
            FROM employees
            GROUP BY department_id
        ) ag_dep

    )

);

#方式二：
#①各部门的平均工资
SELECT AVG(salary),department_id
FROM employees
GROUP BY department_id

#②求出最低平均工资的部门编号
SELECT department_id
FROM employees
GROUP BY department_id
ORDER BY AVG(salary) 
LIMIT 1;

#③查询部门信息
SELECT *
FROM departments
WHERE department_id=(
    SELECT department_id
    FROM employees
    GROUP BY department_id
    ORDER BY AVG(salary) 
    LIMIT 1
);

3. 查询平均工资最低的部门信息和该部门的平均工资

#①各部门的平均工资
SELECT AVG(salary),department_id
FROM employees
GROUP BY department_id
#②求出最低平均工资的部门编号
SELECT AVG(salary),department_id
FROM employees
GROUP BY department_id
ORDER BY AVG(salary) 
LIMIT 1;
#③查询部门信息
SELECT d.*,ag
FROM departments d
JOIN (
    SELECT AVG(salary) ag,department_id
    FROM employees
    GROUP BY department_id
    ORDER BY AVG(salary) 
    LIMIT 1

) ag_dep
ON d.`department_id`=ag_dep.department_id;

4. 查询平均工资最高的 job 信息

#①查询最高的job的平均工资
SELECT AVG(salary),job_id
FROM employees
GROUP BY job_id
ORDER BY AVG(salary) DESC
LIMIT 1

#②查询job信息
SELECT * 
FROM jobs
WHERE job_id=(
    SELECT job_id
    FROM employees
    GROUP BY job_id
    ORDER BY AVG(salary) DESC
    LIMIT 1

);

5. 查询平均工资高于公司平均工资的部门有哪些?

#①查询平均工资
SELECT AVG(salary)
FROM employees

#②查询每个部门的平均工资
SELECT AVG(salary),department_id
FROM employees
GROUP BY department_id

#③筛选②结果集，满足平均工资>①

SELECT AVG(salary),department_id
FROM employees
GROUP BY department_id
HAVING AVG(salary)>(
    SELECT AVG(salary)
    FROM employees
);

6. 查询出公司中所有 manager 的详细信息.

#①查询所有manager的员工编号
SELECT DISTINCT manager_id
FROM employees

#②查询详细信息，满足employee_id=①
SELECT *
FROM employees
WHERE employee_id =ANY(
    SELECT DISTINCT manager_id
    FROM employees
);

7. 各个部门中最高工资中最低的那个部门的最低工资是多少

#①查询各部门的最高工资中最低的部门编号
SELECT department_id
FROM employees
GROUP BY department_id
ORDER BY MAX(salary)
LIMIT 1


#②查询①结果的那个部门的最低工资

SELECT MIN(salary) ,department_id
FROM employees
WHERE department_id=(
    SELECT department_id
    FROM employees
    GROUP BY department_id
    ORDER BY MAX(salary)
    LIMIT 1
);

8. 查询平均工资最高的部门的 manager 的详细信息: last_name, department_id, email, salary

#①查询平均工资最高的部门编号
SELECT 
    department_id 
FROM
    employees 
GROUP BY department_id 
ORDER BY AVG(salary) DESC 
LIMIT 1 

#②将employees和departments连接查询，筛选条件是①
    SELECT 
        last_name, d.department_id, email, salary 
    FROM
        employees e 
        INNER JOIN departments d 
            ON d.manager_id = e.employee_id 
    WHERE d.department_id = 
        (SELECT 
            department_id 
        FROM
            employees 
        GROUP BY department_id 
        ORDER BY AVG(salary) DESC 
        LIMIT 1) ;

作业讲解

先导入student.sql

#一、查询每个专业的学生人数

SELECT majorid,COUNT(*)
FROM student
GROUP BY majorid;

#二、查询参加考试的学生中，每个学生的平均分、最高分

SELECT AVG(score),MAX(score),studentno
FROM result
GROUP BY studentno;

#三、查询姓张的每个学生的最低分大于60的学号、姓名

SELECT s.studentno,s.`studentname`,MIN(score)
FROM student s
JOIN result r
ON s.`studentno`=r.`studentno`
WHERE s.`studentname` LIKE '张%'
GROUP BY s.`studentno`
HAVING MIN(score)>60;

#四、查询生日在“1988-1-1”后的学生姓名、专业名称

SELECT m.`majorname`,s.`studentname`
FROM student s
JOIN major m
ON m.`majorid`=s.`majorid`
WHERE DATEDIFF(borndate,'1988-1-1')>0
GROUP BY m.`majorid`;

#五、查询每个专业的男生人数和女生人数分别是多少

#方式1
SELECT COUNT(*),sex,majorid
FROM student
GROUP BY sex,majorid;

#方式2
SELECT majorid,
(SELECT COUNT(*) FROM student WHERE SEX='男' AND majorid=s.majorid) 男,
(SELECT COUNT(*) FROM student WHERE SEX='女' AND majorid=s.majorid) 女
FROM student s
GROUP BY majorid;

#六、查询专业和张翠山一样的学生的最低分

#①查询张翠山的专业编号
SELECT majorid
FROM student
WHERE studentname = '张翠山'

#②查询编号=①的所有学生编号
SELECT studentno
FROM student
WHERE majorid=(
    SELECT majorid
    FROM student
    WHERE studentname = '张翠山'

)
#③查询最低分
SELECT MIN(score)
FROM result
WHERE studentno IN(

    SELECT studentno
    FROM student
    WHERE majorid=(
        SELECT majorid
        FROM student
        WHERE studentname = '张翠山'
    )
)

#七、查询大于60分的学生的姓名、密码、专业名

SELECT studentname,loginpwd,majorname
FROM student s
JOIN major m ON s.majorid=  m.majorid
JOIN result r ON s.studentno=r.studentno
WHERE r.score>60;

#八、按邮箱位数分组，查询每组的学生个数

SELECT COUNT(*),LENGTH(email)
FROM student
GROUP BY LENGTH(email);

#九、查询学生名、专业名、分数

SELECT studentname,score,majorname
FROM student s
JOIN major m ON s.majorid=  m.majorid
LEFT JOIN result r ON s.studentno=r.studentno

#十、查询哪个专业没有学生，分别用左连接和右连接实现

#左
SELECT m.`majorid`,m.`majorname`,s.`studentno`
FROM major m
LEFT JOIN student s ON m.`majorid` = s.`majorid`
WHERE s.`studentno` IS NULL;

#右
SELECT m.`majorid`,m.`majorname`,s.`studentno`
FROM student s
RIGHT JOIN  major m ON m.`majorid` = s.`majorid`
WHERE s.`studentno` IS NULL;

#十一、查询没有成绩的学生人数

#查询没有成绩的学生
SELECT s.*,r.id
FROM student s
LEFT JOIN result r ON s.`studentno` = r.`studentno`
WHERE r.`id` IS NULL

#查询没有成绩的学生人数
SELECT COUNT(*)
FROM student s
LEFT JOIN result r ON s.`studentno` = r.`studentno`
WHERE r.`id` IS NULL

进阶9：联合查询

一.含义：

union：联合合并将多条查询语句的结果合并成一个结果

二.语法：

查询语句1
union 【all】
查询语句2
union 【all】
...

三.应用场景：

1、将一条比较复杂的查询语句拆分成多条语句
2、适用于查询多个表的时候，查询的列基本是一致

即要查询的结果来自于多个表，且多个表没有直接的连接关系，但查询的信息一致时

四.特点：★

1、要求多条查询语句的查询列数是一致的！
2、要求多条查询语句的查询的每一列的类型和顺序最好一致
3、union关键字默认去重，如果使用union all 可以包含重复项

五.案例

#引入的案例：查询部门编号>90或邮箱包含a的员工信息

SELECT * FROM employees WHERE email LIKE '%a%' OR department_id>90;;

SELECT * FROM employees  WHERE email LIKE '%a%'
UNION
SELECT * FROM employees  WHERE department_id>90;

#案例：查询中国用户中男性的信息以及外国用户中年男性的用户信息

SELECT id,cname FROM t_ca WHERE csex='男'
UNION ALL
SELECT t_id,tname FROM t_ua WHERE tGender='male';

查询总结

语法：
select 查询列表 ⑦
from 表1 别名 ①
连接类型 join 表2 ②
on 连接条件 ③
where 筛选 ④
group by 分组列表 ⑤
having 筛选 ⑥
order by排序列表 ⑧
limit 起始条目索引，条目数; ⑨

WhyNotZero_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2.DQL语言

#进阶1：基础查询/*语法：select 查询列表 from 表名;类似于：System.out.println(打印东西);特点：1、查询列表可以是：表中的字段、常量值、表达式、函数2、查询的结果是一个虚拟的表格*/USE myemployees;#1.查询表中的单个字段SELECT last_name FROM employees;#2.查询表中的多个字段SELECT last_name,salary,email FROM employees;#3.查询表
复制链接

扫一扫