迭代Spark数据帧中的行和列

Question

我有以下动态创建的Spark数据框：

val sf1 = StructField("name", StringType, nullable = true)
val sf2 = StructField("sector", StringType, nullable = true)
val sf3 = StructField("age", IntegerType, nullable = true)

val fields = List(sf1,sf2,sf3)
val schema = StructType(fields)

val row1 = Row("Andy","aaa",20)
val row2 = Row("Berta","bbb",30)
val row3 = Row("Joe","ccc",40)

val data = Seq(row1,row2,row3)

val df = spark.createDataFrame(spark.sparkContext.parallelize(data), schema)

df.createOrReplaceTempView("people")
val sqlDF = spark.sql("SELECT * FROM people")

现在，我需要迭代sqlDF中的每一行和每列来打印每一列，这是我的尝试：

sqlDF.foreach { row =>
  row.foreach { col => println(col) }
}

row是类型Row，但不可迭代，这就是为什么此代码在row.foreach中抛出编译错误的原因。如何迭代Row中的每一列？

Answer 1

您可以使用Row将Seq转换为toSeq。转到Seq后，您可以像往常一样使用foreach，map或任何您需要的内容进行迭代

    sqlDF.foreach { row => 
           row.toSeq.foreach{col => println(col) }
    }

<强>输出：

Berta
bbb
30
Joe
Andy
aaa
20
ccc
40

Answer 2

考虑您有一个Dataframe，如下所示

+-----+------+---+
| name|sector|age|
+-----+------+---+
| Andy|   aaa| 20|
|Berta|   bbb| 30|
|  Joe|   ccc| 40|
+-----+------+---+

要循环 Dataframe 并从 Dataframe 中提取元素，可以选择以下方法之一。

方法1-使用foreach循环

不可能直接使用foreach循环来循环数据帧。为此，首先必须使用case class定义数据框架的架构，然后必须为数据框架指定该架构。

import spark.implicits._
import org.apache.spark.sql._
case class cls_Employee(name:String, sector:String, age:Int)
val df = Seq(cls_Employee("Andy","aaa", 20), cls_Employee("Berta","bbb", 30), cls_Employee("Joe","ccc", 40)).toDF()
df.as[cls_Employee].take(df.count.toInt).foreach(t => println(s"name=${t.name},sector=${t.sector},age=${t.age}"))

请在下面查看结果：

方法2-使用rdd循环

在您的数据框顶部使用rdd.collect。 row变量将包含rdd行类型的 Dataframe 的每一行。要从一行中获取每个元素，请使用row.mkString(",")，它将以逗号分隔的值包含每一行的值。使用split函数（内置函数），您可以访问带有索引的rdd行的每个列值。

for (row <- df.rdd.collect)
{   
    var name = row.mkString(",").split(",")(0)
    var sector = row.mkString(",").split(",")(1)
    var age = row.mkString(",").split(",")(2)   
}

请注意，此方法有两个缺点。
1.如果列值中有,，则数据将错误地拆分到相邻列。
2. rdd.collect是action，它会将所有数据返回到驱动程序的内存中，其中驱动程序的内存可能不足以容纳数据，最终导致应用程序失败。

我建议使用方法1 。

方法3-使用位置并选择

您可以直接使用where和select进行内部循环并查找数据。由于不应将Index抛出超出范围的异常，因此使用if条件

if(df.where($"name" === "Andy").select(col("name")).collect().length >= 1)
    name = df.where($"name" === "Andy").select(col("name")).collect()(0).get(0).toString

方法4-使用临时表

您可以将数据帧注册为临时表，并将其存储在spark的内存中。然后，您可以像其他数据库一样使用选择查询来查询数据，然后收集并保存在变量中

df.registerTempTable("student")
name = sqlContext.sql("select name from student where name='Andy'").collect()(0).toString().replace("[","").replace("]","")

Answer 3

您应该在mkString上使用Row：

sqlDF.foreach { row =>
  println(row.mkString(",")) 
}

但请注意，这将打印在执行程序JVM的内部，所以通常你不会看到输出（除非你使用master = local）

Answer 4

sqlDF.foreach对我不起作用，但@Sarath Avanavu答案的方法1起作用，但有时它还在按记录的顺序进行播放。

我发现了另一种可行的方法

df.collect().foreach { row =>
   println(row.mkString(","))
}

Answer 5

您应该遍历分区，以使Spark可以并行处理数据，并且可以在分区内的每一行上执行foreach。

如果需要，您可以进一步将分区中的数据分为几批

sqlDF.foreachPartition { partitionedRows: Iterator[Model1] =>     
  if (partitionedRows.take(1).nonEmpty) {
       partitionedRows.grouped(numberOfRowsPerBatch).foreach { batch =>
        batch.foreach { row => 
        .....

Answer 6

简单的收集结果，然后申请foreach

df.collect().foreach(println)

Answer 7

让我们假设 resultDF 是数据框。

val resultDF = // DataFrame //
var itr = 0
val resultRow = resultDF.count
val resultSet = resultDF.collectAsList
var load_id = 0
var load_dt = ""
var load_hr = 0

while ( itr < resultRow ){
    col1 = resultSet.get(itr).getInt(0)
    col2 = resultSet.get(itr).getString(1) // if column is having String value
    col3 = resultSet.get(itr).getLong(2) // if column is having Long value

    // Write other logic for your code //

    itr = itr + 1
}

Answer 8

这对我来说很好

sqlDF.collect().foreach(row => row.toSeq.foreach(col => println(col)))