Spark SQL functions.scala 源码解析（三）Window functions （基于 Spark 3.3.0）

最新推荐文章于 2023-02-09 17:33:28 发布
最新推荐文章于 2023-02-09 17:33:28 发布
阅读量3.9k 收藏 4
点赞数 3
分类专栏： 大数据技术体系 文章标签： spark sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shockang/article/details/121905429
版权

前言

本文隶属于专栏《1000个问题搞定大数据技术体系》，该专栏为笔者原创，引用请注明来源，不足和错误之处请在评论区帮忙指出，谢谢！

本专栏目录结构和参考文献请见1000个问题搞定大数据技术体系

目录

Spark SQL functions.scala 源码解析（一）Sort functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（二）Aggregate functions（基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（三）Window functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（四）Non-aggregate functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（五）Math Functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（六）Misc functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（七）String functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（八）DateTime functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（九）Collection functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（十）Partition transform functions（基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（十一）Scala UDF functions（基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（十二）Java UDF functions（基于 Spark 3.3.0）

Spark SQL 内置函数

Spark SQL 内置函数（六）Window Functions（基于 Spark 3.2.0）

正文

cume_dist

  /**
   * 窗口函数：返回窗口分区内值的累积分布，即低于当前行的行的分数
   *
   * {{{
   *   N = 分区内的总行数
   *   cumeDist(x) = 在当前行（包括当前行）的值的数目 x / N
   * }}}
   *
   * @group window_funcs
   * @since 1.6.0
   */
  def cume_dist(): Column = withExpr { new CumeDist }

用法

========== df.select(cume_dist().over(w)) ==========
+--------------------------------------------------------------------------------------------------------------------+
|cume_dist() OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+--------------------------------------------------------------------------------------------------------------------+
|                                                                                                                 1.0|
|                                                                                                                 1.0|
|                                                                                                                 1.0|
|                                                                                                                 1.0|
+--------------------------------------------------------------------------------------------------------------------+

dense_rank

  /**
   * 窗口函数：返回窗口分区内行的排名，没有任何间隙。
   * rank 和dense_rank 的区别在于denseRank 在有平局时不会在排序顺序上留下间隙。 
   * 也就是说，如果您使用dense_rank 对比赛进行排名，并且有三个人并列第二，您会说三个人都排在第二位，下一
   * 个人排在第三位。 
   * Rank 会给我连续的数字，使排在第三位的人（在并列之后）登记为第五位。
   * 这相当于 SQL 中的 DENSE_RANK 函数
   *
   * @group window_funcs
   * @since 1.6.0
   */
  def dense_rank(): Column = withExpr { new DenseRank }

用法


========== df.select(dense_rank().over(w)) ==========
+--------------------------------------------------------------------------------------------------------------------+
|DENSE_RANK() OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+--------------------------------------------------------------------------------------------------------------------+
|                                                                                                                   1|
|                                                                                                                   1|
|                                                                                                                   1|
|                                                                                                                   1|
+--------------------------------------------------------------------------------------------------------------------+

