0%

SQL专项练习笔记

1.选择

595.大的国家

World表:

1
2
3
4
5
6
7
8
9
10
11
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| name | varchar |
| continent | varchar |
| area | int |
| population | int |
| gdp | int |
+-------------+---------+
name 是这张表的主键。
这张表的每一行提供:国家名称、所属大陆、面积、人口和 GDP 值。
  • 面积至少为 300 万平方公里(即,3000000 km2

    或者

  • 人口至少为 2500 万(即 25000000

编写一个 SQL 查询以报告 大国 的国家名称、人口和面积。

1
大国 => where满足相关条件即可
1
2
3
SELECT name, population, area
FROM World
WHERE area >= 3000000 or population >= 25000000;
1
2
3
4
| name        | population | area    |
| ----------- | ---------- | ------- |
| Afghanistan | 25500100 | 652230 |
| Algeria | 37100000 | 2381741 |

1757.可回收且低脂的产品

Products表:

1
2
3
4
5
6
7
8
9
10
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| product_id | int |
| low_fats | enum |
| recyclable | enum |
+-------------+---------+
product_id 是这个表的主键。
low_fats 是枚举类型,取值为以下两种 ('Y', 'N'),其中 'Y' 表示该产品是低脂产品,'N' 表示不是低脂产品。
recyclable 是枚举类型,取值为以下两种 ('Y', 'N'),其中 'Y' 表示该产品可回收,而 'N' 表示不可回收。
  • 查找既是低脂又是可回收的产品编号
1
2
既是...又是...
AND
1
2
3
SELECT product_id
FROM products
WHERE low_fats = 'Y' AND recyclable = 'y';
1
2
3
4
| product_id |
| ---------- |
| 1 |
| 3 |

584.寻找用户推荐人

customer表:

1
2
3
4
5
6
7
8
9
10
+------+------+-----------+
| id | name | referee_id|
+------+------+-----------+
| 1 | Will | NULL |
| 2 | Jane | NULL |
| 3 | Alex | 2 |
| 4 | Bill | NULL |
| 5 | Zack | 1 |
| 6 | Mark | 2 |
+------+------+-----------+
  • 返回一个客户列表,列表中客户的推荐人的编号都 不是 2
1
推荐编号!=2,注意这里加or处理NULL
1
2
3
SELECT name
FROM customer
WHERE referee_id != 2 OR referee_id is NULL;
1
2
3
4
5
6
| name |
| ---- |
| Will |
| Jane |
| Bill |
| Zack |

183.从不订购的客户

Customers表:

1
2
3
4
5
6
7
8
+----+-------+
| Id | Name |
+----+-------+
| 1 | Joe |
| 2 | Henry |
| 3 | Sam |
| 4 | Max |
+----+-------+

Order表:

1
2
3
4
5
6
+----+------------+
| Id | CustomerId |
+----+------------+
| 1 | 3 |
| 2 | 1 |
+----+------------+
  • 找出所有从不订购任何东西的客户
1
2
3
4
5
1.子查询
客户id not in (order表中购物id)

2.左连接
Customer拼Order, customerid为空的就是没有订购的
1
2
3
4
5
6
SELECT C.name Customers
FROM Customers C
WHERE C.id not in(
SELECT CustomerId
FROM Orders
);
1
2
3
4
5
SELECT name Customers
FROM Customers C
LEFT JOIN Orders O
ON C.id = O.CustomerId
WHERE O.CustomerId is NULL;
1
2
3
4
| Customers |
| --------- |
| Henry |
| Max |

2.排序&修改

1873.计算特殊奖金

Employees表:

1
2
3
4
5
6
7
8
9
+-------------+---------+
| 列名 | 类型 |
+-------------+---------+
| employee_id | int |
| name | varchar |
| salary | int |
+-------------+---------+
employee_id 是这个表的主键。
此表的每一行给出了雇员id ,名字和薪水。

写出一个SQL 查询语句,计算每个雇员的奖金。如果一个雇员的id是奇数并且他的名字不是以’M’开头,那么他的奖金是他工资的100%,否则奖金为0。

返回的结果集请按照employee_id排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#case when多条件判断
CASE
WHEN 列名=条件值1 THEN 选项1
WHEN 列名=条件值2 THEN 选项2
ELSE 默认值 END

#MOD取余
MOD(a,b) #a/b的余数

#返回原字符串中指定数目的字符
LEFT(name, 1) #返回name的第一个字符

#IF判断,真返回v1,假返回v2
IF(expr, V1, V2)



CASE WHEN

1
2
3
4
5
6
7
8
9
SELECT employee_id,
(CASE
WHEN MOD(employee_id,2) != 0 AND LEFT(name, 1) != 'M'
THEN salary
WHEN MOD(employee_id,2) = 0 OR LEFT(name, 1) = 'M'
THEN 0
END) bonus
FROM Employees
ORDER BY employee_id;

IF

1
2
3
4
SELECT employee_id,
IF(employee_id%2 != 0 AND name NOT LIKE('M%'),salary,0) bonus
FROM Employees
ORDER BY employee_id;

regexp

1
2
3
4
5
6
SELECT employee_id,
(CASE
WHEN employee_id%2 = 1 AND name NOT REGEXP('^M') THEN salary ELSE 0
END) bonus
FROM Employees
ORDER BY employee_id;
1
2
3
4
5
6
7
| employee_id | bonus |
| ----------- | ----- |
| 2 | 0 |
| 3 | 0 |
| 7 | 7400 |
| 8 | 0 |
| 9 | 7700 |

627.变更性别

Salary 表:

1
2
3
4
5
6
7
8
9
10
11
+-------------+----------+
| Column Name | Type |
+-------------+----------+
| id | int |
| name | varchar |
| sex | ENUM |
| salary | int |
+-------------+----------+
id 是这个表的主键。
sex 这一列的值是 ENUM 类型,只能从 ('m', 'f') 中取。
本表包含公司雇员的信息。

请你编写一个 SQL 查询来交换所有的 'f''m' (即,将所有 'f' 变为 'm' ,反之亦然),仅使用 单个 update 语句 ,且不产生中间临时表。

IF

1
2
UPDATE Salary
SET sex = IF(sex = 'm', 'f', 'm');

CASE WHEN

1
2
UPDATE Salary
SET sex = CASE sex WHEN 'm' THEN 'f' ELSE 'm' END;

奇怪的解法

1
2
3
4
5
UPDATE salary SET sex = char(ascii(sex) ^ ascii('m') ^ ascii('f'))
异或,同位相同为0,不同为1,任何数与0异或等于这个数本身

UPDATE Salary SET sex = char(ascii('m') + ascii('f') - ascii(sex));
求和-本身=另一个
1
2
3
4
5
6
| id | name | sex | salary |
| -- | ---- | --- | ------ |
| 1 | A | f | 2500 |
| 2 | B | m | 1500 |
| 3 | C | f | 5500 |
| 4 | D | m | 500 |

196.删除重复的电子邮箱

Person表:

1
2
3
4
5
6
7
8
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| id | int |
| email | varchar |
+-------------+---------+
id是该表的主键列。
该表的每一行包含一封电子邮件。电子邮件将不包含大写字母。

编写一个 SQL 删除语句删除 所有重复的电子邮件,只保留一个id最小的唯一电子邮件。

任意顺序 返回结果表。 (注意: 仅需要写删除语句,将自动对剩余结果进行查询)

自连接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#自连接去重经典操作
id email id email
1 john@qq.com 1 john@qq.com
1 john@qq.com 2 bob@qq.com
1 john@qq.com 3 john@qq.com
2 bob@qq.com 1 john@qq.com
2 bob@qq.com 2 bob@qq.com
2 bob@qq.com 3 john@qq.com
3 john@qq.com 1 john@qq.com
3 john@qq.com 2 bob@qq.com
3 john@qq.com 3 john@qq.com
#email=email
id email id email
1 john@qq.com 1 john@qq.com
2 bob@qq.com 2 bob@qq.com
3 john@qq.com 1 john@qq.com
3 john@qq.com 3 john@qq.com
# p1.id > p2.id
3 john@qq.com 1 john@qq.com
#p1中id为3的记录就是重复记录,删除之

#DELETE p1:从p1表中删除满足WHERE条件的记录。如上,p1中id=3的满足,所以只删掉他
#自连接产生笛卡尔积,大数据量时容易爆炸
1
2
3
DELETE p1
FROM Person p1, Person p2
WHERE p1.email = p2.email AND p1.id > p2.id;

NOT IN子查询

1
2
3
4
5
6
7
8
9
DELETE FROM Person
WHERE id NOT IN(
SELECT id
FROM(
SELECT min(id) id
FROM Person
GROUP BY email
)p
);

ROW_NUMBER()开窗函数

1

1
2
3
4
5
6
7
8
9
10
DELETE FROM PERSON
WHERE id IN(
SELECT id
FROM(
SELECT id,email,
ROW_NUMBER() OVER(PARTITION BY email ORDER BY id) AS id_order
FROM Person
)p
WHERE id_order > 1
);
1
2
3
4
| id | email            |
| -- | ---------------- |
| 1 | john@example.com |
| 2 | bob@example.com |

3.字符串处理函数/正则

1667.修复表中的名字

表: Users

1
2
3
4
5
6
7
8
+----------------+---------+
| Column Name | Type |
+----------------+---------+
| user_id | int |
| name | varchar |
+----------------+---------+
user_id 是该表的主键。
该表包含用户的 ID 和名字。名字仅由小写和大写字符组成。

编写一个 SQL 查询来修复(查询)名字,使得只有第一个字符是大写的,其余都是小写的。

返回按 user_id 排序的结果表。

CONCAT一下

1
2
3
4
SELECT user_id, 
CONCAT(UPPER(LEFT(name,1)),LOWER(SUBSTRING(name,2))) AS name
FROM Users
ORDER BY user_id;
1
2
3
4
| user_id | name  |
| ------- | ----- |
| 1 | Alice |
| 2 | Bob |
1
2
3
4
LEFT(str, length)
从左开截
SUBSTRING(str, begin, end)
截取字符串,end不写默认为空

1484.按日期分组销售产品

Activities

1
2
3
4
5
6
7
8
+-------------+---------+
| 列名 | 类型 |
+-------------+---------+
| sell_date | date |
| product | varchar |
+-------------+---------+
此表没有主键,它可能包含重复项。
此表的每一行都包含产品名称和在市场上销售的日期。

编写一个 SQL 查询来查找每个日期、销售的不同产品的数量及其名称。
每个日期的销售产品名称应按词典序排列。
返回按 sell_date 排序的结果表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Activities 表:
+------------+-------------+
| sell_date | product |
+------------+-------------+
| 2020-05-30 | Headphone |
| 2020-06-01 | Pencil |
| 2020-06-02 | Mask |
| 2020-05-30 | Basketball |
| 2020-06-01 | Bible |
| 2020-06-02 | Mask |
| 2020-05-30 | T-Shirt |
+------------+-------------+
输出:
+------------+----------+------------------------------+
| sell_date | num_sold | products |
+------------+----------+------------------------------+
| 2020-05-30 | 3 | Basketball,Headphone,T-shirt |
| 2020-06-01 | 2 | Bible,Pencil |
| 2020-06-02 | 1 | Mask |
+------------+----------+------------------------------+
解释:
对于2020-05-30,出售的物品是 (Headphone, Basketball, T-shirt),按词典序排列,并用逗号 ',' 分隔。
对于2020-06-01,出售的物品是 (Pencil, Bible),按词典序排列,并用逗号分隔。
对于2020-06-02,出售的物品是 (Mask),只需返回该物品名。

字符串分组聚合GROUP_CONCAT

1
2
3
4
5
SELECT sell_date,
COUNT(DISTINCT product) num_sold,
GROUP_CONCAT(DISTINCT product ORDER BY product ASC) products
FROM Activities
GROUP BY sell_date;
1
group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator '分隔符'])

