大数据技术之Spark（二）Spark SQL

第1章 SparkSQL 概述

1.1 SparkSQL 是什么?

  Spark SQL 是 Spark 用于结构化数据(structured data)处理的 Spark 模块。
SparkSQL官方文档

1.3 SparkSQL 特点

1.3.1 易整合

  无缝的整合了 SQL 查询和 Spark 编程
   Spark SQL允许您使用SQL或熟悉的DataFrame API在Spark程序中查询结构化数据。可用于Java, Scala, Python和R。（官方文档翻译 ）

1.3.2 统一的数据访问

   使用相同的方式连接不同的数据源
   DataFrames和SQL提供了一种通用的方式来访问各种数据源，包括Hive、Avro、Parquet、ORC、JSON和JDBC。您甚至可以跨这些源连接数据。（官方文档翻译 ）

1.3.3 兼容 Hive

   在已有的仓库上直接运行 SQL 或者 HiveQL
  Spark SQL重用了Hive前端和metastore，使您完全兼容现有的Hive数据、查询和udf。只需将其安装在Hive旁边。（官方文档翻译 ）

1.3.4 标准数据连接

   通过 JDBC 或者 ODBC 来连接
  服务器模式为业务智能工具提供行业标准JDBC和ODBC连接。（官方文档翻译 ）


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

1.4RDD，DataFrame，DataSet特点

1.4.1 RDD特点

  RDD是一个懒执行的不可变的可以支持Lambda表达式的并行数据集合。
  RDD的最大好处就是简单，API的人性化程度很高。
  RDD的劣势是性能限制，它是一个JVM驻内存对象，这也就决定了存在GC的限制和数据增加时Java序列化成本的升高。

1.4.2 DataFrame 是什么？

  在 Spark 中，DataFrame 是一种以 RDD 为基础的分布式数据集，类似于传统数据库中的二维表格。DataFrame 与 RDD 的主要区别在于，前者带有 schema 元信息，即 DataFrame所表示的二维表数据集的每一列都带有名称和类型。这使得 Spark SQL 得以洞察更多的结构信息，从而对藏于 DataFrame 背后的数据源以及作用于 DataFrame 之上的变换进行了针对性的优化，最终达到大幅提升运行时效率的目标。反观 RDD，由于无从得知所存数据元素的具体内部结构，Spark Core 只能在 stage 层面进行简单、通用的流水线优化。

  上图直观地体现了 DataFrame 和 RDD 的区别。
  左侧的 RDD[Person]虽然以 Person 为类型参数，但 Spark 框架本身不了解 Person 类的内部结构。而右侧的 DataFrame 却提供了详细的结构信息，使得 Spark SQL 可以清楚地知道该数据集中包含哪些列，每列的名称和类型各是什么。
  DataFrame 也是懒执行的，但性能上比RDD要高，主要有两方面原因：
(1)定制化内存管理
   数据以二进制的方式存在于非堆内存，节省了大量空间之外，还摆脱了GC的限制。

(2)优化的执行计划
   查询计划通过Spark catalyst optimiser进行优化.
  举个栗子：


上图从下往上看 ，操作执行优先级。
  构造了两个DataFrame，将它们 join 之后又做了一次 filter 操作。如果原封不动地执行这个执行计划，最终的执行效率是不高的。因为 join 是一个代价较大的操作，也可能会产生一个较大的数据集。
  Spark SQL 的查询优化器会先对 DataFrame 进行过滤，再 join 过滤后的较小的结果集，便可以有效缩短执行时间。

  Dataframe的劣势在于在编译期缺少类型安全检查，导致运行时出错.

