第2章 SparkSQL 核心编程

最新推荐文章于 2024-11-17 22:31:08 发布

Wzideng

最新推荐文章于 2024-11-17 22:31:08 发布

阅读量631

点赞数

分类专栏： # spark # scala 文章标签：前端 javascript spark

wzideng所有，如有需求，请联系=>>Wzideng@qq.com

本文链接：https://blog.csdn.net/weixin_43554580/article/details/131878254

版权

spark 同时被 2 个专栏收录

36 篇文章 0 订阅

订阅专栏

scala

21 篇文章 0 订阅

订阅专栏

本文介绍了SparkSQL中的DataFrame和DataSet的核心编程，包括创建、转换、SQL语法和DSL操作。重点讨论了DataFrame和DataSet与RDD之间的相互转换，以及如何在IDEA中开发SparkSQL应用。此外，还提到了SparkSession作为新的起点，以及用户自定义函数(UDF)的使用。

摘要由CSDN通过智能技术生成

（任意内容）

此处输入任意想输入的内容

本课件重点学习如何使用 Spark SQL 所提供的 DataFrame 和 DataSet 模型进行编程.，以及了解它们之间的关系和转换，关于具体的 SQL 书写不是我们的重点。

2.1 新的起点

Spark Core 中，如果想要执行应用程序，需要首先构建上下文环境对象 SparkContext ，Spark SQL 其实可以理解为对 Spark Core 的一种封装，不仅仅在模型上进行了封装，上下文环境对象也进行了封装。

SparkContext 是 Apache Spark 中的核心组件之一，它是 Spark 应用程序与 Spark 集群通信的入口点。在 Spark 中，每个应用程序都需要创建一个 SparkContext 实例，用于与 Spark 集群建立连接并进行任务调度、资源管理等操作。

SparkContext 的主要作用包括：

与集群通信：SparkContext 负责与 Spark 集群建立通信，它与集群中的 ClusterManager 进行通信，请求资源和执行任务。
资源管理：SparkContext 负责管理应用程序在集群中的资源分配，包括 Executor 内存、CPU 核心数等。
任务调度：SparkContext 负责将应用程序中的任务分解成多个阶段，并在集群中调度执行这些任务。
创建 RDD：SparkContext 可以用来创建 RDD（弹性分布式数据集）和其他 Spark 数据结构。
访问 Spark 功能：SparkContext 提供了对 Spark 的各种功能和API的访问，如 Spark SQL、Spark Streaming、MLlib 等。

在 Spark 2.0 之前，通过 SparkContext 来创建各种类型的 RDD，并进行任务调度和资源管理。在 Spark 2.0 之后，引入了 SparkSession，它是 SparkContext、SQLContext 和 HiveContext 的统一入口，提供了更简洁的编程界面。

示例代码（Spark 2.0+）：

import org.apache.spark.sql.SparkSession;

public class SparkExample {
    public static void main(String[] args) {
        // 创建 SparkSession 对象
        SparkSession spark = SparkSession
                .builder()
                .appName("SparkExample")
                .master("local") // 在本地运行，也可以设置为集群的 URL
                .getOrCreate();

        // 使用 SparkSession 执行任务
        // ...

        // 关闭 SparkSession
        spark.stop();
    }
}

在现代的 Spark 应用程序中，推荐使用 SparkSession 来代替 SparkContext，因为它提供了更多的功能，并能兼容不同的数据源和功能模块，使代码更加简洁和易于维护。

在老的版本中，SparkSQL 提供两种 SQL 查询起始点：一个叫 SQLContext，用于 Spark自己提供的 SQL 查询；一个叫 HiveContext，用于连接 Hive 的查询。
SparkSession 是 Spark 最新的 SQL 查询起始点，实质上是 SQLContext 和 HiveContext
的组合，所以在 SQLContex 和 HiveContext 上可用的 API 在 SparkSession 上同样是可以使用
的。SparkSession 内部封装了 SparkContext，所以计算实际上是由 sparkContext 完成的。当
我们使用 spark-shell 的时候, spark 框架会自动的创建一个名称叫做 spark 的 SparkSession 对
象, 就像我们以前可以自动获取到一个 sc 来表示 SparkContext 对象一样。

SparkSession 是 Apache Spark 2.0 之后引入的一个重要组件，它是对 SparkContext、SQLContext 和 HiveContext 的统一入口，提供了更简洁、更方便的编程界面。SparkSession 可以用来访问 Spark 的各种功能，如 Spark SQL、Spark Streaming、MLlib 等，并且支持在不同的数据源之间无缝切换。

