Spark Sql Join操作类型

最新推荐文章于 2024-04-13 21:19:08 发布
最新推荐文章于 2024-04-13 21:19:08 发布
阅读量1k 收藏 4
点赞数 1
分类专栏： bigdata 文章标签： 大数据 big data
原文链接：https://sparkbyexamples.com/spark/spark-sql-dataframe-join/
版权

Spark DataFrame支持所有基本SQL Join类型的操作,如INNER,RIGHT OUTER,LEFT ANTI, LEFT SEMI, CROSS, SELF JOIN. Spark SQL Join操作是宽转换操作,结果数据会重组在网络中,因此当不仔细设计时,会有非常大的性能问题.

另外一方面,Spark SQL Join操作默认带更多优化(多亏DataFrame & DataSet), 虽然这样,当使用时需要考虑仍有一些性能问题.

在本文中,你会学到不同的Join语法并使用不同的Join 类型在DataFrame和DataSet上,例子用Scala.

SQL Join类型和语法

下边列出所有Spark SQL类型和语法

join(right: Dataset[_]): DataFrame
join(right: Dataset[_], usingColumn: String): DataFrame
join(right: Dataset[_], usingColumns: Seq[String]): DataFrame
join(right: Dataset[_], usingColumns: Seq[String], joinType: String): DataFrame
join(right: Dataset[_], joinExprs: Column): DataFrame
join(right: Dataset[_], joinExprs: Column, joinType: String): DataFrame

剩下的教程解释6种语法 Join 类型,接收合适的DataFrame, Join表达式和Join类型用string.

对于语法4 & 5你可以使用"JoinType" 或者"Join 字符串"定义在上边的表用"JoinType"字符串参数.当你使用"JoinType",你应该import org.apache.spark.sql.catalyst.plans._ 作为定义JoinType对象.

JOINTYPEJOIN STRINGEQUIVALENT SQL JOIN
Inner.sqlinnerINNER JOIN
FullOuter.sqlouter, full, fullouter, full_outerFULL OUTER JOIN
LeftOuter.sqlleft, leftouter, left_outerLEFT JOIN
RightOuter.sqlright, rightouter, right_outerRIGHT JOIN
Cross.sqlcross
LeftAnti.sqlanti, leftanti, left_anti
LeftSemi.sqlsemi, leftsemi, left_semi

所有Join对象定义joinType对象为了使用你需要导入org.apache.spark.sql.catalyst.plans.{LeftOuter,Inner,....}.

在你使用Spark SQL join例子之前,首先,先创建emp 和dept DataFrame. 在这里emp_id 列在emp是唯一的, dept_id 在 dept数据集唯一, 并且在emp 中 emp_dept_id 指向dept数据集中dept_id.

val emp = Seq((1,"Smith",-1,"2018","10","M",3000),
    (2,"Rose",1,"2010","20","M",4000),
    (3,"Williams",1,"2010","10","M",1000),
    (4,"Jones",2,"2005","10","F",2000),
    (5,"Brown",2,"2010","40","",-1),
      (6,"Brown",2,"2010","50","",-1)
  )
  val empColumns = Seq("emp_id","name","superior_emp_id","year_joined",
       "emp_dept_id","gender","salary")
  import spark.sqlContext.implicits._
  val empDF = emp.toDF(empColumns:_*)
  empDF.show(false)

  val dept = Seq(("Finance",10),
    ("Marketing",20),
    ("Sales",30),
    ("IT",40)
  )

  val deptColumns = Seq("dept_name","dept_id")
  val deptDF = dept.toDF(deptColumns:_*)
  deptDF.show(false)

Emp Dataset
+------+--------+---------------+-----------+-----------+------+------+
|emp_id|name    |superior_emp_id|year_joined|emp_dept_id|gender|salary|
+------+--------+---------------+-----------+-----------+------+------+
|1     |Smith   |-1             |2018       |10         |M     |3000  |
|2     |Rose    |1              |2010       |20         |M     |4000  |
|3     |Williams|1              |2010       |10         |M     |1000  |
|4     |Jones   |2              |2005       |10         |F     |2000  |
|5     |Brown   |2              |2010       |40         |      |-1    |
|6     |Brown   |2              |2010       |50         |      |-1    |
+------+--------+---------------+-----------+-----------+------+------+

Dept Dataset
+---------+-------+
|dept_name|dept_id|
+---------+-------+
|Finance  |10     |
|Marketing|20     |
|Sales    |30     |
|IT       |40     |
+---------+-------+

Inner Join

