Apache Spark 中支持的七种 Join 类型简介

最新推荐文章于 2024-07-20 22:06:32 发布
最新推荐文章于 2024-07-20 22:06:32 发布
阅读量5.8k 收藏 15
点赞数 3
文章标签： 编程语言 数据可视化 spark 数据分析 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wypblog/article/details/109281755
版权

数据分析中将两个数据集进行 Join 操作是很常见的场景。我在 这篇 文章中介绍了 Spark 支持的五种 Join 策略，本文我将给大家介绍一下 Apache Spark 中支持的 Join 类型（Join Type）。

目前 Apache Spark 3.0 版本中，一共支持以下七种 Join 类型：

•INNER JOIN•CROSS JOIN•LEFT OUTER JOIN•RIGHT OUTER JOIN•FULL OUTER JOIN•LEFT SEMI JOIN•LEFT ANTI JOIN 在实现上，这七种 Join 对应的实现类分别如下：

object JoinType {
  def apply(typ: String): JoinType = typ.toLowerCase(Locale.ROOT).replace("_", "") match {
    case "inner" => Inner
    case "outer" | "full" | "fullouter" => FullOuter
    case "leftouter" | "left" => LeftOuter
    case "rightouter" | "right" => RightOuter
    case "leftsemi" | "semi" => LeftSemi
    case "leftanti" | "anti" => LeftAnti
    case "cross" => Cross
    case _ =>
      val supported = Seq(
        "inner",
        "outer", "full", "fullouter", "full_outer",
        "leftouter", "left", "left_outer",
        "rightouter", "right", "right_outer",
        "leftsemi", "left_semi", "semi",
        "leftanti", "left_anti", "anti",
        "cross")
      throw new IllegalArgumentException(s"Unsupported join type '$typ'. " +
        "Supported join types include: " + supported.mkString("'", "', '", "'") + ".")
  }
}

今天，我并不打算从底层代码来介绍这七种 Join 类型的实现，而是从数据分析师的角度来介绍这几种 Join 的含义和使用。在介绍下文之前，假设我们有顾客（customer）和订单（order）相关的两张表，如下：

scala> val order = spark.sparkContext.parallelize(Seq(
     |   (1, 101,2500), (2,102,1110), (3,103,500), (4 ,102,400)
     | )).toDF("paymentId", "customerId","amount")
order: org.apache.spark.sql.DataFrame = [paymentId: int, customerId: int ... 1 more field]
scala> order.show
+---------+----------+------+
|paymentId|customerId|amount|
+---------+----------+------+
|        1|       101|  2500|
|        2|       102|  1110|
|        3|       103|   500|
|        4|       102|   400|
+---------+----------+------+
scala> val customer = spark.sparkContext.parallelize(Seq(
     |     (101,"iteblog") ,(102,"iteblog_hadoop") ,(103,"iteblog001"), (104,"iteblog002"), (105,"iteblog003"), (106,"iteblog004")
     | )).toDF("customerId", "name")
customer: org.apache.spark.sql.DataFrame = [customerId: int, name: string]
scala> customer.show
+----------+--------------+
|customerId|          name|
+----------+--------------+
|       101|       iteblog|
|       102|iteblog_hadoop|
|       103|    iteblog001|
|       104|    iteblog002|
|       105|    iteblog003|
|       106|    iteblog004|
+----------+--------------+
准备好数据之后，现在我们来一一介绍这些 Join 类型。

INNER JOIN

在 Spark 中，如果没有指定任何 Join 类型，那么默认就是 INNER JOIN。INNER JOIN 只会返回满足 Join 条件（ join condition）的数据，这个大家用的应该比较多，具体如下：

scala> val df = customer.join(order,"customerId")
df: org.apache.spark.sql.DataFrame = [customerId: int, name: string ... 2 more fields]
scala> df.show
+----------+--------------+---------+------+
|customerId|          name|paymentId|amount|
+----------+--------------+---------+------+
|       101|       iteblog|        1|  2500|
|       103|    iteblog001|        3|   500|
|       102|iteblog_hadoop|        2|  1110|
|       102|iteblog_hadoop|        4|   400|
+----------+--------------+---------+------+