1.4.3 DataSet 是什么？

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

 1）是Dataframe API的一个扩展，是Spark最新的数据抽象
 2）用户友好的API风格，既具有类型安全检查也具有Dataframe的查询优化特性。
 3）Dataset支持编解码器，当需要访问非堆上的数据时可以避免反序列化整个对象，提高了效率。
 4）样例类被用来在Dataset中定义数据的结构信息，样例类中每个属性的名称直接映射到DataSet中的字段名称。
 5） Dataframe是Dataset的特列，DataFrame=Dataset[Row] ，所以可以通过as方法将Dataframe转换为Dataset。Row是一个类型，跟Car、Person这些的类型一样，所有的表结构信息我都用Row来表示。
 6）DataSet是强类型的。比如可以有Dataset[Car]，Dataset[Person].
 7）DataFrame只是知道字段，但是不知道字段的类型，所以在执行这些操作的时候是没办法在编译的时候检查是否类型失败的，比如你可以对一个String进行减法操作，在执行的时候才报错，而DataSet不仅仅知道字段，而且知道字段类型，所以有更严格的错误检查。就跟JSON对象和类对象之间的类比。

1.5三者的共性

  1、RDD、DataFrame、Dataset全都是spark平台下的分布式弹性数据集，为处理超大型数据提供便利
  2、三者都有惰性机制，在进行创建、转换，如map方法时，不会立即执行，只有在遇到Action如foreach时，三者才会开始遍历运算，极端情况下，如果代码里面有创建、转换，但是后面没有在Action中使用对应的结果，在执行时会被直接跳过。

val sparkconf = new
SparkConf().setMaster("local").setAppName("test")
.set("spark.port.maxRetries","1000")
val spark = SparkSession.builder()
.config(sparkconf).getOrCreate()
val rdd=spark.sparkContext.parallelize(Seq(("a", 1), 
("b", 1), ("a", 1)))
// map不运行
rdd.map{
	line=> println("运行")
	line._1
}

  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 _=>
""
}

 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.6三者的区别

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

DataFrame:
  1、与RDD和Dataset不同，DataFrame每一行的类型固定为Row，只有通过解析才能获取各个字段的值，如

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

每一列的值没法直接访问
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)

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

//保存
val saveoptions = Map("header" -> "true", "delimiter" -> "\t"
, "path" ->"hdfs://hadoop100:9000/test")
datawDF.write.format("com.wolf.spark.csv")
.mode(SaveMode.Overwrite).options(saveoptions).save()
//读取
val options = Map("header" -> "true", "delimiter" -> "\t"
, "path"->"hdfs://node102:8020/test")
val datarDF= spark.read.options(options).
format("com.wolf.spark.csv").load()

  利用这样的保存方式，可以方便的获得字段名和列的对应，而且分隔符（delimiter）可以自由指定
Dataset:

  Dataset和DataFrame拥有完全相同的成员函数，区别只是每一行的数据类型不同。
  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)
}

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

第二章 SparkSQL 核心编程

2.1 新的起始点SparkSession

在老的版本中，SparkSQL提供两种SQL查询起始点，一个叫SQLContext，用于Spark自己提供的SQL查询，一个叫HiveContext，用于连接Hive的查询，SparkSession是Spark最新的SQL查询起始点，实质上是SQLContext和HiveContext的组合，所以SQLContextHiveContext上可用的API在SparkSession上同样是可以使用的。SparkSession内部封装了sparkContext，所以计算实际上是由sparkContext完成的。

2.2 DataFrame

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

2.2.1 创建 DataFrame

  在 Spark SQL 中 SparkSession 是创建 DataFrame 和执行 SQL 的入口，创建 DataFrame有三种方式：通过 Spark 的数据源进行创建；从一个存在的 RDD 进行转换；还可以从 HiveTable 进行查询返回。
  1) 从 Spark 数据源进行创建
➢ 查看 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]

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

+---+--------+
|age|username|
+---+--------+
| 20|zhangsan|
+---+--------+

2.2.2 SQL 语法

   SQL 语法风格是指我们查询数据的时候使用 SQL 语句来查询，这种风格的查询必须要有临时视图或者全局视图来辅助。
 （1) 读取 JSON 文件创建 DataFrame

scala> val df = spark.read.json("data/user.json")
df: org.apache.spark.sql.DataFrame = [age: bigint，
 username: string]

 (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]

 (4) 结果展示

