SparkSQL的简单使用

最新推荐文章于 2024-05-01 18:46:44 发布
最新推荐文章于 2024-05-01 18:46:44 发布
阅读量1.2k 收藏 8
点赞数
分类专栏： 大数据 文章标签： 大数据 spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44002865/article/details/119445899
版权

SparkSQL

文章目录

1、简介

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 要 更加友好，门槛更低。



DataSet

  • DataSet 是分布式数据集合。DataSet 是 Spark 1.6 中添加的一个新抽象，是 DataFrame 的一个扩展。它提供了 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 来表示。获取数据时需要指定顺序




2、Shell命令

DataFrame

  • 创建 DataFrame

    # 支持 csv format jdbc json load option options orc parquet schema table text textFile 多种创建
spark.read.[csv format jdbc json load option options orc parquet schema table text textFile]

# 事例（json的方式创建，json文件需要保证每行都是json格式）
val df = spark.read.json("data/user.json")

  • SQL语法

    # 查询
spark.sql("select查询语句")

#事例
# 1、创建 DataFrame
val df = spark.read.json("data/user.json")
# 2、创建临时表 user
df.createOrReplaceTempView("user")
# 3、查询
spark.sql("SELECT * FROM user")

  • DSL语法（调用方法）

    #事例
# 1、创建 DataFrame
val df = spark.read.json("data/user.json")
# 2、查看"username"列数据
df.select("name").show()
# 2、查看"username"列数据以及"age+1"数据
# 注意:涉及到运算的时候, 每列都必须使用$, 或者采用引号表达式：单引号+字段名
df.select($"username",$"age" + 1).show
df.select('username, 'age + 1).show()

  • RDD <-> DataFrame（相互转换）

    # RDD 转换为 DataFrame（.toDF）
rdd.toDF(字段名)
rdd.toDF("id", "name")

# DataFrame 转换为 RDD（.rdd）
df.rdd



DataSet

  • 创建DataSet

    # 1、创建类
case class Person(name: String, age: Long)
# 2、创建DataSet（.toDS）
Seq(Person("fff", 20), Person("zzz", 30)).toDS()

  • RDD <-> DataSet（相互转换）

    case class User(name:String, age:Int)

# RDD 转换为 DataSet（.toDS）
rdd.map{data => User(data._1, data._2)}.toDS

# DataSet 转换为 RDD（.rdd）
ds.rdd

  • DataFrame <-> DataSet（相互转换）

    case class User(name:String, age:Int)

# DataFrame  转换为 DataSet（.as[]）
df.as[User]

# DataSet 转换为 DataFrame （.rdd）
ds.toDF




3、IDEA开发

环境准备

  • 添加依赖（pom.xml）

    <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-yarn_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>



RDD、DataFrame、DataSet 三者相互转换

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

object Spark01_SQL_Basic {
  def main(args: Array[String]): Unit = {

    //TODO 创建SparkSession
    //创建Spark配置对象
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("sparkSQL")
    //创建SparkSession对象
    val spark: SparkSession = SparkSession.builder().config(sparkConf).getOrCreate()
    import spark.implicits._

    //TODO 业务逻辑
    //创建DataFrame（json）
    val df: DataFrame = spark.read.json("datas/user.json")

    //DataFrame => SQL语法
    df.createOrReplaceTempView("user")
    spark.sql("select * from user").show()

    //DataFrame => DSL语法
    df.select("name", "age").show()
    df.select($"age" + 1).show()
    df.select('age + 1).show()

    //创建DataSet
    val ds: Dataset[Int] = Seq(1, 2, 3, 4).toDS()
    ds.show()

    //RDD <=> DataFrame（相互转换）
    val rdd: RDD[(Int, String, Int)] = spark.sparkContext.makeRDD(List((1, "fff", 20)))
    val df1: DataFrame = rdd.toDF("id", "name", "age")
    val rdd1: RDD[Row] = df1.rdd

    //DataFrame <=> DataSet（相互转换）
    val ds2: Dataset[User] = df1.as[User]
    val df2: DataFrame = ds2.toDF()

    //RDD <=> DataSet（相互转换）
    val ds3: Dataset[User] = rdd.map(data => User(data._1, data._2, data._3)).toDS()
    val rdd3: RDD[User] = ds3.rdd

        
    //TODO 关闭连接
    spark.stop()
  }

  //创建User类
  case class User(id: Int, name: String, age: Int)

}



自定义函数

UDF

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

object Spark02_SQL_UDF {
  def main(args: Array[String]): Unit = {

    //TODO 创建SparkSession
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("sparkSQL")
    val spark: SparkSession = SparkSession.builder().config(sparkConf).getOrCreate()
    import spark.implicits._

    //TODO 业务逻辑
    //DataFrame
    val df: DataFrame = spark.read.json("datas/user.json")

    df.createOrReplaceTempView("user")

    //自定义udf，第一个参数：名称，第二个参数：逻辑方法
    spark.udf.register("prifix", (name: String) => "Name: " + name)
    spark.sql("select prifix(name), age from user").show()


    //TODO 关闭连接
    spark.stop()
  }
}



UDAF

import org.apache.spark.SparkConf
import org.apache.spark.sql.expressions.Aggregator
import org.apache.spark.sql.{DataFrame, Encoder, Encoders, SparkSession, functions}

object Spark03_SQL_UDAF {
  def main(args: Array[String]): Unit = {

    //TODO 创建SparkSession
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("sparkSQL")
    val spark: SparkSession = SparkSession.builder().config(sparkConf).getOrCreate()

    //TODO 业务逻辑
    val df: DataFrame = spark.read.json("datas/user.json")

    df.createOrReplaceTempView("user")

    //自定义UDAF
    spark.udf.register("ageAvg", functions.udaf(new MyUDAF))
    spark.sql("select ageAvg(age) from user").show()


    //TODO 关闭连接
    spark.stop()
  }

