1、SparkSession新的起始點
在老的版本中,SparkSQL提供兩種SQL查詢起始點:一個叫SQLContext,用於Spark自己提供的SQL查詢;一個叫HiveContext,用於連接Hive的查詢。
SparkSession是Spark最新的SQL查詢起始點,實質上是SQLContext和HiveContext的組合,所以在SQLContext和HiveContext上可用的API在SparkSession上同樣是可以使用的。SparkSession內部封裝了sparkContext,所以計算實際上是由sparkContext完成的。
2、DataFrame
創建
在Spark SQL中SparkSession是創建DataFrame和執行SQL的入口,創建DataFrame有三種方式:通過Spark的數據源進行創建;從一個存在的RDD進行轉換;還可以從Hive Table進行查詢返回。
從Spark數據源進行創建
(1)查看Spark數據源進行創建的文件格式
scala> spark.read.
csv format jdbc json load option options orc parquet schema table text textFile
準備數據
2.json編輯內容:
[root@hadoop105 datas]# vim 2.json
{"name":"zhangsan","age":20}
{"name":"lisi","age":24}
{"name":"wangwu","age":27}
(2)讀取json文件創建DataFrame
//讀取json文件創建DataFrame
scala> spark.read.json("file:///usr/local/hadoop/module/datas/2.json")
res24: org.apache.spark.sql.DataFrame = [age: bigint, name: string]
//創建一個DataFrame
scala> val df=spark.read.json("file:///usr/local/hadoop/module/datas/2.json")
df: org.apache.spark.sql.DataFrame = [age: bigint, name: string]
(3)結果展示
scala> df.show
+---+--------+
|age| name|
+---+--------+
| 20|zhangsan|
| 24| lisi|
| 27| wangwu|
+---+--------+
由於我們當前沒有數據表,但我們可以這樣執行:
//創建一張student表的視圖(對DataFrame創建一個臨時表)
scala> df.createTempView("student")
//即可直接查詢student數據表(數據是通過SQL語句實現查詢全表)
scala> spark.sql("select * from student").show
+---+--------+
|age| name|
+---+--------+
| 20|zhangsan|
| 24| lisi|
| 27| wangwu|
+---+--------+
//條件查詢
scala> spark.sql("select age from student").show
+---+
|age|
+---+
| 20|
| 24|
| 27|
+---+
//查詢年齡取平均值
scala> spark.sql("select avg(age) from student").show
+------------------+
| avg(age)|
+------------------+
|23.666666666666668|
+------------------+
2.2、SQL風格語法(主要)
(1)創建一個會話注意事項
//創建一個會話sql
scala> spark.newSession.sql("select age from student").show
報錯信息:
嘗試再次執行:
//回車鍵查看
scala> df
res32: org.apache.spark.sql.DataFrame = [age: bigint, name: string]
//Tab鍵查看
scala> df.create
createGlobalTempView createOrReplaceTempView createTempView
//對於DataFrame創建一個全局表
scala> df.createGlobalTempView("emp")
scala> spark.sql("select * from emp").show
報錯信息:
正確寫法,執行如下:
scala> spark.sql("select * from global_temp.emp").show
+---+--------+
|age| name|
+---+--------+
| 20|zhangsan|
| 24| lisi|
| 27| wangwu|
+---+--------+
注意:
臨時表是Session範圍內的,Session退出後,表就失效了。如果想應用範圍內有效,可以使用全局表。注意使用全局表時需要全路徑訪問,如:global_temp.emp
若遵守以上規則,我們嘗試換另一種寫法,照樣可以獲取:
scala> spark.newSession.sql("select * from global_temp.emp").show
+---+--------+
|age| name|
+---+--------+
| 20|zhangsan|
| 24| lisi|
| 27| wangwu|
+---+--------+
2.3、 DSL風格語法(次要)
(1)查看DataFrame的Schema信息
//回車鍵
scala> df.printSchema
root
|-- age: long (nullable = true)
|-- name: string (nullable = true)
(2)只查看”name”列數據
scala> df.select("name").show()
+--------+
| name|
+--------+
|zhangsan|
| lisi|
| wangwu|
+--------+
(3)查看”name”列數據以及”age+1”數據
//只查看年齡
scala> df.select("age").show()
+---+
|age|
+---+
| 20|
| 24|
| 27|
+---+
//若查看年齡都加1,這樣執行會報錯
scala> df.select("age"+1).show()
報錯信息:
正確執行:
//需要添加“$”符號
scala> df.select($"age"+1).show()
+---------+
|(age + 1)|
+---------+
| 21|
| 25|
| 28|
+---------+
(3)查看”age”大於”21”的數據
scala> df.filter($"age" > 21).show()
+---+------+
|age| name|
+---+------+
| 24| lisi|
| 27|wangwu|
+---+------+
(4)按照”age”分組,查看數據條數
scala> df.groupBy("age").count().show()
+---+-----+
|age|count|
+---+-----+
| 27| 1|
| 20| 1|
| 24| 1|
+---+-----+
2.4、RDD轉換爲DateFrame
注意:如果需要RDD與DF或者DS之間操作,那麼都需要引入 import spark.implicits._ 【spark不是包名,而是sparkSession對象的名稱】
前置條件:導入隱式轉換並創建一個RDD
通過手動確定轉換
//導入隱式轉換
scala> import spark.implicits._
import spark.implicits._
//創建RDD
scala> val rdd =sc.makeRDD(List(1,2,3,4))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[98] at makeRDD at <console>:27
//創建DataFrame(結構)
scala> rdd.toDF("id")
res45: org.apache.spark.sql.DataFrame = [id: int]
//修改一下DataFrame
scala> val df= rdd.toDF("id")
df: org.apache.spark.sql.DataFrame = [id: int]
//主鍵(將普通數據增加結構化信息,有了含義就靈活查詢sql)
scala> df.show
+---+
| id|
+---+
| 1|
| 2|
| 3|
| 4|
+---+
案例:
//創建一個RDD
scala> val rdd = sc.makeRDD(List((1,"zhangsan",20),(2,"lisi",25),(3,"wangwu",28)))
rdd: org.apache.spark.rdd.RDD[(Int, String, Int)] = ParallelCollectionRDD[102] at makeRDD at <console>:27
//把剛纔創建的指定一下結構(字段)
scala> rdd.toDF("id","name","age")
res47: org.apache.spark.sql.DataFrame = [id: int, name: string ... 1 more field]
//取名
scala> val df = rdd.toDF("id","name","age")
df: org.apache.spark.sql.DataFrame = [id: int, name: string ... 1 more field]
//展現
scala> df.show
+---+--------+---+
| id| name|age|
+---+--------+---+
| 1|zhangsan| 20|
| 2| lisi| 25|
| 3| wangwu| 28|
+---+--------+---+
如這張圖:
RDD可以轉換DataFrame
2.5、DataSet
通過反射確定(需要用到樣例類)
//創建一個樣例類
scala> case class People(name:String, age:Int)
defined class People
//創建一個RDD
scala> val rdd = sc.makeRDD(List(("zhangsan",23),("lisi",27),("wangwu",29)))
rdd: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[106] at makeRDD at <console>:27
//根據樣例類將RDD轉換爲對象類型
scala> val people =rdd.map(t => {People(t._1,t._2)} )
people: org.apache.spark.rdd.RDD[People] = MapPartitionsRDD[107] at map at <console>:31
//根據樣例類將RDD轉換爲DataFrame
scala> val df = people.toDF
df: org.apache.spark.sql.DataFrame = [name: string, age: int]
//展示
scala> df.show
+--------+---+
| name|age|
+--------+---+
|zhangsan| 23|
| lisi| 27|
| wangwu| 29|
+--------+---+
2.6、DateFrame轉換爲RDD
把有結構的數據轉化爲無結構
直接調用rdd即可
//將DataFrame轉換爲RDD
scala> df.rdd
res50: org.apache.spark.rdd.RDD[org.apache.spark.sql.Row] = MapPartitionsRDD[114] at rdd at <console>:36
//打印RDD
scala> df.collect
res51: Array[org.apache.spark.sql.Row] = Array([zhangsan,23], [lisi,27], [wangwu,29])
2.7、DataSet
Dataset是具有強類型的數據集合,需要提供對應的類型信息。
//創建一個樣例類
scala> case class Person(name: String, age: Long)
defined class Person
//創建DataSet
scala> val caseClassDS = Seq(Person("Andy", 32)).toDS()
caseClassDS: org.apache.spark.sql.Dataset[Person] = [name: string, age: bigint]
//顯示
scala> caseClassDS.show
+----+---+
|name|age|
+----+---+
|Andy| 32|
+----+---+
//DataSet
scala> caseClassDS.createTempView("xxx")
scala> spark.sql("select * from xxx").show
+----+---+
|name|age|
+----+---+
|Andy| 32|
+----+---+
DataFrame與Dataset結構不同
RDD轉換爲DataSet
SparkSQL能夠自動將包含有case類的RDD轉換成DataFrame,case類定義了table的結構,case類屬性通過反射變成了表的列名。
//查看是否有創建過rdd
scala> rdd
res58: org.apache.spark.rdd.RDD[(String, Int)] = ParallelCollectionRDD[106] at makeRDD at <console>:27
//打印rdd信息
scala> rdd.collect
res59: Array[(String, Int)] = Array((zhangsan,23), (lisi,27), (wangwu,29))
// 創建一個樣例類
scala> case class Person(name: String, age: Long)
defined class Person
//將RDD轉化爲DataSet
scala> val mapRDD =rdd.map(t => { Person(t._1,t._2) } )
mapRDD: org.apache.spark.rdd.RDD[Person] = MapPartitionsRDD[119] at map at <console>:31
scala> mapRDD.toDS
res60: org.apache.spark.sql.Dataset[Person] = [name: string, age: bigint]
//打印還是有數據
scala> mapRDD.toDS.show
+--------+---+
| name|age|
+--------+---+
|zhangsan| 23|
| lisi| 27|
| wangwu| 29|
+--------+---+
DataSet轉換爲RDD
調用rdd方法即可。
//查看是Dataset類型
scala> val ds = mapRDD.toDS
ds: org.apache.spark.sql.Dataset[Person] = [name: string, age: bigint]
//調用rdd方法,就轉化爲rdd
scala> ds.rdd
res62: org.apache.spark.rdd.RDD[Person] = MapPartitionsRDD[124] at rdd at <console>:36
DataFrame與DataSet的互操作
DataFrame轉換爲DataSet:
//打印rdd的數據信息
scala> rdd.collect
res63: Array[(String, Int)] = Array((zhangsan,23), (lisi,27), (wangwu,29))
//把RDD轉化爲DataFrame
scala> val df = rdd.toDF("name","age")
df: org.apache.spark.sql.DataFrame = [name: string, age: int]
//DataFrame轉化爲Dataset
scala> df.as[Person]
res64: org.apache.spark.sql.Dataset[Person] = [name: string, age: int]
Dataset轉換爲DataFrame
//查看是Dataset類型
scala> val ds =df.as[Person]
ds: org.apache.spark.sql.Dataset[Person] = [name: string, age: int]
//Dataset轉換爲DataFrame類型
scala> df.toDF
res66: org.apache.spark.sql.DataFrame = [name: string, age: int]
這種方法就是在給出每一列的類型後,使用as方法,轉成Dataset,這在數據類型是DataFrame又需要針對各個字段處理時極爲方便。在使用一些特殊的操作時,一定要加上 import spark.implicits._ 不然toDF、toDS無法使用。
RDD、DataFrame、DataSet
在SparkSQL中Spark爲我們提供了兩個新的抽象,分別是DataFrame和DataSet。他們和RDD有什麼區別呢?首先從版本的產生上來看:
RDD (Spark1.0) —> Dataframe(Spark1.3) —> Dataset(Spark1.6)
如果同樣的數據都給到這三個數據結構,他們分別計算之後,都會給出相同的結果。不同是的他們的執行效率和執行方式。
在後期的Spark版本中,DataSet會逐步取代RDD和DataFrame成爲唯一的API接口。
三者的共性
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 _=>
""
}
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、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")
}
(2)DataFrame與Dataset一般不與spark mlib同時使用
(3)DataFrame與Dataset均支持sparksql的操作,比如select,groupby之類,還能註冊臨時表/視窗,進行sql語句操作,如:
(4)DataFrame與Dataset支持一些特別方便的保存方式,比如保存成csv,可以帶上表頭,這樣每一列的字段名一目瞭然
//保存
val saveoptions = Map("header" -> "true", "delimiter" -> "\t", "path" -> "hdfs://hadoop105:9000/test")
datawDF.write.format("com.atguigu.spark.csv").mode(SaveMode.Overwrite).options(saveoptions).save()
//讀取
val options = Map("header" -> "true", "delimiter" -> "\t", "path" -> "hdfs://hadoop105:9000/test")
val datarDF= spark.read.options(options).format("com.atguigu.spark.csv").load()
利用這樣的保存方式,可以方便的獲得字段名和列的對應,而且分隔符(delimiter)可以自由指定。
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)
}
可以看出,Dataset在需要訪問列中的某個字段時是非常方便的,然而,如果要寫一些適配性很強的函數時,如果使用Dataset,行的類型又不確定,可能是各種case class,無法實現適配,這時候用DataFrame即Dataset[Row]就能比較好的解決問題