Spark【Spark SQL（三）DataSet】

已于 2023-09-20 09:32:40 修改
阅读量795 收藏 1
点赞数 1
分类专栏： Spark 文章标签： spark 大数据 分布式
于 2023-09-10 17:28:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64261982/article/details/132792106
版权

DataSet

         DataFrame 的出现，让 Spark 可以更好地处理结构化数据的计算，但存在一个问题：编译时的类型安全问题，为了解决它，Spark 引入了 DataSet API（DataFrame API 的扩展）。DataSet 是分布式的数据集合，它提供了强类型支持，也就是给 RDD 的每行数据都添加了类型约束。

        在 Spark 2.0 中，DataFrame 和 DataSet 被合并为 DataSet 。DataSet包含 DataFrame 的功能，DataFrame 表示为 DataSet[Row] ，即DataSet 的子集。

三种 API 的选择

        RDD 是DataFrame 和 DataSet 的底层，如果需要更多的控制功能（比如精确控制Spark 怎么执行一条查询），尽量使用 RDD。

        如果希望在编译时获得更高的类型安全，建议使用 DataSet。

        如果想统一简化 Spark 的API ，则使用 DataFrame 和 DataSet。

        基于 DataFrame API 和 DataSet API 开发的程序会被自动优化，开发人员不需要操作底层的RDD API 来手动优化，大大提高了开发效率。但是RDD API 对于非结构化数据的处理有独特的优势（比如文本数据流），而且更方便我们做底层的操作。

DataSet 的创建

1、使用createDataset（）方法创建

def main(args: Array[String]): Unit = {
    //local代表本地单线程模式 local[*]代表本地多线程模式
    val spark = SparkSession.builder()
      .appName("create dataset")
      .master("local[*]")
      .getOrCreate()

    //一定要导入它 不然无法创建DataSet对象
    import spark.implicits._

    val ds1 = spark.createDataset(1 to 5)
    ds1.show()
    
    val ds2 = spark.createDataset(spark.sparkContext.textFile("data/sql/people.txt"))
    ds2.show()
    spark.stop()
  }

运行结果：

+-----+
|value|
+-----+
|    1|
|    2|
|    3|
|    4|
|    5|
+-----+

+--------+
|   value|
+--------+
| Tom, 21|
|Mike, 25|
|Andy, 18|
+--------+

2、通过 toDS 方法生成

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

object DataSetCreate {

  //case类一定要写到main方法之外
  case class Person(name:String,age:Int)

  def main(args: Array[String]): Unit = {
    //local代表本地单线程模式 local[*]代表本地多线程模式
    val spark = SparkSession.builder()
      .appName("create dataset")
      .master("local[*]")
      .getOrCreate()

    //一定要导入 SparkSession对象下的implicits
    import spark.implicits._


    val data = List(Person("Tom",21),Person("Andy",22))
    val ds: Dataset[Person] = data.toDS()
    ds.show()

    spark.stop()
  }
}

运行结果：

+----+---+
|name|age|
+----+---+
| Tom| 21|
|Andy| 22|
+----+---+

3、通过DataFrame 转换生成

需要注意：json中的数 
object DataSetCreate{
 case class Person(name:String,age:Long,sex:String)
def main(args: Array[String]): Unit = {
    
    //local代表本地单线程模式 local[*]代表本地多线程模式
    val spark = SparkSession.builder()
      .appName("create dataset")
      .master("local[*]")
      .getOrCreate()
    
    import spark.implicits._
    
    val df = spark.read.json("data/sql/people.json")
    val ds = df.as[Person]

    ds.show()
    spark.stop()
    }
}

RDD、DataFrame 和 DataSet 之间的相互转换

RDD <=> DataFrame

  1. RDD 转 DataFrame ，也就是上一篇博客中介绍的两种方法：
    1. 能创建case类，就直接映射出一个RDD[Person]，然后调用toDF方法利用反射机制推断RDD模式。
    2. 无法创建case类，就使用编程方式定义RDD模式，使用 createDataFrame(rowRDD,schema) 指定rowRDD：RDD[Row]和schema：StructType。
    3. 如果RDD是像：RDD[(Long, String)] 这样保存的是一个元组类型的RDD，那么也可以直接使用 toDF 方法转为 DataFrame 对象，因为元组的 k，v 数据类型是已知的，就相当于有了创建 DataFrame 的模式信息（schema）。
  2. DataFrame 转 RDD，直接使用 rdd() 方法。
package com.study.spark.core.sql

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

object TransForm {

  case class Person(name:String,age:Int)  //txt文件age字段可以用Int,但json文件尽量用Long

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

    import spark.implicits._

    //1.RDD和DataFrame之间互相转换
    //1.1 创建RDD对象
    val rdd: RDD[Person] = spark.sparkContext.textFile("data/sql/people.txt")
      .map(_.split(","))
      .map(attr => Person(attr(0), attr(1).trim.toInt))
    rdd.foreach(println)
    /*
      Person(Andy,18)
      Person(Tom,21)
      Person(Mike,25)
     */
    //1.2 RDD转DataFrame
    val df = rdd.toDF()
    df.show()
    /*
      +----+---+
      |name|age|
      +----+---+
      | Tom| 21|
      |Mike| 25|
      |Andy| 18|
      +----+---+
  */
    //1.3 DataFrame转RDD
    val res: RDD[Row] = df.rdd
    /*
      [Andy,18]
      [Tom,21]
      [Mike,25]
     */
    
    res.foreach(println)
    spark.stop()
  }
}

可以看到，RDD[Person]转为DataFrame后，再从DataFrame转回RDD就变成了RDD[Row] 类型了。

RDD <=> DataSet

RDD 和 DataSet 之间的转换比较简单：

  1. RDD 转 DataSet 直接使用case 类（比如Person），然后映射出 RDD[Person] ，直接调用 toDS方法。
  2. DataSet 转 RDD 直接调用 rdd方法即可。

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

object TransForm {

  case class Person(name:String,age:Int)  //txt文件age字段可以用Int,但json文件尽量用Long

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

    import spark.implicits._

    //1.RDD和DataSet之间互相转换
    //1.1 创建RDD对象
    val rdd: RDD[Person] = spark.sparkContext.textFile("data/sql/people.txt")
      .map(_.split(","))
      .map(attr => Person(attr(0), attr(1).trim.toInt))
    rdd.foreach(println)
    /*
      Person(Andy,18)
      Person(Tom,21)
      Person(Mike,25)
     */
    //1.2 RDD转DataSet
    val ds = rdd.toDS()
    ds.show()
    /*
      +----+---+
      |name|age|
      +----+---+
      | Tom| 21|
      |Mike| 25|
      |Andy| 18|
      +----+---+
  */
    //1.3 DataFrame转RDD
    val res: RDD[Person] = ds.rdd
    res.foreach(println)
    /*
      Person(Andy,18)
      Person(Tom,21)
      Person(Mike,25)
     */
    spark.stop()
  }
}

可以看到，相比RDD和DataFrame互相转换，RDD和DataSet转换的过程中，不会有数据类型的变化，而DataFrame转RDD的过程就会把我们定义的case类转为Row对象。

DataFrame <=> DataSet

  1. DataFrame 转 DataSet 先使用case类，然后直接使用 as[case 类] 方法。
  2. DataSet 转 DataFrame 直接使用 toDF 方法。
import org.apache.spark.sql.{DataFrame, Row, SparkSession}

object TransForm {

  case class Person(name:String,age:Long,sex:String)  //txt文件age字段可以用Int,但json文件尽量用Long

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

    import spark.implicits._

