【问题标题】:How do I parallelize/distribute queries/counts against a Spark DataFrame?如何针对 Spark DataFrame 并行化/分布查询/计数?
【发布时间】:2017-05-05 17:05:37
【问题描述】:

我有一个DataFrame,我必须对其应用一系列过滤查询。例如,我如下加载我的DataFrame

val df = spark.read.parquet("hdfs://box/some-parquet")

然后我有一堆“任意”过滤器,如下所示。

  • C0='true' 和 C1='false'
  • C0='false' 和 C3='true'
  • 等等……

我通常使用 util 方法动态获取这些过滤器。

val filters: List[String] = getFilters()

我所做的只是将这些过滤器应用于DataFrame 以获取计数。例如。

val counts = filters.map(filter => {
 df.where(filter).count
})

我注意到映射过滤器时这不是并行/分布式操作。如果我将过滤器粘贴到 RDD/DataFrame 中,这种方法也不起作用,因为我将执行嵌套数据帧操作(正如我在 SO 上所读到的,Spark 中不允许这样做)。类似以下的内容会产生 NullPointerException (NPE)。

val df = spark.read.parquet("hdfs://box/some-parquet")
val filterRDD = spark.sparkContext.parallelize(List("C0='false'", "C1='true'"))
val counts = filterRDD.map(df.filter(_).count).collect
引起:java.lang.NullPointerException 在 org.apache.spark.sql.Dataset.filter(Dataset.scala:1127) 在 $anonfun$1.apply(:27) 在 $anonfun$1.apply(:27) 在 scala.collection.Iterator$$anon$11.next(Iterator.scala:409) 在 scala.collection.Iterator$class.foreach(Ite​​rator.scala:893) 在 scala.collection.AbstractIterator.foreach(Ite​​rator.scala:1336) 在 scala.collection.generic.Growable$class.$plus$plus$eq(Growable.scala:59) 在 scala.collection.mutable.ArrayBuffer.$plus$plus$eq(ArrayBuffer.scala:104) 在 scala.collection.mutable.ArrayBuffer.$plus$plus$eq(ArrayBuffer.scala:48) 在 scala.collection.TraversableOnce$class.to(TraversableOnce.scala:310) 在 scala.collection.AbstractIterator.to(Iterator.scala:1336) 在 scala.collection.TraversableOnce$class.toBuffer(TraversableOnce.scala:302) 在 scala.collection.AbstractIterator.toBuffer(Iterator.scala:1336) 在 scala.collection.TraversableOnce$class.toArray(TraversableOnce.scala:289) 在 scala.collection.AbstractIterator.toArray(Iterator.scala:1336) 在 org.apache.spark.rdd.RDD$$anonfun$collect$1$$anonfun$13.apply(RDD.scala:912) 在 org.apache.spark.rdd.RDD$$anonfun$collect$1$$anonfun$13.apply(RDD.scala:912) 在 org.apache.spark.SparkContext$$anonfun$runJob$5.apply(SparkContext.scala:1899) 在 org.apache.spark.SparkContext$$anonfun$runJob$5.apply(SparkContext.scala:1899) 在 org.apache.spark.scheduler.ResultTask.runTask(ResultTask.scala:70) 在 org.apache.spark.scheduler.Task.run(Task.scala:86) 在 org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:27​​4) 在 java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142) 在 java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617) 在 java.lang.Thread.run(Thread.java:745)

有没有办法在 Spark 中的 DataFrame 上并行化/分布计数过滤器?顺便说一句,我正在使用 Spark v2.0.2。

【问题讨论】:

  • 假设您想要实现的是对输入数据的单次传递(否则,可能没有任何收获),我会将过滤器函数重新设计为返回 1 的 UDF(过滤器匹配)或 0(无过滤器匹配),通过 UDF 将 1 列添加到数据帧,并对添加的列执行 groupBy / 计数,这将导致 1 行数据帧,包含所有计数。
  • 你能举个例子吗?

标签: apache-spark apache-spark-sql spark-dataframe rdd apache-spark-dataset


【解决方案1】:

通过这样做,唯一可预期的收益(可能非常可观)将是仅在输入数据上传递一次。

我会这样做(编程解决方案,但等效的 SQL 是可能的):

  1. 将过滤器转换为返回 1 或 0 的 UDF
  2. 为每个 UDFS 添加一列
  3. 分组依据/汇总您的数据。

Spark 会话示例如下所示:

scala> val data = spark.createDataFrame(Seq("A", "BB", "CCC").map(Tuple1.apply)).withColumnRenamed("_1", "input")

data: org.apache.spark.sql.DataFrame = [input: string]

scala> data.show
+-----+
|input|
+-----+
|    A|
|   BB|
|  CCC|
+-----+

scala> val containsBFilter = udf((input: String) => if(input.contains("B")) 1 else 0)
containsBFilter: org.apache.spark.sql.expressions.UserDefinedFunction = UserDefinedFunction(<function1>,IntegerType,Some(List(StringType)))

scala> val lengthFilter = udf((input: String) => if (input.length < 3) 1 else 0)
lengthFilter: org.apache.spark.sql.expressions.UserDefinedFunction = UserDefinedFunction(<function1>,IntegerType,Some(List(StringType)))

scala> data.withColumn("inputLength", lengthFilter($"input")).withColumn("containsB", containsBFilter($"input")).select(sum($"inputLength"), sum($"containsB")).show

+----------------+--------------+
|sum(inputLength)|sum(containsB)|
+----------------+--------------+
|               2|             1|
+----------------+--------------+

【讨论】:

  • 这很聪明。我喜欢。你认为使用 Scala 的并行集合类也有助于并行化吗?正如您所说,使用您的方法,这是对数据的一次传递,但是 UDF 会随着过滤器的数量线性增长。但我想如果没有性能影响也没关系。
  • guess Spark 足够聪明,可以很好地处理附加列(例如,通过只传递一次数据来计算它们),因为它们没有依赖关系。它确实需要更多空间,但我们说的很长,这非常有效。使用并行集合违背了 Spark 的目的:Spark 分区是并行单元(1 个执行器核心 = 1 个分区),不要插入你自己的(你只会为带有 Spark 分区的 CPU 而战),只需以正确的方式进行分区。
  • 我这几天一直在修改这种方法。我认为它不适用于我的情况。首先,关于并行收集,这种方法只会在我的驱动程序上并行化,而不是跨集群并行化,这不是我想要的。其次,我必须动态创建这些 UDF(我问了另一个 SO 问题)。但即使我解决了动态创建 UDF 的问题,df = df.withColumn("someFilter", someUdf(...)) 操作也非常长。我可以拥有任意数量的动态 UDF(过滤器),这将添加那么多列。
  • 我真的不明白发生了什么。添加一列应该几乎是即时的,它只是一个逻辑计划更新,不应该进行任何计算。而且我也不知道您的并行集合是什么以及它如何适应所有这些。不过,也许这是另一个问题。至于将过滤器转换为 1/0 的 UDF,它可能是通用的。
猜你喜欢
  • 2022-01-23
  • 2017-03-14
  • 2021-05-08
  • 2016-09-27
  • 2019-08-03
  • 1970-01-01
  • 2017-05-30
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多