1526.患某种疾病的患者

患者信息表: Patients

1
2
3
4
5
6
7
8
9
10
+--------------+---------+
| Column Name | Type |
+--------------+---------+
| patient_id | int |
| patient_name | varchar |
| conditions | varchar |
+--------------+---------+
patient_id (患者 ID)是该表的主键。
'conditions' (疾病)包含 0 个或以上的疾病代码,以空格分隔。
这个表包含医院中患者的信息。

写一条 SQL 语句,查询患有 I 类糖尿病的患者 ID (patient_id)、患者姓名(patient_name)以及其患有的所有疾病代码(conditions)。I 类糖尿病的代码总是包含前缀 DIAB1

任意顺序 返回结果表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
输入:
Patients表:
+------------+--------------+--------------+
| patient_id | patient_name | conditions |
+------------+--------------+--------------+
| 1 | Daniel | YFEV COUGH |
| 2 | Alice | |
| 3 | Bob | DIAB100 MYOP |
| 4 | George | ACNE DIAB100 |
| 5 | Alain | DIAB201 |
+------------+--------------+--------------+
输出:
+------------+--------------+--------------+
| patient_id | patient_name | conditions |
+------------+--------------+--------------+
| 3 | Bob | DIAB100 MYOP |
| 4 | George | ACNE DIAB100 |
+------------+--------------+--------------+
解释:Bob 和 George 都患有代码以 DIAB1 开头的疾病。

