SparkSql

最新推荐文章于 2025-07-15 00:10:38 发布

qq_34795664

最新推荐文章于 2025-07-15 00:10:38 发布

阅读量417

点赞数

CC 4.0 BY-SA版权

分类专栏： Spark 文章标签： spark

本文链接：https://blog.youkuaiyun.com/qq_34795664/article/details/79946548

Spark 专栏收录该内容

3 篇文章

订阅专栏

Spark SQL是Spark处理结构化数据的模块，提供DataFrame和DataSet API。DataFrame是带Schema的分布式数据集，优于RDD，支持SQL查询。DataSet则提供强类型支持，结合了RDD和DataFrame的优点。本文介绍了DataFrame的创建、操作以及与RDD和DataSet的转换，并展示了如何从MySQL加载和写入数据。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

SparkSql

1.sparkSQL概述

Spark SQL是Spark用来处理结构化数据的一个模块，它提供了一个编程抽象叫做DataFrame并且作为分布式SQL查询引擎的作用。它是sparkSQL的底层抽象
有多种方式去使用Spark SQL，包括SQL、DataFrames API和Datasets API。但无论是哪种API或者是编程语言，它们都是基于同样的执行引擎.

1.1.sparkSQL的四大特性

1.易整合
- 将sql查询与spark程序无缝混合，可以使用java、scala、python、R等语言的API操作。
2.统一的数据访问
- 以相同的方式连接到任何数据源。以一种方式连接任意数据源
- sparkSession.read.文件格式(“当前文件格式的路径”)
3.兼容Hive
- 支持hiveSQL的语法。
4.标准的数据连接
- 可以使用行业标准的JDBC或ODBC连接。

2.DataFrame

1DataFrame概念

在Spark中，DataFrame是一种以RDD为基础的分布式数据集，类似于传统数据库的二维表格，DataFrame带有Schema元信息，即DataFrame所表示的二维表数据集的每一列都带有名称和类型，但底层做了更多的优化。DataFrame可以从很多数据源构建，比如：已经存在的RDD、结构化文件、外部数据库、Hive表。

2DataFrame与RDD的区别

DataFrame可看作是分布式的Row对象的集合，其提供了由列组成的详细模式信息，使得Spark SQL可以进行某些形式的执行优化。

左侧的RDD[Person]虽然以Person为类型参数，但Spark框架本身不了解 Person类的内部结构。

而右侧的DataFrame却提供了详细的结构信息，使得Spark SQL可以清楚地知道该数据集中包含哪些列，每列的名称和类型各是什么，DataFrame多了数据的结构信息，即schema。这样看起来就像一张表了，DataFrame还配套了新的操作数据的方法，DataFrame API（如df.select())和SQL(select id, name fromxx_table where …)。

此外DataFrame还引入了off-heap,意味着JVM堆以外的内存, 这些内存直接受操作系统管理（而不是JVM）。Spark能够以二进制的形式序列化数据(不包括结构)到off-heap中, 当要操作数据时, 就直接操作off-heap内存. 由于Spark理解schema, 所以知道该如何操作。

RDD是分布式的Java对象的集合。DataFrame是分布式的Row对象的集合。DataFrame除了提供了比RDD更丰富的算子以外，更重要的特点是提升执行效率、减少数据读取以及执行计划的优化。

有了DataFrame这个高一层的抽象后，我们处理数据更加简单了，甚至可以用SQL来处理数据了，对开发者来说，易用性有了很大的提升。

不仅如此，通过DataFrame API或SQL处理数据，会自动经过Spark 优化器（Catalyst）的优化，即使你写的程序或SQL不高效，也可以运行的很快。

3DataFrame与RDD的优缺点

RDD的优缺点：
- 优点:
- （1）编译时类型安全
  - 编译时就能检查出类型错误
- （2）面向对象的编程风格
  - 直接通过对象调用方法的形式来操作数据
- 缺点:
- （1）序列化和反序列化的性能开销
  - 无论是集群间的通信, 还是IO操作都需要对对象的结构和数据进行序列化和反序列化。
- （2）GC的性能开销
  - 频繁的创建和销毁对象,势必会增加GC
- DataFrame通过引入schema和off-heap（不在堆里面的内存，指的是除了不在堆的内存，使用操作系统上的内存），解决了RDD的缺点, Spark通过schame就能够读懂数据, 因此在通信和IO时就只需要序列化和反序列化数据, 而结构的部分就可以省略了；通过off-heap引入，可以快速的操作数据，避免大量的GC。但是却丢了RDD的优点，DataFrame不是类型安全的, API也不是面向对象风格的。

