spark SQL性能调优 spark-sql -d

转载

mob6454cc6a01b7 2023-09-19 08:34:10

文章标签 spark SQL性能调优 spark sql 大数据 SQL 文章分类 Spark 大数据

学习目录

一、基本概念

1.SparkSQL的概述
2.DataFrame
3.DataSet

二、RDD、DataFrame、DataSet 三者的关系

1.三者的共性
2.三者的区别
3.三者的互相转换

三、IDEA进行sparkSQL三种类型的转换

一、基本概念

1.SparkSQL的概述

SparkSQL：Spark SQL 是 Spark 用于结构化数据(structured data)处理的 Spark 模块。对于开发人员来讲，SparkSQL 可以简化 RDD 的开发，提高开发效率，且执行效率非常快，所以实际工作中，基本上采用的就是 SparkSQL。Spark SQL 为了简化 RDD 的开发，提高开发效率，提供了 2 个编程抽象，类似 Spark Core 中的 RDD，后面会提到

DataFrame
DataSet

SparkSQL的特点

易整合：无缝的整合了 SQL 查询和 Spark 编程
统一的数据访问：使用相同的方式连接不同的数据源
兼容 Hive：在已有的仓库上直接运行 SQL 或者 HiveQL
标准数据连接：通过 JDBC 或者 ODBC 来连接

2.DataFrame

DataFrame ：在spark中 DataFrame 是一种以 RDD 为基础的分布式数据集，类似于传统数据库中的二维表格。DataFrame 与 RDD 的主要区别在于，前者带有 schema 元信息，即 DataFrame所表示的二维表数据集的每一列都带有名称和类型。这使得 Spark SQL 得以洞察更多的结构信息，从而对藏于 DataFrame 背后的数据源以及作用于 DataFrame 之上的变换进行了针对性的优化，最终达到大幅提升运行时效率的目标。反观 RDD，由于无从得知所存数据元素的具体内部结构，Spark Core 只能在 stage 层面进行简单、通用的流水线优化。

　　同时，与 Hive 类似，DataFrame 也支持嵌套数据类型（struct、array 和 map）。从 API 易用性的角度上看，DataFrame API 提供的是一套高层的关系操作，比函数式的 RDD API 要更加友好，门槛更低。

spark SQL性能调优 spark-sql -d_spark

上图更直观地体现了 DataFrame 和 RDD 的区别。

3.DataSet

DataSet 是分布式数据集合。DataSet 是 Spark 1.6 中添加的一个新抽象，是 DataFrame的一个扩展。DataSet 是具有强类型的数据集合，需要提供对应的数据类型。它提供了 RDD 的优势（强类型，使用强大的 lambda 函数的能力）以及Spark SQL 优化执行引擎的优点。DataSet 也可以使用功能性的转换（操作 map，flatMap，filter等等）

DataSet 是 DataFrame API 的一个扩展，是 SparkSQL 最新的数据抽象
用户友好的 API 风格，既具有类型安全检查也具有 DataFrame 的查询优化特性
用样例类来对 DataSet 中定义数据的结构信息，样例类中每个属性的名称直接映射到DataSet 中的字段名称
DataSet 是强类型的。比如可以有 DataSet[Car]，DataSet[Person]
DataFrame 是 DataSet 的特列，DataFrame=DataSet[Row] ，所以可以通过 as 方法将DataFrame 转换为 DataSet。Row 是一个类型，跟 Car、Person 这些的类型一样，所有的表结构信息都用 Row 来表示。获取数据时需要指定顺序

二、RDD、DataFrame、DataSet 三者的关系

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

Spark1.0 => RDD
Spark1.3 => DataFrame
Spark1.6 => Dataset

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

1.三者的共性

RDD、DataFrame、DataSet 全都是 spark 平台下的分布式弹性数据集，为处理超大型数据提供便利
三者都有惰性机制，在进行创建、转换，如 map 方法时，不会立即执行，只有在遇到Action 如 foreach 时，三者才会开始遍历运算
三者有许多共同的函数，如 filter，排序等
在对 DataFrame 和 Dataset 进行操作许多操作都需要这个包:import spark.implicits._（在创建好 SparkSession 对象后尽量直接导入）
三者都会根据 Spark 的内存情况自动缓存运算，这样即使数据量很大，也不用担心会内存溢出
三者都有 partition 的概念
DataFrame 和 DataSet 均可使用模式匹配获取各个字段的值和类型

