SparkSQL（二）：SparkSQL核心编程

一时失言乱红尘 2022-11-21 03:43 257阅读 0赞

### 文章目录 ###

*  一、SparkSQL 核心编程介绍
 *  二、SparkSQL 核心概念
 *   *  2.1 DataFrame
     *   *  2.1.1 创建 DataFrame
         *  2.1.2 SQL 语法
         *  2.1.3 DSL 语法
         *  2.1.4 RDD 转换为 DataFrame
         *  2.1.5 DataFrame 转换为 RDD
     *  2.2 DataSet
     *   *  2.2.1 创建 DataSet
         *  2.2.2 RDD 转换为 DataSet
         *  2.2.3 DataSet 转换为 RDD
         *  2.2.4 DataFrame 和 DataSet 转换
     *  2.3 RDD、DataFrame、DataSet 三者的关系

# 一、SparkSQL 核心编程介绍 #

`Spark Core`中，如果想要执行应用程序，需要首先构建上下文环境对象`SparkContext`，`Spark SQL`其实可以理解为对`Spark Core`的一种封装，不仅仅在模型上进行了封装，上下文环境对象也进行了封装。

在老的版本中，`SparkSQL`提供两种`SQL`查询起始点：一个叫`SQLContext`，用于`Spark`自己提供的SQL查询；一个叫`HiveContext`，用于连接`Hive`的查询。

**SparkSession**是`Spark`最新的`SQL`查询起始点，实质上是`SQLContext`和`HiveContext`的组合，所以在`SQLContext`和`HiveContext`上可用的`API`在`SparkSession`上同样是可以使用的。`SparkSession`内部封装了`SparkContext`，所以计算实际上是由`sparkContext`完成的。当我们使用`spark-shell`的时候， `Spark`会自动的创建一个叫做`Spark`的`SparkSession`， 就像我们以前可以自动获取到一个`sc`来表示`SparkContext`。  
![在这里插入图片描述][20201029202819608.png]

# 二、SparkSQL 核心概念 #

## 2.1 DataFrame ##

`Spark SQL`的`DataFrame API`允许我们使用`DataFrame`而不用必须去注册临时表或者生成`SQL`表达式。`DataFrame API`既有`transformation`操作也有`action`操作。

### 2.1.1 创建 DataFrame ###

在`Spark SQL`中`SparkSession`是创建`DataFrame`和执行`SQL`的入口，创建`DataFrame`有三种方式：通过`Spark`的数据源进行创建；从一个存在的`RDD`进行转换；还可以从`Hive Table`进行查询返回。

**① 从 Spark 数据源进行创建**

*  查看`Spark`支持创建文件的数据源格式

scala> spark.read.
    csv      jdbc   load     options   parquet   table   textFile   
    format   json   option   orc       schema    text

*  读取`json`文件创建`DataFrame`

scala> var df = spark.read.json("../examples/src/main/resources/people.json")
    df: org.apache.spark.sql.DataFrame = [age: bigint, name: string]

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

**② 从 RDD 进行转换**

**③ 从 Hive Table 进行查询返回**

### 2.1.2 SQL 语法 ###

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

**① 读取 JSON 文件创建 DataFrame**

scala> var df = spark.read.json("../examples/src/main/resources/people.json")
    df: org.apache.spark.sql.DataFrame = [age: bigint, name: string]

**② 对 DataFrame 创建一个临时表**

scala> df.createOrReplaceTempView("people")

**③ 通过 SQL 语句实现查询全表**

scala> val sqlDF = spark.sql("select * from people")
    sqlDF: org.apache.spark.sql.DataFrame = [age: bigint， name: string]

**④ 结果展示**

scala> sqldf.show
    +----+-------+
    | age|   name|
    +----+-------+
    |null|Michael|
    |  30|   Andy|
    |  19| Justin|
    +----+-------+

注意：普通临时表是`Session`范围内的，如果想应用范围内有效，可以使用全局临时表。使用全局临时表时需要全路径访问，如：`global_temp.people`

**⑤ 对于 DataFrame 创建一个全局表**

scala> df.createGlobalTempView("people")

**⑥ 通过 SQL 语句实现查询全表**

scala> spark.sql("SELECT * FROM global_temp.people").show()
    +----+-------+
    | age|   name|
    +----+-------+
    |null|Michael|
    |  30|   Andy|
    |  19| Justin|
    +----+-------+
    
    scala> spark.newSession().sql("SELECT * FROM global_temp.people").show()
    +----+-------+
    | age|   name|
    +----+-------+
    |null|Michael|
    |  30|   Andy|
    |  19| Justin|
    +----+-------+

### 2.1.3 DSL 语法 ###

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

**① 创建一个 DataFrame**

scala> var df = spark.read.json("../examples/src/main/resources/people.json")
    df: org.apache.spark.sql.DataFrame = [age: bigint, name: string]

**② 查看 DataFrame 的 Schema 信息**

scala> df.printSchema
    root
     |-- age: long (nullable = true)
     |-- name: string (nullable = true)

**③ 查看指定列**

**④ 查看年龄+1后的数据**

**⑤ 查看 age 大于10的数据**

