• [PSQL] 函数、谓词、CASE表达式

    SQL基础教程读书笔记 MICK，第6章 函数、谓词、CASE表达式，第7章 集合运算

    示例程序下载 http://www.ituring.com.cn/book/1880

    说明：如下笔记中的测试基于postgresql14

    命令行连接本地PSQL：  psql -U -d -h 127.0.0.1 -W

    目录

    6 函数、谓词、CASE表达式

    6-1 各种各样的函数

    算术函数

    字符串函数

    日期函数

    转换函数

    6-2 谓词

    目录

    6 函数、谓词、CASE表达式

    6-1 各种各样的函数

    算术函数

    字符串函数

    日期函数

    转换函数

    6-2 谓词

    LIKE谓词——字符串的部分一致查询

    BETWEEN谓词——范围查询

    IS NULL、IS NOT NULL——判断是否为NULL

    IN谓词——OR的简便用法

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

    EXIST谓词

    6-3 CASE表达式

    CASE表达式的语法

    CAS表达式的使用方法

    7 集合运算

    7-1 表的加减法

    表的加法 UNION

    包含重复行的集合运算 ALL选项

    集合运算的注意事项

    选取表中公共部分(交集) INTERSECT

    记录的减法 EXCEPT

    7-2 联结（以列为单位对表进行联结）

    内联结 INNER JOIN

    外联结——OUTER JOIN

    LIKE谓词——字符串的部分一致查询

    BETWEEN谓词——范围查询

    IS NULL、IS NOT NULL——判断是否为NULL

    IN谓词——OR的简便用法

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

    EXIST谓词

    6-3 CASE表达式

    CASE表达式的语法

    CAS表达式的使用方法

    6 函数、谓词、CASE表达式

    6-1 各种各样的函数

    函数大致可以分为以下几种
    - 算术函数（用来进行数值计算的函数）
    - 字符串函数（用来进行字符串操作的函数）
    - 日期函数（用来进行日期操作的函数）
    - 转换函数（用来转换数据类型和值的函数）
    - 聚合函数（用来进行数据聚合的函数）

    算术函数

    +（加法）
    -（减法）
    *（乘法）
    /（除法）

    语法6-1　ABS函数 -> 绝对值
    ABS(数值)

    语法6-2　MOD函数 -> 求余
    MOD(被除数，除数)

    语法6-3　ROUND函数 -> 四舍五入
    ROUND(对象数值，保留小数的位数)

    字符串函数

    语法6-4　||函数-拼接
    字符串1||字符串2

    说明：
    SQL Server使用“+”运算符（函数）来连接字符串
    MySQL使用CONCAT函数来完成字符串的拼接

    语法6-5　LENGTH函数 -> 字符串长度
    LENGTH(字符串)

    语法6-6　LOWER函数 -> 小写转换
    LOWER(字符串)

    语法6-7　REPLACE函数 -> 字符串的替换
    REPLACE(对象字符串，替换前的字符串，替换后的字符串)

    语法6-8　SUBSTRING函数（PostgreSQL/MySQL专用语法）-> 字符串的截取
    SUBSTRING（对象字符串 FROM 截取的起始位置 FOR 截取的字符数）
    说明：第1个字符位置就是1

    语法6-9　UPPER函数 -> 大写转换
    UPPER(字符串)

    日期函数

    语法6-10　CURRENT_DATE函数 -> 当前日期
    CURRENT_DATE

    代码清单6-13　获得当前日期

    1. shop=# SELECT CURRENT_DATE;
    2.  current_date
    3. --------------
    4.  2022-07-30
    5. (1 row)
    6.  
    7. shop=#

    语法6-11　CURRENT_TIME函数 -> 当前时间
    CURRENT_TIME

    代码清单6-14　取得当前时间

    1. shop=# SELECT CURRENT_TIME;
    2.     current_time
    3. --------------------
    4.  23:09:52.434122+08
    5. (1 row)
    6.  
    7. shop=#

    语法6-12　CURRENT_TIMESTAMP函数 -> 当前日期和时间
    CURRENT_TIMESTAMP

    代码清单6-15　取得当前日期和时间

    1. shop=# SELECT CURRENT_TIMESTAMP;
    2.        current_timestamp
    3. -------------------------------
    4.  2022-07-30 23:12:27.701212+08
    5. (1 row)
    6.  
    7. shop=#

    语法6-13　EXTRACT函数 -> 截取日期元素
    EXTRACT(日期元素 FROM 日期)

    代码清单6-16　截取日期元素

    1. shop=# SELECT CURRENT_TIMESTAMP,
    2. shop-#  EXTRACT(YEAR FROM CURRENT_TIMESTAMP) AS year,
    3. shop-#  EXTRACT(MONTH FROM CURRENT_TIMESTAMP) AS month,
    4. shop-#  EXTRACT(DAY FROM CURRENT_TIMESTAMP) AS day,
    5. shop-#  EXTRACT(HOUR FROM CURRENT_TIMESTAMP) AS hour,
    6. shop-#  EXTRACT(MINUTE FROM CURRENT_TIMESTAMP) AS minute,
    7. shop-#  EXTRACT(SECOND FROM CURRENT_TIMESTAMP) AS second;
    8.        current_timestamp       | year | month | day | hour | minute |  second
    9. -------------------------------+------+-------+-----+------+--------+-----------
    10.  2022-07-30 23:13:51.576628+08 | 2022 |     7 |  30 |   23 |     13 | 51.576628
    11. (1 row)
    12.  
    13. shop=#

    转换函数

    语法6-14　CAST函数 -> 类型转换
    CAST（转换前的值 AS 想要转换的数据类型）

    代码清单6-17　将字符串类型转换为数值类型

    SQL Server，PostgreSQL

    1. shop=# SELECT CAST('0001' AS INTEGER) AS int_col;
    2.  int_col
    3. ---------
    4.        1
    5. (1 row)
    6.  
    7. shop=#

    MySQL
    SELECT CAST('0001' AS SIGNED INTEGER) AS int_col;

    代码清单6-18　将字符串类型转换为日期类型

    SQL Server， PostgreSQL， MySQL

    1. shop=# SELECT CAST('2009-12-14' AS DATE) AS date_col;
    2.   date_col
    3. ------------
    4.  2009-12-14
    5. (1 row)
    6.  
    7. shop=#

    语法6-15　COALESCE函数 -> 将NULL转换为其他值
    COALESCE(数据1，数据2，数据3……)

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

    代码清单6-19　将NULL转换为其他值
    SQL Server,PostgreSQL,MySQL

    1. shop=# SELECT COALESCE(NULL, 1) AS col_1,
    2. shop-#  COALESCE(NULL, 'test', NULL) AS col_2,
    3. shop-#  COALESCE(NULL, NULL, '2009-11-01') AS col_3;
    4.  col_1 | col_2 |   col_3
    5. -------+-------+------------
    6.      1 | test  | 2009-11-01
    7. (1 row)
    8.  
    9. shop=#

    6-2 谓词

    谓词是函数中的一种，其返回值是真值。

    LIKE
    BETWEEN
    IS NULL、IS NOT NULL
    IN
    EXISTS

    LIKE谓词——字符串的部分一致查询

    % 代表“0 字符以上的任意字符串”的特殊符号

     _（下划线）来代 表“任意 1 个字符”

    BETWEEN谓词——范围查询

    代码清单6-27　选取销售单价为100～1000日元的商品

    SELECT product_name, sale_price FROM Product WHERE sale_price BETWEEN 100 AND 1000;

    IS NULL、IS NOT NULL——判断是否为NULL

    代码清单6-30　选取进货单价（purchase_price）不为NULL的商品

    SELECT product_name, purchase_price FROM Product WHERE purchase_price IS NOT NULL;

    IN谓词——OR的简便用法

    代码清单6-32　通过IN来指定多个进货单价进行查询

    1. shop=# SELECT product_name, purchase_price FROM Product WHERE purchase_price IN (320, 500, 5000);
    2.  product_name | purchase_price
    3. --------------+----------------
    4.  T恤          |            500
    5.  打孔器       |            320
    6.  高压锅       |           5000
    7. (3 rows)
    8.  
    9. shop=#

    代码清单6-33　使用NOT IN进行查询时指定多个排除的进货单价进行查询

    1. shop=# SELECT product_name, purchase_price FROM Product WHERE purchase_price NOT IN (320, 500, 5000);
    2.  product_name | purchase_price
    3. --------------+----------------
    4.  运动T恤      |           2800
    5.  菜刀         |           2800
    6.  擦菜板       |            790
    7. (3 rows)
    8.  
    9. shop=#

    注意：在使用IN 和 NOT IN 时是无法选取出 NULL 数据的。

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

    IN 谓词（NOT IN 谓词）具有其他谓词所没有的用法 --> 可以使用子查询作为IN的参数
    由于子查询就是 SQL内部生成的表 ==> 能够将表作为 IN 的参数 / 能够将视图作为 IN 的参数

    之前我们使用的全都是显示商品库存清单的 Product表，但现实中这些商品可能只在个别的商店中进行销售。如下创建的表 ShopProduct 会显示出哪些商店销售哪些商品，

    1. -- DDL：创建表
    2. CREATE TABLE ShopProduct
    3. (shop_id    CHAR(4)       NOT NULL,
    4.  shop_name  VARCHAR(200)  NOT NULL,
    5.  product_id CHAR(4)       NOT NULL,
    6.  quantity   INTEGER       NOT NULL,
    7.  PRIMARY KEY (shop_id, product_id));
    8.  
    9. -- DML：插入数据
    10.  
    11. INSERT INTO ShopProduct (shop_id, shop_name, product_id, quantity) VALUES ('000A',	'东京',		'0001',	30);
    12. INSERT INTO ShopProduct (shop_id, shop_name, product_id, quantity) VALUES ('000A',	'东京',		'0002',	50);
    13. INSERT INTO ShopProduct (shop_id, shop_name, product_id, quantity) VALUES ('000A',	'东京',		'0003',	15);
    14. INSERT INTO ShopProduct (shop_id, shop_name, product_id, quantity) VALUES ('000B',	'名古屋',	'0002',	30);
    15. INSERT INTO ShopProduct (shop_id, shop_name, product_id, quantity) VALUES ('000B',	'名古屋',	'0003',	120);
    16. INSERT INTO ShopProduct (shop_id, shop_name, product_id, quantity) VALUES ('000B',	'名古屋',	'0004',	20);
    17. INSERT INTO ShopProduct (shop_id, shop_name, product_id, quantity) VALUES ('000B',	'名古屋',	'0006',	10);
    18. INSERT INTO ShopProduct (shop_id, shop_name, product_id, quantity) VALUES ('000B',	'名古屋',	'0007',	40);
    19. INSERT INTO ShopProduct (shop_id, shop_name, product_id, quantity) VALUES ('000C',	'大阪',		'0003',	20);
    20. INSERT INTO ShopProduct (shop_id, shop_name, product_id, quantity) VALUES ('000C',	'大阪',		'0004',	50);
    21. INSERT INTO ShopProduct (shop_id, shop_name, product_id, quantity) VALUES ('000C',	'大阪',		'0006',	90);
    22. INSERT INTO ShopProduct (shop_id, shop_name, product_id, quantity) VALUES ('000C',	'大阪',		'0007',	70);
    23. INSERT INTO ShopProduct (shop_id, shop_name, product_id, quantity) VALUES ('000D',	'福冈',		'0001',	100);
    24.  
    25. COMMIT;

    该 CREATE TABLE 语句的特点是指定了 2 列作为主键（primary key）。

    ShopProduct 内容如下，

    1. shop=# SELECT * FROM ShopProduct;
    2.  shop_id | shop_name | product_id | quantity
    3. ---------+-----------+------------+----------
    4.  000A    | 东京      | 0001       |       30
    5.  000A    | 东京      | 0002       |       50
    6.  000A    | 东京      | 0003       |       15
    7.  000B    | 名古屋    | 0002       |       30
    8.  000B    | 名古屋    | 0003       |      120
    9.  000B    | 名古屋    | 0004       |       20
    10.  000B    | 名古屋    | 0006       |       10
    11.  000B    | 名古屋    | 0007       |       40
    12.  000C    | 大阪      | 0003       |       20
    13.  000C    | 大阪      | 0004       |       50
    14.  000C    | 大阪      | 0006       |       90
    15.  000C    | 大阪      | 0007       |       70
    16.  000D    | 福冈      | 0001       |      100
    17. (13 rows)
    18.  
    19. shop=#

    代码清单6-36　使用子查询作为IN的参数

    1. -- 取得“在大阪店销售的商品的销售单价”
    2. SELECT product_name, sale_price
    3.  FROM Product
    4.  WHERE product_id IN (SELECT product_id 
    5.  FROM ShopProduct
    6.  WHERE shop_id = '000C');

      执行结果：

    1.  product_name | sale_price
    2. --------------+------------
    3.  运动T恤      |       4000
    4.  菜刀         |       3000
    5.  叉子         |        500
    6.  擦菜板       |        880
    7. (4 rows)
    8.  
    9. shop=#

    EXIST谓词

    EXIST谓词的使用方法

    代码清单6-38　使用EXIST选取出“大阪店在售商品的销售单价”

    1. shop=# SELECT product_name, sale_price FROM Product AS P
    2. shop-#  WHERE EXISTS (SELECT * FROM ShopProduct AS SP WHERE SP.shop_id = '000C' AND SP.product_id = P.product_id);
    3.  product_name | sale_price
    4. --------------+------------
    5.  运动T恤      |       4000
    6.  菜刀         |       3000
    7.  叉子         |        500
    8.  擦菜板       |        880
    9. (4 rows)
    10.  
    11. shop=#

    @EXIST的参数
    EXIST 左侧没有任何参数。EXIST 只需要在右侧书写 1 个参数，该参数通常都会是一个子查询。

    代码清单6-38　使用EXIST选取出“大阪店在售商品的销售单价”

    1. shop=# SELECT product_name, sale_price FROM Product AS P
    2. shop-#  WHERE EXISTS (SELECT * FROM ShopProduct AS SP WHERE SP.shop_id = '000C' AND SP.product_id = P.product_id);
    3.  product_name | sale_price
    4. --------------+------------
    5.  运动T恤      |       4000
    6.  菜刀         |       3000
    7.  叉子         |        500
    8.  擦菜板       |        880
    9. (4 rows)
    10.  
    11. shop=#

    通过条件"SP.product_id = P.product_id" 将 Product 表和 ShopProduct表进行了联接，因此作为参数的是关联子查询。EXIST 通常都会使用关联子查询作为参数。

    @子查询中的SELECT *
    EXIST 只关心记录是否存在，因此返回哪些列都没有关系。EXIST 只会判断是否存在满足子查询中 WHERE 子句指定的条
    件，只有存在这样的记录时才返回真（TRUE）。

    代码清单6-39　这样的写法也能得到与代码清单6-38相同的结果

    SELECT product_name, sale_price
     FROM Product AS P
     WHERE EXISTS (SELECT 1 -- 这里可以书写适当的常数
     FROM ShopProduct AS SP
     WHERE SP.shop_id = '000C'
     AND SP.product_id = P.product_id);
     
    可以把在 EXIST 的子查询中书写 SELECT * 当作 SQL 的一种习惯。

    6-3 CASE表达式

    CASE表达式的语法

    语法6-16　搜索CASE表达式
    CASE WHEN <求值表达式> THEN <表达式>
     WHEN <求值表达式> THEN <表达式>
     WHEN <求值表达式> THEN <表达式>
     . . .
     ELSE <表达式>
    END

    语法6-A　简单CASE表达式
    CASE <表达式>
     WHEN <表达式> THEN <表达式>
     WHEN <表达式> THEN <表达式>
     WHEN <表达式> THEN <表达式>
     . . .
     ELSE <表达式>
    END

    CAS表达式的使用方法

    代码清单6-41　通过CASE表达式将A ～C的字符串加入到商品种类当中

    1. SELECT product_name,
    2.  CASE WHEN product_type = '衣服'
    3.  THEN 'A ：' || product_type
    4.  WHEN product_type = '办公用品'
    5.  THEN 'B ：' || product_type
    6.  WHEN product_type = '厨房用具'
    7.  THEN 'C ：' || product_type
    8.  ELSE NULL
    9.  END AS abc_product_type
    10.  FROM Product;

    执行结果

    1.  product_name | abc_product_type
    2. --------------+------------------
    3.  T恤          | A ：衣服
    4.  打孔器       | B ：办公用品
    5.  运动T恤      | A ：衣服
    6.  菜刀         | C ：厨房用具
    7.  高压锅       | C ：厨房用具
    8.  叉子         | C ：厨房用具
    9.  擦菜板       | C ：厨房用具
    10.  圆珠笔       | B ：办公用品
    11. (8 rows)
    12.  
    13. shop=#

    也可以使用简单CASE表达式

    1. -- 使用简单CASE表达式的情况
    2. SELECT product_name,
    3.  CASE product_type
    4.  WHEN '衣服' THEN 'A ：' || product_type
    5.  WHEN '办公用品' THEN 'B ：' || product_type
    6.  WHEN '厨房用具' THEN 'C ：' || product_type
    7.  ELSE NULL
    8.  END AS abc_product_type
    9.  FROM Product;

    代码清单6-42　通常使用GROUP BY也无法实现行列转换

    1. SELECT product_type, SUM(sale_price) AS sum_price
    2.  FROM Product GROUP BY product_type;

    执行结果：

    1. product_type | sum_price
    2. --------------+-----------
    3.  衣服         |      5000
    4.  办公用品     |       600
    5.  厨房用具     |     11180
    6. (3 rows)
    7.  
    8. shop=#

    代码清单6-43　使用CASE表达式进行行列转换

    1. -- 对按照商品种类计算出的销售单价合计值进行行列转换
    2. shop=# SELECT SUM(CASE WHEN product_type = '衣服' THEN sale_price ELSE 0 END) AS sum_price_clothes,
    3. shop-# SUM(CASE WHEN product_type = '厨房用具' THEN sale_price ELSE 0 END) AS sum_price_kitchen,
    4. shop-# SUM(CASE WHEN product_type = '办公用品' THEN sale_price ELSE 0 END) AS sum_price_office
    5. shop-# FROM Product;
    6.  sum_price_clothes | sum_price_kitchen | sum_price_office
    7. -------------------+-------------------+------------------
    8.               5000 |             11180 |              600
    9. (1 row)
    10.  
    11. shop=#

    7 集合运算

    7-1 表的加减法

    表的加法 UNION

    创建表Product2并添加数据

    1. CREATE TABLE Product2
    2. (product_id      CHAR(4)      NOT NULL,
    3.  product_name    VARCHAR(100) NOT NULL,
    4.  product_type    VARCHAR(32)  NOT NULL,
    5.  sale_price      INTEGER ,
    6.  purchase_price  INTEGER ,
    7.  regist_date     DATE ,
    8.  PRIMARY KEY (product_id));
    9.  
    10. BEGIN TRANSACTION;
    11. INSERT INTO Product2 VALUES ('0001', 'T恤衫' ,'衣服', 1000, 500, '2008-09-20');
    12. INSERT INTO Product2 VALUES ('0002', '打孔器', '办公用品', 500, 320, '2009-09-11');
    13. INSERT INTO Product2 VALUES ('0003', '运动T恤', '衣服', 4000, 2800, NULL);
    14. INSERT INTO Product2 VALUES ('0009', '手套', '衣服', 800, 500, NULL);
    15. INSERT INTO Product2 VALUES ('0010', '水壶', '厨房用具', 2000, 1700, '2009-09-20');
    16. COMMIT;

    Product和Product2内容如下

    1. shop=# SELECT * FROM Product;
    2.  product_id | product_name | product_type | sale_price | purchase_price | regist_date
    3. ------------+--------------+--------------+------------+----------------+-------------
    4.  0001       | T恤          | 衣服         |       1000 |            500 | 2009-09-20
    5.  0002       | 打孔器       | 办公用品     |        500 |            320 | 2009-09-11
    6.  0003       | 运动T恤      | 衣服         |       4000 |           2800 |
    7.  0004       | 菜刀         | 厨房用具     |       3000 |           2800 | 2009-09-20
    8.  0005       | 高压锅       | 厨房用具     |       6800 |           5000 | 2009-01-15
    9.  0006       | 叉子         | 厨房用具     |        500 |                | 2009-09-20
    10.  0007       | 擦菜板       | 厨房用具     |        880 |            790 | 2008-04-28
    11.  0008       | 圆珠笔       | 办公用品     |        100 |                | 2009-11-11
    12. (8 rows)
    13.  
    14. shop=# SELECT * FROM Product2;
    15.  product_id | product_name | product_type | sale_price | purchase_price | regist_date
    16. ------------+--------------+--------------+------------+----------------+-------------
    17.  0001       | T恤衫        | 衣服         |       1000 |            500 | 2008-09-20
    18.  0002       | 打孔器       | 办公用品     |        500 |            320 | 2009-09-11
    19.  0003       | 运动T恤      | 衣服         |       4000 |           2800 |
    20.  0009       | 手套         | 衣服         |        800 |            500 |
    21.  0010       | 水壶         | 厨房用具     |       2000 |           1700 | 2009-09-20
    22. (5 rows)
    23.  
    24. shop=#

    代码清单7-3 使用UNION对表进行加法运算

    1. SELECT product_id, product_name FROM Product
    2. UNION SELECT product_id, product_name FROM Product2;

    执行结果：

    1.  product_id | product_name
    2. ------------+--------------
    3.  0006       | 叉子
    4.  0002       | 打孔器
    5.  0007       | 擦菜板
    6.  0003       | 运动T恤
    7.  0004       | 菜刀
    8.  0005       | 高压锅
    9.  0008       | 圆珠笔
    10.  0010       | 水壶
    11.  0009       | 手套
    12.  0001       | T恤衫
    13. (10 rows)
    14.  
    15. shop=#

    UNION 等集合运算符通常都会除去重复的记录。

    包含重复行的集合运算 ALL选项

    UNION -> UNION ALL
    代码清单7-5　保留重复行

    1. SELECT product_id, product_name FROM Product
    2. UNION ALL SELECT product_id, product_name FROM Product2;

    集合运算的注意事项

    注意事项①——作为运算对象的记录的列数必须相同
    注意事项②——作为运算对象的记录中列的类型必须一致
    注意事项③——可以使用任何SELECT语句，但ORDER BY子句只能在最后使用一次

    代码清单7-4　ORDER BY子句只在最后使用一次

    1. shop=# SELECT product_id, product_name FROM Product WHERE product_type = '厨房用具'
    2. shop-# UNION SELECT product_id, product_name FROM Product2 WHERE product_type = '厨房用具'
    3. shop-# ORDER BY product_id;
    4.  product_id | product_name
    5. ------------+--------------
    6.  0004       | 菜刀
    7.  0005       | 高压锅
    8.  0006       | 叉子
    9.  0007       | 擦菜板
    10.  0010       | 水壶
    11. (5 rows)
    12.  
    13. shop=#

    选取表中公共部分(交集) INTERSECT

    代码清单7-6　使用INTERSECT选取出表中公共部分

    1. shop=# SELECT product_id, product_name FROM Product
    2. shop-# INTERSECT SELECT product_id, product_name FROM Product2
    3. shop-# ORDER BY product_id;
    4.  product_id | product_name
    5. ------------+--------------
    6.  0001       | T恤衫
    7.  0002       | 打孔器
    8.  0003       | 运动T恤
    9. (3 rows)
    10.  
    11. shop=#

    记录的减法 EXCEPT

    代码清单7-7　使用EXCEPT对记录进行减法运算

    1. shop=# SELECT product_id, product_name FROM Product
    2. shop-# EXCEPT SELECT product_id, product_name FROM Product2
    3. shop-# ORDER BY product_id;
    4.  product_id | product_name
    5. ------------+--------------
    6.  0004       | 菜刀
    7.  0005       | 高压锅
    8.  0006       | 叉子
    9.  0007       | 擦菜板
    10.  0008       | 圆珠笔
    11. (5 rows)
    12.  
    13. shop=#

    7-2 联结（以列为单位对表进行联结）

    UNION是以行（纵向）为单位进行操作，而联结则是以列（横向）为单位进行的。

    内联结 INNER JOIN

    代码清单7-9　将两张表进行内联结

    1. shop=# SELECT SP.shop_id, SP.shop_name, SP.product_id, P.product_name, P.sale_price
    2. shop-# FROM ShopProduct AS SP INNER JOIN Product AS P
    3. shop-# ON SP.product_id = P.product_id;
    4.  shop_id | shop_name | product_id | product_name | sale_price
    5. ---------+-----------+------------+--------------+------------
    6.  000A    | 东京      | 0001       | T恤衫        |       1000
    7.  000A    | 东京      | 0002       | 打孔器       |        500
    8.  000A    | 东京      | 0003       | 运动T恤      |       4000
    9.  000B    | 名古屋    | 0002       | 打孔器       |        500
    10.  000B    | 名古屋    | 0003       | 运动T恤      |       4000
    11.  000B    | 名古屋    | 0004       | 菜刀         |       3000
    12.  000B    | 名古屋    | 0006       | 叉子         |        500
    13.  000B    | 名古屋    | 0007       | 擦菜板       |        880
    14.  000C    | 大阪      | 0003       | 运动T恤      |       4000
    15.  000C    | 大阪      | 0004       | 菜刀         |       3000
    16.  000C    | 大阪      | 0006       | 叉子         |        500
    17.  000C    | 大阪      | 0007       | 擦菜板       |        880
    18.  000D    | 福冈      | 0001       | T恤衫        |       1000
    19. (13 rows)
    20.  
    21. shop=#

    外联结——OUTER JOIN

    指定主表的关键字是 LEFT 和 RIGHT。

    代码清单7-11　将两张表进行外联结

    1. SELECT SP.shop_id, SP.shop_name, SP.product_id, P.product_name, P.sale_price
    2. FROM ShopProduct AS SP RIGHT OUTER JOIN Product AS P
    3. ON SP.product_id = P.product_id;

    附：

    法则 6-1 通常指定关联子查询作为EXIST的参数。
    法则 6-2 作为EXIST参数的子查询中经常会使用SELECT *。
    法则 6-3 虽然CASE表达式中的ELSE子句可以省略，但还是希望大家不要省略。

    法则 7-1 集合运算符会除去重复的记录。
    法则 7-2 在集合运算符中使用ALL选项，可以保留重复行。
    法则 7-3 进行联结时需要在FROM子句中使用多张表。
    法则 7-4 进行内联结时必须使用ON子句，并且要书写在FROM和WHERE之间。
    法则 7-5 使用联结时SELECT子句中的列需要按照“<表的别名>.<列名>”的格式进行书写。
    法则 7-6 外联结中使用LEFT、RIGHT来指定主表。使用二者所得到的结果完全相同。

  • 相关阅读:
    【0基础百日刷题】洛谷刷题知识拾遗
    vulnhub Vegeta: 1
    算法功能：边缘缺陷检测
    33.nacos客户端读取多配置文件实例（springcloud）
    【apt】解决 apt update 时 The method ‘ftp’ is unsupported and disabled by default 错误
    biquad滤波器的设计
    python 调用钉钉机器人接口案例一则 —— 筑梦之路
    开发者体验：现代企业架构的关键一环
    AI-线性回归模型
    echarts X轴类目名太长时隐藏，hover时显示全部
  • 原文地址：https://blog.csdn.net/wy_hhxx/article/details/126079203