SparkSession 的主要作用包括：

统一入口：SparkSession 将 SparkContext、SQLContext 和 HiveContext 的功能整合在一个接口中，简化了应用程序的编写和维护。
Spark SQL：SparkSession 提供了对 Spark SQL 的支持，可以使用 SQL 或 DataFrame API 进行数据查询和处理，从而将结构化数据和半结构化数据（JSON、CSV 等）直接转换为 DataFrame 进行分析。
Hive 集成：SparkSession 具有与 Hive 的完全集成，可以直接访问 Hive 的数据、表和元数据，从而能够在 Spark 中执行 Hive 查询，并将结果写回到 Hive 表中。
读写数据：SparkSession 可以通过 DataFrame API 或者数据源 API 读取和写入各种类型的数据，如 Parquet、Avro、ORC、JSON、CSV 等。
支持多种数据源：SparkSession 可以无缝切换不同的数据源，可以访问 HDFS、Hive、Amazon S3、Cassandra 等。
Streaming 支持：SparkSession 支持 Spark Streaming，可以实时处理数据流。

使用 SparkSession 示例：

import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;

public class SparkExample {
    public static void main(String[] args) {
        // 创建 SparkSession 对象
        SparkSession spark = SparkSession
                .builder()
                .appName("SparkExample")
                .master("local") // 在本地运行，也可以设置为集群的 URL
                .getOrCreate();

        // 读取数据并创建 DataFrame
        Dataset<Row> df = spark.read().json("path/to/json/file");

        // 执行操作，如查询、转换等
        df.show();

        // 关闭 SparkSession
        spark.stop();
    }
}

总之，SparkSession 是 Apache Spark 中一个重要的组件，它提供了一个统一的编程接口，使得 Spark 的功能更易于使用和理解。在现代的 Spark 应用程序中，推荐使用 SparkSession 来代替原来的 SparkContext、SQLContext 和 HiveContext，以获得更多的功能和更简洁的编程体验。
在这里插入图片描述

2.2 DataFrame

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

DataFrame 是 Apache Spark 中的一个分布式数据集，它是由一组命名的列组成的分布式数据集合。DataFrame 可以理解为类似于传统数据库表或者关系型数据库中的表，但是它的数据是以分布式方式存储在集群中的，可以跨多个节点进行并行计算和处理。

在 Spark 中，DataFrame 是对 RDD（弹性分布式数据集）的高级抽象，它提供了一种更高级的数据处理方式，更接近于 SQL 表格的操作风格。DataFrame 可以用于读取和处理各种类型的数据，如 JSON、CSV、Parquet、Avro 等，同时也支持与 Hive 集成，可以直接读取和写入 Hive 表。

DataFrame 具有以下特点：

类型安全：DataFrame 是强类型的，它在编译期间能够捕获类型错误，从而提供了更好的开发体验和错误检测。
惰性求值：DataFrame 支持惰性求值，即在执行数据处理操作时，并不立即进行计算，而是生成一个执行计划，只有在遇到动作操作时才会实际触发计算。
优化执行：Spark 会对 DataFrame 的转换操作进行优化，以提高执行效率，例如可以进行谓词下推、投影下推等优化。
SQL 支持：DataFrame 支持使用 SQL 进行数据查询和处理，可以方便地进行数据筛选、聚合、排序等操作。
面向列的处理：DataFrame 是面向列的数据处理方式，支持向量化的数据处理，能够更高效地进行数据计算。

DataFrame 的创建可以通过多种方式，如读取文件、从 RDD 转换、使用 Hive 表等。同时，DataFrame API 提供了丰富的操作方法，用于对数据进行转换和处理，包括过滤、排序、聚合、联接等。

示例代码（Java）：

import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;

public class DataFrameExample {
    public static void main(String[] args) {
        // 创建 SparkSession 对象
        SparkSession spark = SparkSession
                .builder()
                .appName("DataFrameExample")
                .master("local") // 在本地运行，也可以设置为集群的 URL
                .getOrCreate();

        // 读取数据并创建 DataFrame
        Dataset<Row> df = spark.read().json("path/to/json/file");

        // 执行操作，如查询、转换等
        df.show();

        // 关闭 SparkSession
        spark.stop();
    }
}

以上示例中，我们通过 spark.read().json() 方法从 JSON 文件中读取数据并创建了一个 DataFrame，然后使用 df.show() 方法将 DataFrame 中的数据显示出来。

总之，DataFrame 是 Apache Spark 中的一个核心概念，它提供了高级的、类型安全的、优化的分布式数据处理方式，能够满足大规模数据处理和分析的需求。

