使用dataframe解决spark TopN问题：分组、排序、取TopN和join相关问题

package com.profile.main
import org.apache.spark.sql.expressions.Window
import org.apache.spark.sql.functions._

import org.apache.log4j.{Level, Logger}

import com.profile.tools.{DateTools, JdbcTools, LogTools, SparkTools}
import com.dhd.comment.Constant
import com.profile.comment.Comments
 /**
  * 测试类 //使用dataframe解决spark TopN问题：分组、排序、取TopN
  * @author 
  * date 2017-09-27 14:55
  */
object Test {
 
   def main(args: Array[String]): Unit = {
     val sc=SparkTools.getSparkContext

    //设置日志级别，避免输出大量无关的信息
    Logger.getLogger("org.apache.spark").setLevel(Level.WARN)
    Logger.getLogger("org.apache.spark.sql").setLevel(Level.WARN)

     val sqlContext = new org.apache.spark.sql.SQLContext(sc)
     import sqlContext.implicits._
 
    1、使用dataframe解决spark TopN问题
 
     val df = sc.parallelize(Seq(
       (0,"cat26",30.9), (0,"cat13",22.1), (0,"cat95",19.6), (0,"cat105",1.3),
       (1,"cat67",28.5), (1,"cat4",26.8), (1,"cat13",12.6), (1,"cat23",5.3),
       (2,"cat56",39.6), (2,"cat40",29.7), (2,"cat187",27.9), (2,"cat68",9.8),
       (3,"cat8",35.6))).toDF("Hour", "Category", "TotalValue")
 
     df.show
     /*
     +----+--------+----------+
     |Hour|Category|TotalValue|
     +----+--------+----------+
     |   0|   cat26|      30.9|
     |   0|   cat13|      22.1|
     |   0|   cat95|      19.6|
     |   0|  cat105|       1.3|
     |   1|   cat67|      28.5|
     |   1|    cat4|      26.8|
     |   1|   cat13|      12.6|
     |   1|   cat23|       5.3|
     |   2|   cat56|      39.6|
     |   2|   cat40|      29.7|
     |   2|  cat187|      27.9|
     |   2|   cat68|       9.8|
     |   3|    cat8|      35.6|
     +----+--------+----------+
     */
 
/*     val w = Window.partitionBy($"Hour").orderBy($"TotalValue".desc)
     //取Top1
     val dfTop1 = df.withColumn("rn", rowNumber.over(w)).where($"rn" === 1).drop("rn")
     //注意：row_number()在spark1.x版本中为rowNumber(),在2.x版本为row_number()
     //取Top3
     val dfTop3 = df.withColumn("rn", rowNumber.over(w)).where($"rn" <= 3).drop("rn")
 
     dfTop1.show*/
     /*
     +----+--------+----------+
     |Hour|Category|TotalValue|
     +----+--------+----------+
     |   1|   cat67|      28.5|
     |   3|    cat8|      35.6|
     |   2|   cat56|      39.6|
     |   0|   cat26|      30.9|
     +----+--------+----------+
     */
//     dfTop3.show
     /*
     +----+--------+----------+
     |Hour|Category|TotalValue|
     +----+--------+----------+
     |   1|   cat67|      28.5|
     |   1|    cat4|      26.8|
     |   1|   cat13|      12.6|
     |   3|    cat8|      35.6|
     |   2|   cat56|      39.6|
     |   2|   cat40|      29.7|
     |   2|  cat187|      27.9|
     |   0|   cat26|      30.9|
     |   0|   cat13|      22.1|
     |   0|   cat95|      19.6|
     +----+--------+----------+
     */
 
     //使用RDD解决spark TopN问题：分组、排序、取TopN
 
     val rdd1 = sc.parallelize(Seq(
       (0,"cat26",30.9), (0,"cat13",22.1), (0,"cat95",19.6), (0,"cat105",1.3),
       (1,"cat67",28.5), (1,"cat4",26.8), (1,"cat13",12.6), (1,"cat23",5.3),
       (2,"cat56",39.6), (2,"cat40",29.7), (2,"cat187",27.9), (2,"cat68",9.8),
       (3,"cat8",35.6)))
 
     val rdd2 = rdd1.map(x => (x._1,(x._2, x._3))).groupByKey()
     /*
     rdd2.collect
     res9: Array[(Int, Iterable[(String, Double)])] = Array((0,CompactBuffer((cat26,30.9), (cat13,22.1), (cat95,19.6), (cat105,1.3))),
                                                            (1,CompactBuffer((cat67,28.5), (cat4,26.8), (cat13,12.6), (cat23,5.3))),
                                  (2,CompactBuffer((cat56,39.6), (cat40,29.7), (cat187,27.9), (cat68,9.8))),(3,CompactBuffer((cat8,35.6))))
 
     */
     val N_value = 1  //取前3
 
     val rdd3 = rdd2.map( x => {
       val i2 = x._2.toBuffer
       val i2_2 = i2.sortBy(_._2)
       if (i2_2.length > N_value) i2_2.remove(0, (i2_2.length - N_value))
       (x._1, i2_2.toIterable)
     })
 
     /*
      rdd3.collect
     res8: Array[(Int, Iterable[(String, Double)])] = Array((0,ArrayBuffer((cat95,19.6), (cat13,22.1), (cat26,30.9))),
                                                            (1,ArrayBuffer((cat13,12.6), (cat4,26.8), (cat67,28.5))),
                                  (2,ArrayBuffer((cat187,27.9), (cat40,29.7), (cat56,39.6))),(3,ArrayBuffer((cat8,35.6))))
     */
 
     val rdd4 = rdd3.flatMap(x => {
       val y = x._2
       for (w <- y) yield (x._1, w._1, w._2)
     })
 
     rdd4.collect
     /*
     res3: Array[(Int, String, Double)] = Array((0,cat95,19.6), (0,cat13,22.1), (0,cat26,30.9),
                                                (1,cat13,12.6), (1,cat4,26.8), (1,cat67,28.5),
                            (2,cat187,27.9), (2,cat40,29.7), (2,cat56,39.6), (3,cat8,35.6))
     */
 
     rdd4.toDF("Hour", "Category", "TotalValue").show
    /* +----+--------+----------+
     |Hour|Category|TotalValue|
     +----+--------+----------+
     |   0|   cat95|      19.6|
     |   0|   cat13|      22.1|
     |   0|   cat26|      30.9|
     |   2|  cat187|      27.9|
     |   2|   cat40|      29.7|
     |   2|   cat56|      39.6|
     |   1|   cat13|      12.6|
     |   1|    cat4|      26.8|
     |   1|   cat67|      28.5|
     |   3|    cat8|      35.6|
     +----+--------+----------+*/
 
   }

2、下面再来看DataFrame的join操作。

import org.apache.log4j.{Level, Logger}
import org.apache.spark.sql.hive.HiveContext
import org.apache.spark.{SparkConf, SparkContext}

/**
* spark-DataFrame学习记录-[2]解决spark-dataframe的JOIN操作之后产生重复列（Reference '***' is ambiguous问题解决）
*/
object DataFrameSQL_2 {
def main(args: Array[String]) {

val conf = new SparkConf()
conf.setAppName("test").setMaster("local")

val sc = new SparkContext(conf)

//设置日志级别
Logger.getLogger("org.apache.spark").setLevel(Level.WARN)
Logger.getLogger("org.apache.spark.sql").setLevel(Level.WARN)

val sqlContext = new HiveContext(sc)
import sqlContext.implicits._

val df = sc.parallelize(Array(
("one", "A", 1), ("one", "B", 2), ("two", "A", 3), ("two", "B", 4)
)).toDF("key1", "key2", "value")
df.show()
// +----+----+-----+
// |key1|key2|value|
// +----+----+-----+
// | one| A| 1|
// | one| B| 2|
// | two| A| 3|
// | two| B| 4|
// +----+----+-----+

val df2 = sc.parallelize(Array(
("one", "A", 5), ("two", "A", 6)
)).toDF("key1", "key2", "value2")
df2.show()

// +----+----+------+
// |key1|key2|value2|
// +----+----+------+
// | one| A| 5|
// | two| A| 6|
// +----+----+------+

//多列join可以用&&或者and,对其进行JOIN操作之后，发现多产生了KEY1和KEY2这样的两个字段
val joined = df.join(df2, df("key1") === df2("key1") && df("key2") === df2("key2"), "left_outer")

//这样也可

//val joined = df.join(df2, df("key1") === df2("key1") and df("key2") === df2("key2"), "left_outer")
joined.show()

// +----+----+-----+----+----+------+
// |key1|key2|value|key1|key2|value2|
// +----+----+-----+----+----+------+
// | two| A| 3| two| A| 6|
// | two| B| 4|null|null| null|
// | one| A| 1| one| A| 5|
// | one| B| 2|null|null| null|
// +----+----+-----+----+----+------+

假如这两个字段同时存在，那么就会报错，如下：org.apache.spark.sql.AnalysisException: Reference 'key2' is ambiguous
因此，如何在JOIN之后删除列的，可以通过修改JOIN的表达式，完全可以避免这个问题。主要是通过Seq这个对象来实现。

//多列join最好还是使用Seq()

df.join(df2, Seq("key1", "key2"), "left_outer").show()

// +----+----+-----+------+
// |key1|key2|value|value2|
// +----+----+-----+------+
// | two| A| 3| 6|
// | two| B| 4| null|
// | one| A| 1| 5|
// | one| B| 2| null|
// +----+----+-----+------+

//多列列名相同，则可以修改列名
val df22 = df2.withColumnRenamed("key1","k1").withColumnRenamed("key2","k2")

df.join(df22,df("key1") === df22("k1") && df("key2") === df22("k2"), "left_outer").show()
// +----+----+-----+----+----+------+
// |key1|key2|value| k1| k2|value2|
// +----+----+-----+----+----+------+
// | two| A| 3| two| A| 6|
// | two| B| 4|null|null| null|
// | one| A| 1| one| A| 5|
// | one| B| 2|null|null| null|
// +----+----+-----+----+----+------+

sc.stop()

}

3、下面再来看RDD的join操作。

/建立一个基本的键值对RDD，包含ID和名称，其中ID为1、2、3、4
val Arrayrdd1 = sc.makeRDD(Array(("1","Spark"),("2","Hadoop"),("3","Scala"),("4","Java")),2)
 //建立一个行业薪水的键值对RDD，包含ID和薪水，其中ID为1、2、3、5
 val Arrayrdd2 = sc.makeRDD(Array(("1","30K"),("2","15K"),("3","25K"),("5","10K")),2)
 
 println("//下面做Join操作，预期要得到（1,×）、（2,×）、（3,×）")
 val joinRDD=Arrayrdd1.join(Arrayrdd2).collect.foreach(println)
 
 println("//下面做leftOutJoin操作，预期要得到（1,×）、（2,×）、（3,×）、(4,×）")
 val leftJoinRDD=Arrayrdd1.leftOuterJoin(Arrayrdd2).collect.foreach(println)
 println("//下面做rightOutJoin操作，预期要得到（1,×）、（2,×）、（3,×）、(5,×）")
 val rightJoinRDD=Arrayrdd1.rightOuterJoin(Arrayrdd2).collect.foreach(println)

结果输出如下：

和预期的效果一样。

4、DataFrame 的函数

Action 操作
1、 collect() ,返回值是一个数组，返回dataframe集合所有的行
2、 collectAsList() 返回值是一个java类型的数组，返回dataframe集合所有的行
3、 count() 返回一个number类型的，返回dataframe集合的行数
4、 describe(cols: String*) 返回一个通过数学计算的类表值(count, mean, stddev, min, and max)，这个可以传多个参数，中间用逗号分隔，如果有字段为空，那么不参与运算，只这对数值类型的字段。
例如df.describe("age", "height").show()
5、 first() 返回第一行，类型是row类型
6、 head() 返回第一行，类型是row类型
7、 head(n:Int)返回n行，类型是row 类型
8、 show()返回dataframe集合的值默认是20行，返回类型是unit
9、 show(n:Int)返回n行，，返回值类型是unit
10、 table(n:Int) 返回n行，类型是row 类型
dataframe的基本操作
1、 cache()同步数据的内存
2、 columns 返回一个string类型的数组，返回值是所有列的名字
3、 dtypes返回一个string类型的二维数组，返回值是所有列的名字以及类型
4、 explan()打印执行计划物理的
5、 explain(n:Boolean) 输入值为 false 或者true ，返回值是unit 默认是false ，如果输入true 将会打印逻辑的和物理的
6、 isLocal 返回值是Boolean类型，如果允许模式是local返回true 否则返回false
7、 persist(newlevel:StorageLevel) 返回一个dataframe.this.type 输入存储模型类型
8、 printSchema() 打印出字段名称和类型按照树状结构来打印
9、 registerTempTable(tablename:String) 返回Unit ，将df的对象只放在一张表里面，这个表随着对象的删除而删除了
10、 schema 返回structType 类型，将字段名称和类型按照结构体类型返回
11、 toDF()返回一个新的dataframe类型的
12、 toDF(colnames：String*)将参数中的几个字段返回一个新的dataframe类型的，
13、 unpersist() 返回dataframe.this.type 类型，去除模式中的数据
14、 unpersist(blocking:Boolean)返回dataframe.this.type类型 true 和unpersist是一样的作用false 是去除RDD

集成查询：
1、 agg(expers:column*) 返回dataframe类型，同数学计算求值
df.agg(max("age"), avg("salary"))
df.groupBy().agg(max("age"), avg("salary"))
2、 agg(exprs: Map[String, String]) 返回dataframe类型，同数学计算求值 map类型的
df.agg(Map("age" -> "max", "salary" -> "avg"))
df.groupBy().agg(Map("age" -> "max", "salary" -> "avg"))
3、 agg(aggExpr: (String, String), aggExprs: (String, String)*) 返回dataframe类型，同数学计算求值
df.agg(Map("age" -> "max", "salary" -> "avg"))
df.groupBy().agg(Map("age" -> "max", "salary" -> "avg"))
4、 apply(colName: String) 返回column类型，捕获输入进去列的对象
5、 as(alias: String) 返回一个新的dataframe类型，就是原来的一个别名
6、 col(colName: String) 返回column类型，捕获输入进去列的对象
7、 cube(col1: String, cols: String*) 返回一个GroupedData类型，根据某些字段来汇总
8、 distinct 去重返回一个dataframe类型
9、 drop(col: Column) 删除某列返回dataframe类型
10、 dropDuplicates(colNames: Array[String]) 删除相同的列返回一个dataframe
11、 except(other: DataFrame) 返回一个dataframe，返回在当前集合存在的在其他集合不存在的
12、 explode[A, B](inputColumn: String, outputColumn: String)(f: (A) ⇒ TraversableOnce[B])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[B]) 返回值是dataframe类型，这个将一个字段进行更多行的拆分
df.explode("name","names") {name :String=> name.split(" ")}.show();
将name字段根据空格来拆分，拆分的字段放在names里面
13、 filter(conditionExpr: String): 刷选部分数据，返回dataframe类型 df.filter("age>10").show(); df.filter(df("age")>10).show(); df.where(df("age")>10).show(); 都可以
14、 groupBy(col1: String, cols: String*) 根据某写字段来汇总返回groupedate类型 df.groupBy("age").agg(Map("age" ->"count")).show();df.groupBy("age").avg().show();都可以
15、 intersect(other: DataFrame) 返回一个dataframe，在2个dataframe都存在的元素
16、 join(right: DataFrame, joinExprs: Column, joinType: String)
一个是关联的dataframe，第二个关联的条件，第三个关联的类型：inner, outer, left_outer, right_outer, leftsemi
df.join(ds,df("name")===ds("name") and df("age")===ds("age"),"outer").show();
17、 limit(n: Int) 返回dataframe类型去n 条数据出来
18、 na: DataFrameNaFunctions ，可以调用dataframenafunctions的功能区做过滤 df.na.drop().show(); 删除为空的行
19、 orderBy(sortExprs: Column*) 做alise排序
20、 select(cols:string*) dataframe 做字段的刷选 df.select($"colA", $"colB" + 1)
21、 selectExpr(exprs: String*) 做字段的刷选 df.selectExpr("name","name as names","upper(name)","age+1").show();
22、 sort(sortExprs: Column*) 排序 df.sort(df("age").desc).show(); 默认是asc
23、 unionAll(other:Dataframe) 合并 df.unionAll(ds).show();
24、 withColumnRenamed(existingName: String, newName: String) 修改列表 df.withColumnRenamed("name","names").show();
25、 withColumn(colName: String, col: Column) 增加一列 df.withColumn("aa",df("name")).show();

使用dataframe解决spark TopN问题：分组、排序、取TopN和join相关问题的更多相关文章

hive 分组排序，topN
hive 分组排序,topN 语法格式:row_number() OVER (partition by COL1 order by COL2 desc ) rankpartition by:类似hiv ...
mysql 分组排序取最值
查各个用户下单最早的一条记录查各个用户下单最早的前两条记录查各个用户第二次下单的记录一.建表填数据: SET NAMES utf8mb4; -- 取消外键约束 ; -- ------------ ...
mysql分组排序取最大值所在行，类似hive中row_number() over partition by
如下图, 计划实现 :按照 parent_code 分组, 取组中code最大值所在的整条记录,如红色部分.(类似hive中: row_number() over(partition by)) sel ...
hive分组排序取top N
pig可以轻松获取TOP n.书上有例子 hive中比较麻烦,没有直接实现的函数,可以写udf实现.还有个比较简单的实现方法: 用row_number,生成排名序列号.然后外部分组后按这个序列号多虑, ...
[转] 分组排序取前N条记录以及生成自动数字序列，类似group by后 limit
前言: 同事的业务场景是,按照cid.author分组,再按照id倒叙,取出前2条记录出来. oracle里面可以通过row_number() OVER (PARTITIO ...
SQL之分组排序取top n
转自:http://blog.csdn.net/wguangliang/article/details/50167283 要求:按照课程分组,查找每个课程最高的两个成绩. 数据文件如下: 第一列no为 ...
关于oracle分组排序取值的问题
按照某字段分组某字段排序然后取出该分组中排第1条数据(每组只取一条) SELECT* FROM( SELECT a.*,row_number() over(partition by ORI_FE ...
Oracle 中分组排序取值的问题
整理一下排序: 建表语句:create table EXAM( name VARCHAR2(32), subject VARCHAR2(32), score INTEGER)数据:IN ...
sql分组排序取top
写法1: use anypay; select tr.* from (select task_code, max(created_at) as cal from task_log group by t ...

随机推荐

<Android 基础（七）> DrawerLayout and NavigationView
介绍 DrawerLayout是Support Library包中实现了侧滑菜单效果的控件 android.support.v4.widget.DrawerLayout NavigationView是 ...
Azure杯年会Cosplay大赛，速来围观！
又是一年年会时,正值各家公司红人纷纷登场之际,Azure 自然也不会缺席.我们今年的主题是:Azure 杯年会 Cosplay,秀出你最爱的角色! 在过去的一年中,Azure 智能云取得了长足的发展, ...
Azure本月最新活动，速度Mark！！
缤纷五月,翠色盈盈,风光如画,小编在这里给大家汇总了这个多彩五月最新的活动合集.我们一切都准备好了,就等你来参加了~ 首先最重磅的当然是新一届的全球微软开发者大会! 有吃有喝有 Build,5 月 ...
TP5.1：依赖注入、绑定一个类到容器里、绑定一个闭包到容器中
依赖注入 1.在application中创建一个文件夹,名字为commom,commom文件夹中创建被注入文件夹,在被注入文件夹中创建一个名为demo.php的文件 2.在demo.php中输入: 3 ...
graphql 数据增删改查分页及关联操作（三）
说明: 接第二篇文章,代码也是在第二篇文章之上本文只是针对mondodb来操作一.添加相关的包 yarn add Mongoose 二.初始化Mongodb 修改server.ts 导入 impo ...
运行在 Android 系统上的完整 Linux -- Termux
Termux 可以在安卓系统上搭建一个完整的linux 环境,类似于 cygwin 并非linux 虚拟机,整个安装包只有几百KB 刚开始觉得这东西的命令行很难用,看了官方介绍后才发现它原来有许多 ...
解决robotframework安装时提示wxPython not found问题
背景:想把现在pc的项目做成关键字的形式,可以让功能测试人员也参与到自动化测试中,于是就找到robotframework这个框架,试用下怎么样,在安装时就遇到很多问题,安装的帖子有很多,很详细,如:h ...
Uva 10806 来回最短路，不重复，MCMF
题目链接:https://uva.onlinejudge.org/external/108/10806.pdf 题意:无向图,从1到n来回的最短路,不走重复路. 分析:可以考虑为1到n的流量为2时的最 ...
iOS 有些库只能在真机上运行，不能在模拟器上运行的解决方式
在开发中,多少肯定会用到第三方的东西,或许大家也和我一样遇到到这样的情况,有些库正好适合自己的需求,但是这个库却只支持真机上运行,在模拟器上编译却不通过, 一般情况下,.a静态包,你刚刚导入的时候,不 ...
Node.js 的初体验
例子1: 1.首先第一步 :要下载 node.js. 官网上可以下载下载完后,是这个玩意. 2. 打开 node.js ,然后输入 // 引入http模块 var http = require( ...

使用dataframe解决spark TopN问题：分组、排序、取TopN和join相关问题

使用dataframe解决spark TopN问题：分组、排序、取TopN和join相关问题的更多相关文章

随机推荐

热门专题