Spark(四) -- SparkSQL-优快云博客

本文链接：https://blog.youkuaiyun.com/JeremyIverson/article/details/104621089

Spark SQL and DataFrame

1. Spark SQL

1.1 Spark SQL概述

1.1.1 什么是Spark SQL

在这里插入图片描述

Spark SQL是Spark用来处理结构化数据的一个模块，它提供了一个编程抽象叫做DataFrame并且作为分布式SQL查询引擎的作用。

1.1.2 为什么要学习Spark SQL

我们已经学习了Hive，它是将Hive SQL转换成MapReduce然后提交到集群上执行，大大简化了编写MapReduce的程序的复杂性，由于MapReduce这种计算模型执行效率比较慢。所有Spark SQL的应运而生，它是将Spark SQL转换成RDD，然后提交到集群执行，执行效率非常快！

易整合
统一的数据访问方式
兼容Hive
标准的数据连接

1.2 DataFrames

1.2.1 什么是DataFrames

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

1.2.2 创建DataFrames

在Spark SQL中SQLContext是创建DataFrames和执行SQL的入口，在spark-1.5.2中已经内置了一个sqlContext
在这里插入图片描述

在本地创建一个文件，有三列，分别是id、name、age，用逗号分隔，然后上传到hdfs上

hdfs dfs -put person.txt /

在spark shell执行下面命令，读取数据，将每一行的数据使用列分隔符分割

val lineRDD = sc.textFile("hdfs://hadoop01:9000/person.txt").map(_.split(","))

定义case class（相当于表的schema）

case class Person(id: Long,name: String,age: Int)

将RDD和case class关联

val personRDD = lineRDD .map( x => Person(x(0).toLong,x(1),x(2).toInt ))

将RDD转换成DataFrame

val df = personRDD.toDF

对DataFrame进行处理


scala> df.show()
+---+-------+---+
| id|   name|age|
+---+-------+---+
|  1|laozhao| 18|
|  2|laoduan| 30|
|  3| laomao| 28|
+---+-------+---+

// select 为Transformation 不会立即执行，show之后才会执行
scala> df.select("id","name").show
+---+-------+
| id|   name|
+---+-------+
|  1|laozhao|
|  2|laoduan|
|  3| laomao|
+---+-------+


scala> df.filter(col("age") >= 28 ).show
+---+-------+---+
| id|   name|age|
+---+-------+---+
|  2|laoduan| 30|
|  3| laomao| 28|
+---+-------+---+

1.3. DataFrame常用操作

1.3.1. DSL风格语法

查看DataFrame中的内容

df.show

查看DataFrame部分列中的内容

df.select(personDF.col("name")).show
df.select(col("name"), col("age")).show
df.select("name").show

打印DataFrame的Schema信息

df.printSchema

查询所有的name和age，并将age+1

scala> df.select(col("id"), col("name"), col("age") + 1).show
+---+-------+---------+
| id|   name|(age + 1)|
+---+-------+---------+
|  1|laozhao|       19|
|  2|laoduan|       31|
|  3| laomao|       29|
+---+-------+---------+


scala> df.select(df("id"), df("name"), df("age") + 1).show
+---+-------+---------+
| id|   name|(age + 1)|
+---+-------+---------+
|  1|laozhao|       19|
|  2|laoduan|       31|
|  3| laomao|       29|
+---+-------+---------+

按年龄进行分组并统计相同年龄的人数

scala> df.groupBy("age").count().show()
+---+-----+                                                                     
|age|count|
+---+-----+
| 18|    1|
| 28|    1|
| 30|    1|
+---+-----+

1.3.2. SQL风格语法

如果想使用SQL风格的语法，需要将DataFrame注册成表
df.registerTempTable(“t_person”)

查询年龄最大的前两名

scala> sqlContext.sql("select * from t_person order by age desc limit 2").show
+---+-------+---+                                                               
| id|   name|age|
+---+-------+---+
|  2|laoduan| 30|
|  3| laomao| 28|
+---+-------+---+