  //创建Buff类
  case class Buff(var total: Long, var count: Long)

  //自定义UDAF类
  class MyUDAF extends Aggregator[Long, Buff, Long]{
    //buff初始数据
    override def zero: Buff = Buff(0L, 0L)

    //缓冲区中的业务逻辑
    override def reduce(b: Buff, a: Long): Buff = {
      b.total += a
      b.count += 1
      b
    }

    //将缓冲区间合并的业务逻辑
    override def merge(b1: Buff, b2: Buff): Buff = {
      b1.total += b2.total
      b1.count += b2.count
      b1
    }

    //最终业务逻辑
    override def finish(reduction: Buff): Long = reduction.total / reduction.count

    //buff编码类型（Encoders.product：自定义类型）
    override def bufferEncoder: Encoder[Buff] = Encoders.product

    //输出编码类型（Encoders.scalaLong：系统自带类型）
    override def outputEncoder: Encoder[Long] = Encoders.scalaLong
  }
}




4、加载和保存方式

加载数据

# 支持 csv format jdbc json load option options orc parquet schema table text textFile 多种加载方式
spark.read.[csv format jdbc json load option options orc parquet schema table text textFile]

# json
spark.read.json("data/user.json")

# load
#	format("…")：指定加载的数据类型，包括"csv"、"jdbc"、"json"、"orc"、"parquet"和"textFile"
#	option("…")：在"jdbc"格式下需要传入 JDBC 相应参数，url、user、password 和 dbtable
#	load("…")：在"csv"、"jdbc"、"json"、"orc"、"parquet"和"textFile"格式下需要传入加载数据的路径
spark.read.format("…")[.option("…")].load("…")
# load -> json
spark.read.format("json").load("data/user.json")
# load -> jdbc
spark.read.format("jdbc")
      .option("url", "jdbc:mysql://localhost:3306/test")
      .option("user", "root")
      .option("password", "123456")
      .option("dbtable", "test")
      .load()



保存数据

# 支持 csv jdbc json orc parquet textFile… … 保存数据方式
df.write.[csv jdbc json orc parquet textFile… …]

# 事例
df.write.save("路径")

# save
#	format("…")：指定保存的数据类型，包括"csv"、"jdbc"、"json"、"orc"、"parquet"和"textFile"
#	option("…")：在"jdbc"格式下需要传入 JDBC 相应参数，url、user、password 和 dbtable
#	mode("…")：数据保存类型，"error"(default,抛异常)、"append"(追加)、"overwrite"(覆盖)、"ignore"(忽略)
#	save ("…")：在"csv"、"orc"、"parquet"和"textFile"格式下需要传入保存数据的路径
df.write.format("…")[.option("…")][.mode("…")].save("…")
#save -> json
spark.write.format("json").save("data/user.json")
# save -> jdbc
df.write.format("jdbc")
      .option("url", "jdbc:mysql://localhost:3306/test")
      .option("user", "root")
      .option("password", "123456")
      .option("dbtable", "test1")
      .mode(SaveMode.Append)
      .save()



API

MySQL

import org.apache.spark.SparkConf
import org.apache.spark.sql.expressions.Aggregator
import org.apache.spark.sql._

object Spark04_SQL_JDBC {
  def main(args: Array[String]): Unit = {

    //TODO 创建SparkSession
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("sparkSQL")
    val spark: SparkSession = SparkSession.builder().config(sparkConf).getOrCreate()

        
    //TODO 业务逻辑
    val df: DataFrame = spark.read.format("jdbc")
      .option("url", "jdbc:mysql://localhost:3306/test")
      .option("user", "root")
      .option("password", "123456")
      .option("dbtable", "test")
      .load()
    df.show()

    df.write.format("jdbc")
      .option("url", "jdbc:mysql://localhost:3306/test")
      .option("user", "root")
      .option("password", "123456")
      .option("dbtable", "test1")
      .mode(SaveMode.Append)
      .save()


    //TODO 关闭连接
    spark.stop()
  }
}



Hive