    //1.DataFrame和DataSet之间互相转换
    //1.1 创建DataFrame对象
    val df = spark.read.json("data/sql/people.json")
    df.show()
    /*
      +---+----------+---+
      |age|      name|sex|
      +---+----------+---+
      | 30|   Michael| 男|
      | 19|      Andy| 女|
      | 19|    Justin| 男|
      | 20|Bernadette| 女|
      | 23|  Gretchen| 女|
      | 27|     David| 男|
      | 33|    Joseph| 女|
      | 27|     Trish| 女|
      | 33|      Alex| 女|
      | 25|       Ben| 男|
      +---+----------+---+
    */
    //1.2 DataFrame转DataSet
    val ds = df.as[Person]
    ds.show()
    /*
      +---+----------+---+
      |age|      name|sex|
      +---+----------+---+
      | 30|   Michael| 男|
      | 19|      Andy| 女|
      | 19|    Justin| 男|
      | 20|Bernadette| 女|
      | 23|  Gretchen| 女|
      | 27|     David| 男|
      | 33|    Joseph| 女|
      | 27|     Trish| 女|
      | 33|      Alex| 女|
      | 25|       Ben| 男|
      +---+----------+---+
  */
    //1.3 DataSet转DataFrame
    val res: DataFrame = ds.toDF()
    res.show()
    /*
      +---+----------+---+
      |age|      name|sex|
      +---+----------+---+
      | 30|   Michael| 男|
      | 19|      Andy| 女|
      | 19|    Justin| 男|
      | 20|Bernadette| 女|
      | 23|  Gretchen| 女|
      | 27|     David| 男|
      | 33|    Joseph| 女|
      | 27|     Trish| 女|
      | 33|      Alex| 女|
      | 25|       Ben| 男|
      +---+----------+---+
    */
    spark.stop()
  }
}

DataSet 实现 WordCount

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

    import spark.implicits._

    val res: Dataset[(String, Long)] = spark.read.text("data/word.txt").as[String]
      .flatMap(_.split(" "))
      .groupByKey(_.toLowerCase)
      .count()

    res.show()

    spark.stop()
  }

运行结果:

|   key|count(1)|
+------+--------+
|  fast|       1|
|    is|       3|
| spark|       2|
|better|       1|
|  good|       1|
|hadoop|       1|
+------+--------+

总结

        剩下来就是不断练习各种DataFrame和DataSet的操作、熟悉各种转换和行动操作。

