本笔记为阿里云天池龙珠计划SQL训练营的学习内容，链接为：https://tianchi.aliyun.com/specials/promotion/aicampsql；

目录

Task03：复杂查询方法-视图、子查询、函数等

一、视图

二、子查询

标量子查询

关联子查询

三、实用函数

算数函数

字符串函数

日期函数

转换函数

四、谓词

LIKE谓词 – 用于字符串的部分一致查询

BETWEEN谓词 – 用于范围查询

IS NULL、 IS NOT NULL – 用于判断是否为NULL

IN谓词 – OR的简便用法

使用子查询作为IN谓词的参数

EXIST 谓词

五、CASE 表达式

六、练习题

七、总结

---

Task03：复杂查询方法-视图、子查询、函数等

一、视图

视图是一个虚拟的表，不同于直接操作数据表，视图是依据SELECT语句来创建的（会在下面具体介绍）。

视图与表的最大区别即：是否保存了实际的数据。视图可以看作是一个窗口，通过这个窗口我们可以看到数据库表中真实存在的数据。

视图最主要的优势就是通过定义视图可以将频繁使用的SELECT语句保存以提高效率。

/*创建视图的基本语法如下：
CREATE VIEW <视图名称>(<列名1>,<列名2>,...) AS <SELECT语句>
*/

视图不仅可以基于真实表，我们也可以在视图的基础上继续创建视图，但是这种操作应当避免，因为多重视图会降低效能。

定义视图时一般不能使用ORDER BY语句。因为视图和表一样，数据行都是没有顺序的。

• 基于单表的视图

我们在product表的基础上创建一个视图，如下：

CREATE VIEW productsum (product_type, cnt_product)
AS
SELECT product_type, COUNT(*)FROM productGROUP BY product_type ;

创建的视图如下图所示：

• 基于多表的视图

为了学习多表视图，我们再创建一张表，相关代码如下：

CREATE TABLE shop_product
(shop_id    CHAR(4)       NOT NULL,shop_name  VARCHAR(200)  NOT NULL,product_id CHAR(4)       NOT NULL,quantity   INTEGER       NOT NULL,PRIMARY KEY (shop_id, product_id));
INSERT INTO shop_product (shop_id, shop_name, product_id, quantity) VALUES ('000A',   '东京',     '0001',   30);
INSERT INTO shop_product (shop_id, shop_name, product_id, quantity) VALUES ('000A',   '东京',     '0002',   50);
INSERT INTO shop_product (shop_id, shop_name, product_id, quantity) VALUES ('000A',   '东京',     '0003',   15);
INSERT INTO shop_product (shop_id, shop_name, product_id, quantity) VALUES ('000B',   '名古屋',    '0002',   30);
INSERT INTO shop_product (shop_id, shop_name, product_id, quantity) VALUES ('000B',   '名古屋',    '0003',   120);
INSERT INTO shop_product (shop_id, shop_name, product_id, quantity) VALUES ('000B',   '名古屋',    '0004',   20);
INSERT INTO shop_product (shop_id, shop_name, product_id, quantity) VALUES ('000B',   '名古屋',    '0006',   10);
INSERT INTO shop_product (shop_id, shop_name, product_id, quantity) VALUES ('000B',   '名古屋',    '0007',   40);
INSERT INTO shop_product (shop_id, shop_name, product_id, quantity) VALUES ('000C',   '大阪',     '0003',   20);
INSERT INTO shop_product (shop_id, shop_name, product_id, quantity) VALUES ('000C',   '大阪',     '0004',   50);
INSERT INTO shop_product (shop_id, shop_name, product_id, quantity) VALUES ('000C',   '大阪',     '0006',   90);
INSERT INTO shop_product (shop_id, shop_name, product_id, quantity) VALUES ('000C',   '大阪',     '0007',   70);
INSERT INTO shop_product (shop_id, shop_name, product_id, quantity) VALUES ('000D',   '福冈',     '0001',   100);

我们在product表和shop_product表的基础上创建视图。

CREATE VIEW view_shop_product(product_type, sale_price, shop_name)
AS
SELECT product_type, sale_price, shop_nameFROM product,shop_productWHERE product.product_id = shop_product.product_id;

创建的视图如下图所示

我们可以在这个视图的基础上进行查询

SELECT sale_price, shop_nameFROM view_shop_productWHERE product_type = '衣服';

查询结果为：

视图的修改、更新、删除操作（一般皆不常用）如下：

/* 修改视图语句：
ALTER VIEW <视图名> AS <SELECT语句>
*/-- 其中视图名在数据库中需要是唯一的，不能与其他视图和表重名。/*一般不建议更新视图(update),不允许通过视图来修改表，例如：
UPDATE productsumSET sale_price = '5000'WHERE product_type = '办公用品';
视图虽然更新，但原表可能未按预期结果修改。
*//* 删除视图语句：
DROP VIEW <视图名1> [ , <视图名2> …]
*/

二、子查询

子查询指一个查询语句嵌套在另一个查询语句内部的查询，在 SELECT 子句中先计算子查询，子查询结果作为外层另一个查询的过滤条件，查询可以基于一个表或者多个表。

标量子查询

所谓单一就是要求我们执行的SQL语句只能返回一个值，也就是要返回表中具体的某一行的某一列。例如我们有下面这样一张表，执行一次标量子查询后是要返回类似于，“0004”，“菜刀”这样的结果。

product_id | product_name | sale_price
------------+-------------+----------
0003       | 运动T恤       | 4000
0004       | 菜刀          | 3000
0005       | 高压锅        | 6800

