Spark-Sql

Aimyon_36

已于 2023-09-12 20:56:39 修改

阅读量113

点赞数

分类专栏： Spark 文章标签：大数据 spark hadoop

于 2023-05-11 19:11:13 首次发布

本文链接：https://blog.csdn.net/m0_57697768/article/details/130608733

版权

Spark 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

SparkSql

一、DataFrame&DataSet
- DataFrame
- DataSet
二、DataFrame的使用
三、DataSet的使用
四、RDD、DataFrame、DataSet 三者的关系
- 三者的共性和区别
五、用户自定义函数
- UDF
- UDAF

一、DataFrame&DataSet

DataFrame

在 Spark 中，DataFrame 是一种以 RDD 为基础的分布式数据集，类似于传统数据库中的二维表格。

DataFrame 与 RDD 的主要区别在于，前者带有 schema 元信息，即 DataFrame所表示的二维表数据集的每一列都带有名称和类型。

这使得 Spark SQL 得以洞察更多的结构信息，从而对藏于 DataFrame 背后的数据源以及作用于DataFrame 之上的变换进行了针对性的优化，最终达到大幅提升运行时效率的目标。反观 RDD，由于无从得知所存数据元素的具体内部结构，Spark Core 只能在 stage 层面进行简单、通用的流水线优化。
在这里插入图片描述

DataFrame 是为数据提供了 Schema 的视图。可以把它当做数据库中的一张表来对待DataFrame 也是懒执行的，但性能上比 RDD 要高，主要原因：优化的执行计划，即查询计划通过 Spark catalyst optimiser 进行优化(例如谓词下推,现执行filter)。

DataSet

DataSet 是分布式数据集合。DataSet 是 Spark 1.6 中添加的一个新抽象，是 DataFrame的一个扩展。它提供了 RDD 的优势（强类型，使用强大的 lambda 函数的能力）以及 Spark SQL 优化执行引擎的优点。DataSet 也可以使用功能性的转换（操作 map，flatMap，filter等等）。

➢ DataSet 是 DataFrame API 的一个扩展，是 SparkSQL 最新的数据抽象
➢ 用户友好的 API 风格，既具有类型安全检查也具有 DataFrame 的查询优化特性；
➢ 用样例类来对 DataSet 中定义数据的结构信息，样例类中每个属性的名称直接映射到DataSet 中的字段名称；
➢ DataSet 是强类型的。比如可以有 DataSet[Car]，DataSet[Person]。
➢ DataFrame 是 DataSet 的特列，DataFrame=DataSet[Row] ，所以可以通过 as 方法将DataFrame 转换为 DataSet。Row 是一个类型，跟 Car、Person 这些的类型一样，所有的表结构信息都用 Row 来表示。获取数据时需要指定顺序

二、DataFrame的使用

Spark Core 中，如果想要执行应用程序，需要首先构建上下文环境对象 SparkContext，Spark SQL 其实可以理解为对Spark Core 的一种封装，不仅仅在模型上进行了封装，上下文环境对象也进行了封装。SparkSql使用SparkSession作为新的执行入口，但其底层还是使用SparkContext。

读取文件创建DataFramea

SQL语法风格

SQL 语法风格是指我们查询数据的时候使用 SQL 语句来查询，这种风格的查询必须要有临时视图或者全局视图来辅助

➢ 查看 Spark 支持创建文件的数据源格式
scala> spark.read.
csv format jdbc json load option options orc parquet schema table text textFile

➢ 在 spark 的 bin/data 目录中创建 user.json 文件
{"username":"zhangsan","age":20}

➢ 读取 json 文件创建 DataFrame
scala> val df = spark.read.json("data/user.json")
df: org.apache.spark.sql.DataFrame = [age: bigint， username: string]

➢ 展示结果
scala> df.show()
+---+--------+
|age|username|
+---+--------+
| 20|zhangsan|
+---+--------+

➢创建临时视图
scala> df.createOrReplaceTempView("people")
注意：普通临时表是 Session 范围内的，如果想应用范围内有效，可以使用全局临时表。
使用全局临时表时需要全路径访问，如：global_temp.people

