Spark SQL 支持哪些类型的 JOIN ？

已于 2022-03-26 18:22:47 修改
阅读量2.5k 收藏 3
点赞数 1
分类专栏： 大数据技术体系 文章标签： spark scala 大数据 sql
于 2022-03-26 18:16:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shockang/article/details/123760634
版权

前言

本文隶属于专栏《大数据技术体系》，该专栏为笔者原创，引用请注明来源，不足和错误之处请在评论区帮忙指出，谢谢！

本专栏目录结构和参考文献请见大数据技术体系

7 种 JOIN

Spark 3.3.0 版本支持 7 种类型的 JOIN。

  1. INNER JOIN
  2. FULL OUTER JOIN
  3. LEFT OUTER JOIN
  4. RIGHT OUTER JOIN
  5. LEFT SEMI JOIN
  6. LEFT ANTI JOIN
  7. CROSS JOIN

pyspark 支持 pandas 的merge_asof，即支持 ASOF JOIN，详情请参考我的这篇博客——ASOF JOIN 是什么？pandas 的 merge_asof() 如何使用？

区别

INNER JOIN

INNER JOIN 一般被译作内连接。

内连接查询能将左表和右表中能关联起来的数据连接后返回。

例如：

SELECT A.PK AS A_PK, B.PK AS B_PK,
       A.Value AS A_Value, B.Value AS B_Value
FROM Table_A A
INNER JOIN Table_B B
ON A.PK = B.PK;

查询结果：

+------+------+---------+---------+
| A_PK | B_PK | A_Value | B_Value |
+------+------+---------+---------+
|    1 |    1 | both ab | both ab |
+------+------+---------+---------+
1 row in set (0.00 sec)

FULL OUTER JOIN

FULL OUTER JOIN 一般被译作外连接、全连接，实际查询语句中还可以写作 FULL JOIN。

外连接查询能返回左右表里的所有记录，其中左右表里能关联起来的记录被连接后返回。

例如：

SELECT A.PK AS A_PK, B.PK AS B_PK,
       A.Value AS A_Value, B.Value AS B_Value
FROM Table_A A
FULL OUTER JOIN Table_B B
ON A.PK = B.PK;

查询结果：

+------+---------+------+---------+
| PK   | Value   | PK   | Value   |
+------+---------+------+---------+
|    1 | both ab |    1 | both ba |
|    2 | only a  | NULL | NULL    |
| NULL | NULL    |    3 | only b  |
+------+---------+------+---------+
3 rows in set (0.00 sec)

LEFT OUTER JOIN

LEFT OUTER JOIN 一般被译作左外连接，也写作 LEFT JOIN（左连接）。

左连接查询会返回左表中所有记录，不管右表中有没有关联的数据。

在右表中找到的关联数据列也会被一起返回。

例如：

SELECT A.PK AS A_PK, B.PK AS B_PK,
       A.Value AS A_Value, B.Value AS B_Value
FROM Table_A A
LEFT JOIN Table_B B
ON A.PK = B.PK;

查询结果：

+------+------+---------+---------+
| A_PK | B_PK | A_Value | B_Value |
+------+------+---------+---------+
|    1 |    1 | both ab | both ba |
|    2 | NULL | only a  | NULL    |
+------+------+---------+---------+
2 rows in set (0.00 sec)

RIGHT OUTER JOIN

RIGHT OUTER JOIN 一般被译作右外连接，也写作 RIGHT JOIN（右连接）。

右连接查询会返回右表中所有记录，不管左表中有没有关联的数据。

在左表中找到的关联数据列也会被一起返回。

例如：

SELECT A.PK AS A_PK, B.PK AS B_PK,
       A.Value AS A_Value, B.Value AS B_Value
FROM Table_A A
RIGHT JOIN Table_B B
ON A.PK = B.PK;

查询结果：

+------+------+---------+---------+
| A_PK | B_PK | A_Value | B_Value |
+------+------+---------+---------+
|    1 |    1 | both ab | both ba |
| NULL |    3 | NULL    | only b  |
+------+------+---------+---------+
2 rows in set (0.00 sec)

LEFT SEMI JOIN

LEFT SEMI JOIN （左半连接）是 IN/EXISTS 子查询的一种更高效的实现。

例如：

SELECT A.PK, A.Value
FROM A
WHERE A.PK IN (SELECT B.PK FROM B)

可以改写成：

SELECT A.PK, A.Value
FROM A LEFT SEMI JOIN B
ON (A.PK = B.PK)

特点

  1. LEFT SEMI JOIN 的限制是， JOIN 子句中右边的表只能在 ON 子句中设置过滤条件，在 WHERE 子句、SELECT 子句或其他地方过滤都不行。
  2. LEFT SEMI JOIN 只传递表的 join key 给 map 阶段，因此LEFT SEMI JOIN 中最后 SELECT 的结果只许出现左表。
  3. 因为 LEFT SEMI JOIN 是 in(keySet) 的关系，遇到右表重复记录，左表会跳过，而 JOIN 则会一直遍历。这就导致右表有重复值的情况下 LEFT SEMI JOIN 只产生一条，JOIN 会产生多条，也会导致LEFT SEMI JOIN的性能更高。

LEFT ANTI JOIN

LEFT ANTI JOIN 一般译作左反连接。

A LEFT ANTI JOIN B 的功能是在查询过程中，剔除 A 表中和 B 表有交集的部分

LEFT SEMI JOIN只会返回左表中能匹配到右表的数据，LEFT ANTI JOIN只会返回左表中不能匹配到右表的数据。

其实INNER JOIN 和 LEFT SEMI/ANTI JOIN 的效果功能，都可以使用LEFT OUTER JOIN 最后在WHERE中加以限制的方式进行实现，但是这样的做法会导致查询效率变低。

CROSS JOIN

如果不带WHERE条件子句，它将会返回被连接的两个表的笛卡尔积，返回结果的行数等于两个表行数的乘积；

比如，下面 A、B、C 执行结果相同，但是效率不一样：

A:

SELECT a.*, b.* FROM t1 a, t2 b WHERE a.id=b.id

B:

SELECT * FROM t1 a CROSS JOIN t2 b WHERE a.id=b.id

注：CROSS JOIN后加条件只能用WHERE,不能用ON

C:

SELECT * FROM t2 a INNER JOIN t2 b ON a.id=b.id

一般不建议使用 A 和 B，因为如果有WHERE子句的话，往往会先生成两个表行数乘积的行的数据表然后才根据WHERE条件从中选择。

因此，如果两个需要求交际的表太大，将会非常非常慢，不建议使用。

joinType

每种类型对应的joinType字符串为：

类型joinType
Innerinner
FullOuterouter/full/fullouter/full_outer
LeftOuterleftouter/left/left_outer
RightOuterrightouter/right/right_outer
LeftSemileftsemi/left_semi/semi
LeftAntileftanti/left_anti/anti
Crosscross

我们通过Dataset中的 API 可以选择不同的joinType：

def join(right: Dataset[_], usingColumns: Seq[String], joinType: String): DataFrame

实践

源码下载

spark-examples 代码已开源，本项目致力于提供最具实践性的 Apache Spark 代码开发学习指南。

点击链接前往 github 下载源码：spark-examples

package com.shockang.study.spark.sql.join

import com.shockang.study.spark.util.Utils.formatPrint
import org.apache.spark.sql.SparkSession

/**
 *
 * Spark SQL 支持的 JOIN 测试
 *
 * @author Shockang
 */
object JoinExample {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().appName("JoinExample").master("local[*]").getOrCreate()
    spark.sparkContext.setLogLevel("ERROR")

    val df1 = spark.createDataFrame(List(
      ("Shockang", "程序员"),
      ("Tom", "猫"),
      ("Jerry", "老鼠")
    )).toDF("name", "occupation").cache()

    df1.createTempView("t1")