inner join为默认join,并且也是最常用的.被用来join两个DataFrame/Dataset 在指定列上,在两个数据集上没有匹配列上的数据会被丢弃.

empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"inner")
    .show(false)

当应用inner join在数据集上时,会把emp 中emp_dept_id=50和 dept中dept_id=30的数据丢弃.下边是上边的输出结果

+------+--------+---------------+-----------+-----------+------+------+---------+-------+
|emp_id|name    |superior_emp_id|year_joined|emp_dept_id|gender|salary|dept_name|dept_id|
+------+--------+---------------+-----------+-----------+------+------+---------+-------+
|1     |Smith   |-1             |2018       |10         |M     |3000  |Finance  |10     |
|2     |Rose    |1              |2010       |20         |M     |4000  |Marketing|20     |
|3     |Williams|1              |2010       |10         |M     |1000  |Finance  |10     |
|4     |Jones   |2              |2005       |10         |F     |2000  |Finance  |10     |
|5     |Brown   |2              |2010       |40         |      |-1    |IT       |40     |
+------+--------+---------------+-----------+-----------+------+------+---------+-------+

full outer join

outer也叫full, fullouter join返回Spark DataFrame/Dataset中所有的行, join表达式没有匹配上的用null来表示对象列.

empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"outer").show(false)
empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"full").show(false)
empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"fullouter").show(false)

Left Outer Join

Spark left 同 left outer join返回所有在左边DataFrame/Dataset的所有列,忽略右边数据没有匹配上的数据,它被分配null.

empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"left")
  .show(false)
empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"leftouter")
  .show(false)

在empDF数据集emp_dept_id=50没有记录在dept中,因此数据集在dept列(dept_name & dept_id)为null,并且dept_id=30在dept中会被丢掉.下边是上边Join表达式的结果.

+------+--------+---------------+-----------+-----------+------+------+---------+-------+
|emp_id|name    |superior_emp_id|year_joined|emp_dept_id|gender|salary|dept_name|dept_id|
+------+--------+---------------+-----------+-----------+------+------+---------+-------+
|1     |Smith   |-1             |2018       |10         |M     |3000  |Finance  |10     |
|2     |Rose    |1              |2010       |20         |M     |4000  |Marketing|20     |
|3     |Williams|1              |2010       |10         |M     |1000  |Finance  |10     |
|4     |Jones   |2              |2005       |10         |F     |2000  |Finance  |10     |
|5     |Brown   |2              |2010       |40         |      |-1    |IT       |40     |
|6     |Brown   |2              |2010       |50         |      |-1    |null     |null   |
+------+--------+---------------+-----------+-----------+------+------+---------+-------+
Scala

Right Outer Join

Spark Right 同 Right Outer join 相对于left join是另外一方向,会返回所有右侧DataFrame/Dataset的行,并且忽略匹配在左侧数据集当没有匹配上时,会分区null为那些数据,并且丢掉左侧没有匹配上的数据.

empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"right")
   .show(false)
  empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"rightouter")
   .show(false)

例子中,右侧数据集dep_id=30没有在左侧数据集emp中,因此这条记录包含null在emp列中.并且,emp_dept_id=50的没有匹配上,会被丢掉.下边是输出

+------+--------+---------------+-----------+-----------+------+------+---------+-------+
|emp_id|name    |superior_emp_id|year_joined|emp_dept_id|gender|salary|dept_name|dept_id|
+------+--------+---------------+-----------+-----------+------+------+---------+-------+
|4     |Jones   |2              |2005       |10         |F     |2000  |Finance  |10     |
|3     |Williams|1              |2010       |10         |M     |1000  |Finance  |10     |
|1     |Smith   |-1             |2018       |10         |M     |3000  |Finance  |10     |
|2     |Rose    |1              |2010       |20         |M     |4000  |Marketing|20     |
|null  |null    |null           |null       |null       |null  |null  |Sales    |30     |
|5     |Brown   |2              |2010       |40         |      |-1    |IT       |40     |
+------+--------+---------------+-----------+-----------+------+------+---------+-------+

Left Semi Join

Spark left Semi 和inner join相似,不同点leftsemi join返回在左数据集中所有列,并且忽略右数据集中所有列.换句话说,这个join返回的万仅仅是左数据匹配上右数据集的,没有匹配上的无论左右都被忽略.
相同的结果可以获得通过使用select在这个结果上,用inner join, 然而,使用这个join更高效.

empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"), "leftsemi")
    .show(false)

输出

leftsemi join
+------+--------+---------------+-----------+-----------+------+------+
|emp_id|name    |superior_emp_id|year_joined|emp_dept_id|gender|salary|
+------+--------+---------------+-----------+-----------+------+------+
|1     |Smith   |-1             |2018       |10         |M     |3000  |
|2     |Rose    |1              |2010       |20         |M     |4000  |
|3     |Williams|1              |2010       |10         |M     |1000  |
|4     |Jones   |2              |2005       |10         |F     |2000  |
|5     |Brown   |2              |2010       |40         |      |-1    |
+------+--------+---------------+-----------+-----------+------+------+

Left Anti Join

left anti join 做的和spark leftsemi刚好相反, leftanti join 返回仅仅是左侧列没有匹配上的.

 empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"leftanti")
    .show(false)

输出

+------+-----+---------------+-----------+-----------+------+------+
|emp_id|name |superior_emp_id|year_joined|emp_dept_id|gender|salary|
+------+-----+---------------+-----------+-----------+------+------+
|6     |Brown|2              |2010       |50         |      |-1    |
+------+-----+---------------+-----------+-----------+------+------+

Self Join

Spark join没有自联接join是不完整的.虽然没有自连接join类型可用,我们可以使用任何上边解释的join类型 join到DataFrame自身.下边为一个inner self join

empDF.as("emp1").join(empDF.as("emp2"),
    col("emp1.superior_emp_id") === col("emp2.emp_id"),"inner")
    .select(col("emp1.emp_id"),col("emp1.name"),
      col("emp2.emp_id").as("superior_emp_id"),
      col("emp2.name").as("superior_emp_name"))
      .show(false)

我们可以为所有employees join emp数据集join自己来发现superior emp_id和名字

+------+--------+---------------+-----------------+
|emp_id|name    |superior_emp_id|superior_emp_name|
+------+--------+---------------+-----------------+
|2     |Rose    |1              |Smith            |
|3     |Williams|1              |Smith            |
|4     |Jones   |2              |Rose             |
|5     |Brown   |2              |Rose             |
|6     |Brown   |2              |Rose             |
+------+--------+---------------+-----------------+

使用SQL表达式

因为Spark SQL支持SQL原生语法,我们可以写join操作在创建一个临时表之后,并使用spark.sql()

empDF.createOrReplaceTempView("EMP")
  deptDF.createOrReplaceTempView("DEPT")
//SQL JOIN
  val joinDF = spark.sql("select * from EMP e, DEPT d where e.emp_dept_id == d.dept_id")
  joinDF.show(false)

  val joinDF2 = spark.sql("select * from EMP e INNER JOIN DEPT d ON e.emp_dept_id == d.dept_id")
  joinDF2.show(false)

源代码


package com.sparkbyexamples.spark.dataframe.join

import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.functions.col
object JoinExample extends App {

  val spark: SparkSession = SparkSession.builder()
    .master("local[1]")
    .appName("SparkByExamples.com")
    .getOrCreate()

  spark.sparkContext.setLogLevel("ERROR")

  val emp = Seq((1,"Smith",-1,"2018","10","M",3000),
    (2,"Rose",1,"2010","20","M",4000),
    (3,"Williams",1,"2010","10","M",1000),
    (4,"Jones",2,"2005","10","F",2000),
    (5,"Brown",2,"2010","40","",-1),
      (6,"Brown",2,"2010","50","",-1)
  )
  val empColumns = Seq("emp_id","name","superior_emp_id","year_joined","emp_dept_id","gender","salary")
  import spark.sqlContext.implicits._
  val empDF = emp.toDF(empColumns:_*)
  empDF.show(false)

  val dept = Seq(("Finance",10),
    ("Marketing",20),
    ("Sales",30),
    ("IT",40)
  )

  val deptColumns = Seq("dept_name","dept_id")
  val deptDF = dept.toDF(deptColumns:_*)
  deptDF.show(false)


