Spark SQL详解

最新推荐文章于 2023-02-06 17:00:19 发布
最新推荐文章于 2023-02-06 17:00:19 发布
阅读量1.9k 收藏 8
点赞数 1
分类专栏： 大数据 文章标签： sparkSQL DataFrame DataSet SparkSession Spark on Hive
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BigData_Hobert/article/details/108969380
版权

spark 系列

Spark 核心原理及运行架构

Spark RDD详解

Spark 常用算子大全

Spark SQL 详解

Spark SQL

前言

看了前面的几篇 Spark 博客，相信大家对于 Spark 的基础框架、RDD和核心 SparkCore 已经搞明白了。本篇博客将为大家详细介绍了 Spark 一个重要的内置模块 Spark SQL 。这是工作中最常用的一个内置模块之一。

Spark SQL 简介

什么是Spark SQL?

Spark SQL是Spark用来处理结构化数据的一个模块，它提供了2个编程抽象：DataFrame和DataSet，并且作为分布式SQL查询引擎的作用。

我们已经学习了Hive，它是将Hive SQL转换成MapReduce然后提交到集群上执行，大大简化了编写MapReduce的程序的复杂性，由于MapReduce这种计算模型执行效率比较慢。所以Spark SQL的应运而生，它是将Spark SQL转换成RDD，然后提交到集群执行，执行效率非常快！同时Spark SQL也支持从Hive中读取数据。

Spark SQL 的由来

SQL是一种传统的用来进行数据分析的标准，为了解决SQL on hadoop的问题，早期有以下几种方案：

  • Hive是原始的SQL-on-Hadoop解决方案
  • Impala：和Hive一样，提供了一种可以针对已有Hadoop数据编写SQL查询的方法
  • Presto：类似于Impala，未被主要供应商支持
  • Shark：Spark SQL的前身，设计目标是作为Hive的一个补充
  • Phoenix：基于HBase的开源SQL查询引擎

Shark的初衷：让Hive运行在Spark之上。Spark 是对Hive的改造，继承了大量Hive代码，给优化和维护带来了大量的麻烦。

在这里插入图片描述

Spark SQL 的特点

1. 易整合（集成）
在这里插入图片描述

2. 统一的数据访问方式
在这里插入图片描述

3. 兼容Hive
在这里插入图片描述

4. 标准的数据连接
在这里插入图片描述

Spark SQL 框架结构

在这里插入图片描述
如上图所示，Spark SQL有以下主要功能：

  • Spark SQL是Spark的核心组件之一（2014.4 Spark1.0）
  • 能够直接访问现存的Hive数据
  • 提供JDBC/ODBC接口供第三方工具借助Spark进行数据处理
  • 提供了更高层级的接口方便地处理数据
  • 支持多种操作方式：SQL、API编程
  • 支持多种外部数据源：Parquet、JSON、RDBMS等

Spark SQL的核心 Catalyst优化器（了解）

在这里插入图片描述
Catalyst优化器是Spark SQL的核心。

在 深入研究Spark SQL的Catalyst优化器（原创翻译） 对Spark SQL的核心 Catalyst优化器的原理写的很清楚，这里我就简单的说一下 Catalyst优化器 优化一条SQL语句的大致流程。

例如，如下一条简单的SQL语句，Catalyst优化器是如何去优化的呢？

SELECT name FROM
(
    SELECT id, name FROM people
) p
WHERE p.id = 1

如下图所示，Catalyst优化器的优化主要在投影上面查询过滤器并检查过滤是否可下压。一句话概括来说，Catalyst优化器的优化会自动选择最优执行效率的方案，这在过滤删选操作是非常实用的，可以减少hive SQL所必要的子查询嵌套，使代码变得简单一点。
在这里插入图片描述

Spark SQL 常用API

SparkContext 与 SparkSession

在Spark 2.0以前的版本中，SparkSQL提供两种SQL查询起始点：一个叫SQLContext，用于Spark自己提供的SQL查询编程入口；一个叫HiveContext，是SQLContext的子集，提供更多的功能，主要用于连接Hive的查询。

SparkSession是Spark最新的SQL查询起始点，实质上是SQLContext和HiveContext的组合，所以在SQLContext和HiveContext上可用的API在SparkSession上同样是可以使用的。SparkSession内部封装了sparkContext，所以计算实际上是由sparkContext完成的。SparkSession提供与Spark功能交互单一入口点，并允许使用DataFrame和Dataset API对Spark进行编程。

SparkSession 创建语法：

val spark = SparkSession.builder.master("master").appName("appName").getOrCreate()