正则简单匹配,DIAB1开头或包含空格DIAB1

1
2
3
SELECT *
FROM Patients
WHERE conditions REGEXP '^DIAB1| DIAB1';

LIKE同理

1
2
3
SELECT *
FROM Patients
WHERE conditions LIKE 'DIAB1%' OR conditions LIKE '% DIAB1%'

4.组合查询&指定选取

1965.丢失信息的雇员

表: Employees

1
2
3
4
5
6
7
8
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| employee_id | int |
| name | varchar |
+-------------+---------+
employee_id 是这个表的主键。
每一行表示雇员的id 和他的姓名。

表: Salaries

1
2
3
4
5
6
7
8
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| employee_id | int |
| salary | int |
+-------------+---------+
employee_id is 这个表的主键。
每一行表示雇员的id 和他的薪水。

写出一个查询语句,找到所有 丢失信息 的雇员id。当满足下面一个条件时,就被认为是雇员的信息丢失:

  • 雇员的 姓名 丢失了,或者
  • 雇员的 薪水信息 丢失了,或者

返回这些雇员的id employee_id从小到大排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
输入:
Employees table:
+-------------+----------+
| employee_id | name |
+-------------+----------+
| 2 | Crew |
| 4 | Haven |
| 5 | Kristian |
+-------------+----------+
Salaries table:
+-------------+--------+
| employee_id | salary |
+-------------+--------+
| 5 | 76071 |
| 1 | 22517 |
| 4 | 63539 |
+-------------+--------+
输出:
+-------------+
| employee_id |
+-------------+
| 1 |
| 2 |
+-------------+
解释:
雇员1,2,4,5 都工作在这个公司。
1号雇员的姓名丢失了。
2号雇员的薪水信息丢失了。
1
2
3
4
5
6
7
8
9
10
SELECT L.employee_id
FROM employees L LEFT JOIN Salaries R
ON L.employee_id = R.employee_id
WHERE R.salary IS NULL
UNION
SELECT L.employee_id
FROM Salaries L LEFT JOIN employees R
ON L.employee_id = R.employee_id
WHERE R.name IS NULL
ORDER BY employee_id;

