（三）SparkSQL 学习笔记

DataFrame 基本操作

从定义上看，一个DataFrame包括一系列的 records，这些行的类型是 Row 类型，包括一系列的 columns。 Schema 定义了每一列的列名和数据类型。DataFrame 的分区定义了 DataFrame 或 Dataset 在整个集群中的物理分布情况。

//创建DataFrame
val df = spark.read.format("json") .load("/data/flight-data/json/2015-summary.json")

//查看schema
df.printSchema()

// 查看schema
spark.read.format("json").load("/data/flight-data/json/2015-summary.json").schema

//输出：
org.apache.spark.sql.types.StructType = ...
               StructType( StructField(DEST_COUNTRY_NAME,StringType,true),
                           StructField(ORIGIN_COUNTRY_NAME,StringType,true),
                           StructField(count,LongType,true)
                           )
//解释
一个schema就是一个StructType，由多个StructField类型的fields组成，每个field包括一个列名称、一个列类型、一个布尔型的标识（是否可以有缺失值和null值）
//如何在DataFrame上创建和执行特定的schema

Columns 操作

spark 中的列类型类似于带着你表格中的列，可以从 DataFrame 中选择列、操作列和删除列。对 Spark 来说，列是逻辑结构，它仅仅表示通过一个表达式按每条记录计算出一个值。这意味着，要得到一个 column 列的真实值，需要有一行 row 数据，为了得到一行数据，就需要一个DataFrame。不能在 DataFrame 的上下文之外操作单个列。必须在 DataFrame 内使用 Spark 转换来的操作列。

有许多不同的方法来构造和引用列，但是最简单的方式就是使用 col() 和 column() 函数。要使用这些函数，需要传入一个列名。

// in Scala
import org.apache.spark.sql.functions.{col, column}

 col("someColumnName")
 column("someColumnName")

如前所述，这个列可能存在于我们的DataFrames中，也可能不存在。在将列名和我们在catalog 中维护的列进行比较之前，列不会被解析，即列是 unresolved。

注意
我们刚才提到的两种不同的方法引用列。Scala有一些独特的语言特性， 允许使用更多的简写方式来引用列。以下的语法糖执行完全相同的事情， 即创建一个列， 但不提供性能改进: $“myColumn” ， 'myColumn 。 “$” 允许我们将一个字符串指定为一个特殊的字符串，该字符串应该引用一个表达式。 标记 ( ’ ) 是一种特殊的东西，称为符号; 这是一个特定于scala语言的，指向某个标识符。它们都执行相同的操作，是按名称引用列的简写方式。当您阅读不同的人的Spark代码时，可能会看到前面提到的所有引用。

表达式 expression
表达式是在 DataFrame 中数据记录的一个或多个值上的一组转换。列是表达式，把它想象成一个函数，它将一个或多个列名作为输入，表达式会解析它们，为数据集中的每个记录返回一个单一值。

在最简单的情况下，expr(“someCol”) 等价于 col(“someCol”)。

列操作是表达式功能的一个子集。expr(“someCol - 5”) 与执 行col(“someCol”) - 5，或甚至 expr(“someCol”)- 5 的转换相同。这是因为 Spark 将它们编译为一个逻辑树，逻辑树指定了操作的顺序。

// Scala方式
df.select("DEST_COUNTRY_NAME").show(2)

-- SQL方式
SELECT   DEST_COUNTRY_NAME    FROM    dfTable    LIMIT 2

可以使用相同的查询样式选择多个列，只需在 select 方法调用中添加更多的列名字符串参数：

// in Scala
df.select("DEST_COUNTRY_NAME", "ORIGIN_COUNTRY_NAME").show(2)

-- in SQL
SELECT DEST_COUNTRY_NAME, ORIGIN_COUNTRY_NAME FROM dfTable LIMIT 2

可以用许多不同的方式引用列，可以交替使用它们

