二十七、MySQL JOIN 进行多表查询

二十七、MySQL JOIN 进行多表查询

前面我们学的都是单张表的操作，都比较简单，但数据往往是多张表组成的，往往需要从多张表中查找数据

这时候就会用到表连接，也就是两张或者多张表如何组成一张大表，然后从大表里查找数据

连表方式

我们假设两张表，A 表 和 B 表；

当我们把两张表和在一起的时候，有一种拼合法只取表头颜色一样的拼在一起，不一样的扔掉，我们称之为 内连接

还有一种拼接法就是把 A 表中的都留下来，然后从 B 中找对应的颜色粘合在一起，我们称之为 左连接

还有一种拼接法就是把 B 表中的都留下来，然后从 A 表里找对应的颜色粘合在一起,我们称之为 右连接

最后一种拼接法，就是 A 表中的都留下，然后从 B 表中找对应的颜色粘合在一起，剩下的那些 B 表中的则全部排在最后，并不扔掉，我们称之为 外链接

注意： 记住我刚刚说的查找过程，因为这是面试常考题目，就是先把一张表的记录查出来，然后根据记录一条一条去另一张表里找，这是不是很像我们堆积木游戏一样，表连接的本质过程也是这样，所以才导致了表连接很慢

如果有三张，四张，五张表也是同一个道理

这里有一点没演示到，就是如果任何一张表中有重复的表头颜色，那么也会重复显示一次

MySQL 中的连表

MySQL 支持上面四种连接中的前三种，第四种外连接不支持

可以在 SELECT, UPDATE 和 DELETE 语句中使用 MySQL 的 JOIN 来联合多表查询

连表方式名称说明
INNER JOIN内连接获取两个表中字段匹配关系的记录
LEFT JOIN左连接获取左表所有记录，即使右表没有对应匹配的记录
RIGHT JOIN右连接获取右表所有记录，即使左表没有对应匹配的记录

MySQL 中的 INNER JOIN 可以省略 INNER 关键字，也就是 JOIN == INNER JOIN

范例数据

可以在 mysql> 命令行中运行以下语句填充范例数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
DROP TABLE IF EXISTS `tbl_language`;
DROP TABLE IF EXISTS `tbl_rank`;

CREATE TABLE IF NOT EXISTS `tbl_language`(
   `id` INT UNSIGNED AUTO_INCREMENT,
   `name` VARCHAR(64) NOT NULL,
   `url` VARCHAR(128) NOT NULL,
   `founded_at` DATE,
   PRIMARY KEY ( `id` )
)ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE IF NOT EXISTS `tbl_rank`(
   `id` INT UNSIGNED AUTO_INCREMENT,
   `name` VARCHAR(64) NOT NULL,
   `month` VARCHAR(7) NOT NULL,
   `rank` TINYINT NOT NULL,
   `rate` VARCHAR(32) NOT NULL,
   PRIMARY KEY ( `id` )
)ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

INSERT INTO `tbl_language` VALUES
    (1,'Python','python','1991-2-20'),
    (2,'PHP','php','1994-1-1'),
    (3,'Ruby','ruby','1996-12-25'),
    (4,'Kotlin','kotlin','2016-02-17');

INSERT INTO `tbl_rank` VALUES
    (1, 'Python','2018-04',4,'5.083%'),
    (2, 'PHP','2018-04',6,'4.218%'),
    (3, 'Ruby','2018-04',11,'2.018%'),
    (4, 'Java','2018-04',1,'15.777%'),
    (5, 'Python','2018-03',4,'5.869%'),
    (6, 'PHP','2018-03',7,'4.010%'),
    (7, 'Ruby','2018-03',12,'2.744%'),
    (8, 'Java','2018-03',1,'14.941'),
    (9, 'Python','2018-02',4,'5.168%'),
    (10, 'PHP','2018-02',7,'3.420%'),
    (11, 'Ruby','2018-02',10,'2.534%'),
    (12, 'Java','2018-02',1,'14.988%');

tbl_language 表中的数据如下

1
2
3
4
5
6
7
8
+----+--------+----------------------------+------------+
| id | name   | url                        | founded_at |
+----+--------+----------------------------+------------+
|  1 | Python | python        				| 1991-02-20 |
|  2 | PHP    | php         				| 1994-01-01 |
|  3 | Ruby   | ruby 						| 1996-12-25 |
|  4 | Kotlin | kotlin     					| 2016-02-17 |
+----+--------+----------------------------+------------+

tbl_rank 表中的数据如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
+----+--------+---------+------+---------+
| id | name   | month   | rank | rate    |
+----+--------+---------+------+---------+
|  1 | Python | 2018-04 |    4 | 5.083%  |
|  2 | PHP    | 2018-04 |    6 | 4.218%  |
|  3 | Ruby   | 2018-04 |   11 | 2.018%  |
|  4 | Java   | 2018-04 |    1 | 15.777% |
|  5 | Python | 2018-03 |    4 | 5.869%  |
|  6 | PHP    | 2018-03 |    7 | 4.010%  |
|  7 | Ruby   | 2018-03 |   12 | 2.744%  |
|  8 | Java   | 2018-03 |    1 | 14.941  |
|  9 | Python | 2018-02 |    4 | 5.168%  |
| 10 | PHP    | 2018-02 |    7 | 3.420%  |
| 11 | Ruby   | 2018-02 |   10 | 2.534%  |
| 12 | Java   | 2018-02 |    1 | 14.988% |
+----+--------+---------+------+---------+

在命令提示符中使用 INNER JOIN

接下来我们在 mysql> 命令行中演示上面说到的 MySQL 支持的三种连表方式

我们把 tbl_language 当作 A 表，也就是左表，把 tbl_rank 当作 B 表也就是右表，而颜色就是两张表中相同的字段 name

INNER JOIN

下面的语句用于查找 tbl_language 和 tbl_rank 中 name 字段相同的所有记录

1
SELECT `tbl_language`.name,url,rate  FROM `tbl_language` INNER JOIN `tbl_rank` ON `tbl_language`.name = `tbl_rank`.name;

运行结果如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
MariaDB [test2]> SELECT `tbl_language`.name,url,rate  FROM `tbl_language` INNER JOIN `tbl_rank` ON `tbl_language`.name = `tbl_rank`.name;
+--------+----------------------------+--------+
| name   | url                        | rate   |
+--------+----------------------------+--------+
| Python | python        				| 5.083% |
| PHP    | php         					| 4.218% |
| Ruby   | ruby 						| 2.018% |
| Python | python        				| 5.869% |
| PHP    | php        					| 4.010% |
| Ruby   | ruby 						| 2.744% |
| Python | python        				| 5.168% |
| PHP    | php        					| 3.420% |
| Ruby   | ruby 						| 2.534% |
+--------+----------------------------+--------+
9 rows in set (0.00 sec)

为什么有 9 条记录而不是 3 条 ?

因为 tbl_rank 中有 9 条记录的 name 和 tbl_language 表中的相同，两者取最多的那个

1
SELECT `tbl_language`.name,url,rate  FROM `tbl_language` JOIN `tbl_rank` ON `tbl_language`.name = `tbl_rank`.name;

运行结果如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
MariaDB [test2]> SELECT `tbl_language`.name,url,rate  FROM `tbl_language` JOIN `tbl_rank` ON `tbl_language`.name = `tbl_rank`.name;
+--------+----------------------------+--------+
| name   | url                        | rate   |
+--------+----------------------------+--------+
| Python | python        				| 5.083% |
| PHP    | php        					 | 4.218% |
| Ruby   | ruby 						| 2.018% |
| Python | python        				| 5.869% |
| PHP    | php					         | 4.010% |
| Ruby   | ruby 						| 2.744% |
| Python | python       				| 5.168% |
| PHP    | php         					| 3.420% |
| Ruby   | ruby 						| 2.534% |
+--------+----------------------------+--------+
9 rows in set (0.00 sec)

还可以使用 WHERE 语句来代替 INNER JOIN，下面这条语句的执行结果和它们一样

1
SELECT `tbl_language`.name,url,rate  FROM `tbl_language`,`tbl_rank` WHERE `tbl_language`.name = `tbl_rank`.name;

运行结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
MariaDB [test2]> SELECT `tbl_language`.name,url,rate  FROM `tbl_language`,`tbl_rank` WHERE `tbl_language`.name = `tbl_rank`.name;
+--------+----------------------------+--------+
| name   | url                        | rate   |
+--------+----------------------------+--------+
| Python | python       			 | 5.083% |
| PHP    | php        				 | 4.218% |
| Ruby   | ruby						 | 2.018% |
| Python | python        			| 5.869% |
| PHP    |php        				 | 4.010% |
| Ruby   | ruby						 | 2.744% |
| Python | python			        | 5.168% |
| PHP    | php        				| 3.420% |
| Ruby   | ruby 					| 2.534% |
+--------+----------------------------+--------+
9 rows in set (0.00 sec)

