spark--Spark SQL自定义函数-★★★★★

• 之前hive中也学习过自定义函数

1.UDF(User-Defined-Function)–SparkSQL支持自定义–最常用

• DSL风格 val small2big1: UserDefinedFunction = functions.udf((word:String)=>{word.toUpperCase})//定义方法
• SQL风格 spark.udf.register(“small2big2”,(word:String)=>{word.toUpperCase})//注册UDF
• 即最基本的自定义函数，类似to_char,to_date
• 输入一行，输出一行

2 .UDAF(User-Defined Aggregation Funcation)–SparkSQL支持自定义

• 用户自定义聚合函数，类似在group by之后使用的sum,avg
• 输入多行，输出一行

3.UDTF(User-Defined Table-Generating Functions)–SparkSQL不支持自定义UDTF

• 用户自定义生成函数，有点像flatMap
• 输入一行，输出多行

package cn.hanjiaxiaozhi.sql
​
import org.apache.spark.SparkContext
import org.apache.spark.sql.expressions.UserDefinedFunction
import org.apache.spark.sql.{
    
    DataFrame, Dataset, SparkSession, functions}
​
/**
 * Author hanjiaxiaozhi
 * Date 2020/7/25 10:21
 * Desc 演示使用SparkSQL完成自定义UDF函数
 * 需求: 将表中的单词转为大写
 */
object UDFDemo {
    
    
  def main(args: Array[String]): Unit = {
    
    
    //0.准环境和数据
    val spark: SparkSession = SparkSession.builder().appName("sql").master("local[*]").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    import spark.implicits._
​
    //可以使用sc.textFile("路径")进行读取,然后返回RDD,再转为DataFrame/DataSet
    //也可以直接使用SparkSession的读取方法直接返回DataFrame/DataSet
    val df: DataFrame = spark.read.text("D:\\data\\spark\\udf.txt")
    df.show(false)
    /*
     * +----------+
     * |value     |
     * +----------+
     * |helloworld|
     * |abc       |
     * |study     |
     * |smallWORD |
     * +----------+
     */
​
    //定义UDF函数并使用UDF函数将数据转为大写
    //TODO 1 DSL风格
    //定义自定义UDF
    import org.apache.spark.sql.functions._
    val small2big1: UserDefinedFunction = udf((word:String)=>{
    
    word.toUpperCase})
    //注意:自定义函数中的参数为value列对应的单词,所以应该写$"value",而不是value
    df.select($"value",small2big1($"value")).show(false)
​
​
    //TODO 2 SQL风格
    df.createOrReplaceTempView("t_word")//注册表名
    //定义一个自定义的UDF函数,可以接收一个String并转为大写
    spark.udf.register("small2big2",(word:String)=>{
    
    word.toUpperCase})//注册UDF
    val sql:String =
      """
        |select value,small2big2(value) 
        |from t_word
        |""".stripMargin//编写sql并使用UDF
    spark.sql(sql).show(false)//执行sql
  }
}
​

4.自定义UDAF

• l 需求

有udaf.json格式数据内容如下

{
    
    "name":"Michael","salary":3000}

{
    
    "name":"Andy","salary":4500}

{
    
    "name":"Justin","salary":3500}

{
    
    "name":"Berta","salary":4000}
求取平均工资

• l 方法重写说明

inputSchema：输入数据的类型

bufferSchema：产生中间结果的数据类型

dataType：最终返回的结果类型

deterministic：确保一致性(输入什么类型的数据就返回什么类型的数据)，一般用true

initialize：指定初始值

update：每有一条数据参与运算就更新一下中间结果(update相当于在每一个分区中的运算)

merge：全局聚合(将每个分区的结果进行聚合)

evaluate：计算最终的结果

• l 代码演示

package cn.hanjiaxiaozhi.sql

import org.apache.spark.SparkContext
import org.apache.spark.sql.expressions.{
    
    MutableAggregationBuffer, UserDefinedAggregateFunction}
import org.apache.spark.sql.types._
import org.apache.spark.sql.{
    
    DataFrame, Row, SparkSession}


object UDAFDemo {
    
    
  def main(args: Array[String]): Unit = {
    
    
    //1.获取sparkSession
    val spark: SparkSession = SparkSession.builder().appName("SparkSQL").master("local[*]").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.json
    val employeeDF: DataFrame = spark.read.json("D:\\data\\sql\\udaf.json")
    //3.创建临时表
    employeeDF.createOrReplaceTempView("t_employee")
    //4.注册UDAF函数
    spark.udf.register("avgsalary",new SparkFunctionUDAF)
    //5.使用自定义UDAF函数
    spark.sql("select avgsalary(salary) from t_employee").show()
    //6.使用内置的avg函数
    spark.sql("select avg(salary) from t_employee").show()

  }
}
class SparkFunctionUDAF extends UserDefinedAggregateFunction{
    
    
  //输入的数据类型的schema
  override def inputSchema: StructType = {
    
    
     StructType(StructField("input",LongType)::Nil)
  }
  //缓冲区数据类型schema，就是转换之后的数据的schema
  override def bufferSchema: StructType = {
    
    
    StructType(StructField("sum",LongType)::StructField("total",LongType)::Nil)
  }
  //返回值的数据类型
  override def dataType: DataType = {
    
    
    DoubleType
  }
  //确定是否相同的输入会有相同的输出
  override def deterministic: Boolean = {
    
    
    true
  }
  //初始化内部数据结构
  override def initialize(buffer: MutableAggregationBuffer): Unit = {
    
    
    buffer(0) = 0L
    buffer(1) = 0L
  }
  //更新数据内部结构
  override def update(buffer: MutableAggregationBuffer, input: Row): Unit = {
    
    
    //所有的金额相加
    buffer(0) = buffer.getLong(0) + input.getLong(0)
    //一共有多少条数据
    buffer(1) = buffer.getLong(1) + 1
  }
  //来自不同分区的数据进行合并
  override def merge(buffer1: MutableAggregationBuffer, buffer2: Row): Unit = {
    
    
    buffer1(0) =buffer1.getLong(0) + buffer2.getLong(0)
    buffer1(1) = buffer1.getLong(1) + buffer2.getLong(1)
  }
  //计算输出数据值
  override def evaluate(buffer: Row): Any = {
    
    
    buffer.getLong(0).toDouble / buffer.getLong(1)
  }
}