分别进行两次左连接找出缺失的,最后UNION并起来

1795.每个产品在不同商店的价格

表:Products

1
2
3
4
5
6
7
8
9
10
11
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| product_id | int |
| store1 | int |
| store2 | int |
| store3 | int |
+-------------+---------+
这张表的主键是product_id(产品Id)。
每行存储了这一产品在不同商店store1, store2, store3的价格。
如果这一产品在商店里没有出售,则值将为null。

请你重构 Products 表,查询每个产品在不同商店的价格,使得输出的格式变为(product_id, store, price) 。如果这一产品在商店里没有出售,则不输出这一行。

输出结果表中的 顺序不作要求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
输入:
Products table:
+------------+--------+--------+--------+
| product_id | store1 | store2 | store3 |
+------------+--------+--------+--------+
| 0 | 95 | 100 | 105 |
| 1 | 70 | null | 80 |
+------------+--------+--------+--------+
输出:
+------------+--------+-------+
| product_id | store | price |
+------------+--------+-------+
| 0 | store1 | 95 |
| 0 | store2 | 100 |
| 0 | store3 | 105 |
| 1 | store1 | 70 |
| 1 | store3 | 80 |
+------------+--------+-------+
解释:
产品0在store1,store2,store3的价格分别为95,100,105。
产品1在store1,store3的价格分别为70,80。在store2无法买到。

