什么是多表联合查询

最新推荐文章于 2023-04-04 11:36:41 发布
最新推荐文章于 2023-04-04 11:36:41 发布
阅读量393 收藏 1
点赞数
文章标签： 数据库 java sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46447154/article/details/126025989
版权

什么是多表联合查询

前面所讲的查询语句都是针对一个表的，但是在关系型数据库中，表与表之间是有联系的，所以在

实际应用中，经常使用多表查询。多表查询就是同时查询两个或两个以上的表。

在 MySQL 中，多表查询主要有交叉连接、内连接、外连接、分组查询与子查询等5种。

交叉连接(CROSS JOIN)

笛卡尔积

交叉连接(CROSS JOIN)：有两种，显式的和隐式的2种，一般用来返回连接表的笛卡尔积。

笛卡尔积（Cartesian product）是指两个集合 X 和 Y 的乘积。

例如，有 A 和 B 两个集合，它们的值如下：

A = {1,2}

B = {3,4,5}

集合 A×B 和 B×A 的结果集分别表示为：

A×B={(1,3), (1,4), (1,5), (2,3), (2,4), (2,5) }; 

B×A={(3,1), (3,2), (4,1), (4,2), (5,1), (5,2) };

以上 A×B 和 B×A 的结果就叫做两个集合的笛卡尔积。

并且，从以上结果我们可以看出：两个集合相乘，不满足交换率，即 A×B≠B×A。

A 集合和 B 集合的笛卡尔积是 A 集合的元素个数 × B 集合的元素个数。

多表查询遵循的算法就是以上提到的笛卡尔积，表与表之间的连接可以看成是在做乘法运算。在实

际应用中，应避免使用笛卡尔积，因为笛卡尔积中容易存在大量的不合理数据，简单来说就是容易

导致查询结果重复、混乱。

交叉连接

交叉连接的语法格式如下：

SELECT <字段名> FROM <表1> CROSS JOIN <表2> [WHERE子句]; 
SELECT <字段名> FROM <表1>, <表2> [WHERE子句];

语法说明如下：

字段名：需要查询的字段名称。

<表1><表2>：需要交叉连接的表名。

WHERE 子句：用来设置交叉连接的查询条件。

注意：多个表交叉连接时，在 FROM 后连续使用 CROSS JOIN 或,即可。以上两种语法的返回结果

是相同的，但是第一种语法才是官方建议的标准写法。

当连接的表之间没有关系时，我们会省略掉 WHERE 子句，这时返回结果就是两个表的笛卡尔积，

返回结果数量就是两个表的数据行相乘。需要注意的是，如果每个表有 1000 行，那么返回结果的

数量就有 1000×1000 = 1000000 行，数据量是非常巨大的。

交叉连接可以查询两个或两个以上的表，为了更好的理解，我们就讲解两个表的交叉连接查询。

例 1

查询学生信息表和科目信息表，并得到一个笛卡尔积。

为了方便观察学生信息表和科目表交叉连接后的运行结果，我们先分别查询出这两个表的数据，再

进行交叉连接查询。

1）查询 students_info 表中的数据，SQL 语句和运行结果如下：

创建表

mysql> create table students_info(id int not null primary key auto_inc 

rement,name varchrar(50),age tinyint,sex varchar(4),height float,course_i 

d int) DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

插入数据

mysql> insert students_info(name,age,sex,height,course_id) values('dan 

y',25,'男',160,1),,('green',23,'男',158,2),('henry',23,'女',185,1),('jane',22,'男',162,3),('jim',24,'女',175,,2),('john',21,'男',172,4),('lily',2 

2,'男',165,4),('susan',23,'男',170,5),('thomas',22,'女',178,5),('tom',2 

3,'女',165,5); 

Query OK, 10 rows affected (0.00 sec) 

Records: 10 Duplicates: 0 Warnings: 0

查看表

mysql> select * from students_info; 

+----+--------+------+------+--------+-----------+ 

| id | name | age | sex | height | course_id | 

+----+--------+------+------+--------+-----------+ 

| 1 | dany | 25 | 男 | 160 | 1 | 

| 2 | green | 23 | 男 | 158 | 2 | 

| 3 | henry | 23 | 女 | 185 | 1 | 

| 4 | jane | 22 | 男 | 162 | 3 | 

| 5 | jim | 24 | 女 | 175 | 2 | 

| 6 | john | 21 | 男 | 172 | 4 | 

| 7 | lily | 22 | 男 | 165 | 4 | 

| 8 | susan | 23 | 男 | 170 | 5 | 

| 9 | thomas | 22 | 女 | 178 | 5 | 

| 10 | tom | 23 | 女 | 165 | 5 | 

+----+--------+------+------+--------+-----------+ 

10 rows in set (0.00 sec)

2）查询 course 表中的数据，SQL 语句和运行结果如下：

mysql> create table tb*_course(id int not null primary key auto_*increment, 

course*_name varchar(50));* 

*Query OK, 0 rows affected (0.02 sec)* 

mysql> desc course; 

+-------------+-------------+------+-----+---------+----------------+ 

| Field | Type | Null | Key | Default | Extra | 

+-------------+-------------+------+-----+---------+----------------+ 

| id | int(11) | NO | PRI | NULL | auto*_increment |* 

*| course_*name | varchar(50) | YES | | NULL | | 

+-------------+-------------+------+-----+---------+----------------+ 

2 rows in set (0.00 sec) 

mysql> insert tb*_course(course_*name) values(*'Java'*),(*'Mysql'*),(*'Python'*), 

(*'Go'*),(*'C++'*); 

Query OK, 5 rows affected (0.00 sec) 

Records: 5 Duplicates: 0 Warnings: 0 

mysql> select * from course; 

+----+-------------+ 

| id | course_name | 

+----+-------------+ 

| 1 | Java | 

| 2 | Mysql || 3 | Python | 

| 4 | Go | 

| 5 | C++ | 

+----+-------------+ 

5 rows in set (0.00 sec)

开一个同样的新终端查看两张表

mysql> use hxd; 

Reading table information for completion of table and column names 

You can turn off this feature to get a quicker startup with -A 

Database changed 

mysql> show tables; 

+------------------+ 

| Tables_in_hxd | 

+------------------+ 

| tb*_course |* 

*| tb_*students*_info |* 

*+------------------+* 

*2 rows in set (0.00 sec)*

两个表就准备好了

3）使用 CROSS JOIN 查询出两张表中的笛卡尔积，SQL 语句和运行结果如下：

mysql> select * from course cross join students_info; 

+----+-------------+----+--------+------+------+--------+-----------+ 

| id | course_name | id | name | age | sex | height | course_id | 