lag/lead


  /**
   * 窗口函数：返回当前行之前偏移行的值，如果当前行之前的偏移行少于偏移行，则返回 null 值。 
   * 例如，偏移量为 1 将返回窗口分区中任何给定点的前一行。
   * 这相当于 SQL 中的 LAG 函数。
   *
   * @group window_funcs
   * @since 1.4.0
   */
  def lag(e: Column, offset: Int): Column = lag(e, offset, null)

  /**
   * 窗口函数：返回当前行之前偏移行的值，如果当前行之前的偏移行少于偏移行，则返回 null 值。 
   * 例如，偏移量为 1 将返回窗口分区中任何给定点的前一行。
   * 这相当于 SQL 中的 LAG 函数。
   *
   * @group window_funcs
   * @since 1.4.0
   */
  def lag(columnName: String, offset: Int): Column = lag(columnName, offset, null)

  /**
   * 窗口函数：返回当前行之前偏移行的值，如果当前行之前有少于偏移行，则返回defaultValue 。 
   * 例如，偏移量为 1 将返回窗口分区中任何给定点的前一行。
   * 这相当于 SQL 中的 LAG 函数。
   *
   * @group window_funcs
   * @since 1.4.0
   */
  def lag(columnName: String, offset: Int, defaultValue: Any): Column = {
    lag(Column(columnName), offset, defaultValue)
  }

  /**
   * 窗口函数：返回当前行之前偏移行的值，如果当前行之前有少于偏移行，则返回defaultValue 。 
   * 例如，偏移量为 1 将返回窗口分区中任何给定点的前一行。
   * 这相当于 SQL 中的 LAG 函数。
   *
   * @group window_funcs
   * @since 1.4.0
   */
  def lag(e: Column, offset: Int, defaultValue: Any): Column = {
    lag(e, offset, defaultValue, false)
  }

  /**
   * 窗口函数：返回当前行之前偏移行的值，如果当前行之前有少于偏移行，则返回defaultValue 。 
   * ignoreNulls确定行的空值是包含在计算中还是从计算中消除。 
   * 例如，偏移量为 1 将返回窗口分区中任何给定点的前一行。
   * 这相当于 SQL 中的 LAG 函数。
   *
   * @group window_funcs
   * @since 3.2.0
   */
  def lag(e: Column, offset: Int, defaultValue: Any, ignoreNulls: Boolean): Column = withExpr {
    Lag(e.expr, Literal(offset), Literal(defaultValue), ignoreNulls)
  }

  /**
   * 窗口函数：返回当前行之后偏移行的值，如果当前行之后少于偏移行，则返回null 。 
   * 例如，偏移量为 1 将返回窗口分区中任何给定点的下一行。
   * 这相当于 SQL 中的 LEAD 函数。
   *
   * @group window_funcs
   * @since 1.4.0
   */
  def lead(columnName: String, offset: Int): Column = { lead(columnName, offset, null) }

  /**
   * 窗口函数：返回当前行之后偏移行的值，如果当前行之后少于偏移行，则返回null 。 
   * 例如，偏移量为 1 将返回窗口分区中任何给定点的下一行。
   * 这相当于 SQL 中的 LEAD 函数。
   *
   * @group window_funcs
   * @since 1.4.0
   */
  def lead(e: Column, offset: Int): Column = { lead(e, offset, null) }

  /**
   * 窗口函数：返回当前行后偏移行的值，如果当前行后少于偏移行，则返回defaultValue 。 
   * 例如，偏移量为 1 将返回窗口分区中任何给定点的下一行。
   * 这相当于 SQL 中的 LEAD 函数。
   *
   * @group window_funcs
   * @since 1.4.0
   */
  def lead(columnName: String, offset: Int, defaultValue: Any): Column = {
    lead(Column(columnName), offset, defaultValue)
  }

  /**
   * 窗口函数：返回当前行后偏移行的值，如果当前行后少于偏移行，则返回defaultValue 。 
   * 例如，偏移量为 1 将返回窗口分区中任何给定点的下一行。
   * 这相当于 SQL 中的 LEAD 函数。
   *
   * @group window_funcs
   * @since 1.4.0
   */
  def lead(e: Column, offset: Int, defaultValue: Any): Column = {
    lead(e, offset, defaultValue, false)
  }

  /**
   * 窗口函数：返回当前行后偏移行的值，如果当前行后少于偏移行，则返回defaultValue 。 
   * ignoreNulls确定行的空值是包含在计算中还是从计算中消除。 
   * ignoreNulls的默认值为 false。 
   * 例如，偏移量为 1 将返回窗口分区中任何给定点的下一行。
   * 这相当于 SQL 中的 LEAD 函数。
   *
   * @group window_funcs
   * @since 3.2.0
   */
  def lead(e: Column, offset: Int, defaultValue: Any, ignoreNulls: Boolean): Column = withExpr {
    Lead(e.expr, Literal(offset), Literal(defaultValue), ignoreNulls)
  }

用法

========== df.select(lag($"key", 2).over(w)) ==========
+-------------------------------------------------------------------------------------------------------------------+
|lag(key, 2, NULL) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN -2 FOLLOWING AND -2 FOLLOWING)|
+-------------------------------------------------------------------------------------------------------------------+
|                                                                                                               null|
|                                                                                                               null|
|                                                                                                               null|
|                                                                                                               null|
+-------------------------------------------------------------------------------------------------------------------+

========== df.select(lag("key", 2).over(w)) ==========
+-------------------------------------------------------------------------------------------------------------------+
|lag(key, 2, NULL) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN -2 FOLLOWING AND -2 FOLLOWING)|
+-------------------------------------------------------------------------------------------------------------------+
|                                                                                                               null|
|                                                                                                               null|
|                                                                                                               null|
|                                                                                                               null|
+-------------------------------------------------------------------------------------------------------------------+

========== df.select(lag($"key", 2, "0").over(w)) ==========
+----------------------------------------------------------------------------------------------------------------+
|lag(key, 2, 0) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN -2 FOLLOWING AND -2 FOLLOWING)|
+----------------------------------------------------------------------------------------------------------------+
|                                                                                                               0|
|                                                                                                               0|
|                                                                                                               0|
|                                                                                                               0|
+----------------------------------------------------------------------------------------------------------------+

========== df.select(lag("key", 2, "0").over(w)) ==========
+----------------------------------------------------------------------------------------------------------------+
|lag(key, 2, 0) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN -2 FOLLOWING AND -2 FOLLOWING)|
+----------------------------------------------------------------------------------------------------------------+
|                                                                                                               0|
|                                                                                                               0|
|                                                                                                               0|
|                                                                                                               0|
+----------------------------------------------------------------------------------------------------------------+

========== df.select(lag($"key", 2, "0", true).over(w)) ==========
+----------------------------------------------------------------------------------------------------------------+
|lag(key, 2, 0) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN -2 FOLLOWING AND -2 FOLLOWING)|
+----------------------------------------------------------------------------------------------------------------+
|                                                                                                               0|
|                                                                                                               0|
|                                                                                                               0|
|                                                                                                               0|
+----------------------------------------------------------------------------------------------------------------+

========== df.select(lead($"key", 2).over(w)) ==========
+------------------------------------------------------------------------------------------------------------------+
|lead(key, 2, NULL) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN 2 FOLLOWING AND 2 FOLLOWING)|
+------------------------------------------------------------------------------------------------------------------+
|                                                                                                              null|
|                                                                                                              null|
|                                                                                                              null|
|                                                                                                              null|
+------------------------------------------------------------------------------------------------------------------+

========== df.select(lead("key", 2).over(w)) ==========
+------------------------------------------------------------------------------------------------------------------+
|lead(key, 2, NULL) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN 2 FOLLOWING AND 2 FOLLOWING)|
+------------------------------------------------------------------------------------------------------------------+
|                                                                                                              null|
|                                                                                                              null|
|                                                                                                              null|
|                                                                                                              null|
+------------------------------------------------------------------------------------------------------------------+

========== df.select(lead($"key", 2, "0").over(w)) ==========
+---------------------------------------------------------------------------------------------------------------+
|lead(key, 2, 0) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN 2 FOLLOWING AND 2 FOLLOWING)|
+---------------------------------------------------------------------------------------------------------------+
|                                                                                                              0|
|                                                                                                              0|
|                                                                                                              0|
|                                                                                                              0|
+---------------------------------------------------------------------------------------------------------------+

========== df.select(lead("key", 2, "0").over(w)) ==========
+---------------------------------------------------------------------------------------------------------------+
|lead(key, 2, 0) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN 2 FOLLOWING AND 2 FOLLOWING)|
+---------------------------------------------------------------------------------------------------------------+
|                                                                                                              0|
|                                                                                                              0|
|                                                                                                              0|
|                                                                                                              0|
+---------------------------------------------------------------------------------------------------------------+

========== df.select(lead($"key", 2, "0", true).over(w)) ==========
+---------------------------------------------------------------------------------------------------------------+
|lead(key, 2, 0) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN 2 FOLLOWING AND 2 FOLLOWING)|
+---------------------------------------------------------------------------------------------------------------+
|                                                                                                              0|
|                                                                                                              0|
|                                                                                                              0|
|                                                                                                              0|
+---------------------------------------------------------------------------------------------------------------+

nth_value

  /**
   * 窗口函数：返回值是窗口的偏移第 offset 行（从1开始计数），如果窗口的大小小于偏移行，则返回null 。
   * 当 ignoreNulls 设置为 true 时，它​​将返回它看到的偏移量非空值。 
   * 如果所有值都为 null，则返回 null 值。
   * 这相当于 SQL 中的 nth_value 函数。
   *
   * @group window_funcs
   * @since 3.1.0
   */
  def nth_value(e: Column, offset: Int, ignoreNulls: Boolean): Column = withExpr {
    NthValue(e.expr, Literal(offset), ignoreNulls)
  }

  /**
   * 窗口函数：返回值是窗口的偏移第 offset 行（从1开始计数），如果窗口的大小小于偏移行，则返回null 。
   * 这相当于 SQL 中的 nth_value 函数。
   *
   * @group window_funcs
   * @since 3.1.0
   */
  def nth_value(e: Column, offset: Int): Column = withExpr {
    NthValue(e.expr, Literal(offset), false)
  }

用法

========== df.select(nth_value($"key", 2, true).over(w)) ==========
+---------------------------------------------------------------------------------------------------------------------------------------+
|nth_value(key, 2) ignore nulls OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+---------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                      1|
|                                                                                                                                      1|
|                                                                                                                                      2|
|                                                                                                                                      2|
+---------------------------------------------------------------------------------------------------------------------------------------+

