Spark SQL 入门 DF、DS

Spark SQL 入门

SparkSession

Spark中所有功能的入口点都是SparkSession类。要创建基本的SparkSession，只需使用SparkSession.builder()：

import org.apache.spark.sql.SparkSession
val spark = SparkSession
.builder()
.appName(“Spark SQL basic example”)
.config(“spark.some.config.option”, “some-value”)
.getOrCreate()
// 导入RDD到DF的隐式转换
import spark.implicits._

Dataset

Dataset 是分布式数据集合。提供了RDD的优势（强类型，使用强大的lambda函数的能力）和Spark SQL优化执行引擎的优点。

DataFrame

DataFrame是一个组织成命名列的数据集。在Scala API中，DataFrame它只是一个类型别名Dataset[Row]。
DataFrame可以从多种来源构建，例如：结构化数据文件，Hive中的表，外部数据库或现有RDD。

RDD.DataFrame.DataSet的区别和联系

共性:

1）都是spark中得弹性分布式数据集，轻量级
2）都是惰性机制，延迟计算
3）根据内存情况，自动缓存，加快计算速度
4）都有partition分区概念
5）众多相同得算子：map flatmap 等等

区别：

1）RDD不支持SQL
2）DF每一行都是Row类型，不能直接访问字段，必须解析才行
3）DS每一行是什么类型是不一定的，在自定义了case class之后可以很自由的获 得每一行的信息
4）DataFrame与Dataset均支持spark sql的操作，比如select，group by之类，还 能注册临时表/视窗，进行sql语句操作
5）可以看出，Dataset在需要访问列中的某个字段时是非常方便的，然而，如果要 写一些适配性很强的函数时，如果使用Dataset，行的类型又不确定，可能是 各种case class，无法实现适配，这时候用DataFrame即Dataset[Row]就能比较 好的解决问题。

相互转换

DataFrame/Dataset转RDD：

val rdd1=testDF.rdd
val rdd2=testDS.rdd

RDD转DataFrame：

import spark.implicits._
val testDF = rdd.map {line=>
(line._1,line._2)
}.toDF(“col1”,“col2”)

RDD转Dataset：

import spark.implicits._
case class Coltest(col1:String,col2:Int)extends Serializable //定义字段名和类型
val testDS = rdd.map {line=>
Coltest(line._1,line._2)
}.toDS

Dataset转DataFrame：

//把case class封装成Row
import spark.implicits._
val testDF = testDS.toDF

DataFrame转Dataset：

import spark.implicits._
case class Coltest(col1:String,col2:Int)extends Serializable //定义字段名和类型
val testDS = testDF.as[Coltest]

特别注意：
在使用一些特殊的操作时，一定要加上隐式转换 import spark.implicits._ 不然toDF、toDS无法使用

创建 DataFrames

val df = spark.read.json(“examples/src/main/resources/people.json”)
df.show()

DataFrame操作

import spark.implicits._
// 打印schema
df.printSchema()
// 查询 name列
df.select(“name”).show()
//查询name列 名字加1
df.select($“name”, $"age"+1).show()//查询年龄大于21的人df.filter($“age” > 21).show()
// Count people by age
df.groupBy(“age”).count().show()

以编程方式运行SQL查询

df.createOrReplaceTempView(“people”)
val sqlDF = spark.sql(“SELECT * FROM people”)
sqlDF.show()

创建Dataset

case class Person(name: String, age: Long)
val caseClassDS = Seq(Person(“Andy”, 32)).toDS()
caseClassDS.show()
// DataFrames 转换成 Dataset
val path = “examples/src/main/resources/people.json”
val peopleDS = spark.read.json(path).as[Person]
peopleDS.show()

和RDD的相互操作

使用反射推断模式

import spark.implicits._
// 创建RDD[Person]转换成Dataframe
val peopleDF = spark.sparkContext
.textFile(“examples/src/main/resources/people.txt”)
.map(_.split(","))
.map(attributes => Person(attributes(0), attributes(1).trim.toInt))
.toDF()
peopleDF.createOrReplaceTempView(“people”)
val teenagersDF = spark.sql(“SELECT name, age FROM people WHERE age BETWEEN 13 AND 19”)
teenagersDF.map(teenager => "Name: " + teenager(0)).show()
teenagersDF.map(teenager => "Name: " + teenager.getAsString).show()

以编程方式指定schema

1.Row从原始RDD 创建s的RDD;
2.创建由StructType匹配Row步骤1中创建的RDD中的s 结构 表示的模式。
3.Row通过createDataFrame提供的方法将模式应用于s 的RDD SparkSession。

import org.apache.spark.sql.types._
//创建RDD
val peopleRDD = spark.sparkContext.textFile(“examples/src/main/resources/people.txt”)
val schemaString = “name age”
// 创建schema
val fields = schemaString.split(" “)
.map(fieldName => StructField(fieldName, StringType, nullable = true))
val schema = StructType(fields)
// RDD[String] 转化为RDD[Row]
val rowRDD = peopleRDD
.map(_.split(”,"))
.map(attributes => Row(attributes(0), attributes(1).trim))
/创建DF
val peopleDF = spark.createDataFrame(rowRDD, schema)=
peopleDF.createOrReplaceTempView(“people”)
val results = spark.sql(“SELECT name FROM people”)
results.map(attributes => "Name: " + attributes(0)).show()