scala> df.filter('age>10).show()
    +---+------+
    |age|  name|
    +---+------+
    | 30|  Andy|
    | 19|Justin|
    +---+------+

**⑥ 按照 age 分组，查看数据条数**

scala> df.groupBy("age").count.show
    +----+-----+
    | age|count|
    +----+-----+
    |  19|    1|
    |null|    1|
    |  30|    1|
    +----+-----+

### 2.1.4 RDD 转换为 DataFrame ###

在`IDEA`中开发程序时，如果需要`RDD`与`DF`或者`DS`之间互相操作，那么需要引入`import spark.implicits._`；`spark-shell`中无需导入，自动完成此操作。

`spark-shell`中`spark`是创建的`sparkSession`对象，这里的`spark`对象不能使用`var`声明，因为`Scala`只支持`val`修饰的对象的引入。

scala> val idRdd = sc.textFile("/root/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(("jack",20),("rose",18))).map(t=>User(t._1,t._2)).toDF.show
    +----+---+
    |name|age|
    +----+---+
    |jack| 20|
    |rose| 18|
    +----+---+

### 2.1.5 DataFrame 转换为 RDD ###

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

scala> var idDF = rdd.toDF
    idDF: org.apache.spark.sql.DataFrame = [value: int]
    
    scala> idDF.rdd.collect
    res0: Array[org.apache.spark.sql.Row] = Array([1], [2], [3], [4])

## 2.2 DataSet ##

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

### 2.2.1 创建 DataSet ###

**① 使用样例类序列创建 DataSet**

scala> case class User(name:String,age:Long)
    defined class User
    
    scala> var userDS = Seq(User("Lee",2)).toDS
    userDS: org.apache.spark.sql.Dataset[User] = [name: string, age: bigint]
    
    scala> userDS.show
    +----+---+
    |name|age|
    +----+---+
    | Lee|  2|
    +----+---+

**② 使用基本类型的序列创建 DataSet**

scala> val basicDS = Seq(1,2,3,4).toDS
    basicDS: org.apache.spark.sql.Dataset[Int] = [value: int]
    
    scala> basicDS.show
    +-----+
    |value|
    +-----+
    |    1|
    |    2|
    |    3|
    |    4|
    +-----+

注意：在实际使用的时候，很少用到把序列转换成`DataSet`，更多的是通过`RDD`来得到`DataSet`

### 2.2.2 RDD 转换为 DataSet ###

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

scala> sc.makeRDD(List(User("Jack",20))).toDS
    res1: org.apache.spark.sql.Dataset[User] = [name: string, age: int]

### 2.2.3 DataSet 转换为 RDD ###

`DataSet`其实也是对`RDD`的封装，所以可以直接获取内部的`RDD`

scala> val rdd = basicDS.rdd
    rdd: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[4] at rdd at <console>:26
    
    scala> rdd.collect
    res2: Array[Int] = Array(1, 2, 3, 4)

### 2.2.4 DataFrame 和 DataSet 转换 ###

`DataFrame`其实是`DataSet`的特例，所以它们之间是可以互相转换的。

**① DataFrame 转换为 DataSet**

scala> val userDS = sc.makeRDD(List(User("Jack",20))).toDS
    userDS: org.apache.spark.sql.Dataset[User] = [name: string, age: int]
    
    scala> userDS.toDF
    res3: org.apache.spark.sql.DataFrame = [name: string, age: int]

**② DataFrame 转换为 DataSet**

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

## 2.3 RDD、DataFrame、DataSet 三者的关系 ##

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

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>产生版本时间</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>RDD</td> 
   <td>Spark1.0</td> 
  </tr> 
  <tr> 
   <td>DataFrame</td> 
   <td>Spark1.3</td> 
  </tr> 
  <tr> 
   <td>DataSet</td> 
   <td>Spark1.6</td> 
  </tr> 
 </tbody> 
</table>

如果同样的数据都给到这三个数据结构，他们分别计算之后，都会给出相同的结果。不同是的他们的执行效率和执行方式。在后期的`Spark`版本中，`DataSet`有可能会逐步取代`RDD`和`DataFrame`成为唯一的`API`接口。

**① 三者的共性**

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

**②三者的区别**

<table> 
 <thead> 
  <tr> 
   <th align="left">名称</th> 
   <th align="left">区别</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">RDD</td> 
   <td align="left">1、RDD一般和spark mlib同时使用<br>2、RDD不支持sparksql操作<br></td> 
  </tr> 
  <tr> 
   <td align="left">DataFrame</td> 
   <td align="left">1、与RDD和Dataset不同，DataFrame每一行的类型固定为Row，每一列的值没法直接访问，只有通过解析才能获取各个字段的值<br>2、DataFrame与DataSet一般不与 spark mlib 同时使用<br>3、DataFrame与DataSet均支持 SparkSQL 的操作，比如select，groupby之类，还能注册临时表/视窗，进行 sql 语句操作<br>4、DataFrame与DataSet支持一些特别方便的保存方式，比如保存成csv，可以带上表头，这样每一列的字段名一目了然(后面讲解)<br></td> 
  </tr> 
  <tr> 
   <td align="left">DataSet</td> 
   <td align="left">1、Dataset和DataFrame拥有完全相同的成员函数，区别只是每一行的数据类型不同。 DataFrame其实就是DataSet的一个特例 type DataFrame = Dataset[Row]<br>2、DataFrame也可以叫Dataset[Row],每一行的类型是Row，不解析，每一行究竟有哪些字段，各个字段又是什么类型都无从得知，只能用上面提到的getAS方法或者共性中的第七条提到的模式匹配拿出特定字段。而Dataset中，每一行是什么类型是不一定的，在自定义了case class之后可以很自由的获得每一行的信息</td> 
  </tr> 
 </tbody> 
</table>

**③ 三者的互相转换**  
![在这里插入图片描述][20201102112920211.png_pic_left]

[20201029202819608.png]: /images/20221120/2b24f5fe86dd433da52be2969fbf6ecd.png
[20201102112920211.png_pic_left]: https://img-blog.csdnimg.cn/20201102112920211.png#pic_left