SPARK基础2(读入文件、转临时表、RDD与DataFrame)

上文介绍了spark的各种组件和入门,本文主要介绍spark读入文件以及数据格式(RDD/DataFrame)

1、读入文件与转临时表

1、json文件读取

val df = spark.read.json("E:/people.json")
df.show()//将DataFrame的内容显示到页面

2、CSV文件读取(注意编码要UTF-8)

df=spark.read.csv("E:/emp1.csv")

也可以这样设置

val result = spark.read.format("csv")
 .option("delimiter", "|")//分隔符,默认为逗号,
 .option("header", "true")//第一行不作为数据内容,作为标题
 .option("quote", "'")//quote 引号字符,默认为双引号"
 .option("nullValue", "\\N") //指定一个字符串代表 null 值
 .option("inferSchema", "true")//header 第一行不作为数据内容,作为标题
 .load("test-in/csv/csv_with_header.csv")

完整案例如下所示:

import org.apache.spark.sql.SparkSession
/**
  *scala版本的DataFrame的常用操作。
  *通常将DataFrame存储在一张临时表中,后面通过执行sql的方式执行操作。
  *@authoryangshaojun
  *#date2019/4/39:29
  *@version1.0
  */
object SparkSql_002_DataFrameNormalOperation{
  def main(args:Array[String]):Unit={
    val spark=SparkSession
      .builder()
      .master("local")
      .appName("SparkSql_003_DataFrameNormalOperation")
      .getOrCreate()
    //等同于SQLContext对象sc.read().json("../.json")以及sc.read().load(../.json)
    val df=spark.read.csv("E:/emp1.csv")
    val result=spark.read.format("csv")
      .option("delimiter",",")
      .option("inferSchema",true.toString)//这是自动推断属性列的数据类型。
      .option("header","true")
      .option("quote","'")
      .option("nullValue","\\N")
      .option("inferSchema","true")
      .load("E:/emp1.csv")
    result.show()
    result.createOrReplaceTempView("result")//创建临时表
    spark.sql("SELECT * FROM result where score>60").show()
  }
}

3、TXT
A、spark.read.textFile方法(返回是一个整体很难看)

val testtxt=spark.read.textFile("E:/emp1.txt")
testtxt.show()//成功读取文件数据
testtxt.createOrReplaceTempView("testtxt")//创建临时视图,此视图的生命周期与用于创建此数据集的[SparkSession]相关联。

±-----+
| value|
±-----+
| 张绣,98|
|张老三,55|
| 柳丝,87|
| 赵四,56|
|张无忌,99|
|朱元璋,91|
±-----+

2、(优先推荐)spark.sparkContext.textFile
返回的是个RDD,可以通过createDataFrame方法将RDD转为DataFrame进行查询

val spark = SparkSession
 .builder()
 .appName("testpeople")
 .master("local")
 .getOrCreate()
    // 使用createDataFrame
val FileRDD = spark.sparkContext.textFile("C:/Users/Administrator/Desktop/课程代码/testT.txt",2).map{
lines=>valline=lines.split(",")Row(line(0),line(1).toInt)
}

整体案例如下所示:

package com.cdpsql1
import org.apache.spark.sql.{Row,SparkSession}
import org.apache.spark.sql.types._
import scala.collection.mutable
import java.text.SimpleDateFormat
object SparkSqlExample1{
  def main(args:Array[String]):Unit={
    val spark=SparkSession
      .builder()
      .master("local")
      .appName("test")
      .config("spark.sql.shuffle.partitions","5")
      .getOrCreate()
    //表结构
    val ScoreSchema:StructType=StructType(mutable.ArraySeq(
      StructField("name",StringType,nullable=false),
      StructField("score",IntegerType,nullable=false)
    ))

    //导入数据
    val ScoreData=spark.sparkContext.textFile("E:/emp1.txt").map{
      lines=>val line=lines.split(",")
        Row(line(0),line(1).toInt)
    }
    //转表
    val ScoreTable=spark.createDataFrame(ScoreData,ScoreSchema)
    ScoreTable.createOrReplaceTempView("Score")
    spark.sql("select * from Score where score>60").show()

  }
}

也可以用case class定义表结构