4创建DataFrame

创建dataframe的方式（统一的数据源访问接口sparkSession）

1、读取文本文件创建
- spark.read.text(“路径”)
2、读取json格式文件创建
- spark.read.json(“路径”)
3、读取parquet格式化文件创建
- spark.read.parquet(“路径”)
在spark shell 执型命令 ,读取文件信息

(1)先执行spark-shell --master local[2]
val lineRDD= sc.textFile("/person.txt").map(_.split(" "))

(2)定义case class（相当于表的schema）
case class Person(id:Int, name:String, age:Int)

(3)将RDD与cass class 关联
val personRDD = lineRDD.map(x=>Person(x(0).toInt, x(1), x(2).toInt))

(4)将RDD转换成DataFrame
val personDF = personRDD.toDF

(5)对DataFrame进行处理
personDF.show()

(6)通过SparkSession构建DataFrame
使用spark-shell中已经初始化好的SparkSession对象spark生成DataFrame
val dataFrame=spark.read.text("/person.txt")

5DataFrame的一些操作

DSL语法风格:

 1、打印DataFrame的schema(元数据信息,表的一些字段,值是否可以为空)
   printlnSchema
 2、查看dataFrame中的数据
   show
 3、取出第一位
   first
   head(N) 取出前N个
 4、查看某个字段
   peopleDF.select("name").show
   peopleDF.select(col("name")).show
   peopleDF.select($"name").show
   peopleDF.select(peopleDF("name")).show
 5、取出多个字段
   peopleDF.select("name","age").show
 6、让age字段+1
   peopleDF.select(col("age")+1).show
 7、过滤出年龄大于30的人数
   peopleDF.filter($"age" > 30).count
 8、按年龄进行分组并统计相同年龄的人数
   personDF.groupBy("age").count().show

SQL语法风格(基于dataframe在转换为表格)

1、先需要将DataFrame注册成一张临时表
    personDF.registerTempTable("t_person")

2、然后通过sparkSession.sql(sql语句)操作DataFrame
    sparkSession.sql("select * from t_person").show

3.DataSet

1.DataSet概念

DataSet是分布式的数据集合，Dataset提供了强类型支持，也是在RDD的每行数据加了类型约束。DataSet是在Spark1.6中添加的新的接口。它集中了RDD的优点（强类型和可以用强大lambda函数）以及使用了Spark SQL优化的执行引擎。DataSet可以通过JVM的对象进行构建，可以用函数式的转换（map/flatmap/filter）进行多种操作。

2.DataFrame、DataSet、RDD的区别

假设RDD中的两行数据长这样：

那么DataFrame中的数据长这样:

那么Dataset中的数据长这样:

或者长这样（每行数据是个Object）:

DataSet包含了DataFrame的功能，Spark2.0中两者统一，DataFrame表示为DataSet[Row]，即DataSet的子集
- （1）DataSet可以在编译时检查类型
- （2）并且是面向对象的编程接口

3.DataFrame 与DataSet互相转换

DataFrame和DataSet可以相互转化。

（1）DataFrame转为 DataSet

df.as[ElementType] 这样可以把DataFrame转化为DataSet。

（2）DataSet转为DataFrame

ds.toDF() 这样可以把DataSet转化为DataFrame。

4.创建DataSet

1）通过spark.createDataset创建

val ds1 =spark.createDataset(1 to 10)

2）通toDS方法生成DataSet

case  class Pserson(name:String,age:Long)
val data = List(Person("zhangsan",20),Person("wangwu",18))
val ds = data.toDS

3）通过DataFrame转化生成,使用as[类型]转换为DataSet

5.RDD转换成DataFrame

1.通过反射指定schema(case class)
2.通过StructType指定schema

val schema:StructType= StructType(
StructField("id", IntegerType, false) ::
   StructField("name", StringType, false) ::
   StructField("age", IntegerType, true) :: Nil)

1编写Spark SQL程序操作HiveContext