MySQL LEFT JOIN

LEFT JOIN 会读取左边数据表的全部数据，即便右边表无对应数据

下面的语句会读取 tbl_language 中所有的记录，然后查找 tbl_rank 中的 name 记录一一对应，如果没找到则空，如果找到多条，则重复多次

1
SELECT `tbl_language`.name,url,rate  FROM `tbl_language` LEFT JOIN `tbl_rank` ON `tbl_language`.name = `tbl_rank`.name;

运行结果如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
MariaDB [test2]> SELECT `tbl_language`.name,url,rate  FROM `tbl_language` LEFT JOIN `tbl_rank` ON `tbl_language`.name = `tbl_rank`.name;
+--------+----------------------------+--------+
| name   | url                        | rate   |
+--------+----------------------------+--------+
| Python | python        				| 5.083% |
| PHP    | php        					 | 4.218% |
| Ruby   | ruby 					| 2.018% |
| Python | python       				 | 5.869% |
| PHP    | php         					| 4.010% |
| Ruby   | ruby 						| 2.744% |
| Python | python       				 | 5.168% |
| PHP    | php        					 | 3.420% |
| Ruby   | ruby							 | 2.534% |
| Kotlin | kotlin   					  | NULL   |
+--------+----------------------------+--------+

总共 10条记录 = INNER JOIN 的 9 条 + 左边多余的 1 条

MySQL RIGHT JOIN

RIGHT JOIN 会读取右边数据表的全部数据，即便左边边表无对应数据

下面的语句会读取 tbl_rank 中所有的记录，然后查找 tbl_language 中的 name 记录一一对应，如果没找到则空，如果找到多条，则重复多次

1
SELECT `tbl_language`.name,url,rate  FROM `tbl_language` RIGHT JOIN `tbl_rank` ON `tbl_language`.name = `tbl_rank`.name;

运行结果如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
MariaDB [test2]> SELECT `tbl_language`.name,url,rate  FROM `tbl_language` RIGHT JOIN `tbl_rank` ON `tbl_language`.name = `tbl_rank`.name;
+--------+----------------------------+---------+
| name   | url                        | rate    |
+--------+----------------------------+---------+
| Python | python       			 | 5.083%  |
| Python | python       			 | 5.869%  |
| Python | python       			 | 5.168%  |
| PHP    | php        				 | 4.218%  |
| PHP    | php       				  | 4.010%  |
| PHP    | php       				  | 3.420%  |
| Ruby   | ruby 						| 2.018%  |
| Ruby   | ruby						 | 2.744%  |
| Ruby   | ruby 						| 2.534%  |
| NULL   | NULL                       | 15.777% |
| NULL   | NULL                       | 14.941  |
| NULL   | NULL                       | 14.988% |
+--------+----------------------------+---------+

总计 12 条记录 = INNER JOIN 的 9 条 + tbl_rank 多出来的 3 条

在 PHP 脚本中使用 JOIN

在 PHP 脚本中使用 JOIN 和在 PHP 中使用 SELECT FROM 没有什么不同，因为 JOIN 本身就是 SELECT 中的一部分

PHP 可以使用 PDO::query() 函数来查询某个表中的数据

PDO::query() 函数原型

PDO::query() 有四个函数重载

1
2
3
4
5
6
7
PDOStatement PDO::query ( string $statement )

PDOStatement PDO::query ( string $statement , int $PDO::FETCH_COLUMN , int $colno )

PDOStatement PDO::query ( string $statement , int $PDO::FETCH_CLASS , string $classname , array $ctorargs )

PDOStatement PDO::query ( string $statement , int $PDO::FETCH_INTO , object $object )

如果成功，PDO::query() 返回 PDOStatement 对象，如果失败返回 FALSE

参数

参数说明
statement要被预处理和执行的 SQL 语句，查询中的数据应该被妥善地转义

第二个参数有以下几个可选值，默认为 PDO::FETCH_BOTH