    val df2 = spark.createDataFrame(List(
      ("Alice", 12),
      ("Tom", 10),
      ("Jerry", 11)
    )).toDF("name", "age").cache()

    df2.createTempView("t2")

    // INNER JOIN
    formatPrint("""df1.join(df2, Seq("name"), joinType = "inner").show()""")
    df1.join(df2, Seq("name"), joinType = "inner").show()

    formatPrint("""spark.sql("SELECT * FROM t1 INNER JOIN t2 ON t1.name=t2.name").show()""")
    spark.sql("SELECT * FROM t1 INNER JOIN t2 ON t1.name=t2.name").show()
    formatPrint("""spark.sql("SELECT * FROM t1 JOIN t2 ON t1.name=t2.name").show()""")
    spark.sql("SELECT * FROM t1 JOIN t2 ON t1.name=t2.name").show()

    // FULL OUTER JOIN
    formatPrint("""df1.join(df2, Seq("name"), joinType = "outer").show()""")
    df1.join(df2, Seq("name"), joinType = "outer").show()
    formatPrint("""df1.join(df2, Seq("name"), joinType = "full").show()""")
    df1.join(df2, Seq("name"), joinType = "full").show()
    formatPrint("""df1.join(df2, Seq("name"), joinType = "fullouter").show()""")
    df1.join(df2, Seq("name"), joinType = "fullouter").show()
    formatPrint("""df1.join(df2, Seq("name"), joinType = "full_outer").show()""")
    df1.join(df2, Seq("name"), joinType = "full_outer").show()

    formatPrint("""spark.sql("SELECT * FROM t1 FULL OUTER JOIN t2 ON t1.name=t2.name").show()""")
    spark.sql("SELECT * FROM t1 FULL OUTER JOIN t2 ON t1.name=t2.name").show()
    formatPrint("""spark.sql("SELECT * FROM t1 FULL JOIN t2 ON t1.name=t2.name").show()""")
    spark.sql("SELECT * FROM t1 FULL JOIN t2 ON t1.name=t2.name").show()

    // LEFT OUTER JOIN
    formatPrint("""df1.join(df2, Seq("name"), joinType = "leftouter").show()""")
    df1.join(df2, Seq("name"), joinType = "leftouter").show()
    formatPrint("""df1.join(df2, Seq("name"), joinType = "left").show()""")
    df1.join(df2, Seq("name"), joinType = "left").show()
    formatPrint("""df1.join(df2, Seq("name"), joinType = "left_outer").show()""")
    df1.join(df2, Seq("name"), joinType = "left_outer").show()

    formatPrint("""spark.sql("SELECT * FROM t1 LEFT OUTER JOIN t2 ON t1.name=t2.name").show()""")
    spark.sql("SELECT * FROM t1 LEFT OUTER JOIN t2 ON t1.name=t2.name").show()
    formatPrint("""spark.sql("SELECT * FROM t1 LEFT JOIN t2 ON t1.name=t2.name").show()""")
    spark.sql("SELECT * FROM t1 LEFT JOIN t2 ON t1.name=t2.name").show()

    // RIGHT OUTER JOIN
    formatPrint("""df1.join(df2, Seq("name"), joinType = "rightouter").show()""")
    df1.join(df2, Seq("name"), joinType = "rightouter").show()
    formatPrint("""df1.join(df2, Seq("name"), joinType = "right").show()""")
    df1.join(df2, Seq("name"), joinType = "right").show()
    formatPrint("""df1.join(df2, Seq("name"), joinType = "right_outer").show()""")
    df1.join(df2, Seq("name"), joinType = "right_outer").show()

    formatPrint("""spark.sql("SELECT * FROM t1 RIGHT OUTER JOIN t2 ON t1.name=t2.name").show()""")
    spark.sql("SELECT * FROM t1 RIGHT OUTER JOIN t2 ON t1.name=t2.name").show()
    formatPrint("""spark.sql("SELECT * FROM t1 RIGHT JOIN t2 ON t1.name=t2.name").show()""")
    spark.sql("SELECT * FROM t1 RIGHT JOIN t2 ON t1.name=t2.name").show()