  println("Inner join")
  empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"inner")
    .show(false)

  println("Outer join")
  empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"outer")
    .show(false)
  println("full join")
  empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"full")
    .show(false)
  println("fullouter join")
  empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"fullouter")
    .show(false)

  println("right join")
  empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"right")
    .show(false)
  println("rightouter join")
  empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"rightouter")
    .show(false)

  println("left join")
  empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"left")
    .show(false)
  println("leftouter join")
  empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"leftouter")
    .show(false)

  println("leftanti join")
  empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"leftanti")
    .show(false)

  println("leftsemi join")
  empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"leftsemi")
    .show(false)

  println("cross join")
  empDF.join(deptDF,empDF("emp_dept_id") ===  deptDF("dept_id"),"cross")
    .show(false)

  println("Using crossJoin()")
  empDF.crossJoin(deptDF).show(false)

  println("self join")
  empDF.as("emp1").join(empDF.as("emp2"),
    col("emp1.superior_emp_id") === col("emp2.emp_id"),"inner")
    .select(col("emp1.emp_id"),col("emp1.name"),
      col("emp2.emp_id").as("superior_emp_id"),
      col("emp2.name").as("superior_emp_name"))
      .show(false)

  empDF.createOrReplaceTempView("EMP")
  deptDF.createOrReplaceTempView("DEPT")

  //SQL JOIN
  val joinDF = spark.sql("select * from EMP e, DEPT d where e.emp_dept_id == d.dept_id")
  joinDF.show(false)

  val joinDF2 = spark.sql("select * from EMP e INNER JOIN DEPT d ON e.emp_dept_id == d.dept_id")
  joinDF2.show(false)

}

结论

在本教程中,你已经学习了Spark SQL join 类型,INNER, LEFT OUTER, RIGHT OUTER, LEFT ANTI, LEFT SEMI, CROSS, SELF的使用,和对应SCALA代码.