========== df.select(nth_value($"key", 2).over(w)) ==========
+--------------------------------------------------------------------------------------------------------------------------+
|nth_value(key, 2) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+--------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                         1|
|                                                                                                                         1|
|                                                                                                                         2|
|                                                                                                                         2|
+--------------------------------------------------------------------------------------------------------------------------+

ntile

  /**
   * 窗口函数：返回有序窗口分区中的 ntile group id（从 1 到n包括在内）。 
   * 例如，如果n为 4，则行的第一季度将获得值 1，第二季度将获得 2，第三季度将获得 3，最后一个季度将获得
   * 4。
   * 这相当于 SQL 中的 NTILE 函数。
   *
   * @group window_funcs
   * @since 1.4.0
   */
  def ntile(n: Int): Column = withExpr { new NTile(Literal(n)) }

用法

========== df.select(ntile(2).over(w)). ==========
+----------------------------------------------------------------------------------------------------------------+
|ntile(2) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+----------------------------------------------------------------------------------------------------------------+
|                                                                                                               1|
|                                                                                                               2|
|                                                                                                               1|
|                                                                                                               2|
+----------------------------------------------------------------------------------------------------------------+

percent_rank

  /**
   * 窗口函数：返回窗口分区内行的相对排名（即百分位数）。
   * 这是通过以下方式计算的：
   * {{{
   *   (分区中行的排名 - 1) / (分区中的行数 - 1)
   * }}}
   * 这相当于 SQL 中的 PERCENT_RANK 函数。
   *
   * @group window_funcs
   * @since 1.6.0
   */
  def percent_rank(): Column = withExpr { new PercentRank }

用法

========== df.select(percent_rank().over(w)) ==========
+----------------------------------------------------------------------------------------------------------------------+
|PERCENT_RANK() OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+----------------------------------------------------------------------------------------------------------------------+
|                                                                                                                   0.0|
|                                                                                                                   0.0|
|                                                                                                                   0.0|
|                                                                                                                   0.0|
+----------------------------------------------------------------------------------------------------------------------+

rank

  /**
   * 窗口函数：返回窗口分区内行的排名。
   * rank 和dense_rank 之间的区别在于dense_rank 在有平局时不会在排名序列中留下间隙。 
   * 也就是说，如果您使用dense_rank 对比赛进行排名，并且有三个人并列第二，您会说三个人都排在第二位，下
   * 个人排在第三位。 
   * Rank 会给我连续的数字，使排在第三位的人（在并列之后）登记为第五位。
   * 这相当于 SQL 中的 RANK 函数。
   *
   * @group window_funcs
   * @since 1.4.0
   */
  def rank(): Column = withExpr { new Rank }

用法

========== df.select(rank().over(w)) ==========
+--------------------------------------------------------------------------------------------------------------+
|RANK() OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+--------------------------------------------------------------------------------------------------------------+
|                                                                                                             1|
|                                                                                                             1|
|                                                                                                             1|
|                                                                                                             1|
+--------------------------------------------------------------------------------------------------------------+

row_number

  /**
   * 窗口函数：返回窗口分区内从 1 开始的序列号。
   *
   * @group window_funcs
   * @since 1.6.0
   */
  def row_number(): Column = withExpr { RowNumber() }

用法

========== df.select(row_number().over(w)) ==========
+--------------------------------------------------------------------------------------------------------------------+
|row_number() OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+--------------------------------------------------------------------------------------------------------------------+
|                                                                                                                   1|
|                                                                                                                   2|
|                                                                                                                   1|
|                                                                                                                   2|
+--------------------------------------------------------------------------------------------------------------------+

实践

代码

package com.shockang.study.spark.sql.functions

import com.shockang.study.spark.util.Utils.formatPrint
import org.apache.log4j.{Level, Logger}
import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.expressions.Window
import org.apache.spark.sql.functions._

/**
 *
 * @author Shockang
 */
