Spark SQL 编程总结_spark sql编程实验总结

一、SparkSession 新的起始点

在老的版本中，SparkSQL 提供两种 SQL 查询起始点：

SQLContext：用于 Spark 自己提供的 SQL 查询；

HiveContext：用于连接 Hive 的查询。

SparkSession 是 Spark 最新的 SQL 查询起始点，实质上是 SQLContext 和 HiveContext 的组合，所以在 SQLContext 和 HiveContext 上可用的 API 在 SparkSession 上同样是可以使用的。SparkSession 内部封装了 sparkContext，所以计算实际上是由 sparkContext 完成的。

二、DataFrame

2.1 创建

在 Spark SQL 中 SparkSession 是创建 DataFrame 和执行 SQL 的入口，创建 DataFrame 有三种方式：

通过 Spark 的数据源进行创建；

从一个存在的 RDD 进行转换；

从 Hive Table 进行查询返回。

1、从 Spark 数据源进行创建

（1）查看 Spark 数据源进行创建的文件格式

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

（2）读取 json 文件创建 DataFrame

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

(3）展示结果

scala> df.show
+----+-------+
| age| name|
+----+-------+
|null|Michael|
| 30| Andy|
| 19| Justin|
+----+-------+
1
2
3
4
5
6
7

2、从 RDD 进行转换

第5节专门讨论

3、从 Hive Table 进行查询返回

第3.3 节专门讨论

2.2 SQL 风格语法(主要)

（1）创建一个 DataFrame

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

（2）对 DataFrame 创建一个临时表

scala> df.createOrReplaceTempView("people")

（3）通过 SQL 语句实现查询全表

scala> val sqlDF = spark.sql("SELECT * FROM people")
sqlDF: org.apache.spark.sql.DataFrame = [age: bigint, name: string]
1

（4）结果展示

scala> sqlDF.show
+----+-------+
| age| name|
+----+-------+
|null|Michael|
| 30| Andy|
| 19| Justin|
+----+-------+
1
2
3
4
5
6
7

注意：临时表是 Session 范围内的，Session退出后，表就失效了。如果想应用范围内有效，可以使用全局表。注意使用全局表时需要全路径访问，如：global_temp.people

（5）对于 DataFrame 创建一个全局表

scala> df.createGlobalTempView("people")

（6）通过 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|
+----+-------+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.3 DSL 风格语法(次要)

（1）创建一个 DataFrame

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

（2）查看 DataFrame 的 Schema 信息

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

（3）只查看”name”列数据

scala> df.select("name").show()
+-------+
| name|
+-------+
|Michael|
| Andy|
| Justin|
+-------+
1
2
3
4
5
6
7
8

（4）查看”name”列数据以及”age+1”数据

scala> df.select($"name", $"age" + 1).show()
+-------+---------+
| name|(age + 1)|
+-------+---------+
|Michael| null|
| Andy| 31|
| Justin| 20|
+-------+---------+
1
2
3
4
5
6
7
8

（5）查看”age”大于”21”的数据

scala> df.filter($"age" > 21).show()
+---+----+
|age|name|
+---+----+
| 30|Andy|
+---+----+
1
2
3
4
5
6

（6）按照”age”分组，查看数据条数

scala> df.groupBy("age").count().show()
+----+-----+
| age|count|
+----+-----+
| 19| 1|
|null| 1|
| 30| 1|
+----+-----+
1
2
3
4
5
6
7

2.4 RDD 转换为 DateFrame

注意：如果需要 RDD 与 DF 或者 DS 之间操作，那么都需要引入 import spark.implicits._
【spark不是包名，而是 sparkSession 对象的名称】

前置条件：导入隐式转换并创建一个 RDD

scala> import spark.implicits._
import spark.implicits._

scala> val peopleRDD =
sc.textFile("examples/src/main/resources/people.txt")
peopleRDD: org.apache.spark.rdd.RDD[String] =
examples/src/main/resources/people.txt MapPartitionsRDD[3] at textFile
at :27
1
2
3
4
5
6
7

（1）通过手动确定转换

scala> peopleRDD.map{x=>val para =
x.split(",");(para(0),para(1).trim.toInt)}.toDF("name","age")
res1: org.apache.spark.sql.DataFrame = [name: string, age: int]
1
2

（2）通过反射确定（需要用到样例类）

1）创建一个样例类

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

2）根据样例类将 RDD 转换为 DataFrame

scala> peopleRDD.map{ x => val para =
x.split(",");People(para(0),para(1).trim.toInt)}.toDF
res2: org.apache.spark.sql.DataFrame = [name: string, age: int]
1
2

（3）通过编程的方式（了解即可）

1）导入所需的类型

scala> import org.apache.spark.sql.types._
import org.apache.spark.sql.types._
1

2）创建 Schema

scala> val structType: StructType = StructType(StructField("name",
StringType) :: StructField("age", IntegerType) :: Nil)
structType: org.apache.spark.sql.types.StructType =
StructType(StructField(name,StringType,true),
StructField(age,IntegerType,true))

1
2
3
4
5
6

3）导入所需的类型

scala> import org.apache.spark.sql.Row
import org.apache.spark.sql.Row
1

4）根据给定的类型创建二元组 RDD

scala> val data = peopleRDD.map{ x => val para =
x.split(",");Row(para(0),para(1).trim.toInt)}
data: org.apache.spark.rdd.RDD[org.apache.spark.sql.Row] =
MapPartitionsRDD[6] at map at :33

1
2
3
4
5

5）根据数据及给定的 schema 创建 DataFrame

scala> val dataFrame = spark.createDataFrame(data, structType)
dataFrame: org.apache.spark.sql.DataFrame = [name: string, age: int]
1

2.5 DateFrame 转换为 RDD

直接调用 rdd 即可

（1）创建一个 DataFrame

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

（2）将 DataFrame 转换为 RDD

scala> val dfToRDD = df.rdd
dfToRDD: org.apache.spark.rdd.RDD[org.apache.spark.sql.Row] =
MapPartitionsRDD[19] at rdd at :29
1
2

（3）打印 RDD

scala> dfToRDD.collect
res13: Array[org.apache.spark.sql.Row] = Array([Michael, 29], [Andy,
30], [Justin, 19])
1
2

三、DataSet

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

3.1 创建

(1）创建一个样例类

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

(2）创建 DataSet

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

3.2 RDD 转换为 DataSet

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

（1）创建一个 RDD

scala> val peopleRDD =
sc.textFile("examples/src/main/resources/people.txt")
peopleRDD: org.apache.spark.rdd.RDD[String] =
examples/src/main/resources/people.txt MapPartitionsRDD[3] at textFile at :27
1
2
3

（2）创建一个样例类

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

（3）将 RDD 转化为 DataSet

scala> peopleRDD.map(line => {val para =
line.split(",");Person(para(0),para(1).trim.toInt)}).toDS
res8: org.apache.spark.sql.Dataset[Person] = [name: string, age: bigint]
1
2

3.3 DataSet 转换为 RDD

调用 rdd 方法即可。

（1）创建一个 DataSet

scala> val DS = Seq(Person("Andy", 32)).toDS()
DS: org.apache.spark.sql.Dataset[Person] = [name: string, age: bigint]
1

（2）将 DataSet 转换为 RDD

scala> DS.rdd
res11: org.apache.spark.rdd.RDD[Person] = MapPartitionsRDD[15] at rdd at :28
1

四、DataFrame 与 DataSet 的互操作

4.1 DataFrame 转 Dataset

（1）创建一个 DateFrame

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

（2）创建一个样例类

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

（3）将 DateFrame 转化为 DataSet

scala> df.as[Person]
res14: org.apache.spark.sql.Dataset[Person] = [age: bigint, name:string]
1

这种方法就是在给出每一列的类型后，使用 as 方法，转成 Dataset，这在数据类型是 DataFrame 又需 要 针 对 各 个 字 段 处 理 时 极 为 方 便 。 在 使 用 一 些 特 殊 的 操 作 时 ， 一 定 要 加 上 import spark.implicits._ 不然 toDF、toDS 无法使用。

4.2 Dataset 转 DataFrame

（1）创建一个样例类

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

（2）创建 DataSet

scala> val ds = Seq(Person("Andy", 32)).toDS()
ds: org.apache.spark.sql.Dataset[Person] = [name: string, age: bigint]
1

（3）将 DataSet 转化为 DataFrame

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

（4）展示

scala> df.show
+----+---+
|name|age|
+----+---+
|Andy| 32|
+----+---+
1
2
3
4
5

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

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

RDD (Spark1.0) —> Dataframe(Spark1.3) —> Dataset(Spark1.6)

如果同样的数据都给到这三个数据结构，他们分别计算之后，都会给出相同的结果。不同是的他们的执行效率和执行方式。

在后期的 Spark 版本中，DataSet 会逐步取代 RDD 和 DataFrame 成为唯一的 API 接口。

5.1 三者的共性

1、RDD、DataFrame、Dataset 全都是 spark 平台下的分布式弹性数据集，为处理超大型数据提供便利

2、三者都有惰性机制，在进行创建、转换，如 map 方法时，不会立即执行，只有在遇到 Action如 foreach 时，三者才会开始遍历运算。

3、三者都会根据 spark 的内存情况自动缓存运算，这样即使数据量很大，也不用担心会内存溢出

4、三者都有 partition 的概念

5、三者有许多共同的函数，如 filter，排序等

6、在对 DataFrame 和 Dataset 进行操作许多操作都需要这个包进行支持import spark.implicits._

7、DataFrame 和 Dataset 均可使用模式匹配获取各个字段的值和类型

DataFrame：

testDF.map{
case Row(col1:String,col2:Int)=>
println(col1);println(col2)
col1
case _=>
""
}
1
2
3
4
5
6

Dataset：

case class Coltest(col1:String,col2:Int)extends Serializable //定义字段
名和类型
testDS.map{
case Coltest(col1:String,col2:Int)=>
println(col1);println(col2)
col1
case _=>
""
}
1
2
3
4
5
6
7
8

5.2 三者的区别

1、RDD:

1）RDD 一般和 spark mlib 同时使用
2）RDD 不支持 sparksql 操作

2、DataFrame:

1）与 RDD 和 Dataset 不同，DataFrame 每一行的类型固定为 Row，每一列的值没法直接访问，只有通过解析才能获取各个字段的值，如：

testDF.foreach{
line =>
val col1=line.getAs[String]("col1")
val col2=line.getAs[String]("col2")
}
1
2
3
4

2）DataFrame 与 Dataset 一般不与 spark mlib 同时使用

3）DataFrame 与 Dataset 均支持 sparksql 的操作，比如 select，groupby 之类，还能注册临时表/视窗，进行 sql 语句操作，如：

dataDF.createOrReplaceTempView("tmp")
spark.sql("select ROW,DATE from tmp where DATE is not null order by
DATE").show(100,false)
1
2

4）DataFrame 与 Dataset 支持一些特别方便的保存方式，比如保存成 csv，可以带上表头，这样每一列的字段名一目了然

//保存
val saveoptions = Map("header" -> "true", "delimiter" -> "\t", "path"
-> "hdfs://hadoop102:9000/test")
datawDF.write.format("com.atguigu.spark.csv").mode(SaveMode.Overwrite
).options(saveoptions).save()
//读取
val options = Map("header" -> "true", "delimiter" -> "\t", "path" ->
"hdfs://hadoop102:9000/test")
val datarDF= spark.read.options(options).format("com.atguigu.spark.cs
v").load()
1
2
3
4
5
6
7
8
9

3、Dataset：

1）Dataset 和 DataFrame 拥有完全相同的成员函数，区别只是每一行的数据类型不同。

2）DataFrame 也可以叫 Dataset[Row],每一行的类型是 Row，不解析，每一行究竟有哪些字段，各个字段又是什么类型都无从得知，只能用上面提到的 getAS 方法或者共性中的第七条提到的模式匹配拿出特定字段。而 Dataset 中，每一行是什么类型是不一定的，在自定义了 case class之后可以很自由的获得每一行的信息

case class Coltest(col1:String,col2:Int)extends Serializable //定义字段
名和类型
/**
rdd
("a", 1)
("b", 1)
("a", 1)
**/
val test: Dataset[Coltest]=rdd.map{line=>
Coltest(line._1,line._2)
}.toDS
test.map{
line=>
println(line.col1)
println(line.col2)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

可以看出，Dataset 在需要访问列中的某个字段时是非常方便的，然而，如果要写一些适配性很强的函数时，如果使用 Dataset，行的类型又不确定，可能是各种 case class，无法实现适配，这时候用 DataFrame 即 Dataset[Row]就能比较好的解决问题。