从上面可以看出，当我们没有指定任何 Join 类型时，默认就是 INNER JOIN；在生成的结果中， Spark 自动为我们删除了两张表都存在的 customerId。如果用图来表示的话， INNER JOIN 可以如下表示：

上图粉色部分就是 INNER JOIN 的结果。

CROSS JOIN

这种类型的 Join 也称为笛卡儿积（Cartesian Product），Join 左表的每行数据都会跟右表的每行数据进行 Join，产生的结果行数为 m*n，所以在生产环境下尽量不要用这种 Join。下面是 CROSS JOIN 的使用例子：

scala> val df = customer.crossJoin(order)
df: org.apache.spark.sql.DataFrame = [customerId: int, name: string ... 3 more fields]
scala> df.show
+----------+--------------+---------+----------+------+
|customerId|          name|paymentId|customerId|amount|
+----------+--------------+---------+----------+------+
|       101|       iteblog|        1|       101|  2500|
|       101|       iteblog|        2|       102|  1110|
|       101|       iteblog|        3|       103|   500|
|       101|       iteblog|        4|       102|   400|
|       102|iteblog_hadoop|        1|       101|  2500|
|       102|iteblog_hadoop|        2|       102|  1110|
|       102|iteblog_hadoop|        3|       103|   500|
|       102|iteblog_hadoop|        4|       102|   400|
|       103|    iteblog001|        1|       101|  2500|
|       103|    iteblog001|        2|       102|  1110|
|       103|    iteblog001|        3|       103|   500|
|       103|    iteblog001|        4|       102|   400|
|       104|    iteblog002|        1|       101|  2500|
|       104|    iteblog002|        2|       102|  1110|
|       104|    iteblog002|        3|       103|   500|
|       104|    iteblog002|        4|       102|   400|
|       105|    iteblog003|        1|       101|  2500|
|       105|    iteblog003|        2|       102|  1110|
|       105|    iteblog003|        3|       103|   500|
|       105|    iteblog003|        4|       102|   400|
+----------+--------------+---------+----------+------+
only showing top 20 rows

LEFT OUTER JOIN

LEFT OUTER JOIN 等价于 LEFT JOIN，这个 Join 的返回的结果相信大家都知道，我就不介绍了。下面三种写法都是等价的：

val leftJoinDf = customer.join(order,Seq("customerId"), "left_outer")
val leftJoinDf = customer.join(order,Seq("customerId"), "leftouter")
val leftJoinDf = customer.join(order,Seq("customerId"), "left")
scala> leftJoinDf.show
+----------+--------------+---------+------+
|customerId|          name|paymentId|amount|
+----------+--------------+---------+------+
|       101|       iteblog|        1|  2500|
|       103|    iteblog001|        3|   500|
|       102|iteblog_hadoop|        2|  1110|
|       102|iteblog_hadoop|        4|   400|
|       105|    iteblog003|     null|  null|
|       106|    iteblog004|     null|  null|
|       104|    iteblog002|     null|  null|
+----------+--------------+---------+------+

如果用图表示的话，LEFT OUTER JOIN 可以如下所示：可以看出，参与 Join 的左表数据都会显示出来，而右表只有关联上的才会显示。

RIGHT OUTER JOIN

和 LEFT OUTER JOIN 类似，RIGHT OUTER JOIN 等价于 RIGHT JOIN，下面三种写法也是等价的：

val rightJoinDf = order.join(customer,Seq("customerId"), "right")
val rightJoinDf = order.join(customer,Seq("customerId"), "right_outer")
val rightJoinDf = order.join(customer,Seq("customerId"), "rightouter")
scala> rightJoinDf.show
+----------+---------+------+--------------+
|customerId|paymentId|amount|          name|
+----------+---------+------+--------------+
|       101|        1|  2500|       iteblog|
|       103|        3|   500|    iteblog001|
|       102|        2|  1110|iteblog_hadoop|
|       102|        4|   400|iteblog_hadoop|
|       105|     null|  null|    iteblog003|
|       106|     null|  null|    iteblog004|
|       104|     null|  null|    iteblog002|
+----------+---------+------+--------------+

如果用图表示的话，RIGHT OUTER JOIN 可以如下所示：可以看出，参与 Join 的右表数据都会显示出来，而左表只有关联上的才会显示。