+----+-------------+----+--------+------+------+--------+-----------+ 

| 1 | Java | 1 | dany | 25 | 男 | 160 | 1 | 

| 2 | Mysql | 1 | dany | 25 | 男 | 160 | 1 | 

| 3 | Python | 1 | dany | 25 | 男 | 160 | 1 | 

| 4 | Go | 1 | dany | 25 | 男 | 160 | 1 | 

| 5 | C++ | 1 | dany | 25 | 男 | 160 | 1 | 

| 1 | Java | 2 | green | 23 | 男 | 158 | 2 | 

| 2 | Mysql | 2 | green | 23 | 男 | 158 | 2 | 

| 3 | Python | 2 | green | 23 | 男 | 158 | 2 | 

| 4 | Go | 2 | green | 23 | 男 | 158 | 2 | 

| 5 | C++ | 2 | green | 23 | 男 | 158 | 2 | 

| 1 | Java | 3 | henry | 23 | 女 | 185 | 1 | 

| 2 | Mysql | 3 | henry | 23 | 女 | 185 | 1 | 

| 3 | Python | 3 | henry | 23 | 女 | 185 | 1 | 

| 4 | Go | 3 | henry | 23 | 女 | 185 | 1 | 

| 5 | C++ | 3 | henry | 23 | 女 | 185 | 1 | 

| 1 | Java | 4 | jane | 22 | 男 | 162 | 3 | 

| 2 | Mysql | 4 | jane | 22 | 男 | 162 | 3 | 

| 3 | Python | 4 | jane | 22 | 男 | 162 | 3 | 

| 4 | Go | 4 | jane | 22 | 男 | 162 | 3 | 

| 5 | C++ | 4 | jane | 22 | 男 | 162 | 3 | 

| 1 | Java | 5 | jim | 24 | 女 | 175 | 2 | 

| 2 | Mysql | 5 | jim | 24 | 女 | 175 | 2 || 3 | Python | 5 | jim | 24 | 女 | 175 | 2 | 

| 4 | Go | 5 | jim | 24 | 女 | 175 | 2 | 

| 5 | C++ | 5 | jim | 24 | 女 | 175 | 2 | 

| 1 | Java | 6 | john | 21 | 男 | 172 | 4 | 

| 2 | Mysql | 6 | john | 21 | 男 | 172 | 4 | 

| 3 | Python | 6 | john | 21 | 男 | 172 | 4 | 

| 4 | Go | 6 | john | 21 | 男 | 172 | 4 | 

| 5 | C++ | 6 | john | 21 | 男 | 172 | 4 | 

| 1 | Java | 7 | lily | 22 | 男 | 165 | 4 | 

| 2 | Mysql | 7 | lily | 22 | 男 | 165 | 4 | 

| 3 | Python | 7 | lily | 22 | 男 | 165 | 4 | 

| 4 | Go | 7 | lily | 22 | 男 | 165 | 4 | 

| 5 | C++ | 7 | lily | 22 | 男 | 165 | 4 | 

| 1 | Java | 8 | susan | 23 | 男 | 170 | 5 | 

| 2 | Mysql | 8 | susan | 23 | 男 | 170 | 5 | 

| 3 | Python | 8 | susan | 23 | 男 | 170 | 5 | 

| 4 | Go | 8 | susan | 23 | 男 | 170 | 5 | 

| 5 | C++ | 8 | susan | 23 | 男 | 170 | 5 | 

| 1 | Java | 9 | thomas | 22 | 女 | 178 | 5 | 

| 2 | Mysql | 9 | thomas | 22 | 女 | 178 | 5 | 

| 3 | Python | 9 | thomas | 22 | 女 | 178 | 5 | 

| 4 | Go | 9 | thomas | 22 | 女 | 178 | 5 | 

| 5 | C++ | 9 | thomas | 22 | 女 | 178 | 5 | 

| 1 | Java | 10 | tom | 23 | 女 | 165 | 5 | 

| 2 | Mysql | 10 | tom | 23 | 女 | 165 | 5 | 

| 3 | Python | 10 | tom | 23 | 女 | 165 | 5 | 

| 4 | Go | 10 | tom | 23 | 女 | 165 | 5 | 

| 5 | C++ | 10 | tom | 23 | 女 | 165 | 5 | 

+----+-------------+----+--------+------+------+--------+-----------+ 

50 rows in set (0.00 sec)

英文逗号 , 可以代替cross join

mysql> select * from course,students_info; 

+----+-------------+----+--------+------+------+--------+-----------+ 

| id | course_name | id | name | age | sex | height | course_id | 

+----+-------------+----+--------+------+------+--------+-----------+ 

| 1 | Java | 1 | dany | 25 | 男 | 160 | 1 | 

| 2 | Mysql | 1 | dany | 25 | 男 | 160 | 1 | 

| 3 | Python | 1 | dany | 25 | 男 | 160 | 1 | 

| 4 | Go | 1 | dany | 25 | 男 | 160 | 1 | 

| 5 | C++ | 1 | dany | 25 | 男 | 160 | 1 | 

| 1 | Java | 2 | green | 23 | 男 | 158 | 2 | 

| 2 | Mysql | 2 | green | 23 | 男 | 158 | 2 | 

| 3 | Python | 2 | green | 23 | 男 | 158 | 2 | 

| 4 | Go | 2 | green | 23 | 男 | 158 | 2 | 

| 5 | C++ | 2 | green | 23 | 男 | 158 | 2 | 

| 1 | Java | 3 | henry | 23 | 女 | 185 | 1 | 

| 2 | Mysql | 3 | henry | 23 | 女 | 185 | 1 | 

| 3 | Python | 3 | henry | 23 | 女 | 185 | 1 | 

| 4 | Go | 3 | henry | 23 | 女 | 185 | 1 | 

| 5 | C++ | 3 | henry | 23 | 女 | 185 | 1 || 1 | Java | 4 | jane | 22 | 男 | 162 | 3 | 

| 2 | Mysql | 4 | jane | 22 | 男 | 162 | 3 | 

| 3 | Python | 4 | jane | 22 | 男 | 162 | 3 | 

| 4 | Go | 4 | jane | 22 | 男 | 162 | 3 | 

| 5 | C++ | 4 | jane | 22 | 男 | 162 | 3 | 

| 1 | Java | 5 | jim | 24 | 女 | 175 | 2 | 

| 2 | Mysql | 5 | jim | 24 | 女 | 175 | 2 | 

| 3 | Python | 5 | jim | 24 | 女 | 175 | 2 | 

| 4 | Go | 5 | jim | 24 | 女 | 175 | 2 | 

| 5 | C++ | 5 | jim | 24 | 女 | 175 | 2 | 