查询出销售单价高于平均销售单价的商品语句：

SELECT product_id, product_name, sale_priceFROM productWHERE sale_price > (SELECT AVG(sale_price) FROM product);  -- 由于WHERE子句中不能使用聚合函数，因此，要使用子查询

上面的这条语句首先后半部分查询出product表中的平均售价，前面的sql语句在根据WHERE条件挑选出合适的商品。
由于标量子查询的特性，导致标量子查询不仅仅局限于 WHERE 子句中，通常任何可以使用单一值的位置都可以使用。也就是说， 能够使用常数或者列名的地方，无论是 SELECT 子句、GROUP BY 子句、HAVING 子句，还是 ORDER BY 子句，几乎所有的地方都可以使用。

SELECT product_id,product_name,sale_price,(SELECT AVG(sale_price)FROM product) AS avg_priceFROM product;                      -- 因为先计算子查询，得出的结果在外部SELECT中当成常数，最后筛选出所有行的数据。SELECT product_id,product_name,sale_price,AVG(sale_price) as avg_priceFROM product;                      -- 因为聚合函数的影响，最后只得到一行的数据

关联子查询

关联子查询就是通过一些标志将内外两层的查询连接起来起到过滤数据的目的。

SELECT product_type, product_name, sale_priceFROM product ASp1WHERE sale_price > (SELECT AVG(sale_price)FROM product ASp2WHERE p1.product_type =p2.product_typeGROUP BY product_type);

该SQL语句将外面的product表标记为p1，将内部的product设置为p2，而且通过WHERE语句连接了两个查询。运行结果如下图所示

关联查询的执行过程可以简要的概括如下：

1. 首先执行不带WHERE的主查询
2. 根据主查询结果匹配product_type，获取子查询结果
3. 将子查询结果再与主查询结合执行完整的SQL语句

在子查询中像标量子查询，嵌套子查询或者关联子查询可以看作是子查询的一种操作方式即可，不用刻意记忆。

SELECT product_type, product_name, sale_priceFROM product ASp1WHERE sale_price > (SELECT AVG(sale_price)FROM product ASp2WHERE p1.product_type =p2.product_typeGROUP BY product_type);

再介绍一个工作中实用的with方法：

with p1 as     -- with <别名> as (select 语句) 其实是一种视图命名的方法
(
SELECT product_type, product_name, sale_priceFROM product ASp1WHERE sale_price > (SELECT AVG(sale_price)FROM product ASp2WHERE p1.product_type =p2.product_typeGROUP BY product_type);)select product_type from p1   -- 调用起来极其方便，减少了大量嵌套子查询的书写过程。

三、实用函数

以下介绍SQL中的常用函数

算数函数

• ABS – 绝对值

语法：ABS( 数值 )

ABS 函数用于计算一个数字的绝对值。当 ABS 函数的参数为NULL时，返回值也是NULL。

• MOD – 求余数

语法：MOD( 被除数，除数 )

MOD 是计算除法余数（求余）的函数，是 modulo 的缩写。小数没有余数的概念，只能对整数列求余数。

注意：主流的 DBMS 都支持 MOD 函数，只有SQL Server 不支持该函数，其使用%符号来计算余数。

• ROUND – 四舍五入（保留小数位数）

语法：ROUND( 对象数值，保留小数的位数 )

ROUND 函数用来进行四舍五入操作。保留小数的位数尽量不要使用为变量。

字符串函数

• CONCAT – 拼接

语法：CONCAT(str1, str2, str3)

• LENGTH – 字符串长度

语法：LENGTH( 字符串 )

• LOWER – 小写转换

LOWER 函数只能针对英文字母使用，它会将参数中的字符串全都转换为小写。该函数不适用于英文字母以外的场合，不影响原本就是小写的字符。

类似的， UPPER 函数用于大写转换。

• REPLACE – 字符串的替换

语法：REPLACE( 对象字符串，替换前的字符串，替换后的字符串 )

• SUBSTRING – 字符串的截取

语法：SUBSTRING （对象字符串 FROM 截取的起始位置 FOR 截取的字符数）

使用 SUBSTRING 函数 可以截取出字符串中的一部分字符串。截取的起始位置从字符串最左侧开始计算，索引值起始为1。部分地方使用时为substr()。

日期函数

不同DBMS的日期函数语法各有不同，本课程介绍一些被标准 SQL 承认的可以应用于绝大多数 DBMS 的函数。特定DBMS的日期函数查阅文档即可。

• CURRENT_DATE – 获取当前日期

SELECT CURRENT_DATE;
+--------------+
| CURRENT_DATE |
+--------------+
| 2020-08-08   |
+--------------+
1 row in set (0.00 sec)

• CURRENT_TIME – 当前时间

SELECT CURRENT_TIME;
+--------------+
| CURRENT_TIME |
+--------------+
| 17:26:09     |
+--------------+
1 row in set (0.00 sec)

• CURRENT_TIMESTAMP – 当前日期和时间

SELECT CURRENT_TIMESTAMP;
+---------------------+
| CURRENT_TIMESTAMP   |
+---------------------+
| 2020-08-08 17:27:07 |
+---------------------+
1 row in set (0.00 sec)

• EXTRACT – 截取日期元素

语法：EXTRACT(日期元素 FROM 日期)

使用 EXTRACT 函数可以截取出日期数据中的一部分，例如“年”

“月”，或者“小时”“秒”等。该函数的返回值并不是日期类型而是数值类型