➢通过 SQL 语句实现查询全表
scala> val sqlDF = spark.sql("SELECT * FROM people")
scala> sqlDF.show
+---+--------+
|age|username|
+---+--------+
| 20|zhangsan|
| 30| lisi|
| 40| wangwu|
+---+--------+

注意：如果从内存中获取数据，spark 可以知道数据类型具体是什么。如果是数字，默认作为 Int
处理；但是从文件中读取的数字，不能确定是什么类型，所以用 bigint 接收，可以和 Long 类型转换，但是和 Int 不能进行转换

DSL语法风格

DataFrame 提供一个特定领域语言(domain-specific language, DSL)去管理结构化的数据。可以在 Scala, Java, Python 和 R 中使用 DSL，使用 DSL 语法风格不必去创建临时视图了。

1) 创建一个 DataFrame
scala> val df = spark.read.json("data/user.json")
df: org.apache.spark.sql.DataFrame = [age: bigint， name: string]

2) 查看 DataFrame 的 Schema 信息
scala> df.printSchema
root
|-- age: Long (nullable = true)
|-- username: string (nullable = true)

3) 只查看"username"列数据，
scala> df.select("username").show()
+--------+
|username|
+--------+
|zhangsan|
| lisi|
| wangwu|
+--------+

4) 查看"username"列数据以及"age+1"数据
注意:涉及到运算的时候, 每列都必须使用$, 或者采用引号表达式：单引号+字段名
scala> df.select($"username",$"age" + 1).show
scala> df.select('username, 'age + 1 as "newage").show()
+--------+---------+
|username|newage|
+--------+---------+
|zhangsan| 21|
| lisi| 31|
| wangwu| 41|
+--------+---------+

5) 查看"age"大于"30"的数据
scala> df.filter($"age">30).show
+---+---------+
|age| username|
+---+---------+
| 40| wangwu|
+---+---------+

RDD和DataFrame的转换

使用toDF方法将RDD转换为DataFrame

scala> val idRDD = sc.textFile("data/id.txt")
scala> idRDD.toDF("id").show
+---+
| id|
+---+
| 1|
| 2|
| 3|
| 4|
+---+

实际开发中，一般通过样例类将 RDD 转换为 DataFrame
scala> case class User(name:String, age:Int)
defined class User
scala> sc.makeRDD(List(("zhangsan",30), ("lisi",40))).map(t=>User(t._1, 
t._2)).toDF.show
+--------+---+
| name|age|
+--------+---+
|zhangsan| 30|
| lisi| 40|
+--------+---+

DataFrame 其实就是对 RDD 的封装，所以可以直接获取内部的 RDD

scala> val df = sc.makeRDD(List(("zhangsan",30),("lisi",40))).map(t=>User(t._1,t._2)).toDF
df: org.apache.spark.sql.DataFrame = [name: string, age: int]

scala> val rdd = df.rdd
rdd: org.apache.spark.rdd.RDD[org.apache.spark.sql.Row] = MapPartitionsRDD[46] at rdd at <console>:25

#RDD存储的类型为org.apache.spark.sql.Row

scala> val array = rdd.collect
array: Array[org.apache.spark.sql.Row] = Array([zhangsan,30], [lisi,40])

scala> array(0)
res28: org.apache.spark.sql.Row = [zhangsan,30]

scala> array(0)(0)
res29: Any = zhangsan

scala> array(0).getAs[String]("name")
res30: String = zhangsan

三、DataSet的使用

DataSet 是具有强类型的数据集合，需要提供对应的类型信息。

创建 DataSet

1）使用样例类序列创建 DataSet

scala> case class Person(name: String, age: Long)
defined class Person

scala> val caseClassDS = Seq(Person("zhangsan",2)).toDS()
caseClassDS: org.apache.spark.sql.Dataset[Person] = [name: string, age: Long]

scala> caseClassDS.show
+---------+---+
| name|age|
+---------+---+
| zhangsan| 2|
+---------+---+

2）使用基本类型的序列创建 DataSet