| 1 | Java | 6 | john | 21 | 男 | 172 | 4 | 

| 2 | Mysql | 6 | john | 21 | 男 | 172 | 4 | 

| 3 | Python | 6 | john | 21 | 男 | 172 | 4 | 

| 4 | Go | 6 | john | 21 | 男 | 172 | 4 | 

| 5 | C++ | 6 | john | 21 | 男 | 172 | 4 | 

| 1 | Java | 7 | lily | 22 | 男 | 165 | 4 | 

| 2 | Mysql | 7 | lily | 22 | 男 | 165 | 4 | 

| 3 | Python | 7 | lily | 22 | 男 | 165 | 4 | 

| 4 | Go | 7 | lily | 22 | 男 | 165 | 4 | 

| 5 | C++ | 7 | lily | 22 | 男 | 165 | 4 | 

| 1 | Java | 8 | susan | 23 | 男 | 170 | 5 | 

| 2 | Mysql | 8 | susan | 23 | 男 | 170 | 5 | 

| 3 | Python | 8 | susan | 23 | 男 | 170 | 5 | 

| 4 | Go | 8 | susan | 23 | 男 | 170 | 5 | 

| 5 | C++ | 8 | susan | 23 | 男 | 170 | 5 | 

| 1 | Java | 9 | thomas | 22 | 女 | 178 | 5 | 

| 2 | Mysql | 9 | thomas | 22 | 女 | 178 | 5 | 

| 3 | Python | 9 | thomas | 22 | 女 | 178 | 5 | 

| 4 | Go | 9 | thomas | 22 | 女 | 178 | 5 | 

| 5 | C++ | 9 | thomas | 22 | 女 | 178 | 5 | 

| 1 | Java | 10 | tom | 23 | 女 | 165 | 5 | 

| 2 | Mysql | 10 | tom | 23 | 女 | 165 | 5 | 

| 3 | Python | 10 | tom | 23 | 女 | 165 | 5 | 

| 4 | Go | 10 | tom | 23 | 女 | 165 | 5 | 

| 5 | C++ | 10 | tom | 23 | 女 | 165 | 5 | 

+----+-------------+----+--------+------+------+--------+-----------+ 

50 rows in set (0.00 sec)

mysql>

由运行结果可以看出，course 和 students_info 表交叉连接查询后，返回了 50 条记录。可以

想象，当表中的数据较多时，得到的运行结果会非常长，而且得到的运行结果也没太大的意义。所

以，通过交叉连接的方式进行多表查询的这种方法并不常用，我们应该尽量避免这种查询。

例 2

查询 course 表中的 id 字段和 students_info 表中的 course_id 字段相等的内容， SQL 语句

和运行结果如下：

mysql> select * from course cross join students_info where tb_cours 

e.id = students_info.course_id; 

+----+-------------+----+--------+------+------+--------+-----------+ 

| id | course_name | id | name | age | sex | height | course_id | 

+----+-------------+----+--------+------+------+--------+-----------+ 

| 1 | Java | 1 | dany | 25 | 男 | 160 | 1 | 

| 2 | Mysql | 2 | green | 23 | 男 | 158 | 2 | 

| 1 | Java | 3 | henry | 23 | 女 | 185 | 1 | 

| 3 | Python | 4 | jane | 22 | 男 | 162 | 3 | 

| 2 | Mysql | 5 | jim | 24 | 女 | 175 | 2 | 

| 4 | Go | 6 | john | 21 | 男 | 172 | 4 | 

| 4 | Go | 7 | lily | 22 | 男 | 165 | 4 | 

| 5 | C++ | 8 | susan | 23 | 男 | 170 | 5 | 

| 5 | C++ | 9 | thomas | 22 | 女 | 178 | 5 | 

| 5 | C++ | 10 | tom | 23 | 女 | 165 | 5 | 

+----+-------------+----+--------+------+------+--------+-----------+ 

10 rows in set (0.00 sec)

查看每一个课程有哪些人学

mysql> select course.course_name,students_info.name from course 

cross join tb_studdents_info where course.id = students_info.cours 

e_id; 

+-------------+--------+ 

| course_name | name | 

+-------------+--------+ 

| Java | dany | 

| Mysql | green | 

| Java | henry | 

| Python | jane | 

| Mysql | jim | 

| Go | john | 

| Go | lily | 

| C++ | susan | 

| C++ | thomas | 

| C++ | tom | 

+-------------+--------+ 

10 rows in set (0.00 sec)

查看课程对应的年龄

mysql> select course.course_name,students_info.age from course c 

ross join tb_studeents_info where course.id = students_info.course_ 

id; 

+-------------+------+ 

| course_name | age | 

+-------------+------+ 

| Java | 25 | 

| Mysql | 23 | 

| Java | 23 | 

| Python | 22 || Mysql | 24 | 

| Go | 21 | 

| Go | 22 | 

| C++ | 23 | 

| C++ | 22 | 

| C++ | 23 | 

+-------------+------+ 

10 rows in set (0.00 sec)

查看课程对应的性别

mysql> select course.course_name,students_info.sex from course c

ross join tb_studeents_info where course.id = students_info.course_

id;

±------------±-----+

| course_name | sex |

±------------±-----+

| Java | 男 |

| Mysql | 男 |

| Java | 女 |

| Python | 男 |

| Mysql | 女 |

| Go | 男 |

| Go | 男 |

| C++ | 男 |

| C++ | 女 |

| C++ | 女 |

±------------±-----+

10 rows in set (0.00 sec)

学java有哪些人

mysql> select course.course_name,students_info.name from course 

cross join tb_studdents_info where course.id = students_info.cours 

e_id and course.course_name = 'Java'; 

+-------------+-------+ 

| course_name | name | 

+-------------+-------+ 

| Java | dany | 

| Java | henry | 

+-------------+-------+ 

2 rows in set (0.00 sec)

学java的年龄

mysql> select tb*_course.course_*name,tb*_students_*info.age from tb*_course c* 

*ross join tb_*studeents*_info where tb_*course.id = tb*_students_*info.course*_* 

*id and tb_*course.course*_name = 'Java* 

*a';* 

*+-------------+------+* 

*| course_*name | age |+-------------+------+ 

| Java | 25 | 

| Java | 23 | 

+-------------+------+ 

2 rows in set (0.00 sec) 

学java的平均年龄多大 

mysql> select course.course_name,avg(students_info.age) from tb_cou 

rse cross join tb__students_info where course.id = students_info.co 

urse_id and course.course_name = 'Java'; 

+-------------+---------------------------+ 

| course_name | avg(students_info.age) | 

+-------------+---------------------------+ 

| Java | 24.0000 | 