值说明
PDO::FETCH_ASSOC返回一个索引为结果集列名的数组
PDO::FETCH_BOTH默认，返回一个索引为结果集列名和以0开始的列号的数组
PDO::FETCH_BOUND返回 TRUE ，并分配结果集中的列值给 PDOStatement::bindColumn() 方法绑定的 PHP 变量
PDO::FETCH_CLASS返回一个请求类的新实例，映射结果集中的列名到类中对应的属性名。如果 fetch_style 包含 PDO::FETCH_CLASSTYPE（例如：PDO::FETCH_CLASS |PDO::FETCH_CLASSTYPE），则类名由第一列的值决定
PDO::FETCH_INTO更新一个被请求类已存在的实例，映射结果集中的列到类中命名的属性
PDO::FETCH_LAZY结合使用 PDO::FETCH_BOTH 和 PDO::FETCH_OBJ，创建供用来访问的对象变量名
PDO::FETCH_NUM返回一个索引为以0开始的结果集列号的数组
PDO::FETCH_OBJ返回一个属性名对应结果集列名的匿名对象

我们使用默认的 PDO::FETCH_BOTH 获取所有数据，其它方式请移步我们的 PHP 基础教程

1
2
3
4
5
6
7
8
9
10
11
<?php 

$sql= "SELECT `tbl_language`.name,url,rate  FROM `tbl_language` INNER JOIN `tbl_rank` ON `tbl_language`.name = `tbl_rank`.name;";

$dbh = new PDO('mysql:host=127.0.0.1;dbname=test2', 'root', '');    
$stmt = $dbh->query($sql);

foreach($stmt as $row)
{
    var_dump($row);
}

输出结果如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
array(6) {
  ["name"]=>
  string(6) "Python"
  [0]=>
  string(6) "Python"
  ["url"]=>
  string(19) "python"
  [1]=>
  string(19) "python"
  ["rate"]=>
  string(6) "5.083%"
  [2]=>
  string(6) "5.083%"
}
array(6) {
  ["name"]=>
  string(3) "PHP"
  [0]=>
  string(3) "PHP"
  ["url"]=>
  string(18) "php"
  [1]=>
  string(18) "php"
  ["rate"]=>
  string(6) "4.218%"
  [2]=>
  string(6) "4.218%"
}
array(6) {
  ["name"]=>
  string(4) "Ruby"
  [0]=>
  string(4) "Ruby"
  ["url"]=>
  string(26) "ruby"
  [1]=>
  string(26) "ruby"
  ["rate"]=>
  string(6) "2.018%"
  [2]=>
  string(6) "2.018%"
}
array(6) {
  ["name"]=>
  string(6) "Python"
  [0]=>
  string(6) "Python"
  ["url"]=>
  string(19) "python"
  [1]=>
  string(19) "python"
  ["rate"]=>
  string(6) "5.869%"
  [2]=>
  string(6) "5.869%"
}
array(6) {
  ["name"]=>
  string(3) "PHP"
  [0]=>
  string(3) "PHP"
  ["url"]=>
  string(18) "php"
  [1]=>
  string(18) "php"
  ["rate"]=>
  string(6) "4.010%"
  [2]=>
  string(6) "4.010%"
}
array(6) {
  ["name"]=>
  string(4) "Ruby"
  [0]=>
  string(4) "Ruby"
  ["url"]=>
  string(26) "ruby"
  [1]=>
  string(26) "ruby"
  ["rate"]=>
  string(6) "2.744%"
  [2]=>
  string(6) "2.744%"
}
array(6) {
  ["name"]=>
  string(6) "Python"
  [0]=>
  string(6) "Python"
  ["url"]=>
  string(19) "python"
  [1]=>
  string(19) "python"
  ["rate"]=>
  string(6) "5.168%"
  [2]=>
  string(6) "5.168%"
}
array(6) {
  ["name"]=>
  string(3) "PHP"
  [0]=>
  string(3) "PHP"
  ["url"]=>
  string(18) "php"
  [1]=>
  string(18) "php"
  ["rate"]=>
  string(6) "3.420%"
  [2]=>
  string(6) "3.420%"
}
array(6) {
  ["name"]=>
  string(4) "Ruby"
  [0]=>
  string(4) "Ruby"
  ["url"]=>
  string(26) "ruby"
  [1]=>
  string(26) "ruby"
  ["rate"]=>
  string(6) "2.534%"
  [2]=>
  string(6) "2.534%"
}