MySQL知识（十）——连接查询与子查询

最新推荐文章于 2023-09-04 21:39:06 发布
最新推荐文章于 2023-09-04 21:39:06 发布
阅读量2.6k 收藏 4
点赞数 2
分类专栏： MySQL学习笔记 文章标签： mysql 数据库 连接查询 子查询
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zen99T/article/details/50736769
版权

1 连接查询

　　连接查询是关系数据库中最主要的查询，主要包括连接、外连接等。通过连接运算符可以实现多个表查询。在关系数据库管理系统中，表建立时各数据之间的关系不必确定，常把一个实体的所有信息存放在一个表中。当查询数据时，通过连接操作查询出存放在多个表中的不同实体的信息。当两个或多个表中存在相同意义的字段时，便可以通过这些字段对不同的表进行连接查询。

1.1 内连接查询

　　内连接（INNER JOIN）使用比较运算符进行表间某（些）列数据的比较操作，并列出这些表中与连接条件相匹配的数据行，组合成新的纪录。在内连接查询中，只有满足条件的记录才能出现在结果关系中。
　　（1）fruits表和suppliers表的结构：

mysql> DESC fruits;
+---------+--------------+------+-----+---------+-------+
| Field   | Type         | Null | Key | Default | Extra |
+---------+--------------+------+-----+---------+-------+
| f_id    | char(10)     | NO   | PRI | NULL    |       |
| s_id    | int(11)      | NO   |     | NULL    |       |
| f_name  | char(255)    | NO   |     | NULL    |       |
| f_price | decimal(8,2) | NO   |     | NULL    |       |
+---------+--------------+------+-----+---------+-------+
4 rows in set

mysql> DESC suppliers;
+--------+----------+------+-----+---------+----------------+
| Field  | Type     | Null | Key | Default | Extra          |
+--------+----------+------+-----+---------+----------------+
| s_id   | int(11)  | NO   | PRI | NULL    | auto_increment |
| s_name | char(50) | NO   |     | NULL    |                |
| s_city | char(50) | YES  |     | NULL    |                |
| s_zip  | char(10) | YES  |     | NULL    |                |
| s_call | char(50) | NO   |     | NULL    |                |
+--------+----------+------+-----+---------+----------------+
5 rows in set

　　（2）SELECT、FROM、WHERE查询

mysql> SELECT suppliers.s_id,s_name,f_name,f_price
    -> FROM fruits,suppliers
    -> WHERE fruits.s_id=suppliers.s_id;
+------+----------------+------------+---------+
| s_id | s_name         | f_name     | f_price |
+------+----------------+------------+---------+
|  101 | FastFruit Inc. | apple      | 5.2     |
|  103 | ACME           | apricot    | 2.2     |
|  101 | FastFruit Inc. | blackberry | 10.2    |
|  104 | FNK Inc.       | berry      | 7.6     |
|  107 | DK Inc.        | xxxx       | 3.6     |
|  102 | LT Supplies    | orange     | 11.2    |
|  105 | Good Set       | melon      | 8.2     |
|  101 | FastFruit Inc. | cherry     | 3.2     |
|  104 | FNK Inc.       | lemon      | 6.4     |
|  106 | Just Eat Ours  | mango      | 15.6    |
|  105 | Good Set       | xbabay     | 2.6     |
|  105 | Good Set       | xxtt       | 11.6    |
|  103 | ACME           | coconut    | 9.2     |
|  102 | LT Supplies    | banana     | 10.3    |
|  102 | LT Supplies    | grape      | 5.3     |
|  107 | DK Inc.        | xbababa    | 3.6     |
+------+----------------+------------+---------+
16 rows in set

　　（3）使用INNER JOIN语法进行查询

mysql> SELECT suppliers.s_id,s_name,f_name,f_price
    -> FROM fruits INNER JOIN suppliers
    -> ON fruits.s_id=suppliers.s_id;
+------+----------------+------------+---------+
| s_id | s_name         | f_name     | f_price |
+------+----------------+------------+---------+
|  101 | FastFruit Inc. | apple      | 5.2     |
|  103 | ACME           | apricot    | 2.2     |
|  101 | FastFruit Inc. | blackberry | 10.2    |
|  104 | FNK Inc.       | berry      | 7.6     |
|  107 | DK Inc.        | xxxx       | 3.6     |
|  102 | LT Supplies    | orange     | 11.2    |
|  105 | Good Set       | melon      | 8.2     |
|  101 | FastFruit Inc. | cherry     | 3.2     |
|  104 | FNK Inc.       | lemon      | 6.4     |
|  106 | Just Eat Ours  | mango      | 15.6    |
|  105 | Good Set       | xbabay     | 2.6     |
|  105 | Good Set       | xxtt       | 11.6    |
|  103 | ACME           | coconut    | 9.2     |
|  102 | LT Supplies    | banana     | 10.3    |
|  102 | LT Supplies    | grape      | 5.3     |
|  107 | DK Inc.        | xbababa    | 3.6     |
+------+----------------+------------+---------+
16 rows in set

