Spark SQL 概述

遗憾还会等她吗

已于 2024-07-30 10:20:51 修改

阅读量626

点赞数 15

分类专栏： Spark 文章标签： spark sql 大数据 scala

于 2024-07-30 10:17:51 首次发布

本文链接：https://blog.csdn.net/2301_79349971/article/details/140789220

版权

Spark 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、Spark SQL 架构

Spark SQL 的架构主要由以下几个组件组成：

SparkSession：Spark 应用的统一入口点，用于创建 DataFrame、DataSet 和执行 SQL 查询。

Catalyst 优化器：Spark SQL 的查询优化引擎，负责解析、分析、优化和生成物理执行计划。
DataFrame 和 DataSet API：提供面向对象的编程接口，支持丰富的数据操作方法
数据源接口：支持多种数据源，如 HDFS、S3、HBase、Cassandra、Hive 等。
执行引擎：将优化后的查询计划转换为执行任务，并在分布式集群上并行执行这些任务。

二、Spark SQL 特点

统一数据访问接口：支持多种数据源（如 CSV、JSON、Parquet、Hive、JDBC、HBase 等）并提供一致的查询接口。
DataFrame 和 Dataset API：提供面向对象的编程接口，支持类型安全的操作，便于数据处理。
Catalyst 优化器：自动将用户的查询转换为高效的执行计划，提升查询性能。
与 Hive 的集成：无缝集成 Hive，能够直接访问现存的 Hive 数据，并使用 Hive 的 UDF 和 UDAF。
高性能：通过 Catalyst 优化器和 Tungsten 执行引擎，实现高效的查询性能和内存管理。
多种操作方式：支持 SQL 和 API 编程两种操作方式，灵活性高。
外部工具接口：提供 JDBC/ODBC 接口供第三方工具借助 Spark 进行数据处理。
高级接口：提供了更高层级的接口，方便地处理数据。

三、Spark SQL 运行原理

查询解析（Query Parsing）：将 SQL 查询解析成抽象语法树（AST）。

逻辑计划生成（Logical Plan Generation）：将 AST 转换为未优化的逻辑计划。

逻辑计划优化（Logical Plan Optimization）：使用 Catalyst 优化器对逻辑计划进行一系列规则优化。

物理计划生成（Physical Plan Generation）：将优化后的逻辑计划转换为一个或多个物理计划，并选择最优的物理计划。

执行（Execution）：将物理计划转换为 RDD，并在集群上并行执行。

四、Spark SQL API 相关概述

1、SparkContext：SparkContext 是 Spark 应用程序的主入口点，负责连接到 Spark 集群，管理资源和任务调度。在 Spark 2.0 之后，推荐使用 SparkSession 取代 SparkContext。

2、SQLContext：SQLContext 是 Spark SQL 的编程入口点，允许用户通过 SQL 查询或 DataFrame API 进行数据处理。它提供了基本的 Spark SQL 功能。

3、HiveContext：HiveContext 是 SQLContext 的子集，增加了对 Hive 的集成支持，可以直接访问 Hive 中的数据和元数据，使用 Hive 的 UDF 和 UDAF。

4、SparkSession：SparkSession 是 Spark 2.0 引入的新概念，合并了 SQLContext 和 HiveContext 的功能，提供了统一的编程接口。SparkSession 是 Spark SQL 的建议入口点，支持使用 DataFrame 和 Dataset API 进行数据处理。

创建 SparkContext 和 SparkSession 的注意事项：如果同时需要创建 SparkContext 和 SparkSession，必须先创建 SparkContext，再创建 SparkSession。如果先创建 SparkSession，再创建 SparkContext，会导致异常，因为在同一个 JVM 中只能运行一个 SparkContext。

五、Spark SQL 依赖

<properties>
    <spark.version>3.1.2</spark.version>
    <spark.scala.version>2.12</spark.scala.version>
</properties>
<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-sql_${spark.scala.version}</artifactId>
    <version>${spark.version}</version>
</dependency>

六、Spark SQL 依赖

在 Spark SQL 中，数据集主要分为以下几种类型：DataFrame 和 Dataset。它们是处理和操作结构化和半结构化数据的核心抽象。

1、DataFrame

Dataset 是在 Spark 2.0 中引入的新的抽象数据结构，它是强类型的，可以存储 JVM 对象。Dataset API 结合了 DataFrame 的操作简便性和类型安全性，适用于需要更高级别数据类型控制和面向对象编程风格的场景。具体特点如下：

类似于二维表格：DataFrame 类似于传统的关系数据库中的二维表格。
Schema（数据结构信息）：在 RDD 的基础上加入了 Schema，描述数据结构的信息。
支持嵌套数据类型：DataFrame 的 Schema 支持嵌套的数据类型，如 struct、map 和 array
丰富的 SQL 操作 API：提供更多类似 SQL 操作的 API，便于进行数据查询和操作。

2、Dataset

Dataset 是在 Spark 2.0 中引入的新的抽象数据结构，它是强类型的，可以存储 JVM 对象。Dataset API 结合了 DataFrame 的操作简便性和类型安全性，适用于需要更高级别数据类型控制和面向对象编程风格的场景。具体特点如下：

强类型：Spark 1.6中引入的一个更通用的数据集合，Dataset 是强类型的，提供类型安全的操作。
RDD + Schema：可以认为 Dataset 是 RDD 和 Schema 的结合，既有 RDD 的分布式计算能力，又有 Schema 描述数据结构的信息。
适用于特定领域对象：可以存储和操作特定领域对象的强类型集合。
并行操作：可以使用函数或者相关操作并行地进行转换和操作。

3、DataFrame 和 Dataset 的关系

DataFrame 是特殊的 Dataset：DataFrame 是 Dataset 的一个特例，即 DataFrame = Dataset[Row]
数据抽象和操作方式的统一：DataFrame 和 Dataset 统一了 Spark SQL 的数据抽象和操作方式，提供了灵活且强大的数据处理能力。

七、Spark Sql 基本用法

1、Scala 创建 SparkSession 对象

import org.apache.spark.sql.SparkSession
object SparkSqlContext {

  def main(args: Array[String]): Unit = {
    // 创建 SparkConf 对象，设置应用程序的配置
    val conf: SparkConf = new SparkConf()
      .setMaster("local[4]")   // 设置本地运行模式，使用 4 个线程
      .setAppName("spark sql") // 设置应用程序名称为 "spark sql"

    // 创建 SparkSession 对象，用于 Spark SQL 的编程入口
    val spark: SparkSession = SparkSession.builder()
      .config(conf) // 将 SparkConf 配置应用于 SparkSession
      .getOrCreate() // 获取现有的 SparkSession，或者新建一个
	
    // 获取 SparkContext 对象，可以直接从 SparkSession 中获取
    val sc: SparkContext = spark.sparkContext

    // 导入 SparkSession 的隐式转换，可以使用 DataFrame API 的方法
    import spark.implicits._

    // 在这里可以编写数据处理代码，例如创建 DataFrame 和 Dataset，进行数据操作等...

    // 停止 SparkSession，释放资源
    spark.stop()
  }
}

2、DataFrame 和 Dataset 的创建方式

1、从集合创建

case class Person(name: String, age: Int)				// 下同

val data1 = Seq(Person("Alice", 25), Person("Bob", 30))	
val ds: Dataset[Person] = spark.createDataset(data)		// 这里的spark是SparkSession对象(如上代码)，下同

val data2 = Seq(("Alice", 25), ("Bob", 30))
val df: DataFrame = data.toDF("name", "age")

2、从文件系统读取

val schema = StructType(Seq(
  StructField("name", StringType, nullable = false),
  StructField("age", IntegerType, nullable = false)
))

val dsJson: Dataset[Person] = spark.read.json("/path/to/json/file").as[Person]

val dfCsv: DataFrame = spark.read
	// 使用.schema方法指定CSV文件的模式（schema）其定义了DataFrame的列名和类型。
	// 这是一个可选步骤，但如果CSV文件没有头部行，或者你想覆盖文件中的头部行，则必须指定。  
  .schema(schema)		  
   // 这里设置"header"为"true"，表示CSV文件的第一行是列名，不需要Spark从文件中自动推断。 
  .option("header", "true")
  .csv("/path/to/csv/file")

3、从关系型数据库读取

val url = "jdbc:mysql://localhost:3306/database"
val properties = new java.util.Properties()
properties.setProperty("user", "username")
properties.setProperty("password", "password")

val dsDb: Dataset[Person] = spark.read.jdbc(url, "table", properties).as[Person]

val dfDb: DataFrame = spark.read.jdbc(url, "table", properties)

4、从非结构化数据源读取

val dsParquet: Dataset[Person] = spark.read.parquet("/path/to/parquet/file").as[Person]

val dfParquet: DataFrame = spark.read.parquet("/path/to/parquet/file")

5、手动创建 Dataset

import org.apache.spark.sql.types._

val schema = StructType(Seq(
  StructField("name", StringType, nullable = false),
  StructField("age", IntegerType, nullable = false)
))
val data = Seq(Row("Alice", 25), Row("Bob", 30))

val dsManual: Dataset[Person] = spark.createDataFrame(spark.sparkContext.parallelize(data), schema).as[Person]

val dfManual: DataFrame = spark.createDataFrame(
  spark.sparkContext.parallelize(data), schema
)

3、DataFrame API

语法示例一

模拟数据(1000条)：

id,name,gender,age,city
1,邵睿,男,12,上海市
2,林子异,男,48,广州市
3,孟秀英,女,46,上海市
4,金嘉伦,男,8,北京市
...

需求：哪些城市和性别组合在人口较多（ID数量>50）的情况下具有最高的平均年龄，以及这些组合在各自性别中的排名。

// 导入SparkSession的隐式转换，这样可以使用DataFrame的便捷方法(例如下面的'$'符号)
import spark.implicits._

// 定义了一个DataFrame的schema，但在这个例子中，使用了CSV的header来自动推断schema
val schema = StructType(Seq(
  StructField("id", LongType),
  StructField("name", StringType),
  StructField("gender", StringType),
  StructField("age", IntegerType),
  StructField("city", StringType),
))

