关于 MySQL LEFT JOIN 你可能需要了解的三点

最新推荐文章于 2024-04-16 22:28:22 发布
转载 最新推荐文章于 2024-04-16 22:28:22 发布 · 60 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/zjfjava/p/6041445.html
文章标签：

#数据库 #c/c++

本文详细解析MySQL中LEFT JOIN的工作原理，对比ON与WHERE子句的区别，并通过具体示例阐述了如何正确使用LEFT JOIN及WHERE...ISNULL进行数据检索。

即使你认为自己已对 MySQL 的 LEFT JOIN 理解深刻，但我敢打赌，这篇文章肯定能让你学会点东西！

  • ON 子句与 WHERE 子句的不同
  • 一种更好地理解带有 WHERE ... IS NULL 子句的复杂匹配条件的简单方法 
  • Matching-Conditions 与 Where-conditions 的不同

关于 “A LEFT JOIN B ON 条件表达式” 的一点提醒

ON 条件（“A LEFT JOIN B ON 条件表达式”中的ON）用来决定如何从 B 表中检索数据行。

如果 B 表中没有任何一行数据匹配 ON 的条件,将会额外生成一行所有列为 NULL 的数据

在匹配阶段 WHERE 子句的条件都不会被使用。仅在匹配阶段完成以后，WHERE 子句条件才会被使用。它将从匹配阶段产生的数据中检索过滤。

让我们看一个 LFET JOIN 示例：

