第六章：决胜秋招
Section A
练习一: 各部门工资最高的员工（难度：中等）
创建Employee 表，包含所有员工信息，每个员工有其对应的 Id, salary 和 department Id。
+----+-------+--------+--------------+
| Id | Name | Salary | DepartmentId |
+----+-------+--------+--------------+
| 1 | Joe | 70000 | 1 |
| 2 | Henry | 80000 | 2 |
| 3 | Sam | 60000 | 2 |
| 4 | Max | 90000 | 1 |
+----+-------+--------+--------------+
CREATE TABLE Employee
(id INT NOT NULL ,
name VARCHAR(50) NOT NULL ,
salary INT NOT NULL ,
departmentid INT NOT NULL ,
PRIMARY KEY (id));
INSERT INTO Employee VALUES(1,'Joe',70000,1);
INSERT INTO Employee VALUES(2,'Henry',80000,2);
INSERT INTO Employee VALUES(3,'Sam',60000,2);
INSERT INTO Employee VALUES(4,'Max',90000,1);
SELECT * FROM Employee;
创建Department 表，包含公司所有部门的信息。
+----+----------+
| Id | Name |
+----+----------+
| 1 | IT |
| 2 | Sales |
+----+----------+
CREATE TABLE Department
(id INT NOT NULL ,
name VARCHAR(50) NOT NULL ,
PRIMARY KEY (id));
INSERT INTO Department VALUES(1,'IT');
INSERT INTO Department VALUES(2,'Sales');
SELECT * FROM Department ;
编写一个 SQL 查询，找出每个部门工资最高的员工。例如，根据上述给定的表格，Max 在 IT 部门有最高工资，Henry 在 Sales 部门有最高工资。
+------------+----------+--------+
| Department | Employee | Salary |
+------------+----------+--------+
| IT | Max | 90000 |
| Sales | Henry | 80000 |
+------------+----------+--------+
SELECT
a.department, ee.name , ee.salary
FROM
(
SELECT MAX(e.salary) as salary, d.name as department, e.departmentid
FROM employee e
LEFT JOIN department d on e.departmentid = d.id
GROUP BY d.name
)a
LEFT JOIN employee ee on ee.salary = a.salary and ee.departmentid = a.departmentid
练习二: 换座位（难度：中等）
小美是一所中学的信息科技老师，她有一张 seat 座位表，平时用来储存学生名字和与他们相对应的座位 id。
其中纵列的id是连续递增的
小美想改变相邻俩学生的座位。
你能不能帮她写一个 SQL query 来输出小美想要的结果呢？
请创建如下所示seat表：
示例：
+---------+---------+
| id | student |
+---------+---------+
| 1 | Abbot |
| 2 | Doris |
| 3 | Emerson |
| 4 | Green |
| 5 | Jeames |
+---------+---------+
CREATE TABLE seat
(id INT NOT NULL ,
student VARCHAR(20) NOT NULL ,
PRIMARY KEY (id));
INSERT INTO seat VALUES(1,'Abbot');
INSERT INTO seat VALUES(2,'Doris');
INSERT INTO seat VALUES(3,'Emerson');
INSERT INTO seat VALUES(4,'Green');
INSERT INTO seat VALUES(5,'Jeames');
SELECT * FROM seat;
假如数据输入的是上表，则输出结果如下：
+---------+---------+
| id | student |
+---------+---------+
| 1 | Doris |
| 2 | Abbot |
| 3 | Green |
| 4 | Emerson |
| 5 | Jeames |
+---------+---------+
注意：
如果学生人数是奇数，则不需要改变最后一个同学的座位。
SELECT
CASE WHEN id = (SELECT MAX(id) FROM seat) THEN id
WHEN MOD(id,2)=1 THEN id+1
WHEN MOD(id,2)=0 THEN id-1
ELSE NULL END AS id,
student
FROM seat
ORDER BY id;
练习三: 分数排名（难度：中等）
假设在某次期末考试中，二年级四个班的平均成绩分别是 93、93、93、91。
+-------+-----------+
| class | score_avg |
+-------+-----------+
| 1 | 93 |
| 2 | 93 |
| 3 | 93 |
| 4 | 91 |
+-------+-----------+
CREATE TABLE score
(class INT NOT NULL ,
score_avg INT NOT NULL ,
PRIMARY KEY (class));
INSERT INTO score VALUES(1, 93);
INSERT INTO score VALUES(2, 93);
INSERT INTO score VALUES(3, 93);
INSERT INTO score VALUES(4, 91);
SELECT * FROM score;
目前有如下三种排序结果，请根据查询结果书写出查询用 sql
+-------+-----------+-------+-------+-------+
| class | score_avg | rank1 | rank2 | rank3 |
+-------+-----------+-------+-------+-------+
| 1 | 93 | 1 | 1 | 1 |
| 2 | 93 | 1 | 1 | 2 |
| 3 | 93 | 1 | 1 | 3 |
| 4 | 91 | 4 | 2 | 4 |
+-------+-----------+-------+-------+-------+
SELECT
class,
score_avg,
RANK() OVER (ORDER BY score_avg DESC) AS rank1,
DENSE_RANK() OVER (ORDER BY score_avg DESC) AS rank2,
ROW_NUMBER() OVER (ORDER BY score_avg DESC) AS rank3
FROM score;
练习四：连续出现的数字（难度：中等）
编写一个 SQL 查询，查找所有至少连续出现三次的数字。
+----+-----+
| Id | Num |
+----+-----+
| 1 | 1 |
| 2 | 1 |
| 3 | 1 |
| 4 | 2 |
| 5 | 1 |
| 6 | 2 |
| 7 | 2 |
+----+-----+
CREATE TABLE logs
(id INT NOT NULL ,
num INT NOT NULL ,
PRIMARY KEY (id));
INSERT INTO logs VALUES (1, 1);
INSERT INTO logs VALUES (2, 1);
INSERT INTO logs VALUES (3, 1);
INSERT INTO logs VALUES (4, 2);
INSERT INTO logs VALUES (5, 1);
INSERT INTO logs VALUES (6, 2);
INSERT INTO logs VALUES (7, 2);
SELECT * FROM logs;
例如，给定上面的 Logs 表， 1 是唯一连续出现至少三次的数字。
+-----------------+
| ConsecutiveNums |
+-----------------+
| 1 |
+-----------------+
SELECT DISTINCT a.num AS ConsecutiveNums
FROM
LOGS a, LOGS b, LOGS c
WHERE
a.id = b.id - 1 AND b.id = c.id - 1 AND a.num = b.num AND b.num = c.num;
练习五：树节点 （难度：中等）
对于tree表，id是树节点的标识，p_id是其父节点的id。
+----+------+
| id | p_id |
+----+------+
| 1 | null |
| 2 | 1 |
| 3 | 1 |
| 4 | 2 |
| 5 | 2 |
+----+------+
每个节点都是以下三种类型中的一种：
- Root: 如果节点是根节点。
- Leaf: 如果节点是叶子节点。
- Inner: 如果节点既不是根节点也不是叶子节点。
CREATE TABLE tree
(id INT NOT NULL ,
p_id INT ,
PRIMARY KEY (id));
INSERT INTO tree VALUES (1, null);
INSERT INTO tree VALUES (2, 1);
INSERT INTO tree VALUES (3, 1);
INSERT INTO tree VALUES (4, 2);
INSERT INTO tree VALUES (5, 2);
SELECT * FROM tree;
写一条查询语句打印节点id及对应的节点类型。按照节点id排序。上面例子的对应结果为：
+----+------+
| id | Type |
+----+------+
| 1 | Root |
| 2 | Inner|
| 3 | Leaf |
| 4 | Leaf |
| 5 | Leaf |
+----+------+
说明
- 节点’1’是根节点，因为它的父节点为NULL，有’2’和’3’两个子节点。
- 节点’2’是内部节点，因为它的父节点是’1’，有子节点’4’和’5’。
- 节点’3’，‘4’，'5’是叶子节点，因为它们有父节点但没有子节点。
下面是树的图形：
1
/ \
2 3
/ \
4 5
注意
如果一个树只有一个节点，只需要输出根节点属性。
SELECT id,
CASE WHEN p_id IS NULL THEN 'Root'
WHEN id IN (SELECT p_id FROM tree) THEN 'Inner'
ELSE 'Leaf' END AS Type
FROM tree;
练习六：至少有五名直接下属的经理 （难度：中等）
Employee表包含所有员工及其上级的信息。每位员工都有一个Id，并且还有一个对应主管的Id（ManagerId）。
+------+----------+-----------+----------+
|Id |Name |Department |ManagerId |
+------+----------+-----------+----------+
|101 |John |A |null |
|102 |Dan |A |101 |
|103 |James |A |101 |
|104 |Amy |A |101 |
|105 |Anne |A |101 |
|106 |Ron |B |101 |
+------+----------+-----------+----------+
CREATE TABLE Employee2
(id INT NOT NULL ,
name varchar(20) NOT NULL ,
department varchar(20),
managerid INT,
PRIMARY KEY (id));
INSERT INTO Employee2 VALUES (101, 'John', 'A', null);
INSERT INTO Employee2 VALUES (102, 'Dan', 'A', 101);
INSERT INTO Employee2 VALUES (103, 'James', 'A', 101);
INSERT INTO Employee2 VALUES (104, 'Amy', 'A', 101);
INSERT INTO Employee2 VALUES (105, 'Anne', 'A', 101);
INSERT INTO Employee2 VALUES (106, 'Ron', 'B', 101);
SELECT * FROM Employee2;
针对Employee表，写一条SQL语句找出有5个下属的主管。对于上面的表，结果应输出：
+-------+
| Name |
+-------+
| John |
+-------+
注意:
没有人向自己汇报。
SELECT e1.NAME
FROM Employee2 e1
JOIN (
SELECT managerid
FROM Employee2
GROUP BY managerid
HAVING count(id) = 5
) t1
ON e1.id = t1.managerid;
练习七：查询回答率最高的问题 （难度：中等）
求出survey_log表中回答率最高的问题，表格的字段有：uid, action, question_id, answer_id, q_num, timestamp。
uid是用户id；action的值为：“show”， “answer”， “skip”；当action是"answer"时，answer_id不为空，相反，当action是"show"和"skip"时为空（null）；q_num是问题的数字序号。
写一条sql语句找出回答率（show 出现次数 / answer 出现次数）最高的 question_id。
举例：
输入
| uid | action | question_id | answer_id | q_num | timestamp |
|---|---|---|---|---|---|
| 5 | show | 285 | null | 1 | 123 |
| 5 | answer | 285 | 124124 | 1 | 124 |
| 5 | show | 369 | null | 2 | 125 |
| 5 | skip | 369 | null | 2 | 126 |
输出
| question_id |
|---|
| 285 |
说明
问题285的回答率为1/1，然而问题369的回答率是0/1，所以输出是285。
注意：
最高回答率的意思是：同一个问题出现的次数中回答的比例。
CREATE TABLE survey_log (
uid INT,
action VARCHAR (20),
question_id INT,
answer_id INT,
q_num INT,
TIMESTAMP INT
);
INSERT INTO survey_log VALUES (5, 'show', 285, NULL, 1, 123);
INSERT INTO survey_log VALUES (5, 'answer', 285, 124124, 1, 124);
INSERT INTO survey_log VALUES (5, 'show', 369, NULL, 2, 125);
INSERT INTO survey_log VALUES (5, 'skip', 369, NULL, 2, 126);
SELECT * FROM survey_log;
SELECT a.question_id
FROM (
SELECT question_id,
sum(CASE WHEN answer_id IS NOT NULL THEN 1 ELSE 0 END) / sum(CASE WHEN action = 'show' THEN 1 ELSE 0 END) AS ratio
FROM survey_log
GROUP BY question_id
ORDER BY ratio DESC
LIMIT 1) a;
练习八：各部门前3高工资的员工（难度：中等）
将练习一中的 employee 表清空，重新插入以下数据（也可以复制练习一中的 employee 表，再插入第5、第6行数据）：
+----+-------+--------+--------------+
| Id | Name | Salary | DepartmentId |
+----+-------+--------+--------------+
| 1 | Joe | 70000 | 1 |
| 2 | Henry | 80000 | 2 |
| 3 | Sam | 60000 | 2 |
| 4 | Max | 90000 | 1 |
| 5 | Janet | 69000 | 1 |
| 6 | Randy | 85000 | 1 |
+----+-------+--------+--------------+
编写一个 SQL 查询，找出每个部门工资前三高的员工。例如，根据上述给定的表格，查询结果应返回：
+------------+----------+--------+
| Department | Employee | Salary |
+------------+----------+--------+
| IT | Max | 90000 |
| IT | Randy | 85000 |
| IT | Joe | 70000 |
| Sales | Henry | 80000 |
| Sales | Sam | 60000 |
+------------+----------+--------+
此外，请考虑实现各部门前N高工资的员工功能。
-- 建表语句
CREATE TABLE employee9 SELECT * FROM employee;
SELECT * FROM employee9;
INSERT INTO employee9 VALUES(5, 'Janet', 69000, 1);
INSERT INTO employee9 VALUES(6, 'Randy', 85000, 1);
SELECT * FROM employee9 ;
-- 窗口函数解法
SELECT t.department, t.employee, t.salary
FROM(
SELECT d.name AS department, e.name AS employee, e.salary,
DENSE_RANK() OVER ( PARTITION BY d.name ORDER BY e.salary) AS rankn
FROM employee9 e
JOIN department d
ON e.departmentid = d.id) t
WHERE t.rankn <= 3
ORDER BY department, salary DESC;
练习九：平面上最近距离 (难度: 困难）
point_2d表包含一个平面内一些点（超过两个）的坐标值（x，y）。
写一条查询语句求出这些点中的最短距离并保留2位小数。
|x | y |
|----|----|
| -1 | -1 |
| 0 | 0 |
| -1 | -2 |
最短距离是1，从点（-1，-1）到点（-1，-2）。所以输出结果为：
| shortest |
1.00
+--------+
|shortest|
+--------+
|1.00 |
+--------+
**注意：**所有点的最大距离小于10000。
-- 建表语句
-- 建表语句
DROP TABLE IF EXISTS point_2d;
CREATE TABLE point_2d (
x INT,
y INT
);
INSERT INTO point_2d VALUES(-1, -1);
INSERT INTO point_2d VALUES( 0, 0);
INSERT INTO point_2d VALUES(-1, -2);
SELECT * FROM point_2d;
SELECT
MIN(ROUND(POW(POW(ABS(p1.x-p2.x),2)+POW(ABS(p1.y-p2.y),2),0.5),2)) AS shortest
FROM point_2d p1
JOIN point_2d p2
ON p1.x!=p2.x
OR p1.y!=p2.y;
练习十：行程和用户（难度：困难）
Trips 表中存所有出租车的行程信息。每段行程有唯一键 Id，Client_Id 和 Driver_Id 是 Users 表中 Users_Id 的外键。Status 是枚举类型，枚举成员为 (‘completed’, ‘cancelled_by_driver’, ‘cancelled_by_client’)。
| Id | Client_Id | Driver_Id | City_Id | Status | Request_at |
|---|---|---|---|---|---|
| 1 | 1 | 10 | 1 | completed | 2013-10-1 |
| 2 | 2 | 11 | 1 | cancelled_by_driver | 2013-10-1 |
| 3 | 3 | 12 | 6 | completed | 2013-10-1 |
| 4 | 4 | 13 | 6 | cancelled_by_client | 2013-10-1 |
| 5 | 1 | 10 | 1 | completed | 2013-10-2 |
| 6 | 2 | 11 | 6 | completed | 2013-10-2 |
| 7 | 3 | 12 | 6 | completed | 2013-10-2 |
| 8 | 2 | 12 | 12 | completed | 2013-10-3 |
| 9 | 3 | 10 | 12 | completed | 2013-10-3 |
| 10 | 4 | 13 | 12 | cancelled_by_driver | 2013-10-3 |
Users 表存所有用户。每个用户有唯一键 Users_Id。Banned 表示这个用户是否被禁止，Role 则是一个表示（‘client’, ‘driver’, ‘partner’）的枚举类型。
+----------+--------+--------+
| Users_Id | Banned | Role |
+----------+--------+--------+
| 1 | No | client |
| 2 | Yes | client |
| 3 | No | client |
| 4 | No | client |
| 10 | No | driver |
| 11 | No | driver |
| 12 | No | driver |
| 13 | No | driver |
+----------+--------+--------+
写一段 SQL 语句查出2013年10月1日至2013年10月3日期间非禁止用户的取消率。基于上表，你的 SQL 语句应返回如下结果，取消率（Cancellation Rate）保留两位小数。
+------------+-------------------+
| Day | Cancellation Rate |
+------------+-------------------+
| 2013-10-01 | 0.33 |
| 2013-10-02 | 0.00 |
| 2013-10-03 | 0.50 |
+------------+-------------------+
-- create table
DROP TABLE if EXISTS Trips;
CREATE TABLE Trips
(Id INT,
Client_Id INT,
Driver_Id INT,
City_Id INT,
Status VARCHAR(30),
Request_at DATE,
PRIMARY KEY (Id));
INSERT INTO Trips VALUES (1, 1, 10, 1, 'completed', '2013-10-1');
INSERT INTO Trips VALUES (2, 2, 11, 1, 'cancelled_by_driver', '2013-10-1');
INSERT INTO Trips VALUES (3, 3, 12, 6, 'completed', '2013-10-1');
INSERT INTO Trips VALUES (4, 4, 13, 6, 'cancelled_by_client', '2013-10-1');
INSERT INTO Trips VALUES (5, 1, 10, 1, 'completed', '2013-10-2');
INSERT INTO Trips VALUES (6, 2, 11, 6, 'completed', '2013-10-2');
INSERT INTO Trips VALUES (7, 3, 12, 6, 'completed', '2013-10-2');
INSERT INTO Trips VALUES (8, 2, 12, 12, 'completed', '2013-10-3');
INSERT INTO Trips VALUES (9, 3, 10, 12, 'completed', '2013-10-3');
INSERT INTO Trips VALUES (10, 4, 13, 12, 'cancelled_by_driver', '2013-10-3');
SELECT * FROM Trips;
DROP TABLE if EXISTS Users ;
CREATE TABLE Users
(Users_Id INT,
Banned VARCHAR(30),
Role VARCHAR(30),
PRIMARY KEY (Users_Id));
INSERT INTO Users VALUES (1, 'No', 'client');
INSERT INTO Users VALUES (2, 'Yes', 'client');
INSERT INTO Users VALUES (3, 'No', 'client');
INSERT INTO Users VALUES (4, 'No', 'client');
INSERT INTO Users VALUES (10, 'No', 'driver');
INSERT INTO Users VALUES (11, 'No', 'driver');
INSERT INTO Users VALUES (12, 'No', 'driver');
INSERT INTO Users VALUES (13, 'No', 'driver');
SELECT * FROM Users;
-- QUERY
SELECT TTT.Request_at,
-- 3.分别对符合条件的分子和分母求和，并保留2位小数
ROUND(SUM(CASE WHEN TTT.Status like 'cancelled%'
AND TTT.Banned1 != 'YES'
AND TTT.Banned2 != 'YES' THEN 1 ELSE 0 END)/SUM(CASE WHEN TTT.Banned1 != 'YES'
AND TTT.Banned2 != 'YES' THEN 1 ELSE 0 END),2)
AS "Cancellation Rate"
FROM
(
-- 2.获取 driver 用户 Banned 标识
SELECT TT.Request_at, TT.Status, TT.Banned AS Banned1, UU.Banned AS Banned2
FROM
(
-- 1.获取 cilent 用户 Banned 标识
SELECT T.Request_at, T.Driver_Id, T.Status, U.Banned, U.Role FROM Trips T
JOIN Users U ON T.Client_Id = U.Users_Id AND U.Role = 'client'
WHERE T.Request_at BETWEEN '2013-10-01' AND '2020-10-03') TT
JOIN Users UU ON TT.Driver_Id = UU.Users_Id AND UU.Role = 'driver') TTT
GROUP BY TTT.Request_at
Section B
练习一：行转列
假设 A B C 三位小朋友期末考试成绩如下所示：
+-----+-----------+------|
| name| subject |score |
+-----+-----------+------|
| A | chinese | 99 |
| A | math | 98 |
| A | english | 97 |
| B | chinese | 92 |
| B | math | 91 |
| B | english | 90 |
| C | chinese | 88 |
| C | math | 87 |
| C | english | 86 |
+-----+-----------+------|
请使用 SQL 代码将以上成绩转换为如下格式：
+-----+-----------+------|---------|
| name| chinese | math | english |
+-----+-----------+------|---------|
| A | 99 | 98 | 97 |
| B | 92 | 91 | 90 |
| C | 88 | 87 | 86 |
+-----+-----------+------|---------|
-- create table
DROP TABLE if EXISTS score2;
CREATE TABLE score2
(name VARCHAR(30) NOT NULL ,
subject VARCHAR(30) NOT NULL ,
score INT);
INSERT INTO score2 VALUES ('A', 'chinese', 99);
INSERT INTO score2 VALUES ('A', 'math', 98);
INSERT INTO score2 VALUES ('A', 'english', 97);
INSERT INTO score2 VALUES ('B', 'chinese', 92);
INSERT INTO score2 VALUES ('B', 'math', 91);
INSERT INTO score2 VALUES ('B', 'english', 90);
INSERT INTO score2 VALUES ('C', 'chinese', 88);
INSERT INTO score2 VALUES ('C', 'math', 87);
INSERT INTO score2 VALUES ('C', 'english', 86);
SELECT * FROM score2;
SELECT name,
SUM(CASE WHEN subject = 'chinese' THEN score ELSE null END) as chinese,
SUM(CASE WHEN subject = 'math' THEN score ELSE null END) as math,
SUM(CASE WHEN subject = 'english' THEN score ELSE null END) as english
FROM score2
GROUP BY name;
练习二：列转行
假设 A B C 三位小朋友期末考试成绩如下所示：
+-----+-----------+------|---------|
| name| chinese | math | english |
+-----+-----------+------|---------|
| A | 99 | 98 | 97 |
| B | 92 | 91 | 90 |
| C | 88 | 87 | 86 |
+-----+-----------+------|---------|
请使用 SQL 代码将以上成绩转换为如下格式：
+-----+-----------+------|
| name| subject |score |
+-----+-----------+------|
| A | chinese | 99 |
| A | math | 98 |
| A | english | 97 |
| B | chinese | 92 |
| B | math | 91 |
| B | english | 90 |
| C | chinese | 88 |
| C | math | 87 |
| C | english | 86 |
+-----+-----------+------|
-- create table
DROP TABLE if EXISTS score22;
CREATE TABLE score22
(name VARCHAR(30) NOT NULL ,
chinese INT,
math INT,
english INT);
INSERT INTO score22 VALUES ('A', 99, 98, 97);
INSERT INTO score22 VALUES ('B', 92, 91, 90);
INSERT INTO score22 VALUES ('C', 88, 87, 86);
SELECT * FROM score22;
SELECT name, 'chinese' as `subject`, `chinese` as `score`
FROM score22
UNION ALL
SELECT name, 'math' as `subject` , `math` as `score`
FROM score22
UNION ALL
SELECT name, 'english' as `subject`, `english` as `score`
FROM score22
ORDER BY name;
练习三：谁是明星带货主播？
假设，某平台2021年主播带货销售额日统计数据如下：
表名 anchor_sales
+-------------+------------+---------|
| anchor_name | date | sales |
+-------------+------------+---------|
| A | 20210101 | 40000 |
| B | 20210101 | 80000 |
| A | 20210102 | 10000 |
| C | 20210102 | 90000 |
| A | 20210103 | 7500 |
| C | 20210103 | 80000 |
+-------------+------------+---------|
定义：如果某主播的某日销售额占比达到该平台当日销售总额的 90% 及以上，则称该主播为明星主播，当天也称为明星主播日。
请使用 SQL 完成如下计算：
a. 2021年有多少个明星主播日？
b. 2021年有多少个明星主播？
-- create table
DROP TABLE if EXISTS anchor_sales;
CREATE TABLE anchor_sales
(anchor_name VARCHAR(30) NOT NULL ,
date DATETIME,
sales INT);
INSERT INTO anchor_sales VALUES ('A', 20210101, 40000);
INSERT INTO anchor_sales VALUES ('B', 20210101, 80000);
INSERT INTO anchor_sales VALUES ('A', 20210102, 10000);
INSERT INTO anchor_sales VALUES ('C', 20210102, 90000);
INSERT INTO anchor_sales VALUES ('A', 20210103, 7500);
INSERT INTO anchor_sales VALUES ('C', 20210103, 80000);
SELECT * FROM anchor_sales;
-- a
SELECT COUNT(DISTINCT anchor_name)
FROM (
SELECT * FROM (
SELECT t1.anchor_name, t1.date, t1.sales / t2.sum_sales as ratio
FROM anchor_sales t1
JOIN (SELECT date, sum(sales) AS sum_sales FROM anchor_sales GROUP BY date) t2
ON t1.date = t2.date ) t3
WHERE t3.ratio >= 0.9) t4;
-- b
SELECT COUNT(DISTINCT date)
FROM (
SELECT * FROM (
SELECT t1.anchor_name, t1.date, t1.sales / t2.sum_sales as ratio
FROM anchor_sales t1
JOIN (SELECT date, sum(sales) AS sum_sales FROM anchor_sales GROUP BY date) t2
ON t1.date = t2.date ) t3
WHERE t3.ratio >= 0.9) t4;
练习四：MySQL 中如何查看sql语句的执行计划？可以看到哪些信息？
MySQL 在执行的 sql 语句之前加上 EXPLAIN 就可以看到其执行计划了。
各列的含义如下:
- id: SELECT 查询的标识符. 每个 SELECT 都会自动分配一个唯一的标识符.
- select_type: SELECT 查询的类型.
- table: 查询的是哪个表
- partitions: 匹配的分区
- type: join 类型
- possible_keys: 此次查询中可能选用的索引
- key: 此次查询中确切使用到的索引.
- ref: 哪个字段或常数与 key 一起被使用
- rows: 显示此查询一共扫描了多少行. 这个是一个估计值.
- filtered: 表示此查询条件所过滤的数据的百分比
- extra: 额外的信息
重点字段介绍如下：
- select_type：
select_type 表示了查询的类型, 它的常用取值有:- SIMPLE, 表示此查询不包含 UNION 查询或子查询（最常见的查询类型）
- PRIMARY, 表示此查询是最外层的查询
- UNION, 表示此查询是 UNION 的第二或随后的查询
- DEPENDENT UNION, UNION 中的第二个或后面的查询语句, 取决于外面的查询
- UNION RESULT, UNION 的结果
- SUBQUERY, 子查询中的第一个 SELECT
- DEPENDENT SUBQUERY: 子查询中的第一个 SELECT, 取决于外面的查询. 即子查询依赖于外层查询的结果.
- Table
表示查询涉及的表或衍生表 - Type
type 字段比较重要, 它提供了判断查询是否高效的重要依据依据. 通过 type 字段, 我们判断此次查询是 全表扫描 还是 索引扫描 等。
type 常用的取值有:- system
表中只有一条数据. 这个类型是特殊的 const 类型。 - const
针对主键或唯一索引的等值查询扫描, 最多只返回一行数据. const 查询速度非常快, 因为它仅仅读取一次即可。 - eq_ref
此类型通常出现在多表的 join 查询, 表示对于前表的每一个结果, 都只能匹配到后表的一行结果. 并且查询的比较操作通常是 =, 查询效率较高 - ref
- 此类型通常出现在多表的 join 查询, 针对于非唯一或非主键索引, 或者是使用了 最左前缀规则索引的查询。
- range: 表示使用索引范围查询, 通过索引字段范围获取表中部分数据记录. 这个类型通常出现在 =, <>, >, >=, <, <=, IS NULL, <=>, BETWEEN, IN() 操作中。当 type 是 range 时, 那么 EXPLAIN 输出的 ref 字段为 NULL, 并且 key_len 字段是此次查询中使用到的索引的最长的那个。
- index: 表示全索引扫描(full index scan), 和 ALL 类型类似, 只不过 ALL 类型是全表扫描, 而 index 类型则仅仅扫描所有的索引, 而不扫描数据。index 类型通常出现在: 所要查询的数据直接在索引树中就可以获取到, 而不需要扫描数据. 当是这种情况时, Extra 字段 会显示 Using index。
- ALL: 表示全表扫描, 这个类型的查询是性能最差的查询之一. 通常来说, 我们的查询不应该出现 ALL 类型的查询, 因为这样的查询在数据量大的情况下, 对数据库的性能是巨大的灾难. 如一个查询是 ALL 类型查询, 那么一般来说可以对相应的字段添加索引来避免。
type 类型的性能比较
通常来说, 不同的 type 类型的性能关系如下：
ALL < index < range ~ index_merge < ref < eq_ref < const < system
ALL 类型因为是全表扫描, 因此在相同的查询条件下, 它是速度最慢的。
而 index 类型的查询虽然不是全表扫描, 但是它扫描了所有的索引, 因此比 ALL 类型的稍快。
后面的几种类型都是利用了索引来查询数据, 因此可以过滤部分或大部分数据, 因此查询效率就比较高了。
一般来说，保证查询至少达到 range 级别，最好能达到 ref。
练习五
解释 ACID 之前，首先要了解一个概念，那就是 事务 ，所谓事务，它是一个操作序列，这些操作要么都执行，要么都不执行，它是一个不可分割的工作单位。
ACID，是指在可靠数据库管理系统（DBMS）中，事务(transaction)所应该具有的四个特性：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）.这是可靠数据库所应具备的几个特性。
- system
练习五：解释一下 SQL 数据库中 ACID 是指什么
- 原子性
原子性是指事务是一个不可再分割的工作单位，事务中的操作要么都发生，要么都不发生。 - 一致性
一致性是指在事务开始之前和事务结束以后，数据库的完整性约束没有被破坏。这是说数据库事务不能破坏关系数据的完整性以及业务逻辑上的一致性。 - 隔离性
多个事务并发访问时，事务之间是隔离的，一个事务不应该影响其它事务运行效果。 - 持久性
持久性，意味着在事务完成以后，该事务所对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。
即使出现了任何事故比如断电等，事务一旦提交，则持久化保存在数据库中。
Section C
练习一：行转列
假设有如下比赛结果：
+--------------+-----------+
| cdate | result |
+--------------+-----------+
| 2021-01-01 | 胜 |
| 2021-01-01 | 胜 |
| 2021-01-01 | 负 |
| 2021-01-03 | 胜 |
| 2021-01-03 | 负 |
| 2021-01-03 | 负 |
+------------+-------------+
请使用 SQL 将比赛结果转换为如下形式：
+--------------+-----+-----|
| 比赛日期 | 胜 | 负 |
+--------------+-----------+
| 2021-01-01 | 2 | 1 |
| 2021-01-03 | 1 | 2 |
+------------+-----------+
-- create table
DROP TABLE if EXISTS row_col;
CREATE TABLE row_col
(cdate DATE,
result VARCHAR(30));
INSERT INTO row_col VALUES ('2021-01-01', '胜');
INSERT INTO row_col VALUES ('2021-01-01', '胜');
INSERT INTO row_col VALUES ('2021-01-01', '负');
INSERT INTO row_col VALUES ('2021-01-03', '胜');
INSERT INTO row_col VALUES ('2021-01-03', '负');
INSERT INTO row_col VALUES ('2021-01-03', '负');
SELECT * FROM row_col;
SELECT cdate AS `比赛日期`,
SUM(CASE WHEN result = '胜' THEN 1 ELSE 0 END ) AS `胜`,
SUM(CASE WHEN result = '负' THEN 1 ELSE 0 END ) AS `负`
FROM row_col
GROUP BY cdate;
练习二：列转行
假设有如下比赛结果：
+--------------+-----+-----|
| 比赛日期 | 胜 | 负 |
+--------------+-----------+
| 2021-01-01 | 4 | 1 |
| 2021-01-03 | 1 | 4 |
+------------+-----------+
请使用 SQL 将比赛结果转换为如下形式：
+--------------+-----------+
| cdate | result |
+--------------+-----------+
| 2021-01-01 | 胜 |
| 2021-01-01 | 胜 |
| 2021-01-01 | 胜 |
| 2021-01-01 | 胜 |
| 2021-01-01 | 负 |
| 2021-01-03 | 胜 |
| 2021-01-03 | 负 |
| 2021-01-03 | 负 |
| 2021-01-03 | 负 |
| 2021-01-03 | 负 |
+------------+-------------+
简单方法：
-- create table
DROP TABLE if EXISTS col_row;
CREATE TABLE col_row
(比赛日期 DATE,
胜 INT,
负 INT);
INSERT INTO col_row VALUES ('2021-01-01', 4, 1);
INSERT INTO col_row VALUES ('2021-01-03', 1, 4);
SELECT * FROM col_row;
SELECT
a.`比赛日期` AS cdate, '胜' AS result
FROM
col_row AS a
INNER JOIN mysql.help_topic AS b ON b.help_topic_id < a.`胜`
UNION ALL
SELECT
a.`比赛日期` AS cdate, '负' AS result
FROM
col_row AS a
INNER JOIN mysql.help_topic AS b ON b.help_topic_id < a.`负`
ORDER BY
cdate, result;
练习三：连续登录
有用户表行为记录表t_act_records表，包含两个字段：uid（用户ID），imp_date（日期）
- 计算2021年每个月，每个用户连续登录的最多天数
- 计算2021年每个月，连续2天都有登录的用户名单
- 计算2021年每个月，连续5天都有登录的用户数
构造表mysql如下：
DROP TABLE if EXISTS t_act_records;
CREATE TABLE t_act_records
(uid VARCHAR(20),
imp_date DATE);
INSERT INTO t_act_records VALUES('u1001', 20210101);
INSERT INTO t_act_records VALUES('u1002', 20210101);
INSERT INTO t_act_records VALUES('u1003', 20210101);
INSERT INTO t_act_records VALUES('u1003', 20210102);
INSERT INTO t_act_records VALUES('u1004', 20210101);
INSERT INTO t_act_records VALUES('u1004', 20210102);
INSERT INTO t_act_records VALUES('u1004', 20210103);
INSERT INTO t_act_records VALUES('u1004', 20210104);
INSERT INTO t_act_records VALUES('u1004', 20210105);
可以参考 MySQL 连续登录通用计算模型
-- 1. 计算2021年每个月，每个用户连续登录的最多天数
SELECT t2.uid, t2.check_period, MAX(t2.continous_days) AS max_continous_days
FROM (
select
t1.uid,
min(t1.imp_date) `start_time`,
max(t1.imp_date) `end_time`,
count(1) as continous_days,
month(t1.imp_date) as check_period,
DATEDIFF(t1.imp_date, '2021-01-01' ) + (select count(1) from t_act_records t2 where t2.uid = t1.uid and DATEDIFF(t2.imp_date, t1.imp_date)>=0) as flag
from t_act_records t1
group by
t1.uid,flag
) t2
GROUP BY t2.uid, t2.check_period;
-- 2. 计算2021年每个月，连续2天都有登录的用户名单
SELECT t2.uid, t2.check_period
FROM (
select
t1.uid,
min(t1.imp_date) `start_time`,
max(t1.imp_date) `end_time`,
count(1) as continous_days,
month(t1.imp_date) as check_period,
DATEDIFF(t1.imp_date, '2021-01-01' ) + (select count(1) from t_act_records t2 where t2.uid = t1.uid and DATEDIFF(t2.imp_date, t1.imp_date)>=0) as flag
from t_act_records t1
group by
t1.uid,flag
) t2
WHERE t2.continous_days >= 2;
-- 3. 计算2021年每个月，连续5天都有登录的用户数
SELECT t2.check_period, count(distinct t2.uid) AS continous_5days
FROM (
select
t1.uid,
min(t1.imp_date) `start_time`,
max(t1.imp_date) `end_time`,
count(1) as continous_days,
month(t1.imp_date) as check_period,
DATEDIFF(t1.imp_date, '2021-01-01' ) + (select count(1) from t_act_records t2 where t2.uid = t1.uid and DATEDIFF(t2.imp_date, t1.imp_date)>=0) as flag
from t_act_records t1
group by
t1.uid,flag
) t2
WHERE t2.continous_days >= 5
GROUP BY t2.check_period;
练习四：用户购买商品推荐
假设现在需要根据算法给每个 user_id 推荐购买商品，推荐算法比较简单，推荐和他相似的用户购买过的 product 即可，说明如下：
- 排除用户自己购买过的商品
- 相似用户定义：曾经购买过 2 种或 2 种以上的相同的商品
输入表：orders
+---------+------------+
| user_id | product_id |
+---------+------------+
| 123 | 1 |
| 123 | 2 |
| 123 | 3 |
| 456 | 1 |
| 456 | 2 |
| 456 | 4 |
+---------+------------+
输出表：
+---------+------------+
| user_id | product_id |
+---------+------------+
| 123 | 4 |
| 456 | 3 |
+---------+------------+
DROP TABLE if EXISTS orders;
CREATE TABLE orders
(user_id INT,
product_id INT);
INSERT INTO orders VALUES (123, 1);
INSERT INTO orders VALUES (123, 2);
INSERT INTO orders VALUES (123, 3);
INSERT INTO orders VALUES (456, 1);
INSERT INTO orders VALUES (456, 2);
INSERT INTO orders VALUES (456, 4);
WITH t1 AS
(
SELECT a.user_id , a.product_id , b.user_id AS buid, b.product_id AS bpid
FROM orders a
LEFT JOIN orders b
ON a.product_id = b.product_id AND a.user_id <> b.user_id),
t2 AS
(
SELECT user_id, buid,count(bpid) AS bpcnt FROM t1
GROUP BY user_id, buid
HAVING bpcnt >= 2)
SELECT t2.user_id, t1.product_id
FROM t2
LEFT JOIN t1
ON t2.buid = t1.user_id
WHERE t1.bpid IS NULL;
练习五：hive 数据倾斜的产生原因及优化策略？
首先，什么是数据倾斜？
数据倾斜就是：由于数据分布不均匀，造成数据大量的集中到一点，造成数据热点，常见现象是：任务进度长时间维持在 99%或者 100%的附近，查看任务监控页面，发现只有少量 reduce 子任务未完成，因为其处理的数据量和其他的 reduce 差异过大。 单一 reduce 处理的记录数和平均记录数相差太大，通常达到好几倍之多，最长时间远大 于平均时长。
Hive 数据倾斜产生的原因主要有如下几条：
关键词
场景
影响后果
JOIN
其中一个表较小，但是 key 比较集中
分发到一个或几个 Reduce 上的数据远高于平均值
大表与大表，但是分桶的判断字段中，0值或控制过多
这些空值都有一个 Reduce 处理，导致该 Reduce 执行的非常慢
GROUP BY
维多不均衡，某值的数量过多
处理某值的 Reduce 非常耗时
Count distinct
某特殊值过多
处理此特殊值的 Reduce 非常耗时
优化策略：
- 空值产生的数据倾斜
策略1：为空的列值不参与关联
select * from log a join user b on a.user_id is not null and a.user_id = b.user_id
union all
select * from log c where c.user_id is null;
策略2：赋予空值新的 key 值
select * from log a left outer join user b on
case when a.user_id is null then concat('hive',rand()) else a.user_id end = b.user_id
- 不同数据类型产生的数据倾斜
把数字类型 id 转换成 string 类型的 id
select * from user a left outer join log b on b.user_id = cast(a.user_id as string)
- 大小表关联产生的数据倾斜
使用map join解决小表关联大表造成的数据倾斜问题。（这个方法使用的频率很高。）
map join 概念：将其中做连接的小表（全量数据）分发到所有 MapTask 端进行 Join，从 而避免了 reduceTask，前提要求是内存足以装下该全量数据。
MapJoin 具体用法：
select /* +mapjoin(a) */ a.id aid, name, age from a join b on a.id = b.id;select /* +mapjoin(movies) */ a.title, b.rating from movies a join ratings b on a.movieid =
b.movieid;
在 hive0.11 版本以后会自动开启 map join 优化，由两个参数控制：
set hive.auto.convert.join=true; //设置 MapJoin 优化自动开启
set hive.mapjoin.smalltable.filesize=25000000 //设置小表不超过多大时开启 mapjoin 优化
如果是大大表关联呢？那就大事化小，小事化了。把大表切分成小表，然后分别 map join
那么如果小表不大不小，那该如何处理呢？？？
使用 map join 解决小表(记录数少)关联大表的数据倾斜问题，这个方法使用的频率非常 高，但如果小表很大，大到 map join 会出现 bug 或异常，这时就需要特别的处理。
练习六：LEFT JOIN 是否可能会出现多出的行？为什么？
假设 t1 表有6行（关联列 name 有2行为空），t2 表有6行（关联列 name 有3行为空）,
那么 SELECT * FROM t1 LEFT JOIN t2 on t1.name = t2.name 会返回多少行结果？
可以参考下图
10 行结果。
因为 t1 表的 2 个空行和 t2 表的 3 个空行进行叉乘，得到了 6 行，加上 t1 表中 name 非空的 4 行，最终得到 10 行。(在 on 条件中 ，比较运算符 = 两边的值都是 NULL 时，返回 true，所以会变为 6 行。