scala> sqlDF.show
+---+--------+
|age|username|
+---+--------+
| 20|zhangsan|
| 30| lisi   |
| 40| wangwu |
+---+--------+

  注意：普通临时表是 Session 范围内的，如果想应用范围内有效，可以使用全局临时表。使用全局临时表时需要全路径访问，如：global_temp.people
(5) 对于 DataFrame 创建一个全局表

scala> df.createGlobalTempView("people")

(6) 通过 SQL 语句实现查询全表

scala> spark.sql("SELECT * FROM global_temp.people").show()
+---+--------+
|age|username|
+---+--------+
| 20|zhangsan|
| 30| lisi|
| 40| wangwu|
+---+--------+
scala> spark.newSession()
.sql("SELECT * FROM global_temp.people").show()
+---+--------+
|age|username|
+---+--------+
| 20|zhangsan|
| 30| lisi|
| 40| wangwu|
+---+--------+

2.2.3 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).show()
scala> df.select('username, 'age + 1 as "newage").show()
+--------+---------+
|username|(age + 1)|
+--------+---------+
|zhangsan| 21|
| lisi| 31|
| wangwu| 41|
+--------+---------+

(5) 查看"age"大于"30"的数据

scala> df.filter($"age">30).show
+---+---------+
|age| username|
+---+---------+
| 40| wangwu|
+---+---------+

(6) 按照"age"分组，查看数据条数

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

2.2.4 RDD 转换为 DataFrame

  在 IDEA 中开发程序时，如果需要 RDD 与 DF 或者 DS 之间互相操作，那么需要引入 import spark.implicits._
  这里的 spark 不是 Scala 中的包名，而是创建的 sparkSession 对象的变量名称，所以必须先创建 SparkSession 对象再导入。这里的 spark 对象不能使用 var 声明，因为 Scala 只支持val 修饰的对象的引入。

spark-shell 中无需导入，自动完成此操作。

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|
+--------+---+

2.2.5 DataFrame 转换为 RDD

  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
scala> val array = rdd.collect
array: Array[org.apache.spark.sql.Row] = Array([zhangsan,30], [lisi,40])

注意：此时得到的 RDD 存储类型为 Row

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

2.3 DataSet

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

2.3.1 创建 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|
+-----+

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

2.3.2 RDD 转换为 DataSet

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

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]

2.3.3 DataSet 转换为 RDD

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

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]
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))

2.3.4 DataFrame 和 DataSet 转换

  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]

2.4 三者的互相转换

2.5 IDEA 开发 SparkSQL

object SparkSQL01_Demo {
 def main(args: Array[String]): Unit = {
 //创建上下文环境配置对象
 val conf: SparkConf = new
SparkConf()
.setMaster("local[*]")
.setAppName("SparkSQL01_Demo")
 //创建 SparkSession 对象
 val spark: SparkSession = SparkSession.builder()
 .config(conf).getOrCreate()
 //RDD=>DataFrame=>DataSet 转换需要引入隐式转换规则，否则无法转换
 //spark 不是包名，是上下文环境对象名
 import spark.implicits._
 //读取 json 文件 创建 DataFrame {"username": "lisi","age": 18}
 val df: DataFrame = spark.read.json("input/test.json")
 //df.show()
 //SQL 风格语法
 df.createOrReplaceTempView("user")
 //spark.sql("select avg(age) from user").show
 //DSL 风格语法
 //df.select("username","age").show()
 //*****RDD=>DataFrame=>DataSet*****
 //RDD
 val rdd1: RDD[(Int, String, Int)] =
spark.sparkContext.makeRDD(
List((1,"zhangsan",30),(2,"lisi",28),(3,"wangwu",20)))
 //DataFrame
 val df1: DataFrame = rdd1.toDF("id","name","age")
 //df1.show()
 //DateSet
 val ds1: Dataset[User] = df1.as[User]
 //ds1.show()
 //*****DataSet=>DataFrame=>RDD*****
 //DataFrame
 val df2: DataFrame = ds1.toDF()
 //RDD 返回的 RDD 类型为 Row，里面提供的 
// getXXX 方法可以获取字段值，类似 jdbc 处理结果集，但是索引从 0 开始
 val rdd2: RDD[Row] = df2.rdd
 //rdd2.foreach(a=>println(a.getString(1)))
 //*****RDD=>DataSet*****
 rdd1.map{
 case (id,name,age)=>User(id,name,age)
 }.toDS()
 //*****DataSet=>=>RDD*****
 ds1.rdd
 //释放资源
 spark.stop()
 }
}
case class User(id:Int,name:String,age:Int)