//todo:sparkSql 操作hive的SQL
object sparkHiveSql {
  def main(args: Array[String]): Unit = {
    //1.创建spark的sparksession
    val spark: SparkSession = SparkSession.builder().appName("sparkHiveSql").master("local[2]").enableHiveSupport().getOrCreate()
    spark.sparkContext.setLogLevel("WARN")


    //操作就HIV额SQL语句
    spark.sql("create table if not exists person(id int,name string,age int) row format delimited fields terminated by ' ' ")
    spark.sql("load data local inpath './data/Person.txt' into table person")
    spark.sql("select * from person").show()
    spark.stop()
  }
}

6.数据源

1.sparkSql 从mysql 中加载数据

调用sparkSession.read方法读取MySQL的数据库中的数据

object sparkSqlFromMysql {

  def main(args: Array[String]): Unit = {
    //1.创建sparkSession对象
    val spark: SparkSession = SparkSession.builder().appName("sparkSqlFromMysql").master("local[2]").getOrCreate()
    //2.创建Properties对象,设置连接myslq的配置信息
    val properties: Properties = new Properties()
    properties.setProperty("user", "root")
    properties.setProperty("password", "hadoop")
    val url: String = "jdbc:mysql://192.168.1.20:3306/mytest"
    //TODO:读取MySQL的数据
    val mysqlDF: DataFrame = spark.read.jdbc(url, "iplocation", properties)
    //显示MySQL的数据
    mysqlDF.show()
    spark.stop()
  }
}

1.1通过spark-shell运行

（1)启动spark-shell(必须指定mysql的连接驱动包)

spark-shell \
--master spark://node1:7077 \
--executor-memory 1g \
--total-executor-cores  2 \
--jars /opt/bigdata/hive/lib/mysql-connector-java-5.1.35.jar \
--driver-class-path /opt/bigdata/hive/lib/mysql-connector-java-5.1.35.jar

(2)从mysql中加载数据

  val mysqlDF = spark.read.format("jdbc").options(Map("url"
  -> "jdbc:mysql://192.168.200.150:3306/spark", "driver"
  -> "com.mysql.jdbc.Driver", "dbtable" ->
  "iplocation", "user" -> "root",
  "password" -> "123456")).load()

2parkSql将数据写入到MySQL中

调用DataFrame.write方法将数据写入到MySQL的数据库中

//todo:将sparkSQL的数据写入mysql
object sparkSql2Mysql {

  def main(args: Array[String]): Unit = {
    //1.定义sparkSession  对象
    val spark: SparkSession = SparkSession.builder().appName("sparkSql2Mysql").getOrCreate()
    //2.读取文件
    val data: RDD[String] = spark.sparkContext.textFile(args(0))
    //3.对数据进行拆分
    val lines: RDD[Array[String]] = data.map(_.split(" "))
    //4.关联样例类
    val personRDD: RDD[person] = lines.map(x => person(x(0).toInt, x(1), x(2).toInt))
    //TODO:转换为dataframe,导如隐式转换
    import spark.implicits._
    val personDF: DataFrame = personRDD.toDF()
    //5.将dataframe注册成表
    personDF.createTempView("t_person")
    //6.操作表,表中数据按照年龄进行降序
    val resultDF: DataFrame = spark.sql("select * from t_person order by age desc")
    //7.将结果保存到数据库
    val url: String = "jdbc:mysql://192.168.1.20:3306/mytest"
    val properties: Properties = new Properties()
    properties.setProperty("user", "root")
    properties.setProperty("password", "hadoop")
    resultDF.write.mode(SaveMode.Append).jdbc(url, args(1), properties)
    //关闭
    spark.stop()
  }
}

mode的几种格式

 /**
   * Specifies the behavior when data or table already exists. Options include:
   *   - `overwrite`: overwrite the existing data.
   *   - `append`: append the data.
   *   - `ignore`: ignore the operation (i.e. no-op).
   *   - `error`: default option, throw an exception at runtime.
   */

*-* overwrite：覆盖之前数据(会事先创建一个表)
*-* append:追加数据(会事先创建一个表)
*-* ingore:忽略，只要表存在就不进行任何操作
*-* errorIfExist:默认选项。存在表就报错

将Jar包提交到spark集群

spark-submit \
--class test.sql.SparkSqlToMysql \
--master spark://node1:7077 \
--executor-memory 1g \
--total-executor-cores 2 \
--jars /opt/bigdata/hive/lib/mysql-connector-java-5.1.35.jar  \
--driver-class-path /opt/bigdata/hive/lib/mysql-connector-java-5.1.35.jar \
/root/original-spark-2.0.2.jar  /person.txt