　　（4）自连接
　　在一个连接查询中，涉及到的连个表都是同一个表。自连接是一个特殊的内连接，它是指相互连接的表在物理上为同一张表，但可以在逻辑上分为两张表。
　　例如，查询f_id=’a1’的水果供应商提供的其他水果种类：

mysql> SELECT f1.f_id,f1.f_name
    -> FROM fruits AS f1,fruits AS f2
    -> WHERE f1.s_id=f2.s_id AND f2.f_id='a1';
+------+------------+
| f_id | f_name     |
+------+------------+
| a1   | apple      |
| b1   | blackberry |
| c0   | cherry     |
+------+------------+
3 rows in set

1.2 外连接查询

　　连接查询将查询多个表中相关联的行，内连接时，返回查询结果集合中的仅是符合查询条件和连接条件的行。但有时候需要包含没有关联的行中数据，即返回查询结果集合中的不仅包含符合连接条件的行，而且还包括左表（左外连接或左连接）、右表（右外连接或右连接）或两个边接表（全外连接）中的所有数据行。
　　外连接分为左外连接和右外连接
　　①LEFT JOIN（左连接）：返回包括左表中的所有记录和右表中连接字段相等的记录。
　　②RIGHT JOIN（右连接）：返回包括右表中的所有记录和左表中连接字段相等的记录。
　　（1）左连接
　　左连接的结果包括LEFT OUTER子句中指定的左表的所有行，而不仅仅是连接列所匹配的行，如果左表的某行在右表中没有匹配行，则在相关联的结果行中，右表的所有选择列表列均为空值。

mysql> SELECT customers.c_id,orders.o_num
    -> FROM customers LEFT OUTER JOIN orders
    -> ON customers.c_id=orders.c_id;
+-------+-------+
| c_id  | o_num |
+-------+-------+
| 10001 | 30001 |
| 10003 | 30002 |
| 10004 | 30003 |
| 10001 | 30005 |
| 10002 | NULL  |
+-------+-------+
5 rows in set

　　（2）右连接
　　右连接时左连接的反向连接，将返回右表的所有行。如果右表的某行在左表中没有匹配行，左表将返回空值。

mysql> SELECT customers.c_id,orders.o_num
    -> FROM customers RIGHT OUTER JOIN orders
    -> ON customers.c_id=orders.c_id;
+-------+-------+
| c_id  | o_num |
+-------+-------+
| 10001 | 30001 |
| 10003 | 30002 |
| 10004 | 30003 |
| NULL  | 30004 |
| 10001 | 30005 |
+-------+-------+
5 rows in set

1.3 复合条件连接查询

　　复合条件连接查询是在连接查询的过程中，通过添加过滤条件，限制查询的结果，使查询的结果更加准确。

mysql> SELECT customers.c_id,orders.o_num
    -> FROM customers INNER JOIN orders
    -> ON customers.c_id=orders.c_id AND customers.c_id=10001;
+-------+-------+
| c_id  | o_num |
+-------+-------+
| 10001 | 30001 |
| 10001 | 30005 |
+-------+-------+
2 rows in set

2 子查询

　　子查询是一个查询语句嵌套在另一个查询语句内部的查询。在SELECT子句中先计算子查询，子查询结果作为外层另一个查询的过滤条件，查询可以基于一个表或多个表。子查询可以添加到SELECT、UPDATE和DELETE语句中，而且可以进行多层嵌套。

2.1 带ANY、SOME关键字的子查询

　　ANY和SOME关键字是同义词，表示满足其中任一条件，它们允许创建一个表达式对子查询的返回值列表进行比较，只要满足内层子查询中的任何一个比较条件，就返回一个结果作为外层查询的条件。

mysql> CREATE TABLE tbl1(num1 INT NOT NULL);
Query OK, 0 rows affected

mysql> CREATE TABLE tbl2(num1 INT NOT NULL);
Query OK, 0 rows affected

