让我们考虑一下这些表格:

A

id | SomeData

B

id | id_A | SomeOtherData

id_A是表a的外键

写这个查询:

SELECT *
FROM A
LEFT JOIN B
ON A.id = B.id_A;

将提供如下结果:

/ : part of the result
                                       B
                      +---------------------------------+
            A         |                                 |
+---------------------+-------+                         |
|/////////////////////|///////|                         |
|/////////////////////|///////|                         |
|/////////////////////|///////|                         |
|/////////////////////|///////|                         |
|/////////////////////+-------+-------------------------+
|/////////////////////////////|
+-----------------------------+

A中有而B中没有的东西意味着B中有空值。

现在，让我们考虑B.id_A中的一个特定部分，并从前面的结果中突出显示它:

/ : part of the result
* : part of the result with the specific B.id_A
                                       B
                      +---------------------------------+
            A         |                                 |
+---------------------+-------+                         |
|/////////////////////|///////|                         |
|/////////////////////|///////|                         |
|/////////////////////+---+///|                         |
|/////////////////////|***|///|                         |
|/////////////////////+---+---+-------------------------+
|/////////////////////////////|
+-----------------------------+

写这个查询:

SELECT *
FROM A
LEFT JOIN B
ON A.id = B.id_A
AND B.id_A = SpecificPart;

将提供如下结果:

/ : part of the result
* : part of the result with the specific B.id_A
                                       B
                      +---------------------------------+
            A         |                                 |
+---------------------+-------+                         |
|/////////////////////|       |                         |
|/////////////////////|       |                         |
|/////////////////////+---+   |                         |
|/////////////////////|***|   |                         |
|/////////////////////+---+---+-------------------------+
|/////////////////////////////|
+-----------------------------+

因为这将在内部连接中删除不在B.id_A = SpecificPart中的值

现在，让我们把查询改为这样:

SELECT *
FROM A
LEFT JOIN B
ON A.id = B.id_A
WHERE B.id_A = SpecificPart;

结果是:

/ : part of the result
* : part of the result with the specific B.id_A
                                       B
                      +---------------------------------+
            A         |                                 |
+---------------------+-------+                         |
|                     |       |                         |
|                     |       |                         |
|                     +---+   |                         |
|                     |***|   |                         |
|                     +---+---+-------------------------+
|                             |
+-----------------------------+

因为整个结果是根据B. id_a = SpecificPart过滤的，删除了B. id_a为NULL的部分，这些部分在A中，但不在B中

这就是我的解。

SELECT song_ID,songs.fullname, singers.fullname
FROM music JOIN songs ON songs.ID = music.song_ID  
JOIN singers ON singers.ID = music.singer_ID
GROUP BY songs.fullname

你必须有GROUP BY才能让它工作。

希望这对你有所帮助。

当涉及到左连接时，where子句和on子句之间有很大的区别。

这里有一个例子:

mysql> desc t1; 
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | NO   |     | NULL    |       |
| fid   | int(11)     | NO   |     | NULL    |       |
| v     | varchar(20) | NO   |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+

fid是表t2的id。

mysql> desc t2;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | NO   |     | NULL    |       |
| v     | varchar(10) | NO   |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

查询“on子句”:

mysql> SELECT * FROM `t1` left join t2 on fid = t2.id AND t1.v = 'K' 
    -> ;
+----+-----+---+------+------+
| id | fid | v | id   | v    |
+----+-----+---+------+------+
|  1 |   1 | H | NULL | NULL |
|  2 |   1 | B | NULL | NULL |
|  3 |   2 | H | NULL | NULL |
|  4 |   7 | K | NULL | NULL |
|  5 |   5 | L | NULL | NULL |
+----+-----+---+------+------+
5 rows in set (0.00 sec)

where子句查询:

mysql> SELECT * FROM `t1` left join t2 on fid = t2.id where t1.v = 'K';
+----+-----+---+------+------+
| id | fid | v | id   | v    |
+----+-----+---+------+------+
|  4 |   7 | K | NULL | NULL |
+----+-----+---+------+------+
1 row in set (0.00 sec)

很明显， 第一个查询从t1返回一条记录，从t2返回与t1相关的行(如果有的话)。v = 'K'。

第二个查询返回来自t1的行，但只针对t1。v = 'K'将有任何与它相关的行。

从字面上看，它们是等价的。

在大多数开源数据库(最著名的例子是MySql和postgresql)中，查询计划是出现在关系数据库管理系统中的访问路径选择(Selinger et al, 1979)中的经典算法的变体。在这种方法中，条件有两种类型

引用单个表的条件(用于筛选) 引用两个表的条件(不管它们出现在哪里，都被视为连接条件)

特别是在MySql中，通过跟踪优化器，您可以看到自己的join ..On条件在解析过程中被等价的where条件替换。类似的事情也发生在postgresql中(虽然没有办法通过日志看到它，你必须阅读源代码描述)。

无论如何，主要的一点是，这两种语法变体之间的差异在解析/查询-重写阶段就消失了，甚至没有达到查询计划和执行阶段。因此，就性能而言，它们是否相同是毫无疑问的，它们在进入执行阶段之前就已经完全相同了。

你可以用explain来验证他们的计划是否相同。例如，在postgres中，计划将包含一个join子句，即使你没有在语法中使用join..on。

Oracle和SQL server不是开源的，但是，据我所知，它们基于等价规则(类似于关系代数中的规则)，并且它们在这两种情况下也产生相同的执行计划。

显然，对于外部连接，这两种语法风格是不相等的，对于那些你必须使用join…在语法

a. WHERE子句:加入后，记录将被过滤。

b. ON子句-在加入之前，记录(来自右边表格)将被过滤。

您正在尝试连接数据还是过滤数据?

为了可读性，将这些用例分别隔离到ON和WHERE是最有意义的。

在ON中联接数据 在WHERE中过滤数据

如果where子句中存在JOIN条件和过滤条件，那么读取查询将变得非常困难。

性能方面，你应该看不到区别，尽管不同类型的SQL有时处理查询计划的方式不同，所以值得尝试¯\_()_/¯(注意缓存会影响查询速度)

另外，正如其他人注意到的那样，如果使用外部连接，如果将筛选条件放在ON子句中，则会得到不同的结果，因为它只影响其中一个表。

我在这里写了一篇更深入的文章: https://dataschool.com/learn/difference-between-where-and-on-in-sql