Question

我发现在Apache Spark SQL（版本2.2.0）中，当在窗口规范上使用的用户定义的聚合函数（UDAF）提供了多行相同的输入时，UDAF（看似）不能正确调用evaluate方法。

我已经能够在Java和Scala中，本地和群集上重现这种行为。下面的代码显示了一个示例，如果行在前一行的1秒内，则标记为false。

class ExampleUDAF(val timeLimit: Long) extends UserDefinedAggregateFunction {
  def deterministic: Boolean = true
  def inputSchema: StructType = StructType(Array(StructField("unix_time", LongType)))
  def dataType: DataType = BooleanType

  def bufferSchema = StructType(Array(
    StructField("previousKeepTime", LongType),
    StructField("keepRow", BooleanType)
  ))

  def initialize(buffer: MutableAggregationBuffer) = {
    buffer(0) = 0L
    buffer(1) = false
  }

  def update(buffer: MutableAggregationBuffer, input: Row) = {    
    if (buffer(0) == 0L) {
      buffer(0) = input.getLong(0)
      buffer(1) = true
    } else {
      val timeDiff = input.getLong(0) - buffer.getLong(0)

      if (timeDiff < timeLimit) {
        buffer(1) = false
      } else {
        buffer(0) = input.getLong(0)
        buffer(1) = true
      }
    }
  }

  def merge(buffer1: MutableAggregationBuffer, buffer2: Row) = {} // Not implemented
  def evaluate(buffer: Row): Boolean = buffer.getBoolean(1)
 }

val timeLimit = 1000 // 1 second
val udaf = new ExampleUDAF(timeLimit)

val window = Window
  .orderBy(column("unix_time"))
  .partitionBy(column("category"))

val df = spark.createDataFrame(Arrays.asList(
    Row(1510000001000L, "a", true), 
    Row(1510000001000L, "a", false), 
    Row(1510000001000L, "a", false),
    Row(1510000001000L, "a", false),
    Row(1510000700000L, "a", true),
    Row(1510000700000L, "a", false)
  ), new StructType().add("unix_time", LongType).add("category", StringType).add("expected_result", BooleanType))

df.withColumn("actual_result", udaf(column("unix_time")).over(window)).show

以下是运行上述代码的输出。由于没有先前的数据，因此第一行的actual_result值应为true。当unix_time输入被修改为在每条记录之间有1毫秒时，UDAF按预期工作。

在UDAF方法中添加print语句显示evaluate最后只调用一次，并且update方法中的缓冲区已正确更新为true，但这不是返回的内容UDAF完成后。

+-------------+--------+---------------+-------------+
|    unix_time|category|expected_result|actual_result|
+-------------+--------+---------------+-------------+
|1510000001000|       a|           true|        false|  // Should true as first element
|1510000001000|       a|          false|        false|
|1510000001000|       a|          false|        false|
|1510000001000|       a|          false|        false|
|1510000700000|       a|           true|        false|  // Should be true as more than 1000 milliseconds between self and previous
|1510000700000|       a|          false|        false|
+-------------+--------+---------------+-------------+

我在使用窗口规范时正确理解Spark的UDAF行为？如果没有，任何人都可以提供这方面的任何见解。如果我对Windows上的UDAF行为的理解是正确的，那么这可能是Spark中的一个错误吗？谢谢。

Answer 1

UDAF的一个问题是，它没有指定要使用rowsBetween()在哪个行上运行窗口。如果没有rowsBetween()规范，则窗口函数将在当前行之前和之后的每一行中使用 all （请参阅下面的更新）行，包括当前一行（在给定类别）。因此，在您的示例actual_result中，所有行的DataFrame基本上只考虑最后两行，其中unix_time=1510000700000实际上将为所有行返回false。

带有这样的window声明：

Window.partitionBy(col("category")).orderBy(col("unix_time")).rowsBetween(-1L, 0L)

您始终仅在上一行和当前行上查找。上一行优先。这将创建正确的输出。但是，由于具有相同unix_time的行的顺序不是唯一的，因此无法预测具有相同true的行中哪一行将具有值unix_time。

结果可能如下所示：

+-------------+--------+---------------+-------------+
|    unix_time|category|expected_result|actual_result|
+-------------+--------+---------------+-------------+
|1510000001000|       a|          false|         true|
|1510000001000|       a|          false|        false|
|1510000001000|       a|          false|        false|
|1510000001000|       a|           true|        false|
|1510000700000|       a|           true|         true|
|1510000700000|       a|          false|        false|
+-------------+--------+---------------+-------------+

更新

进一步研究之后，似乎提供了orderBy列时，它将采用当前行+当前行之前的所有元素。并非所有分区元素都像我之前所说的那样。另外，如果orderBy列包含重复值窗口的每个重复行将包含所有重复值。您可以通过以下操作清楚地看到它：

val wA = Window.partitionBy(col("category")).orderBy(col("unix_time"))
val wB = Window.partitionBy(col("category"))
val wC = Window.partitionBy(col("category")).orderBy(col("unix_time")).rowsBetween(-1L, 0L)

df.withColumn("countRows", count(col("unix_time")).over(wA)).show()
df.withColumn("countRows", count(col("unix_time")).over(wB)).show()
df.withColumn("countRows", count(col("unix_time")).over(wC)).show()

它将计算每个窗口中的元素数量。

wA窗口在每1510000001000行中将有4个元素，每1510000700000中将有6个元素。
对于wB，当没有orderBy时，每个分区的窗口中都包含所有行，因此所有窗口将具有6个元素。
最后一个wC指定对行的选择，因此不会为哪个窗口选择哪个行留下歧义。第一行只有1个元素，所有后续行的窗口中只有2个元素。会产生正确的结果。

我今天也学到了一些新东西：）

Apache Spark SQL UDAF在窗口上显示重复输入的奇怪行为

1 个答案: