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]].先将邻近的分区合并,避免多余的网络传输。
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|
+-----+-----+----------+
2
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()