mysql> INSERT INTO tbl1 VALUES(1),(5),(13),(27);
Query OK, 4 rows affected
Records: 4  Duplicates: 0  Warnings: 0

mysql> INSERT INTO tbl2 VALUES(6),(14),(11),(20);
Query OK, 4 rows affected
Records: 4  Duplicates: 0  Warnings: 0

mysql> SELECT num1
    -> FROM tbl1
    -> WHERE num1>ANY(SELECT num1 FROM tbl2);
+------+
| num1 |
+------+
|   13 |
|   27 |
+------+
2 rows in set

　　只要大于tbl2表中任意一个数即为符合条件的结果。

2.2 带ALL关键字的子查询

　　使用ALL需要满足所有内层查询的条件。
　　使用前面的tbl1表和tbl2表：

mysql> SELECT num1
    -> FROM tbl1
    -> WHERE num1>ALL(SELECT num1 FROM tbl2);
+------+
| num1 |
+------+
|   27 |
+------+
1 row in set

2.3 带EXISTS关键字的子查询

　　EXISTS关键字后面的参数是一个任意的子查询，系统对子查询进行运算以判断它是否返回行，如果至少返回一行，那么EXISTS的结果为true，此时外层查询语句将进行查询；如果子查询没有返回任何行，那么EXISTS返回的结果是false，此时外层语句将不进行查询。
　　使用前面的fruits表和suppliers表：
　　（1）查询suppliers表中是否存在s_id=107的供应商，如果存在则查询fruits表中的记录：

mysql> SELECT * FROM fruits
    -> WHERE EXISTS
    -> (SELECT s_name FROM suppliers WHERE s_id=107);
+------+------+------------+---------+
| f_id | s_id | f_name     | f_price |
+------+------+------------+---------+
| a1   |  101 | apple      | 5.2     |
| a2   |  103 | apricot    | 2.2     |
| b1   |  101 | blackberry | 10.2    |
| b2   |  104 | berry      | 7.6     |
| b5   |  107 | xxxx       | 3.6     |
| bs1  |  102 | orange     | 11.2    |
| bs2  |  105 | melon      | 8.2     |
| c0   |  101 | cherry     | 3.2     |
| l2   |  104 | lemon      | 6.4     |
| m1   |  106 | mango      | 15.6    |
| m2   |  105 | xbabay     | 2.6     |
| m3   |  105 | xxtt       | 11.6    |
| o2   |  103 | coconut    | 9.2     |
| t1   |  102 | banana     | 10.3    |
| t2   |  102 | grape      | 5.3     |
| t4   |  107 | xbababa    | 3.6     |
+------+------+------------+---------+
16 rows in set

　　EXISTS关键字可以和条件表达式一起使用：
　　（2）查询suppliers表中是否存在s_id=107的供应商，如果存在则查询fruits表中的f_price大于10.20的记录：

mysql> SELECT * FROM fruits
    -> WHERE f_price>10.20 AND EXISTS
    -> (SELECT s_name FROM suppliers WHERE s_id=107);
+------+------+--------+---------+
| f_id | s_id | f_name | f_price |
+------+------+--------+---------+
| bs1  |  102 | orange | 11.2    |
| m1   |  106 | mango  | 15.6    |
| m3   |  105 | xxtt   | 11.6    |
| t1   |  102 | banana | 10.3    |
+------+------+--------+---------+
4 rows in set

　　NOT EXISTS与EXISTS使用方法相同，返回的结果相反。

2.4 带IN关键字的子查询

　　IN关键字进行子查询时，内层查询语句仅仅返回一个数据列，这个数据列里的值将提供给外层查询语句进行比较操作。
　　例：在orderitems表中查询f_id为c0的订单号，并根据订单号查询具有订单号的客户c_id：

mysql> SELECT c_id
    -> FROM orders
    -> WHERE o_num
    -> IN
    -> (SELECT o_num FROM orderitems WHERE f_id='c0');
+-------+
| c_id  |
+-------+
| 10004 |
| 10001 |
+-------+
2 rows in set

　　NOT IN关键字与IN正好相反

2.5 带比较运算符的子查询

　　子查询还可以使用其他的比较运算符，如”<”,”<=”,”=”,”>=”,”!=”等
　　例，在suppliers表中查询s_city等于’Tianjin’的供应商s_id，然后再fruits表中查询所有该供应商提供的水果的种类：

mysql> SELECT s_id,f_name FROM fruits
    -> WHERE s_id =
    -> (SELECT s1.s_id FROM suppliers AS s1 WHERE s1.s_city='Tianjin');