//定义case class,相当于表结构
case class People(var name:String,var sc:Int)
import org.apache.spark.{SparkContext, SparkConf}
import org.apache.spark.sql.{SparkSession}
object TestDataFrame1 {
  def main(args: Array[String]): Unit = {
    val spark=SparkSession
      .builder()
      .master("local")
      .appName("test")
      .config("spark.sql.shuffle.partitions","5")
      .getOrCreate()
     val sqlContext=spark.sqlContext
    //先将RDD转化成case class 数据类型,然后再通过toDF()方法隐式转换成DataFrame
    import sqlContext.implicits._
    // 将本地的数据读入 RDD, 并将 RDD 与 case class 关联
    val peopleRDD = spark.sparkContext.textFile("E:/emp1.txt")
      .map{line => People(line.split(",")(0), line.split(",")(1).trim.toInt)}

    // 将RDD 转换成 DataFrames
    val df = peopleRDD.toDF()
    //将DataFrames创建成一个临时的视图

    df.createOrReplaceTempView("people")
    //使用SQL语句进行查询
    df.show()

  }
}
//定义case class,相当于表结构
case class People(var name:String,var sc:Int)
import org.apache.spark.sql.{SparkSession}
object TestDataFrame1 {
  def main(args: Array[String]): Unit = {

    val spark=SparkSession
      .builder()
      .master("local")
      .appName("test")
      .config("spark.sql.shuffle.partitions","5")
      .getOrCreate()
    //先将RDD转化成case class 数据类型,然后再通过toDF()方法隐式转换成DataFrame
    import spark.implicits._
    // 将本地的数据读入 RDD, 并将 RDD 与 case class 关联
    val peopleRDD = spark.sparkContext.textFile("E:/emp1.txt")
      .map{line => People(line.split(",")(0), line.split(",")(1).trim.toInt)}
    // 将RDD 转换成 DataFrames
    val df = peopleRDD.toDF()
    //将DataFrames创建成一个临时的视图
    df.createOrReplaceTempView("people")
    //使用SQL语句进行查询
    df.show()
  }
package t1
import org.apache.spark.sql.{SparkSession,Row}
object r4 {
  def main(a: Array[String])={
    val spark=SparkSession
      .builder()
      .master("local")
      .appName("test")
      //.config("spark.sql.shuffle.partitions","1")
      .getOrCreate()
    import spark.implicits._
    val pd=spark.sparkContext.textFile("E:/emp1.txt").map{
      lines => val line=lines.split(",")
        person(line(0), line(1).toInt)
    }
    val pe=pd.toDF()
    pe.show()
  }
}

分列读入,方便后期filter过滤