显示表的Schema信息


scala> sqlContext.sql("desc t_person").show
+--------+---------+-------+
|col_name|data_type|comment|
+--------+---------+-------+
|      id|   bigint|       |
|    name|   string|       |
|     age|      int|       |
+--------+---------+-------+

2. 以编程方式执行Spark SQL查询

2.1 编写Spark SQL查询程序

前面我们讲解了如何在Spark Shell中使用SQL完成查询，现在我们来实现在自定义的程序中编写Spark SQL查询程序。首先在maven项目的pom.xml中添加Spark SQL的依赖


    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <encoding>UTF-8</encoding>
        <scala.version>2.10.6</scala.version>
        <spark.version>1.6.1</spark.version>
        <hadoop.version>2.6.4</hadoop.version>
    </properties>
 
    <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.10</artifactId>
            <version>${spark.version}</version>
        </dependency>

2.1.1 通过反射推断Schema

创建一个object为 com.mylove.spark.day04.SQLDemo

package com.mylove.spark.day04

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

object SQLDemo {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("SQLDemo")
    val sc = new SparkContext(conf)
    val sqlContext = new SQLContext(sc)
    System.setProperty("user.name","hadoop")
      //从指定的地址创建RDD
    val personRdd = sc.textFile(args(0)).map( line =>{
      val fields = line.split(",")
      Person(fields(0).toLong,fields(1),fields(2).toInt)
    })
    //导入隐式转换，如果不到人无法将RDD转换成DataFrame
    //将RDD转换成DataFrame
    import sqlContext.implicits._
    val personDF = personRdd.toDF()
    personDF.registerTempTable("person")
    val df = sqlContext.sql("select * from person where age >= 20 order by age desc limit 2 ")
    df.write.json(args(1))
    sc.stop()
  }
}

case class Person(id:Long,name:String,age:Int)

将程序打成jar包，上传到spark集群，提交Spark任务：
/home/hadoop/apps/spark-1.6.1/bin/spark-submit --class com.mylove.spark.day04.SQLDemo --master spark://hadoop01:7077 /home/hadoop/hello-spark-1.0-SNAPSHOT.jar hdfs://hadoop01:9000/person.txt hdfs://hadoop01:9000/out22

查看运行结果
hadoop fs -cat /out22/part-r-*
在这里插入图片描述

2.1.2. 通过StructType直接指定Schema

package com.mylove.spark.day04
import org.apache.spark.sql.{Row, SQLContext}
import org.apache.spark.sql.types._
import org.apache.spark.{SparkContext, SparkConf}


object SpecifyingSchema {
  def main(args: Array[String]) {
    //创建SparkConf()并设置App名称
    val conf = new SparkConf().setAppName("SQLDemo")
    //SQLContext要依赖SparkContext
    val sc = new SparkContext(conf)
    //创建SQLContext
    val sqlContext = new SQLContext(sc)
    //从指定的地址创建RDD
    val personRDD = sc.textFile(args(0)).map(_.split(","))
    //通过StructType直接指定每个字段的schema
    val schema = StructType(
      List(
        StructField("id", IntegerType, true),
        StructField("name", StringType, true),
        StructField("age", IntegerType, true)
      )
    )
    //将RDD映射到rowRDD
    val rowRDD = personRDD.map(p => Row(p(0).toInt, p(1).trim, p(2).toInt))
    //将schema信息应用到rowRDD上
    val personDataFrame = sqlContext.createDataFrame(rowRDD, schema)
    //注册表
    personDataFrame.registerTempTable("t_person")
    //执行SQL
    val df = sqlContext.sql("select * from t_person order by age desc limit 2")
    //将结果以JSON的方式存储到指定位置
    df.write.json(args(1))
    //停止Spark Context
    sc.stop()
  }
}

同样打成jar包运行。