從 Spark DataFrame 中的單個列派生多個列

Question

我有一個 DF，它有一個巨大的可解析元數據作為 Dataframe 中的單個字符串列，我們稱之為 DFA，與 ColmnA。

我想通過函數 ClassXYZ = Func1(ColmnA) 將該列 ColmnA 分成多列。 此函數返回一個 ClassXYZ 類，具有多個變量，現在必須將這些變量中的每一個映射到新的 Column，例如 ColmnA1、ColmnA2 等。

我將如何通過僅調用此 Func1 一次來將這些附加列從 1 個 Dataframe 轉換為另一個，而不必重復它來創建所有列。

如果我每次都調用這個巨大的函數來添加一個新列，它很容易解決，但這是我希望避免的。

請提供工作或偽代碼建議。

謝謝

桑傑

Answer 1

一般來說，你想要的不是直接可能的。 UDF 一次只能返回一列。 有兩種不同的方法可以克服此限制：

1. 返回復雜類型的列。 最通用的解決方案是StructType但您也可以考慮ArrayType或MapType 。

    import org.apache.spark.sql.functions.udf val df = Seq( (1L, 3.0, "a"), (2L, -1.0, "b"), (3L, 0.0, "c") ).toDF("x", "y", "z") case class Foobar(foo: Double, bar: Double) val foobarUdf = udf((x: Long, y: Double, z: String) => Foobar(x * y, z.head.toInt * y)) val df1 = df.withColumn("foobar", foobarUdf($"x", $"y", $"z")) df1.show // +---+----+---+------------+ // | x| y| z| foobar| // +---+----+---+------------+ // | 1| 3.0| a| [3.0,291.0]| // | 2|-1.0| b|[-2.0,-98.0]| // | 3| 0.0| c| [0.0,0.0]| // +---+----+---+------------+ df1.printSchema // root // |-- x: long (nullable = false) // |-- y: double (nullable = false) // |-- z: string (nullable = true) // |-- foobar: struct (nullable = true) // | |-- foo: double (nullable = false) // | |-- bar: double (nullable = false)

   這稍后可以很容易地展平，但通常沒有必要這樣做。

2. 切換到 RDD，重塑並重建 DF：

    import org.apache.spark.sql.types._ import org.apache.spark.sql.Row def foobarFunc(x: Long, y: Double, z: String): Seq[Any] = Seq(x * y, z.head.toInt * y) val schema = StructType(df.schema.fields ++ Array(StructField("foo", DoubleType), StructField("bar", DoubleType))) val rows = df.rdd.map(r => Row.fromSeq( r.toSeq ++ foobarFunc(r.getAs[Long]("x"), r.getAs[Double]("y"), r.getAs[String]("z")))) val df2 = sqlContext.createDataFrame(rows, schema) df2.show // +---+----+---+----+-----+ // | x| y| z| foo| bar| // +---+----+---+----+-----+ // | 1| 3.0| a| 3.0|291.0| // | 2|-1.0| b|-2.0|-98.0| // | 3| 0.0| c| 0.0| 0.0| // +---+----+---+----+-----+

Answer 2

假設在你的函數之后會有一個元素序列，舉個例子如下：

val df = sc.parallelize(List(("Mike,1986,Toronto", 30), ("Andre,1980,Ottawa", 36), ("jill,1989,London", 27))).toDF("infoComb", "age")
df.show
+------------------+---+
|          infoComb|age|
+------------------+---+
|Mike,1986,Toronto| 30|
| Andre,1980,Ottawa| 36|
|  jill,1989,London| 27|
+------------------+---+

現在你可以用這個 infoComb 做的是你可以開始拆分字符串並獲得更多列：

df.select(expr("(split(infoComb, ','))[0]").cast("string").as("name"), expr("(split(infoComb, ','))[1]").cast("integer").as("yearOfBorn"), expr("(split(infoComb, ','))[2]").cast("string").as("city"), $"age").show
+-----+----------+-------+---+
| name|yearOfBorn|   city|age|
+-----+----------+-------+---+
|Mike|      1986|Toronto| 30|
|Andre|      1980| Ottawa| 36|
| jill|      1989| London| 27|
+-----+----------+-------+---+

希望這可以幫助。

Answer 3

如果生成的列與原始列的長度相同，則可以使用withColumn函數並應用udf來創建全新的列。 在此之后，您可以刪除原始列，例如：

 val newDf = myDf.withColumn("newCol1", myFun(myDf("originalColumn")))
.withColumn("newCol2", myFun2(myDf("originalColumn"))
.drop(myDf("originalColumn"))

其中 myFun 是一個定義如下的 udf：

   def myFun= udf(
    (originalColumnContent : String) =>  {
      // do something with your original column content and return a new one
    }
  )

Answer 4

我選擇創建一個函數來展平一列，然后與 udf 同時調用它。

首先定義這個：

implicit class DfOperations(df: DataFrame) {

  def flattenColumn(col: String) = {
    def addColumns(df: DataFrame, cols: Array[String]): DataFrame = {
      if (cols.isEmpty) df
      else addColumns(
        df.withColumn(col + "_" + cols.head, df(col + "." + cols.head)),
        cols.tail
      )
    }

    val field = df.select(col).schema.fields(0)
    val newCols = field.dataType.asInstanceOf[StructType].fields.map(x => x.name)

    addColumns(df, newCols).drop(col)
  }

  def withColumnMany(colName: String, col: Column) = {
    df.withColumn(colName, col).flattenColumn(colName)
  }

}

那么用法很簡單：

case class MyClass(a: Int, b: Int)

val df = sc.parallelize(Seq(
  (0),
  (1)
)).toDF("x")

val f = udf((x: Int) => MyClass(x*2,x*3))

df.withColumnMany("test", f($"x")).show()

//  +---+------+------+
//  |  x|test_a|test_b|
//  +---+------+------+
//  |  0|     0|     0|
//  |  1|     2|     3|
//  +---+------+------+

Answer 5

這可以通過使用樞軸函數輕松實現

df4.groupBy("year").pivot("course").sum("earnings").collect()