    val pd = spark.sparkContext.textFile("E:/emp1.txt").map {
      line => {
        val f=line.split(",")
        val name=f(0)
        val sc=f(1).toInt
        (name,sc)
      }
    }
    val x=pd.filter(t => t._2.toInt > 60)
    x.foreach(println)

val pd=spark.sparkContext.textFile("E:/emp1.txt").map{
line=>person(line.split(",")(0),line.split(",")(1).toInt)
}.toDF("X1","X2")
pd.show()
val x=pd.filter($"X2">60)
x.show()

2、RDD与DataFrame

接下来说的是spark中的数据格式:RDD与DataFrame
RDD和DataFrame在前文已经介绍很多次了,这里我们详细介绍这两种数据格式

2.1 RDD

RDD(Resilient Distributed Dataset)叫做弹性分布式数据集,是Spark中最基本的数据抽象,它代表一个不可变、可分区、里面的元素可并行计算的集合。
1.弹性 正常情况下,数据是存放到内存里的,但是如果说内存放不下这么多数据时,这时候就会写到磁盘。RDD的这种自动进行内存和磁盘之间权衡和切换的机制,就是RDD的弹性的特点所在。对用户来说是透明的。

2.分布式
简单说就是数据存放到不同机器上,1个Rdd=多个Partition,Parition就是分区,这个分区其实是个非常重要的概念,为什么这么说呢?Paritition本质上只是一部分数据,它和Task是一一对应的,task在提交的时候又有什么依据呢?其实又跟这个有关系

3.数据集
数据集这个概念也是相当有意思,你以为就是简单的一堆数据吗?答案是否定 ,RDD可以理解为“数据+对数据操作”,RDD的基本单位是partition,以及每个分片的操作函数,也就是算子。当然了,RDD还“记录”着自身的血缘关系,对parent RDD的依赖,官方叫“lineage”。仅仅这么简单吗?这涉及到RDD的容错性,当某个节点挂掉了,这时候数据就丢失了,怎么办?spark程序挂掉了?那这也太low了,RDD是有很强的容错性的,当它发现自己的数据丢失了以后,会自动从自己来源的数据进行重计算,重新获取自己这份数据,这就是“血缘关系”。

由上可知,RDD特点为:分区,不可变,并行操作。
a, 分区
每一个 RDD都被分为多个分区,每个分区 运行在集群的不同节点上。
RDD可以包含PYTHON、JAVA、scala中任意类型的对象,甚至是用户自定义对象。
逻辑上我们可以将 RDD 理解成一个大的数组,数组中的每个元素就代表一个分区 (Partition) 。

在物理存储中,每个分区指向一个存储在内存或者硬盘中的数据块 (Block) ,其实这个数据块就是每个 task 计算出的数据块,它们可以分布在不同的节点上。

所以,RDD 只是抽象意义的数据集合,分区内部并不会存储具体的数据,只会存储它在该 RDD 中的 index,通过该 RDD 的 ID 和分区的 index 可以唯一确定对应数据块的编号,然后通过底层存储层的接口提取到数据进行处理。

在集群中,各个节点上的数据块会尽可能的存储在内存中,只有当内存没有空间时才会放入硬盘存储,这样可以最大化的减少硬盘 IO 的开销。

b,不可变
不可变性是指每个 RDD 都是只读的,它所包含的分区信息是不可变的。由于已有的 RDD 是不可变的,所以我们只有对现有的 RDD 进行转化 (Transformation) 操作,才能得到新的 RDD ,一步一步的计算出我们想要的结果。

这样会带来这样的好处:我们在 RDD 的计算过程中,不需要立刻去存储计算出的数据本身,我们只要记录每个 RDD 是经过哪些转化操作得来的,即:依赖关系,这样一方面可以提高计算效率,一方面是错误恢复会更加容易。如果在计算过程中,第 N 步输出的 RDD 的节点发生故障,数据丢失,那么可以根据依赖关系从第 N-1 步去重新计算出该 RDD,这也是 RDD 叫做"弹性"分布式数据集的一个原因。

c,并行操作
因为 RDD 的分区特性,所以其天然支持并行处理的特性。即不同节点上的数据可以分别被处理,然后生成一个新的 RDD。
RDD的创建方式一般有三种,1、读入文件;2、创建,sc.parallelize(array),3其他形式转化
下文会接着介绍RDD的特性与算子

2.2DataFrame

DataFrame与RDD的区别:
在这里插入图片描述
从上面的图中可以看出DataFrame和RDD的区别。RDD是分布式的 Java对象的集合,比如,RDD[Person]是以Person为类型参数,但是,Person类的内部结构对于RDD而言却是不可知的。DataFrame是一种以RDD为基础的分布式数据集,也就是分布式的Row对象的集合(每个Row对象代表一行记录),提供了详细的结构信息,也就是我们经常说的模式(schema),Spark SQL可以清楚地知道该数据集中包含哪些列、每列的名称和类型。

和RDD一样,DataFrame的各种变换操作也采用惰性机制,只是记录了各种转换的逻辑转换路线图(是一个DAG图),不会发生真正的计算,这个DAG图相当于一个逻辑查询计划,最终,会被翻译成物理查询计划,生成RDD DAG,按照之前介绍的RDD DAG的执行方式去完成最终的计算得到结果。
RDD怎么转化为DATAFRAME?
一般来说有两种方法:class case和StructType
参照上文读入文件的方法解决。
综上,SPARK中的DATAFRAME特点如下:
1)分布式的数据集,并且以列的方式组合的。相当于具有schema的RDD
2)相当于关系型数据库中的表,但是底层有优化
3)提供了一些抽象的操作,如select、filter、aggregation、plot(具体api操作在下文中:SPARK基础3(DataFrame操作)
4)它是由于R语言或者Pandas语言处理小数据集的经验应用到处理分布式大数据集上
5)在1.3版本之前,叫SchemaRDD

  • 2
    点赞
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值