+-------------+---------------------------+ 

1 row in set (0.00 sec) 

取java年龄最小 

mysql> select course.course_name,min(students_info.age) from tb_cou 

rse cross join tb__students_info where course.id = students_info.co 

urse_id and course.course_name = 'Java'; 

+-------------+---------------------------+ 

| course_name | min(students_info.age) | 

+-------------+---------------------------+ 

| Java | 23 | 

+-------------+---------------------------+ 

1 row in set (0.00 sec) 

取java年龄最大 

mysql> select course.course_name,max(students_info.age) from tb_cou 

rse cross join tb__students_info where course.id = students_info.co 

urse_id and course.course_name = 'Java'; 

+-------------+---------------------------+ 

| course_name | max(students_info.age) | 

+-------------+---------------------------+ 

| Java | 25 | 

+-------------+---------------------------+ 

1 row in set (0.00 sec)

如果在交叉连接时使用 WHERE 子句，MySQL 会先生成两个表的笛卡尔积，然后再选择满足 WHERE 条件的记录。因此，表的数量较多时，交叉连接会非常非常慢。一般情况下不建议使用交 叉连接。

​ 在 MySQL 中，多表查询一般使用内连接和外连接，它们的效率要高于交叉连接。3.3 内连接 内连接（INNER JOIN）主要通过设置连接条件的方式，来移除查询结果中某些数据行的交叉连 接。简单来说，就是利用条件表达式来消除交叉连接的某些数据行。 内连接使用 INNER JOIN 关键字连接两张表，并使用 ON 子句来设置连接条件。如果没有连接条 件，INNER JOIN 和 CROSS JOIN 在语法上是等同的，两者可以互换。 内连接的语法格式如下：

SELECT <字段名> FROM <表1> INNER JOIN <表2> [ON子句];

语法说明如下。

字段名：需要查询的字段名称。

<表1><表2>：需要内连接的表名。

INNER JOIN ：内连接中可以省略 INNER 关键字，只用关键字 JOIN。

ON 子句：用来设置内连接的连接条件。

INNER JOIN 也可以使用 WHERE 子句指定连接条件，但是 INNER JOIN … ON 语法是官方的

标准写法，而且 WHERE 子句在某些时候会影响查询的性能。

多个表内连接时，在 FROM 后连续使用 INNER JOIN 或 JOIN 即可。

内连接可以查询两个或两个以上的表。为了更好的理解，暂时只讲解两个表的连接查询。

例 1

在 students_info 表和 course 表之间，使用内连接查询学生姓名和相对应的课程名称，SQL

语句和运行结果如下。

mysql> select * from course inner join students_info; 

+----+-------------+----+--------+------+------+--------+-----------+ 

| id | course_name | id | name | age | sex | height | course_id | 

+----+-------------+----+--------+------+------+--------+-----------+ 

| 1 | Java | 1 | dany | 25 | 男 | 160 | 1 | 

| 2 | Mysql | 1 | dany | 25 | 男 | 160 | 1 | 

| 3 | Python | 1 | dany | 25 | 男 | 160 | 1 | 

| 4 | Go | 1 | dany | 25 | 男 | 160 | 1 | 

| 5 | C++ | 1 | dany | 25 | 男 | 160 | 1 | 

| 1 | Java | 2 | green | 23 | 男 | 158 | 2 | 

| 2 | Mysql | 2 | green | 23 | 男 | 158 | 2 | 

| 3 | Python | 2 | green | 23 | 男 | 158 | 2 | 

| 4 | Go | 2 | green | 23 | 男 | 158 | 2 | 

| 5 | C++ | 2 | green | 23 | 男 | 158 | 2 | 

| 1 | Java | 3 | henry | 23 | 女 | 185 | 1 | 

| 2 | Mysql | 3 | henry | 23 | 女 | 185 | 1 | 

| 3 | Python | 3 | henry | 23 | 女 | 185 | 1 | 

| 4 | Go | 3 | henry | 23 | 女 | 185 | 1 | 

| 5 | C++ | 3 | henry | 23 | 女 | 185 | 1 || 1 | Java | 4 | jane | 22 | 男 | 162 | 3 | 

| 2 | Mysql | 4 | jane | 22 | 男 | 162 | 3 | 

| 3 | Python | 4 | jane | 22 | 男 | 162 | 3 | 

| 4 | Go | 4 | jane | 22 | 男 | 162 | 3 | 

| 5 | C++ | 4 | jane | 22 | 男 | 162 | 3 | 

| 1 | Java | 5 | jim | 24 | 女 | 175 | 2 | 

| 2 | Mysql | 5 | jim | 24 | 女 | 175 | 2 | 

| 3 | Python | 5 | jim | 24 | 女 | 175 | 2 | 

| 4 | Go | 5 | jim | 24 | 女 | 175 | 2 | 

| 5 | C++ | 5 | jim | 24 | 女 | 175 | 2 | 

| 1 | Java | 6 | john | 21 | 男 | 172 | 4 | 

| 2 | Mysql | 6 | john | 21 | 男 | 172 | 4 | 

| 3 | Python | 6 | john | 21 | 男 | 172 | 4 | 

| 4 | Go | 6 | john | 21 | 男 | 172 | 4 | 

| 5 | C++ | 6 | john | 21 | 男 | 172 | 4 | 

| 1 | Java | 7 | lily | 22 | 男 | 165 | 4 | 

| 2 | Mysql | 7 | lily | 22 | 男 | 165 | 4 | 

| 3 | Python | 7 | lily | 22 | 男 | 165 | 4 | 

| 4 | Go | 7 | lily | 22 | 男 | 165 | 4 | 

| 5 | C++ | 7 | lily | 22 | 男 | 165 | 4 | 

| 1 | Java | 8 | susan | 23 | 男 | 170 | 5 | 

| 2 | Mysql | 8 | susan | 23 | 男 | 170 | 5 | 

| 3 | Python | 8 | susan | 23 | 男 | 170 | 5 | 

| 4 | Go | 8 | susan | 23 | 男 | 170 | 5 | 

| 5 | C++ | 8 | susan | 23 | 男 | 170 | 5 | 

| 1 | Java | 9 | thomas | 22 | 女 | 178 | 5 | 

| 2 | Mysql | 9 | thomas | 22 | 女 | 178 | 5 | 

| 3 | Python | 9 | thomas | 22 | 女 | 178 | 5 | 

| 4 | Go | 9 | thomas | 22 | 女 | 178 | 5 | 

| 5 | C++ | 9 | thomas | 22 | 女 | 178 | 5 | 

| 1 | Java | 10 | tom | 23 | 女 | 165 | 5 | 