注意：

  • 无特殊说明时，下文中“spark”均指SparkSession实例；
  • 如果是spark-shell下，会自动创建“sc”和“spark”；
  • master通常为local[*]，制定开启CPU核数进行计算，*可为任何整数，如果为*本身，代表动用计算机现有可用CPU核数。

在spark的早期版本中，SparkContext是spark的主要切入点，由于RDD是主要的API，我们通过sparkcontext来创建和操作RDD。对于每个其他的API，我们需要使用不同的context。例如，对于Streming，我们需要使用StreamingContext；对于sql，使用sqlContext；对于Hive，使用hiveContext。但是随着DataSet和DataFrame的API逐渐成为标准的API，就需要为他们建立接入点。

SparkContext 创建语法：

val conf = new SparkConf().setMaster("master").setAppName("appName")
val sc = new SparkContext(conf)

创建sparkContext对象：主要用于读取需要处理的数据，封装在RDD集合中；调度jobs执行。

SparkSession内部封装了SparkContext，所以计算实际上是由SparkContext完成的。

DataFrame

与RDD类似，DataFrame也是一个分布式数据容器。然而DataFrame更像传统数据库的二维表格，除了数据以外，还记录数据的结构信息，即schema。同时，与Hive类似，DataFrame也支持嵌套数据类型（struct、array和map）。从API易用性的角度上看，DataFrame API提供的是一套高层的关系操作，比函数式的RDD API要更加友好，门槛更低。
在这里插入图片描述
上图直观地体现了DataFrame和RDD的区别。左侧的RDD[Person]虽然以Person为类型参数，但Spark框架本身不了解Person类的内部结构。而右侧的DataFrame却提供了详细的结构信息，使得Spark SQL可以清楚地知道该数据集中包含哪些列，每列的名称和类型各是什么。DataFrame是为数据提供了Schema的视图。可以把它当做数据库中的一张表来对待，DataFrame也是懒执行的。性能上比RDD要高。

RDD是分布式的 Java对象的集合。DataFrame是分布式的Row对象的集合。DataFrame除了提供了比RDD更丰富的算子以外，更重要的特点是提升执行效率、减少数据读取以及执行计划的优化。

创建方式与使用

在Spark SQL中SparkSession是创建DataFrame和执行SQL的入口，创建DataFrame有三种方式：通过Spark的数据源进行创建；从一个存在的RDD进行转换；还可以从Hive Table进行查询返回。

1. 通过Spark的数据源进行创建

json.txt 源数据：

{"name":"hubert","age":"100"}
{"name":"rose","age":"10"}
{"name":"jack","age":"39"}
{"name":"henry","age":"34"}

val spark = SparkSession.builder().appName("test").master("local[*]").getOrCreate()
// 读取json文件
val df = spark.read.format("json").load("data/json.txt")
// 操作
df.select("name","age").show(false)
spark.close()

// 结果
+------+---+
|name  |age|
+------+---+
|hubert|100|
|rose  |10 |
|jack  |39 |
|henry |34 |
+------+---+

2. 从RDD中转换

下面 RDD转换为DateFrame 会细说。

3. 从Hive Table进行查询返回

这个将在后面的博文中涉及到，这里暂且不谈。

SQL风格语法（主要）

object Test04 {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().appName("test").master("local[*]").getOrCreate()

    // 1）创建一个DataFrame
    val df = spark.read.json("data/json.txt")

    // 2）对DataFrame创建一个临时表
    df.createOrReplaceTempView("people")

    // 3）通过SQL语句实现查询全表
    val sqlDF = spark.sql("SELECT * FROM people")

    // 4）结果展示
    sqlDF.show(false)

    // 5）对于DataFrame创建一个全局表
    df.createGlobalTempView("people")

    // 6）通过SQL语句实现查询全表
    spark.sql("select * from global_temp.people").show(false)

    spark.close()
  }
}

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

全局的临时视图存在于系统数据库 global_temp中，我们必须加上库名去引用它

DSL 风格语法 (次要)

object Test04 {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().appName("test").master("local[*]").getOrCreate()
    // 导入 sparkSession 对象spark的隐式类
    import spark.implicits._

    // 1）创建一个DataFrame
    val df = spark.read.json("data/json.txt")

    // 2）查看DataFrame的Schema信息
    df.printSchema()

    // 3）只查看"name"列数据
    df.select("name").show(false)

    // 4）查看"name"列数据以及"age+1"数据
    df.select($"name",$"age" + 1).show(false)

    // 5）查看"age"大于"21"的数据
    df.filter($"age" >21).show(false)

    // 6）按照"age"分组，查看数据条数
    df.groupBy("age").count().show()

    spark.close()
  }
}

结果：

root
 |-- age: string (nullable = true)
 |-- name: string (nullable = true)

+------+
|name  |
+------+
|hubert|
|rose  |
|jack  |
|henry |
+------+

+------+---------+
|name  |(age + 1)|
+------+---------+
|hubert|101.0    |
|rose  |11.0     |
|jack  |40.0     |
|henry |35.0     |
+------+---------+

+---+------+
|age|name  |
+---+------+
|100|hubert|
|39 |jack  |
|34 |henry |
+---+------+

+---+-----+
|age|count|
+---+-----+
| 34|    1|
|100|    1|
| 10|    1|
| 39|    1|
+---+-----+

RDD转换为DateFrame

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

1. 元组方式导入

object MyDf {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[*]").appName("test").getOrCreate()
    import spark.implicits._
    val df= spark.sparkContext.textFile("data/ds.txt").map(line=>{
      val strs = line.split(" ")
      (strs(0).toInt,strs(1),strs(2).toInt)
    }).toDF("userID","userName","age")
    df.show(false)
  }
}

元组方式需要类型转换。

2. 样例类方式导入

// 定义样例类
case class UserInfo1(userId:Int,userName:String,age:Int)
object MyDf {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[*]").appName("test").getOrCreate()

    import spark.implicits._
    val df= spark.sparkContext.textFile("data/ds.txt").map(line=>{
      val strs = line.split(" ")
      UserInfo1(strs(0).toInt,strs(1),strs(2).toInt)
    }).toDF
    df.show(false)
  }
}

样例类无需进行类型转换。

3. 指定Row-Schema编程导入

object MyDf {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[*]").appName("test").getOrCreate()
    
    val rdd = spark.sparkContext.textFile("file:///F:\\IT\\study\\java\\myspark01\\data\\ds.txt")
      .map(line=>{
        val strs = line.split(" ")
        Row(strs(0).toInt,strs(1),strs(2).toInt)
      })

	// 创建 结构schema
    val schema = StructType(Seq(
      StructField("useId",IntegerType,false),
      StructField("userName",StringType,false),
      StructField("age",IntegerType,false)
    ))
    val df = spark.createDataFrame(rdd,schema)
    df.show(false)
  }
}

这种方式不常用，比较复杂。

DateFrame 转换为RDD

直接调用rdd即可。

object MyDf {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[*]").appName("test").getOrCreate()
    import spark.implicits._
    val rdd = spark.sparkContext.textFile("data/ds.txt").rdd
  }
}

DataSet

1）是Dataframe API(Spark 1.6之后)的一个扩展，是Spark最新的数据抽象。

2）用户友好的API风格，既具有类型安全检查也具有Dataframe的查询优化特性。

3）Dataset支持编解码器，当需要访问非堆上的数据时可以避免反序列化整个对象，提高了效率。

4）样例类被用来在Dataset中定义数据的结构信息，样例类中每个属性的名称直接映射到DataSet中的字段名称。

5）Dataframe是Dataset的特列，DataFrame=Dataset[Row] ，所以可以通过as方法将Dataframe转换为Dataset。Row是一个类型，跟Car、Person这些的类型一样，所有的表结构信息我都用Row来表示。

6）DataSet是强类型的。可以使用强大的lambda函数的能力，比如可以有Dataset[Car]，Dataset[Person]。

7）DataFrame只是知道字段，但是不知道字段的类型，所以在执行这些操作的时候是没办法在编译的时候检查是否类型失败的，比如你可以对一个String进行减法操作，在执行的时候才报错，而DataSet不仅仅知道字段，而且知道字段类型，所以有更严格的错误检查。就跟JSON对象和类对象之间的类比。

8）一个Dataset 可以从JVM对象构造，然后使用函数转换（map， flatMap，filter等）去操作。 Dataset API 支持Scala和Java。 Python不支持Dataset API。

创建方式

1）创建一个样例类
scala> case class Person(name: String, age: Long)
defined class Person

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

RDD转换为DataSet

SparkSQL能够自动将包含有case类的RDD转换成DataFrame，case类定义了table的结构，case类属性通过反射变成了表的列名。

case class UserInfo(userId:Int,userName:String,birthday:String)
object MyDs {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[*]").appName("test").getOrCreate()

    val rdd = spark.sparkContext.textFile("data/ds.txt").map(line=>{
    val strs = line.split(" ")
      UserInfo1(strs(0).toInt,strs(1),strs(2).toInt)
    })
    import spark.implicits._
    spark.createDataset(rdd).show(false)
  }
}

