Scala 如何在Spark中为Dataset实现Seq.grouped（size:Int）：Seq[Seq[A]]

我想尝试实现

def-grouped（size:Int）：迭代器[Repr]

，该迭代器在Spark中为

数据集

所用

因此，输入应该是

ds:Dataset[A]，size:Int

和输出

Seq[Dataset[A]

，其中输出中的

Dataset[A]

每个都不能大于

size

我应该如何进行？我尝试了

重新分区

和

映射分区

，但我不确定从那里走到哪里

多谢各位

---

编辑：我在

RDD

中找到了

glom

方法，但它产生了一个

RDD[Array[a]]

我如何从这个方向转到另一个方向

Array[RDD[a]]

这是我找到的解决方案，但我不确定它是否能可靠工作：

  override protected def batch[A](
    input:     Dataset[A],
    batchSize: Int
  ): Seq[Dataset[A]] = {
    val count = input.count()
    val partitionQuantity = Math.ceil(count / batchSize).toInt

    input.randomSplit(Array.fill(partitionQuantity)(1.0 / partitionQuantity), seed = 0)
  }

---

给你，你想要的东西

/*
{"countries":"pp1"}
{"countries":"pp2"}
{"countries":"pp3"}
{"countries":"pp4"}
{"countries":"pp5"}
{"countries":"pp6"}
{"countries":"pp7"}
   */

import org.apache.spark.rdd.RDD
import org.apache.spark.sql._
import org.apache.spark.sql.expressions.Window
import org.apache.spark.sql.functions._
import org.apache.spark.{SparkConf, SparkContext};


object SparkApp extends App {

  override def main(args: Array[String]): Unit = {

    val conf = new SparkConf().setAppName("Simple Application").setMaster("local").set("spark.ui.enabled", "false")
    val sc = new SparkContext(conf)
    val sqlContext = new SQLContext(sc)

    val dataFrame: DataFrame = sqlContext.read.json("/data.json")

    val k = 3

    val windowSpec = Window.partitionBy("grouped").orderBy("countries")

    val newDF = dataFrame.withColumn("grouped", lit("grouping"))

    var latestDF = newDF.withColumn("row", row_number() over windowSpec)

    val totalCount = latestDF.count()
    var lowLimit = 0
    var highLimit = lowLimit + k

    while(lowLimit < totalCount){
      latestDF.where(s"row <= $highLimit and row > $lowLimit").show(false)
      lowLimit = lowLimit + k
      highLimit = highLimit + k
    }
  }
}

/*
{“国家”：“pp1”}
{“国家”：“pp2”}
{“国家”：“pp3”}
{“国家”：“pp4”}
{“国家”：“pp5”}
{“国家”：“pp6”}
{“国家”：“第7页”}
*/
导入org.apache.spark.rdd.rdd
导入org.apache.spark.sql_
导入org.apache.spark.sql.expressions.Window
导入org.apache.spark.sql.functions_
导入org.apache.spark.{SparkConf，SparkContext}；
对象SparkApp扩展应用程序{
覆盖def main（参数：数组[字符串]）：单位={
val conf=new SparkConf（）.setAppName（“简单应用程序”）.setMaster（“本地”）.set（“spark.ui.enabled”、“false”）
val sc=新的SparkContext（配置）
val sqlContext=新的sqlContext（sc）
val dataFrame:dataFrame=sqlContext.read.json（“/data.json”）
val k=3
val windowSpec=Window.partitionBy（“分组”）.orderBy（“国家”）
val newDF=dataFrame.withColumn（“分组”），lit（“分组”）
var latestDF=newDF.withColumn（“行”，windowSpec上的行号（））
val totalCount=latestDF.count（）
var下限=0
var上限=下限+k
while（下限<总计数）{
latestDF.where（s“row$lowLimit”）.show（false）
下限=下限+k
上限=上限+k
}
}
}

正如您所怀疑的，它不可靠。randomSplit不保证批大小相等，因此将有批大于给定大小。