DataFrame的read和write&SparkSQL&UDF函数&存储格式的转换

DataFrame

在Spark中，DataFrame是一种以RDD为基础的分布式数据集，类似于传统数据库中的二维表格。DataFrame与RDD的主要区别在于，前者带有schema元信息，即DataFrame所表示的二维表数据集的每一列都带有名称和类型。这使得Spark SQL得以洞察更多的结构信息，从而对藏于DataFrame背后的数据源以及作用于DataFrame之上的变换进行了针对性的优化，最终达到大幅提升运行时效率的目标。反观RDD，由于无从得知所存数据元素的具体内部结构，Spark Core只能在stage层面进行简单、通用的流水线优化。
DataFrame的read和write
json
read

def main(args: Array[String]): Unit = {
     
    val spark = SparkSession.builder
      .master("local")
      .appName(this.getClass.getSimpleName)
      .getOrCreate()
    val df: DataFrame = spark.read.json("D:\\testlog\\people.json")
    import spark.implicits._
    //可以使用UDF
    df.select($"name",$"age").show()
    //不可以使用UDF,适用于大部分场景
    df.select("name","age").show()
    //不建议使用
    df.select(df.col("name"),df.col("age")).show()
    spark.stop()
 }

select方法用于选择要输出的列，推荐使用$"col"和"col"的方法

• 使用select方法可以选取打印的列，空值为null
• show()默认打印20条数据，可以指定条数
• truncate默认true,截取长度，可以设置为false

filter写法

 df.select($"name",$"age").filter('name === "Andy").show() //推荐使用
 df.select($"name",$"age").filter(df("name") === "Andy").show()
 df.select($"name",$"age").filter("name = 'Andy'").show()

write

 val df1 = df.select($"name",$"age").filter('name === "Andy")
 df1.write.mode(SaveMode.Overwrite).json("D:\\testlog\\aa.json")

Save操作可以选择使用SaveMode，它指定目标如果存在，如何处理现有数据。重要的是要认识到，这些保存模式不利用任何锁定，也不是原子性的。此外，在执行覆盖时，在写入新数据之前将删除数据。

Scala/Java	Any Language	Meaning
SaveMode.ErrorIfExists (default)	“error” or “errorifexists” (default)	在将DataFrame保存到数据源时，如果数据已经存在，则会抛出error。
SaveMode.Append	“append”	在将DataFrame保存到数据源时，如果数据/表已经存在，则DataFrame的内容将被append到现有数据中。
SaveMode.Overwrite	“overwrite”	overwrite模式意味着在将DataFrame保存到数据源时，如果数据/表已经存在，则现有数据将被DataFrame的内容覆盖。
SaveMode.Ignore	“ignore”	ignore模式意味着在将DataFrame保存到数据源时，如果数据已经存在，则save操作不保存DataFrame的内容，也不更改现有数据。这类似于SQL中的CREATE TABLE IF NOT EXISTS。

Text

read

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

    import spark.implicits._
    
    val df: DataFrame = spark.read.format("text").load("D:\\testlog\\infos.txt")
    
 	//转换成RDD
    df.rdd.map(row=>{
     
      val rows = row.toString().split(",")
      (rows(1), rows(2))
    }).foreach(println(_))
    
    //dataFrame不能直接split
    //返回是dataSet
    val mapDS: Dataset[(String, String)] = df.map(row => {
     
      val rows = row.toString().split(",")
      (rows(1), rows(2))
    })
    mapDS.show()

    //DataSet转换成DataFrame
    val mapDF = mapDS.toDF()
    mapDF.show()

    //使用textFile方法读取文本文件直接返回是一个DataSet
    val textDS: Dataset[String] = spark.read.textFile("D:\\testlog\\infos.txt")
    textDS.map(row =>{
     
      val rows = row.split(",")
      (rows(1),rows(2))
    }).show()
    spark.stop()
 }

文本数据读进来的一行在一个字段里面，所以要使用map算子，在map中split

• 直接read.format()读进来的是DataFrame，map中不能直接split
• DataFrame通过.rdd的方式转换成RDD，map中也不能直接split
• 通过read.textFile()的方式读进来的是Dataset，map中可以split

write

 val textDS: Dataset[String] = spark.read.textFile("D:\\testlog\\infos.txt")
 val writeDS = textDS.map(row => {
     
      val rows = row.split(",")
      //拼接成一列
      (rows(1) + "," + rows(2))
 })
 writeDS.write.format("text").mode(SaveMode.Overwrite).save("D:\\testlog\\bb.txt")

文本数据写出去的时候

• 不支持int类型，如果存在int类型，会报错，解决办法是toString，转换成字符串
• 只能作为一列输出，如果是多列，会报错，解决办法是拼接起来，组成一列
  文本数据压缩输出，只要是Spark支持的压缩的格式，都可以指定

writeDS.write.format("text")
      // 添加压缩操作
      .option("compression","gzip")
      .mode(SaveMode.Overwrite).save("D:\\testlog\\bb.txt")

csv
read

 val df = spark.read.format("csv")
      .option("header","true")
      .option("sep",",")
      .option("interSchema","true")
      .load("D:\\testlog\\sales.csv")

csv读取数据注意使用几个参数

• 指定表头：option(“header”, “true”)
• 指定分隔符：option(“sep”, “;”)
• 类型自动推测：option(“interSchema”,“true”)

JDBC
read
依赖

<dependency>
    <groupId>com.typesafe</groupId>
    <artifactId>config</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

application.conf文件

db.default.driver="com.mysql.jdbc.Driver"
db.default.url="jdbc:mysql://ruozedata001:6619/xxx?characterEncoding=utf-8"
db.default.user="xxx"
db.default.password="xxx"
db.default.source="xxx"
db.default.db="xxx"

db.default.poolInitialSize=10
db.default.poolMaxSize=20
db.default.connectionTimeoutMillis=1000

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

    //获取配置文件中的值，db.default开头
    val conf = ConfigFactory.load()
    val driver = conf.getString("db.default.driver")
    val url = conf.getString("db.default.url")
    val user = conf.getString("db.default.user")
    val password = conf.getString("db.default.password")
    val source = conf.getString("db.default.source")
    val db = conf.getString("db.default.db")

    val df = spark.read.format("jdbc")
      .option("url",url)
      .option("dbtable",s"$db.$source")
      .option("user",user)
      .option("password",password)
      .option("driver",driver)
      .load()

    df.createOrReplaceTempView("t_emp")

    spark.sql("select * from t_emp").show()

    spark.stop()
  }