2.2.1 创建 DataFrame

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

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

从 RDD 进行转换

在 Apache Spark 中，RDD（弹性分布式数据集）是分布式数据处理的核心抽象，是一个不可变的、分区化的数据集合。RDD 提供了一系列的转换操作，用于对数据集进行处理和转换，以实现各种复杂的分布式计算任务。常见的 RDD 转换操作包括：

map(func)：对 RDD 中的每个元素应用函数 func，返回一个新的 RDD。
filter(func)：筛选出满足条件的元素，返回一个新的 RDD。
flatMap(func)：与 map 类似，但每个输入元素可以映射为零个或多个输出元素。
union(other)：将当前 RDD 与另一个 RDD 合并，返回一个包含两个 RDD 元素的新 RDD。
distinct()：去除 RDD 中的重复元素，返回一个新的 RDD。
groupByKey()：对 (key, value) 形式的 RDD 进行分组，返回一个新的 PairRDD，其中 key 是键，value 是具有相同键的值组成的可迭代集合。
reduceByKey(func)：对 (key, value) 形式的 RDD 进行按键聚合，返回一个新的 PairRDD，其中 key 是键，value 是经过 func 聚合后的结果。
sortByKey()：按照键对 RDD 进行排序，返回一个新的 PairRDD。
join(other)：对两个 PairRDD 进行连接操作，返回一个包含连接结果的新 PairRDD。
cogroup(other)：对两个 PairRDD 进行连接操作，并返回一个包含每个键的所有值的可迭代集合的新 PairRDD。

除了上述常见的转换操作外，RDD 还支持其他许多转换操作，如 Cartesian、mapPartitions、reduce、aggregate 等，每个转换操作都有不同的应用场景，可以根据具体的业务需求进行选择。

值得注意的是，RDD 是惰性求值的，即在进行转换操作时，并不会立即执行计算，而是创建一个转换后的 RDD 的执行计划。只有当对 RDD 执行动作操作时，Spark 才会根据执行计划实际进行计算和处理。这种特性有助于优化计算过程，并提高 Spark 的性能。

从 Hive Table 进行查询返回

在 Apache Spark 中，可以通过 HiveContext 或 SparkSession 的 SQL 接口来查询 Hive 表，并将查询结果返回为 DataFrame 或 Dataset。下面是通过 SparkSession 查询 Hive 表并返回结果的示例代码：

import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;

public class HiveQueryExample {
    public static void main(String[] args) {
        // 创建 SparkSession 对象
        SparkSession spark = SparkSession
                .builder()
                .appName("HiveQueryExample")
                .enableHiveSupport() // 启用 Hive 支持
                .master("local") // 在本地运行，也可以设置为集群的 URL
                .getOrCreate();

        // 查询 Hive 表
        Dataset<Row> result = spark.sql("SELECT * FROM database_name.table_name");

        // 显示查询结果
        result.show();

        // 关闭 SparkSession
        spark.stop();
    }
}

在上述示例中，首先创建了一个 SparkSession 对象并启用了 Hive 支持。然后，通过 spark.sql() 方法执行了一个 SQL 查询，将结果存储在一个 DataFrame 对象中。最后，通过 result.show() 方法将查询结果显示出来。

需要注意的是，为了能够在 Spark 中查询 Hive 表，必须启用 Hive 支持，并且在创建 SparkSession 时通过 enableHiveSupport() 方法来启用。这样，Spark 就能够与 Hive 元数据库进行交互，并读取 Hive 表的元数据和数据。同时，还需要确保 Spark 配置中的 hive-site.xml 文件包含了正确的 Hive 配置信息，以便连接到 Hive 数据库。

通过以上方式，就可以在 Spark 中查询 Hive 表并将结果返回为 DataFrame 或 Dataset，从而方便地进行数据处理和分析。

2.2.2 SQL 语法

SQL 语法风格是指我们查询数据的时候使用 SQL 语句来查询，这种风格的查询必须要有临时视图或者全局视图来辅助。

读取 JSON 文件创建 DataFrame

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

对 DataFrame 创建一个临时表

scala> df.createOrReplaceTempView("people")

createOrReplaceTempView 是 Apache Spark 中用于创建或替换临时视图（Temporary View）的方法。它是在 Spark SQL 中的一个函数，用于将 DataFrame 或 Dataset 注册为一个临时视图，以便可以通过 SQL 查询对其进行操作。

