Ausgabe
Ich bin neu bei Big Data und gehe eine vorhandene Codebasis durch und versuche, einen bestimmten Codeabschnitt zu verstehen. Ich war beeindruckt, als ich einen Join-Ausdruck verstand, der zum Verbinden zweier Datenrahmen verwendet wird, in denen Reduce als Teil des Ausdrucks verwendet wird. Hier ist der Code, der den Join-Ausdruck enthält
def joinOnMultipleColumns(leftDF: Dataset[Row], rightDF: Dataset[Row],
leftColumns: List[String], rightColumns: List[String]
): DataFrame = {
// Both leftColumns and rightColumns variables are of same length
val joinExpression = leftColumns
.zip(rightColumns)
.map { case (c1, c2) => col(c1) === col(c2) }
.reduce(_ && _) // -----> what does the map and reduce part mean here
rightDF.cache.show
leftDF.join(rightDF, joinExpression)
}
Bitte lassen Sie mich wissen, wenn ich weitere Informationen bereitstellen muss
Gemäß meiner Annahme erhält die Funktion zwei Spaltenlisten [t1_col1, t1_col2], [t2_col1, t2_col2] zusammen mit den beiden Datenrahmen
- zip würde zu (t1_col1, t2_col1), (t1_col2, t2_col2) führen
- Map und Reduce zusammen erstellen einen Join-Ausdruck mit col1===col2, aber ich bin mir nicht sicher, was genau passiert, und meine Annahme könnte auch völlig falsch sein
Kann mir bitte jemand helfen zu verstehen, was der Code tatsächlich tut?
Lösung
Map ist eine Funktion hoher Ordnung, die für die Transformation von Werten in einer Sammlung verantwortlich ist, indem sie die an map übergebene Funktion auf jeden Wert in der Sammlung anwendet. Lassen Sie uns in Ihren Code eintauchen:
-
Angenommen, Sie haben folgende Werte: leftColumns = [“col1_1”, “col1_2”] und rightColumn = [“col2_1”, “col2_2”]
-
Postleitzahl
leftColumns
.zip(rightColumns)
In diesem Schritt komprimieren wir zwei anfängliche Sammlungen von Zeichenfolgen in eine Sammlung von Tupeln:[("col1_1", "col2_1"),("col1_2", "col2_2")]
- Karte
.map { case (c1, c2) => col(c1) === col(c2) } //
Wie ich bereits sagte, müssen wir bei map eine Funktion auf jedes Element in der Sammlung anwenden. Das Element der Sammlung ist ein Tupel von (String,String). Funktion ist eine col(left)===col(right). Das bedeutet also, dass wir List[(String,String)] in List[Column] umwandeln (weil ===angewendet auf Spalte wird Spalte === in scaladoc zurückgeben )
Schließlich erhalten wir:[col("col1_1") === col("col2_1"), col("col1_2") === col("col2_2")]
- reduzieren
.reduce(_ && _)
Reduce ist dafür verantwortlich, die Sammlung von Werten in einen Wert zu falten. In diesem Fall falten wir List[Column] zu nur Column, indem wir den &&(Und-Operator anwenden, der Column zurückgibt, wenn wir ihn auf Column && in scaladoc anwenden
Endlich werden wir das bekommen: Dies col("col1_1") === col("col2_1") && col("col1_2") === col("col2_2")ist eine Reihe von Bedingungen für die Verbindung von 2 Datenrahmen
Beantwortet von – Artem Astashov
Antwort geprüft von – Mildred Charles (FixError Admin)