object WindowFunctionsExample {

  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.OFF)
    val spark = SparkSession.builder().appName("AggregateFunctionsExample").master("local[*]").getOrCreate()

    import spark.implicits._

    val df = Seq((1, "1"), (2, "2"), (1, "1"), (2, "2")).toDF("key", "value").cache()
    val w = Window.partitionBy("value").orderBy("key")

    // cume_dist
    formatPrint("""df.select(cume_dist().over(w))""")
    df.select(cume_dist().over(w)).show()

    // dense_rank
    formatPrint("""df.select(dense_rank().over(w))""")
    df.select(dense_rank().over(w)).show()

    // lag/lead
    formatPrint("""df.select(lag($"key", 2).over(w))""")
    df.select(lag($"key", 2).over(w)).show()

    formatPrint("""df.select(lag("key", 2).over(w))""")
    df.select(lag("key", 2).over(w)).show()

    formatPrint("""df.select(lag($"key", 2, "0").over(w))""")
    df.select(lag($"key", 2, "0").over(w)).show()

    formatPrint("""df.select(lag("key", 2, "0").over(w))""")
    df.select(lag("key", 2, "0").over(w)).show()

    formatPrint("""df.select(lag($"key", 2, "0", true).over(w))""")
    df.select(lag($"key", 2, "0", true).over(w)).show()

    formatPrint("""df.select(lead($"key", 2).over(w))""")
    df.select(lead($"key", 2).over(w)).show()

    formatPrint("""df.select(lead("key", 2).over(w))""")
    df.select(lead("key", 2).over(w)).show()

    formatPrint("""df.select(lead($"key", 2, "0").over(w))""")
    df.select(lead($"key", 2, "0").over(w)).show()

    formatPrint("""df.select(lead("key", 2, "0").over(w))""")
    df.select(lead("key", 2, "0").over(w)).show()

    formatPrint("""df.select(lead($"key", 2, "0", true).over(w))""")
    df.select(lead($"key", 2, "0", true).over(w)).show()

    // nth_value
    formatPrint("""df.select(nth_value($"key", 2, true).over(w))""")
    df.select(nth_value($"key", 2, true).over(w)).show()

    formatPrint("""df.select(nth_value($"key", 2).over(w))""")
    df.select(nth_value($"key", 2).over(w)).show()

    // ntile
    formatPrint("""df.select(ntile(2).over(w)).""")
    df.select(ntile(2).over(w)).show()

    // percent_rank
    formatPrint("""df.select(percent_rank().over(w))""")
    df.select(percent_rank().over(w)).show()

    // rank
    formatPrint("""df.select(rank().over(w))""")
    df.select(rank().over(w)).show()

    // row_number
    formatPrint("""df.select(row_number().over(w))""")
    df.select(row_number().over(w)).show()
  }
}

输出

========== df.select(cume_dist().over(w)) ==========
+--------------------------------------------------------------------------------------------------------------------+
|cume_dist() OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+--------------------------------------------------------------------------------------------------------------------+
|                                                                                                                 1.0|
|                                                                                                                 1.0|
|                                                                                                                 1.0|
|                                                                                                                 1.0|
+--------------------------------------------------------------------------------------------------------------------+

========== df.select(dense_rank().over(w)) ==========
+--------------------------------------------------------------------------------------------------------------------+
|DENSE_RANK() OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+--------------------------------------------------------------------------------------------------------------------+
|                                                                                                                   1|
|                                                                                                                   1|
|                                                                                                                   1|
|                                                                                                                   1|
+--------------------------------------------------------------------------------------------------------------------+

========== df.select(lag($"key", 2).over(w)) ==========
+-------------------------------------------------------------------------------------------------------------------+
|lag(key, 2, NULL) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN -2 FOLLOWING AND -2 FOLLOWING)|
+-------------------------------------------------------------------------------------------------------------------+
|                                                                                                               null|
|                                                                                                               null|
|                                                                                                               null|
|                                                                                                               null|
+-------------------------------------------------------------------------------------------------------------------+

========== df.select(lag("key", 2).over(w)) ==========
+-------------------------------------------------------------------------------------------------------------------+
|lag(key, 2, NULL) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN -2 FOLLOWING AND -2 FOLLOWING)|
+-------------------------------------------------------------------------------------------------------------------+
|                                                                                                               null|
|                                                                                                               null|
|                                                                                                               null|
|                                                                                                               null|
+-------------------------------------------------------------------------------------------------------------------+

========== df.select(lag($"key", 2, "0").over(w)) ==========
+----------------------------------------------------------------------------------------------------------------+
|lag(key, 2, 0) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN -2 FOLLOWING AND -2 FOLLOWING)|
+----------------------------------------------------------------------------------------------------------------+
|                                                                                                               0|
|                                                                                                               0|
|                                                                                                               0|
|                                                                                                               0|
+----------------------------------------------------------------------------------------------------------------+

========== df.select(lag("key", 2, "0").over(w)) ==========
+----------------------------------------------------------------------------------------------------------------+
|lag(key, 2, 0) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN -2 FOLLOWING AND -2 FOLLOWING)|
+----------------------------------------------------------------------------------------------------------------+
|                                                                                                               0|
|                                                                                                               0|
|                                                                                                               0|
|                                                                                                               0|
+----------------------------------------------------------------------------------------------------------------+