?
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
mysql> CREATE TABLE `product` (
   `id` int (10) unsigned NOT NULL auto_increment,
   `amount` int (10) unsigned default NULL ,
   PRIMARY KEY  (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=latin1
  
mysql> CREATE TABLE `product_details` (
   `id` int (10) unsigned NOT NULL ,
   `weight` int (10) unsigned default NULL ,
   `exist` int (10) unsigned default NULL ,
   PRIMARY KEY  (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1
  
mysql> INSERT INTO product (id,amount)
        VALUES (1,100),(2,200),(3,300),(4,400);
Query OK, 4 rows affected (0.00 sec)
Records: 4  Duplicates: 0  Warnings: 0
  
mysql> INSERT INTO product_details (id,weight,exist)
        VALUES (2,22,0),(4,44,1),(5,55,0),(6,66,1);
Query OK, 4 rows affected (0.00 sec)
Records: 4  Duplicates: 0  Warnings: 0
  
mysql> SELECT * FROM product;
+ ----+--------+
| id | amount |
+ ----+--------+
|  1 |    100 |
|  2 |    200 |
|  3 |    300 |
|  4 |    400 |
+ ----+--------+
4 rows in set (0.00 sec)
  
mysql> SELECT * FROM product_details;
+ ----+--------+-------+
| id | weight | exist |
+ ----+--------+-------+
|  2 |     22 |     0 |
|  4 |     44 |     1 |
|  5 |     55 |     0 |
|  6 |     66 |     1 |
+ ----+--------+-------+
4 rows in set (0.00 sec)
  
mysql> SELECT * FROM product LEFT JOIN product_details
        ON (product.id = product_details.id);
+ ----+--------+------+--------+-------+
| id | amount | id   | weight | exist |
+ ----+--------+------+--------+-------+
|  1 |    100 | NULL |   NULL |  NULL |
|  2 |    200 |    2 |     22 |     0 |
|  3 |    300 | NULL |   NULL |  NULL |
|  4 |    400 |    4 |     44 |     1 |
+ ----+--------+------+--------+-------+
4 rows in set (0.00 sec)

ON 子句和 WHERE 子句有什么不同？

一个问题：下面两个查询的结果集有什么不同么？

?
1
2
3
4
5
6
1. SELECT * FROM product LEFT JOIN product_details
          ON (product.id = product_details.id)
          AND   product_details.id=2;
2. SELECT * FROM product LEFT JOIN product_details
          ON (product.id = product_details.id)
          WHERE product_details.id=2;

用例子来理解最好不过了：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
mysql> SELECT * FROM product LEFT JOIN product_details
        ON (product.id = product_details.id)
        AND product_details.id=2;
+ ----+--------+------+--------+-------+
| id | amount | id   | weight | exist |
+ ----+--------+------+--------+-------+
|  1 |    100 | NULL |   NULL |  NULL |
|  2 |    200 |    2 |     22 |     0 |
|  3 |    300 | NULL |   NULL |  NULL |
|  4 |    400 | NULL |   NULL |  NULL |
+ ----+--------+------+--------+-------+
4 rows in set (0.00 sec)
  
mysql> SELECT * FROM product LEFT JOIN product_details
        ON (product.id = product_details.id)
        WHERE product_details.id=2;
+ ----+--------+----+--------+-------+
| id | amount | id | weight | exist |
+ ----+--------+----+--------+-------+
|  2 |    200 |  2 |     22 |     0 |
+ ----+--------+----+--------+-------+
1 row in set (0.01 sec)

第一条查询使用 ON 条件决定了从 LEFT JOIN的 product_details表中检索符合的所有数据行。

第二条查询做了简单的LEFT JOIN，然后使用 WHERE 子句从 LEFT JOIN的数据中过滤掉不符合条件的数据行。

再来看一些示例：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
mysql>
mysql> SELECT * FROM product LEFT JOIN product_details
        ON product.id = product_details.id
        AND product.amount=100;
+ ----+--------+------+--------+-------+
| id | amount | id   | weight | exist |
+ ----+--------+------+--------+-------+
|  1 |    100 | NULL |   NULL |  NULL |
|  2 |    200 | NULL |   NULL |  NULL |
|  3 |    300 | NULL |   NULL |  NULL |
|  4 |    400 | NULL |   NULL |  NULL |
+ ----+--------+------+--------+-------+
4 rows in set (0.00 sec)

所有来自product表的数据行都被检索到了，但没有在product_details表中匹配到记录（product.id = product_details.id AND product.amount=100 条件并没有匹配到任何数据）

?
1
2
3
4
5
6
7
8
9
10
11
12
mysql> SELECT * FROM product LEFT JOIN product_details
        ON (product.id = product_details.id)
        AND product.amount=200;
+ ----+--------+------+--------+-------+
| id | amount | id   | weight | exist |
+ ----+--------+------+--------+-------+
|  1 |    100 | NULL |   NULL |  NULL |
|  2 |    200 |    2 |     22 |     0 |
|  3 |    300 | NULL |   NULL |  NULL |
|  4 |    400 | NULL |   NULL |  NULL |
+ ----+--------+------+--------+-------+
4 rows in set (0.01 sec)

同样，所有来自product表的数据行都被检索到了，有一条数据匹配到了。

使用 WHERE ... IS NULL 子句的 LEFT JOIN

当你使用 WHERE ... IS NULL 子句时会发生什么呢？

如前所述，WHERE 条件查询发生在 匹配阶段之后，这意味着 WHERE ... IS NULL 子句将从匹配阶段后的数据中过滤掉不满足匹配条件的数据行。

纸面上看起来很清楚，但是当你在 ON 子句中使用多个条件时就会感到困惑了。

我总结了一种简单的方式来理解上述情况：

  • 将 IS NULL 作为否定匹配条件
  • 使用 !(A and B) == !A OR !B 逻辑判断

看看下面的示例：

?
1
2
3
4
5
6
7
8
9
10
11
mysql> SELECT a.* FROM product a LEFT JOIN product_details b
        ON a.id=b.id AND b.weight!=44 AND b.exist=0
        WHERE b.id IS NULL ;
+ ----+--------+
| id | amount |
+ ----+--------+
|  1 |    100 |
|  3 |    300 |
|  4 |    400 |
+ ----+--------+
3 rows in set (0.00 sec)

让我们检查一下 ON 匹配子句：

?
1
(a.id=b.id) AND (b.weight!=44) AND (b.exist=0)

我们可以把 IS NULL 子句 看作是否定匹配条件。

这意味着我们将检索到以下行：

?
1
2
3
!( exist(b.id that equals to a.id) AND b.weight !=44 AND b.exist=0 )
!exist(b.id that equals to a.id) || !(b.weight !=44) || !(b.exist=0)
!exist(b.id that equals to a.id) || b.weight =44 || b.exist=1

就像在C语言中的逻辑 AND 和 逻辑 OR表达式一样，其操作数是从左到右求值的。如果第一个参数做够判断操作结果，那么第二个参数便不会被计算求值（短路效果）

看看别的示例：

?
1
2
3
4
5
6
7
8
9
10
11
12
mysql> SELECT a.* FROM product a LEFT JOIN product_details b
        ON a.id=b.id AND b.weight!=44 AND b.exist=1
        WHERE b.id IS NULL ;
+ ----+--------+
| id | amount |
+ ----+--------+
|  1 |    100 |
|  2 |    200 |
|  3 |    300 |
|  4 |    400 |
+ ----+--------+
4 rows in set (0.00 sec)

Matching-Conditions 与 Where-conditions 之战

如果你吧基本的查询条件放在 ON 子句中，把剩下的否定条件放在 WHERE 子句中，那么你会获得相同的结果。

例如，你可以不这样写：

?
1
2
3
SELECT a.* FROM product a LEFT JOIN product_details b
ON a.id=b.id AND b.weight!=44 AND b.exist=0
WHERE b.id IS NULL ;

你可以这样写：

?
1
2
3
SELECT a.* FROM product a LEFT JOIN product_details b
ON a.id=b.id
WHERE b.id is null OR b.weight=44 OR b.exist=1;

 

?
1
2
3
4
5
6
7
8
9
10
11
mysql> SELECT a.* FROM product a LEFT JOIN product_details b
        ON a.id=b.id
        WHERE b.id is null OR b.weight=44 OR b.exist=1;
+ ----+--------+
| id | amount |
+ ----+--------+
|  1 |    100 |
|  3 |    300 |
|  4 |    400 |
+ ----+--------+
3 rows in set (0.00 sec)

你可以不这样写：

?
1
2
3
SELECT a.* FROM product a LEFT JOIN product_details b
ON a.id=b.id AND b.weight!=44 AND b.exist!=0
WHERE b.id IS NULL ;

可以这样写：

?
1
2
3
SELECT a.* FROM product a LEFT JOIN product_details b
ON a.id=b.id
WHERE b.id is null OR b.weight=44 OR b.exist=0;

 

?
1
2
3
4
5
6
7
8
9
10
11
12
mysql> SELECT a.* FROM product a LEFT JOIN product_details b
        ON a.id=b.id
        WHERE b.id is null OR b.weight=44 OR b.exist=0;
+ ----+--------+
| id | amount |
+ ----+--------+
|  1 |    100 |
|  2 |    200 |
|  3 |    300 |
|  4 |    400 |
+ ----+--------+
4 rows in set (0.00 sec)

这些查询真的效果一样？

如果你只需要第一个表中的数据的话，这些查询会返回相同的结果集。有一种情况就是，如果你从 LEFT JOIN的表中检索数据时，查询的结果就不同了。

如前所属，WHERE 子句是在匹配阶段之后用来过滤的。

例如：

?
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
mysql> SELECT * FROM product a LEFT JOIN product_details b
        ON a.id=b.id AND b.weight!=44 AND b.exist=1
        WHERE b.id is null ;
+ ----+--------+------+--------+-------+
| id | amount | id   | weight | exist |
+ ----+--------+------+--------+-------+
|  1 |    100 | NULL |   NULL |  NULL |
|  2 |    200 | NULL |   NULL |  NULL |
|  3 |    300 | NULL |   NULL |  NULL |
|  4 |    400 | NULL |   NULL |  NULL |
+ ----+--------+------+--------+-------+
4 rows in set (0.00 sec)
  
mysql> SELECT * FROM product a LEFT JOIN product_details b
        ON a.id=b.id
        WHERE b.id IS NULL OR b.weight=44 OR b.exist=0;
+ ----+--------+------+--------+-------+
| id | amount | id   | weight | exist |
+ ----+--------+------+--------+-------+
|  1 |    100 | NULL |   NULL |  NULL |
|  2 |    200 |    2 |     22 |     0 |
|  3 |    300 | NULL |   NULL |  NULL |
|  4 |    400 |    4 |     44 |     1 |
+ ----+--------+------+--------+-------+
4 rows in set (0.00 sec)

总附注：

如果你使用 LEFT JOIN 来寻找在一些表中不存在的记录，你需要做下面的测试：WHERE 部分的 col_name IS NULL(其中 col_name 列被定义为 NOT NULL)，MYSQL 在查询到一条匹配 LEFT JOIN 条件后将停止搜索更多行（在一个特定的组合键下）。

 

From：http://www.oschina.net/question/89964_65912

转载于:https://www.cnblogs.com/zjfjava/p/6041445.html

关注
mysql join语法解析
yonggeit的博客
06-01 632
一．Join语法概述 join 用于多表中字段之间的联系，语法如下： ... FROM table1 INNER|LEFT|RIGHT JOIN table2 ON conditiona table1:左表；table2:右表。 JOIN 按照功能大致分为如下三类： INNER JOIN（内连接,或等值连接）：取得两个表中存在连接匹配关系的记录。 LEFT JOIN
flink实战--双流join之原理解析
阿华田的博客
03-26 9240
JOIN简介 谈flink双流JOIN之前，我们先谈一下大家最熟悉的mysql表join，我们知道表join有如下几种，具体区别就不在介绍了。那么流的join和表的join有什么区别呢？本文我们介绍一下。 CROSS JOIN - 交叉连接，计算笛卡儿积； INNER JOIN - 内连接，返回满足条件的记录； OUTER JOIN LEFT - 返回左表所有行，右表不存...
Java面试基础篇
m0_67392010的博客
07-29 4120
先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。Java的强引用、弱引用、软引用、虚引用。Java语言基础常识。Java12新特性。JavaIO详解。...
MySQL 多表关联一对多查询实现取最新一条数据的方法示例
01-19
本文实例讲述了MySQL 多表关联一对多查询实现取最新一条数据的方法。分享给大家供大家参考，具体如下： MySQL 多表关联一对多查询取最新的一条数据 遇到的问题 多表关联一对多查询取最新的一条数据，数据出现重复 由于历史原因，表结构设计不合理；产品告诉我说需要导出客户信息数据，需要导出客户的 所属行业，纳税性质 数据；但是这两个字段却在订单表里面，每次客户下单都会要求客户填写；由此可知，客户数据和订单数据是一对多的关系；那这样的话，问题就来了，我到底以订单中的哪一条数据为准呢？经过协商后一致同意以最新的一条数据为准； 数据测试初始化SQL脚本 DROP TABLE IF EXIST
全网都在说一个错误的结论
weixin_57907028的博客
10-13 3234
前文我将 product_no 字段设置为了索引，这种二级索引只有一个字段。如果将多个字段组合成一个索引，那么这种二级索引就被称为联合索引。联合索引 ``(product_no, name)` 的 B+Tree 示意图如下：可以看到，联合索引的非叶子节点用两个字段的值作为 B+Tree 的索引值。**联合索引的 B+Tree 是先按 product_no 进行排序，然后再 product_no 相同的情况再按 name 字段排序。**记住这句话，很重要！
sql(join中on与where区别)
hoken的专栏
04-20 2790
left join :左连接，返回左表中所有的记录以及右表中连接字段相等的记录。 right join :右连接，返回右表中所有的记录以及左表中连接字段相等的记录。 inner join: 内连接，又叫等值连接，只返回两个表中连接字段相等的行。 full join:外连接，返回两个表中的行：left join + right join。 cross join:结果是笛卡尔积
flink双流JOIN原理
野狼e族 的博客
02-02 1129
JOIN简介 谈flink双流JOIN之前，我们先谈一下大家最熟悉的mysql表join，我们知道表join有如下几种，具体区别就不在介绍了。那么流的join和表的join有什么区别呢？本文我们介绍一下。 CROSS JOIN - 交叉连接，计算笛卡儿积； INNER JOIN - 内连接，返回满足条件的记录； OUTER JOIN LEFT - 返回左表所有行，右表不存在补NULL； RIGHT - 返回右表所有行，左边不存在补NULL； FULL -返回左表和右表的并集，不存在一边补...
08 SQL进阶 -- 集合运算 -- 表的连结（JOIN）
在科技的浪潮中，我们寻找着创新的火种，在代码的海洋里，我们编织着智慧的网。腾飞开源，就是这样一个由技术精英汇聚而成的博客平台，我们致力于分享在Java、Python、IoT和人工智能等领域的最新研究成果和实战经验。 在腾飞开源的博客上，你会看到紧跟技术前
04-16 1388
前一节我们学习了 UNION和INTERSECT 等集合运算, 这些集合运算的特征就是以行方向为单位进行操作. 通俗地说, 就是进行这些集合运算时, 会导致记录行数的增减。使用 UNION 会增加记录行数,而使用 INTERSECT 或者 EXCEPT 会减少记录行数。但这些运算不能改变列的变化, 虽然使用函数或者 CASE表达式等列运算, 可以增加列的数量, 但仍然只能从一张表中提供的基础信息列中获得一些"引申列", 本质上并不能提供更多的信息。
MySQL百万数据优化总结 一
segegefe的博客
07-30 2204
为什么使用unionall因为union操作会对结果去重且排序，所以从速度来说，unionall会更胜一筹。
mysql join和where_MySql join on 和 where
weixin_39595537的博客
01-27 279
left join :左连接，返回左表中所有的记录以及右表中连接字段相等的记录。right join :右连接，返回右表中所有的记录以及左表中连接字段相等的记录。inner join: 内连接，又叫等值连接，只返回两个表中连接字段相等的行。full join:外连接，返回两个表中的行：left join + right join。cross join:结果是笛卡尔积，就是第一个表的行数乘以第二个表...
mysql中join后on、where的区别
sky198989的博客
05-20 280
转载：https://www.cnblogs.com/dashuai01/p/9040945.html
【MySQL知识点】MySQL中 left join 的on和where的差异
风暴计划
11-20 859
目录 1 建表 2 插入数据 3 测试 3.1左连接: A left join B on A.id=B.id, 返回记录数与A表记录数一致,无论A/B表是否能匹配上 3.2 左连接中, on条件与where条件过滤的差异 3.3使用 where... is null子句的 left join 【主旨：MySQL中 left join 的on和where的差异】 1 建表 drop table ASM_Product if exists; create table ASM_Pr...
mysql查询语句join、on、where执行顺序
lihongbao80的专栏
02-18 1万+
MySQL 的执行顺序 一、典型SELECT语句完整的执行顺序 1）from子句组装来自不同数据源的数据； 2）使用on进行join连接的数据筛选 3）where子句基于指定的条件对记录行进行筛选； 4）group by子句将数据划分为多个分组； 5）cube， rollup 6）使用聚集函数进行计算； 7）使用having子句筛选分组； 8）计算所有的表达式； 9）计算select的字段； 10）使用distinct 进行数据去重 11）使用order by对结果集进行排序。 12）选择TOPN的数据 二
什么？left join 的 on 条件失效了？查出了不符合条件的数据?
明明如月的技术博客
04-21 2764
最近发现很多人对 left join 的 on 条件的作用有误解，导致出现 Bug。 由于很多人都不太注意这问题，很容易造成故障。 下面我们简单复现这个问题，并解释为什么会这样，希望大家日常开发中万分小心。
Mysql的Join语句中On和Where条件的区别
smtctc的专栏
02-15 767
Mysql的Join语句中On和Where条件的区别 首先创建两张测试用表 create table t1 (id int not null,c1 int,primary key(id)) create table t2 like t1 插入如下的数据 t1 | id | c1 | | - | :-: | | 1 | 10 | | 2 | 20 | | 3 | 30 | t2 | id...
SQL语法——left join on 多条件
热门推荐
minixuezhen的博客
03-30 37万+
left join on +多条件与where区别 重点 先匹配，再筛选where条件。 本文将通过几个例子说明两者的差别。 表1：product id amount 1 100 2 200 3 300 4 400 表2：product_details id weight exist ...
mysql之left join、join的on、where区别看这篇就懂
weixin_44981707的博客
12-06 1万+
mysql之left join、join的on、where区别看这篇就懂 前言： 网上大量关于left join、join的on、where区别其实很多都是错误，本文开始揭晓其中区别所在，该如何使用。 1.准备 建表语句 CREATE TABLE `t_students` ( `id` int(11) NOT NULL AUTO_INCREMENT, `class_id` int(11) NOT NULL, `name` varchar(10) NOT NULL, `gender` char
Mysql--两表join时的on和where区别
修行的博客
11-11 1867
两表join时的on和where区别 表A join 表B----条件–on—> 临时表—where—> 结果表 on是作为临时表的筛选条件，where作为最终表的筛选条件 总结一： 1.where 是在两个表join完成后，再附上where条件; 2.and 则是在表连接前过滤A表或B表里面哪些记录符合连接条件，同时会兼顾是left join还是right join。即 假如是左连接的话，如果左边表的某条记录不符合连接条件，那么它不进行连接，但是仍然留在结果集中（此时右边部分的连接结果为NU
null值和null值能关联上吗
最新发布
07-09
<think>嗯，用户的问题是关于数据库中两个表的NULL值能否进行JOIN关联。这个问题很专业，涉及到SQL中NULL值的特殊性和JOIN操作的细节。 从用户提供的引用内容来看，引用[2]特别重要，它明确说明了标准SQL中NULL值的比较行为：在普通的等值JOIN中，NULL不会被匹配，因为NULL代表未知值，任何与NULL的比较都会返回UNKNOWN。但用户也提到Hive的扩展语法<=>，这个操作符可以处理NULL值之间的比较。 用户可能正在处理数据仓库或ETL任务，遇到了NULL值关联的问题。ta的困惑点在于：为什么明明两个表都有NULL，JOIN时却匹配不上？这在实际业务场景中很常见，比如处理客户数据时缺失的标识字段。 需要重点解释清楚三点： 第一，标准SQL的JOIN行为：on t1.id=t2.id 会自动排除NULL值，因为SQL的三值逻辑（TRUE/FALSE/UNKNOWN）导致NULL=NULL返回UNKNOWN而非TRUE。引用[2]的示例表数据展示得很清楚。 第二，解决方案的特殊语法：MySQL的<=>、Hive的<=>、Oracle的decode函数等。这里要强调不同数据库的差异，避免用户混淆。引用[2]的Hive示例可以直接作为代码示范。 第三，实际业务中的注意事项：NULL值关联是否合理？比如当NULL代表相同含义时（如都表示"未知客户"）才需要关联，否则可能造成数据污染。引用[3]提到的空值过滤技巧也值得提及。 用户的问题质量很高，说明ta已经遇到了实际案例。回答时要突出解决方案的实用性，比如直接给出可运行的SQL模板。考虑到ta可能使用不同数据库系统，需要明确标注语法差异。 最后生成的问题要引导用户深入思考：从性能影响（索引失效）到业务逻辑合理性（NULL是否应视为相同值），这都是高级开发者常遇到的痛点。</think>在SQL中，两个表的`NULL`值**默认无法通过普通JOIN关联匹配**，但可通过特殊语法实现关联。具体分析如下： --- ### 一、标准JOIN的NULL处理规则 1. **普通等值JOIN失效** 当使用`ON t1.column = t2.column`时： - `NULL = NULL` 返回`UNKNOWN`（非`TRUE`） - 结果：**自动排除所有含`NULL`的行**，包括两侧均为`NULL`的情况[^2][^3]。 ```sql -- 示例：普通JOIN无法关联NULL SELECT t1.id, t2.id FROM table1 t1 JOIN table2 t2 ON t1.id = t2.id; -- 结果：不返回任何包含NULL的行 ``` 2. **左右连接的NULL保留差异** - `LEFT JOIN`：保留左表所有行，右表不匹配时补`NULL` - `RIGHT JOIN`：保留右表所有行，左表不匹配时补`NULL`[^1] --- ### 二、强制关联NULL的解决方案 #### 方法1：使用`<=>`运算符（Hive/MySQL） ```sql -- 匹配NULL与NULL，同时处理非NULL等值 SELECT t1.id, t1.value, t2.id, t2.value FROM t1 JOIN t2 ON t1.id <=> t2.id; -- Hive/MySQL语法 ``` **结果**： | t1.id | t1.value | t2.id | t2.value | |-------|----------|-------|----------| | 1 | v1 | 1 | v2 | | NULL | v2 | NULL | v3 | [^2] #### 方法2：显式处理NULL（通用SQL） ```sql SELECT t1.id, t1.value, t2.id, t2.value FROM t1 JOIN t2 ON (t1.id = t2.id) -- 匹配非NULL值 OR (t1.id IS NULL AND t2.id IS NULL); -- 显式匹配NULL ``` --- ### 三、关键注意事项 1. **性能影响** - `OR`条件可能导致索引失效，大表关联需谨慎[^3] - `<=>`在支持它的数据库中更高效（如Hive） 2. **业务逻辑合理性** - 确认`NULL`是否代表相同语义（如"未知" vs "未填写"） - 非语义一致的`NULL`关联可能造成数据污染[^4] --- ### 四、实际应用示例 ```sql -- 关联用户与部门，保留部门为NULL的记录 SELECT u.id, u.name, d.dept_name FROM users u LEFT JOIN departments d ON u.dept_id <=> d.id; -- 包括dept_id为NULL的用户 ``` > **提示**：在需要区分“无关联”和“未知”的场景，建议用占位值（如`-1`）替代`NULL`，避免语义混淆。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值