+------+------------+
| s_id | f_name     |
+------+------------+
|  101 | apple      |
|  101 | blackberry |
|  101 | cherry     |
+------+------------+
3 rows in set

3 合并查询结果

　　使用UNION关键字，可以给出多条SELECT语句，并将它们的结果组合成单个结果集。合并时，两个表对应的列数和数据类型必须相同。各个SELECT语句之间使用UNION或UNION ALL关键字分隔。
　　UNION不使用关键字ALL，执行的时候删除重复的记录，所有返回的行都是唯一的；使用关键字ALL的作用是不删除重复行也不对结果进行自动排序。
　　例：查询所有价格小于9的水果信息，查询s_id等于101和103所有水果的信息，
　　（1）使用UNION连接查询结果：

mysql> SELECT s_id,f_name,f_price
    -> FROM fruits
    -> WHERE f_price<9.0
    -> UNION
    -> SELECT s_id,f_name,f_price
    -> FROM fruits
    -> WHERE s_id IN(101,103);
+------+------------+---------+
| s_id | f_name     | f_price |
+------+------------+---------+
|  101 | apple      | 5.2     |
|  103 | apricot    | 2.2     |
|  104 | berry      | 7.6     |
|  107 | xxxx       | 3.6     |
|  105 | melon      | 8.2     |
|  101 | cherry     | 3.2     |
|  104 | lemon      | 6.4     |
|  105 | xbabay     | 2.6     |
|  102 | grape      | 5.3     |
|  107 | xbababa    | 3.6     |
|  101 | blackberry | 10.2    |
|  103 | coconut    | 9.2     |
+------+------------+---------+
12 rows in set

　　（2）使用UNION ALL连接查询结果：

mysql> SELECT s_id,f_name,f_price
    -> FROM fruits
    -> WHERE f_price<9.0
    -> UNION ALL
    -> SELECT s_id,f_name,f_price
    -> FROM fruits
    -> WHERE s_id IN(101,103);
+------+------------+---------+
| s_id | f_name     | f_price |
+------+------------+---------+
|  101 | apple      | 5.2     |
|  103 | apricot    | 2.2     |
|  104 | berry      | 7.6     |
|  107 | xxxx       | 3.6     |
|  105 | melon      | 8.2     |
|  101 | cherry     | 3.2     |
|  104 | lemon      | 6.4     |
|  105 | xbabay     | 2.6     |
|  102 | grape      | 5.3     |
|  107 | xbababa    | 3.6     |
|  101 | apple      | 5.2     |
|  103 | apricot    | 2.2     |
|  101 | blackberry | 10.2    |
|  101 | cherry     | 3.2     |
|  103 | coconut    | 9.2     |
+------+------------+---------+
15 rows in set

4 为表和字段取别名

　　（1）为表取别名

表名 [AS] 表别名

　　（2）为字段取别名

列名 [AS] 列别名

5 说明

阅读《MySQL5.5 从零开始学》笔记记录。

添仔哥哥
关注
专栏目录
Mysql学习总结（8）——MySql基本查询、连接查询、子查询、正则表达查询讲解
科技D人生
01-04 2306
查询数据指从数据库中获取所需要的数据。查询数据是数据库操作中最常用，也是最重要的操作。用户可以根据自己对数据的需求，使用不同的查询方式。通过不同的查询方式，可以获得不同的数据。MySQL中是使用SELECT语句来查询数据的。在这一章中将讲解的内容包括。 1、查询语句的基本语法 2、在单表上查询数据 3、使用聚合函数查询数据 4、多表上联合查询 5、子查询 6、合并查询结果 7、为表和
MySQL——查询专项练习
掉了根毛的博客
06-02 2413
还记得在一开始学完mysql的各种查询（联合查询、连接查询、子查询）的理论知识后，学得有点云里雾里的，我发现对于单表的查询ok，多表查询有点无从下手，这么多查询，我该用哪个好呢？在脱离文档，笔记可能就有点不太写得出sql了。 我的捷径就是多练习！有针对的去进行练习！在练习中去融会贯通。 先声明一下，本篇博客的练习题的答案并没有注重于查询的性能，仅作为初学者拿来参考。 当然也欢迎开发者给出你们...
SQL——连接查询与子查询
ChaoLingW的博客
07-29 3021
  连接查询        交叉连接 等值连接  内连接 外连接        左连接 右连接     笛卡尔积 结果为两个表行数的乘积 交叉连接 结果符合笛卡尔积     语法 cross join 或者 join 或者直接用","   等值连接： select 字段.... from 表1,... where 连接条件   内连接，合并具有同一列的两个以上的表...