2.6SparkSQL数据源

2.6.1 通用的加载和保存方式

  SparkSQL 提供了通用的保存数据和数据加载的方式。这里的通用指的是使用相同的API，根据不同的参数读取和保存不同格式的数据，SparkSQL 默认读取和保存的文件格式为 parquet
(1) 加载数据

spark.read.load 是加载数据的通用方法

scala> spark.read.format("…")[.option("…")].load("…")

 ➢ format(“…”)：指定加载的数据类型，包括"csv"、“jdbc”、“json”、“orc”、“parquet"和"textFile”。
 ➢ load(“…”)：在"csv"、“jdbc”、“json”、“orc”、“parquet"和"textFile"格式下需要传入加载数据的路径。
 ➢ option(”…")：在"jdbc"格式下需要传入 JDBC 相应参数，url、user、password 和 dbtable我们前面都是使用 read API 先把文件加载到DataFrame 然后再查询，其实，我们也可以直接在文件上进行查询: 文件格式.文件路径

scala>spark.sql
("select * from json.`/opt/module/data/user.json`").show

(2) 保存数据
df.write.save 是保存数据的通用方法

scala>df.write.
csv jdbc json orc parquet textFile… …
如果保存不同格式的数据，可以对不同的数据格式进行设定
scala>df.write.format("…")[.option("…")].save("…")
save ("…")：在"csv"、"orc"、"parquet"和"textFile"
格式下需要传入保存数据的路径。

  保存操作可以使用 SaveMode, 用来指明如何处理数据，使用 mode()方法来设置。有一点很重要: 这些 SaveMode 都是没有加锁的, 也不是原子操作。
  SaveMode 是一个枚举类，其中的常量包括：

Scala/Java	Any Language	Meaning
SaveMode.ErrorIfExists(default)	“error”(default)	如果文件已经存在则抛出异常
SaveMode.Append	“append”	如果文件已经存在则追加
SaveMode.Overwrite	“overwrite”	如果文件已经存在则覆盖
SaveMode.Ignore	“ignore”	如果文件已经存在则忽略

df.write.mode(“append”).json(“/opt/module/data/output”)

2.6.2 Parquet

  Spark SQL 的默认数据源为 Parquet 格式。Parquet 是一种能够有效存储嵌套数据的列式存储格式。
  数据源为 Parquet 文件时，Spark SQL 可以方便的执行所有的操作，不需要使用 format。修改配置项 spark.sql.sources.default，可修改默认数据源格式。
(1) 加载数据

scala> val df = spark.read.load("examples/src/main/resources/users.parquet")
scala> df.show

(2) 保存数据

scala> var df = spark.read.json("/opt/module/data/input/people.json")
//保存为 parquet 格式
scala> df.write.mode("append").save("/opt/module/data/output")

2.6.3 JSON

  Spark SQL 能够自动推测 JSON 数据集的结构，并将它加载为一个 Dataset[Row]. 可以通过 SparkSession.read.json()去加载 JSON 文件。

注意：Spark 读取的 JSON 文件不是传统的 JSON 文件，每一行都应该是一个 JSON 串。格式如下：

{"name":"Michael"}
{"name":"Andy"， "age":30}
[{"name":"Justin"， "age":19},{"name":"Justin"， "age":19}]

(1）导入隐式转换
import spark.implicits._
(2）加载 JSON 文件

val path = "/opt/module/spark-local/people.json"
val peopleDF = spark.read.json(path)

(3）创建临时表

peopleDF.createOrReplaceTempView("people")

(4）数据查询

val teenagerNamesDF = spark.sql("SELECT name FROM people
 WHERE age BETWEEN 13
AND 19")teenagerNamesDF.show()
+------+
| name|
+------+
|Justin|
+------+