DataSet 转换为RDD

调用rdd方法即可。

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

2）将DataSet转换为RDD
scala> DS.rdd
res11: org.apache.spark.rdd.RDD[Person] = MapPartitionsRDD[15] at rdd at <console>:28

DataFrame与DataSet的互操作

DataSet转DataFrame

这个很简单理解，因为只是把case class封装成Row。

1）导入隐式转换
import spark.implicits._

（2）转换
val testDF = testDS.toDF

DataFrame转DataSet

（1）导入隐式转换
import spark.implicits._

（2）创建样例类
case class Coltest(col1:String,col2:Int)extends Serializable //定义字段名和类型

（3）转换
val testDS = testDF.as[Coltest]

这种方法就是在给出每一列的类型后，使用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:

  • RDD一般和spark mlib(机器学习库)同时使用

  • RDD不支持sparksql操作

2. DataFrame:

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

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

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

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

  • 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.csv").load()

3. 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]就能比较好的解决问题。

转化总结

关于RDD、DataFrame、DataSet之间如何相互转换，上面已经说过了，下面用一张图总结一下。
在这里插入图片描述

案列

所有交易的周分布情况 ：

import java.text.SimpleDateFormat
import java.time.LocalDate
import java.time.format.DateTimeFormatter
import java.util.Calendar

import org.apache.spark.sql.SparkSession
// 手动导包
import org.apache.spark.sql.functions._

