SparkSQL代码笔记01——创建SparkSession、RDD和DF和DS相互转换、DSL和SQL风格

最新推荐文章于 2022-11-18 23:02:50 发布

嘉平11

最新推荐文章于 2022-11-18 23:02:50 发布

阅读量1.8k

点赞数

分类专栏： Spark

本文链接：https://blog.csdn.net/zgm12/article/details/104451548

版权

Spark 专栏收录该内容

28 篇文章 1 订阅

订阅专栏

一、创建sparksession的几种方法：

package scalaBase.day13

import org.apache.spark.SparkConf
import org.apache.spark.sql.{DataFrame, SparkSession}

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

    val spark1 = SparkSession.builder().appName("sparkSessionDemo1").master("local").getOrCreate()
    val conf = new SparkConf().setAppName("sparkSessionDemo1").setMaster("local")
    val spark2 = SparkSession.builder().config(conf).getOrCreate()
    val spark3 = SparkSession.builder().appName("SparkSessionDemo1").master("local")
      .enableHiveSupport() //获得hive支持
      .getOrCreate()

    val df1: DataFrame = spark1.read.json("D:/MyBigData/Aspark/data/spark/people.json")
df1.show()

    val df2: DataFrame = spark2.read.json("D:/MyBigData/Aspark/data/spark/people.json")
    df2.show()
    val df3: DataFrame = spark3.read.json("D:/MyBigData/Aspark/data/spark/people.json")
  df3.show()

    spark1.stop()
    spark2.stop()
    spark3.stop()
  }
}

二、RDD和DF和DS相互转换

2.1.DF和DS的区别：

对于SparkCore而言对数据的进行操作需要先转换成RDD,对RDD可以使用各种算子进行处理,最终对数据进行统一的操作,所以我们将RDD看做是对数据的封装(抽象)

对于SparkSQL而言对数据进行操作的也需要进行转换,这里提供了两个新的抽象,分别是DataFrame和DataSet

//好像SparkSQL底层还是调用RDD

RDD vs DataFrames vs DataSet

首先从版本的产生上来看RDD(Spark1.0)—>Dataframe(Spark1.3)—>Dataset(Spark1.6)

RDD

RDD是一个懒执行的不可变的可以支持Functional(函数式编程)的并行数据集合。

RDD的最大好处就是简单，API的人性化程度很高。

RDD的劣势是性能限制，它是一个JVM驻内存对象，这也就决定了存在GC的限制和数据增加时Java序列化成本的升高。

DataFrame

简单来数DataFrame是RDD+Schema的集合

什么是Schema?

之前我们学习过MySQL数据库,在数据库中schema是数据库的组织和结构模式中包含了schema对象，可以是表(table)、列(column)、数据类型(data type)、视图(view)、存储过程(stored procedures)、关系(relationships)、主键(primary key)、外键(foreign key)等,Sechema代表的就是一张表。

与RDD类似，DataFrame也是一个分布式数据容器。然而DataFrame更像传统数据库的二维表格，除了数据以外，还记录数据的结构信息，即schema。同时，与Hive类似，DataFrame也支持嵌套数据类型（struct、array和map）。从API易用性的角度上看，DataFrame API提供的是一套高层的关系操作，比函数式的RDD API要更加友好，门槛更低。由于与R和Pandas的DataFrame类似，Spark DataFrame很好地继承了传统单机数据分析的开发体验。

DataFrame是为数据提供了Schema的视图。可以把它当做数据库中的一张表来对待

DataFrame也是懒执行的。

性能上比RDD要高，主要有两方面原因：

定制化内存管理

优化的执行计划

Dataframe的劣势在于在编译期缺少类型安全检查，导致运行时出错。

ps:DataFrame只是知道字段，但是不知道字段的类型，所以在执行这些操作的时候是没办法在编译的时候检查是否类型失败的，比如你可以对一个String进行减法操作，在执行的时候才报错，而DataSet不仅仅知道字段，而且知道字段类型，所以有更严格的错误检查。

Dataset

是Dataframe API的一个扩展，是Spark最新的数据抽象

用户友好的API风格，既具有类型安全检查也具有Dataframe的查询优化特性。

Dataset支持编解码器，当需要访问非堆上的数据时可以避免反序列化整个对象，提高了效率。

样例类被用来在Dataset中定义数据的结构信息，样例类中每个属性的名称直接映射到DataSet中的字段名称。

Dataframe是Dataset的特列，DataFrame=Dataset[Row] ，所以可以通过as方法将Dataframe转换为Dataset。Row是一个类型，跟Car、Person这些的类型一样，所有的表结构信息我们都用Row来表示。

DataSet是强类型的。比如可以有Dataset[Car]，Dataset[Person]。

ps:DataSet[Row]这个类似于我们学习的泛型Row就是泛型类型。

三者的共性

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

