比较两个Spark数据帧

时间：2017-08-07 18:16:23

标签： apache-spark apache-spark-sql

Spark数据帧1 - ：

+------+-------+---------+----+---+-------+
|city  |product|date     |sale|exp|wastage|
+------+-------+---------+----+---+-------+
|city 1|prod 1 |9/29/2017|358 |975|193    |
|city 1|prod 2 |8/25/2017|50  |687|201    |
|city 1|prod 3 |9/9/2017 |236 |431|169    |
|city 2|prod 1 |9/28/2017|358 |975|193    |
|city 2|prod 2 |8/24/2017|50  |687|201    |
|city 3|prod 3 |9/8/2017 |236 |431|169    |
+------+-------+---------+----+---+-------+

Spark数据帧2 - ：

+------+-------+---------+----+---+-------+
|city  |product|date     |sale|exp|wastage|
+------+-------+---------+----+---+-------+
|city 1|prod 1 |9/29/2017|358 |975|193    |
|city 1|prod 2 |8/25/2017|50  |687|201    |
|city 1|prod 3 |9/9/2017 |230 |430|160    |
|city 1|prod 4 |9/27/2017|350 |90 |190    |
|city 2|prod 2 |8/24/2017|50  |687|201    |
|city 3|prod 3 |9/8/2017 |236 |431|169    |
|city 3|prod 4 |9/18/2017|230 |431|169    |
+------+-------+---------+----+---+-------+

请查看上面给出的火花数据帧1和火花数据帧2的以下条件的火花数据帧，

  1. 删除记录
  2. 新纪录
  3. 无变化的记录

  4. 记录更改

    此处的重点是“城市”，“产品”，“日期”。

    5. 我们需要解决方案而不使用Spark SQL。

7 个答案:

答案 0 :(得分：6)

一种可扩展且简单的方法是用spark-extension来区分两个DataFrame：

import uk.co.gresearch.spark.diff._

df1.diff(df2, "city", "product", "date").show

+----+------+-------+----------+---------+----------+--------+---------+------------+-------------+
|diff|  city|product|      date|left_sale|right_sale|left_exp|right_exp|left_wastage|right_wastage|
+----+------+-------+----------+---------+----------+--------+---------+------------+-------------+
|   N|city 1|prod 2 |2017-08-25|       50|        50|     687|      687|         201|          201|
|   C|city 1|prod 3 |2017-09-09|      236|       230|     431|      430|         169|          160|
|   I|city 3|prod 4 |2017-09-18|     null|       230|    null|      431|        null|          169|
|   N|city 3|prod 3 |2017-09-08|      236|       236|     431|      431|         169|          169|
|   D|city 2|prod 1 |2017-09-28|      358|      null|     975|     null|         193|         null|
|   I|city 1|prod 4 |2017-09-27|     null|       350|    null|       90|        null|          190|
|   N|city 1|prod 1 |2017-09-29|      358|       358|     975|      975|         193|          193|
|   N|city 2|prod 2 |2017-08-24|       50|        50|     687|      687|         201|          201|
+----+------+-------+----------+---------+----------+--------+---------+------------+-------------+

它标识我插入， C 挂起， D 删除和u N 更改的行。

答案 1 :(得分：4)

我不确定找到已删除和修改的记录，但您可以使用except函数来获取差异

df2.except(df1)

这将返回已在dataframe2中添加或修改的行或带有更改的记录。 输出：

+------+-------+---------+----+---+-------+
|  city|product|     date|sale|exp|wastage|
+------+-------+---------+----+---+-------+
|city 3| prod 4|9/18/2017| 230|431|    169|
|city 1| prod 4|9/27/2017| 350| 90|    190|
|city 1| prod 3|9/9/2017 | 230|430|    160|
+------+-------+---------+----+---+-------+

您还可以尝试使用连接和过滤来获取已更改和未更改的数据

df1.join(df2, Seq("city","product", "date"), "left").show(false)
df1.join(df2, Seq("city","product", "date"), "right").show(false)

希望这有帮助！

答案 2 :(得分：2)

查看MegaSparkDiff它是GitHub上的一个开源项目，有助于比较数据帧..该项目尚未在maven中心发布，但您可以查看比较2个数据帧的SparkCompare scala类

以下代码段将为您提供2个数据框，其中一个包含inLeftButNotInRight，另一个包含InRightButNotInLeft。

如果你在两者之间进行JOIN，那么你可以应用一些逻辑来识别丢失的主键（如果可能），然后这些键将构成已删除的记录。

我们正在努力添加您在项目中寻找的用例。 https://github.com/FINRAOS/MegaSparkDiff

https://github.com/FINRAOS/MegaSparkDiff/blob/master/src/main/scala/org/finra/msd/sparkcompare/SparkCompare.scala 

private def compareSchemaDataFrames(left: DataFrame , leftViewName: String
                              , right: DataFrame , rightViewName: String) :Pair[DataFrame, DataFrame] = {
    //make sure that column names match in both dataFrames
    if (!left.columns.sameElements(right.columns))
      {
        println("column names were different")
        throw new Exception("Column Names Did Not Match")
      }

    val leftCols = left.columns.mkString(",")
    val rightCols = right.columns.mkString(",")

    //group by all columns in both data frames
    val groupedLeft = left.sqlContext.sql("select " + leftCols + " , count(*) as recordRepeatCount from " +  leftViewName + " group by " + leftCols )
    val groupedRight = left.sqlContext.sql("select " + rightCols + " , count(*) as recordRepeatCount from " +  rightViewName + " group by " + rightCols )

    //do the except/subtract command
    val inLnotinR = groupedLeft.except(groupedRight).toDF()
    val inRnotinL = groupedRight.except(groupedLeft).toDF()

    return new ImmutablePair[DataFrame, DataFrame](inLnotinR, inRnotinL)
  }

答案 3 :(得分：0)

使用Spark不同的联接类型似乎是计算行上的删除，添加和更新的关键。

此问题说明了不同的联接类型，具体取决于您要实现的目标： What are the various join types in Spark?

答案 4 :(得分：0)

请参阅下面的实用程序函数，该函数用于按照以下条件比较两个数据框

  1. 列长
  2. 记录数
  3. 逐列比较所有记录

任务三是通过使用记录中所有列的串联哈希来完成的。

def verifyMatchAndSaveSignatureDifferences(oldDF: DataFrame, newDF: DataFrame, pkColumn: String) : Long = {
  assert(oldDF.columns.length == newDF.columns.length, s"column lengths don't match")
  assert(oldDF.count == newDF.count, s"record count don't match")

  def createHashColumn(df: DataFrame) : Column = {
     val colArr = df.columns
     md5(concat_ws("", (colArr.map(col(_))) : _*))
  }

  val newSigDF = newDF.select(col(pkColumn), createHashColumn(newDF).as("signature_new"))
  val oldSigDF = oldDF.select(col(pkColumn), createHashColumn(oldDF).as("signature"))

  val joinDF = newSigDF.join(oldSigDF, newSigDF("pkColumn") === oldSigDF("pkColumn")).where($"signature" !== $"signature_new").cache

  val diff = joinDF.count
  //write out any recorsd that don't match
  if (diff > 0)
     joinDF.write.saveAsTable("signature_table")

  joinDF.unpersist()

  diff
}

如果该方法返回0，则这两个数据帧在所有其他数据上都完全相同，在默认配置单元hive中一个名为signature_table的表将包含所有在这两者中不同的记录。

希望这会有所帮助。

答案 5 :(得分：0)

假设我们有两个 DataFrame，z1 和 z1。选项 1 适用于没有重复的行。您可以在 spark-shell 中尝试这些。

  • 选项 1：直接做除外

val inZ1NotInZ2 = z1.except(z2).toDF()
val inZ2NotInZ1 = z2.except(z1).toDF()

inZ1NotInZ2.show
inZ2NotInZ1.show
  • 选项 2：使用 GroupBy（对于具有重复行的 DataFrame）
val z1Grouped = z1.groupBy(z1.columns.map(c => z1(c)).toSeq : _*).count().withColumnRenamed("count", "recordRepeatCount")
val z2Grouped = z2.groupBy(z2.columns.map(c => z2(c)).toSeq : _*).count().withColumnRenamed("count", "recordRepeatCount")

val inZ1NotInZ2 = z1Grouped.except(z2Grouped).toDF()
val inZ2NotInZ1 = z2Grouped.except(z1Grouped).toDF()
  • 选项 3，使用 exceptAll，它也适用于具有重复行的数据
// Source Code: https://github.com/apache/spark/blob/50538600ec/sql/core/src/main/scala/org/apache/spark/sql/Dataset.scala#L2029
val inZ1NotInZ2 = z1.exceptAll(z2).toDF()
val inZ2NotInZ1 = z2.exceptAll(z1).toDF()

答案 6 :(得分：0)

Spark 版本：2.2.0

同时使用except和left反连接

df2.except(df1) 将类似于：

<头>
城市 产品 日期 销售 exp 浪费
城市 3 产​​品 4 9/18/2017 230 431 169
城市 1 产​​品 4 9/27/2017 350 90 190
城市 1 产​​品 3 9/9/2017 230 430 160

正如koiralo所说，但是删除的item'city 2 prod 1'丢失了，所以我们需要left anti join（或left join with filters）：

select * from df1 left anti join df2 on df1.city=df2.city and df1.product=df2.product

然后将df2.except(df1)和left anti join的结果合并

但是我没有在大数据集上测试左反连接的性能

PS：如果你的spark版本超过2.4，使用spark-extension会更方便

相关问题
最新问题