    // LEFT SEMI JOIN
    formatPrint("""df1.join(df2, Seq("name"), joinType = "leftsemi").show()""")
    df1.join(df2, Seq("name"), joinType = "leftsemi").show()
    formatPrint("""df1.join(df2, Seq("name"), joinType = "left_semi").show()""")
    df1.join(df2, Seq("name"), joinType = "left_semi").show()
    formatPrint("""df1.join(df2, Seq("name"), joinType = "semi").show()""")
    df1.join(df2, Seq("name"), joinType = "semi").show()

    formatPrint("""spark.sql("SELECT * FROM t1 LEFT SEMI JOIN t2 ON t1.name=t2.name").show()""")
    spark.sql("SELECT * FROM t1 LEFT SEMI JOIN t2 ON t1.name=t2.name").show()
    formatPrint("""spark.sql("SELECT * FROM t1 SEMI JOIN t2 ON t1.name=t2.name").show()""")
    spark.sql("SELECT * FROM t1 SEMI JOIN t2 ON t1.name=t2.name").show()

    // LEFT ANTI JOIN
    formatPrint("""df1.join(df2, Seq("name"), joinType = "leftanti").show()""")
    df1.join(df2, Seq("name"), joinType = "leftanti").show()
    formatPrint("""df1.join(df2, Seq("name"), joinType = "left_anti").show()""")
    df1.join(df2, Seq("name"), joinType = "left_anti").show()
    formatPrint("""df1.join(df2, Seq("name"), joinType = "anti").show()""")
    df1.join(df2, Seq("name"), joinType = "anti").show()

    formatPrint("""spark.sql("SELECT * FROM t1 LEFT ANTI JOIN t2 ON t1.name=t2.name").show()""")
    spark.sql("SELECT * FROM t1 LEFT ANTI JOIN t2 ON t1.name=t2.name").show()
    formatPrint("""spark.sql("SELECT * FROM t1 ANTI JOIN t2 ON t1.name=t2.name").show()""")
    spark.sql("SELECT * FROM t1 ANTI JOIN t2 ON t1.name=t2.name").show()

    // CROSS JOIN
    formatPrint("""df1.join(df2, Seq("name"), joinType = "cross").show()""")
    df1.join(df2, Seq("name"), joinType = "cross").show()

    formatPrint("""spark.sql("SELECT * FROM t1 CROSS JOIN t2 ON t1.name=t2.name").show()""")
    spark.sql("SELECT * FROM t1 CROSS JOIN t2 ON t1.name=t2.name").show()

    spark.stop()
  }
}

控制台打印

========== df1.join(df2, Seq("name"), joinType = "inner").show() ==========
+-----+----------+---+
| name|occupation|age|
+-----+----------+---+
|  Tom|        猫| 10|
|Jerry|      老鼠| 11|
+-----+----------+---+

========== spark.sql("SELECT * FROM t1 INNER JOIN t2 ON t1.name=t2.name").show() ==========
+-----+----------+-----+---+
| name|occupation| name|age|
+-----+----------+-----+---+
|  Tom|        猫|  Tom| 10|
|Jerry|      老鼠|Jerry| 11|
+-----+----------+-----+---+

========== spark.sql("SELECT * FROM t1 JOIN t2 ON t1.name=t2.name").show() ==========
+-----+----------+-----+---+
| name|occupation| name|age|
+-----+----------+-----+---+
|  Tom|        猫|  Tom| 10|
|Jerry|      老鼠|Jerry| 11|
+-----+----------+-----+---+

========== df1.join(df2, Seq("name"), joinType = "outer").show() ==========
+--------+----------+----+
|    name|occupation| age|
+--------+----------+----+
|   Alice|      null|  12|
|   Jerry|      老鼠|  11|
|Shockang|    程序员|null|
|     Tom|        猫|  10|
+--------+----------+----+

========== df1.join(df2, Seq("name"), joinType = "full").show() ==========
+--------+----------+----+
|    name|occupation| age|
+--------+----------+----+
|   Alice|      null|  12|
|   Jerry|      老鼠|  11|
|Shockang|    程序员|null|
|     Tom|        猫|  10|
+--------+----------+----+

========== df1.join(df2, Seq("name"), joinType = "fullouter").show() ==========
+--------+----------+----+
|    name|occupation| age|
+--------+----------+----+
|   Alice|      null|  12|
|   Jerry|      老鼠|  11|
|Shockang|    程序员|null|
|     Tom|        猫|  10|
+--------+----------+----+

========== df1.join(df2, Seq("name"), joinType = "full_outer").show() ==========
+--------+----------+----+
|    name|occupation| age|
+--------+----------+----+
|   Alice|      null|  12|
|   Jerry|      老鼠|  11|
|Shockang|    程序员|null|
|     Tom|        猫|  10|
+--------+----------+----+

========== spark.sql("SELECT * FROM t1 FULL OUTER JOIN t2 ON t1.name=t2.name").show() ==========
+--------+----------+-----+----+
|    name|occupation| name| age|
+--------+----------+-----+----+
|    null|      null|Alice|  12|
|   Jerry|      老鼠|Jerry|  11|
|Shockang|    程序员| null|null|
|     Tom|        猫|  Tom|  10|
+--------+----------+-----+----+

========== spark.sql("SELECT * FROM t1 FULL JOIN t2 ON t1.name=t2.name").show() ==========
+--------+----------+-----+----+
|    name|occupation| name| age|
+--------+----------+-----+----+
|    null|      null|Alice|  12|
|   Jerry|      老鼠|Jerry|  11|
|Shockang|    程序员| null|null|
|     Tom|        猫|  Tom|  10|
+--------+----------+-----+----+

========== df1.join(df2, Seq("name"), joinType = "leftouter").show() ==========
+--------+----------+----+
|    name|occupation| age|
+--------+----------+----+
|Shockang|    程序员|null|
|     Tom|        猫|  10|
|   Jerry|      老鼠|  11|
+--------+----------+----+

========== df1.join(df2, Seq("name"), joinType = "left").show() ==========
+--------+----------+----+
|    name|occupation| age|
+--------+----------+----+
|Shockang|    程序员|null|
|     Tom|        猫|  10|
|   Jerry|      老鼠|  11|
+--------+----------+----+

========== df1.join(df2, Seq("name"), joinType = "left_outer").show() ==========
+--------+----------+----+
|    name|occupation| age|
+--------+----------+----+
|Shockang|    程序员|null|
|     Tom|        猫|  10|
|   Jerry|      老鼠|  11|
+--------+----------+----+

========== spark.sql("SELECT * FROM t1 LEFT OUTER JOIN t2 ON t1.name=t2.name").show() ==========
+--------+----------+-----+----+
|    name|occupation| name| age|
+--------+----------+-----+----+
|Shockang|    程序员| null|null|
|     Tom|        猫|  Tom|  10|
|   Jerry|      老鼠|Jerry|  11|
+--------+----------+-----+----+

========== spark.sql("SELECT * FROM t1 LEFT JOIN t2 ON t1.name=t2.name").show() ==========
+--------+----------+-----+----+
|    name|occupation| name| age|
+--------+----------+-----+----+
|Shockang|    程序员| null|null|
|     Tom|        猫|  Tom|  10|
|   Jerry|      老鼠|Jerry|  11|
+--------+----------+-----+----+

========== df1.join(df2, Seq("name"), joinType = "rightouter").show() ==========
+-----+----------+---+
| name|occupation|age|
+-----+----------+---+
|Alice|      null| 12|
|  Tom|        猫| 10|
|Jerry|      老鼠| 11|
+-----+----------+---+