object MyDay {
  def dayChange(datestr:String)={
    val arr = Array("日","一","二","三","四","五","六")
    val cal = Calendar.getInstance()
    cal.setTime(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").parse(datestr))
    arr(cal.get(Calendar.DAY_OF_WEEK)-1)
  }

  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[*]").appName("test").getOrCreate()
    val df = spark.read.format("csv").load("dfdata/orders.csv")
      .toDF("orderId","orddate","userId","status")

    val cs = spark.read.format("csv").load("dfdata/customers.csv")
      .toDF("userId","lname","fname","pwd1","pwd2","address","city","country","zip")

    val item = spark.read.format("csv").load("dfdata/order_items.csv")
      .toDF("id","orderId","productId","buyNum","countPrice","price")

    //    所有交易的周分布情况
    // 方法一：SQL语句操作+hive Sql函数
    df.createOrReplaceTempView("orders")
    spark.sql("""select
        |case dayofweek(orddate) when 1 then "Sunday" when 2 then "Monday"
        |when 3 then "Tuesday" when 4 then "wednesday" when 5 then "Tuesday"
        |when 6 then "Friday" else "Saturday" end weekday,count(*)
        |from orders group by dayofweek(orddate)""".stripMargin).show(false)

    // 方法二  （最常用）：自定义UDF+df算子操作
    import spark.implicits._

    // 自定义UDF
    val wdChange = udf{num:Int=>
      num match {
        case 1 => "Sunday"
        case 2 => "Monday"
        case 3 => "Tuesday"
        case 4 => "wednesday"
        case 5 => "Tuesday"
        case 6 => "Friday"
        case _ => "Saturday"
      }
    }

    df.groupBy(dayofweek($"orddate").as("weekday"))
      .agg(count("orderId").alias("countid"))
      .withColumn("wd",wdChange($"weekday")).drop("weekday")
      .show(false)

    // 方法三：DF算子+LocalDate库操作
    df.select("orderId","orddate").map(f=>(
      LocalDate.parse(f(1).toString,
        DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss")).getDayOfWeek.getValue,f(0).toString))
        .rdd.groupByKey().foreach(x=>println(x._1,x._2.size))

    // 方法四：DF算子+自定义函数dayChange操作
    df.select("orderId","orddate").map(f=>(dayChange(f(1).toString),f(0).toString))
      .rdd.groupByKey().foreach(x=>println(x._1,x._2.size))

    df.select("orderId","orddate").map(f=>(dayChange(f(1).toString),f(0).toString))
      .groupBy("_1").agg("_2"->"count").show(false)
  }
}

SparkSession 数据读取与保存

Spark的数据读取及数据保存可以从两个维度来作区分：文件格式以及文件系统。文件格式分为：Text文件、Json文件、Csv文件、Sequence文件以及Object文件；文件系统分为：本地文件系统、HDFS、Hive以及数据库。

文件类数据读取与保存

Text文件

1）数据读取：textFile(String)

scala> val hdfsFile = sc.textFile("hdfs://vmsingle:9000/fruit.txt")
hdfsFile: org.apache.spark.rdd.RDD[String] = hdfs://vmsingle:9000/fruit.txt MapPartitionsRDD[21] at textFile at <console>:24

2）数据保存: saveAsTextFile(String)

scala> hdfsFile.saveAsTextFile("/fruitOut")

在这里插入图片描述

Json文件

如果JSON文件中每一行就是一个JSON记录，那么可以通过将JSON文件当做文本文件来读取，然后利用相关的JSON库对每一条数据进行JSON解析。

注意：使用RDD读取JSON文件处理很复杂，同时SparkSQL集成了很好的处理JSON文件的方式，所以应用中多是采用SparkSQL处理JSON文件。

json.txt 源数据：

{"name":"hubert","age":"100"}
{"name":"rose","age":"10"}
{"name":"jack","age":"39"}
{"name":"henry","age":"34"}

textFile读取json文件：

val conf = new SparkConf().setMaster("local[*]").setAppName("test")
val sc = new SparkContext(conf)

// 导入解析json所需的包
import scala.util.parsing.json.JSON
// 读取json文件
val rdd = sc.textFile("data/json.txt")
// 解析json数据
val result = rdd.map(line=>JSON.parseFull(line))
// 操作
result.foreach(f=>println(f.get.asInstanceOf[Map[String,String]].get("name").get))
sc.stop()

// 结果
hubert
jack
rose
henry

read.format 读取json文件：

val spark = SparkSession.builder().appName("test").master("local[*]").getOrCreate()
// 读取json文件
val df = spark.read.format("json").load("data/json.txt")
// 操作
df.select("name","age").show(false)
spark.close()

// 结果
+------+---+
|name  |age|
+------+---+
|hubert|100|
|rose  |10 |
|jack  |39 |
|henry |34 |
+------+---+

Sequence文件

SequenceFile文件是Hadoop用来存储二进制形式的key-value对而设计的一种平面文件(Flat File)。Spark 有专门用来读取 SequenceFile 的接口。在 SparkContext 中，可以调用 sequenceFile[ keyClass, valueClass](path)。

注意：SequenceFile文件只针对PairRDD

1)创建一个RDD
scala> val rdd = sc.parallelize(Array((1,2),(3,4),(5,6)))
rdd: org.apache.spark.rdd.RDD[(Int, Int)] = ParallelCollectionRDD[13] at parallelize at <console>:24

2)将RDD保存为Sequence文件
scala> rdd.saveAsSequenceFile("file:///opt/spark234/seqFile")

3）查看该文件
[root@vmsingle seqFile]# pwd
/opt/spark234/seqFile

[root@vmsingle seqFile]# ll
总用量 8
-rw-r--r-- 1 root root 108 10月  9 10:29 part-00000
-rw-r--r-- 1 root root 124 10月  9 10:29 part-00001
-rw-r--r-- 1 root root 0 10月  9 10:29 _SUCCESS

[root@vmsingle seqFile]#  cat part-00000

4）读取Sequence文件
scala> val seq = sc.sequenceFile[Int,Int]("file:///opt/spark234/seqFile")
seq: org.apache.spark.rdd.RDD[(Int, Int)] = MapPartitionsRDD[18] at sequenceFile at <console>:24

5）打印读取后的Sequence文件
scala> seq.collect
res14: Array[(Int, Int)] = Array((1,2), (3,4), (5,6))

对象文件

对象文件是将对象序列化后保存的文件，采用Java的序列化机制。可以通过objectFile[k,v](path) 函数接收一个路径，读取对象文件，返回对应的 RDD，也可以通过调用saveAsObjectFile() 实现对对象文件的输出。因为是序列化所以要指定类型。

1）创建一个RDD
scala> val rdd = sc.parallelize(Array(1,2,3,4))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[19] at parallelize at <console>:24

2）将RDD保存为Object文件
scala> rdd.saveAsObjectFile("file:///opt/spark234/objectFile")

3）查看该文件
[root@vmsingle seqFile]# pwd
/opt/spark234/objectFile

[root@vmsingle seqFile]# ll
总用量 8
-rw-r--r-- 1 atguigu atguigu 142 10月  9 10:37 part-00000
-rw-r--r-- 1 atguigu atguigu 142 10月  9 10:37 part-00001
-rw-r--r-- 1 atguigu atguigu   0 10月  9 10:37 _SUCCESS

[root@vmsingle seqFile]# cat part-00000 
SEQ!org.apache.hadoop.io.NullWritable"org.apache.hadoop.io.BytesWritableW@`l

4）读取Object文件
scala> val objFile = sc.objectFile[Int]("file:///opt/spark234/objectFile")
objFile: org.apache.spark.rdd.RDD[Int] = MapPartitionsRDD[31] at objectFile at <console>:24

5）打印读取后的Object文件
scala> objFile.collect
res19: Array[Int] = Array(1, 2, 3, 4)

总结