2、三者都有惰性机制，在进行创建、转换，如map方法时，不会立即执行，只有在遇到Action如foreach时，三者才会开始遍历运算，极端情况下，如果代码里面有创建、转换，但是后面没有在Action中使用对应的结果，在执行时会被直接跳过。

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

4、三者都有partition的概念。

5、三者有许多共同的函数，如filter，排序等。

6、在对DataFrame和Dataset进行操作许多操作都需要这个包进行支持。

7、DataFrame和Dataset均可使用模式匹配获取各个字段的值和类型。

三者的区别

RDD

1、RDD一般和spark mlib同时使用

2、RDD不支持sparksql操作

DataFrame

1、与RDD和Dataset不同，DataFrame每一行的类型固定为Row，只有通过解析才能获取各个字段的值每一列的值没法直接访问。

2、DataFrame与Dataset一般不与spark mlib同时使用。

3、DataFrame与Dataset均支持sparksql的操作，比如select，groupby之类，还能注册临时表/视窗，进行sql语句操作。

4、DataFrame与Dataset支持一些特别方便的保存方式，比如保存成csv，可以带上表头，这样每一列的字段名一目了然。

利用这样的保存方式，可以方便的获得字段名和列的对应，而且分隔符（delimiter）可以自由指定。

Dataset

Dataset和DataFrame拥有完全相同的成员函数，区别只是每一行的数据类型不同。

DataFrame也可以叫Dataset[Row],每一行的类型是Row，不解析，每一行究竟有哪些字段，各个字段又是什么类型都无从得知，只能用上面提到的getAS方法或者共性中的第七条提到的模式匹配拿出特定字段。

而Dataset中，每一行是什么类型是不一定的，在自定义了case class之后可以很自由的获得每一行的信息。

Dataset在需要访问列中的某个字段时是非常方便的，然而，如果要写一些适配性很强的函数时，如果使用Dataset，行的类型又不确定，可能是各种case class，无法实现适配，这时候用DataFrame即Dataset[Row]就能比较好的解决问题。

2.2 相互转换

RDD转DataFrame有三种方法：

1.直接转换即使用元组的模式存储在转换 toDF

2.使用样例类的模式匹配Scheam在转换 toDF

3.StructType直接指定Schema在转换 spark.createDataFrame

RDD转DataSet：

使用样例类的模式匹配Scheam再转换 toDS

ps:其余读取文件的方式可以直接获取对应的DataFrame

DataSet和DataFrame之间的互相转换：

DataSet转换DataFrame：调用toDF方法,直接用case class中定义的属性

DataFrame转换DataSet：调用as[对应样例类类名]

DataSet和DataFrame转换为RDD：DataSet对象或DataFrame对象调用rdd方法就可以转换为rdd

部分示范：

RDD转换成DataFrame:

//1.1在toDF时添加schema信息----------------------------------------------------
package scalaBase.day13

import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.sql.SparkSession

object sparkSQLDemo1 {
  def main(args: Array[String]): Unit = {
    //将RDD转为DF

    val conf2 = new SparkConf().setAppName("sparkSessionDemo1").setMaster("local")
    val sc = new SparkContext(conf2)
    val spark1 = SparkSession.builder().appName("sparkSessionDemo1").master("local").getOrCreate()

    val rdd1 = sc.textFile("D:/MyBigData/Aspark/data/spark/people.txt").map(x => {
      val f = x.split(",")
      (f(0), f(1).toInt)
    })

    import spark1.implicits._    //用到toDF所以要引入这个，注意，spark1这里是sparkSession对象
    val df1 = rdd1.toDF("name","age")  //RDD转DF
    df1.show()

    spark1.stop()
  }
}


//1.2，使用样例类、toDF----------------------------------------------------
package scalaBase.day13

import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.sql.SparkSession

//通过映射方式转换成DF

case class People(name:String,age:Int)
object sparkSQLDemo2 {
  def main(args: Array[String]): Unit = {
    val conf2 = new SparkConf().setAppName("sparkSessionDemo1").setMaster("local")
    val sc = new SparkContext(conf2)
    val spark1 = SparkSession.builder().appName("sparkSessionDemo1").master("local").getOrCreate()

    val rdd1 = sc.textFile("D:/MyBigData/Aspark/data/spark/people.txt").map(x => {
      val f = x.split(",")
      People(f(0),f(1).toInt)   //这里不一样了
    })


    import spark1.implicits._
    val df1 = rdd1.toDF()  //RDD转DF
    df1.show()

    spark1.stop()
  }
}


//1.3，使用StructType----------------------------------------------------
package scalaBase.day13

import org.apache.spark.rdd.RDD
import org.apache.spark.sql.types.{IntegerType, StringType, StructField, StructType}
import org.apache.spark.sql.{Row, SparkSession, types}
import org.apache.spark.{SparkConf, SparkContext}