| 2 | Mysql | 10 | tom | 23 | 女 | 165 | 5 | 

| 3 | Python | 10 | tom | 23 | 女 | 165 | 5 | 

| 4 | Go | 10 | tom | 23 | 女 | 165 | 5 | 

| 5 | C++ | 10 | tom | 23 | 女 | 165 | 5 | 

+----+-------------+----+--------+------+------+--------+-----------+ 

50 rows in set (0.00 sec)

使用内连接查询学生姓名和相对应的课程名称

mysql> select s.name,c.course_name from students_info s inner join tb_ 

course c on s.course_id = c.id; 

+--------+-------------+ 

| name | course_name | 

+--------+-------------+ 

| dany | Java | 

| green | Mysql | 

| henry | Java | 

| jane | Python | 

| jim | Mysql | 

| john | Go | 

| lily | Go || susan | C++ | 

| thomas | C++ | 

| tom | C++ | 

+--------+-------------+ 

10 rows in set (0.00 sec) 

统计学java的有多少人 

mysql> select count(s.name),c.course_name from students_info s inner j 

oin course c onn s.course_id = c.id and c.course_name = 'Java'; 

+---------------+-------------+ 

| count(s.name) | course_name | 

+---------------+-------------+ 

| 2 | Java | 

+---------------+-------------+ 

1 row in set (0.00 sec)

在这里的查询语句中，两个表之间的关系通过 INNER JOIN指定，连接的条件使用ON子句给出。

注意：当对多个表进行查询时，要在 SELECT 语句后面指定字段是来源于哪一张表。因此，在多表 查询时，SELECT 语句后面的写法是表名.列名。另外，如果表名非常长的话，也可以给表设置别 名，这样就可以直接在 SELECT 语句后面写上表的别名.列名。

外连接

内连接的查询结果都是符合连接条件的记录，而外连接会先将连接的表分为基表和参考表，再以基 表为依据返回满足和不满足条件的记录。 外连接可以分为左外连接和右外连接2种，下面根据实例分别介绍左外连接和右外连接。

左连接

左外连接又称为左连接，使用 LEFT OUTER JOIN 关键字连接两个表，并使用 ON 子句来设置连接 条件。

左连接的语法格式如下：

SELECT <字段名> FROM <表1> LEFT OUTER JOIN <表2> <ON子句>;

语法说明如下:

字段名：需要查询的字段名称。

<表1><表2>：需要左连接的表名。

LEFT OUTER JOIN：左连接中可以省略 OUTER 关键字，只使用关键字 LEFT JOIN。ON 子句：用来设置左连接的连接条件，不能省略。

上述语法中，”表1”为基表，”表2”为参考表。左连接查询时，可以查询出”表1”中的所有记录 和”表2”中匹配连接条件的记录。如果”表1”的某行在”表2”中没有匹配行，那么在返回结果 中，”表2”的字段值均为空值（NULL）。

例 1

在进行左连接查询之前，我们先查看 course 和 students_info 两张表中的数据。SQL 语句和 运行结果如下:

mysql> select * from course; 

+----+-------------+ 

| id | course_name | 

+----+-------------+ 

| 1 | Java | 

| 2 | Mysql | 

| 3 | Python | 

| 4 | Go | 

| 5 | C++ | 

+----+-------------+ 

5 rows in set (0.00 sec)

在 students_info 表和 course 表中查询所有学生姓名和相对应的课程名称，包括没有课程的学生，SQL 语句和运行结果如下:

mysql> select s.name,c.course_name from students_info s  left outer join course c on s.course_id = c.id;
+--------+-------------+
| name   | course_name |
+--------+-------------+
| Dany   | Java        |
| Henry  | Java        |
| Green  | MySQL       |
| Jim    | MySQL       |
| Jane   | Python      |
| John   | Go          |
| Lily   | Go          |
| Susan  | C++         |
| Thomas | C++         |
| Tom    | C++         |
| xiaoqi | NULL        |
+--------+-------------+
11 rows in set (0.00 sec)
右连接

右外连接又称为右连接，右连接是左连接的反向连接。使用 RIGHT OUTER JOIN 关键字连接两个表，并使用 ON 子句来设置连接条件。

右连接的语法格式如下：

SELECT <字段名> FROM <表1> RIGHT OUTER JOIN <表2> <ON子句>;

语法说明如下:

  • 字段名：需要查询的字段名称。
  • <表1><表2>：需要右连接的表名。
  • RIGHT OUTER JOIN：右连接中可以省略 OUTER 关键字，只使用关键字 RIGHT JOIN。
  • ON 子句：用来设置右连接的连接条件，不能省略。

与左连接相反，右连接以"表2"为基表，"表1"为参考表。右连接查询时，可以查询出"表2"中的所有记录和"表1"中匹配连接条件的记录。如果"表2"的某行在"表1"中没有匹配行，那么在返回结果中，"表1"的字段值均为空值（NULL）。
例 2
在 students_info 表和 course 表中查询所有课程，包括没有学生的课程，SQL 语句和运行结果如下:

mysql> select   s.name,c.course_name       from students_info s right outer join tb_courrse c on s.course_id = c.id;
+--------+-------------+
| name   | course_name |
+--------+-------------+
| Dany   | Java        |
| Green  | MySQL       |
| Henry  | Java        |
| Jane   | Python      |
| Jim    | MySQL       |
| John   | Go          |
| Lily   | Go          |
| Susan  | C++         |
| Thomas | C++         |
| Tom    | C++         |
| NULL   | HTML        |
+--------+-------------+
11 rows in set (0.00 sec)

分组查询

在 MySQL 中，GROUP BY 关键字可以根据一个或多个字段对查询结果进行分组。

使用 GROUP BY 关键字的语法格式如下：

GROUP BY  <字段名>

其中，"字段名"表示需要分组的字段名称，多个字段时用逗号隔开。

GROUP BY单独使用

单独使用 GROUP BY 关键字时，查询结果会只显示每个分组的第一条记录。

下面根据 students_info 表中的 sex 字段进行分组查询，SQL 语句和运行结果如下

mysql> select name,sex from students_info group by sex;
+-------+------+
| name  | sex  |
+-------+------+
| Henry | 女   |
| Dany  | 男   |
+-------+------+
2 rows in set (0.00 sec)

GROUP BY 关键字可以和 GROUP_CONCAT() 函数一起使用。GROUP_CONCAT() 函数会把每个分组的字段值都显示出来。

下面根据 students_info 表中的 sex 字段进行分组查询，使用 GROUP_CONCAT() 函数将每个分组的 name 字段的值都显示出来。SQL 语句和运行结果如下：

mysql> select sex,group_concat(name,age)   from students_info group by sex;
+------+----------------------------+
| sex  | GROUP_CONCAT(name)         |
+------+----------------------------+
| 女   | Henry,Jim,John,Thomas,Tom  |
| 男   | Dany,Green,Jane,Lily,Susan |
+------+----------------------------+
2 rows in set (0.00 sec)

下面根据 students_info 表中的 age 和 sex 字段进行分组查询。SQL 语句和运行结果

mysql> select sex,group_concat(name),height   from students_info group by sex,height;
+------+------+--------------------+
| age  | sex  | GROUP_CONCAT(name) |
+------+------+--------------------+
|   21 | 女   | John               |
|   22 | 女   | Thomas             |
|   22 | 男   | Jane,Lily          |
|   23 | 女   | Henry,Tom          |
|   23 | 男   | Green,Susan        |
|   24 | 女   | Jim                |
|   25 | 男   | Dany               |
+------+------+--------------------+
7 rows in set (0.00 sec)
GROUP BY 与 GROUP_CONCAT()

GROUP BY 关键字可以和 GROUP_CONCAT() 函数一起使用。GROUP_CONCAT() 函数会把每个分组的字段值都显示出来。

下面根据 students_info 表中的 sex 字段进行分组查询，使用 GROUP_CONCAT() 函数将每个分组的 name 字段的值都显示出来。SQL 语句和运行结果如下：

mysql> SELECT `sex`, GROUP_CONCAT(name) FROM students_info GROUP BY sex;
+------+----------------------------+
| sex  | GROUP_CONCAT(name)         |
+------+----------------------------+
| 女   | Henry,Jim,John,Thomas,Tom  |
| 男   | Dany,Green,Jane,Lily,Susan |
+------+----------------------------+
2 rows in set (0.00 sec)

下面根据 students_info 表中的 age 和 sex 字段进行分组查询。SQL 语句和运行结果如下：

mysql> SELECT age,sex,GROUP_CONCAT(name) FROM students_info 
    -> GROUP BY age,sex;
+------+------+--------------------+
| age  | sex  | GROUP_CONCAT(name) |
+------+------+--------------------+
|   21 | 女   | John               |
|   22 | 女   | Thomas             |
|   22 | 男   | Jane,Lily          |
|   23 | 女   | Henry,Tom          |
|   23 | 男   | Green,Susan        |
|   24 | 女   | Jim                |
|   25 | 男   | Dany               |
+------+------+--------------------+
7 rows in set (0.00 sec)

GROUP BY 与聚合函数
在数据统计时，GROUP BY 关键字经常和聚合函数一起使用。

聚合函数包括 COUNT()，SUM()，AVG()，MAX() 和 MIN()。其中，COUNT() 用来统计记录的条数；SUM() 用来计算字段值的总和；AVG() 用来计算字段值的平均值；MAX() 用来查询字段的最大值；MIN() 用来查询字段的最小值。

下面根据 students_info 表的 sex 字段进行分组查询，使用 COUNT() 函数计算每一组的记录数。SQL 语句和运行结果如下：

mysql> select sex,count(sex) from students_info
    -> group by sex;
+------+------------+
| sex  | count(sex) |
+------+------------+
| 女   |          5 |
| 男    |          6 |
+------+------------+
2 rows in set (0.00 sec)

平均值：

mysql> select sex,avg(height),age from students_info group by age; 
+------+--------------------+------+
| sex  | avg(height)        | age  |
+------+--------------------+------+
| 男   |                180 |   20 |
| 女   |                172 |   21 |
| 男   | 168.33333333333334 |   22 |
| 男   |              169.5 |   23 |
| 女   |                175 |   24 |
| 男   |                160 |   25 |
+------+--------------------+------+
6 rows in set (0.00 sec)

总和

mysql> select sum(age),group_concat(name),id  from students_info;
+----------+-------------------------------------------------------------+----+
| sum(age) | group_concat(name)                                          | id |
+----------+-------------------------------------------------------------+----+
|      248 | Dany,Green,Henry,Jane,Jim,John,Lily,Susan,Thomas,Tom,xiaoqi |  1 |
+----------+-------------------------------------------------------------+----+
1 row in set (0.00 sec)

最大值

+----------+-------------------------------------------------------------+----+
| max(age) | group_concat(name)                                          | id |
+----------+-------------------------------------------------------------+----+
|       25 | Dany,Green,Henry,Jane,Jim,John,Lily,Susan,Thomas,Tom,xiaoqi |  1 |
+----------+-------------------------------------------------------------+----+
1 row in set (0.00 sec)

最小值

mysql> select s.name,min(s.age),c.course_name  from students_info s inner join course c on s.course_id = c.id;
+------+------------+-------------+
| name | min(s.age) | course_name |
+------+------------+-------------+
| Dany |         21 | Java        |
+------+------------+-------------+
1 row in set (0.01 sec)
GROUP BY 与 WITH ROLLUP

WITH POLLUP 关键字用来在所有记录的最后加上一条记录，这条记录是上面所有记录的总和，即统计记录数量。

下面根据 students_info 表中的 sex 字段进行分组查询，并使用 WITH ROLLUP 显示记录的总和：

mysql> celect sex,group_concat(name) from students_info 
    ->GROUP BY sex WITH ROLLUP;
+------+------------------------------------------------------+
| sex  | group_concat(name)                                  |
+------+------------------------------------------------------+
| 女   | Henry,Jim,John,Thomas,Tom                            |
| 男   | Dany,Green,Jane,Lily,Susan                           |
| NULL | Henry,Jim,John,Thomas,Tom,Dany,Green,Jane,Lily,Susan |
+------+------------------------------------------------------+
3 rows in set (0.00 sec)

子查询

子查询是 MySQL 中比较常用的查询方法，通过子查询可以实现多表查询。子查询指将一个查询语句嵌套在另一个查询语句中。子查询可以在 SELECT、UPDATE 和 DELETE 语句中使用，而且可以进行多层嵌套。在实际开发时，子查询经常出现在 WHERE 子句中。

子查询在 WHERE 中的语法格式如下：

WHERE <表达式> <操作符> (子查询)

其中，操作符可以是比较运算符和 IN、NOT IN、EXISTS、NOT EXISTS 等关键字。

1）IN | NOT IN
当表达式与子查询返回的结果集中的某个值相等时，返回 TRUE，否则返回 FALSE；若使用关键字 NOT，则返回值正好相反。

2）EXISTS | NOT EXISTS
用于判断子查询的结果集是否为空，若子查询的结果集不为空，返回 TRUE，否则返回 FALSE；若使用关键字 NOT，则返回的值正好相反。
例 1
使用子查询在 students_info 表和 course 表中查询学习 Java 课程的学生姓名，SQL 语句和运行结果如下:

mysql> SELECT name FROM students_info 
    -> WHERE course_id IN (SELECT id FROM course WHERE course_name = 'Java');
+-------+
| name  |
+-------+
| Dany  |
| Henry |
+-------+
2 rows in set (0.01 sec)

结果显示，学习 Java 课程的只有 Dany 和 Henry。上述查询过程也可以分为以下 2 步执行，实现效果是相同的。
首先单独执行内查询，查询出 course 表中课程为 Java 的 id，SQL 语句和运行结果如下:

mysql> SELECT id FROM course 
    -> WHERE course_name = 'Java';
+----+
| id |
+----+
|  1 |
+----+
1 row in set (0.00 sec)

可以看到，符合条件的 id 字段的值为 1。
然后执行外层查询，在 students_info 表中查询 course_id 等于 1 的学生姓名。SQL 语句和运行结果如下:

mysql> SELECT name FROM students_info 
    -> WHERE course_id IN (1);
+-------+
| name  |
+-------+
| Dany  |
| Henry |
+-------+
2 rows in set (0.00 sec)

习惯上，外层的 SELECT 查询称为父查询，圆括号中嵌入的查询称为子查询（子查询必须放在圆括号内）。MySQL 在处理上例的 SELECT 语句时，执行流程为：先执行子查询，再执行父查询。
例 2
与例 1 类似，在 SELECT 语句中使用 NOT IN 关键字，查询没有学习 Java 课程的学生姓名，SQL 语句和运行结果如下:

mysql> SELECT name FROM students_info 
    -> WHERE course_id NOT IN (SELECT id FROM course WHERE course_name = 'Java');
+--------+
| name   |
+--------+
| Green  |
| Jane   |
| Jim    |
| John   |
| Lily   |
| Susan  |
| Thomas |
| Tom    |
| LiMing |
+--------+
9 rows in set (0.01 sec)

可以看出，运行结果与上面的例子刚好相反，没有学习 Java 课程的是除了 Dany 和 Henry 之外的学生。
例 3
使用=运算符，在 course 表和 students_info 表中查询出所有学习 Python 课程的学生姓名，SQL 语句和运行结果如下：

mysql> SELECT name FROM students_info
    -> WHERE course_id = (SELECT id FROM course WHERE course_name = 'Python');
+------+
| name |
+------+
| Jane |
+------+
1 row in set (0.00 sec)

结果显示，学习 Python 课程的学生只有 Jane。
例 4
使用<>运算符，在 course 表和 students_info 表中查询出没有学习 Python 课程的学生姓名，SQL 语句和运行结果如下:

mysql> SELECT name FROM students_info
    -> WHERE course_id <> (SELECT id FROM course WHERE course_name = 'Python');
+--------+
| name   |
+--------+
| Dany   |
| Green  |
| Henry  |
| Jim    |
| John   |
| Lily   |
| Susan  |
| Thomas |
| Tom    |
| LiMing |
+--------+
10 rows in set (0.00 sec)

可以看出，运行结果与例 3 刚好相反，没有学习 Python 课程的是除了 Jane 之外的学生。
例 5
查询 course 表中是否存在 id=1 的课程，如果存在，就查询出 students_info 表中的记录，SQL 语句和运行结果如下：

mysql> SELECT * FROM students_info
    -> WHERE EXISTS(SELECT course_name FROM course WHERE id=1);
+----+--------+------+------+--------+-----------+
| id | name   | age  | sex  | height | course_id |
+----+--------+------+------+--------+-----------+
|  1 | Dany   |   25 | 男   |    160 |         1 |
|  2 | Green  |   23 | 男   |    158 |         2 |
|  3 | Henry  |   23 | 女   |    185 |         1 |
|  4 | Jane   |   22 | 男   |    162 |         3 |
|  5 | Jim    |   24 | 女   |    175 |         2 |
|  6 | John   |   21 | 女   |    172 |         4 |
|  7 | Lily   |   22 | 男   |    165 |         4 |
|  8 | Susan  |   23 | 男   |    170 |         5 |
|  9 | Thomas |   22 | 女   |    178 |         5 |
| 10 | Tom    |   23 | 女   |    165 |         5 |
| 11 | LiMing |   22 | 男   |    180 |         7 |
+----+--------+------+------+--------+-----------+
11 rows in set (0.01 sec)

由结果可以看到，course 表中存在 id=1 的记录，因此 EXISTS 表达式返回 TRUE，外层查询语句接收 TRUE 之后对表 students_info 进行查询，返回所有的记录。

EXISTS 关键字可以和其它查询条件一起使用，条件表达式与 EXISTS 关键字之间用 AND 和 OR 连接。
例 6
查询 course 表中是否存在 id=1 的课程，如果存在，就查询出 students_info 表中 age 字段大于 24 的记录，SQL 语句和运行结果如下:

mysql> SELECT * FROM students_info
    -> WHERE age>24 AND EXISTS(SELECT course_name FROM course WHERE id=1);
+----+------+------+------+--------+-----------+
| id | name | age  | sex  | height | course_id |
+----+------+------+------+--------+-----------+
|  1 | Dany |   25 | 男   |    160 |         1 |
+----+------+------+------+--------+-----------+
1 row in set (0.01 sec)

结果显示，从 students_info 表中查询出了一条记录，这条记录的 age 字段取值为 25。内层查询语句从 course 表中查询到记录，返回 TRUE。外层查询语句开始进行查询。根据查询条件，从 students_info 表中查询 age 大于 24 的记录。

子查询的功能也可以通过表连接完成，但是子查询会使 SQL 语句更容易阅读和编写。

一般来说，表连接（内连接和外连接等）都可以用子查询替换，但反过来却不一定，有的子查询不能用表连接来替换。子查询比较灵活、方便、形式多样，适合作为查询的筛选条件，而表连接更适合于查看连接表的数据。