df.createOrReplaceTempView()方法创建一个DataFrame数据生成的临时表，提供spark.sql()使用SQL操作数据，返回的也是一个DataFrame

write

 val writeDF = spark.sql("select * from t_emp")

 writeDF.write.format("jdbc")
      .option("url",url)
      .option("dbtable",s"$db.$source")
      .option("user",user)
      .option("password",password)
      .option("driver",driver).mode(SaveMode.Overwrite)
      .save()

SparkSQL

需求：每个平台每个省市的流量前2

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

    import spark.implicits._
    val df = spark.read.textFile("D:\\ssc\\access.log")
    val accessDF = df.map(x => {
     
      val splits = x.split("\t")
      val platform = splits(1)
      val traffic = splits(6).toLong
      val province = splits(8)
      val city = splits(9)
      val isp = splits(10)
      (platform, traffic, province, city, isp)
    }).toDF("platform", "traffic", "province", "city", "isp")
    accessDF.createOrReplaceTempView("t_access")

    val topNSQL =
      """
        |select * from (
        |select t.*,row_number() over (partition by t.platform order by t.cnt desc) as r from (
        |select platform,province,city,sum(traffic) as cnt from t_access group by platform,province,city
        |)t
        |)a where a.r <= 1
      """.stripMargin
    spark.sql(topNSQL).show()
    spark.stop()
  }

如果只是简单聚和统计可以使用API
分组，求和，别名，降序

import org.apache.spark.sql.functions._
accessDF.groupBy("platform", "province", "city")
.agg(sum("traffic").as("traffics"))
.sort('traffics.desc).show()

UDF函数

1、数据

大狗	小破车,渣团,热刺,我纯
木桶	利物浦
二条	南大王,西班牙人

2、需求：求出每个人的爱好个数
3、实现

def main(args: Array[String]): Unit = {
     
    val spark = SparkSession.builder
      .master("local")
      .appName(this.getClass.getSimpleName)
      .getOrCreate()
    import spark.implicits._
    val df = spark.sparkContext.textFile("D:\\ssc\\likes.txt")
        .map(_.split("\t"))
        .map(x=>Likes(x(0),x(1))).toDF()
    df.createOrReplaceTempView("t_team")
    val teamsLengthUTF = spark.udf.register("teams_length",(input:String)=>{
     
      input.split(",").length
    })
    println("--------------SQL方式----------------")
    spark.sql("select name,teams,teams_length(teams) as teams_length from t_team").show(false)
    println("--------------API方式----------------")
    df.select($"name",$"teams",teamsLengthUTF($"teams").as("teams_length")).show(false)
    spark.stop()
  }
  case class Likes(name:String,teams:String)
}

存储格式转换

Spark的时候只需要在df.write.format(“orc”).mode().save()中指定格式即可，如orc

df.write.format("orc").mode("overwrite").save("out")