让线程再跑一会
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spark dataset and dataframe 深入分析
12-11
SPARK 最新版本支持的dataset and dataframe的深入分析和设计
Spark Dataset
an13654067079的博客
08-12 1390
Spark Dataset
Spark---Dataset
shall潇の菜园
05-11 122
文章目录DatasetCatalyst Dataset 公共类Dataset 扩展对象 实现scala.Serializable 数据集是特定于域的对象的强类型集合，可以使用功能或关系操作并行转换它们。每个数据集还具有一个称为a的无类型视图DataFrame，该视图是的数据集Row。 官方参考文档：点这里 package testrdd import org.apache.spark.{SparkConf, SparkContext} import org.apache.spark.sql.Spar
spark之Dataset
MY BLOG
09-15 465
@InterfaceStability.Stable public class Dataset<T> extends Object implements scala.Serializabl 1）Dataset是面向特定领域的强类型集合 2）每个Dataset具有一个称为DataFrame的无类型视图，该视图是Row的Dataset。 3）与RDD类似，DataSet包含Transformation和Action两种操作。 4）两种创建Dataset的方式： 使用SparkSessio.
Spark SQL中的Dataset
qq_45973211的博客
09-01 977
Dataset是一个分布式的数据集。
Spark SQL源码概览.pdf
01-11
Spark SQL Core 封装 Catalyst，向应用程序提供 SparkSession、Dataset、 DataFrame 等 API（DataFrame 是 Dataset[Row]的别名）；Spark SQL Hive 则提供操作 Hive 的 接口。本文主要关注查询执行过程，不涉及 ...
Spark SQL分批入库
04-13
List<row> list= spark.sql(sql).collectAsList()，获或者其他方法将数据存在List里面，然后就list转为 Dataset分批入库
spark rdd api dataframe 以及dataframe rdd dataset 相互转换 spark sql
02-14
包括spara rdd api，dataframe action操作、查询操作、join操作，dataframe rdd dataset 相互转换以及spark sql。
spark商业实战三部曲
01-03
2.3 Spark 2.2 SQL. 19 2.3.1 Spark SQL. 20 2.3.2 DataFrame和DatasetAPI 20 2.3.3 Timed Window.. 21 2.4 Spark 2.2 Streaming. 21 2.4.1 StructuredStreaming. 21 2.4.2 增量输出模式... 23 2.5 Spark 2.2...
Learning Spark SQL_source_code - Aurobindo Sarkar
10-30
Learning Spark SQL 配套源码，书籍内容写的非常好，结合源码看书，效果更佳。
SparkSQL
wz_TXWY的博客
09-27 630
SparkSQL SparkSQL Table of Contents 1. SparkSQL 是什么 1.1. SparkSQL 的出现契机 1.2. SparkSQL 的适用场景 2. SparkSQL 初体验 2.3. RDD 版本的 WordCount 2.2. 命令式 API 的入门案例 2.2. SQL 版本 WordCount 3. [扩展] C...
spark使用DataSet
serenysdfg的博客
03-05 568
本文中，我们介绍了Spark的基本概念，并通过spark shell演示了spark中的核心Api DataSet的使用。 在后面的文章中将会介绍spark中两个重要的扩展库Spark SQL和StructruedStreaming等,它们为数据的处理提供了更加方便和强大的操作。 Spark依然处于快速发展阶段中，其提供的功能可能随着版本的演进也会在不停的演进，就如RDD被DataSet替换，...
Spark SQL之Dataset
派大星的博客
09-01 1046
Dataset
spark（七）：DataSet
幻神舞的专栏
12-17 4003
文章目录说明分享资料优势代码实例DataFrame和DataSet的区别总结 说明 本博客周五更新 本文记录spark 分布式数据类型DataSet的基本原理和使用方法。 DataSet是Spark1.6添加的分布式数据集合，Spark2.0合并DataSet和DataFrame数据集合API，DataFrame变成DataSet的子集。 DataSet继承RDD优点，并使用Spark SQL优化的执行引擎。支持JVM对象构建，支持函数式转换（map/flatmap/filter）等多种操作 分享 大
Spark DataSet介绍
热门推荐
zg_hover的专栏
01-13 1万+
spark dataset
Spark Datasets介绍
Spark MLlib 机器学习
02-23 4334
1、Spark Datasets介绍 1.1 背景 从Spark1.3.0版本开始推出DataFrame，DataFrame让Spark具备了处理大规模结构化数据的能力，在比原有的RDD转化方式易用的前提下，计算性能更快。发布DataFrame之后开发者收到了很多反馈，其中一个主要的是大家反映缺乏编译时类型安全。为了解决这个问题，Spark采用新的 Dataset API (DataFrame
快速理解Spark Dataset
hellozhxy的博客
08-10 1628
1. 前言 RDD、DataFrame、Dataset是Spark三个最重要的概念，RDD和DataFrame两个概念出现的比较早，Dataset相对出现的较晚（1.6版本开始出现），有些开发人员对此还不熟悉，本文重点引领快速理解Dataset。 带着几个问题去阅读： 1、DataFrame比RDD有哪些优点？ 2、DataFrame和Dataset有什么关系？ 3、有了DataFram...
Spark----DataFrame和DataSet
最新发布
大呱的博客
04-12 940
Spark之DataFrame和DataSet
spark.sql.Dataset的foreach()用法
04-01
`foreach()`是一个用于对数据集中的每个元素进行操作的函数。它接受一个函数作为参数，该函数接受一个数据集中的元素并对其进行操作。在Spark中，`foreach()`函数用于对数据集中的每个元素进行迭代处理。 以下是`foreach()`的示例用法： ```scala import org.apache.spark.sql.functions._ val df = spark.range(10) df.foreach(row => println(row)) ``` 这个例子中，我们使用`spark.range()`创建了一个数据集。然后，我们使用`foreach()`函数来迭代数据集中的每个元素并打印它们。 在Spark中，`foreach()`函数通常用于向外部系统写入数据，例如将数据写入HDFS、Kafka、数据库等。在这种情况下，`foreach()`函数可以在每个分区上运行，从而实现更高效的写入操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

让线程再跑一会

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值