  • SparkSQL 写数据：DataFrame/DataSet.write.json/csv/jdbc

  • SparkSQL读数据：SparkSession.read.json/csv/text/jdbc/format

文件系统类数据读取与保存

HDFS

Spark的整个生态系统与Hadoop是完全兼容的，所以对于Hadoop所支持的文件类型或者数据库类型，Spark也同样支持。另外，由于Hadoop的API有新旧两个版本，所以Spark为了能够兼容Hadoop所有的版本，也提供了两套创建操作接口。对于外部存储创建操作而言，hadoopRDD和newHadoopRDD是最为抽象的两个函数接口，主要包含以下四个参数。

1）输入格式(InputFormat): 制定数据输入的类型,如TextInputFormat等,新旧两个版本所引用的版本分别是org.apache.hadoop.mapred.InputFormat和org.apache.hadoop.mapreduce.InputFormat(NewInputFormat)

2）键类型: 指定[K,V]键值对中K的类型

3）值类型: 指定[K,V]键值对中V的类型

4）分区值: 指定由外部存储生成的RDD的partition数量的最小值,如果没有指定,系统会使用默认值defaultMinSplits。

注意：其他创建操作的API接口都是为了方便最终的Spark程序开发者而设置的，是这两个接口的高效实现版本。例如，对于textFile而言，只有path这个指定文件路径的参数，其他参数在系统内部指定了默认值。

  • 在Hadoop中以压缩形式存储的数据，不需要指定解压方式就能够进行读取，因为Hadoop本身有一个解压器会根据压缩文件的后缀推断解压算法进行解压。