FULL OUTER JOIN

FULL OUTER JOIN 的含义大家应该也都熟悉，我就不介绍其含义了。FULL OUTER JOIN 有以下四种写法：

val fullJoinDf = order.join(customer,Seq("customerId"), "outer")
val fullJoinDf = order.join(customer,Seq("customerId"), "full")
val fullJoinDf = order.join(customer,Seq("customerId"), "full_outer")
val fullJoinDf = order.join(customer,Seq("customerId"), "fullouter")
scala> fullJoinDf.show
+----------+---------+------+--------------+
|customerId|paymentId|amount|          name|
+----------+---------+------+--------------+
|       101|        1|  2500|       iteblog|
|       103|        3|   500|    iteblog001|
|       102|        2|  1110|iteblog_hadoop|
|       102|        4|   400|iteblog_hadoop|
|       105|     null|  null|    iteblog003|
|       106|     null|  null|    iteblog004|
|       104|     null|  null|    iteblog002|
+----------+---------+------+--------------+

FULL OUTER JOIN 可以用如下图表示：

LEFT SEMI JOIN

LEFT SEMI JOIN 这个大家应该知道的人相对少些，LEFT SEMI JOIN 只会返回匹配右表的数据，而且 LEFT SEMI JOIN 只会返回左表的数据，右表的数据是不会显示的，下面三种写法都是等价的：

val leftSemiJoinDf = order.join(customer,Seq("customerId"), "leftsemi")
val leftSemiJoinDf = order.join(customer,Seq("customerId"), "left_semi")
val leftSemiJoinDf = order.join(customer,Seq("customerId"), "semi")
scala> leftSemiJoinDf.show
+----------+---------+------+
|customerId|paymentId|amount|
+----------+---------+------+
|       101|        1|  2500|
|       103|        3|   500|
|       102|        2|  1110|
|       102|        4|   400|
+----------+---------+------+

从上面结果可以看出，LEFT SEMI JOIN 其实可以用 IN/EXISTS 来改写：

scala> order.registerTempTable("order")
warning: there was one deprecation warning (since 2.0.0); for details, enable `:setting -deprecation' or `:replay -deprecation'
scala> customer.registerTempTable("customer")
warning: there was one deprecation warning (since 2.0.0); for details, enable `:setting -deprecation' or `:replay -deprecation'
scala> val r = spark.sql("select * from order where customerId in (select customerId from customer)")
r: org.apache.spark.sql.DataFrame = [paymentId: int, customerId: int ... 1 more field]
scala> r.show
+---------+----------+------+
|paymentId|customerId|amount|
+---------+----------+------+
|        1|       101|  2500|
|        3|       103|   500|
|        2|       102|  1110|
|        4|       102|   400|
+---------+----------+------+

LEFT SEMI JOIN 可以用下图表示：

LEFT ANTI JOIN

与 LEFT SEMI JOIN 相反，LEFT ANTI JOIN 只会返回没有匹配到右表的左表数据。而且下面三种写法也是等效的：

val leftAntiJoinDf = customer.join(order,Seq("customerId"), "leftanti")
val leftAntiJoinDf = customer.join(order,Seq("customerId"), "left_anti")
val leftAntiJoinDf = customer.join(order,Seq("customerId"), "anti")
scala> leftAntiJoinDf.show
+----------+----------+
|customerId|      name|
+----------+----------+
|       105|iteblog003|
|       106|iteblog004|
|       104|iteblog002|
+----------+----------+

同理，LEFT ANTI JOIN 也可以用 NOT IN 来改写：

scala> val r = spark.sql("select * from customer where customerId not in (select customerId from order)")
r: org.apache.spark.sql.DataFrame = [customerId: int, name: string]
scala> r.show
+----------+----------+
|customerId|      name|
+----------+----------+
|       104|iteblog002|
|       105|iteblog003|
|       106|iteblog004|
+----------+----------+

LEFT SEMI ANTI 可以用下图表示：

好了，Spark 七种 Join 类型已经简单介绍完了，大家可以根据不同类型的业务场景选择不同的 Join 类型。今天分享就到这，感谢大家关注支持。

猜你喜欢