SELECT CURRENT_TIMESTAMP as now,
EXTRACT(YEAR   FROM CURRENT_TIMESTAMP) AS year,
EXTRACT(MONTH  FROM CURRENT_TIMESTAMP) AS month,
EXTRACT(DAY    FROM CURRENT_TIMESTAMP) AS day,
EXTRACT(HOUR   FROM CURRENT_TIMESTAMP) AS hour,
EXTRACT(MINUTE FROM CURRENT_TIMESTAMP) AS MINute,
EXTRACT(SECOND FROM CURRENT_TIMESTAMP) AS second;
+---------------------+------+-------+------+------+--------+--------+
| now                 | year | month | day  | hour | MINute | second |
+---------------------+------+-------+------+------+--------+--------+
| 2020-08-08 17:34:38 | 2020 |     8 |    8 |   17 |     34 |     38 |
+---------------------+------+-------+------+------+--------+--------+
1 row in set (0.00 sec)

• timediff - 2个时间的时间差

语法：timediff(日期，日期)

转换函数

“转换”这个词的含义非常广泛，在 SQL 中主要有两层意思：一是数据类型的转换，简称为类型转换，在英语中称为cast；另一层意思是值的转换。

• CAST – 类型转换

语法：CAST（转换前的值 AS 想要转换的数据类型）

-- 将字符串类型转换为数值类型
SELECT CAST('0001' AS SIGNED INTEGER) AS int_col;
+---------+
| int_col |
+---------+
|       1 |
+---------+
1 row in set (0.00 sec)
-- 将字符串类型转换为日期类型
SELECT CAST('2009-12-14' AS DATE) AS date_col;
+------------+
| date_col   |
+------------+
| 2009-12-14 |
+------------+
1 row in set (0.00 sec)

• COALESCE – 将NULL转换为其他值（不常用）

语法：COALESCE(数据1，数据2，数据3……)

COALESCE 是 SQL 特有的函数。该函数会返回可变参数 A 中左侧开始第 1个不是NULL的值。参数个数是可变的，因此可以根据需要无限增加。

在 SQL 语句中将 NULL 转换为其他值时就会用到转换函数。

SELECT COALESCE(NULL, 11) AS col_1,
COALESCE(NULL, 'hello world', NULL) AS col_2,
COALESCE(NULL, NULL, '2020-11-01') AS col_3;
+-------+-------------+------------+
| col_1 | col_2       | col_3      |
+-------+-------------+------------+
|    11 | hello world | 2020-11-01 |
+-------+-------------+------------+
1 row in set (0.00 sec)

四、谓词

谓词的作用就是 “判断是否存在满足某种条件的记录”。

LIKE谓词 – 用于字符串的部分一致查询

当需要进行字符串的部分一致查询时需要使用该谓词。

• %是代表“零个或多个任意字符串”的特殊符号
• _下划线匹配任意 1 个字符

SELECT *
FROM samplelike
WHERE strcol LIKE 'ddd%';  -- 匹配strcol字段中以ddd开头的记录SELECT *
FROM samplelike
WHERE strcol LIKE '%ddd%';  -- 匹配strcol字段中只要包含ddd的记录即可，不论ddd出现在开头、结尾等任意位置SELECT *
FROM samplelike
WHERE strcol LIKE 'ddd%'; -- 匹配strcol字段中以ddd结尾的记录SELECT *
FROM samplelike
WHERE strcol LIKE 'ddd__'; -- 匹配strcol字段中以ddd开头，且末尾为任意2个字符的总长为5个字符的记录

BETWEEN谓词 – 用于范围查询

使用 BETWEEN 可以进行范围查询，且为闭区间。

-- 选取销售单价为100～ 1000元的商品
SELECT product_name, sale_price
FROM product
WHERE sale_price BETWEEN 100 AND 1000;/*BETWEEN 的特点就是结果中会包含 100 和 1000 这两个临界值，也就是闭区间。
如果不想让结果中包含临界值，那就必须使用 < 和 >。
*/SELECT product_name, sale_price
FROM product
WHERE sale_price > 100
AND sale_price < 1000;

IS NULL、 IS NOT NULL – 用于判断是否为NULL

为了选取出某些值为 NULL 的列的数据，不能使用 =，而只能使用特定的谓词IS NULL。

SELECT product_name, purchase_price
FROM product
WHERE purchase_price IS NULL;-- 与此相反，想要选取 NULL 以外的数据时，需要使用IS NOT NULL。SELECT product_name, purchase_price
FROM product
WHERE purchase_price IS NOT NULL;

IN谓词 – OR的简便用法

多个查询条件取并集时可以选择使用or语句。

-- 通过OR指定多个进货单价进行查询
SELECT product_name, purchase_price
FROM product
WHERE purchase_price = 320
OR purchase_price = 500
OR purchase_price = 5000;-- 虽然上述方法没有问题，但还是存在一点不足之处，那就是随着希望选取的对象越来越多， SQL 语句也会越来越长，阅读起来也会越来越困难。这时， 我们就可以使用IN 谓词
-- IN(值1, 值2, 值3, …)来替换上述 SQL 语句。
SELECT product_name, purchase_price
FROM product
WHERE purchase_price IN (320, 500, 5000);-- 上述语句简洁了很多，可读性大幅提高。
-- 反之，希望选取出“进货单价不是 320 元、 500 元、 5000 元”的商品时，可以使用否定形式NOT IN来实现。
SELECT product_name, purchase_price
FROM product
WHERE purchase_price NOT IN (320, 500, 5000);