scala> val ds = Seq(1,2,3,4,5).toDS
ds: org.apache.spark.sql.Dataset[Int] = [value: int]

scala> ds.show
+-----+
|value|
+-----+
| 1|
| 2|
| 3|
| 4|
| 5|
+-----+

RDD和DataSet的转换

SparkSQL 能够自动将包含有 case 类的 RDD 转换成 DataSet，case 类定义了 table 的结构，case 类属性通过反射变成了表的列名。Case 类可以包含诸如 Seq 或者 Array 等复杂的结构。

➢RDD转DataSet

scala> case class User(name:String, age:Int)
defined class User

scala> sc.makeRDD(List(("zhangsan",30), ("lisi",49))).map(t=>User(t._1, t._2)).toDS
res11: org.apache.spark.sql.Dataset[User] = [name: string, age: int]

➢DataSet 转换为 RDD

scala> case class User(name:String, age:Int)
defined class User

scala>res11=sc.makeRDD(List(("zhangsan",30), ("lisi",49))).map(t=>User(t._1,t._2)).toDS
res11: org.apache.spark.sql.Dataset[User] = [name: string, age: int]

scala> val rdd = res11.rdd
rdd: org.apache.spark.rdd.RDD[User] = MapPartitionsRDD[51] at rdd at <console>:25

scala> rdd.collect
res12: Array[User] = Array(User(zhangsan,30), User(lisi,49))

DataFrame 和 DataSet 的转换

➢ DataFrame 转换为 DataSet

scala> case class User(name:String, age:Int)
defined class User

scala> val df = sc.makeRDD(List(("zhangsan",30), ("lisi",49))).toDF("name","age")
df: org.apache.spark.sql.DataFrame = [name: string, age: int]

scala> val ds = df.as[User]
ds: org.apache.spark.sql.Dataset[User] = [name: string, age: int]

➢ DataSet 转换为 DataFrame

scala> val ds = df.as[User]
ds: org.apache.spark.sql.Dataset[User] = [name: string, age: int]

scala> val df = ds.toDF
df: org.apache.spark.sql.DataFrame = [name: string, age: int]

四、RDD、DataFrame、DataSet 三者的关系

在 SparkSQL 中 Spark 为我们提供了两个新的抽象，分别是 DataFrame 和 DataSet。他们
和 RDD 有什么区别呢？首先从版本的产生上来看：
➢ Spark1.0 => RDD
➢ Spark1.3 => DataFrame
➢ Spark1.6 => Dataset

三者的共性和区别

共性

➢ RDD、DataFrame、DataSet 全都是 spark 平台下的分布式弹性数据集，为处理超大型数据提供便利;
➢ 三者都有惰性机制，在进行创建、转换，如 map 方法时，不会立即执行，只有在遇到 Action 如 foreach时，三者才会开始遍历运算; ➢ 三者有许多共同的函数，如 filter，排序等;
➢ 在对 DataFrame 和 Dataset进行操作许多操作都需要这个包:import spark.implicits._（在创建好 SparkSession 对象后尽量直接导入）
➢ 三者都会根据 Spark 的内存情况自动缓存运算，这样即使数据量很大，也不用担心会内存溢出 ➢ 三者都有 partition 的概念
➢ DataFrame 和 DataSet 均可使用模式匹配获取各个字段的值和类型

区别

➢ RDD 一般和 spark mllib 同时使用
➢ RDD 不支持 sparksql 操作

DataFrame

➢ 与 RDD 和 Dataset 不同，DataFrame 每一行的类型固定为 Row，每一列的值没法直接访问，只有通过解析才能获取各个字段的值
➢ DataFrame 与 DataSet 一般不与 spark mllib 同时使用
➢ DataFrame 与 DataSet 均支持 SparkSQL 的操作，比如 select，groupby 之类，还能注册临时表/视窗，进行 sql 语句操作
➢ DataFrame 与 DataSet 支持一些特别方便的保存方式，比如保存成 csv，可以带上表头，这样每一列的字段名一目了然(后面专门讲解)

DataSet

