Comment mettre à jour la colonne en fonction d'une condition (une valeur dans un groupe)?

J'ai le texte suivant df:

+---+----+-----+
|sno|dept|color|
+---+----+-----+
|  1|  fn|  red|
|  2|  fn| blue|
|  3|  fn|green|
+---+----+-----+

Si la couleur l'une des valeurs de la colonne est red, puis j'ai toutes les valeurs de la colonne de couleur doit être mis à jour pour être red, comme ci-dessous:

+---+----+-----+
|sno|dept|color|
+---+----+-----+
|  1|  fn|  red|
|  2|  fn|  red|
|  3|  fn|  red|
+---+----+-----+

Je ne pouvais pas le comprendre. S'il vous plaît aider; j'ai essayé le code suivant:

val gp=jdbcDF.filter($"dept".contains("fn"))
     //.withColumn("newone",when($"dept"==="fn","RED").otherwise("NULL"))
    gp.show()
gp.map(
  row=>{
    val row1=row.getAs[String](1)
    var row2=row.getAs[String](2)
    val make=if(row1 =="fn") row2="red"
    Row(row(0),row(1),make)
  }
).collect().foreach(println)

InformationsquelleAutor senthil kumar p | 2016-11-19

10

Donné:
```
val df = Seq(
  (1, "fn", "red"),
  (2, "fn", "blue"),
  (3, "fn", "green"),
  (4, "aa", "blue"),
  (5, "aa", "green"),
  (6, "bb", "red"),
  (7, "bb", "red"),
  (8, "aa", "blue")
).toDF("id", "fn", "color")
```
De faire le calcul:
```
val redOrNot = df.groupBy("fn")
  .agg(collect_set('color) as "values")
  .withColumn("hasRed", array_contains('values, "red"))

//gives null for no option
val colorPicker = when('hasRed, "red")
val result = df.join(redOrNot, "fn")
  .withColumn("resultColor", colorPicker) 
  .withColumn("color", coalesce('resultColor, 'color)) //skips nulls that leads to the answer
  .select('id, 'fn, 'color)
```
La result se présente comme suit (qui semble être une réponse):
```
scala> result.show
+---+---+-----+
| id| fn|color|
+---+---+-----+
|  1| fn|  red|
|  2| fn|  red|
|  3| fn|  red|
|  4| aa| blue|
|  5| aa|green|
|  6| bb|  red|
|  7| bb|  red|
|  8| aa| blue|
+---+---+-----+
```
Vous pouvez la chaîne when opérateurs et ont une valeur par défaut avec otherwise. Consulter le scaladoc de quand de l'opérateur.

Je pense que vous pourriez faire quelque chose de très similaire (et peut-être la plus efficace) à l'aide fenêtré opérateurs ou définis par l'utilisateur fonctions d'agrégation (udaf, nous), mais...eh bien...n'avez pas actuellement de savoir comment le faire. Laissant le commentaire ici pour en inspirer d'autres 😉

p.s. Appris beaucoup de choses! Merci pour l'idée!
- J'espère que je peux le remplacer lors de l'UDF, pour que je puisse retourner n'importe quelle couleur basée sur une certaine logique.
- Voir la mise à jour. Vous devez être prudent avec un UDF comme Spark SQL de l'optimiseur de requête peut ne pas bons(er) de l'optimisation.
- cette syntaxe est possible df.withColumn("Green_Ind", when($"color" === "Green", 1).when($"color" === "Red", 1).otherwise(0))
- Que sur les fonctions de la fenêtre. Bien que votre réponse est la meilleure, je pense qu'il peut également être réalisé avec les fonctions de la Fenêtre n'est-il pas?
- Vous vous demandez encore, il n'est pas possible d'atteindre cet objectif sans join, que si les données est énorme, oui, il est possible d'utiliser la diffusion de rejoindre pour la première DF si.
InformationsquelleAutor Jacek Laskowski

Solution efficace qui ne nécessite pas cher groupement:

//All groups with `red`
df.where($"color" === "red").select($"fn".alias("fn_")).distinct
  //Join with input
  .join(df.as("df"), $"fn" === $"fn_", "rightouter")
  //Replace `color`
  .withColumn("color", when($"fn_"isNull, $"color").otherwise(lit("red")))
  .drop("fn_")

- Ce une bonne réponse. Jacek mentionne également dans la accepté de répondre.

InformationsquelleAutor e9f20079

4

Vous sont conditionnellement à jour le DataFrame si elle satisfait à une certaine propriété. Dans ce cas, la propriété est "la couleur de la colonne contient "rouge"". Le idiomatiques façon de l'exprimer est de filtrer le prédicat et, ensuite, de déterminer si les lignes de la satisfaire. Il n'est pas nécessaire pour une jointure.
```
import org.apache.spark.sql.functions.lit
import org.apache.spark.sql.DataFrame

def makeAllRedIfAnyAreRed(df: DataFrame) = {
    val containsRed = df.filter(df("color") === "red").count() > 0
    if (containsRed) df.withColumn("color", lit("red")) else df
}
```
InformationsquelleAutor Daniel Shields

Car il pourrait y avoir quelques lignes dans filtré dataframe, je suis en ajoutant de la solution avec isin() et .withColumn() combinaison.

Échantillon DataFrame

val df = Seq(
  (1, "fn", "red"),
  (2, "fn", "blue"),
  (3, "fn", "green"),
  (4, "aa", "blue"),
  (5, "aa", "green"),
  (6, "bb", "red"),
  (7, "bb", "red"),
  (8, "aa", "blue")
).toDF("id", "dept", "color")

Maintenant, nous allons choisir seulement depts qui ont au moins un rouge color ligne et de le placer dans broadcast variable comme ci-dessous.

val depts = sc.broadcast(df.filter($"color" === "red").select(collect_set("dept")).first.getSeq[String](0)))

Mise à jour rouge couleur pour filtrée depts enregistrements.

isin() prend un vararg afin de convertir la liste de vararg (depts.value:_*)

//creating new column by giving diff name (clr) to see the diff
val result = df.withColumn("clr", when($"dept".isin(depts.value:_*),lit("red"))
                    .otherwise($"color"))

result.show()

+---+----+-----+-----+
| id|dept|color|  clr|
+---+----+-----+-----+
|  1|  fn|  red|  red|
|  2|  fn| blue|  red|
|  3|  fn|green|  red|
|  4|  aa| blue| blue|
|  5|  aa|green|green|
|  6|  bb|  red|  red|
|  7|  bb|  red|  red|
|  8|  aa| blue| blue|
+---+----+-----+-----+

InformationsquelleAutor mrsrinivas

Étincelle 2.2.0:
Exemple de Dataframe ( prises à partir des exemples ci-dessus)