Comment joindre les deux DataFrames de Scala et Apache Spark?

Il y a deux DataFrames (Scala, Apache Spark 1.6.1)

1) Correspond à

         MatchID | Player1    |  Player2 
         --------------------------------
               1 | John Wayne | John Doe
               2 | Ive Fish   | San Simon

2) Les Données Personnelles

              Player     |  BirthYear 
              --------------------------------
              John Wayne | 1986
              Ive Fish   | 1990
              San Simon  | 1974
              john Doe   | 1995

Comment pourrait créer un nouveau DataFrame avec "Annéenaissance" pour les deux joueurs

         MatchID | Player1    |  Player2  | BYear_P1 |BYear_P2 | Diff
         -------------------------------------------------------------
               1 | John Wayne | John Doe  |   1986   | 1995    |  9  
               2 | Ive Fish   | San Simon |   1990   | 1974    |  16

?

J'ai essayé

    val df = MatchesDF.join(PersonalDF, MatchesDF("Player1") === PersonalDF("Player"))

puis rejoindre à nouveau pour le second joueur

    val resDf = df.join(PersonalDF, df("Player2") === PersonalDF("Player"))

mais c'est TRÈS coûteux en temps de l'opération.

Peut être une autre façon de faire de Scala et Apache Spark?

OriginalL'auteur gmlvsv | 2016-04-22

  1. 11

    Cela devrait mieux fonctionner:

    case class Match(matchId: Int, player1: String, player2: String)
case class Player(name: String, birthYear: Int)

val matches = Seq(
  Match(1, "John Wayne", "John Doe"),
  Match(2, "Ive Fish", "San Simon")
)

val players = Seq(
  Player("John Wayne", 1986),
  Player("Ive Fish", 1990),
  Player("San Simon", 1974),
  Player("John Doe", 1995)
)

val matchesDf = sqlContext.createDataFrame(matches)
val playersDf = sqlContext.createDataFrame(players)

matchesDf.registerTempTable("matches")
playersDf.registerTempTable("players")

sqlContext.sql(
  "select matchId, player1, player2, p1.birthYear, p2.birthYear, abs(p1.birthYear-p2.birthYear) " +
  "from matches m inner join  players p1 inner join players p2 " +
  "where m.player1 = p1.name and m.player2 = p2.name").show()

+-------+----------+---------+---------+---------+---+
|matchId|   player1|  player2|birthYear|birthYear|_c5|
+-------+----------+---------+---------+---------+---+
|      1|John Wayne| John Doe|     1986|     1995|  9|
|      2|  Ive Fish|San Simon|     1990|     1974| 16|
+-------+----------+---------+---------+---------+---+

    Je n'ai pas trouvé le moyen d'exprimer une jointure de 3 tables en Scala DSL.

    de nouveau à faire des jointures, comment fait-il faire mieux?
    Cette course d'environ 2 minutes pour les Matchs de la table avec ~10000 lignes et table de Joueur avec ~700 dossiers
    utiliser les données des cadres pour vos jointures au lieu de la plaine sql pour de meilleures performances.
    Face à semblable question : stackoverflow.com/questions/38149483/... une idée ?
    si vous avez plus de 2 DataFrame vous souhaitez faire adhérer. Serait-il plus rapide de le faire en une seule requête ou plusieurs rejoindre / select ?

    OriginalL'auteur Vitalii Kotliarenko

  2. 7

    C'est une solution à l'aide de la spark dataframe fonctions:

    import sqlContext.implicits._
import org.apache.spark.sql.Row
import org.apache.spark.sql.functions.abs
val matches = sqlContext.sparkContext.parallelize(Row(1, "John Wayne", "John Doe"), Row(2, "Ive Fish", "San Simon")))
val players = sqlContext.sparkContext.parallelize(Seq(
Row("John Wayne", 1986),
Row("Ive Fish", 1990),
Row("San Simon", 1974),
Row("John Doe", 1995)
))
val matchesDf = sqlContext.createDataFrame(matches, StructType(Seq(
StructField("matchId", IntegerType, nullable = false),
StructField("player1", StringType, nullable = false),
StructField("player2", StringType, nullable = false)))
).as('matches)
val playersDf = sqlContext.createDataFrame(players, StructType(Seq(
StructField("player", StringType, nullable = false),
StructField("birthYear", IntegerType, nullable = false)
))).as('players)
matchesDf
.join(playersDf, $"matches.player1" === $"players.player")
.select($"matches.matchId" as "matchId", $"matches.player1" as "player1", $"matches.player2" as "player2", $"players.birthYear" as "player1BirthYear")
.join(playersDf, $"player2" === $"players.player")
.select($"matchId" as "MatchID", $"player1" as "Player1", $"player2" as "Player2", $"player1BirthYear" as "BYear_P1", $"players.birthYear" as "BYear_P2")
.withColumn("Diff", abs('BYear_P2.minus('BYear_P1)))
.show()
+-------+----------+---------+--------+--------+----+
|MatchID|   Player1|  Player2|BYear_P1|BYear_P2|Diff|
+-------+----------+---------+--------+--------+----+
|      1|John Wayne| John Doe|    1986|    1995|   9|
|      2|  Ive Fish|San Simon|    1990|    1974|  16|
+-------+----------+---------+--------+--------+----+

    OriginalL'auteur Sohum Sachdev

  3. 4
    val df = left.join(right, Seq("name"))
display(df)
    Bonjour et bienvenue sur StackOverflow. S'il vous plaît ajouter quelques explications de votre réponse, de sorte qu'il devient de plus en plus précieux pour les autres utilisateurs. Voir stackoverflow.com/help/how-to-answer
    Cette information est insuffisante pour fournir toute sorte d'aide. Ce qui est "de gauche"? Ce qui est "juste"? Veuillez reformuler votre réponse..
    Il n'y a pas une telle fonction d'affichage dans Spark Dataframe (Scala de mise en œuvre)

    OriginalL'auteur gaurhari dass