  • 如果用Spark从Hadoop中读取某种类型的数据不知道怎么读取的时候，上网查找一个使用map-reduce的时候是怎么读取这种这种数据的，然后再将对应的读取方式改写成上面的hadoopRDD和newAPIHadoopRDD两个类就行了。

MySQL数据库连接

支持通过Java JDBC访问关系型数据库。需要通过JdbcRDD进行，示例如下:

(1）添加依赖

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.38</version>
</dependency>

(2）mysql读写操作

object LinkSql {
  def main(args: Array[String]): Unit = {
  	// 1.创建sparkSession 对象
    val spark = SparkSession.builder().appName("test").master("local[*]").getOrCreate()
    
    // 设置连接用户、密码、数据库驱动类
    val prop = new Properties()
    prop.setProperty("driver","com.mysql.jdbc.Driver")
    prop.setProperty("user","root")
    prop.setProperty("password","hubert")
    
    // 读取库hubert的表games的数据
    val jdbcDF = spark.read.jdbc("jdbc:mysql://192.168.152.140:3306/hubert","games",prop)
    jdbcDF.show(false)

	// 创建DF
    val df = spark.createDataFrame(spark.sparkContext.parallelize(
      Seq((4,"地下城","电竞网游","拳头","2007"), (5,"刀塔","电竞网游","拳头","2007")
      ))).toDF("gameId","gameName","gameType","gameCompany","gameYear")
    df.show(false)
    
    // DF写入库hubert的表games的数据
    df.write.mode("append").jdbc("jdbc:mysql://192.168.152.140:3306/hubert","games",prop)
  }
}

Hive 连接

Spark on hive 与 hive on spark 的区别

  1. Spark on hive

    是spark 通过Spark-SQL使用hive 语句，操作hive ,底层运行的还是 spark rdd。

    （1）就是通过sparksql，加载hive的配置文件，获取到hive的元数据信息

    （2）spark sql获取到hive的元数据信息之后就可以拿到hive的所有表的数据

    （3）接下来就可以通过spark sql来操作hive表中的数据

  2. hive on spark
    是把hive查询从mapreduce 的mr (Hadoop计算引擎)操作替换为spark rdd（spark 执行引擎） 操作. 相对于spark on hive,这个要实现起来则麻烦很多, 必须重新编译你的spark和导入jar包，不过目前大部分使用的是spark on hive。

Hive查询流程及原理

  • 执行HQL时，先到MySQL元数据库中查找描述信息，然后解析HQL并根据描述信息生成MR任务

  • Hive将SQL转成MapReduce执行速度慢

  • 使用SparkSQL整合Hive其实就是让SparkSQL去加载Hive 的元数据库，然后通过SparkSQL执行引擎去操作Hive表内的数据

  • 首先需要开启Hive的元数据库服务，让SparkSQL能够加载元数据

(1）添加依赖

<dependency>
  <groupId>org.apache.spark</groupId>
  <artifactId>spark-hive_2.11</artifactId>
  <version>2.3.4</version>
</dependency>

(2) 加载配置文件

Spark 有一个内置的 MateStore，使用 Derby 嵌入式数据库保存数据，但是这种方式不适合生产环境，因为这种模式同一时间只能有一个 SparkSession 使用，所以生产环境更推荐使用 Hive 的 MetaStore。

SparkSQL 整合 Hive 的 MetaStore 主要思路就是要通过配置能够访问它， 并且能够使用 HDFS 保存 WareHouse，所以可以直接拷贝 Hadoop 和 Hive 的配置文件到 Spark 的配置目录

  • hive-site.xml 元数据仓库的位置等信息
  • core-site.xml 安全相关的配置
  • hdfs-site.xml HDFS 相关的配置
    在这里插入图片描述

(3) 操作hive

object LinkHive {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[*]").appName("test").enableHiveSupport().getOrCreate()
    val df = spark.sql("select * from hubert.userinfos")
    df.show(false)
  }
}

Parquet

Parquet文件是一种流行的列式存储格式，以二进制存储，文件中包含数据与元数据。

object LinkParquet {
  def main(args: Array[String]): Unit = {
    val spark = SparkSession.builder().master("local[*]").appName("test").enableHiveSupport().getOrCreate()
    val sc = spark.sparkContext

    //Spark SQL写parquet文件
    import org.apache.spark.sql.types.{StructType, StructField, StringType,ArrayType,IntegerType}
    val schema=StructType(Array(StructField("name",StringType),
      StructField("favorite_color",StringType),
      StructField("favorite_numbers",ArrayType(IntegerType))))
    val rdd=sc.parallelize(List(("Alyssa",null,Array(3,9,15,20)),("Ben","red",null)))
    val rowRDD=rdd.map(p=>Row(p._1,p._2,p._3))
    val df=spark.createDataFrame(rowRDD,schema)

    //在该目录下生成parquet文件
    df.write.parquet("/data/users")

    //Spark SQL读parquet文件（该目录下存在parquet文件）
    val df1=spark.read.parquet("/data/users")
    df1.show
    df1.printSchema
  }
}

结果：
在这里插入图片描述

参考文章

深入研究Spark SQL的Catalyst优化器（原创翻译）

BigData_Hubert
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark SQL常见4种数据源详解
09-09
Spark SQL是Apache Spark的一部分，它提供了一种统一的方式来处理结构化和半结构化的数据。在本文中，我们将深入探讨Spark SQL中的四种常见数据源：Parquet、JSON、CSV和JDBC，并了解如何使用它们进行数据读取和写入...
Spark系列---sql详解
lipviolet的博客
03-06 1557
object _06SparkSQLAndCoreTest { def main(args: Array[String]): Unit = { Logger.getLogger("org.apach...
SparkSQL知识点总结
默主归沙的博客
06-06 3934
零基础学sparksql
SparkSQL详解
qq_40322236的博客
02-06 2050
Spark SQL是 Spark 用来处理结构化数据的一个模块，它提供了 2 个编程抽象：DataFrame 和 DataSet，并且作为分布式 SQL 查询引擎的作用。
Spark SQL 详解
WGS.
10-30 1209
文章目录RDD、dataframe、dataset的区别和联系封装spark和SCrdd、dataframe、dataset互相转换rdd转dataframe、datasetdf转rdd、dsds转rdd、dfdataframe的创建读取文本文件创建DataFrame读取json文件创建DataFrame读取parquet列式存储格式文件创建DataFrame读取mysql数据通过idea通过服务器spark-shell通过idea将数据写入到mysqlDSL风格和SQL风格DSL风格语法SQL风格语法sp
大数据技术之SparkSQL（超级详细）
热门推荐
未来社会二十年发展的核心技术趋势由ABCD四个字母组成，分别是AI（人工智能）、BlockChain（区块链）、Cloud（云）、和Data（大数据）每一次进步都有新的认知和感触
01-11 2万+
Spark SQL是Spark用来处理结构化数据的一个模块，它提供了2个编程抽象：DataFrame和DataSet，并且作为分布式SQL查询引擎的作用。 它是将Hive SQL转换成MapReduce然后提交到集群上执行，大大简化了编写MapReduc的程序的复杂性，由于MapReduce这种计算模型执行效率比较慢。所以Spark SQL的应运而生，它是将Spark SQL转换成RDD，然后提交到集群执行，执行效率非常快！
Spark SQL数据加载和保存实例讲解
12-16
Spark SQL重要是操作DataFrame，DataFrame本身提供了save和load的操作， Load：可以创建DataFrame， Save：把DataFrame中的数据保存到文件或者说与具体的格式来指明我们要读取的文件的类型以及与具体的格式来指出...
spark原理与调优详解
最新发布
12-14
spark原理与调优详解 Spark 是一种基于内存的分布式计算框架，旨在高效地处理大规模数据。下面是 Spark 的原理和调优详解。 Spark 背景和安装 Spark 的产生背景是为了解决传统 MapReduce 框架的不足之处，如计算...
Spark DataFrame详解.zip
05-29
DataFrame在Spark SQL模块下，它结合了SQL查询的便利性和RDD的灵活性，使得数据处理更加高效且易于理解。在本详解中，我们将深入探讨DataFrame的各个方面，包括其解析、创建、Action操作、条件查询以及join操作。 1...
Spark SQL 总结整理(二)：Spark SQL 解析流程、工作原理
super_wj0820的博客
09-18 2857
Spark SQL对SQL语句的处理和关系型数据库类似，即词法/语法解析、绑定、优化、执行。Spark SQL会先将SQL语句解析成一棵树，然后使用规则(Rule)对Tree进行绑定、优化等处理过程 1. Spark SQL运行架构 由上图看出，Spark SQL 的解析流程为： 1. 使用 SessionCatalog 保存元数据 在解析SQL语句之前，会创建 SparkSession，或者如...
Spark SQL函数
简之的通向技术之路
10-23 5006
Spark SQL函数
Spark SQL百万级数据批量读写入MySQL
jmx_bigdata的博客
11-03 4151
Spark SQL读取MySQL的方式 Spark SQL还包括一个可以使用JDBC从其他数据库读取数据的数据源。与使用JdbcRDD相比，应优先使用此功能。这是因为结果作为DataFrame返回，它们可以在Spark SQL中轻松处理或与其他数据源连接。JDBC数据源也更易于使用Java或Python，因为它不需要用户提供ClassTag。 可以使用Data Sources API将远程数据库中的表加载为DataFrame或Spark SQL临时视图。用户可以在数据源选项中指定JDBC连接属性。 user
Spark Sql 总结
05-30 345
=================将spark DataFrame转换为List ======================================== // SQL can be run over RDDs that have been registered as tables. DataFrame teenagers = sqlContext.sql("SELECT name F
Spark学习笔记：Spark SQL
BigPig的博客
01-23 1079
背景 从Spark 1.0开始，Spark SQL成为Spark生态系统一员，是专门处理结构化数据(比如DB, Json)的Spark组件。它提供了2种操作数据的方式：1）SQL Queries；2）DataFrames/Datasets API。Spark SQL = Schema + RDD，RDD可以表达所有的数据格式（包括结构化和非结构化）， Spark SQL只表达结构化的数据。 Spa...
Spark Sql 函数详解
weixin_43956381的博客
12-10 1977
1.聚合函数 approx_count_distinct count_distinct近似值 avg 平均值 collect_list 聚合指定字段的值到list collect_set 聚合指定字段的值到set corr 计算两列的Pearson相关系数 count 计数 countDistinct 去重计数 SQL中用法 select count(distinct class) ...
Spark SQL入门用法与原理分析
可可的专栏
01-05 2万+
sparkSQL是为了让开发人员摆脱自己编写RDD等原生Spark代码而产生的，开发人员只需要写一句SQL语句或者调用API，就能生成（翻译成）对应的SparkJob代码并去执行，开发变得更简洁， 1. API 2.原理 3.Catalyst解析器 4.sparkSQL使用json的坑 5.SparkSQL整体架构
Spark SQL在100TB上的自适应执行实践（转载）
weixin_33739523的博客
11-24 387
Spark SQL是Apache Spark最广泛使用的一个组件，它提供了非常友好的接口来分布式处理结构化数据，在很多应用领域都有成功的生产实践，但是在超大规模集群和数据集上，Spark SQL仍然遇到不少易用性和可扩展性的挑战。为了应对这些挑战，英特尔大数据技术团队和百度大数据基础架构部工程师在Spark 社区版本的基础上，改进并实现了自适应执行引擎。...
掌握Spark SQL：数据处理与接口详解
Spark SQL 是 Apache Spark 的核心组件，它为处理结构化和半结构化数据提供了一个统一的接口。Spark SQL 的引入使得在大规模分布式环境中进行数据查询、转换和分析变得更加高效。它与 Spark Ecosystem 的其他组件如 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值