临时视图是一种临时的、在当前 SparkSession 中有效的视图，它并不是在 Hive 元数据库中注册的永久性视图。因此，临时视图只在当前 SparkSession 中可用，一旦 SparkSession 关闭，临时视图也将被删除。

createOrReplaceTempView 的语法如下：

void createOrReplaceTempView(String viewName);

其中，viewName 参数是临时视图的名称，可以在后续的 SQL 查询中使用该名称来引用临时视图。

示例代码：

import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;

public class CreateTempViewExample {
    public static void main(String[] args) {
        // 创建 SparkSession 对象
        SparkSession spark = SparkSession
                .builder()
                .appName("CreateTempViewExample")
                .master("local") // 在本地运行，也可以设置为集群的 URL
                .getOrCreate();

        // 读取数据并创建 DataFrame
        Dataset<Row> df = spark.read().json("path/to/json/file");

        // 将 DataFrame 注册为一个临时视图
        df.createOrReplaceTempView("my_temp_view");

        // 使用 SQL 查询临时视图
        Dataset<Row> result = spark.sql("SELECT * FROM my_temp_view");

        // 显示查询结果
        result.show();

        // 关闭 SparkSession
        spark.stop();
    }
}

在上述示例中，我们首先创建了一个 SparkSession 对象，并读取了数据并创建了 DataFrame。然后，通过 createOrReplaceTempView 方法将 DataFrame 注册为一个名为 “my_temp_view” 的临时视图。接下来，我们使用 SQL 查询该临时视图，并将查询结果显示出来。

通过 createOrReplaceTempView 方法，我们可以方便地将 DataFrame 或 Dataset 注册为一个临时视图，以便在 Spark SQL 中使用 SQL 进行数据查询和处理。

通过 SQL 语句实现查询全表

scala> val sqlDF = spark.sql("SELECT * FROM people")
sqlDF: org.apache.spark.sql.DataFrame = [age: bigint， name: string]

结果展示

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

注意：普通临时表是 Session 范围内的，如果想应用范围内有效，可以使用全局临时表。使
用全局临时表时需要全路径访问，如：global_temp.people

对于 DataFrame 创建一个全局表

scala> df.createGlobalTempView("people")

通过 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 语法风格不必去创建临时视图了。

创建一个 DataFrame

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

查看 DataFrame 的 Schema 信息

scala> df.printSchema
root
|-- age: Long (nullable = true)
|-- username: string (nullable = true)

只查看"username"列数据，

scala> df.select("username").show()
+--------+
|username|
+--------+
|zhangsan|
| lisi|
| wangwu|
+--------+

查看"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|
+--------+---------+

查看"age"大于"30"的数据

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

按照"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 是 Apache Spark 中引入的一个新的抽象概念，在 Spark 2.0 版本之后加入。DataSet 是对 DataFrame 的扩展，它提供了更加丰富和类型安全的 API，支持编译时类型检查，并且能够与 Java、Scala 中的强类型对象进行无缝交互。

DataSet 是一种分布式数据集合，类似于 DataFrame，但是 DataSet 是面向对象的，并且支持将分布式数据集合映射为强类型对象。这样，可以在编译时捕获类型错误，并提供更好的代码提示和自动完成功能，减少运行时错误。

DataSet 主要特点包括：

强类型：DataSet 支持对数据进行强类型编码，可以在编译时发现类型错误。
面向对象：DataSet 可以将分布式数据集合映射为强类型对象，支持面向对象的数据处理方式。
SQL 支持：DataSet 也支持使用 SQL 进行数据查询和处理，与 DataFrame 一样提供了 SQL 接口。
惰性求值：DataSet 也是惰性求值的，即在执行数据处理操作时，并不立即进行计算，只有遇到动作操作时才会实际触发计算。
优化执行：DataSet 的转换操作也会被优化，以提高执行效率。

在使用 Spark 时，可以根据需求选择使用 DataFrame 或 DataSet 进行数据处理。如果需要更加强大的类型检查和面向对象的编程体验，可以选择使用 DataSet。如果需要更加灵活和简便的数据处理方式，可以选择使用 DataFrame。

示例代码（Scala）：

import org.apache.spark.sql.{SparkSession, Dataset}

// 定义一个 case class 作为 DataSet 的强类型对象
case class Person(name: String, age: Int)

