视图
视图是一个虚拟的表，不同于直接操作数据表，视图是依据 SELECT 语句来创建的（会在下面具体介绍），所以操作视图时会根据创建视图的 SELECT 语句生成一张虚拟表，然后在这张虚拟表上做 SQL 操作。
视图存在的原因
通过定义视图可以将频繁使用的 SELECT 语句保存以提高效率。
通过定义视图可以使用户看到的数据更加清晰。
通过定义视图可以不对外公开数据表全部字段，增强数据的保密性。
通过定义视图可以降低数据的冗余。
我觉得这有点像语言里的方法
创建视图的基本语法如下：
CREATE VIEW <视图名称>(<列名1>,<列名2>,...) AS <SELECT语句>
复制代码
复制代码
复制代码
其中 SELECT 语句需要书写在 AS 关键字之后。 SELECT 语句中列的排列顺序和视图中列的排列顺序相同， SELECT 语句中的第 1 列就是视图中的第 1 列， SELECT 语句中的第 2 列就是视图中的第 2 列，以此类推。而且视图的列名是在视图名称之后的列表中定义的。 需要注意的是视图名在数据库中需要是唯一的，不能与其他视图和表重名。
视图不仅可以基于真实表，我们也可以在视图的基础上继续创建视图。
需要注意的是在一般的 DBMS 中定义视图时不能使用 ORDER BY 语句。下面这样定义视图是错误的。
CREATE VIEW productsum (product_type, cnt_product)ASSELECT product_type, COUNT(*) FROM product GROUP BY product_type ORDER BY product_type;
复制代码
复制代码
复制代码
为什么不能使用 ORDER BY 子句呢？这是因为视图和表一样，数据行都是没有顺序的。
下面创建一个多表视图 首先看下两张表结构
CREATE VIEW view_shop_product(product_type, sale_price, shop_name)ASSELECT product_type, sale_price, shop_name FROM product, shop_product WHERE product.product_id = shop_product.product_id;
复制代码
复制代码
复制代码
我们可以在这个视图的基础上进行查询
修改视图结构的基本语法如下：
ALTER VIEW <视图名> AS <SELECT语句>
复制代码
复制代码
复制代码
对于一个视图来说，如果包含以下结构的任意一种都是不可以被更新的：
视图归根结底还是从表派生出来的，因此，如果原表可以更新，那么 视图中的数据也可以更新。反之亦然，如果视图发生了改变，而原表没有进行相应更新的话，就无法保证数据的一致性了。
view_shop_product 视图不包括以上的限制条件，我们来尝试更新一下视图
UPDATE view_shop_product SET sale_price = '6000' WHERE shop_name = '福冈';
复制代码
复制代码
复制代码
删除视图的基本语法如下：
DROP VIEW <视图名1> [ , <视图名2> …]
复制代码
复制代码
复制代码
注意：需要有相应的权限才能成功删除。
我们删除刚才创建的 view_shop_product 视图
DROP VIEW view_shop_product;
复制代码
复制代码
复制代码
如果我们继续操作这个视图的话就会提示当前操作的内容不存在。
子查询
我们先来看一个语句
SELECT stu_nameFROM ( SELECT stu_name, COUNT(*) AS stu_cnt FROM students_info GROUP BY stu_age) AS studentSum;
复制代码
复制代码
复制代码
这个语句看起来很好理解，其中使用括号括起来的 sql 语句首先执行，执行成功后再执行外面的 sql 语句。但是我们上一节提到的视图也是根据 SELECT 语句创建视图然后在这个基础上再进行查询。那么什么是子查询呢？子查询和视图又有什么关系呢？
什么是子查询子查询指一个查询语句嵌套在另一个查询语句内部的查询，这个特性从 MySQL 4.1 开始引入，在 SELECT 子句中先计算子查询，子查询结果作为外层另一个查询的过滤条件，查询可以基于一个表或者多个表。
子查询和视图的关系子查询就是将用来定义视图的 SELECT 语句直接用于 FROM 子句当中。其中 AS studentSum 可以看作是子查询的名称，而且由于子查询是一次性的，所以子查询不会像视图那样保存在存储介质中， 而是在 SELECT 语句执行之后就消失了。
嵌套子查询与在视图上再定义视图类似，子查询也没有具体的限制，例如我们可以这样
SELECT product_type, cnt_productFROM (SELECT * FROM (SELECT product_type, COUNT(*) AS cnt_product FROM product GROUP BY product_type) AS productsum WHERE cnt_product = 4) AS productsum2;
复制代码
复制代码
复制代码
其中最内层的子查询我们将其命名为 productSum，这条语句根据 product_type 分组并查询个数，第二层查询中将个数为 4 的商品查询出来，最外层查询 product_type 和 cnt_product 两列。 虽然嵌套子查询可以查询出结果，但是随着子查询嵌套的层数的叠加，SQL 语句不仅会难以理解而且执行效率也会很差，所以要尽量避免这样的使用。
标量就是单一的意思，那么标量子查询也就是单一的子查询，那什么叫做单一的子查询呢？
所谓单一就是要求我们执行的 SQL 语句只能返回一个值，也就是要返回表中具体的某一行的某一列。例如我们有下面这样一张表
product_id | product_name | sale_price ------------+-------------+----------0003 | 运动T恤 | 4000 0004 | 菜刀 | 3000 0005 | 高压锅 | 6800
复制代码
复制代码
复制代码
那么我们执行一次标量子查询后是要返回类似于，“0004”，“菜刀”这样的结果。
标量子查询有什么用
我们现在已经知道标量子查询可以返回一个值了，那么它有什么作用呢？
直接这样想可能会有些困难，让我们看几个具体的需求：
查询出销售单价高于平均销售单价的商品
查询出注册日期最晚的那个商品
你有思路了吗？
让我们看如何通过标量子查询语句查询出销售单价高于平均销售单价的商品。
SELECT product_id, product_name, sale_price FROM product WHERE sale_price > (SELECT AVG(sale_price) FROM product);
复制代码
复制代码
复制代码
上面的这条语句首先后半部分查询出 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_price FROM product;
复制代码
复制代码
复制代码
你能猜到这段代码的运行结果是什么吗？运行一下看看与你想象的结果是否一致。
关联子查询
关联子查询既然包含关联两个字那么一定意味着查询与子查询之间存在着联系。这种联系是如何建立起来的呢？
我们先看一个例子：
SELECT product_type, product_name, sale_price FROM product AS p1 WHERE sale_price > (SELECT AVG(sale_price) FROM product AS p2 WHERE p1.product_type = p2.product_type GROUP BY product_type);
复制代码
复制代码
复制代码
你能理解这个例子在做什么操作么？先来看一下这个例子的执行结果
通过上面的例子我们大概可以猜到吗，关联子查询就是通过一些标志将内外两层的查询连接起来起到过滤数据的目的，接下来我们就一起看一下关联子查询的具体内容吧。
还记得我们之前的那个例子么查询出销售单价高于平均销售单价的商品，这个例子的 SQL 语句如下
SELECT product_id, product_name, sale_price FROM product WHERE sale_price > (SELECT AVG(sale_price) FROM product);
复制代码
复制代码
复制代码
我们再来看一下这个需求选取出各商品种类中高于该商品种类的平均销售单价的商品。SQL 语句如下：
SELECT product_type, product_name, sale_price FROM product ASp1 WHERE sale_price > (SELECT AVG(sale_price) FROM product ASp2 WHERE p1.product_type =p2.product_type GROUP BY product_type);
复制代码
复制代码
复制代码
可以看出上面这两个语句的区别吗？
在第二条 SQL 语句也就是关联子查询中我们将外面的 product 表标记为 p1，将内部的 product 设置为 p2，而且通过 WHERE 语句连接了两个查询。
但是如果刚接触的话一定会比较疑惑关联查询的执行过程，这里有一个博客讲的比较清楚。在这里我们简要的概括为：
首先执行不带 WHERE 的主查询
根据主查询讯结果匹配 product_type，获取子查询结果
将子查询结果再与主查询结合执行完整的 SQL 语句
在子查询中像标量子查询，嵌套子查询或者关联子查询可以看作是子查询的一种操作方式即可。
创建出满足下述三个条件的视图（视图名称为 ViewPractice5_1）。使用 product（商品）表作为参照表，假设表中包含初始状态的 8 行数据。
对该视图执行 SELECT 语句的结果如下所示。
向习题一中创建的视图 aaa 中插入如下数据，会得到什么样的结果？
INSERT INTO aaa VALUES (' 刀子 ', 300, '2009-11-02');
复制代码
复制代码
复制代码
视图不会改变 因为他不满足价格大于 1000，日期也补满足， 但是会修改其基础表，不建议这样做 这样做。
各种各样的函数
ABS -- 绝对值
语法：ABS( 数值 )
ABS 函数用于计算一个数字的绝对值，表示一个数到原点的距离。
当 ABS 函数的参数为NULL时，返回值也是NULL。
MOD -- 求余数
语法：MOD( 被除数，除数 )
MOD 是计算除法余数（求余）的函数，是 modulo 的缩写。小数没有余数的概念，只能对整数列求余数。
注意：主流的 DBMS 都支持 MOD 函数，只有 SQL Server 不支持该函数，其使用%符号来计算余数。
ROUND -- 四舍五入
语法：ROUND( 对象数值，保留小数的位数 )
ROUND 函数用来进行四舍五入操作。
注意：当参数 保留小数的位数 为变量时，可能会遇到错误，请谨慎使用变量。
字符串函数
语法：CONCAT(str1, str2, str3)
MySQL 中使用 CONCAT 函数进行拼接。
语法：LENGTH( 字符串 )
LOWER 函数只能针对英文字母使用，它会将参数中的字符串全都转换为小写。该函数不适用于英文字母以外的场合，不影响原本就是小写的字符。
类似的， UPPER 函数用于大写转换。
语法：REPLACE( 对象字符串，替换前的字符串，替换后的字符串 )
语法：SUBSTRING （对象字符串 FROM 截取的起始位置 FOR 截取的字符数）
使用 SUBSTRING 函数 可以截取出字符串中的一部分字符串。截取的起始位置从字符串最左侧开始计算，索引值起始为 1。
日期函数
CURRENT_DATE -- 获取当前日期
CURRENT_TIME -- 当前时间
CURRENT_TIMESTAMP -- 当前日期和时间
语法：EXTRACT(日期元素 FROM 日期)
使用 EXTRACT 函数可以截取出日期数据中的一部分，例如“年”
“月”，或者“小时”“秒”等。该函数的返回值并不是日期类型而是数值类型
转换函数
“转换”这个词的含义非常广泛，在 SQL 中主要有两层意思：一是数据类型的转换，简称为类型转换，在英语中称为cast；另一层意思是值的转换。
语法：CAST（转换前的值 AS 想要转换的数据类型）
语法：COALESCE(数据1，数据2，数据3……)
COALESCE 是 SQL 特有的函数。该函数会返回可变参数 A 中左侧开始第 1 个不是 NULL 的值。参数个数是可变的，因此可以根据需要无限增加。
在 SQL 语句中将 NULL 转换为其他值时就会用到转换函数。
谓词
谓词就是返回值为真值的函数。包括TRUE / FALSE / UNKNOWN。
谓词主要有以下几个：
LIKE
BETWEEN
IS NULL、IS NOT NULL
IN
EXISTS
当需要进行字符串的部分一致查询时需要使用该谓词。
部分一致大体可以分为前方一致、中间一致和后方一致三种类型。
首先我们来创建一张表
-- DDL ：创建表CREATE TABLE samplelike( strcol VARCHAR(6) NOT NULL,PRIMARY KEY (strcol));samplelike);-- DML ：插入数据INSERT INTO samplelike (strcol) VALUES ('abcddd');INSERT INTO samplelike (strcol) VALUES ('dddabc');INSERT INTO samplelike (strcol) VALUES ('abdddc');INSERT INTO samplelike (strcol) VALUES ('abcdd');INSERT INTO samplelike (strcol) VALUES ('ddabc');INSERT INTO samplelike (strcol) VALUES ('abddc');SELECT * FROM samplelike;+--------+| strcol |+--------+| abcdd || abcddd || abddc || abdddc || ddabc || dddabc |+--------+6 rows in set (0.00 sec)
复制代码
复制代码
复制代码
前方一致即作为查询条件的字符串（这里是“ddd”）与查询对象字符串起始部分相同。
SELECT *FROM samplelikeWHERE strcol LIKE 'ddd%';+--------+| strcol |+--------+| dddabc |+--------+1 row in set (0.00 sec)
复制代码
复制代码
复制代码
其中的%是代表“零个或多个任意字符串”的特殊符号，本例中代表“以 ddd 开头的所有字符串”。
中间一致即查询对象字符串中含有作为查询条件的字符串，无论该字符串出现在对象字
符串的最后还是中间都没有关系。
SELECT *FROM samplelikeWHERE strcol LIKE '%ddd%';+--------+| strcol |+--------+| abcddd || abdddc || dddabc |+--------+3 rows in set (0.00 sec)
复制代码
复制代码
复制代码
后方一致即作为查询条件的字符串（这里是“ddd”）与查询对象字符串的末尾部分相同。
SELECT *FROM samplelikeWHERE strcol LIKE '%ddd';+--------+| strcol |+--------+| abcddd |+--------+1 row in set (0.00 sec)
复制代码
复制代码
复制代码
综合如上三种类型的查询可以看出，查询条件最宽松，也就是能够取得最多记录的是中间一致。这是因为它同时包含前方一致和后方一致的查询结果。
使用 _（下划线）来代替 %，与 % 不同的是，它代表了“任意 1 个字符”。
SELECT *FROM samplelikeWHERE strcol LIKE 'abc__';+--------+| strcol |+--------+| abcdd |+--------+1 row in set (0.00 sec)
复制代码
复制代码
复制代码
BETWEEN 谓词 -- 用于范围查询
使用 BETWEEN 可以进行范围查询。该谓词与其他谓词或者函数的不同之处在于它使用了 3 个参数。
-- 选取销售单价为100～ 1000元的商品SELECT product_name, sale_priceFROM productWHERE sale_price BETWEEN 100 AND 1000;+--------------+------------+| product_name | sale_price |+--------------+------------+| T恤 | 1000 || 打孔器 | 500 || 叉子 | 500 || 擦菜板 | 880 || 圆珠笔 | 100 |+--------------+------------+5 rows in set (0.00 sec)
复制代码
复制代码
复制代码
BETWEEN 的特点就是结果中会包含 100 和 1000 这两个临界值，也就是闭区间。如果不想让结果中包含临界值，那就必须使用 < 和 >。
SELECT product_name, sale_priceFROM productWHERE sale_price > 100AND sale_price < 1000;+--------------+------------+| product_name | sale_price |+--------------+------------+| 打孔器 | 500 || 叉子 | 500 || 擦菜板 | 880 |+--------------+------------+3 rows in set (0.00 sec)
复制代码
复制代码
复制代码
IS NULL、 IS NOT NULL -- 用于判断是否为 NULL
为了选取出某些值为 NULL 的列的数据，不能使用 =，而只能使用特定的谓词 IS NULL。
与此相反，想要选取 NULL 以外的数据时，需要使用 IS NOT NULL。
IN 谓词 -- OR 的简便用法
多个查询条件取并集时可以选择使用or语句。
-- 通过OR指定多个进货单价进行查询SELECT product_name, purchase_priceFROM productWHERE purchase_price = 320OR purchase_price = 500OR purchase_price = 5000;+--------------+----------------+| product_name | purchase_price |+--------------+----------------+| T恤 | 500 || 打孔器 | 320 || 高压锅 | 5000 |+--------------+----------------+3 rows in set (0.00 sec)
复制代码
复制代码
复制代码
虽然上述方法没有问题，但还是存在一点不足之处，那就是随着希望选取的对象越来越多， SQL 语句也会越来越长，阅读起来也会越来越困难。这时， 我们就可以使用 IN 谓词 `IN(值 1, 值 2, 值 3, ......)来替换上述 SQL 语句。
SELECT product_name, purchase_priceFROM productWHERE purchase_price IN (320, 500, 5000);+--------------+----------------+| product_name | purchase_price |+--------------+----------------+| T恤 | 500 || 打孔器 | 320 || 高压锅 | 5000 |+--------------+----------------+3 rows in set (0.00 sec)
复制代码
复制代码
复制代码
上述语句简洁了很多，可读性大幅提高。 反之，希望选取出“进货单价不是 320 元、 500 元、 5000 元”的商品时，可以使用否定形式 NOT IN 来实现。
SELECT product_name, purchase_priceFROM productWHERE purchase_price NOT IN (320, 500, 5000);+--------------+----------------+| product_name | purchase_price |+--------------+----------------+| 运动T恤 | 2800 || 菜刀 | 2800 || 擦菜板 | 790 |+--------------+----------------+3 rows in set (0.00 sec)
复制代码
复制代码
复制代码
需要注意的是，在使用 IN 和 NOT IN 时是无法选取出 NULL 数据的。 实际结果也是如此，上述两组结果中都不包含进货单价为 NULL 的叉子和圆珠笔。 NULL 只能使用 IS NULL 和 IS NOT NULL 来进行判断。
使用子查询作为 IN 谓词的参数
IN 谓词（NOT IN 谓词）具有其他谓词所没有的用法，那就是可以使用子查询作为其参数。我们已经在 5-2 节中学习过了，子查询就是 SQL 内部生成的表，因此也可以说“能够将表作为 IN 的参数”。同理，我们还可以说“能够将视图作为 IN 的参数”。
在此，我们创建一张新表shopproduct显示出哪些商店销售哪些商品。
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));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);
复制代码
复制代码
复制代码
由于单独使用商店编号（shop_id）或者商品编号（product_id）不能区分表中每一行数据 ，因此指定了 2 列作为主键（primary key）对商店和商品进行组合，用来唯一确定每一行数据。
假设我么需要取出大阪在售商品的销售单价，该如何实现呢？
第一步，取出大阪门店的在售商品 `product_id ;
第二步，取出大阪门店在售商品的销售单价 `sale_price
-- step1：取出大阪门店的在售商品 `product_id`SELECT product_idFROM shopproductWHERE shop_id = '000C';+------------+| product_id |+------------+| 0003 || 0004 || 0006 || 0007 |+------------+4 rows in set (0.00 sec)
复制代码
复制代码
复制代码
上述语句取出了大阪门店的在售商品编号，接下来，我么可以使用上述语句作为第二步的查询条件来使用了。
-- step2：取出大阪门店在售商品的销售单价 `sale_price`SELECT product_name, sale_priceFROM productWHERE product_id IN (SELECT product_id FROM shopproduct WHERE shop_id = '000C');+--------------+------------+| product_name | sale_price |+--------------+------------+| 运动T恤 | 4000 || 菜刀 | 3000 || 叉子 | 500 || 擦菜板 | 880 |+--------------+------------+4 rows in set (0.00 sec)
复制代码
复制代码
复制代码
根据第 5 章学习的知识，子查询是从最内层开始执行的（由内而外），因此，上述语句的子查询执行之后，sql 展开成下面的语句
-- 子查询展开后的结果SELECT product_name, sale_priceFROM productWHERE 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 同样支持子查询作为参数，用法和 in 完全一样。
-- NOT IN 使用子查询作为参数，取出未在大阪门店销售的商品的销售单价SELECT product_name, sale_price FROM product WHERE product_id NOT IN (SELECT product_id FROM shopproduct WHERE shop_id = '000A');+--------------+------------+| product_name | sale_price |+--------------+------------+| 菜刀 | 3000 || 高压锅 | 6800 || 叉子 | 500 || 擦菜板 | 880 || 圆珠笔 | 100 |+--------------+------------+5 rows in set (0.00 sec)
复制代码
复制代码
复制代码
谓词的作用就是 “判断是否存在满足某种条件的记录”。
如果存在这样的记录就返回真（TRUE），如果不存在就返回假（FALSE）。
EXIST（存在）谓词的主语是“记录”。
我们继续以 IN 和子查询 中的示例，使用 EXIST 选取出大阪门店在售商品的销售单价。
SELECT product_name, sale_price FROM product AS p WHERE EXISTS (SELECT * FROM shopproduct AS sp WHERE 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 sp WHERE sp.shop_id = '000C' AND sp.product_id = p.product_id)
复制代码
复制代码
复制代码
上面这样的子查询就是唯一的参数。确切地说，由于通过条件“SP.product_id = P.product_id”将 product 表和 shopproduct 表进行了联接，因此作为参数的是关联子查询。 EXIST 通常会使用关联子查询作为参数。
由于 EXIST 只关心记录是否存在，因此返回哪些列都没有关系。 EXIST 只会判断是否存在满足子查询中 WHERE 子句指定的条件“商店编号（shop_id）为 '000C'，商品（product）表和商店
商品（shopproduct）表中商品编号（product_id）相同”的记录，只有存在这样的记录时才返回真（TRUE）。
因此，使用下面的查询语句，查询结果也不会发生变化。
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);+--------------+------------+| product_name | sale_price |+--------------+------------+| 运动T恤 | 4000 || 菜刀 | 3000 || 叉子 | 500 || 擦菜板 | 880 |+--------------+------------+4 rows in set (0.00 sec)
复制代码
复制代码
复制代码
大家可以把在 EXIST 的子查询中书写 SELECT * 当作 SQL 的一种习惯。
就像 EXIST 可以用来替换 IN 一样， NOT IN 也可以用 NOT EXIST 来替换。
下面的代码示例取出，不在大阪门店销售的商品的销售单价。
SELECT product_name, sale_price FROM product AS p WHERE NOT EXISTS (SELECT * FROM shopproduct AS sp WHERE 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)
复制代码
复制代码
复制代码
NOT EXIST 与 EXIST 相反，当“不存在”满足子查询中指定条件的记录时返回真（TRUE）。
评论