Question

我正在尝试在hive中运行查询：

这里是最简单的设置（我知道我可以做=但我使用自定义UDF，它不仅仅是一个相等比较）

数据集a和b各约为30,000行

SELECT * FROM a INNER JOIN b ON Custom_UDF_Equals_Comparison(a.id, b.id) LIMIT 5

其中custom_UDF_Equals_Comparison只是在a.id = b.id

之间进行相等检查

当我运行此查询时，我可以在我的日志输出中看到许多m / r任务正在运行，假设它在两个数据集之间进行比较，直到比较所有可能的排列，并且远高于LIMIT为5（我会我只知道少数几个m / r任务，因为我知道大多数数据都可以在每个表的前几行内连接，为什么会出现这种情况呢？和/或我该如何解决？

编辑：

嗨zero323，这是一个类似的问题，但不完全正确，它解释了为什么在使用UDF进行比较时执行2 RDD的完全比较，但它没有解释为什么LIMIT不会停止比较当找到5的限制时。例如，如果在前10次连接尝试中找到5行，为什么它会用于剩余的30,000 * 30,000次尝试。是否因为在所有连接发生后应用限制这一事实？例如它加入30,000 * 30,000行然后将它们减少到5？

EDIT2：

  def levenshtein(str1: String, str2: String): Int = {
val lenStr1 = str1.length
val lenStr2 = str2.length

val d: Array[Array[Int]] = Array.ofDim(lenStr1 + 1, lenStr2 + 1)

for (i <- 0 to lenStr1) d(i)(0) = i
for (j <- 0 to lenStr2) d(0)(j) = j

for (i <- 1 to lenStr1; j <- 1 to lenStr2) {
  val cost = if (str1(i - 1) == str2(j-1)) 0 else 1

  d(i)(j) = min(
    d(i-1)(j  ) + 1,     // deletion
    d(i  )(j-1) + 1,     // insertion
    d(i-1)(j-1) + cost   // substitution
  )
}

d(lenStr1)(lenStr2)

}

def min(nums: Int*): Int = nums.min

def join_views( joinType: String, parameters: Any, col1: Any, col2: Any) : Boolean = {
if (joinType == "Equals") {
  if (col1 == null || col2 == null) {
    return false
  }

  return col1 == col2
}
else if (joinType == "Fuzzy_String") {
  if (col1 == null || col2 == null) {
    return false
  }

  val val1 = col1.asInstanceOf[String]
  val val2 = col2.asInstanceOf[String]

  val ratio = Utils.distancePercentage(val1, val2)

  if (ratio == 1.0) {
    return val1 == val2
  }

  return (ratio >= parameters.asInstanceOf[Double])
}

return false;

}

... ON join_views（＆＃34; Fuzzy_String＆＃34;，＆＃34; 0.1＆＃34;，a.col1，b.col1）LIMIT 5 = 20secs

... ON join_views（＆＃34; Fuzzy_String＆＃34;，＆＃34; 0.9＆＃34;，a.col1，b.col1）LIMIT 5 = 100secs

Answer 1

所以这里有三个不同的问题：

Spark通过使用散列和排序来优化连接，因此这些优化仅适用于等连接。其他类型的连接，包括依赖于UDF的连接，需要成对比较因此笛卡尔积。您可以查看Why using a UDF in a SQL query leads to cartesian product?了解详情。
无法完全优化数据移动（尤其是随机播放）后的操作限制。您可以在nice answer提供的Towards limiting the big RDD至Sun Rui中找到一个很好的解释。

由于缺少洗牌，你的情况更加简单，但你仍然需要将分区放在一起。
限制优化基于分区，而不是记录。 Spark开始检查第一个分区，如果满足条件的元素数量低于要求，它会迭代每次迭代时要增加的分区数（据我记得因子为4）。如果你正在寻找一个罕见的事件，这可以非常快地增加。

Apache Spark - Hive内部联接，LIMIT和自定义UDF

1 个答案: