spark中dataframe，dataset，sparksql中的各种用法

最新推荐文章于 2023-01-03 16:51:26 发布
cclovezbf
最新推荐文章于 2023-01-03 16:51:26 发布
阅读量450
点赞数
分类专栏： spark 文章标签： df ds rdd
本文链接：https://blog.csdn.net/cclovezbf/article/details/103816002
版权
spark 专栏收录该内容
17 篇文章 1 订阅
订阅专栏
package org.apache.spark.examples


import DsFilter.Student
import org.apache.spark.{HashPartitioner, Partitioner}
import org.apache.spark.broadcast.Broadcast
import org.apache.spark.rdd.RDD
import org.apache.spark.sql._
import org.apache.spark.sql.types.StructType

object DsFilter {

  def main(args: Array[String]): Unit = {
    System.setProperty("hadoop.home.dir","E:\\office\\hadoop-2.7.1") //如果读取不到环境变量，设置这个
    val spark: SparkSession = SparkSession
      .builder
      .appName("Spark Examples")
      .master("local[*]") //我的机器是4core
      .getOrCreate()

    var list = Seq[Student]()
    for (i <- 1 to 10){
      list= list :+ Student("cc",i,i.toString)
      list= list :+ Student("chi",i,i.toString)
      list= list:+Student("zbf",i,i.toString)
      list= list:+Student("dd",i,i.toString)
    }//创建40条记录
    val userList=Seq(User("cc",true),User("chi",true),User("dd",false),User("zbf",false))
    val rdd: RDD[Student] = spark.sparkContext.parallelize(list) //parallelize(list , numpartition) 这里可以指定分区数,默认是hash分区,既然是hash分区那么可能分配不均
    val partitions: Long = rdd.count()
    println(s"rdd中的数据量=${partitions}") // 40
    printRDDPartition(rdd)
    /**
     * 第0个分区-------(cc,1,1),(chi,1,1),(zbf,1,1),(dd,1,1),(cc,2,2),(chi,2,2),(zbf,2,2),(dd,2,2),(cc,3,3),(chi,3,3)
     * 第1个分区-------(zbf,3,3),(dd,3,3),(cc,4,4),(chi,4,4),(zbf,4,4),(dd,4,4),(cc,5,5),(chi,5,5),(zbf,5,5),(dd,5,5)
     * 第2个分区-------(cc,6,6),(chi,6,6),(zbf,6,6),(dd,6,6),(cc,7,7),(chi,7,7),(zbf,7,7),(dd,7,7),(cc,8,8),(chi,8,8)
     * 第3个分区-------(zbf,8,8),(dd,8,8),(cc,9,9),(chi,9,9),(zbf,9,9),(dd,9,9),(cc,10,10),(chi,10,10),(zbf,10,10),(dd,10,10)
     */
    val studentName: Array[String] = rdd.map(_.name).collect().distinct //获取有多少个name, 目前是四个
    val hashparitionedRddTurple: RDD[(String, Student)] = rdd.map(x=>(x.name,x)).partitionBy(new HashPartitioner(4))
    val hashpartitonedRDd: RDD[Student] = hashparitionedRddTurple.map(_._2) //里面的元素还是那40条 但是存放位置不一样了
    println("hashpartitonedRDd分区后的数据")
    printRDDPartition(hashpartitonedRDd)
    /**
     * 第0个分区-------(cc,1,1),(chi,1,1),(dd,1,1),(cc,2,2),(chi,2,2),(dd,2,2),(cc,3,3),(chi,3,3),(dd,3,3),(cc,4,4),(chi,4,4),(dd,4,4),(cc,5,5),(chi,5,5),(dd,5,5),(cc,6,6),(chi,6,6),(dd,6,6),(cc,7,7),(chi,7,7),(dd,7,7),(cc,8,8),(chi,8,8),(dd,8,8),(cc,9,9),(chi,9,9),(dd,9,9),(cc,10,10),(chi,10,10),(dd,10,10)
     * 第1个分区-------
     * 第2个分区-------(zbf,1,1),(zbf,2,2),(zbf,3,3),(zbf,4,4),(zbf,5,5),(zbf,6,6),(zbf,7,7),(zbf,8,8),(zbf,9,9),(zbf,10,10)
     * 第3个分区-------
     */
    val paritionedRddTurple: RDD[(String, Student)] = rdd.map(x=>(x.name,x)).partitionBy(new MyPartition(studentName))
    val partitonedRDd: RDD[Student] = paritionedRddTurple.map(_._2) //里面的元素还是那40条 但是存放位置不一样了
    println("rdd分区后的数据")
    printRDDPartition(partitonedRDd)
    /**
     * 第0个分区-------(cc,1,1),(cc,2,2),(cc,3,3),(cc,4,4),(cc,5,5),(cc,6,6),(cc,7,7),(cc,8,8),(cc,9,9),(cc,10,10)
     * 第1个分区-------(chi,1,1),(chi,2,2),(chi,3,3),(chi,4,4),(chi,5,5),(chi,6,6),(chi,7,7),(chi,8,8),(chi,9,9),(chi,10,10)
     * 第2个分区-------(zbf,1,1),(zbf,2,2),(zbf,3,3),(zbf,4,4),(zbf,5,5),(zbf,6,6),(zbf,7,7),(zbf,8,8),(zbf,9,9),(zbf,10,10)
     * 第3个分区-------(dd,1,1),(dd,2,2),(dd,3,3),(dd,4,4),(dd,5,5),(dd,6,6),(dd,7,7),(dd,8,8),(dd,9,9),(dd,10,10)
     */
    /*   rdd中的数据其实看似有序，但是对于我们来说大部分无序,所以需要我们自己定义分区器,
    自定义分区的作用：一个分区做一件事,
                    ①比如我要输出文件有序第一个文件是cc第二个是chi第三个是zbf,现在4个分区最后输出文件是4个
                    ②每个分区数据有不同的逻辑 比如我想cc的age+1,chi的age+2
                    rdd.foreachPartition(iter=>{
                        val list: List[Student] = iter.toList
                       if(list.head.name.equals("cc")){}
                       if(list.head.name.equals("chi")){}
                    })
                    // 下面是lowb方法，先过滤出需要的rdd然后再处理
                    rdd.filter(_.name.equals("cc"))
                    rdd.filter(_.name.equals("chi"))
                    多嘴说一句
                    rdd.foreachPartition作用 比如我现在rdd是4个分区,数据是40个
                    如果涉及到数据库连接建议用foreaparition 此时只需要创建4个连接,每个连接对应一个分区
                    如果用foreach 则需要创建40个连接 每个连接对应一条数据
                    有人会说我在最外面建立一个就好对应整个数据集合，不可能,这个涉及到序列化问题,简单来说上面两个连接都是在worker端建立
                    //driver端
                    建立连接 对应整个数据 然后driver到work相当于两个世界,要把driver的数据到work相当于快递要打包(序列化),目前连接不能序列化
                    foreach/partition(
                    //work端
                    //建立连接 对应一条数据或者一个分区
                    )
    */

    import spark.implicits._   //导入隐世转换,因为rdd是org.apache.spark.rdd包下的本身没有toDF方法,所以导入spark.implicits._包,才有rdd.todf
    val ds: Dataset[User] = spark.createDataset(userList)
    val rddToDf: DataFrame = rdd.toDF() //注意 rdd中是student样例类所以可以直接转化为,如果是List(Seq("cc",1,"1"),Seq("cc",2,"2")) 要toDF("name","age","score")
    rddToDf.show(5) //action算子,自己测试时可以用,实际生产个人不建议频繁用
    /**
     * +----+---+-----+
     * |name|age|score|
     * +----+---+-----+
     * |  cc|  1|    1|
     * | chi|  1|    1|
     * | zbf|  1|    1|
     * |  dd|  1|    1|
     * |  cc|  2|    2|
     * +----+---+-----+
     * only showing top 5 rows
     */
    //df的repartition
    val dfPartitionedRdd: RDD[Student] = rddToDf.repartition(4,new Column("name")).rdd.map(x=>Student(x.getString(0),x.getInt(1),x.getString(2)))
    println("rdd转化成df后repartition后每个rdd分区")
    printRDDPartition(dfPartitionedRdd)
    /**  说明下,这里df.repartition 根据name分区，是根据name 的hashcode值,以上述为例
     * cc.hashcode=1 chi.hashcode=1 dd.hashcode=0 zbf.hashcode=3
     * 取余后 dd分配到0分区,cc和chi分配到1分区,zbf分配到3分区,
     * df的reparition 和 rdd.partition都是hash分区
     * 第0个分区-------(dd,1,1),(dd,2,2),(dd,3,3),(dd,4,4),(dd,5,5),(dd,6,6),(dd,7,7),(dd,8,8),(dd,9,9),(dd,10,10)
     * 第1个分区-------(cc,1,1),(chi,1,1),(cc,2,2),(chi,2,2),(cc,3,3),(chi,3,3),(cc,4,4),(chi,4,4),(cc,5,5),(chi,5,5),(cc,6,6),(chi,6,6),(cc,7,7),(chi,7,7),(cc,8,8),(chi,8,8),(cc,9,9),(chi,9,9),(cc,10,10),(chi,10,10)
     * 第2个分区-------
     * 第3个分区-------(zbf,1,1),(zbf,2,2),(zbf,3,3),(zbf,4,4),(zbf,5,5),(zbf,6,6),(zbf,7,7),(zbf,8,8),(zbf,9,9),(zbf,10,10)
     */
    rddToDf.describe("name","age","score").show()
    /** //科学计数法
     * +-------+----+------------------+
     * |summary|name|               age|
     * +-------+----+------------------+
     * |  count|  30|                30|
     * |   mean|null|               5.5|
     * | stddev|null|2.9213837061606074|
     * |    min|  cc|                 1|
     * |    max| zbf|                10|
     * +-------+----+------------------+
     */
    println(" rddToDf.printSchema()=")
    rddToDf.printSchema()
    /**
     * root
     * |-- name: string (nullable = true)
     * |-- age: integer (nullable = false)
     * |-- score: string (nullable = true)
     */
    val column1: Column = rddToDf.apply("name")
    println(s"rddToDf.apply=${column1}")
    /**
     * rddToDf.apply=name
     */
    val schema: StructType = rddToDf.schema
    println(s" rddToDf.schema=${schema.mkString("|")}")
    /**
     * rddToDf.schema=StructField(name,StringType,true)|StructField(age,IntegerType,false)|StructField(score,StringType,true)
     */
    val columns: Array[String] = rddToDf.columns
    println(s" rddToDf.columns=${columns.mkString("|")}")
    /**
     * rddToDf.columns=name|age|score
     */
    val dtypes: Array[(String, String)] = rddToDf.dtypes
    println(s" rddToDf.dtypes=${dtypes.mkString("|")}")
    /**
     * rddToDf.dtypes=(name,StringType)|(age,IntegerType)|(score,StringType)
     */
    val column: Column = rddToDf.col("name")
    println(s"column=${column}")
    /**
     * column=name
     */
    rddToDf.explain() //目前层次未到 有点难看懂
    rddToDf.createTempView("Student") //创建一张临时表
    val df: DataFrame = spark.sql("select * from Student")
    df.show(5)
    /**
     * +----+---+-----+
     * |name|age|score|
     * +----+---+-----+
     * |  cc|  1|    1|
     * | chi|  1|    1|
     * | zbf|  1|    1|
     * |  dd|  1|    1|
     * |  cc|  2|    2|
     * +----+---+-----+
     * only showing top 5 rows
     */

    import org.apache.spark.sql.functions._ //下面这种属于DSL风格sql查询,方法也是再functions._下的包里才有
    df.filter(col("name").equalTo("cc")).show(5)
    /**
     * +----+---+-----+
     * |name|age|score|
     * +----+---+-----+
     * |  cc|  1|    1|
     * |  cc|  2|    2|
     * |  cc|  3|    3|
     * |  cc|  4|    4|
     * |  cc|  5|    5|
     * +----+---+-----+
     */
    df.filter("age>5").show(5)
    /**
     * +----+---+-----+
     * |name|age|score|
     * +----+---+-----+
     * |  cc|  6|    6|
     * | chi|  6|    6|
     * | zbf|  6|    6|
     * |  dd|  6|    6|
     * |  cc|  7|    7|
     * +----+---+-----+
     * only showing top 5 rows
     */
      df.groupBy("name").agg(count(col("age")),avg(col("score"))).show(3)
    /**
     * +----+----------+----------+
     * |name|count(age)|avg(score)|
     * +----+----------+----------+
     * | zbf|        10|       5.5|
     * |  cc|        10|       5.5|
     * | chi|        10|       5.5|
     * +----+----------+----------+
     * only showing top 3 rows
     */
    df.groupBy("name").agg(max(col("age"))as("maxAge"),avg(col("score")).as("avgScore")).show(3)
    /** //取别名
     * +----+------+--------+
     * |name|maxAge|avgScore|
     * +----+------+--------+
     * | zbf|    10|     5.5|
     * |  cc|    10|     5.5|
     * | chi|    10|     5.5|
     * +----+------+--------+
     * only showing top 3 rows
     */
    df.cube("name","age").agg(sum("score").as("score")).orderBy(col("name"),col("score")).show(100)
    /**55条记录 =40条记录+4条name=null + 10条age=null +1条name=null&&age=null
     * select name ,age ,sum(score) as score from student groupby name ,age
     * union select null age ,sum(score) as score from student groupby age
     * union select name,null ,sum(score) as score from student groupby name
     * union select null,null,sum(score) as score from student groupby name
     * +----+----+-----+
     * |name| age|score|
     * +----+----+-----+
     * |null|   1|  4.0|
     * |null|   2|  8.0|
     * |null|   3| 12.0|
     * |null|   4| 16.0|
     * |null|   5| 20.0|
     * |null|   6| 24.0|
     * |null|   7| 28.0|
     * |null|   8| 32.0|
     * |null|   9| 36.0|
     * |null|  10| 40.0|
     * |null|null|220.0|
     * |  cc|   1|  1.0|
     * |  cc|   2|  2.0|
     * |  cc|   3|  3.0|
     * |  cc|   4|  4.0|
     * |  cc|   5|  5.0|
     * |  cc|   6|  6.0|
     * |  cc|   7|  7.0|
     * |  cc|   8|  8.0|
     * |  cc|   9|  9.0|
     * |  cc|  10| 10.0|
     * |  cc|null| 55.0|
     * | chi|   1|  1.0|
     * | chi|   2|  2.0|
     * | chi|   3|  3.0|
     * | chi|   4|  4.0|
     * | chi|   5|  5.0|
     * | chi|   6|  6.0|
     * | chi|   7|  7.0|
     * | chi|   8|  8.0|
     * | chi|   9|  9.0|
     * | chi|  10| 10.0|
     * | chi|null| 55.0|
     * |  dd|   1|  1.0|
     * |  dd|   2|  2.0|
     * |  dd|   3|  3.0|
     * |  dd|   4|  4.0|
     * |  dd|   5|  5.0|
     * |  dd|   6|  6.0|
     * |  dd|   7|  7.0|
     * |  dd|   8|  8.0|
     * |  dd|   9|  9.0|
     * |  dd|  10| 10.0|
     * |  dd|null| 55.0|
     * | zbf|   1|  1.0|
     * | zbf|   2|  2.0|
     * | zbf|   3|  3.0|
     * | zbf|   4|  4.0|
     * | zbf|   5|  5.0|
     * | zbf|   6|  6.0|
     * | zbf|   7|  7.0|
     * | zbf|   8|  8.0|
     * | zbf|   9|  9.0|
     * | zbf|  10| 10.0|
     * | zbf|null| 55.0|
     * +----+----+-----+
     */
    df.rollup("name","age").agg(sum("score").as("score")).orderBy(col("name"),col("score")).show(100)
    /**45条记录=40 + 4条name分组 和1条 不分组
     * select name ,age ,sum(score) as score from student groupby name ,age
     * union select name,null ,sum(score) as score from student groupby name
     * union select null,null,sum(score) as score from student groupby name
     * !!!!!区别  个人理解!!!!!!
     * cube立方三维,借用kylin的思想就是从多个角度去看分组，如果我分组维度有3个,name,age,score,那么先减去1个维度获得【(name,age)(name,score)(age.score)】,然后减去2个维度获得[(name),(age),(score)],再减去3个维度【】
     * rollup,向上 注意比如我name age 分组,(注意顺序！！)那么我还是逐渐减少分组维度,向上递减，先减去age这个维度获得4条记录，然后减去name这个维度 获得1条记录
     * +----+----+-----+
     * |name| age|score|
     * +----+----+-----+
     * |null|null|220.0|
     * |  cc|   1|  1.0|
     * |  cc|   2|  2.0|
     * |  cc|   3|  3.0|
     * |  cc|   4|  4.0|
     * |  cc|   5|  5.0|
     * |  cc|   6|  6.0|
     * |  cc|   7|  7.0|
     * |  cc|   8|  8.0|
     * |  cc|   9|  9.0|
     * |  cc|  10| 10.0|
     * |  cc|null| 55.0|
     * | chi|   1|  1.0|
     * | chi|   2|  2.0|
     * | chi|   3|  3.0|
     * | chi|   4|  4.0|
     * | chi|   5|  5.0|
     * | chi|   6|  6.0|
     * | chi|   7|  7.0|
     * | chi|   8|  8.0|
     * | chi|   9|  9.0|
     * | chi|  10| 10.0|
     * | chi|null| 55.0|
     * |  dd|   1|  1.0|
     * |  dd|   2|  2.0|
     * |  dd|   3|  3.0|
     * |  dd|   4|  4.0|
     * |  dd|   5|  5.0|
     * |  dd|   6|  6.0|
     * |  dd|   7|  7.0|
     * |  dd|   8|  8.0|
     * |  dd|   9|  9.0|
     * |  dd|  10| 10.0|
     * |  dd|null| 55.0|
     * | zbf|   1|  1.0|
     * | zbf|   2|  2.0|
     * | zbf|   3|  3.0|
     * | zbf|   4|  4.0|
     * | zbf|   5|  5.0|
     * | zbf|   6|  6.0|
     * | zbf|   7|  7.0|
     * | zbf|   8|  8.0|
     * | zbf|   9|  9.0|
     * | zbf|  10| 10.0|
     * | zbf|null| 55.0|
     * +----+----+-----+
     */
    df.withColumn("newname",col("name")).show(3)
    /** 新增一列
     * +----+---+-----+-------+
     * |name|age|score|newname|
     * +----+---+-----+-------+
     * |  cc|  1|    1|     cc|
     * | chi|  1|    1|    chi|
     * | zbf|  1|    1|    zbf|
     * +----+---+-----+-------+
     * only showing top 3 rows
     */
    df.withColumn("newname",col("name")).select("name","age","score").show(3)
    /**
     * +----+---+-----+-------+
     * |name|age|score|newname|
     * +----+---+-----+-------+
     * |  cc|  1|    1|     cc|
     * | chi|  1|    1|    chi|
     * | zbf|  1|    1|    zbf|
     * +----+---+-----+-------+
     * only showing top 3 rows
     */
    df.select(col("name").equalTo("cc")).show(5)
    /**这个刚好和上面对应 cc chi zbf dd cc 刚好是true false false false true
     * +-----------+
     * |(name = cc)|
     * +-----------+
     * |       true|
     * |      false|
     * |      false|
     * |      false|
     * |       true|
     * +-----------+
     * only showing top 5 rows
     */
    df.select(col("age").lt(5)).show(5) //小于
    /**
     * +---------+
     * |(age < 5)|
     * +---------+
     * |     true|
     * |     true|
     * |     true|
     * |     true|
     * |     true|
     * +---------+
     * only showing top 5 rows
     */
    val dsBC: Broadcast[Dataset[User]] = spark.sparkContext.broadcast(ds)
    df.join(ds,df("name")===ds("name"),"outer").orderBy(col("score")).show(4)
    /**两张表关联
     * 'inner', 'outer', 'full', 'fullouter', 'full_outer', 'leftouter', 'left', 'left_outer',
     * 'rightouter', 'right', 'right_outer', 'leftsemi', 'left_semi', 'leftanti', 'left_anti', 'cross'
     * +----+---+-----+----+-----+
     * |name|age|score|name|shuai|
     * +----+---+-----+----+-----+
     * |  cc|  1|    1|  cc| true|
     * | chi|  1|    1| chi| true|
     * | zbf|  1|    1| zbf|false|
     * |  dd|  1|    1|  dd|false|
     * +----+---+-----+----+-----+
     * only showing top 10 rows
     */



  }

  //打印输出
  def printRDDPartition(rdd:RDD[Student]): Unit ={
    val array: Array[Array[Student]] = rdd.glom().collect()
    for(i <- 0 until  array.size){
      println(s"第${i}个分区-------${array(i).map(x=>{
        (x.name,x.age,x.score)
      }).mkString(",")}")
    }
  }
  case class Student(name: String, age: Int,score:String){}
  case class User(name: String, shuai:Boolean){}
  class MyPartition(studentName:Array[String]) extends  Partitioner{
    override def numPartitions: Int = studentName.size //分区数
    override def getPartition(key: Any): Int = { //这个方法是那40条数据，每条数据都会把name 传进来返回一个分区号
      val index: Array[(String, Int)] = studentName.zipWithIndex //给每个名字固定一个下标 =>其实也就是第几个分区
      val tuples: Array[(String, Int)] = index.filter(_._1.equals(key.toString)) //在index数组中找到传来名字的属于哪个分区
      tuples.head._2 //head是因为 数据去重了只有一条
    }
  }

}
cclovezbf
关注
0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spark中dataframe，dataset，sparksql中的各种用法

package org.apache.spark.examplesimport DsFilter.Studentimport org.apache.spark.{HashPartitioner, Partitioner}import org.apache.spark.broadcast.Broadcastimport org.apache.spark.rdd.RDDimport o...
复制链接

扫一扫
专栏目录