1、时间轮在 Kafka 的应用和实战，面试用得到

2、网易云音乐实时计算平台设计及实践

3、字节跳动 EB 级 HDFS 实践

4、Apache Hudi 现在也支持 Flink 引擎了

过往记忆大数据微信群，请添加微信：fangzhen0219,备注【进群】

过往记忆
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SparkSql Join Types详解
SunnyRivers
01-31 255
我们都知道join是根据某些条件把两行数据关联起来，而且也熟悉常用的一些join type，如inner、left、right等等，但是有些人可能对semi、anti或者一些语法的缩写和全写搞的不是很清楚，这篇博客就用简单明了的案例把这些都讲明白。
Spark支持的Join类型、Join的3种实现
upupfeng的博客
08-15 3859
说一下的Spark Join的分类及基本实现机制
手撕SparkSQL五大JOIN的底层机制
敏叔
07-31 1645
Broadcast hash join (BHJ) Shuffle hash join（SHJ） Shuffle sort merge join (SMJ) Shuffle-and-replicate nested loop join，又称笛卡尔积（Cartesian product join） Broadcast nested loop join (BNLJ) 这些机制你真的了解清楚么， 今天对SparkSQL JOIN的机制从原理和源码都深入剖析，不管是做Spark优化，问题排查，都有极大的帮助~~
Spark的join类型和策略
互联网知识分享
08-01 902
在Spark中进行join操作时，可以通过不同的参数进行配置和调优，以下是一些常用参数的介绍：joinType：指定连接类型，默认为inner。joinHint：指定连接策略的提示，包括"shuffle"和。：设置广播超时时间，默认为5分钟。：设置自动广播的阈值，默认为10MB。：设置洗牌操作的分区数，默认为200。下面是一个完整的Spark代码案例，演示了如何使用不同的join类型和策略：importvalspark =.builder()
Spark五种 Join 方式
u012957549的博客
08-02 7001
在Spark 种 有2种 数据分发方式分别是 Hash Shuffle,和BroadCast。 在Spark 种 有3种 join 方式 分别是 SoftMergeJoin, HashJoin,Nested Loop Join 。 所以一共5种join 方式（没有 BroadCast SoftMergeJoin） 为什么没有它呢 相比 SMJ，HJ 并不要求参与 Join 的两张表有序，也不需要维护两个游标来判断当前的记录位置，只要基表在 Build 阶段构建的哈希表可以放进内存，HJ 算法就可以在 Pro
Spark SQL 支持哪些类型的 JOIN ？
Shockang的博客
03-26 2585
前言 本文隶属于专栏《大数据技术体系》，该专栏为笔者原创，引用请注明来源，不足和错误之处请在评论区帮忙指出，谢谢！ 本专栏目录结构和参考文献请见大数据技术体系 7 种 JOIN Spark 3.3.0 版本支持 7 种类型的 JOIN。 INNER JOIN FULL OUTER JOIN LEFT OUTER JOIN RIGHT OUTER JOIN LEFT SEMI JOIN LEFT ANTI JOIN CROSS JOIN pyspark 支持 pandas 的merge_asof，
Apache Spark的面试题.zip
03-08
以上内容涵盖了Apache Spark面试中可能遇到的一些关键知识点，涵盖了Spark的基础、核心组件、架构、SQL、流处理、性能优化、容错机制、应用场景及未来发展趋势等方面。理解并掌握这些知识点将对准备Spark相关的面试...
ApacheSparkJavaDemo:Java中的Apache Spark示例
04-30
DataFrame API是在Spark SQL中引入的，它提供了一种更高级、更类型安全的方式来处理结构化数据。DataFrame可以看作是SQL表的分布式视图，支持丰富的聚合和转换操作。在Java中，可以使用`SparkSession`来操作...
Apache-Spark2.20源码中文注释
06-02
6. **Shuffle 操作**：在 Spark 中，Shuffle 是数据重新分区的过程，通常发生在 join、groupByKey 或 reduceByKey 等操作中。Shuffle 会触发网络传输，对性能影响较大，理解其内部机制有助于优化作业。 7. **容错...
大数据--Apache Spark
08-09
Apache Spark 作为一种高性能的大数据处理框架，在这一背景下应运而生。 #### 大数据面临的挑战 - **数据增长速度超过计算能力**：随着数据源的不断增加，数据的增长速度已经远远超过了计算速度的进步。 - **数据...
【Spark精讲】Spark五种JOIN策略
话数Science
12-16 3586
Spark JOIN详解，Spark五种JOIN策略，Shuffle Hash Join，Broadcast Hash Join，Sort Merge Join，Cartesian Join，Broadcast Nested Loop Join
Spark_Spark JOIN的种类 以及选择依据
迎难而上
06-07 2869
参考文章 ： 1.Spark join种类(>3种)及join选择依据 https://blog.csdn.net/rlnLo2pNEfx9c/article/details/106066081 Spark 内部JOIN 大致分为以下3种实现方式 ： 1.BroadCastHashJoin 2.ShuffledHashJoin 3.SortMergeJoin 1.BroadCastHashJoin 翻过源码之后你就会发现，Spark 1.6之前实...
Spark三种常见JOIN方式
linken01的博客
02-25 1544
简述spark join的三种方式。
大数据技术架构(组件)33——Spark：Spark SQL--Join Type
sysocc的博客
02-12 674
1.5、如果用户没有指定任何Join Hint，那么就根据Join的策略Broadcast Hash Join ---> Shuffle Hash Join --> Sort Merge Join ---> Cartesian Product Join --> Broadcast Nested Loop Join顺序选择Join策略。当然用户也可以手动选择策。1、Shuffle阶段：对两个表参与Join的keys使用相同的分区算法和分区数进行分区，目的就是为了保障相同的key都分配到相同的分区里面。
Spark SQL 测试JoinType中所有join的类型，便于理解
weixin_34005042的博客
05-25 1425
准备 测试数据 trade订单号 卖家 买家 买家城市 1 A 小王 北京 2 B 小李 天津 3 A 小刘 北京 order所属订单号 买家 商品名称 价格 发货时间 1 小王 电视 12 2015-08-01 09:08:31 1 小王 冰箱 24 2015-08-01 09:08:14 2 小李 空调 12 ...
数据仓库中的数据治理
最新发布
weixin_72431427的博客
07-20 803
数据仓库中的数据治理，包括定义和流程，并探讨为什么数据治理对于数据仓库的成功至关重要。
spark中的leftOuterjoin操作
04-20
在Apache Spark中，leftOuterJoin是一种用于合并两个数据集的函数，它基于两个数据集之间的键进行连接。连接操作的结果是一个新的数据集，其中包含左表（左连接的那一方）的所有记录以及右表（右连接的那一方）中匹配的记录。如果右表中没有匹配的记录，则对应的键在结果数据集中对应的位置会是一个null值。 leftOuterJoin的主要操作是使用一个指定的键将两个数据集进行连接。左连接意味着在左边的数据集中的每个键都与右边的数据集进行匹配。如果在右边的数据集中找不到匹配的键，则结果中对应的键将为null。 这里是一个基本的例子： ```python left = left_data.join(right = right_data, on = "key") ``` 在这个例子中，"key"是连接两个数据集的键，"left_data"和"right_data"是两个数据集。 在Spark中，leftOuterJoin的操作与join操作类似，但是它还会包括那些在右表中找不到匹配项的记录。这就是它的左外部性（left-out-ness）的含义。结果数据集中将包含左表中的所有记录，以及右表中匹配的记录，即使右表中没有匹配项。 以下是一个使用leftOuterJoin的例子： ```python left = spark.createDataFrame([("A", 10), ("B", 20)], ["key", "value"]) right = spark.createDataFrame([("B", 25), ("C", 30)], ["key", "value"]) result = left.join(right, left["key"] == right["key"], "leftouter") result.show() ``` 在这个例子中，我们创建了两个DataFrame，然后使用leftOuterJoin进行连接。结果将包括左表中的所有记录（A和B），以及右表中匹配的记录（B）。如果右表中没有匹配的记录（C），那么结果中对应的键将为null。 注意：在Spark中，所有的连接操作都是内联的，这意味着如果左表或右表中的一个被改变，所有的连接操作都会重新计算。这就是Spark支持大规模数据处理的原因之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值