小编Wil*_*ton的帖子

我正在尝试对集合进行一些分析.我有一个示例数据集,如下所示:

orders.json

{"items":[1,2,3,4,5]}
{"items":[1,2,5]}
{"items":[1,3,5]}
{"items":[3,4,5]}

它只是一个字段,它是一个代表ID的数字列表.

这是我试图运行的Spark脚本:

val sparkConf = new SparkConf()
  .setMaster("local[*]")
  .setAppName("Dataframe Test")

val sc = new SparkContext(sparkConf)
val sql = new SQLContext(sc)

val dataframe = sql.read.json("orders.json")

val expanded = dataframe
  .explode[::[Long], Long]("items", "item1")(row => row)
  .explode[::[Long], Long]("items", "item2")(row => row)

val grouped = expanded
  .where(expanded("item1") !== expanded("item2"))
  .groupBy("item1", "item2")
  .count()

val recs = grouped
  .groupBy("item1")

创建expanded并且grouped很好,简而言之,expanded是两个ID在同一原始集中的所有可能的两个ID的列表.grouped过滤掉与自身匹配的ID,然后将所有唯一ID组合在一起并为每个ID生成计数.架构和数据样本grouped是:

root
 |-- item1: long (nullable = true)
 |-- item2: long …

filter在包含null值的基本scala集合上，具有以下（且非常直观）的行为：

scala> List("a", "b", null).filter(_ != "a")
res0: List[String] = List(b, null)

但是，我很惊讶地发现以下过滤器删除了火花数据帧中的空值：

scala> val df = List(("a", null), ( "c", "d")).toDF("A", "B")
scala> df.show
+---+----+
|  A|   B|
+---+----+
|  a|null|
|  c|   d|
+---+----+
scala> df.filter('B =!= "d").show
+---+---+
|  A|  B|
+---+---+
+---+---+

如果要保留null值，我应该添加

df.filter('B =!= "d" || 'B.isNull).show
+---+----+
|  A|   B|
+---+----+
|  a|null|
+---+----+

就个人而言，我认为默认情况下删除空值非常容易出错。为什么选择这个？为何在api文档中未明确说明？我想念什么吗？

编辑:这是一个关于Spark 1.2的老问题

为了达到目的,我一直在尝试计算SchemaRDD中字符串列的长度.我正在学习Spark SQL,所以我的问题严格来说是使用Spark或Spark SQL公开的SQL接口,或者了解它们的局限性.

我的第一次尝试就是使用集成的关系查询

notes.select('note).orderBy(length('note))

在编译时没有运气:

error: not found: value length

(这让我想知道在哪里可以找到这个DSL实际上可以解决的"表达式".例如,它为列添加解析了"+".)

然后我试了一下

sql("SELECT note, length(note) as len FROM notes")

这失败了

java.util.NoSuchElementException: key not found: length

(然后我重读了这个(我正在运行1.2.0) http://spark.apache.org/docs/1.2.0/sql-programming-guide.html#supported-hive-features 并想知道Spark SQL是什么意思支持列出的蜂巢功能.)

问题:表达式和/或SQL语句中真正支持的长度运算符是什么？如果是,语法是什么？(奖励:是否有关于Spark SQL Expressions中解决的内容的特定文档,以及一般的语法是什么？)

谢谢!

我正在尝试使用@groupname和@group标签在我的库API文档中组织一个类的成员,但它不起作用(我正在使用sbt 0.13.11)

我的玩具build.sbt:

name := "test"
scalaVersion := "2.10.5"

我的玩具代码src/main/scala/test.scala:

package test
/** Test class
 *
 * @groupname print Printer
 * @groupname throw Thrower
 */
class TestClass {
  /** @group print */
  def trivialPrint: Unit = print("Hello")
  /** @group throw */
  def trivialError: Unit = throw new Exception("Hello")
}

sbt doc编译API文档,其中我的两个函数都在类的"Value Members"组中(参见截图).我究竟做错了什么？

我最近试图回答一个问题，当我意识到我不知道如何在 Spark DataFrames 的正则表达式中使用反向引用。

例如，使用 sed，我可以做到

> echo 'a1
b22
333' | sed "s/\([0-9][0-9]*\)/;\1/"                                                                                                   

a;1
b;22
;333

但是使用 Spark DataFrames 我不能：

val df = List("a1","b22","333").toDF("str")
df.show

+---+
|str|
+---+
| a1|
|b22|
|333|
+---+

val res = df  .withColumn("repBackRef",regexp_replace('str,"(\\d+)$",";\\1"))
res.show

+---+-----------+
|str|repBackRef|
+---+----------+
| a1|       a;1|
|b22|       b;1|
|333|        ;1|
+---+----------+

澄清一下：我不想要这种特殊情况下的结果，我想要一个与反向引用一样通用的解决方案，例如，sed.

还要注意 usingregexp_extract是缺乏的，因为它在没有匹配时表现不佳：

val res2 = df
  .withColumn("repExtract",regexp_extract('str,"^([A-z])+?(\\d+)$",2))
res2.show

这样您就被迫像我在上述答案中所做的那样，对每个模式使用一列进行提取。

谢谢！