spark sql oom 场景 spark sql使用

文章目录

• 零、学习目标
• 一、基本操作
• 二、默认数据源

• （1）默认数据源Parquet
• （2）案例演示读取Parquet文件
• （3）.启动shell

• 练习
• student.txt文件转换成student.parquet
• （1）读取文件
• （2）新建一个类并导入spark.implicits._
• （3）处理一下student.txt文件
• （4）转为DF并保存到hdfs

• 2.使用Idea

• (1)ldea准备环境准备
• (2)文件准备
• (3)ldea写

• 三、手动指定数据源

• format（）和option（）方法概述

• 1. 案例演示读取不同数据源

• （1）读取csv文件
• (2)、读取JSON，保存为parquet
• （3）读取JDBC保存为Json（云上）

• 四、数据写入模式

• （1)、mode()方法
• （2)、枚举类SaveMode
• （3）不同的写入模式

零、学习目标

学会使用默认数据源
学会手动指定数据源
理解数据写入模式
掌握分区自动推断

一、基本操作

Spark SQL提供了两个常用的加载数据和写入数据的方法：load()方法和save()方法。load()方法可以加载外部数据源为一个DataFrame，save()方法可以将一个DataFrame写入指定的数据源。

二、默认数据源

（1）默认数据源Parquet

默认情况下，load()方法和save()方法只支持Parquet格式的文件，Parquet文件是以二进制方式存储数据的，因此不可以直接读取，文件中包括该文件的实际数据和Schema信息，也可以在配置文件中通过参数spark.sql.sources.default对默认文件格式进行更改。Spark SQL可以很容易地读取Parquet文件并将其数据转为DataFrame数据集。

（2）案例演示读取Parquet文件

执行命令： cd $SPARK_HOME/examples/src/main/resources，查看Spark的样例数据文件users.parquet

–用cat命令显示users.parquet文件内容，只会显示乱码

将数据文件users.parquet上传到HDFS的/datasource/input目录

（3）.启动shell

spark-shell --master spark://master:7077

–读取hdfs上的文件

val userdf = spark.read.load("hdfs://master:9000/datasource/input/users.parquet")

–查看

val userdf = spark.read.load("hdfs://master:9000/datasource/input/users.parquet")
userdf.show     //查看
userdf.printSchema //查看结构

–执行命令：userdf.select("name", "favorite_color").write.save("hdfs://master:9000/datasource/output")，对数据帧指定列进行查询，查询结果依然是数据帧，然后通过write成员的save()方法写入HDFS指定目录

userdf.select("name", "favorite_color").write.save("hdfs://master:9000/datasource/output")

除了使用select()方法查询外，也可以使用SparkSession对象的sql()方法执行SQL语句进行查询，该方法的返回结果仍然是一个DataFrame。

–基于数据帧创建临时视图，执行命令：
userdf.createTempView("t_user")

userdf.createTempView("t_user")

再使用

spark.sql("select name, favorite_color from t_user").write.save("hdfs://master:9000/datasource/output2")

练习

student.txt文件转换成student.parquet

–解决思路：将student.txt转成studentDF，利用数据帧的save()方法保存到/datasource/output3目录，然后将文件更名复制到/datasource/input目录

–得到学生数据帧 - studentDF

1,郑秀芸,女,20
2,王志峰,男,18
3,陈燕文,女,21
4,郑国栋,男,19
6,肖雨涵,男,20

（1）读取文件

val ds = spark.read.textFile("hdfs://master:9000//student2/input/student.txt")

（2）新建一个类并导入spark.implicits._

case class Student(id: Int,name: String,gender: String,age: Int)

spark.implicits._

（3）处理一下student.txt文件

val stuDS = ds.map(line =>{
          val fd = line.split(",")
          val id = fd(0).toInt
          val name = fd(1).toString
			val gender = fd(2).toString
			val age = fd(3).toInt
         Student(id,name,gender,age)
         }
         )

（4）转为DF并保存到hdfs

val stuDF = stuDS.toDF

stuDF.write.save("hdfs://master:9000/datasource/output3")

2.使用Idea

(1)ldea准备环境准备

• pom.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>net.dw.rdd</groupId>
    <artifactId>SparkRDDDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>2.12.15</version>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.12</artifactId>
            <version>3.1.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.12</artifactId>
            <version>3.1.3</version>
        </dependency>

    </dependencies>

    <build>
        <sourceDirectory>src/main/scala</sourceDirectory>
    </build>
</project>

• hdfs-site.xml文件和log4j.properties文件

在resources目录下创建 hdfs-site.xml和log4j.properties文件

• hdfs-site.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <property>
        <description>only config in clients</description>
        <name>dfs.client.use.datanode.hostname</name>
        <value>true</value>
    </property>
</configuration>

• log4j.properties

log4j.rootLogger=ERROR,console, stdout, logfile
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spark.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

(2)文件准备

把刚刚保存文件改名为student.parquet

hdfs dfs -cp  /datasource/output3/part-00000-8ad4f77c-b1b6-45f6-8c65-8a1fd5f9b981-c000.snappy.parquet  /datasource/input/student.parquet

(3)ldea写

package net.dw.sql

import org.apache.spark.sql.SparkSession

object ReadParquetFile {
  def main(args: Array[String]): Unit = {
    //创建或得到Spark会话对象
    val spark = SparkSession.builder()
      .appName("ReadParquetFile")
      .master("local[*]")
      .getOrCreate()
    // 加载student.parquet文件，得到数据帧
    val studentDF = spark.read.load("hdfs://master:9000/datasource/input/student.parquet")
    //显示学生数据帧内容
    studentDF.show()
    //查询20岁以上的女生
    val  girlDF =studentDF.filter("gender='女' and age > 20")
    //显示女生数据帧内容
    girlDF.show()
    //保存到hdfs保证目录不存在
   // girlDF.write.save("hdfs://master:9000/datasource/output")








  }

}