  • 导入依赖(pom.xml)

    <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-yarn_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>

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

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

<dependency>
    <groupId>org.apache.hive</groupId>
    <artifactId>hive-exec</artifactId>
    <version>1.2.1</version>
</dependency>

  • 程序

    import org.apache.spark.SparkConf
import org.apache.spark.sql._

object Spark05_SQL_Hive {
  def main(args: Array[String]): Unit = {

    //TODO 创建SparkSession
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("sparkSQL")
    //开启hive支持（enableHiveSupport）
    val spark: SparkSession = SparkSession.builder().enableHiveSupport().config(sparkConf).getOrCreate()

     
    //TODO 业务逻辑
    spark.sql("show tables").show()


    //TODO 关闭连接
    spark.stop()
  }
}
code@fzk
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark学习笔记12：DataFrame与Dataset
balabalalibala的博客
06-13 754
在Spark中，一个DataFrame所代表的是一个元素类型为Row的Dataset，即DataFrame只是Dataset[Row]的一个类型别名。
DataFrame&Dataset
kokopop007的博客
08-23 765
#DataFrame产生背景 DataFrame不是spark sql提出的，而是早在R，Pandas语言就已经存在了。 #DataFrame概述 官网概述： A Dataset is a distributed collection of data 数据集是分布式数据集合 A DataFrame is a Dataset organized into named columns. DataFra...
头歌：SparkSQL简单使用
最新发布
weixin_62399938的博客
05-01 1827
Spark SQL是用来操作结构化和半结构化数据的接口。当每条存储记录共用已知的字段集合，数据符合此条件时，Spark SQL就会使得针对这些数据的读取和查询变得更加简单高效。具体来说，Spark SQL提供了以下三大功能：(1) Spark SQL可以从各种结构化数据源（例如JSON、Parquet等）中读取数据。
DataFrame与DataSet的互操作_大数据培训
zjjcchina的博客
08-11 1763
这种方法就是在给出每一列的类型后，使用as方法，转成Dataset，这在数据类型是DataFrame又需要针对各个字段处理时极为方便。在使用一些特殊的操作时，一定要加上 import spark.implicits._ 不然toDF、toDS无法使用。3）将DataFrame转化为DataSet。3）将DataSet转化为DataFrame。1）创建一个DateFrame。2）创建DataSet。...
SparkSQL数据源
m0_53510670的博客
06-21 2162
第1关：SparkSQL加载和保存 代码： packagecom.educoder.bigData.sparksql2; importorg.apache.spark.sql.AnalysisException; importorg.apache.spark.sql.SaveMode; importorg.apache.spark.sql.SparkSession; publicclassTest1{ publicstaticvo...
Spark SQL概述及其基本用法
weixin_41812379的博客
11-01 6435
Spark SQL概述 Spark SQL是什么 Spark SQL 是 Spark 用于结构化数据(structured data)处理的 Spark 模块。 Spark SQL 的前身是Shark。Shark是基于 Hive 所开发的工具，它修改了下图所示的右下角的内存管理、物理计划、执行三个模块，并使之能运行在 Spark 引擎上。下图是 Hive和Shark的区别。 但是，Spark在不断发展，但又太过依赖Hive，有了不少限制。于是，Spark团队提出了Spark SQL。 SparkSQL抛弃
SparkSQL 笔记 01
01-07
目录SparkSQL1. 基础概念2.DataFrame3.SparkSql程序开发(1.x,2.x)（1）SparkSQL1.x（2）SparkSQL2.x SparkSQL 1. 基础概念 Spark SQL是Spark用来处理结构化数据的一个模块，它提供了一个编程抽象叫做DataFrame并且...
spark-sql入门
01-12
spark-sql入门资源！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
SparkSQL–有必要坐下来聊聊Join
02-25
Join是数据库查询永远绕不开的话题，传统查询SQL技术总体可以分为简单操作（过滤操作-where、排序操作-limit等），聚合操作-groupBy等以及Join操作等。其中Join操作是其中最复杂、代价最大的操作类型，也是OLAP场景...
Spark SQL简易教程
05-10
Spark SQL简易教程
Spark dataset and dataframe 深入分析
12-11
SPARK 最新版本支持的dataset and dataframe的深入分析和设计
Spark SQL 操作数据源
m0_59839948的博客
05-22 870
Spark SQL能够通过DataFrame 和Dataset操作多种数据源执行SQL查询，并且提供了多中数据源之间的转换方式。 读取MySQL数据库： 在master节点使用MySQL客户端创建数据库、数据表以及插入数据，具体命令如下： mysql -uroot -pPassword123$ 数据库和数据表创建后，如果想通过Spark SQL API方式访问MySQL数据库，需要在pom.xml配置文件中添加如下依赖： <dependency> ...
Spark SQL 简单使用
M_SIGNALs的博客
11-28 6762
环境：scala 版本2.11.8，spark 版本2.0.1，使用 Intellij IDEA 来开发。
RDD、DataFrame、DataSet对比与相互转换
RayfunC的博客
01-30 858
RDD (Spark1.0) —&gt; Dataframe(Spark1.3) —&gt; Dataset(Spark1.6)  三者的共性 1、RDD、DataFrame、Dataset 全都是 spark 平台下的分布式弹性数据集，为处理超大型数据提供便利 2、三者都有惰性机制，在进行创建、转换，如 map 方法时，不会立即执行，只有在遇到 Action 如 foreach 时，三...
DataFrame与Dataset 的区别
热门推荐
qq_43688472的博客
01-15 1万+
DataFrame与Dataset 的关系 DataFrame与Dataset一般与spark ml同时使用 DataFrame与Dataset均支持sparksql的操作，比如select，groupby之类，还能注册临时表/视窗，进行sql语句操作，如 dataDF.createOrReplaceTempView("tmp") spark.sql("select ROW,DATE ...
对于DataFrame结构的理解
chaohui2638457321的博客
12-22 304
对于df结构的理解 1、DataFrame = Dataset[Row] DataFrame 在Spark1.6之后就没有单独保存此类，其实是装有Row对象的Dataset Dataset的创建一般会将 Row 封装为一个案例类 而虽然移除了DataFrame这个类，但是还是依旧保存这个方法，是因为它的创建方式灵活， 增加或者删除某个字段时操作方便，而Dataset需要增删某一个字段时，则需要根据需求 创建新的Row对象，程序性能较差 2、Row Row是一个特质，D.
SparkSQL使用的简单例子
UFO的博客
02-08 2416
SparkSQL使用的一些简单例子……
RDD、DataFrame、DataSet的概念、区别联系、相互转换操作
weixin_60315352的博客
12-12 408
RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，1、RDD是Spark中的抽象数据结构类型,Spark中最基本的数据抽象,实现了以操作本地集合的方式来操作分布式数据集的抽象实现，2、它代表一个不可变、可分区、里面的元素可并行计算的集合。3、RDD具有数据流模型的特点：自动容错、位置感知性调度和可伸缩性。4、RDD允许用户在执行多个查询时显式地将工作集缓存在内存中，后续的查询能够重用工作集，这极大地提升了查询速度。
sparksql简单使用
07-11
SparkSQL是Spark中的一个模块，它提供了一种基于SQL的编程接口，可以让用户使用SQL语句来查询和操作数据。而HiveSQL是Hive中的一个模块，它也提供了一种基于SQL的编程接口，可以让用户使用SQL语句来查询和操作数据。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值