需要注意的是，在使用IN 和 NOT IN 时是无法选取出NULL数据的。
实际结果也是如此，上述两组结果中都不包含进货单价为 NULL 的产品。 NULL 只能使用 IS NULL 和 IS NOT NULL 来进行判断。 

使用子查询作为IN谓词的参数

IN 谓词（NOT IN 谓词）具有其他谓词所没有的用法，那就是可以使用子查询作为其参数。子查询就是 SQL内部生成的表，因此也可以说“能够将表作为 IN 的参数”，也能够将视图作为 IN 的参数。

在此，我们创建一张新表shopproduct显示出哪些商店销售哪些商品。

-- DDL ：创建表
DROP TABLE IF EXISTS shopproduct;
CREATE TABLE shopproduct
(  shop_id CHAR(4)     NOT NULL,shop_name VARCHAR(200) NOT NULL,
product_id CHAR(4)      NOT NULL,quantity INTEGER      NOT NULL,
PRIMARY KEY (shop_id, product_id) -- 指定主键
);
-- DML ：插入数据
START TRANSACTION; -- 开始事务
INSERT INTO shopproduct (shop_id, shop_name, product_id, quantity) VALUES ('000A', '东京', '0001', 30);
INSERT INTO shopproduct (shop_id, shop_name, product_id, quantity) VALUES ('000A', '东京', '0002', 50);
INSERT INTO shopproduct (shop_id, shop_name, product_id, quantity) VALUES ('000A', '东京', '0003', 15);
INSERT INTO shopproduct (shop_id, shop_name, product_id, quantity) VALUES ('000B', '名古屋', '0002', 30);
INSERT INTO shopproduct (shop_id, shop_name, product_id, quantity) VALUES ('000B', '名古屋', '0003', 120);
INSERT INTO shopproduct (shop_id, shop_name, product_id, quantity) VALUES ('000B', '名古屋', '0004', 20);
INSERT INTO shopproduct (shop_id, shop_name, product_id, quantity) VALUES ('000B', '名古屋', '0006', 10);
INSERT INTO shopproduct (shop_id, shop_name, product_id, quantity) VALUES ('000B', '名古屋', '0007', 40);
INSERT INTO shopproduct (shop_id, shop_name, product_id, quantity) VALUES ('000C', '大阪', '0003', 20);
INSERT INTO shopproduct (shop_id, shop_name, product_id, quantity) VALUES ('000C', '大阪', '0004', 50);
INSERT INTO shopproduct (shop_id, shop_name, product_id, quantity) VALUES ('000C', '大阪', '0006', 90);
INSERT INTO shopproduct (shop_id, shop_name, product_id, quantity) VALUES ('000C', '大阪', '0007', 70);
INSERT INTO shopproduct (shop_id, shop_name, product_id, quantity) VALUES ('000D', '福冈', '0001', 100);
COMMIT; -- 提交事务
SELECT * FROM shopproduct;
+---------+-----------+------------+----------+
| shop_id | shop_name | product_id | quantity |
+---------+-----------+------------+----------+
| 000A    | 东京      | 0001       |       30 |
| 000A    | 东京      | 0002       |       50 |
| 000A    | 东京      | 0003       |       15 |
| 000B    | 名古屋      | 0002       |       30 |
| 000B    | 名古屋      | 0003       |      120 |
| 000B    | 名古屋      | 0004       |       20 |
| 000B    | 名古屋      | 0006       |       10 |
| 000B    | 名古屋      | 0007       |       40 |
| 000C    | 大阪      | 0003       |       20 |
| 000C    | 大阪      | 0004       |       50 |
| 000C    | 大阪      | 0006       |       90 |
| 000C    | 大阪      | 0007       |       70 |
| 000D    | 福冈      | 0001       |      100 |
+---------+-----------+------------+----------+
13 rows in set (0.00 sec)

由于单独使用商店编号（shop_id）或者商品编号（product_id）不能区分表中每一行数据
，因此指定了 2 列作为主键（primary key）对商店和商品进行组合，用来唯一确定每一行数据。

假设我么需要取出大阪在售商品的销售单价，该如何实现呢？

第一步，取出大阪门店的在售商品 `product_id ;

第二步，取出大阪门店在售商品的销售单价 `sale_price

-- step1：取出大阪门店的在售商品 `product_id`
SELECT product_id
FROM shopproduct
WHERE shop_id = '000C';
+------------+
| product_id |
+------------+
| 0003       |
| 0004       |
| 0006       |
| 0007       |
+------------+
4 rows in set (0.00 sec)

上述语句取出了大阪门店的在售商品编号，接下来，我么可以使用上述语句作为第二步的查询条件来使用了。

-- step2：取出大阪门店在售商品的销售单价 `sale_price`
SELECT product_name, sale_price
FROM product
WHERE product_id IN (SELECT product_idFROM shopproductWHERE shop_id = '000C');
+--------------+------------+
| product_name | sale_price |
+--------------+------------+
| 运动T恤      |       4000 |
| 菜刀         |       3000 |
| 叉子         |        500 |
| 擦菜板       |        880 |
+--------------+------------+
4 rows in set (0.00 sec)

由于子查询是从最内层开始执行的（由内而外），因此，上述语句的子查询执行之后，sql 展开成下面的语句

-- 子查询展开后的结果
SELECT product_name, sale_price
FROM product
WHERE product_id IN ('0003', '0004', '0006', '0007');
+--------------+------------+
| product_name | sale_price |
+--------------+------------+
| 运动T恤      |       4000 |
| 菜刀         |       3000 |
| 叉子         |        500 |
| 擦菜板       |        880 |
+--------------+------------+
4 rows in set (0.00 sec)