object sparkSQLDemo3 {
  def main(args: Array[String]): Unit = {
    //将RDD转为DF

    val conf2 = new SparkConf().setAppName("sparkSessionDemo1").setMaster("local")
    val sc = new SparkContext(conf2)
    val spark1 = SparkSession.builder().appName("sparkSessionDemo1").master("local").getOrCreate()

    val rdd1: RDD[Row] = sc.textFile("D:/MyBigData/Aspark/data/spark/people.txt").map(x => {
      val f = x.split(",")
      Row(f(0), f(1).toInt) //此处要用Row
    })


    val schame: StructType = StructType(
      Array(
        StructField("name", StringType, false),   //参数分别为：列名、列类型、是否可为空
        StructField("age", IntegerType, false)
      )
    )
    val df = spark1.createDataFrame(rdd1,schame)    //这里也不一样了
df.show()

    spark1.stop()
  }
}

RDD转换成DataSet:

package com.zgm.sc.day14
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, Dataset, SparkSession}
import org.apache.spark.{SparkConf, SparkContext}

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

//通过映射将RDD转化成SparkSession
object SparkSQLDemo4{
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setAppName("b").setMaster("local")
    val sc: SparkContext = new SparkContext(conf)

    val data: RDD[Array[String]] = sc.textFile("data/people.txt").map(_.split(","))
    val tupRDD: RDD[People] = data.map(x=>People(x(0),x(1).trim.toInt))

    val spark: SparkSession = SparkSession.builder().config(conf).getOrCreate()
    import spark.implicits._
    val ds: Dataset[People] = tupRDD.toDS()
    ds.show()
    sc.stop()
    spark.stop()
  }

}

DataFrame转换成RDD:

无论是通过那这种方式获取的DataFrame都可以使用一个方法转换
val frameToRDD: RDD[Row] = frame.rdd
frameToRDD.foreach(x => println(x.getString(0)+","+x.getInt(1)))

DataSet转换成RDD:

//调用rdd方法
val dataSetTORDD:RDD[People] = dataSet.rdd
dataSetTORDD.foreach(x => println(x.name+","+x.age));

DataSet转换DataFrame

//调用toDF方法,直接服用case class中定义的属性
val frame: DataFrame = dataSet.toDF()
frame.show()

DataFrame转换DataSet

val value: Dataset[People] = frame.as[People]
case class People(name:String,age:Int)

三、DSL和SQL风格

1.DSL：

package scalaBase.day13

import org.apache.spark.SparkConf
import org.apache.spark.sql.{DataFrame, SparkSession}

object sparkSQLDemo5 {
  def main(args: Array[String]): Unit = {
    val spark1 = SparkSession.builder().appName("sparkSessionDemo1").master("local").getOrCreate()

    val df1: DataFrame = spark1.read.json("D:/MyBigData/Aspark/data/spark/people.json")
    import spark1.implicits._
    val df2: DataFrame = df1.groupBy($"age").count()//此处的count是组内count
    df2.show()
    df1.select($"age">20).show()
    df1.filter($"age">20).show()

  }
}



//运行结果：
+---+-----+
|age|count|
+---+-----+
| 29|    1|
| 19|    1|
| 30|    1|
+---+-----+

+----------+
|(age > 20)|
+----------+
|      true|
|      true|
|     false|
+----------+

+---+-------+
|age|   name|
+---+-------+
| 29|Michael|
| 30|   Andy|
+---+-------+


Process finished with exit code 0

2.SQL风格

需要用到createOrReplaceTempView函数

注意：SparkSQL只可以对数据进行查询，而不可以进行增删改查！！！！！！！

不管是SQL风格还是DSL风格，实质一样的，只是表现形式不同

package com.qf.gp1921.day13

import org.apache.spark.SparkConf
import org.apache.spark.sql.{DataFrame, SparkSession}

/**
  * SQL语句风格
  */
object SparkSQLDemo6 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SparkSQLDemo6").setMaster("local")
    val spark = SparkSession.builder().config(conf).getOrCreate()

    val df: DataFrame = spark.read.json("dir/people.json")

    // 注册为一张临时表
    df.createOrReplaceTempView("person")
    // 用sql进行查询
    val sqlDF: DataFrame = spark.sql("select * from person where age > 20 limit 10")

    sqlDF.show()
    // 主要是应用范围的区别，该方法属于一个全局表，如果访问全局表需要给全路径
    // 这种方式使用率极少
    df.createGlobalTempView("person2")
    spark.sql("select * from global_temp.person2").show()
    spark.newSession().sql("select * from global_temp.person2").show
    
    spark.stop
  }
}

嘉平11

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
SparkSQL代码笔记01——创建SparkSession、RDD和DF和DS相互转换、DSL和SQL风格

一、创建sparksession的几种方法：package scalaBase.day13import org.apache.spark.SparkConfimport org.apache.spark.sql.{DataFrame, SparkSession}object sparkSessionDemo1 { def main(args: Array[String]): U...
复制链接

扫一扫