大怀特
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark SQL操作大全.zip
03-24
- **Join操作**：支持不同类型的join，如inner join、outer join、cross join等。 - **数据转换**：包含丰富的数据清洗和转换函数，如cast、to_date、substring等。 6. **性能优化** - ** Catalyst优化器**：...
SparkSQL join
weixin_72649242的博客
12-18 1174
SparkSQL join_type
Spark——SparkSQL的3种Join实现
lehsyh的专栏
05-24 883
[转载]：https://www.toutiao.com/i6713491937078280712 引言 Join是SQL语句中的常用操作，良好的表结构能够将数据分散在不同的表中，使其符合某种范式，减少表冗余、更新容错等。而建立表和表之间关系的最佳方式就是Join操作。 对于Spark来说有3中Join的实现，每种Join对应着不同的应用场景： Broadcast Hash Join ：适合一张较小的表和一张大表进行join Shuffle Hash Join : 适合一张小表和一张大表进行joi
sparksql join方式
05-14 1127
Broadcast Hash Join：适合一张很小的表和一张大表进行JoinShuffle Hash Join：适合一张小表(比上一个大一点)和一张大表进行JoinSort Merge Join：适合两张大表进行JoinCartesian Hash Join: 笛卡尔连接方式，性能很差NestedLoopJoin : 性能很差对应以下几个类，Spark会根据CBO和AQE来决定使用哪种join方式。
Spark SQL join的三种实现方式
m0_61607827的博客
03-16 2715
引言 join是SQL中的常用操作，良好的表结构能够将数据分散到不同的表中，使其符合某种规范(mysql三大范式)，可以最大程度的减少数据冗余，更新容错等，而建立表和表之间关系的最佳方式就是join操作。 对于Spark来说有3种Join的实现，每种Join对应的不同的应用场景(SparkSQL自动决策使用哪种实现范式)： 　　1.Broadcast Hash Join：适合一张很小的表和一张大表进行Join； 　　2.Shuffle Hash Join：适合一张小表(比上一个大一点)和一张大表进行
Spark详解（十四）：Spark SQL的Join实现
u013939918的博客
07-30 1992
1. 简介 Join是SQL语句中的常用操作，良好的表结构能够将数据分散在不同的表中，使其符合某种范式，减少表冗余、更新容错等。而建立表和表之间关系的最佳方式就是Join操作。Join连接是大数据处理的重要手段，它基于表之间的共同字段将来自两个或多个表的行结合起来。如今Spark SQL(Dataset/DataFrame)已经成为Spark应用程序开发的主流，作为开发者，我们有必要了解Join在Spark中是如何组织运行的。 2. Join的基本要素 如下图所示，Join大致包括三个要素：Join方
spark sql解析-源码分析
03-16
1. **DataFrame API**：DataFrame是Spark SQL的核心概念，它是一种分布式数据集合，提供了类似SQL的API用于数据操作。DataFrame是基于RDD（弹性分布式数据集）的概念，但增加了类型安全和元数据，使得数据处理更加...
Learning Spark SQL - Aurobindo Sarkar
12-25
3. SQL支持：解释如何使用SQL语句进行查询，包括JOIN、GROUP BY、ORDER BY等操作。 4. 数据源：介绍如何读取和写入各种数据源，如HDFS、Parquet、JSON等。 5. 性能优化：探讨Catalyst优化器的工作原理和性能调优策略...
Spark SQL.xmind.zip
08-12
本资料集详细总结了Spark SQL在大数据处理中的应用，包括数据读取、转换、聚合、JOIN等操作，以及如何在实际项目中部署和调优Spark SQL。通过学习，你将能够掌握Spark SQL的核心概念和技术，为大数据处理和分析打下...
基于spark sql引擎的即席查询服务.zip
最新发布
04-25
1. **性能优化**：Spark SQL支持Code Generation和Catalyst Optimizer，这两个特性能够生成高效的执行计划，并进行查询优化，例如列裁剪、谓词下推、Join重写等，从而提高查询速度。 2. **内存管理**：Spark SQL...
【Spark的五种Join策略解析】
岸芷汀兰
09-12 1817
Spark将参与Join的两张表抽象为流式遍历表(streamIter)和查找表(buildIter)，通常streamIter为大表，buildIter为小表，我们不用担心哪个表为streamIter，哪个表为buildIter，这个spark会根据join语句自动帮我们完成。对于每条来自streamIter的记录，都要去buildIter中查找匹配的记录，所以buildIter一定要是查找性能较优的数据结构。
sparkSql join 关联机制
fanghailiang2016的博客
04-13 946
Join 有 3 种实现机制，分别是 NLJ（Nested Loop Join）、SMJ（Sort Merge Join）和 HJ（Hash Join）
Spark SQL 之 Join 实现
weixin_30258027的博客
09-20 852
原文地址：Spark SQL 之 Join 实现 Spark SQL 之 Join 实现 涂小刚2017-07-19217标签：spark，数据库 Join作为SQL中一个重要语法特性，几乎所有稍微复杂一点的数据分析场景都离不开Join，如今Spark SQL(Dataset/DataFrame)已经成为Spark应用程序开发的主流，作为开发者，我们有必要了解Jo...
SparkSQL大数据实战：揭开Join的神秘面纱
weixin_34306446的博客
06-01 644
本文来自 网易云社区 。   Join操作是数据库和大数据计算中的高级特性，大多数场景都需要进行复杂的Join操作，本文从原理层面介绍了SparkSQL支持的常见Join算法及其适用场景。 Join背景介绍 Join是数据库查询永远绕不开的话题，传统查询SQL技术总体可以分为简单操作（过滤操作-where、排序操作-limit等），聚合操作-groupby以及Join操作等。其中Join操...
【Scala】数据集成（join）
yuxeaotao的博客
06-01 589
数据集成是将多文件或者多数据库中的数据进行合并，然后存放在一个一致的数据存储中 。 数据集成一般通过 join、 union 或 merge 等关键字把两个(或多个)数据集连接在一起， SparkSQL (包括DataFrame)有join方法， Pandas下有merge方法。 数据集成往往需要耗费很多资源 ，尤其是大数据间的集成涉及 shuffle 过程， 有时需要牵涉多个节点，所以 除了数据一致性外，性能问题常常不请自来，需要我们特别留心。 传统数据库 一般是在单机上采用 hash jo
SparkSql Join基本流程(hash join,broadcast join,shuffle hash join ,sort merge join)
foreverlove_ty的博客
09-25 1369
Join 表信息和sql 表A : table_A，字段a1,a2,No 表B : table_B，字段b1,b2,No select a1,a2,b1,b2 from table_A t_A join table_B t_B on t_A.No=t_B.No ; 总体流程 流程的设计 step1 : 遍历table_A 表的所有记录，以过滤条件中的字段No的值进行分组，每个No值对于的A组数据，遍历出来，待用 step2 : 遍历table_B 表的所有记录，同A的处理方式 拿出A组数据去匹配B组数据
SparkSQL的Join的实现方式
junkmachine的博客
09-16 1328
SparkSql笔记
SparkSQL的3种Join实现
微信搜：import_bigdata，大数据领域硬核原创作者
07-06 476
引言Join是SQL语句中的常用操作，良好的表结构能够将数据分散在不同的表中，使其符合某种范式，减少表冗余、更新容错等。而建立表和表之间关系的最佳方式就是Join操作。对...
spark sql inner join
10-12
Spark SQL中的inner join是一种基于两个数据集中的共同字段进行连接的操作，只有在两个数据集中都存在的记录才会被保留下来。具体语法如下： ``` SELECT column_name(s) FROM table1 INNER JOIN table2 ON table1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值