object DataSetExample {
  def main(args: Array[String]): Unit = {
    // 创建 SparkSession 对象
    val spark = SparkSession
      .builder()
      .appName("DataSetExample")
      .master("local") // 在本地运行，也可以设置为集群的 URL
      .getOrCreate()

    // 导入隐式转换，以便将 DataFrame 转换为 DataSet
    import spark.implicits._

    // 创建 DataSet
    val ds: Dataset[Person] = Seq(Person("Alice", 30), Person("Bob", 25)).toDS()

    // 显示 DataSet 中的数据
    ds.show()

    // 关闭 SparkSession
    spark.stop()
  }
}

以上示例中，我们首先定义了一个 case class Person，作为 DataSet 的强类型对象。然后，我们通过 Seq(Person("Alice", 30), Person("Bob", 25)).toDS() 将一个序列转换为 DataSet，并显示其中的数据。

总之，DataSet 是 Apache Spark 中对 DataFrame 的扩展，它提供了更强大、更类型安全的数据处理功能，适用于需要更加严格类型检查和面向对象编程的场景。

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.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.5 RDD、DataFrame、DataSet 三者的关系

在 SparkSQL 中 Spark 为我们提供了两个新的抽象，分别是 DataFrame 和 DataSet。他们和 RDD 有什么区别呢？首先从版本的产生上来看：

➢ Spark1.0 => RDD

➢ Spark1.3 => DataFrame

➢ Spark1.6 => Dataset

如果同样的数据都给到这三个数据结构，他们分别计算之后，都会给出相同的结果。不同是的他们的执行效率和执行方式。在后期的 Spark 版本中，DataSet 有可能会逐步取代 RDD和 DataFrame 成为唯一的 API 接口。

2.5.1 三者的共性

➢ RDD、DataFrame、DataSet 全都是 spark 平台下的分布式弹性数据集，为处理超大型数据提供便利;

➢ 三者都有惰性机制，在进行创建、转换，如 map 方法时，不会立即执行，只有在遇到Action 如 foreach 时，三者才会开始遍历运算;

➢ 三者有许多共同的函数，如 filter，排序等;

➢ 在对 DataFrame 和 Dataset 进行操作许多操作都需要这个包:import spark.implicits._（在创建好 SparkSession 对象后尽量直接导入）

➢ 三者都会根据 Spark 的内存情况自动缓存运算，这样即使数据量很大，也不用担心会内存溢出

➢ 三者都有 partition 的概念

➢ DataFrame 和 DataSet 均可使用模式匹配获取各个字段的值和类型

2.5.2 三者的区别

➢ RDD 一般和 spark mllib 同时使用
➢ RDD 不支持 sparksql 操作

DataFrame

➢ 与 RDD 和 Dataset 不同，DataFrame 每一行的类型固定为 Row，每一列的值没法直接访问，只有通过解析才能获取各个字段的值
➢ DataFrame 与 DataSet 一般不与 spark mllib 同时使用
➢ DataFrame 与 DataSet 均支持 SparkSQL 的操作，比如 select，groupby 之类，还能注册临时表/视窗，进行 sql 语句操作
➢ DataFrame 与 DataSet 支持一些特别方便的保存方式，比如保存成 csv，可以带上表头，这样每一列的字段名一目了然(后面专门讲解)

DataSet

➢ Dataset 和 DataFrame 拥有完全相同的成员函数，区别只是每一行的数据类型不同。DataFrame 其实就是 DataSet 的一个特例 type DataFrame = Dataset[Row]
➢ DataFrame 也可以叫 Dataset[Row],每一行的类型是 Row，不解析，每一行究竟有哪些字段，各个字段又是什么类型都无从得知，只能用上面提到的 getAS 方法或者共性中的第七条提到的模式匹配拿出特定字段。而 Dataset 中，每一行是什么类型是不一定的，在自定义了 case class 之后可以很自由的获得每一行的信息。

2.5.3 三者的互相转换

在这里插入图片描述

2.6 IDEA 开发 SparkSQL

实际开发中，都是使用 IDEA 进行开发的。

2.6.1 添加依赖

<dependency>
	 <groupId>org.apache.spark</groupId>
	 <artifactId>spark-sql_2.12</artifactId>
	 <version>3.0.0</version>
</dependency>

2.6.2 代码实现

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.7 用户自定义函数

用户可以通过 spark.udf 功能添加自定义函数，实现自定义功能。

2.7.1 UDF

创建 DataFrame

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

scala> spark.udf.register("addName",(x:String)=> "Name:"+x)
res9: org.apache.spark.sql.expressions.UserDefinedFunction = 
UserDefinedFunction(<function1>,StringType,Some(List(StringType)))

创建临时表

scala> df.createOrReplaceTempView("people")

应用 UDF

scala> spark.sql("Select addName(name),age from people").show()

Wzideng

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录