列转行,再UNION ALL起来

1
2
3
4
5
6
7
8
9
10
11
SELECT product_id, 'store1' store, store1 price
FROM Products
WHERE store1 IS NOT NULL
UNION ALL
SELECT product_id, 'store2' store, store2 price
FROM Products
WHERE store2 IS NOT NULL
UNION ALL
SELECT product_id,'store3' store, store3 price
FROM Products
WHERE store3 IS NOT NULL;

608.树节点

给定一个表 treeid 是树节点的编号, p_id 是它父节点的 id 。

1
2
3
4
5
6
7
8
9
+----+------+
| id | p_id |
+----+------+
| 1 | null |
| 2 | 1 |
| 3 | 1 |
| 4 | 2 |
| 5 | 2 |
+----+------+

树中每个节点属于以下三种类型之一:

  • 叶子:如果这个节点没有任何孩子节点。
  • 根:如果这个节点是整棵树的根,即没有父节点。
  • 内部节点:如果这个节点既不是叶子节点也不是根节点。

写一个查询语句,输出所有节点的编号和节点的类型,并将结果按照节点编号排序。上面样例的结果为:

1
2
3
4
5
6
7
8
9
+----+------+
| id | Type |
+----+------+
| 1 | Root |
| 2 | Inner|
| 3 | Leaf |
| 4 | Leaf |
| 5 | Leaf |
+----+------+

分别查询Root,Inner, Leaf并UNION

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
SELECT id, 'Root' Type
FROM tree
WHERE p_id IS NULL
UNION
SELECT id,'Leaf' Type
FROM tree
WHERE id NOT IN(
SELECT DISTINCT p_id
FROM tree
WHERE p_id iS NOT NULL
) AND p_id IS NOT NULL
UNION
SELECT id, 'Inner' Type
FROM tree
WHERE id IN(
SELECT DISTINCT p_id
FROM tree
WHERE p_id IS NOT NULL
) AND p_id IS NOT NULL
ORDER BY id;

CASE WHEN 流程控制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
SELECT id 'id',
CASE
WHEN tree.id IN (
SELECT T.id
FROM tree T
WHERE T.p_id IS NULL
)
THEN 'Root'
WHEN tree.id IN(
SELECT T.p_id
FROM tree T
)
THEN 'Inner'
ELSE 'Leaf'
END Type
FROM tree
ORDER BY 'id'

IF与CASE WHEN同理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
SELECT id 'id',
CASE
WHEN tree.id IN (
SELECT T.id
FROM tree T
WHERE T.p_id IS NULL
)
THEN 'Root'
WHEN tree.id IN(
SELECT T.p_id
FROM tree T
)
THEN 'Inner'
ELSE 'Leaf'
END Type
FROM tree
ORDER BY 'id'

176.第二高的薪水

Employee 表:

1
2
3
4
5
6
7
8
+-------------+------+
| Column Name | Type |
+-------------+------+
| id | int |
| salary | int |
+-------------+------+
id 是这个表的主键。
表的每一行包含员工的工资信息。

编写一个 SQL 查询,获取并返回 Employee 表中第二高的薪水 。如果不存在第二高的薪水,查询应该返回 null

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
输入:
Employee 表:
+----+--------+
| id | salary |
+----+--------+
| 1 | 100 |
| 2 | 200 |
| 3 | 300 |
+----+--------+
输出:
+---------------------+
| SecondHighestSalary |
+---------------------+
| 200 |
+---------------------+

输入:
Employee 表:
+----+--------+
| id | salary |
+----+--------+
| 1 | 100 |
+----+--------+
输出:
+---------------------+
| SecondHighestSalary |
+---------------------+
| null |
+---------------------+

OFFSET

1
2
3
4
5
6
SELECT(
SELECT DISTINCT salary
FROM Employee
ORDER BY Salary DESC
LIMIT 1 OFFSET 1
) SecondHighestSalary
1
2
3
4
5
6
7
8
9
10
11
12
13
##
LIMIT 1 OFFSET 1
先跳过第一个,再只取一个
LIMIT 3 OFFSET 1
先跳过第一个,再取前三个,得第2,3,4三条数据

使用子查询是因为如果只有一个数据的话无法返回null
| id | salary |
| -- | ------ |
| 1 | 100 |

| SecondHighestSalary |
| ------------------- |

IFNULL

1
2
3
4
5
6
7
SELECT IFNULL(
(SELECT DISTINCT Salary
FROM Employee
ORDER BY Salary DESC
LIMIT 1 OFFSET 1),
NULL
) SecondHighestSalary

5.合并

175. 组合两个表

表: Person

1
2
3
4
5
6
7
8
9
+-------------+---------+
| 列名 | 类型 |
+-------------+---------+
| PersonId | int |
| FirstName | varchar |
| LastName | varchar |
+-------------+---------+
personId 是该表的主键列。
该表包含一些人的 ID 和他们的姓和名的信息。

表: Address

1
2
3
4
5
6
7
8
9
10
+-------------+---------+
| 列名 | 类型 |
+-------------+---------+
| AddressId | int |
| PersonId | int |
| City | varchar |
| State | varchar |
+-------------+---------+
addressId 是该表的主键列。
该表的每一行都包含一个 ID = PersonId 的人的城市和州的信息。

编写一个SQL查询来报告 Person 表中每个人的姓、名、城市和州。如果 personId 的地址不在 Address 表中,则报告为空 null

任意顺序 返回结果表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
输入: 
Person表:
+----------+----------+-----------+
| personId | lastName | firstName |
+----------+----------+-----------+
| 1 | Wang | Allen |
| 2 | Alice | Bob |
+----------+----------+-----------+
Address表:
+-----------+----------+---------------+------------+
| addressId | personId | city | state |
+-----------+----------+---------------+------------+
| 1 | 2 | New York City | New York |
| 2 | 3 | Leetcode | California |
+-----------+----------+---------------+------------+
输出:
+-----------+----------+---------------+----------+
| firstName | lastName | city | state |
+-----------+----------+---------------+----------+
| Allen | Wang | Null | Null |
| Bob | Alice | New York City | New York |
+-----------+----------+---------------+----------+
解释:
地址表中没有 personId = 1 的地址,所以它们的城市和州返回 null。
addressId = 1 包含了 personId = 2 的地址信息。
1
2
3
4
SELECT firstName, lastName, city, state
FROM Person
LEFT JOIN Address
ON Person.personId = Address.personId;
1
2
3
4
5
##
INNER JOIN
取交集
OUTER JOIN
left join, right join, full outer join都是外连接,可能会出现null

1581. 进店却未进行过交易的顾客

表:Visits

1
2
3
4
5
6
7
8
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| visit_id | int |
| customer_id | int |
+-------------+---------+
visit_id 是该表的主键。
该表包含有关光临过购物中心的顾客的信息。

表:Transactions

1
2
3
4
5
6
7
8
9
+----------------+---------+
| Column Name | Type |
+----------------+---------+
| transaction_id | int |
| visit_id | int |
| amount | int |
+----------------+---------+
transaction_id 是此表的主键。
此表包含 visit_id 期间进行的交易的信息。

有一些顾客可能光顾了购物中心但没有进行交易。请你编写一个 SQL 查询,来查找这些顾客的 ID ,以及他们只光顾不交易的次数。

返回以 任何顺序 排序的结果表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
输入:
Visits
+----------+-------------+
| visit_id | customer_id |
+----------+-------------+
| 1 | 23 |
| 2 | 9 |
| 4 | 30 |
| 5 | 54 |
| 6 | 96 |
| 7 | 54 |
| 8 | 54 |
+----------+-------------+
Transactions
+----------------+----------+--------+
| transaction_id | visit_id | amount |
+----------------+----------+--------+
| 2 | 5 | 310 |
| 3 | 5 | 300 |
| 9 | 5 | 200 |
| 12 | 1 | 910 |
| 13 | 2 | 970 |
+----------------+----------+--------+
输出:
+-------------+----------------+
| customer_id | count_no_trans |
+-------------+----------------+
| 54 | 2 |
| 30 | 1 |
| 96 | 1 |
+-------------+----------------+
解释:
ID = 23 的顾客曾经逛过一次购物中心,并在 ID = 12 的访问期间进行了一笔交易。
ID = 9 的顾客曾经逛过一次购物中心,并在 ID = 13 的访问期间进行了一笔交易。
ID = 30 的顾客曾经去过购物中心,并且没有进行任何交易。
ID = 54 的顾客三度造访了购物中心。在 2 次访问中,他们没有进行任何交易,在 1 次访问中,他们进行了 3 次交易。
ID = 96 的顾客曾经去过购物中心,并且没有进行任何交易。
如我们所见,ID 为 30 和 96 的顾客一次没有进行任何交易就去了购物中心。顾客 54 也两次访问了购物中心并且没有进行任何交易。
1
2
3
4
5
6
SELECT V.customer_id, count(*) count_no_trans
FROM Visits V
LEFT JOIN Transactions T
ON V.visit_id = T.visit_id
WHERE amount IS NULL
GROUP BY customer_id;
1
2
## 
Visit左连接Tans,amount为NULL则是没有消费的选手,GROUP BY聚合后COUNT(*)之

1148. 文章浏览 I

Views 表:

1
2
3
4
5
6
7
8
9
10
11
+---------------+---------+
| Column Name | Type |
+---------------+---------+
| article_id | int |
| author_id | int |
| viewer_id | int |
| view_date | date |
+---------------+---------+
此表无主键,因此可能会存在重复行。
此表的每一行都表示某人在某天浏览了某位作者的某篇文章。
请注意,同一人的 author_id 和 viewer_id 是相同的。

请编写一条 SQL 查询以找出所有浏览过自己文章的作者,结果按照 id 升序排列。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Views 表:
+------------+-----------+-----------+------------+
| article_id | author_id | viewer_id | view_date |
+------------+-----------+-----------+------------+
| 1 | 3 | 5 | 2019-08-01 |
| 1 | 3 | 6 | 2019-08-02 |
| 2 | 7 | 7 | 2019-08-01 |
| 2 | 7 | 6 | 2019-08-02 |
| 4 | 7 | 1 | 2019-07-22 |
| 3 | 4 | 4 | 2019-07-21 |
| 3 | 4 | 4 | 2019-07-21 |
+------------+-----------+-----------+------------+

结果表:
+------+
| id |
+------+
| 4 |
| 7 |
+------+
1
2
3
4
SELECT DISTINCT author_id id
FROM Views
WHERE author_id = viewer_id
ORDER BY author_id ASC;
1
2
##
所有浏览过自己文章的作者 -> author_id = viewer_id