• 结果

三、手动指定数据源

format（）和option（）方法概述

1.使用format()方法可以手动指定数据源。数据源需要使用完全 限定名（例如org.apache.spark.sql.parquet），但对于Spark SQL的内置数据源，也可以使用它们的缩写名（JSON、Parquet、JDBC、ORC、Libsvm、CSV、Text）。
2.通过手动指定数据源，可以将DataFrame数据集保存为不同的文件格式或者在不同的文件格式之间转换。
3.在指定数据源的同时，可以使用option()方法向指定的数据源传递所需参数。例如，向JDBC数据源传递账号、密码等参数。

1. 案例演示读取不同数据源

（1）读取csv文件

–执行

cd $SPARK_HOME/examples/src/main/resources

查看Spark的样例数据文件people.csv

–将people.csv文件上传到HDFS的/datasource/input目录，然后查看文件内

–在shell里执行

val peopleDF = spark.read.format("csv").load("hdfs://master:9000/datasource/input/people.csv")

读取人员csv文件，得到人员数据帧

–执行

people.show

查看人员数据帧内容

–大家可以看到，people.csv文件第一行是字段名列表，但是转成数据帧之后，却成了第一条记录，这样显然是不合理的，怎么办呢？就需要用到option()方法来传递参数，告诉Spark第一行是表头header，而不是表记录。

–执行

val peopleDF = spark.read.format("csv").option("header", "true").load("hdfs://master:9000/datasource/input/people.csv")

peopleDF.show

由于csv文件默认分隔符是逗号，而people.csv的分隔符是分号，因此要利用option(“delimiter”, “;”)告诉Spark

–执行命令：

val peopleDF = spark.read.format("csv").option("header", "true").option("delimiter", ";").load("hdfs://master:9000/datasource/input/people.csv")

peopleDF.show

(2)、读取JSON，保存为parquet

–查看people.JSON

–上传到HDFS /datasource/input 目录，并查看其内容

hdfs dfs -put people.json /datasource/input
 	hdfs dfs -cat /datasource/input/people.json

–在Spark Shell里，执行命令

val peopleDF = spark.read.format("json").load("hdfs://master:9000/datasource/input/people.json")
peopleDF.show

–执行

peopleDF.select("name", "age").write.format("parquet").save("hdfs://master:9000/datasource/output4")

将peopleDF以parquet格式，保存到output4

–查看生成的文件

–将该parquet文件更名拷贝到/datasource/input目录，执行命令

hdfs dfs -cp /datasource/output4/part-00000-a1e62c69-59e5-40b6-8391-89bdfffe61ff-c000.snappy.parquet /datasource/input/people.parquet

• 现在读取/datasource/input/people.parquet文件得到人员数据帧

val peopleDF=spark.read.load("hdfs://master:9000/datasource/input/people.parquet")
peopleDF.show

（3）读取JDBC保存为Json（云上）

• 执行

val userDF = spark.read.format("jdbc")
  .option("url", "jdbc:mysql://master:3306/student?useSSL=false")
  .option("driver", "com.mysql.jdbc.Driver")
  .option("dbtable", "t_user")  
  .option("user", "root")  
  .option("password", "p@ssw0rd")
  .load()

• 发现没有jdbc驱动

• 执行 cd /SPARK_HOME

在里面上传驱动

• 将数据驱动程序分发到slave1和slave2虚拟机
• 执行命令：scp mysql-connector-java-5.1.48.jar - root@slave1:$SPARK_HOME/jars
• 执行命令：scp mysql-connector-java-5.1.48.jar root@slave2:$SPARK_HOME/jars

• 执行：paste进入粘贴模式



• 执行

userDF.show

• 执行命令，将userDF的结果以json保存到hdfs

userDF.write.format("json").save("hdfs://master:9000/datasource/output5")

• 执行命令，查看刚刚保存在hdfs上的文件

hdfs dfs -cat /datasource/output5/*

四、数据写入模式

（1)、mode()方法

• 在写入数据时，可以使用mode()方法指定如何处理已经存在的数据，该方法的参数是一个枚举类SaveMode。
• 使用SaveMode类，需要import org.apache.spark.sql.SaveMode;

（2)、枚举类SaveMode

• SaveMode.ErrorIfExists：默认值。当向数据源写入一个DataFrame时，如果数据已经存在，就会抛出异常。
• SaveMode.Append：当向数据源写入一个DataFrame时，如果数据或表已经存在，会在原有的基础上进行追加。
• SaveMode.Overwrite：当向数据源写入一个DataFrame时，如果数据或表已经存在，就会将其覆盖（包括数据或表的Schema）。
• SaveMode.Ignore：当向数据源写入一个DataFrame时，如果数据或表已经存在，就不会写入内容，类似SQL中的CREATE TABLE IF NOT EXISTS。

（3）不同的写入模式

• 查看数据源：people.json

hdfs dfs -cat /datasource/input/people.json

• 在spark-shell里读取 一下 people.json

• 导入SaveMode包

import org.apache.spark.sql.SaveMode;

• 保存到/datasource/result 目录

peopleDf.select("name").write.mode(SaveMode.Overwrite).format("json").save("hdfs://master:9000/datasource/result")

• 查看 保存的数据

hdfs dfs -cat /datasource/result/*