========== df1.join(df2, Seq("name"), joinType = "right").show() ==========
+-----+----------+---+
| name|occupation|age|
+-----+----------+---+
|Alice|      null| 12|
|  Tom|        猫| 10|
|Jerry|      老鼠| 11|
+-----+----------+---+

========== df1.join(df2, Seq("name"), joinType = "right_outer").show() ==========
+-----+----------+---+
| name|occupation|age|
+-----+----------+---+
|Alice|      null| 12|
|  Tom|        猫| 10|
|Jerry|      老鼠| 11|
+-----+----------+---+

========== spark.sql("SELECT * FROM t1 RIGHT OUTER JOIN t2 ON t1.name=t2.name").show() ==========
+-----+----------+-----+---+
| name|occupation| name|age|
+-----+----------+-----+---+
| null|      null|Alice| 12|
|  Tom|        猫|  Tom| 10|
|Jerry|      老鼠|Jerry| 11|
+-----+----------+-----+---+

========== spark.sql("SELECT * FROM t1 RIGHT JOIN t2 ON t1.name=t2.name").show() ==========
+-----+----------+-----+---+
| name|occupation| name|age|
+-----+----------+-----+---+
| null|      null|Alice| 12|
|  Tom|        猫|  Tom| 10|
|Jerry|      老鼠|Jerry| 11|
+-----+----------+-----+---+

========== df1.join(df2, Seq("name"), joinType = "leftsemi").show() ==========
+-----+----------+
| name|occupation|
+-----+----------+
|  Tom|        猫|
|Jerry|      老鼠|
+-----+----------+

========== df1.join(df2, Seq("name"), joinType = "left_semi").show() ==========
+-----+----------+
| name|occupation|
+-----+----------+
|  Tom|        猫|
|Jerry|      老鼠|
+-----+----------+

========== df1.join(df2, Seq("name"), joinType = "semi").show() ==========
+-----+----------+
| name|occupation|
+-----+----------+
|  Tom|        猫|
|Jerry|      老鼠|
+-----+----------+

========== spark.sql("SELECT * FROM t1 LEFT SEMI JOIN t2 ON t1.name=t2.name").show() ==========
+-----+----------+
| name|occupation|
+-----+----------+
|  Tom|        猫|
|Jerry|      老鼠|
+-----+----------+

========== spark.sql("SELECT * FROM t1 SEMI JOIN t2 ON t1.name=t2.name").show() ==========
+-----+----------+
| name|occupation|
+-----+----------+
|  Tom|        猫|
|Jerry|      老鼠|
+-----+----------+

========== df1.join(df2, Seq("name"), joinType = "leftanti").show() ==========
+--------+----------+
|    name|occupation|
+--------+----------+
|Shockang|    程序员|
+--------+----------+

========== df1.join(df2, Seq("name"), joinType = "left_anti").show() ==========
+--------+----------+
|    name|occupation|
+--------+----------+
|Shockang|    程序员|
+--------+----------+

========== df1.join(df2, Seq("name"), joinType = "anti").show() ==========
+--------+----------+
|    name|occupation|
+--------+----------+
|Shockang|    程序员|
+--------+----------+

========== spark.sql("SELECT * FROM t1 LEFT ANTI JOIN t2 ON t1.name=t2.name").show() ==========
+--------+----------+
|    name|occupation|
+--------+----------+
|Shockang|    程序员|
+--------+----------+

========== spark.sql("SELECT * FROM t1 ANTI JOIN t2 ON t1.name=t2.name").show() ==========
+--------+----------+
|    name|occupation|
+--------+----------+
|Shockang|    程序员|
+--------+----------+

========== df1.join(df2, Seq("name"), joinType = "cross").show() ==========
+-----+----------+---+
| name|occupation|age|
+-----+----------+---+
|  Tom|        猫| 10|
|Jerry|      老鼠| 11|
+-----+----------+---+