-- in Scala
import org.apache.spark.sql.functions.{expr, col, column}
df.select(
        df.col("DEST_COUNTRY_NAME"),
    		col("DEST_COUNTRY_NAME"),
            column("DEST_COUNTRY_NAME"),
            'DEST_COUNTRY_NAME,
            $"DEST_COUNTRY_NAME",
             expr("DEST_COUNTRY_NAME"))
  .show(2

但是有一个常见的错误，就是混合使用列对象和列字符串，例如：

df.select(col("DEST_COUNTRY_NAME"), "EST_COUNTRY_NAME")

expr 是我们可以使用的最灵活的引用，它可以引用一个简单的列或一个列字符串操作。例如：

// 更改列名，然后通过使用AS关键字来更改它
-- in Scala
df.select(expr("DEST_COUNTRY_NAME AS destination")).show(2)

-- in SQL
SELECT DEST_COUNTRY_NAME as destination FROM dfTable LIMIT 2

// 操作将列名更改为原来的名称
df.select(expr("DEST_COUNTRY_NAME  as  destination").alias("DEST_COUNTRY_NAME")) .show(2)

字面常量转换为 Spark 类型

有时候，需要将显式字面常量值传递给 Spark， 它只是一个值，而不是一个列。这可能是一个 常数值或以后需要比较的值。可以通过 literals，将给定变成语言的字面值转换为 Spark 能够理解的值。

-- in Scala
import org.apache.spark.sql.functions.lit

df.select(expr("*"), lit(1).as("One")).show(2)

-- in SQL
SELECT *, 1 as One FROM dfTable LIMIT 2

添加列

将新列添加到 DataFrame 中，这是通过在 DataFrame 上使用 withColum 方法来实现的。例如，添加一个列，将数字 “1” 添加为一个列，列名为 numberOne：

-- in Scala
df.withColumn("numberOne", lit(1)).show(2)

-- in SQL
SELECT *, 1 as numberOne FROM dfTable LIMIT 2

例如，设置一个布尔标志，表示源国与目标国相同：

-- in Scala
df.withColumn("withinCountry", expr("ORIGIN_COUNTRY_NAME == DEST_COUNTRY_NAME"))

注意：witchColumn 函数有两个参数：别名和为 DataFrame 中的给定行的创建值的表达式。

同时也可以重命名列

df.withColumn("Destination", expr("DEST_COUNTRY_NAME")).columns

重命名列

可以使用 withColumnRenamed 方法来重命名，这会将第一个参数中的字符串的名称重命名为第二个参数中的字符串

-- in Scala
df.withColumnRenamed("DEST_COUNTRY_NAME", "dest").columns

删除列

df.drop("ORIGIN_COUNTRY_NAME").columns
df.drop("ORIGIN_COUNTRY_NAME", "DEST_COUNTRY_NAME")

更改列类型

如需要列从一种类型转换到另一种类型。例如，从一组 StringType 应该是整数，可以将列从一种类型转换为另一种类型。

将count列从整数类型转换成 Long 类型：

-- in scala
df.withColumn("count2", col("count").cast("long"))

-- in SQL
SELECT *, cast(count as long) AS count2 FROM dfTable

过滤行

为了过滤行，创建一个计算值为 true 或 false 的表达式。然后用一个等于 false 的表达式过滤掉这些行。使用 DataFrames 执行此操作的最常见方法是将表达式创建为字符串，或者使用一组列操作构建表达式。执行此操作有两种方法： 可以使用 where 或 filter，它们都将执行相同的操作，并在使用 DataFrames 时接受相同的参数类型

-- in scala
df.filter(col("count") < 2).show(2)
df.where("count < 2").show(2)

-- in SQL
SELECT * FROM dfTable WHERE count < 2 LIMIT 2

如希望将多个过滤器放入相同的表达式中，只需要将它们按顺序链接起来，让 Spark 处理

-- in Scala
df.where(col("count") < 2).where(col("ORIGIN_COUNTRY_NAME") =!= "Croatia")
  .show(2)

-- in SQL
SELECT * FROM dfTable WHERE count < 2 AND ORIGIN_COUNTRY_NAME != "Croatia"
LIMIT 2

行去重

一个常见的用例是在一个 DataFrame 中提取唯一的或不同的值。这些值可以在一个或多个列中。这样做的方式为：在 DataFrame 上使用不同的方法，它允许我们对该 DataFrame 中的任何行进行删除重复行操作。

-- in Scala
df.select("ORIGIN_COUNTRY_NAME", "DEST_COUNTRY_NAME").distinct().count()

-- in SQL
SELECT COUNT(DISTINCT(ORIGIN_COUNTRY_NAME, DEST_COUNTRY_NAME)) FROM dfTable

Union

DataFrame 是不可变的，这意味着用户不能向 DataFrame 追加，因为这会改变 DataFrame。要附加到 DataFrame 上，必须将原始的 DataFrame 与新的 DataFr5ame 结合起来。这只是连接两个 DataFrame， 对于 union 两个 DataFrame，必须确保它们具有相同的模式和列数，否则，union 将会报错。

-- in Scala
import org.apache.spark.sql.Row
val schema = df.schema
val newRows = Seq(
  Row("New Country", "Other Country", 5L),
  Row("New Country 2", "Other Country 3", 1L)
)

val parallelizedRows = spark.sparkContext.parallelize(newRows)
val newDF = spark.createDataFrame(parallelizedRows, schema)

df.union(newDF)
  .where("count = 1")
  .where($"ORIGIN_COUNTRY_NAME" =!= "United States")
  .show()

行排序

在对 DataFrame 中的值进行排序时，如需对DataFrame 顶部最大或最小值进行排序。有两个相同的操作可以执行这种操作：sort、orderBy。它们默认是按升序排序，可以接受多个表达式，字符串和列。

-- in Scala
df.sort("count").show(5)

df.orderBy("count", "DEST_COUNTRY_NAME").show(5)
df.orderBy(col("count"), col("DEST_COUNTRY_NAME")).show(5)

//要更明确地指定排序方向，需要在操作列时使用asc和desc函数
import org.apache.spark.sql.functions.{desc, asc}

df.orderBy(expr("count desc")).show(2)
df.orderBy(desc("count"), asc("DEST_COUNTRY_NAME")).show(2)

出于优化目的，有时建议在另一组转换之前对每个分区进行排序。可以使用 sortWithinPartitions 方法来执行

spark.read.format("json").load("/data/flight-data/json/*-summary.json").sortWithinPartitions("count")

limit

通常要限制从 DataFrame 中提取的内容，如要取 DataFrame 中的前几位

-- in Scala
df.limit(5).show()

-- in SQL
SELECT * FROM dfTable LIMIT 6

-- in Scala
df.orderBy(expr("count desc")).limit(6).show()

-- in SQL
SELECT * FROM dfTable ORDER BY count desc LIMIT 6

rePartition & coalesce

一个重要的优化方式是根据一些经常过滤的列对数据进行分区，它控制跨集群的数据的物理分布，包括分区计划和分区数量。

rePartition 将导致数据的完全 shuffle， 无论是否需要重新 shuffle。这意味着只有当将来的分区数目大于当前的分区数目时，或者当希望通过一组列进行分区时，才应该使用 rePartition。

-- in Scala
df.rdd.getNumPartitions // 1

-- in Scala
df.repartition(5)

//如果经常对某个列进行过滤，那么基于该列进行重新分区是值得的
df.repartition(col("DEST_COUNTRY_NAME"))
df.repartition(5, col("DEST_COUNTRY_NAME"))

而 coalesce 不会导致完全 shuffle，并尝试合并分区。

-- in Scala
df.repartition(5, col("DEST_COUNTRY_NAME")).coalesce(2)

收集数据到 Driver

• collect 从整个 DataFrame 中获取所有数据；
• take 选取 DataFrame 的前几行；
• show 打印出几行数据

--  in Scala
val collectDF = df.limit(10)
collectDF.take(5) 
collectDF.show() 
collectDF.show(5, false)
collectDF.collect()

UDF 的使用

spark.udf.register("zipToLong", (z:String) => z.toLong)
spark.udf.register("largerThan", (z:String,number:Long) => z.toLong>number)

zipDS.select(col("city"),zipToLongUDF(col("zip")).as("zipToLong"),largerThanUDF(col("zip"),lit("99923")).as("largerThan")).orderBy(desc("zipToLong")).show();