spark算子之DataFrame和DataSet

前言

传统的RDD相对于mapreduce和storm提供了丰富强大的算子。在spark慢慢步入DataFrame到DataSet的今天，在算子的类型基本不变的情况下，这两个数据集提供了更为强大的的功能。但也有些功能暂时无法使用。比如reduceByKey,在DataFrame和DataSet里是没有的。所以觉得有必要做一些梳理。

准备工作

测试数据，json格式：

{ "DEVICENAME": "test1", "LID": 170501310, "ADDRESS": "xxxx", "ID": 230001160 }
{ "DEVICENAME": "test2", "LID": 170501311, "ADDRESS": "xxxx", "ID": 230001161 }
{ "DEVICENAME": "test3", "LID": 170501310, "ADDRESS": "xxxx", "ID": 230001160 }
{ "DEVICENAME": "test4", "LID": 170501310, "ADDRESS": "xxxx", "ID": 230001160 }
{ "DEVICENAME": "test5", "LID": 170501310, "ADDRESS": "xxxx", "ID": 230001160 }

分别转化为DataFrame和DataSet，然后结合spark 算子之RDD一文中所罗列的主要算子，进行一一对比。

    val session = SparkSession

    .builder()

    .appName("test")

    .master("local[*]")

    .getOrCreate()

    import session.implicits._

    val df = session.read.json(path)

    val ds = session.read.json(path).as[data] 

    df.show()

    ds.show()

    df.printSchema()

    ds.printSchema()

//

val path: String = "D:/test.txt";
case class data(DEVICENAME: String, LID: BigInt, ADDRESS: String, ID: BigInt)

得到的数据：

+-------+----------+---------+---------+
|ADDRESS|DEVICENAME| ID| LID|
+-------+----------+---------+---------+
| xxxx| test1|230001160|170501310|
| xxxx| test2|230001161|170501311|
| xxxx| test3|230001160|170501310|
| xxxx| test4|230001160|170501310|
| xxxx| test5|230001160|170501310|
+-------+----------+---------+---------+

结构：

root
|-- ADDRESS: string (nullable = true)
|-- DEVICENAME: string (nullable = true)
|-- ID: long (nullable = true)
|-- LID: long (nullable = true)

算子对比

filter

相比于RDD的filter算子，df和ds均提供了针对属性，表达式，自定义函数等过滤表达式。还提供了基本等价于filter的where算子。

  def filter(session: SparkSession) {

    import session.implicits._

    val df = session.read.json(path)

    val ds = session.read.json(path).as[data]

    df.filter(_.getLong(2) > 0).show()

    df.filter($"ID" > 0).show()

    df.filter("DEVICENAME == 'test1'").show()

    df.where("ID > 230001160").show()

    df.where($"ID" > 230001160).show()

    df.filter($"ID" > 0 || $"ID" < 0)

    ds.filter(_.ID > 0).show()

    ds.filter($"ID" > 0 || $"ID" > 0).show()

    ds.filter("DEVICENAME == 'test1'").show()

    ds.where("ID > 230001160").show()

    ds.filter(x => {

      x.ID > 230001160 && x.LID > 170501311

    }).show()

  }

针对虚拟列的过滤，类似于having，但必须是计算完成的列：

    df.groupBy("ID").filter($"avg(ID)" > 0).show()//编译不通过

    df.groupBy("ID").avg("LID").filter($"avg(ID)" > 0).show()//错误

    df.groupBy("ID").avg("ID").filter($"avg(ID)" > 0).show()

union

使用上并没有区别。但ds和df的union算子有所优化，效率更高。RDD直接将两个RDD相加。而ds和df则中间调用了CombineUnions函数，关键字combine，Combines all adjacent [[Union]] operators into a single [[Union]].先将邻近的分区合并，避免多余的网络传输。

spark算子之DataFrame和DataSet

intersect except

求交集差集

rdd intersection subtract

df/ds intersect except

    import session.implicits._

    val df = session.read.json(path)

    val ds = session.read.json(path).as[data]

    val df2 = df.filter($"ID" > 230001160)

    df.intersect(df2).show()

    println("===================")

    df.except(df2).show()

结果：

+-------+----------+---------+---------+
|ADDRESS|DEVICENAME| ID| LID|
+-------+----------+---------+---------+
| xxxx| test2|230001161|170501311|

===================

+-------+----------+---------+---------+
|ADDRESS|DEVICENAME| ID| LID|
+-------+----------+---------+---------+
| xxxx| test3|230001160|170501310|
| xxxx| test1|230001160|170501310|
| xxxx| test5|230001160|170501310|
| xxxx| test4|230001160|170501310|
+-------+----------+---------+---------+

distinct dropDuplicates

去重。df/ds提供了新的去重算子dropDuplicates。传统的distinct 只能对元素全量去重，dropDuplicates可以针对元素的某一个或者多个属性进行去重。

    import session.implicits._

    val df = session.read.json(path)

    val ds = session.read.json(path).as[data]

    df.distinct().show()

    df.dropDuplicates().show()

    val array = Array("ID","LID")

    val seq = Seq("ID","LID")

    df.dropDuplicates("ID","LID").show()

    df.dropDuplicates(array).show()

    df.dropDuplicates(seq).show()

select selectExpr drop

选择器。select可以选择某列或某几列，selectExpr 可以使用条件表达式选择某列或某几列。drop 可以选择屏蔽某列或某几列。

    import session.implicits._

    val df = session.read.json(path)

    val ds = session.read.json(path).as[data]

    df.drop("ID").show()//删掉ID这一列

    df.select("ID", "ADDRESS").show()//选择ID，ADDRESS

    df.select($"ID", $"ADDRESS",$"ADDRESS" as "NEWNAME").show()//将ADDRESS重命名

    ds.select($"ID", $"ID" + 1 as "NEWNAME").show()//将ID进行计算并重命名

    ds.selectExpr("ID", "ID + 1 as NEWNAME","abs(ID - 230001165)").show()

withColumn withColumnRenamed

withColumn新增一个列，但是有一个局限性，是当前df/ds中，且存在的列。既然是新增列，当然列名不能相同。

withColumnRenamed 相当于重命名。

两个功能都显得有些鸡肋。

    import session.implicits._

    val df = session.read.json(path)

    val ds = session.read.json(path).as[data]

    val rowDF = session.sparkContext.parallelize(1 to df.count().toInt).toDF("ID")

    df.withColumn("ID",df("ID") + 1).show()//名字相同，等于只做+1操作

    df.withColumn("ID2",df("ID")).show()//值相同，列名不同，新增一列

    df.withColumn("ID3",df("ID")+1).show()//值相同，列名不同，新增一列

    df.withColumn("ID",rowDF("ID")).show()//报错

    df.withColumnRenamed("ID", "NEWID").show()

groupBy

groupBy与RDD的groupBy区别较大。前面讲到，groupBy对(K,V)对的RDD经过处理后，变成 [key,{key:value1,key:value2}]。而df/ds经过groupBy操作后，变成了RelationalGroupedDataset对象。必须经过后续操作，才能继续使用。后续操作具体主是聚合函数。

groupBy本意就是分组，那么分组过后进行聚合显得当然是合情合理。

如图所示，官方提供了两种方式。第一种是单个的聚合函数。第二种是多个聚合函数。

    import session.implicits._

    val df = session.read.json(path)

    val ds = session.read.json(path).as[data]

    df.groupBy("LID").avg("ID").show()// select LID,AVG(ID) FROM TABLE 单个函数单个字段

    df.groupBy("LID").avg("ID","LID").show()//单个函数多个字段

   //其它聚合函数

    df.groupBy("LID").avg("ID").show() //平均值

    df.groupBy("LID").mean("ID").show()//平均值

    df.groupBy("LID").max("ID").show()

    df.groupBy("LID").count().show()

    df.groupBy("LID").min("ID").show()

    df.groupBy("LID").sum("ID").show()

   //多个聚合函数

    df.groupBy("LID").agg(Map(

      "LID" -> "max",

      "ID" -> "avg")).show()

聚合函数都是一些常规的东西，跟关系型数据聚合函数差不多。需要注意的是，求平均值，提供了两个函数：avg和mean，从源码上来看，功能是一样的。还有一个比较特殊的函数是pivot。

这个函数感觉是为报表而生。它可以将列值作为列名在横坐标上展示。在一定程度上，使报表展示更加清晰。

展示一个具体的例子：

测试数据：

城市销售额人数月份

{ "city": "重庆", "sales": 170501, "nums": 10,"month":1}
{ "city": "四川", "sales": 170501, "nums": 12,"month":1}
{ "city": "重庆", "sales": 170502, "nums": 13,"month":2}
{ "city": "重庆", "sales": 170504, "nums": 9,"month":3}
{ "city": "四川", "sales": 170505, "nums": 20,"month":2}
{ "city": "四川", "sales": 170506, "nums": 20,"month":3}

背景需求：求每个城市每个月的平均销售额。

实现方式：

1 传统方式 SELECT city,month,avg(sales) sales FROM TABLE GROUP BY city,month

import session.implicits._

val df = session.read.json("D:/test2.txt").as[test]

df.groupBy("city","month").avg("sales").show()

case class test(city:String, sales:Long,nums:BigInt,month:BigInt)

显示结果：

+-----+-----+----------+
| city|month|avg(sales)|
+-----+-----+----------+
| 四川| 2 | 170505.0|
| 重庆| 3 | 170504.0|
| 四川| 1 | 170501.0|
| 四川| 3 | 170506.0|
| 重庆| 1 | 170501.0|
| 重庆| 2 | 170502.0|
+-----+-----+----------+

 df.groupBy("city").pivot("month").avg("sales").show()

显示结果：

+-----+--------+--------+--------+
| city | 1 | 2 | 3 |
+-----+--------+--------+--------+
| 重庆|170501.0|170502.0|170504.0|
| 四川|170501.0|170505.0|170506.0|
+-----+--------+--------+--------+

当然，还可以选择哪些值作为列展示

df.groupBy("city").pivot("month", Seq("1","2")).avg("sales").show()

目前尚不支持类似excel一样的两种以上的表头。两种展示方式，孰优孰劣，不置评述。但至少提供了另一种选择。

orderBy sort

df/df已经摒弃了sortBykey等函数。两者有什么区别呢？没有区别。

**

   * Returns a new Dataset sorted by the given expressions.

   * This is an alias of the `sort` function.

   *

   * @group typedrel

   * @since 2.0.0

   */

  @scala.annotation.varargs

  def orderBy(sortExprs: Column*): Dataset[T] = sort(sortExprs : _*)

 df.groupBy("ID").agg(Map("ID" -> "max", "LID" -> "avg","ADDRESS" -> "max")).orderBy($"ID".desc).show()

 df.groupBy("ID").agg(Map("ID" -> "max", "LID" -> "avg","ADDRESS" -> "max")).sort($"ID".desc).show()

cube rollup

类似于的groupby。

cube是做幂集操作。*上对幂集的解释。包括空集

Example[edit]

If S is the set {x, y, z}, then the subsets of S are

{} (also denoted {\displaystyle \varnothing } or {\displaystyle \emptyset }, the empty set or the null set)

{x}

{y}

{z}

{x, y}

{x, z}

{y, z}

{x, y, z}

and hence the power set of S is {{}, {x}, {y}, {z}, {x, y}, {x, z}, {y, z}, {x, y, z}}.

    df.cube("ID", "LID")

    session.sql("select  ID,LID FROM TABLE group by ID,LID with cube").show()

    //GROUP BY ID,LID

    //GROUP BY LID,ID

    //GROUP BY LID

    //GROUP BY ID

rollup,包括空集

    df.cube("ID", "LID")

    session.sql("select  ID,LID FROM TABLE group by ID,LID with rollup").show()

    //GROUP BY ID,LID

    //GROUP BY ID

stat

科学和数学函数

join

相比RDD，df/ds的join算子增加了连接条件。

    val df = session.read.json(path)

    val ds = session.read.json(path).as[data]

    val df2 = session.read.json("").as[data]

    //两张表关联字段名相同的情况下

//    df.join(df2,"LID").show()

    //两张表关联字段名不相同的情况下

//    df2.join(df,df2("LID2") === df("LID")).show()

//     df2.join(df,df2("LID2") === df("LID") && df2("ID") === df("ID")).show()

     df2.join(df,Seq("LID","ID"),"inner").show()

秒客网

spark算子之DataFrame和DataSet

Example[edit]

相关文章