========== spark.sql("SELECT * FROM t1 CROSS JOIN t2 ON t1.name=t2.name").show() ==========
+-----+----------+-----+---+
| name|occupation| name|age|
+-----+----------+-----+---+
|  Tom|        猫|  Tom| 10|
|Jerry|      老鼠|Jerry| 11|
+-----+----------+-----+---+
Shockang
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark支持的Join类型、Join的3种实现
upupfeng的博客
08-15 3891
说一下的Spark Join的分类及基本实现机制
每个 Spark 工程师都应该知道的五种 Join 策略
过往记忆大数据
09-13 4611
数据分析中将两个数据集进行 Join 操作是很常见的场景。在 Spark 的物理计划（physical plan）阶段，Spark 的 JoinSelection 类会根据 Join h...
Apache Spark 中支持的七种 Join 类型简介
过往记忆大数据
10-25 6101
数据分析中将两个数据集进行 Join 操作是很常见的场景。我在 这篇 文章中介绍了 Spark 支持的五种 Join 策略，本文我将给大家介绍一下 Apache Spark 中支持的 J...
Spark的join类型和策略
互联网知识分享
08-01 938
在Spark中进行join操作时，可以通过不同的参数进行配置和调优，以下是一些常用参数的介绍：joinType：指定连接类型，默认为inner。joinHint：指定连接策略的提示，包括"shuffle"和。：设置广播超时时间，默认为5分钟。：设置自动广播的阈值，默认为10MB。：设置洗牌操作的分区数，默认为200。下面是一个完整的Spark代码案例，演示了如何使用不同的join类型和策略：importvalspark =.builder()
Spark SQL 之 Join 实现
weixin_30258027的博客
09-20 862
原文地址：Spark SQL 之 Join 实现 Spark SQL 之 Join 实现 涂小刚2017-07-19217标签：spark，数据库 Join作为SQL中一个重要语法特性，几乎所有稍微复杂一点的数据分析场景都离不开Join，如今Spark SQL(Dataset/DataFrame)已经成为Spark应用程序开发的主流，作为开发者，我们有必要了解Jo...
spark sql解析-源码分析
03-16
6. **Hive兼容性**：Spark SQL通过Hive Metastore服务支持与Hive的数据交换，使得用户可以使用Spark SQL查询Hive表，同时也能将DataFrame保存到Hive表中。 7. **Code Generation**：Spark SQL利用Tungsten项目实现...
Spark SQL操作大全.zip
03-24
- **Join操作**：支持不同类型的join，如inner join、outer join、cross join等。 - **数据转换**：包含丰富的数据清洗和转换函数，如cast、to_date、substring等。 6. **性能优化** - ** Catalyst优化器**：...
Learning Spark SQL - Aurobindo Sarkar
12-25
3. SQL支持：解释如何使用SQL语句进行查询，包括JOIN、GROUP BY、ORDER BY等操作。 4. 数据源：介绍如何读取和写入各种数据源，如HDFS、Parquet、JSON等。 5. 性能优化：探讨Catalyst优化器的工作原理和性能调优策略...
基于spark sql引擎的即席查询服务.zip
最新发布
04-25
1. **性能优化**：Spark SQL支持Code Generation和Catalyst Optimizer，这两个特性能够生成高效的执行计划，并进行查询优化，例如列裁剪、谓词下推、Join重写等，从而提高查询速度。 2. **内存管理**：Spark SQL...
Spark SQL.xmind.zip
08-12
Spark SQL支持多种数据源，如HDFS、Cassandra、Hive等，可以读取和写入多种格式的数据，如JSON、Parquet、Avro等。DataFrame是Spark SQL的核心抽象，它是一种分布式的、带有列名的表格数据结构，可以视为SQL表或关系...
Spark之五种join策略
边看边学
12-31 738
Spark源码中关于join策略的描述 /** * Select the proper physical plan for join based on join strategy hints, the availability of * equi-join keys and the sizes of joining relations. Below are the existing join strategies, * their characteristics and their limitations.
Spark Dataset的join操作
u012280876的博客
09-24 2352
以下是两个具有相同列名的Dataset按照同名列相等进行join操作，join结果中同名列只会出现一个： val df1 = Seq((1, 2, 3),(1, 1, 1)).toDF("a", "b", "c") val df2 = Seq((1, 2, 4),(2, 2, 2)).toDF("a", "b", "c") df1.show +---+---+---+ | a| b| c|...
Spark join的分类
ThreeAspects的博客
05-30 731
  当前SparkSQL支持三种Join算法：shuffle hash join、broadcast hash join以及sort merge join。 Hash Join   采用hash join算法，整个过程会经历三步： 确定Build Table以及Probe Table：Build Table使用join key构建Hash Table，而Probe Table使用join key进行探测，探测成功就可以join在一起。通常情况下，小表会作为Build Table，大表作为Probe Ta
Spark_Spark JOIN的种类 以及选择依据
迎难而上
06-07 2878
参考文章 ： 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之前实...
sparkSQL的三种join（broadcast join、shuffle hash join和sort merge join）以及AE
rong_king_的博客
04-07 7184
每天一个小例子： spark中， 1.left semi join （左半连接）的意思就是， JOIN 子句中右边的表只能在 ON 子句中设置过滤条件，右表中有重复的数据会自动跳过，具体详见：https://blog.csdn.net/happyrocking/article/details/79885071 2. left anti join 含义：left anti join 是 not in/not exists 子查询的一种更高效的实现，相当于not in或者not exists，left anti
R语言dplyr包:高效数据处理函数case_when、inner/semi_join/anti_join、right/left_join@灵魂走风的江湖
热门推荐
关注我，你就是我的电子朋友咯！
03-30 1万+
R语言高效数据处理包 本篇为dplyr包实用函数的连载，主要为SQL数据库中类似功能的实现。 1、case_when函数，有一些SQL基础（casewhen）的都猜得到这个函数的功能 可实现多条件判断并可以添加标签的函数，这在我们对数据进行分类整理中十分的实用，这个函数中的参数可以这样分：一部分是判断条件，另一部分是所要做的标签 iris%>%select(Sepal.Lengt...
值得反复研读的表连接之ANTI JOIN方式
u011868279的博客
10-23 1128
值得反复研读的表连接之ANTI JOIN方式
Spark 浅谈Spark中的各种join
dinl_vin的博客
02-16 3716
众所周知,Join的种类丰富: 按照**关联形式(**Join type)划分: 有内关联,外关联,左关联,右关联,半关联,逆关联等,由业务逻辑决定的关联形式决定了Spark任务的运行结果; 按照关联机制(Join Mechanisms)划分: 有NLJ(Nested Loop Join) , SMJ(Sort Merge Join)和HJ(Hash Join),由数据内容决定的实现机制,则决定了Spark任务的运行效率; 关联形式 Spark支持的关联形式: 关联形式 Join Type关键字
Spark:FullOuterJoin算子
weixin_48109576的博客
08-09 1408
FullOuterJoin算子是Tranformation,具有shuffle 将左表右表全部聚合有的显示Some(value)没有显示None(value) 分区按照Hashpartitioner二个rdd最大分区数分区 底层调的是cogroup,然后flatMapValues压平 有个样例类匹配 如果rdd1相同key的value有就用Some(v),rdd2没有value就用None 如果rdd2相同key的value有就用Some(v),rdd2没有value就用None 如.
spark sql中出现 cross join 问题解决
03-16
在Spark SQL中，如果出现了cross join问题，可以通过以下方法解决： 1. 确认是否需要使用cross join。cross join会将两个表中的所有行进行组合，生成一个新的表。如果不需要这样的结果，可以考虑使用其他类型的join。 2. 检查join条件。如果join条件不正确，可能会导致cross join。确保join条件正确，可以避免cross join的问题。 3. 使用where子句。可以使用where子句来过滤掉不需要的行，从而避免cross join的问题。 4. 使用join类型。可以使用其他类型的join，如inner join、left join、right join等，来避免cross join的问题。 总之，避免cross join的方法有很多，需要根据具体情况选择合适的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值