========== df.select(lag($"key", 2, "0", true).over(w)) ==========
+----------------------------------------------------------------------------------------------------------------+
|lag(key, 2, 0) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN -2 FOLLOWING AND -2 FOLLOWING)|
+----------------------------------------------------------------------------------------------------------------+
|                                                                                                               0|
|                                                                                                               0|
|                                                                                                               0|
|                                                                                                               0|
+----------------------------------------------------------------------------------------------------------------+

========== df.select(lead($"key", 2).over(w)) ==========
+------------------------------------------------------------------------------------------------------------------+
|lead(key, 2, NULL) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN 2 FOLLOWING AND 2 FOLLOWING)|
+------------------------------------------------------------------------------------------------------------------+
|                                                                                                              null|
|                                                                                                              null|
|                                                                                                              null|
|                                                                                                              null|
+------------------------------------------------------------------------------------------------------------------+

========== df.select(lead("key", 2).over(w)) ==========
+------------------------------------------------------------------------------------------------------------------+
|lead(key, 2, NULL) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN 2 FOLLOWING AND 2 FOLLOWING)|
+------------------------------------------------------------------------------------------------------------------+
|                                                                                                              null|
|                                                                                                              null|
|                                                                                                              null|
|                                                                                                              null|
+------------------------------------------------------------------------------------------------------------------+

========== df.select(lead($"key", 2, "0").over(w)) ==========
+---------------------------------------------------------------------------------------------------------------+
|lead(key, 2, 0) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN 2 FOLLOWING AND 2 FOLLOWING)|
+---------------------------------------------------------------------------------------------------------------+
|                                                                                                              0|
|                                                                                                              0|
|                                                                                                              0|
|                                                                                                              0|
+---------------------------------------------------------------------------------------------------------------+

========== df.select(lead("key", 2, "0").over(w)) ==========
+---------------------------------------------------------------------------------------------------------------+
|lead(key, 2, 0) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN 2 FOLLOWING AND 2 FOLLOWING)|
+---------------------------------------------------------------------------------------------------------------+
|                                                                                                              0|
|                                                                                                              0|
|                                                                                                              0|
|                                                                                                              0|
+---------------------------------------------------------------------------------------------------------------+

========== df.select(lead($"key", 2, "0", true).over(w)) ==========
+---------------------------------------------------------------------------------------------------------------+
|lead(key, 2, 0) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN 2 FOLLOWING AND 2 FOLLOWING)|
+---------------------------------------------------------------------------------------------------------------+
|                                                                                                              0|
|                                                                                                              0|
|                                                                                                              0|
|                                                                                                              0|
+---------------------------------------------------------------------------------------------------------------+

========== df.select(nth_value($"key", 2, true).over(w)) ==========
+---------------------------------------------------------------------------------------------------------------------------------------+
|nth_value(key, 2) ignore nulls OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+---------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                                      1|
|                                                                                                                                      1|
|                                                                                                                                      2|
|                                                                                                                                      2|
+---------------------------------------------------------------------------------------------------------------------------------------+

========== df.select(nth_value($"key", 2).over(w)) ==========
+--------------------------------------------------------------------------------------------------------------------------+
|nth_value(key, 2) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+--------------------------------------------------------------------------------------------------------------------------+
|                                                                                                                         1|
|                                                                                                                         1|
|                                                                                                                         2|
|                                                                                                                         2|
+--------------------------------------------------------------------------------------------------------------------------+

========== df.select(ntile(2).over(w)). ==========
+----------------------------------------------------------------------------------------------------------------+
|ntile(2) OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+----------------------------------------------------------------------------------------------------------------+
|                                                                                                               1|
|                                                                                                               2|
|                                                                                                               1|
|                                                                                                               2|
+----------------------------------------------------------------------------------------------------------------+

========== df.select(percent_rank().over(w)) ==========
+----------------------------------------------------------------------------------------------------------------------+
|PERCENT_RANK() OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+----------------------------------------------------------------------------------------------------------------------+
|                                                                                                                   0.0|
|                                                                                                                   0.0|
|                                                                                                                   0.0|
|                                                                                                                   0.0|
+----------------------------------------------------------------------------------------------------------------------+

========== df.select(rank().over(w)) ==========
+--------------------------------------------------------------------------------------------------------------+
|RANK() OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+--------------------------------------------------------------------------------------------------------------+
|                                                                                                             1|
|                                                                                                             1|
|                                                                                                             1|
|                                                                                                             1|
+--------------------------------------------------------------------------------------------------------------+

========== df.select(row_number().over(w)) ==========
+--------------------------------------------------------------------------------------------------------------------+
|row_number() OVER (PARTITION BY value ORDER BY key ASC NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)|
+--------------------------------------------------------------------------------------------------------------------+
|                                                                                                                   1|
|                                                                                                                   2|
|                                                                                                                   1|
|                                                                                                                   2|
+--------------------------------------------------------------------------------------------------------------------+
Shockang
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Flink / Scala 实战 - 14.AllWindowFunction 与 KeyedProcessFunction 处理 TopK 问题
BITDDD小栈
09-28 1097
Flink / Scala 使用 keyedProcessFunction + ListState 处理 TopK。
Flink的window操作之Window Functions(二)
JasonLee实时计算
12-16 4281
上一篇中介绍了Flink中的window操作,接着介绍一下窗口函数. Window Functions 在定义了窗口分配器之后呢,我们需要为每一个窗口明确的指定计算,这个就是窗口函数要做的事情,当系统决定一个窗口已经准备好执行之后，这个窗口函数将被用来处理窗口中的每一个元素(可能是分组的)。 窗口函数可以是ReduceFunction, FoldFunction , WindowFuncti...
【spark内置函数】window
hyj
08-04 568
一、说明 这里的window函数是属于functions.scala文件中的内置函数。 window函数是在spark2.0.0中新增的API函数。 这里选取股票数据为测试数据：测试数据下载地址。 时间一定要整理成yyyy-MM-dd hh:mm:ss格式，其他格式内置函数不识别。 二、数据样式 --表头 id,date,openPrice,highestPrice,lowestPrice,closePrice,exchangeNum 代码,时间,开盘价,最高价,最低价,收盘价,成交量(手) -
Spark之functions
SunnyRivers
05-11 2042
前言 Spark源码中的org.apache.spark.sql包下有一个叫做functions.scala的文件，该文件包含了大量的内置函数，尤其是在agg中会广泛使用（不仅限于此） 这些内置函数可以极大的简化spark数据分析，到Spark2.2已经拥有307个函数，只有通过大量实践才能熟练掌握 函数分类 UDF自定义函数、聚合函数、日期时间函数、排序函数、非聚合函数、数学函数、窗口函数、...
spark.sql.functions函数
m0_64683883的博客
11-29 1143
org.apache.spark.sql.functions类中所有的函数，时间函数，聚合函数，字符串函数，窗口函数，排序函数等
SparkSql窗口函数源码分析（第一部分）
xiaoluobutou的专栏
02-09 476
窗口函数定义的接口类（在OVER子句或Window子句中指定）WindowSpecDefinition：定义了一个窗口函数应该包含哪些元素（定义了输入行的分区方式（按哪个字段分区）、定义分区内数据的该怎么排序（SortOrder类，按哪个字段排，升序还是降序）、定义了分区中的窗口框架（WindowFrame类））WindowSpecReference：代表引用一个窗口函数，比如下面这种用法，这种写法的好处就是：over 后面内容如果相同的话，可以只用写一次。
基于Scala的Spark RDD、Spark SQL、Spark Streaming相关Demo设计源码
03-28
这是一个基于Scala语言开发的Spark RDD、Spark SQL、Spark Streaming相关Demo，包含35个文件。主要文件类型包括29个Scala源文件、2个Markdown文档、1个Reduced文件、1个XML文件、1个Java源文件和1个TXT文件。该项目...
基于Scala的Spark模型转换为PMML格式设计源码
最新发布
04-04
本设计源码提供了一个基于Scala的Spark模型转换为PMML格式。项目包含21个文件，主要使用Scala编程语言，并包含了Java。文件类型包括9个XML配置文件、2个CRC文件、2个Scala源代码文件、1个名称文件、1个Markdown文档...
spark sql解析-源码分析
03-16
在这个源码分析中，我们将深入探讨Spark SQL的工作原理、主要组件以及其解析过程。 1. **DataFrame API**：DataFrame是Spark SQL的核心概念，它是一种分布式数据集合，提供了类似SQL的API用于数据操作。DataFrame是...
基于Scala的Spark学习项目设计源码
04-04
本设计源码提供了一个基于Scala的Spark学习项目。项目包含95个文件，主要使用Scala和Java编程语言。文件类型包括80个Scala源代码文件、4个XML配置文件、3个TXT文档、2个Markdown文档、2个Java源代码文件、1个GIT忽略...
深入解析Scala与Java共筑的Spark全面学习源码
03-25
项目概述：《深入解析Scala与Java共筑的Spark全面学习源码》 本项目以Scala为主要开发语言，辅以Java实现，全面讲解了Spark的原理与应用。包含文件共150个，其中主要包括： - XML配置文件：139个，为项目提供了...
DB2 在线分析处理（OLAP函数的使用）
叶落枫亭
12-22 4820
之前用过Oracle的分析函数 row_number() over(partition by column order by column) rn 来进行数据分析,没想到DB2也是支持的,转载一篇详细的介绍:   说起 DB2 在线分析处理，可以用很好很强大来形容。这项功能特别适用于各种统计查询，这些查询用通常的SQL很难实现，或者根本就无发实现。首先，我们从一个简单的例子开始，来一步一步揭开
【极简spark教程】spark常用内置函数
檐前潜心学种瓜
04-29 4031
三分钟看懂spark内置函数，三行代码写出自己的UDF
Scala中运用windowing函数
kopunk的专栏
07-21 463
先创建一个rank spec // 用df("salary").asc代表升序排列，desc代表降序 val rankSpec = Window.partitionBy("age").orderBy(df("salary").desc) 然后为自己的表添加一列rank val sararyRank = df.withColumn("rank",dense_rank().over(ra...
Window Function超详细解析
渐宽阁读书小弟
03-30 4116
文章目录用于测试的CustomSourceFunction增量聚合函数ReduceFunctionAggregateFunctionFoldFunction全量窗口函数ProcessWindowFunction增量聚合函数与全量窗口函数整合ProcessWindowFunction状态操作 用于测试的CustomSourceFunction 增量聚合函数 计算性能较高，占用存储空间少，主要基于中间...
Scala Functions vs Methods（scala中的函数和方法）
zmxj的专栏
06-27 5533
被强 Scala has both functions and methods. Most of the time we can ignore this distinction, but sometimes we have to deal with the fact that they are not quite the same thing.  In my Scala Syntax
Scala之窗口函数排序
杨羊不是羊的博客
05-27 684
scala窗口函数这排序rank import org.apache.spark.sql.expressions.Window import spark.implicits._ val testDF =Seq( ("A", 50), ("B", 39), ("A", 48), ("A", 48), ("B", 35), ("C", 42), ("C", 60), ("C", 45), ("C", 52), ("C", 52)).toDF("name","score"
Spark SQL 函数全集
热门推荐
Liam's Blog (AI & BigData)
03-23 4万+
Summary org.apache.spark.sql.functions是一个Object，提供了约两百多个函数。 大部分函数与Hive的差不多。 除UDF函数，均可在spark-sql中直接使用。 经过import org.apache.spark.sql.functions._ ，也可以用于Dataframe，Dataset。 version 2.3.0 大部分支持Colum...
spark scala dataframe 窗户函数Window的应用 实现row_number() over(partition by , order by )
u010865811的博客
04-02 3798
需要引入的包： import org.apache.spark.sql.expressions.Window import org.apache.spark.sql.functions._ //scala实现row_number() over(partition by , order by ) val w = Window.partitionBy($"prediction").o...
java.sql.SQLException: No suitable driver at java.sql.DriverManager.getDriver(DriverManager.java:315) at org.apache.spark.sql.execution.datasources.jdbc.JDBCOptions.$anonfun$driverClass$2(JDBCOptions.scala:105) at scala.Option.getOrElse(Option.scala:189) at org.apache.spark.sql.execution.datasources.jdbc.JDBCOptions.<init>(JDBCOptions.scala:105) at org.apache.spark.sql.execution.datasources.jdbc.JDBCOptions.<init>(JDBCOptions.scala:35) at org.apache.spark.sql.execution.datasources.jdbc.JdbcRelationProvider.createRelation(JdbcRelationProvider.scala:32) at org.apache.spark.sql.execution.datasources.DataSource.resolveRelation(DataSource.scala:339) at org.apache.spark.sql.DataFrameReader.loadV1Source(DataFrameReader.scala:279) at org.apache.spark.sql.DataFrameReader.$anonfun$load$2(DataFrameReader.scala:268) at scala.Option.getOrElse(Option.scala:189) at org.apache.spark.sql.DataFrameReader.load(DataFrameReader.scala:268) at org.apache.spark.sql.DataFrameReader.load(DataFrameReader.scala:203) at org.apache.spark.sql.DataFrameReader.jdbc(DataFrameReader.scala:294) ... 47 elided
05-23
这是一个Java SQL异常，报告找不到合适的驱动器。这通常是因为在使用JDBC连接数据库时没有正确的驱动器。 请确保你已经正确安装并配置了数据库驱动程序。 您可以通过在代码中包括正确的JDBC驱动程序来解决此问题。例如，如果您使用的是MySQL数据库，则需要将MySQL JDBC驱动程序添加到您的项目依赖项中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值