weixin_46447154
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多表连接查询详解
gezishan007的博客
11-18 7230
多表连接查询详解
MySql多表联查
qq_40766118的博客
10-24 1万+
多表联查 使用多表联查的场景，有些时候数据在不同的表中，这个时候我们就需要用到mysql中的多表联查。 多表联查概念 将两个或两个以上的表按某个条件连接起来，从而选取需要的数据。多表联查是同时查询两个或两个以上的表时使用的。 多表联查分类 内连接查询 内连接查询使用关键字join或cross join 或 inner join,  然后
多表连接查询详细解析(详细版)
weixin_43850781的博客
08-12 1万+
前言：写SQL语句：(先找出表的数据)找哪2个表，什么字段，过滤条件。(最后思考过滤条件,过滤条件肯定是2张表都有关联的字段，不一定是同名的字段，思考：表1哪个字段和表2哪个字段有关联) 1.为什么要多张表，因为设计成一张表会造成数据冗余，浪费存储空间。 2.连接查询的分类 根据语法出现的年代来划分： SQL92(一些老的DBA可能还在使用这种语法。DBA：DataBase Administrator,数据库管理员) SQL99(比较新的语法) 根据表的连接方式来划分： 内连接： 等值连接 非等值连接 自
数据库多表链接查询的方式
Ran小Ran的博客
05-18 1万+
大家好，在日常学习中分享一下所学的笔记，希望可以帮助到大家~ 多表联查的分类大致分为以下四类： 1. 通过Select子句进行查询 2. 通过内连接 inner join进行查询 3. 通过外连接left join，left outer join，right join，right outer join，union进行查询 4. 通过子查询（嵌套查询）进行查询 一、通过SELECT子句进行多表查询 语法： Select 字段名 from 表1，表2 … where 表1...
多表联合查询
wangshuai0703的博客
02-05 917
多表联合查询
数据库语法总结（3）——多表联查
m0_61746796的博客
04-04 5435
数据库语法总结（3)
易语言ACCESS数据库多表关联查询例程
08-15
ACCESS数据库多表关联查询例程 系统结构:易语言ACCESS数据库多表关联查询例程源码,ACCESS数据库多表关联查询例程 ======窗口程序集1 | | | |------ _按钮1_被单击 | | | |------ _按钮2_被单击 | |
ThinkPHP多表联合查询的常用方法
10-25
主要介绍了ThinkPHP多表联合查询的常用方法,对于项目开发非常重要！需要的朋友可以参考下
Yii2.0框架模型多表关联查询示例
10-16
主要介绍了Yii2.0框架模型多表关联查询,结合实例形式总结分析了Yii2.0框架多表关联查询相关操作技巧,需要的朋友可以参考下
mysql多表联合查询操作实例分析
09-09
MySQL的多表联合查询是数据库操作中非常重要的一个概念，特别是在处理复杂的数据关系时，能够有效地从多个表中提取所需信息。本篇文章将深入探讨这一主题，通过实例分析来阐述其语法、功能以及操作技巧。 首先，让...
MySQL联合查询（多表查询）
热门推荐
weixin_48891146的博客
03-02 3万+
1、内连接 select *from 表1 [ inner | cross ] join 表2 [ on过滤条件 ] [ where查询条件 ] ； [ inner | cross ]: join 内连接关键字(必须要有)； on从语法上可省略，但如果省略它，将查询的是多表的笛卡尔积； 1.select *from 表1 join 表2 [ on过滤条件 ] [ where查询条件 ] ； 2.select *from 表1，表2 [ where查询条件 ] ； 3.select *fro
Mybatis(四)——多表级联查询
三毛村滴雪鱼粉的博客
08-03 1154
MyBatis多表级联查询
MySQL多表联合查询
weixin_53388991的博客
07-27 4398
多表联合查询就是同时查询两个或两个以上的表。在MySQL中，多表联合查询主要有交叉连接、内连接、外连接、分组查询与子查询等5种。
mysql 联合查询
m0_62377363的博客
06-30 2002
什么是多表联合查询 前面所讲的查询语句都是针对一个表的，但是在关系型数据库中，表与表之间是有联系的，所以在实际应用中，经常使用多表查询。多表查询就是同时查询两个或两个以上的表。 在 MySQL 中，多表查询主要有交叉连接、内连接、外连接、分组查询与子查询等5种。交叉连接(CROSS JOIN) 3.2.1 笛卡尔积 集合 A×B 和 B×A 的结果集分别表示为： 以上 A×B 和 B×A 的结果就叫做两个集合的笛卡尔积。并且，从以上结果我们可以看出3.2.2 交叉连接 交叉连接的语法格式如下： 或 语法说明
【MySQL数据库】——多表联查
Kangadd的博客
05-18 4096
多表联查可以通过连接运算实现，即将多张表通过主外键关系关联在一起进行查询 一、内联查询 1.等值查询（也被称为笛卡尔积） 语法：select 查询的字段 from 表1,表2 where 条件1,条件2... 这种查询方式会拿到所有符合条件的值，虽然简单暴力，但无法应用于复杂场景。 2.inner join 语法：select 查询的字段 from 表1 inner join 表2 on 条件 这种查询方式拿到的结果如图： 二、外联查询 1.left join（左外联查询） 语法
图解数据库多表查询（多表联查）的几种方式
weixin_44901808的博客
08-08 7288
多表查询
多表查询
zby2018的博客
12-31 1090
多表查询 1、认识多表查询 多表查询指的就是同时从多张数据表中取出数据并且显示的一种操作。 SQL语句的格式： 【③选出所需要的数据列】SELECT [DISTINCT] * | 列 [别名]，列 [别名]，列 [别名]… 【①确定数据来源】FROM 表名称 [别名] , 表名称 [别名]… 【②筛选数据行】WHERE 限定条件（s）； 【④数据排序】ORDER BY 排序字段[ASC | ...
史上最牛mysql-06 (多表连接)
小北呱的博客
12-06 3476
多表连接 个人博客 ：www.xiaobeigua.icu 多表查询，也称为关联查询，指两个或更多个表一起完成查询操作。 前提条件：这些一起查询的表之间是有关系的（一对一、一对多），它们之间一定是有关联字段，这个关联字段可能建立了外键，也可能没有建立外键。比如：员工表和部门表，这两个表依靠“部门编号”进行关联。 1. 一个案例引发的多表连接 1.1 案例说明 从多个表中获取数据： #案例：查询员工的姓名及其部门名称 SELECT last_n
多表联合查询 连接查询
qq_35677589的博客
01-06 925
实际中不是单表进行查询而是多表进行联合查询，这时就要用到联合查询。 1、什么时连接查询 2、连接查询的分类 3、笛卡尔乘积现象 对表进行别名命名是为了当两个表的关键字相同时，能够正常进行搜索 4、内连接 上面的代码和下面的代码作用相同： 这里的on后面连接筛选的条件，join的作用是连接两个表，也就是说要在两个表里找，就要用join来将两个表都添加进来。 5、内连接之非等值连接 6、自连接 将一个表看成是两章一张表的一个字段是另一个表.
多表联合查询是什么意思
最新发布
06-02
多表联合查询是指在关系型数据库中，通过对多个表进行连接操作，从中查询出符合特定条件的数据。这种查询通常需要使用 SQL 语言中的 JOIN 操作符，将多个表按照特定的关联关系连接在一起，然后通过 WHERE 子句对数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值