webdevqa.jp.net

Scala with Spark Datasetsで型付き結合を実行する

Sparkコンパイル時に分析エラーと構文エラーを与え、ハードコードされた名前/番号の代わりにゲッターで作業できるようにするため、データセットが好きです。ほとんどの計算はデータセットのレベルAPI:たとえば、RDD行のデータフィールドを使用するよりも、データセット型オブジェクトにアクセスすることで、agg、select、sum、avg、map、filter、またはgroupBy操作を実行する方がはるかに簡単です。

しかし、これには結合操作がありません、私はこのような結合を行うことができることを読みました

ds1.joinWith(ds2, ds1.toDF().col("key") === ds2.toDF().col("key"), "inner")

しかし、ケースクラスインターフェイスを介してそれを行うことを好むので、それは私が望むものではありません。

ds1.joinWith(ds2, ds1.key === ds2.key, "inner")

現時点での最良の代替案は、ケースクラスの隣にオブジェクトを作成し、この関数を与えて正しい列名を文字列として提供するようです。したがって、コードの最初の行を使用しますが、ハードコードされた列名の代わりに関数を配置します。しかし、それは十分にエレガントではありません。

ここで他のオプションについて誰かにアドバイスできますか?目標は、実際の列名から抽象化して、できればケースクラスのゲッターを介して動作することです。

私はSpark 1.6.1およびScala 2.10

28
Sparky

観察

Spark SQLは、結合条件が等値演算子に基づいている場合にのみ、結合を最適化できます。これは、等価結合と非等価結合を別々に検討できることを意味します。

等結合

Equijoinは、両方のDatasetsを(キー、値)タプルにマッピングし、キーに基づいて結合を実行し、結果を再形成することにより、タイプセーフな方法で実装できます。

import org.Apache.spark.sql.Encoder
import org.Apache.spark.sql.Dataset

def safeEquiJoin[T, U, K](ds1: Dataset[T], ds2: Dataset[U])
    (f: T => K, g: U => K)
    (implicit e1: Encoder[(K, T)], e2: Encoder[(K, U)], e3: Encoder[(T, U)]) = {
  val ds1_ = ds1.map(x => (f(x), x))
  val ds2_ = ds2.map(x => (g(x), x))
  ds1_.joinWith(ds2_, ds1_("_1") === ds2_("_1")).map(x => (x._1._2, x._2._2))
}

非等結合

関係代数演算子を使用してR⋈θS =σθ(R×S)として表現し、直接コードに変換できます。

Spark 2.0

crossJoinを有効にし、joinWithを平等に等しい述語とともに使用します。

spark.conf.set("spark.sql.crossJoin.enabled", true)

def safeNonEquiJoin[T, U](ds1: Dataset[T], ds2: Dataset[U])
                         (p: (T, U) => Boolean) = {
  ds1.joinWith(ds2, lit(true)).filter(p.tupled)
}

Spark 2.1

crossJoinメソッドを使用します。

def safeNonEquiJoin[T, U](ds1: Dataset[T], ds2: Dataset[U])
    (p: (T, U) => Boolean)
    (implicit e1: Encoder[Tuple1[T]], e2: Encoder[Tuple1[U]], e3: Encoder[(T, U)]) = {
  ds1.map(Tuple1(_)).crossJoin(ds2.map(Tuple1(_))).as[(T, U)].filter(p.tupled)
}

case class LabeledPoint(label: String, x: Double, y: Double)
case class Category(id: Long, name: String)

val points1 = Seq(LabeledPoint("foo", 1.0, 2.0)).toDS
val points2 = Seq(
  LabeledPoint("bar", 3.0, 5.6), LabeledPoint("foo", -1.0, 3.0)
).toDS
val categories = Seq(Category(1, "foo"), Category(2, "bar")).toDS

safeEquiJoin(points1, categories)(_.label, _.name)
safeNonEquiJoin(points1, points2)(_.x > _.x)

ノート

  • これらのメソッドは、直接joinWithアプリケーションと質的に異なり、高価なDeserializeToObject/SerializeFromObject変換を必要とすることに注意してください(直接joinWithはデータの論理演算)。

    これは Spark 2.0 Dataset vs DataFrame で説明されている動作に似ています。

  • Spark SQL API frameless に限定されない場合は、Datasetsの興味深いタイプセーフな拡張機能を提供します(今日ではSpark 2.0)のみをサポートします:

    import frameless.TypedDataset
    
    val typedPoints1 = TypedDataset.create(points1)
    val typedPoints2 = TypedDataset.create(points2)
    
    typedPoints1.join(typedPoints2, typedPoints1('x), typedPoints2('x))
    
  • Dataset AP​​Iは1.6では安定しないため、そこで使用するのは理にかなっていないと思います。

  • もちろん、このデザインと説明的な名前は必要ありません。型クラスを簡単に使用して、このメソッドを暗黙的にDatasetに追加できます。組み込みシグネチャとの競合がないため、両方をjoinWithと呼ぶことができます。

29
user6910411

また、タイプセーフでないSpark APIのもう1つの大きな問題は、2つのDatasetsを結合すると、DataFrameが得られることです。元の2つのデータセットから。

val a: Dataset[A]
val b: Dataset[B]

val joined: Dataframe = a.join(b)
// what would be great is 
val joined: Dataset[C] = a.join(b)(implicit func: (A, B) => C)
1
linehrr