MySQL基础（六）-----子查询和连接查询
leen的博客
06-06 4487
子查询简而言之就是在一个查询里面再嵌套一个或者多个查询语句； 连接查询指的就是将多个表或者单个表连接在一起进行查询
子查询与内连接查询区别（效率上，连接查询高于子查询）、左连接以及连接的原理，还有内连接与左连接的区别
m0_66468899的博客
08-14 2352
子查询与内连接查询区别（效率上，连接查询高于子查询）、左连接以及连接的原理，还有内连接与左连接的区别一、子查询与内连接查询区别（效率上，连接查询高于子查询）：比起连接查询慢点是：它取出表1 的第一行记录 ，就去与表2 的每一行记录进行比较，然后，它再取出表1 的第2行记录，去与表2 的每一行记录进行比较，又取出，然后与另外一个表的每一行记录进行比较，又取出，又与每一行记录比较，又取出。。。。。。：直接取出表1所有记录与表2拼接到一起，然后在拼接后的同一张表再去比较，所以连接查询效率快。
数据库-内外连接 子查询
lildn的博客
11-30 166
内外连接 select * from forum inner join reply on forum.id = reply.t_id;#inner是内连接，查询满足relay.id = forum.id的两个表数据 select * from forum left outer join reply on forum.id = reply.t_id;#查询forum和对应的relay表中的回复，如果没有回复，用null填充 内外连接区别：1. 内连接只显示满足on条件的内容 2. 外链接根据是左外链接还是
问题：连接查询和子查询的区别和连接及优劣？
黑某人
07-19 4112
问题：连接查询和子查询的区别和连接及优劣？ 子查询的定义： 1.子查询就是把一次查询的结果作为条件放到另一个查询中。（两张表之间不需要有关联字段） 连接查询的定义： 连接查询：通过连接运算符实现多个表的查询（两张表需要有联系，通过外键连接） 效率： 1.表关联的效率要高于子查询，因为子查询走的是笛卡尔积， 子查询在查询的时候回将两个表中的数据都查询比较一边。 如果一张表为n条记录，一张为m条记录，效率为n*m 而连接查询会直接去根据条件筛选掉联合表中的数据 效率为 n 或 m ...
MySQL基础知识（四)——子查询和连接
third_的博客
12-24 568
一.子查询 先创建一张商品表，后续对其进行操作。 # 创建一个商品表，商品id：goods_id 商品名称：goods_name 商品分类：goods_cate # 商品品牌：brand_name 商品价格：goods_price 是否上架：is_show 是否已售空：is_saleoff CREATE TABLE IF NOT EXISTS tbl_goods( goods_i...
mysql优化——子查询
Y_BigFFFFFF的博客
07-29 492
项目中有需要，需要对sql进行一些优化。刚刚工作的我对优化可是特别感兴趣，终于能学习到个不错的知识了，于是我跟着大佬的步伐，积累了一些简单的经验。 话不多说，马上进入正题，此次的优化查询主要是两张表，小表数据量可忽略不计，但是字段比较多，大表的话数据量达到了百万级别，用左关联，小表去关联大表的时候会出现查询效率低下，返回结果慢，于是根据仅有不多的知识去做了一些简单的优化，稍微会提升一下。 这是一开始查询的sql与时间 SELECT DISTINCT * FROM BG_order t1 LEFT JO
mysql复习——基础知识
12-14
34. 子查询：在查询语句中嵌套查询。 35. 导入SQL文件：`source 文件路径.sql`。 36. 外键：用于保持表之间关系的关键字，确保数据完整性和一致性。 以上是MySQL基础操作的简要概述，理解和掌握这些知识点是进行...
SQL子查询、内连接和外连接查询
06-04
1．掌握相关。 2．体会各种查询的异同及相互之间的转换，体会各种查询的执行过程，为综合应用打下良好的基础。 ● 查询没有选修指定课程号的学生的学号、姓名、性别、出生日期和级别。课程号由局部变量提供。 declare @Cno char(6); set @Cno='a00002'; select sno as 学号,sname as 姓名,sex as 性别,birthday as 生日,enter_year as 级别 from Student where sno not in(select sno from Select_Course as SC where cno in( select cno from Course where SC.cno=@Cno ));
子查询和关联查询的区别
qiuchaoxi的博客
07-19 1万+
子查询就是查询中又嵌套的查询,表连接都可以用子查询，但不是所有子查询都能用表连接替换，子查询比较灵活，方便，形式多样，适合用于作为查询的筛选条件，而表连接更适合与查看多表的数据。 子查询不一定需要两个表有关联字段，而连接查询必须有字段关联（所谓的主外键关系） 1，表关联的效率要高于子查询，因为子查询走的是笛卡尔积 2，表关联可能有多条记录，子查询只有一条记录，如果需要唯一的列，最好走子查询...
MySQL——连接查询与子查询
最新发布
m0_73968621的博客
09-04 1180
连接查询，结合俩（多）张表，在俩张（多）表当中查询数据，在一张表当中查询一部分，在另一张表当中查询另一部分数据，这种跨表查询，连接多张表查询数据的方法叫做连接查询！内连接与外连接的区别：内连接没有主次关系，两（多）张表是平级的，而外连接有主次关系，主要是查什么，其次是查什么！右外连接（right）：表示join关键字右边的表是主表，主要是查出右边表的数据，顺带将左边的表的数据也查出来。当连接俩张表进行查询的时候，如果没有任何限制的情况下，查询的次数为两张表所有记录的乘积！目前主流使用SQL99语法。
mysql 表的关系&表连接&子查询
qq_38557784的博客
03-24 952
表的关系 一对多 建表原则：在多的一方添加 一方的主键作为外键 多对多 如果数据表是多对多的关系那么需要创建一张表，把2张关系吧的外键引入 一对一关系 在任何一方添加对方的主键作为外键 内连接 表的自然连接（多表查询) 使用的两张表 create database emp; use emp; create table department( id int, name varchar(20) ); create table employee( id int primary key au
六、连接查询和子查询
技术小白
04-18 3183
6.1 链接查询 连接是关系数据库模型的主要特点。连接查询是关系数据库中 主要的查询，主要包括内连接、外连接等。通过连接运算符可以实现多个表查询。 在关系数据库管理系统中，表建立时各数据之间的关系不必确定，常把一个实体的所有信息存放在一个表中。当查询数据时，通过连接操作查询出存放在多个表中的不同实体的信息。当两个或多个表中存在相同意义的字段时，便可以通过这些字段对不同的表进行连接查询。本节将介绍多表之间的内连接查询、外连接查询以及复合条件连接查询. 1.内连接查询 内连接（INNER JOIN）使用比
MySQL--连接查询和子查询
weixin_61500949的博客
05-23 1372
连接查询 一、多表查询的概念： 1.多表查询：从多张表查询数据 2.连接查询： ①内连接：相当于查询A、B交集数据 ②外连接： (1)左外连接：相当于查询A表所有数据和交集的部分数据 (2)右外连接：相当于查询B表所有数据和交集的部分数据 二、内连接： 1.查询全部字段隐式内连接： SELECT 表1.*,表2.*,...FROM 表1,表2,...WHERE 条件； SELECT emp.*,dept...
MySQL—连接查询、子查询
weixin_44725040的博客
04-03 875
什么是笛卡尔积？笛卡尔积，又叫cross join，是SQL中两表连接的一种方式。假如A表中的数据为m行，B表中的数据有n行，那么A和B做笛卡尔积，结果为m*n行需求：查询所有的员工和所有部门结果如下：如果左表是部门表，右表是员工表，左表中每一行记录与右表中的每一行记录全都匹配一次。结果的行数=左表中行数x右表中行数。
MySQL 子查询、内联结、外联结
Sundy_sc的专栏
06-28 312
子查询 MySQL 子查询版本要求：MySQL4.1引入了对子查询的支持。 子查询：嵌套在其他查询语句中的查询。 示例： 利用子查询进行过滤 假如需要查询出成绩表分数最高的学生的姓名及编号 select st.s_no,st.s_name from student st where st.s_no in (select s1.s_no from score s1 where s1.sc_degree in (select max(sc.sc_degree)from score sc)); 从上..
MySQL基础篇 | 连接查询、子查询（嵌套）
热门推荐
m0_61933976的博客
08-30 1万+
MySQL基础篇【第四篇】| 连接查询（内连接和外连接）、子查询（嵌套）
MySQL高级优化：查询逻辑与WHERE条件详解
5. **优化策略**：文档可能还会讨论如何通过使用合适的数据结构（如B树索引、覆盖索引）、减少查询的复杂性、避免N+1问题（针对子查询优化）等方式，提高查询的执行效率。 6. **总结与问答环节**：最后部分通常会对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值