➢ Dataset 和 DataFrame 拥有完全相同的成员函数，区别只是每一行的数据类型不同。DataFrame 其实就是 DataSet 的一个特例 type DataFrame = Dataset[Row]
➢ DataFrame 也可以Dataset[Row],每一行的类型是 Row，不解析，每一行究竟有哪些字段，各个字段又是什么类型都无从得知，只能用上面提到的 getAS方法或者共性中的第七条提到的模式匹配出特定字段。而 Dataset 中，每一行是什么类型是不一定的，在自定义了 case class之后可以很自由的获得每一行的信息

三者之间的相互转换
在这里插入图片描述

五、用户自定义函数

在 Spark 处理数据的过程中，虽然 DataSet 下的算子不多，但已经可以处理大多数的数据需求，但仍有少数需求需要自定义函数。UDF(User Defined Functions) 是普通的不会产生 Shuffle 不会划分新的阶段的用户自定义函数，UDAF(User Defined Aggregator Functions) 则会打乱分区，用户自定义聚合函数。

UDF

用户可以通过 spark.udf 功能添加自定义函数，实现自定义功能。

user.json数据
{“username”: “Aimyon”,“age”: 28}
{“username”: “aimer”,“age”: 32}
{“username”: “ado”,“age”: 22}
{“username”: “vaundy”,“age”: 22}

object Spark01_UDF {
  def main(args: Array[String]): Unit = {
  //配置Session环境
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("UDF")
    val spark: SparkSession = SparkSession.builder().config(conf).getOrCreate()
  //读取文件
    val df = spark.read.json("resources/user.json")
  //创建视图
    df.createOrReplaceTempView("user")
  //用户自定义函数
    spark.udf.register("prefixName",(name:String)=>{
      "Name:"+name
    })
  //在sql中使用函数
    spark.sql("select age,prefixName(userName) from user ").show()
	+---+--------------------+
	|age|prefixName(userName)|
	+---+--------------------+
	| 28|         Name:Aimyon|
	| 32|          Name:aimer|
	| 22|            Name:ado|
	| 22|         Name:vaundy|
	+---+--------------------+
  }
}

UDAF

强类型的 Dataset 和弱类型的 DataFrame 都提供了相关的聚合函数，如count()，countDistinct()，avg()，max()，min()。除此之外，用户可以设定自己的自定义聚合函数。通过继承UserDefinedAggregateFunction来实现用户自定义弱类型聚合函数。从 Spark3.0 版本后，UserDefinedAggregateFunction 已经不推荐使用了。可以统一采用强类型聚合函数Aggregator

main方法;

object Spark02_UDAF_2 {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("UDAF")
    val spark: SparkSession = SparkSession.builder().config(conf).getOrCreate()

    val df = spark.read.json("resources/user.json")

    df.createOrReplaceTempView("user")

    spark.udf.register("ageAvg",functions.udaf(new MyAvgUDAF))

    spark.sql("select ageAvg(age) from user ").show()
    +--------------+
	|myavgudaf(age)|
	+--------------+
	|            26|
	+--------------+
  }

UDAF的定义

 case class Buff(var total:Long,var count:Long)
  class MyAvgUDAF extends Aggregator[Long,Buff,Long]{
//    缓冲区的初始化
    override def zero: Buff = {
      Buff(0L,0L)
    }
//    根据输入数据更新缓冲区数据 b:缓冲区 a:输入数据
    override def reduce(b: Buff, a: Long): Buff = {
      b.total = b.total + a
      b.count = b.count + 1
      b
    }
//    合并缓冲区
    override def merge(b1: Buff, b2: Buff): Buff = {
      b1.total = b2.total + b1.total
      b1.count = b2.count + b1.count
      b1
    }
//    计算结果
    override def finish(reduction: Buff): Long = {
      reduction.total/reduction.count
    }
//    缓冲区编码:分区中的传输需要序列化
    override def bufferEncoder: Encoder[Buff] = Encoders.product
//    输出编码
    override def outputEncoder: Encoder[Long] = Encoders.scalaLong
  }