可以看到，子查询转换之后变为 in 谓词用法。

既然 in 谓词也能实现，那为什么还要使用子查询呢？这里给出两点原因：

①：实际生活中，某个门店的在售商品是不断变化的，使用 in 谓词就需要经常更新 sql 语句，降低了效率，提高了维护成本；

②：实际上，某个门店的在售商品可能有成百上千个，手工维护在售商品编号真是个大工程。

使用子查询即可保持 sql 语句不变，极大提高了程序的可维护性，这是系统开发中需要重点考虑的内容。

• NOT IN和子查询

NOT IN 同样支持子查询作为参数，用法和 in 完全一样。

-- NOT IN 使用子查询作为参数，取出未在大阪门店销售的商品的销售单价
SELECT product_name, sale_priceFROM productWHERE product_id NOT IN (SELECT product_idFROM shopproductWHERE shop_id = '000A');
+--------------+------------+
| product_name | sale_price |
+--------------+------------+
| 菜刀         |       3000 |
| 高压锅       |       6800 |
| 叉子         |        500 |
| 擦菜板       |        880 |
| 圆珠笔       |        100 |
+--------------+------------+
5 rows in set (0.00 sec)

EXIST 谓词

即使不使用 EXIST，基本上也都可以使用 IN（或者 NOT IN）来代替。（可以不常使用）

我们继续以 IN和子查询 中的示例，使用 EXIST 选取出大阪门店在售商品的销售单价。

SELECT product_name, sale_priceFROM product AS pWHERE EXISTS (SELECT *FROM shopproduct AS spWHERE sp.shop_id = '000C'AND sp.product_id = p.product_id);
+--------------+------------+
| product_name | sale_price |
+--------------+------------+
| 运动T恤      |       4000 |
| 菜刀         |       3000 |
| 叉子         |        500 |
| 擦菜板       |        880 |
+--------------+------------+
4 rows in set (0.00 sec)

之前我们学过的谓词，基本上都是像“列 LIKE 字符串”或者“ 列 BETWEEN 值 1 AND 值 2”这样需要指定 2 个以上的参数，而 EXIST 的左侧并没有任何参数。因为 EXIST 是只有 1 个参数的谓词。 所以，EXIST 只需要在右侧书写 1 个参数，该参数通常都会是一个子查询。

(SELECT *FROM shopproduct AS spWHERE sp.shop_id = '000C'AND sp.product_id = p.product_id)

上面这样的子查询就是唯一的参数。确切地说，由于通过条件“SP.product_id = P.product_id”将 product 表和 shopproduct表进行了联接，因此作为参数的是关联子查询。 EXIST 通常会使用关联子查询作为参数。

• 子查询中的SELECT *

由于 EXIST 只关心记录是否存在，因此返回哪些列都没有关系。 EXIST 只会判断是否存在满足子查询中 WHERE 子句指定的条件“商店编号（shop_id）为 '000C'，商品（product）表和商店

商品（shopproduct）表中商品编号（product_id）相同”的记录，只有存在这样的记录时才返回真（TRUE）。

因此，使用下面的查询语句，查询结果也不会发生变化。

SELECT product_name, sale_priceFROM product AS pWHERE EXISTS (SELECT 1 -- 这里可以书写适当的常数FROM shopproduct AS spWHERE sp.shop_id = '000C'AND sp.product_id = p.product_id);
+--------------+------------+
| product_name | sale_price |
+--------------+------------+
| 运动T恤      |       4000 |
| 菜刀         |       3000 |
| 叉子         |        500 |
| 擦菜板       |        880 |
+--------------+------------+
4 rows in set (0.00 sec)

可以把EXIST 的子查询中书写 SELECT * 当作 SQL 的一种习惯

• 使用NOT EXIST替换NOT IN

就像 EXIST 可以用来替换 IN 一样， NOT IN 也可以用NOT EXIST来替换。

下面的代码示例取出，不在大阪门店销售的商品的销售单价。

SELECT product_name, sale_priceFROM product AS pWHERE NOT EXISTS (SELECT *FROM shopproduct AS spWHERE sp.shop_id = '000A'AND sp.product_id = p.product_id);
+--------------+------------+
| product_name | sale_price |
+--------------+------------+
| 菜刀         |       3000 |
| 高压锅       |       6800 |
| 叉子         |        500 |
| 擦菜板       |        880 |
| 圆珠笔       |        100 |
+--------------+------------+
5 rows in set (0.00 sec)

五、CASE 表达式

一些难度较高的SQL笔试题中，case出现频次较高，此函数平常工作场景也十分常见，需要重点掌握。

CASE 表达式是在区分情况时使用的，这种情况的区分在编程中通常称为（条件）分支。

CASE表达式的语法分为简单CASE表达式和搜索CASE表达式两种。由于搜索CASE表达式包含简单CASE表达式的全部功能。本课程将重点介绍搜索CASE表达式。

-- case语法
CASE WHEN <求值表达式> THEN <表达式>WHEN <求值表达式> THEN <表达式>WHEN <求值表达式> THEN <表达式>...
ELSE <表达式>
END

上述语句执行时，依次判断 when 表达式是否为真值，是则执行 THEN 后的语句，如果所有的 when 表达式均为假，则执行 ELSE 后的语句。
无论多么庞大的 CASE 表达式，最后也只会返回一个值。