// 定义WindowSpec，用于后续的窗口函数操作，按gender分区，按avg_age降序排序，(复用使用此)
val WindowSpec: WindowSpec = Window
  .partitionBy($"gender")
  .orderBy($"avg_age".desc)

// 从CSV文件中读取数据，使用header作为列名，然后选择特定的列，进行分组和聚合操作
// 哪些城市和性别组合在人口较多（ID数量>50）的情况下具有最高的平均年龄，以及这些组合在各自性别中的排名。
spark.read
   // .schema(schema)	// 应用我们定义的schema 
  .option("header", "true") 							// 使用CSV的header作为列名
  .csv("D:\\projects\\sparkSql\\people.csv")			// DataFrame
  .select($"id", $"name", $"age", $"city", $"gender") 	// 选择需要的列(不写默认就是全选)
  .groupBy($"city", $"gender") 							// 按城市和性别分组
  .agg(			// 多重聚合
    count($"id").as("count"),   		// 计算每个组的ID数量
    round(avg($"age"), 2).as("avg_age") // 计算每个组的平均年龄，并保留两位小数
  )
  .where($"count".gt(50))  		// 过滤出ID数量大于(可以使用>)50的组
  .orderBy($"avg_age".desc)     // 按平均年龄降序排序

  .select($"city", $"gender", $"avg_age",
    dense_rank().over(Window.partitionBy($"gender").orderBy($"avg_age".desc)).as("gender_avg_age_rank"))
  .show() // 显示结果

结果：

+------+------+-------+-------------------+
|  city|gender|avg_age|gender_avg_age_rank|
+------+------+-------+-------------------+
|北京市|    男|  41.05|                  1|
|  东莞|    男|  42.81|                  2|
|上海市|    男|  43.92|                  3|
|成都市|    男|  45.89|                  4|
|  中山|    男|  47.08|                  5|
|广州市|    男|  47.47|                  6|
|  深圳|    男|  48.36|                  7|
|上海市|    女|  46.02|                  1|
|  中山|    女|  49.55|                  2|
+------+------+-------+-------------------+

语法示例二：视图，sql

// 读取CSV文件到DataFrame，使用header作为列名
val dfPeople: DataFrame = spark.read
    .option("header", "true") // 使用CSV的header作为列名
    .csv("D:\\projects\\sparkSql\\people.csv")

// 将DataFrame注册为临时视图
dfPeople.createOrReplaceTempView("people_view")
// 可以使用Spark SQL来查询这个视图了
// 例如，查询所有人的姓名和年龄
spark.sql("SELECT name, age FROM people_view").show()
// 二
spark.sql(
      """
        |select * from people_view
        |where gender = '男'
        |""".stripMargin
    ).show()

语法示例三：join

case class Student(name: String, classId: Int)
case class Class(classId: Int, className: String)

val frmStu = spark.createDataFrame(
  Seq(
    Student("张三", 1),
    Student("李四", 1),
    Student("王五", 2),
    Student("赵六", 2),
    Student("李明", 2),
    Student("王刚", 4),
    Student("王朋", 5),
  )
)

val frmClass = spark.createDataFrame(
  Seq(
    Class(1, "name1"),
    Class(2, "name2"),
    Class(3, "name3"),
    Class(4, "name4")
  )
)

left 左连接，rignt 右连接, full 全外连接，anti左差集，semi左交集

// 别名 + inner 内连接
frmStu.as("S")
	.join(frmClass.as("C"), $"S.classId" === $"C.classId")	// joinType 默认 inner内连接
	.show()

// 使用左外连接将df和frmClass根据classId合并
frmStu
  .join(frmClass, Seq("classId"), "left")	
  .show()

// 左差集
frmStu
  .join(frmClass, Seq("classId"), "anti")	
  .show()

// 左交集
frmStu
  .join(frmClass, Seq("classId"), "semi")	
  .show()

结果

别名 + inner 内连接
+----+-------+-------+---------+
|name|classId|classId|className|
+----+-------+-------+---------+
|张三|      1|      1|    name1|
|李四|      1|      1|    name1|
|王五|      2|      2|    name2|
|赵六|      2|      2|    name2|
|李明|      2|      2|    name2|
|王刚|      4|      4|    name4|
+----+-------+-------+---------+

使用左外连接将df和frmClass根据classId合并
+-------+----+---------+
|classId|name|className|
+-------+----+---------+
|      1|张三|    name1|
|      1|李四|    name1|
|      2|王五|    name2|
|      2|赵六|    name2|
|      2|李明|    name2|
|      4|王刚|    name4|
|      5|王朋|     null|
+-------+----+---------+

左差集
+-------+----+
|classId|name|
+-------+----+
|      5|王朋|
+-------+----+

左交集
+-------+----+
|classId|name|
+-------+----+
|      1|张三|
|      1|李四|
|      2|王五|
|      2|赵六|
|      2|李明|
|      4|王刚|
+-------+----+