Diviser 1 colonne en 3 colonnes en scala

J'ai un dataframe Spark utilisation de scala qui a une colonne que j'ai besoin de split.

scala> test.show
+-------------+
|columnToSplit|
+-------------+
|        a.b.c|
|        d.e.f|
+-------------+

J'ai besoin de cette colonne de fractionnement pour ressembler à ceci:

+--------------+
|col1|col2|col3|
|   a|   b|   c|
|   d|   e|   f|
+--------------+

Je suis en utilisant Étincelle 2.0.0

Grâce

source d'informationauteur Matt Maurer

  1. 27

    Essayer:

    df.withColumn("_tmp", split($"columnToSplit", "\\.")).select(
  $"_tmp".getItem(0).as("col1"),
  $"_tmp".getItem(1).as("col2"),
  $"_tmp".getItem(2).as("col3")
).drop("_tmp")
  2. 11

    Une solution qui évite de sélectionner une partie. Cette fonction est utile lorsque vous voulez juste ajouter de nouvelles colonnes:

    case class Message(others: String, text: String)

val r1 = Message("foo1", "a.b.c")
val r2 = Message("foo2", "d.e.f")

val records = Seq(r1, r2)
val df = spark.createDataFrame(records)

df.withColumn("col1", split(col("text"), "\\.").getItem(0))
  .withColumn("col2", split(col("text"), "\\.").getItem(1))
  .withColumn("col3", split(col("text"), "\\.").getItem(2))
  .show(false)

+------+-----+----+----+----+
|others|text |col1|col2|col3|
+------+-----+----+----+----+
|foo1  |a.b.c|a   |b   |c   |
|foo2  |d.e.f|d   |e   |f   |
+------+-----+----+----+----+
  3. 7

    À le faire par programmation, vous pouvez créer une séquence d'expressions avec (0 until 3).map(i => col("temp").getItem(i).as(s"col$i")) (suppose que vous avez besoin de 3 colonnes comme résultat) et ensuite l'appliquer à select avec : _* syntaxe:

    df.withColumn("temp", split(col("columnToSplit"), "\\.")).select(
    (0 until 3).map(i => col("temp").getItem(i).as(s"col$i")): _*
).show
+----+----+----+
|col0|col1|col2|
+----+----+----+
|   a|   b|   c|
|   d|   e|   f|
+----+----+----+

    De garder toutes les colonnes:

    df.withColumn("temp", split(col("columnToSplit"), "\\.")).select(
    col("*") +: (0 until 3).map(i => col("temp").getItem(i).as(s"col$i")): _*
).show
+-------------+---------+----+----+----+
|columnToSplit|     temp|col0|col1|col2|
+-------------+---------+----+----+----+
|        a.b.c|[a, b, c]|   a|   b|   c|
|        d.e.f|[d, e, f]|   d|   e|   f|
+-------------+---------+----+----+----+
  4. 1

    Ceci ajoute des colonnes à l'origine DataFrame et ne pas utiliser selectet seulement divise une fois en utilisant une temporaire de la colonne:

    import spark.implicits._

df.withColumn("_tmp", split($"columnToSplit", "\\."))
  .withColumn("col1", $"_tmp".getItem(0))
  .withColumn("col2", $"_tmp".getItem(1))
  .withColumn("col3", $"_tmp".getItem(2))
  .drop("_tmp")