SparkSQL（二）：SparkSQL核心编程

一、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。

二、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)

③ 查看指定列

scala> df.select("name").show()
+-------+
|   name|
+-------+
|Michael|
|   Andy|
| Justin|
+-------+

④ 查看年龄+1后的数据

scala> df.select($"name",$"age"+1).show()
+-------+---------+
|   name|(age + 1)|
+-------+---------+
|Michael|     null|
|   Andy|       31|
| Justin|       20|
+-------+---------+scala> df.select('name,'age+1).show()
+-------+---------+
|   name|(age + 1)|
+-------+---------+
|Michael|     null|
|   Andy|       31|
| Justin|       20|
+-------+---------+scala> df.select('name,'age+1 as "newAge").show()
+-------+------+
|   name|newAge|
+-------+------+
|Michael|  null|
|   Andy|    31|
| Justin|    20|
+-------+------+

⑤ 查看 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 Userscala> 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 Userscala> 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>:26scala> 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有什么区别呢？首先从版本的产生上来看：

名称	产生版本时间
RDD	Spark1.0
DataFrame	Spark1.3
DataSet	Spark1.6

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

① 三者的共性

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

②三者的区别

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

③ 三者的互相转换