Spark Dataset API - rejoindre

Je suis en train d'utiliser l'Étincelle Dataset API, mais je vais avoir quelques problèmes faisant une simple jointure.

Disons que j'ai deux jeu de données avec les champs: date | value, puis dans le cas de DataFrame mon rejoindre ressemblerait à:

val dfA : DataFrame
val dfB : DataFrame

dfA.join(dfB, dfB("date") === dfA("date") )

Cependant pour Dataset il est le .joinWith méthode, mais la même approche ne fonctionne pas:

val dfA : Dataset
val dfB : Dataset

dfA.joinWith(dfB, ? )

Qu'est-ce que l'argument requis par .joinWith ?

OriginalL'auteur mastro | 2016-04-06

27

À utiliser joinWith vous devez d'abord créer un DataSet, et deux d'entre eux. Pour créer un DataSet, vous devez créer une classe de cas qui correspond à votre schéma et appel DataFrame.as[T] où T est le cas de la classe. Donc:
```
case class KeyValue(key: Int, value: String)
val df = Seq((1,"asdf"),(2,"34234")).toDF("key", "value")
val ds = df.as[KeyValue]
//org.apache.spark.sql.Dataset[KeyValue] = [key: int, value: string]
```
Vous pouvez aussi sauter le cas de la classe et de l'utilisation d'un n-uplet:
```
val tupDs = df.as[(Int,String)]
//org.apache.spark.sql.Dataset[(Int, String)] = [_1: int, _2: string]
```
Alors si vous aviez une autre classe de cas /DF, comme ce dire:
```
case class Nums(key: Int, num1: Double, num2: Long)
val df2 = Seq((1,7.7,101L),(2,1.2,10L)).toDF("key","num1","num2")
val ds2 = df2.as[Nums]
//org.apache.spark.sql.Dataset[Nums] = [key: int, num1: double, num2: bigint]
```
Ensuite, bien que la syntaxe de join et joinWith sont similaires, les résultats sont différents:
```
df.join(df2, df.col("key") === df2.col("key")).show
//+---+-----+---+----+----+
//|key|value|key|num1|num2|
//+---+-----+---+----+----+
//|  1| asdf|  1| 7.7| 101|
//|  2|34234|  2| 1.2|  10|
//+---+-----+---+----+----+

ds.joinWith(ds2, df.col("key") === df2.col("key")).show
//+---------+-----------+
//|       _1|         _2|
//+---------+-----------+
//| [1,asdf]|[1,7.7,101]|
//|[2,34234]| [2,1.2,10]|
//+---------+-----------+
```
Comme vous pouvez le voir, joinWith laisse les objets intacts comme les pièces d'un tuple, tandis que join s'aplatit les colonnes dans un seul espace de noms. (Ce qui va causer des problèmes dans le cas ci-dessus, parce que le nom de la colonne "clé" est répété.)

Curieusement, je dois utiliser df.col("key") et df2.col("key") à créer les conditions pour rejoindre ds et ds2 -- si vous utilisez seulement col("key") sur chaque côté, il ne fonctionne pas, et ds.col(...) n'existe pas. À l'aide de l'original df.col("key") fait le truc, cependant.

explication détaillée. Juste une confusion. Est-il une meilleure façon d'écrire tapé condition de jointure. pour, par exemple, df.col("clé") peut-on avoir quelque chose de plus type de coffre que l'on peut résoudre la justesse de la "clé" au moment de la compilation.
Je suis complètement d'accord, basé sur cette syntaxe n'est pas dans la création du jeu de données, donc où est l'avantage? Je ne peut pas obtenir sur le fait qu'il n'y est pas de type alternative.. dommage!
il y a une solution dans ce réponse de "tapé rejoindre en Scala, avec Spark ensembles de données"

OriginalL'auteur David Griffin
6

De https://docs.cloud.databricks.com/docs/latest/databricks_guide/05%20Spark/1%20Intro%20Datasets.html

il semble que vous pourriez faire
```
dfA.as("A").joinWith(dfB.as("B"), $"A.date" === $"B.date" )
```
le lien ne fonctionne pas.

OriginalL'auteur Raghuram Onti Srinivasan
2

Dans l'exemple ci-dessus, vous pouvez essayer l'option en dessous -
- Définir une classe de cas pour la production de votre
  
  case class JoinOutput(key:Int, value:String, num1:Double, num2:Long)
- Joindre deux jeux de données avec les "Seq("clé")", cela vous aidera à éviter la double clé de colonnes dans le résultat. Qui va vous aider à appliquer le cas de la classe ou de récupérer les données dans la prochaine étape,
  
  ds.join(ds2, Seq("key")).as[JoinOutput] res27: org.apache.spark.sql.Dataset[JoinOutput] = [key: int, value: string ... 2 more fields]
  
  scala> ds.join(ds2, Seq("key")).as[JoinOutput].show +---+-----+----+----+ |key|value|num1|num2| +---+-----+----+----+ | 1| asdf| 7.7| 101| | 2|34234| 1.2| 10| +---+-----+----+----+
vous n'avez pas spécifiquement de répondre à la question, mais la Seq("clé") astuce m'a aidé

OriginalL'auteur Syntax

Vous devez vous connecter pour publier un commentaire.