假设现在 要实现如下结果：

A ：衣服
B ：办公用品
C ：厨房用具

因为表中的记录并不包含“A ： ”或者“B ： ”这样的字符串，所以需要在 SQL 中进行添加。并将“A ： ”“B ： ”“C ： ”与记录结合起来。

• 应用场景1：根据不同分支得到不同列值

SELECT  product_name,CASE WHEN product_type = '衣服' THEN CONCAT('A ： ',product_type)WHEN product_type = '办公用品'  THEN CONCAT('B ： ',product_type)WHEN product_type = '厨房用具'  THEN CONCAT('C ： ',product_type)ELSE NULLEND AS abc_product_typeFROM  product;
+--------------+------------------+
| product_name | abc_product_type |
+--------------+------------------+
| T恤          | A ： 衣服        |
| 打孔器       | B ： 办公用品    |
| 运动T恤      | A ： 衣服        |
| 菜刀         | C ： 厨房用具    |
| 高压锅       | C ： 厨房用具    |
| 叉子         | C ： 厨房用具    |
| 擦菜板       | C ： 厨房用具    |
| 圆珠笔       | B ： 办公用品    |
+--------------+------------------+
8 rows in set (0.00 sec)

ELSE 子句也可以省略不写，这时会被默认为 ELSE NULL。但为了防止有人漏读，还是希望大家能够显示地写出 ELSE 子句。
此外， CASE 表达式最后的“END”是不能省略的，请大家特别注意不要遗漏。忘记书写 END 会发生语法错误，这也是初学时最容易犯的错误。

• 应用场景2：实现列方向上的聚合

通常我们使用如下代码实现行的方向上不同种类的聚合（这里是 sum）

SELECT product_type,SUM(sale_price) AS sum_priceFROM productGROUP BY product_type;
+--------------+-----------+
| product_type | sum_price |
+--------------+-----------+
| 衣服         |      5000 |
| 办公用品      |       600 |
| 厨房用具      |     11180 |
+--------------+-----------+
3 rows in set (0.00 sec)

假如要在列的方向上展示不同种类额聚合值，该如何写呢？

sum_price_clothes | sum_price_kitchen | sum_price_office
------------------+-------------------+-----------------5000 |             11180 |              600

聚合函数 + CASE WHEN 表达式即可实现该效果

-- 对按照商品种类计算出的销售单价合计值进行行列转换
SELECT SUM(CASE WHEN product_type = '衣服' THEN sale_price ELSE 0 END) AS sum_price_clothes,SUM(CASE WHEN product_type = '厨房用具' THEN sale_price ELSE 0 END) AS sum_price_kitchen,SUM(CASE WHEN product_type = '办公用品' THEN sale_price ELSE 0 END) AS sum_price_officeFROM product;
+-------------------+-------------------+------------------+
| sum_price_clothes | sum_price_kitchen | sum_price_office |
+-------------------+-------------------+------------------+
|              5000 |             11180 |              600 |
+-------------------+-------------------+------------------+
1 row in set (0.00 sec)

• （扩展内容）应用场景3：实现行转列

假设有如下图表的结构

计划得到如下的图表结构

聚合函数 + CASE WHEN 表达式即可实现该转换

-- CASE WHEN 实现数字列 score 行转列
SELECT name,SUM(CASE WHEN subject = '语文' THEN score ELSE null END) as chinese,SUM(CASE WHEN subject = '数学' THEN score ELSE null END) as math,SUM(CASE WHEN subject = '外语' THEN score ELSE null END) as englishFROM scoreGROUP BY name;
+------+---------+------+---------+
| name | chinese | math | english |
+------+---------+------+---------+
| 张三 |      93 |   88 |      91 |
| 李四 |      87 |   90 |      77 |
+------+---------+------+---------+
2 rows in set (0.00 sec)

上述代码实现了数字列 score 的行转列，也可以实现文本列 subject 的行转列（不常用）

-- CASE WHEN 实现文本列 subject 行转列
SELECT name,MAX(CASE WHEN subject = '语文' THEN subject ELSE null END) as chinese,MAX(CASE WHEN subject = '数学' THEN subject ELSE null END) as math,MIN(CASE WHEN subject = '外语' THEN subject ELSE null END) as englishFROM scoreGROUP BY name;
+------+---------+------+---------+
| name | chinese | math | english |
+------+---------+------+---------+
| 张三 | 语文    | 数学 | 外语    |
| 李四 | 语文    | 数学 | 外语    |
+------+---------+------+---------+
2 rows in set (0.00 sec

六、练习题

1. 创建出满足下述三个条件的视图（视图名称为 ViewPractice5_1）。使用 product（商品）表作为参照表，假设表中包含初始状态的 8 行数据。

• 条件 1：销售单价大于等于 1000 日元。
• 条件 2：登记日期是 2009 年 9 月 20 日。
• 条件 3：包含商品名称、销售单价和登记日期三列。

对该视图执行 SELECT 语句的结果如下所示。

SELECT * FROM ViewPractice5_1;

执行结果

product_name | sale_price | regist_date
--------------+------------+------------
T恤衫         | 　 1000    | 2009-09-20
菜刀          |    3000    | 2009-09-20

回答如下：

/*按TASK1的内容建表;
过程中遇到个坑：关于建表后编码问题，product_name,product_type无法识别中文字符串；
将表中字段改为utf8mb4即解决。*/
CREATE TABLE product(product_id CHAR(4) NOT NULL, product_name VARCHAR(100) NOT NULL, product_type VARCHAR(32) NOT NULL, sale_price INTEGER, purchase_price INTEGER, regist_date DATE, PRIMARY KEY(product_id))  ;alter table PRODUCT character set  utf8;alter table product change product_type product_type varchar(32) CHARACTER SET utf8mb4;
show create table product;
INSERT INTO product VALUES('0001', 'T恤衫' , '衣服', 1000, 500, '2009-09-20');
INSERT INTO product VALUES('0002', '打孔器', '办公用品', 500, 320, '2009-09-11');
INSERT INTO product VALUES('0003', '运动T恤', '衣服', 4000, 2800, NULL);
INSERT INTO product VALUES('0004', '菜刀', '厨房用具', 3000, 2800, '2009-09-20');
INSERT INTO product VALUES('0005', '高压锅', '厨房用具', 6800, 5000, '2009-01-15');
INSERT INTO product VALUES('0006', '叉子', '厨房用具', 500, NULL, '2009-09-20');
INSERT INTO product VALUES('0007', '擦菜板', '厨房用具', 880, 790, '2008-04-28');
INSERT INTO product VALUES('0008', '圆珠笔', '办公用品', 100, NULL, '2009-11-11');
select * from product;-- 创建视图create view ViewPractice5_1
as
(select product_name,sale_price,regist_datefrom productwhere sale_price>=1000and regist_date = '2009-09-20');select * from ViewPractice5_1 ;

2.向习题一中创建的视图 ViewPractice5_1 中插入如下数据，会得到什么样的结果呢？

INSERT INTO ViewPractice5_1 VALUES (' 刀子 ', 300, '2009-11-02');

报错，不是因为需要按照顺序添加数据。而是视图插入数据时，原表也会插入数据，而原表数据插入时不满足约束条件，原表有3个NOT NULL的约束字段。不过也不建议往视图中插入数据。

3.请根据如下结果编写 SELECT 语句，其中 sale_price_all 列为全部商品的平均销售单价。

product_id | product_name | product_type | sale_price | sale_price_all
------------+-------------+--------------+------------+---------------------
0001       | T恤衫         | 衣服         | 1000       | 2097.5000000000000000
0002       | 打孔器        | 办公用品      | 500        | 2097.5000000000000000
0003       | 运动T恤       | 衣服          | 4000      | 2097.5000000000000000
0004       | 菜刀          | 厨房用具      | 3000       | 2097.5000000000000000
0005       | 高压锅        | 厨房用具      | 6800       | 2097.5000000000000000
0006       | 叉子          | 厨房用具      | 500        | 2097.5000000000000000
0007       | 擦菜板        | 厨房用具       | 880       | 2097.5000000000000000
0008       | 圆珠笔        | 办公用品       | 100       | 2097.5000000000000000

select product_id,product_name,product_type,sale_price, (select avg(sale_price) from product) as sale_price_allfrom product

4.请根据习题一中的条件编写一条 SQL 语句，创建一幅包含如下数据的视图（名称为AvgPriceByType）。

product_id | product_name | product_type | sale_price | avg_sale_price
------------+-------------+--------------+------------+---------------------
0001       | T恤衫         | 衣服         | 1000       |2500.0000000000000000
0002       | 打孔器         | 办公用品     | 500        | 300.0000000000000000
0003       | 运动T恤        | 衣服        | 4000        |2500.0000000000000000
0004       | 菜刀          | 厨房用具      | 3000        |2795.0000000000000000
0005       | 高压锅         | 厨房用具     | 6800        |2795.0000000000000000
0006       | 叉子          | 厨房用具      | 500         |2795.0000000000000000
0007       | 擦菜板         | 厨房用具     | 880         |2795.0000000000000000
0008       | 圆珠笔         | 办公用品     | 100         | 300.0000000000000000

提示：其中的关键是 avg_sale_price 列。与习题三不同，这里需要计算出的 是各商品种类的平均销售单价。这与使用关联子查询所得到的结果相同。 也就是说，该列可以使用关联子查询进行创建。问题就是应该在什么地方使用这个关联子查询。

create view AvgPriceByType as
(select product_id,product_name,p.product_type,sale_price ,avg_sale_pricefrom product p ,(select avg(sale_price) as avg_sale_price ,product_typefrom product group by product_type) q where p.product_type = q.product_type) ;select * from AvgPriceByType;-- SELECT等同于以下：
select product_id,product_name,p.product_type,sale_price,(select avg(sale_price) from product p2where p1.product_type = p2.product_typegroup by p1.product_type) as avg_sale_price
from product p;

5.运算或者函数中含有 NULL 时，结果全都会变为NULL ？（判断题）

答案是对的。经实验CONCAT（）的确如此。但是我想说COALESCE()?

6.对本章中使用的 product（商品）表执行如下 2 条 SELECT 语句，能够得到什么样的结果呢？

①

SELECT product_name, purchase_priceFROM productWHERE purchase_price NOT IN (500, 2800, 5000);

匹配除了purchase_price = 500or2800or5000的记录 ，即=320，790的2条数据

②

SELECT product_name, purchase_priceFROM productWHERE purchase_price NOT IN (500, 2800, 5000, NULL);

此时无任何数据。匹配失败，不要这么使用。NOT IN参数中不能含NULL，否则结果为空。

7.按照销售单价（ sale_price）对练习 6.1 中的 product（商品）表中的商品进行如下分类。

• 低档商品：销售单价在1000日元以下（T恤衫、办公用品、叉子、擦菜板、 圆珠笔）
• 中档商品：销售单价在1001日元以上3000日元以下（菜刀）
• 高档商品：销售单价在3001日元以上（运动T恤、高压锅）

请编写出统计上述商品种类中所包含的商品数量的 SELECT 语句，结果如下所示。

执行结果

low_price | mid_price | high_price
----------+-----------+------------5 |         1 |         2

 select sum(case when sale_price<=1000 then 1 else 0  end) low_price,sum(case when sale_price between 1001  and 3000 then 1 else 0 end)mid_price,sum(case when sale_price>=3001 then 1 else 0  end) high_pricefrom product

七、总结

本章节干货满满，几乎都是日常工作中常用的函数/功能。视图可以简化子查询的过程，增强可读性。各种实用函数和谓词需要熟练掌握。

【阿里云天池龙珠计划SQL训练营】SQL复习Task3相关推荐

1. Python基础入门（中）--阿里云天池龙珠计划python训练营

   一.学习内容概况 学习地址:天池龙珠计划python训练营 今天主要学习到的内容有: 列表 元祖 字符串 字典 集合 序列 二.具体学习内容 1.列表 简单数据类型 整型<class 'int' ...

2. 【学习笔记】阿里云天池龙珠计划SQL训练营-Task06：综合练习题-10道经典题目

   本笔记为阿里云天池龙珠计划SQL训练营的学习内容 链接为:https://tianchi.aliyun.com/specials/promotion/aicampsql 练习题1: 请使用A股上市公司 ...

3. 本笔记为阿里云天池龙珠计划SQL训练营的学习内容，链接为：https://tianchi.aliyun.com/specials/promotion/aicampsql” Task06学习笔记

   本笔记为阿里云天池龙珠计划SQL训练营的学习内容,链接为:https://tianchi.aliyun.com/specials/promotion/aicampsql" Task06学习笔 ...

4. 阿里云天池龙珠计划SQL训练营Task03：复杂查询方法-视图、子查询、函数等

   本笔记为阿里云天池龙珠计划SQL训练营的学习内容,链接为:https://tianchi.aliyun.com/specials/promotion/aicampsql: 3.1 视图 我们先来看一个 ...

5. 【阿里云天池龙珠计划SQL训练营】SQL复习Task2

   本笔记为阿里云天池龙珠计划SQL训练营的学习内容,链接为:https://tianchi.aliyun.com/specials/promotion/aicampsql: 目录 Task02:SQL基 ...

6. 阿里云天池龙珠计划SQL训练营Task 1:初识数据库与SQL

   本笔记为阿里云天池龙珠计划SQL训练营的学习内容,链接为:https://tianchi.aliyun.com/specials/promotion/aicampsql: 一.初识数据库 数据库是将大 ...

7. 阿里云天池龙珠计划SQL训练营Task04：集合运算-表的加减法和join等

   本笔记为阿里云天池龙珠计划SQL训练营的学习内容,链接为:https://tianchi.aliyun.com/specials/promotion/aicampsql: 4.1表的加减法 4.1.1 ...

8. 阿里云天池龙珠计划SQL训练营——Day2

   Day 2: 本笔记为阿里云天池龙珠计划SQL训练营的学习内容,链接为:https://tianchi.aliyun.com/specials/promotion/aicampsql: 比较运算符:& ...

9. python海龟图画龙珠_阿里云天池龙珠计划——Python基础入门第2课：变量和赋值...

   阿里云天池龙珠计划--Python基础入门第2课:变量和赋值 [我是测试题2]下面这段代码的运行结果是什么? # 运行一下结果就出来了 a = "hello" b = " ...

最新文章

1. 恩智浦AI视觉组之逐飞岁末彩蛋
2. Linux(Centos)之安装Redis及注意事项
3. RunLoop深度探究以及有关面试题
4. 可能存在无限递归_做事永远无头无尾？人生中的递归现象
5. 网易云的朋友给我这份339页的Android面经，成功入职阿里
6. 如何利用openSsl来计算一个文件的md5值？
7. pythonmessage用法_请问Mac下如何用python读取iMessage信息？
8. C++——《算法分析》实验贰——最长公共子序列问题
9. 从零开始学Pytorch（八）之Modern CNN
10. 容器入门（2） - podman
11. 水很深的深度学习-Task05循环神经网络RNN
12. 搜索引擎中影响索引长度的因素
13. 将bean转换成键值列表
14. Python 学习笔记 （6）—— 读写文件
15. java.net cidr接口_CIDR - xiaohuazi - 博客园
16. 在 MAC下安装 Exuberant ctags
17. python 返回函数，偏函数，装饰器，itertools，collections，dir()type（）
18. 华为手机鸿蒙系统下载,华为鸿蒙系统手机版
19. 可汗学院公开课：统计学笔记——基础知识、二项及泊松分布 、大数定律、正态分布
20. linux内核函数之 blk_plug

热门文章

1. 微信小程序中如何修改数组指定元素（或对象）
2. 为什么说多功能智慧路灯杆是智慧城市大数据采集的入口？
3. win10 录屏快捷键
4. python将txt文件按行数分成多个txt文件
5. 简单的cmd切换路径
6. 3D图形学（10）：游戏中的加速渲染算法
7. 计算机主板 原理,计算机主板的工作原理（二）
8. OPPOR9s 官方原厂售后线刷包救砖包解账户锁屏幕锁
9. 黑客神技！看我如何用Python跟踪个人财务！会计随身携带？让自己的每一笔收支都明细！
10. Netty实战 IM即时通讯系统（一）IM系统简介