2.三者的区别

（1）RDD

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

（2）DataFrame

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

（3）DataSet

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

3.三者的互相转换

案例说明：代码运行在spark的bin目录文件夹下的spark-shell.cmd中

（1）RDD 转换为 DataFrame
val rdd = sc.makeRDD( List((“zhangsan”,20),(“lisi”,30),(“wangwu”,40)) ) //创建RDD
val df = rdd.toDF( “name”,“age”) //给出数据结构

（2）DataFrame 转换为 RDD
df.rdd

（2）DataFrame 转换为 DataSet
case class People(name:String, age:Int) //需要创建一个样例类确定结构名称
val ds = df.as[People] //df就转换为ds as表示：作为什么类型，给出什么数据类型

（3）DataSet 转换为 DataFrame
ds.toDF //又转换为DataFrame 类型去掉只留结构又变成了DataFrame

（4）RDD 转换为 DataSet
case class People(name:String, age:Int) //需要创建一个样例类确定结构名称
val rdd= sc.makeRDD( List(People(“zhangsan”,20),People(“lisi”,30),People(“wangwu”,40)) ) //里面数据是样例类，既有数据又有类型
val ds = rdd.toDS //转换为 DataSet

（5）DataSet转换为 RDD
ds.rdd

spark SQL性能调优 spark-sql -d_spark_02

p161、p162

三、IDEA进行sparkSQL三种类型的转换

环境配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>Spark3.0</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    
    <dependencies>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.12</artifactId>
            <version>3.0.0</version>
        </dependency>

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

</project>

案例代码

package com.bigdata.SparkSQL

import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, Dataset, Row, SparkSession}

/**
 * @author wangbo
 * @version 1.0
 */
object Spark01_SparkSQL_basic {
  def main(args: Array[String]): Unit = {
    // TODO 创建SparkSQL的运行环境
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("sparkSQL")
    val sparkSession: SparkSession = SparkSession.builder().config(sparkConf).getOrCreate()
    //在使用DataFrame时，如果涉及到转换操作，需要引入隐式转换规则
    import  sparkSession.implicits._

    // TODO 执行逻辑操作
    /*
     DataFrame
     */
    val df: DataFrame = sparkSession.read.json("datas/user.json")
    //df.show()

    //DataFrame SQL的方式
//    df.createOrReplaceTempView("user")
//    sparkSession.sql("select * from user").show()
	//上面两行代码也可以写成如下形式，可以直接在文件上进行查询: 文件格式.`文件路径`
//	  sparkSession.sql("select * from json.'datas/user.json' ").show()

    //DataFrame DSL的方式
//    df.select("age","username").show()
//    df.select($"age"+1).show()
//    df.select('age+1).show()


    /*
     DataSet
     */
    //DataFrame其实是特定泛型的DataSet
//    val list = List(1, 2, 3, 4)
//    val ds: Dataset[Int] = list.toDS()
//    ds.show()


    /*
     RDD <=> DataFrame
     */
    val rdd: RDD[(Int, String, Int)] = sparkSession.sparkContext.makeRDD(List((1, "zhangsan", 30), (2, "lisi", 40)))
    val df1: DataFrame = rdd.toDF("id", "name", "age")  //RDD => DataFrame
    val rowRDD: RDD[Row] = df1.rdd  //DataFrame => RDD

    /*
     DataSet <=> DataFrame
     */
    val ds1: Dataset[User] = df1.as[User]  //DataFrame => DataSet
    val df2: DataFrame = ds1.toDF() //DataSet => DataFrame

    /*
     RDD <=> DataSet
     */

    val ds2: Dataset[User] = rdd.map {
      case (id, name, age) => {
        User(id, name, age)
      }
    }.toDS()  //RDD => DataSet
    val userrRDD: RDD[User] = ds2.rdd  //DataSet => RDD

    // TODO 关闭环境
    sparkSession.close()
  }

  //准备一个样例类
  case class User(id:Int,name:String,age:Int)
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。