Question

我正在做一个火花项目，需要建议如何以最佳方式解决以下问题：

我有一个数据框（Say MainDF），它拥有数百万条记录。格式如下（name：String，value：Int）。以下内容示例：

First,500,9999999
Second,100,499
Third,0,99
Unknown,-99999,0

我有另一个小文件，有4行记录，如下所示（className：String，minValue：Int，maxValue：Int）现在我需要根据min和max之间的值查找类名创建一个文件，输出如下：

Davi,130,Second
Joel,20,Third
Emma,500,First

我需要为MainDF中的每个值查找这个小文件，并根据小File.Example的值范围添加Class名称：

//Main Data read, millions of records
val MainData = sc.textFile("/mainfile.csv")
case class MainType(Name:String,value:Int)
val MainDF = MainData .map(line => line.split(",")).map(e =>MainType(e(0),e(1).toInt))).toDF
MainDF.registerTempTable("MainTable")
val refData = sc.broadast( sc.textFile("/refdata.csv"))
case class refDataType (className:String,minValue:Int,maxValue:Int)
//ref data, just 4 records
val refRDD = refData.map(line=> line.split(",")).map( e => refDataType ( e(0) , e(1).toInt, e(2).toInt))

这是我写的代码：

{{1}}

我想我必须在这里编写一个UDF，但我不知道如何在UDF中使用Dataframe，或者有没有办法在spark scala中执行此操作

Answer 1

您可以使用textFile将文件作为RDD阅读，收集它，因为它非常小（可能会根据您的要求进行广播）。

通过收集RDD获得阵列后，您可以创建Range，然后创建UDF以检查您的值是否在该范围内。

val rdd = sc.parallelize(Array(
("First",500,9999999),
("Second",100,499),
("Third",0,99),
("Unknown",-99999,0)
))

val dataArr = rdd.map{ case (className, min, max) => 
                       (className, Range(min, max) )  }.collect
// First Element will be the Class Name
// Second will be the Range(min, max)
// sc.broadcast(dataArr) here

val getClassName = udf {(x: Int) => { 
                  dataArr.map{ e => 
                        if (e._2.contains(x) ) e._1.toString 
                        else null.asInstanceOf[String] }
                  .filter(_ != null )
                  .apply(0) }}

df.withColumn("ClassName", getClassName($"VALUE") ).show
+----+-----+---------+
|NAME|VALUE|ClassName|
+----+-----+---------+
|Davi|  130|   Second|
|Joel|   20|    Third|
|Emma|  500|    First|
+----+-----+---------+

我很肯定可能有更好的解决方案。

Answer 2

这里最简单的方法是使用csv数据源读取这两个文件并使用标准SparkSQL加入它们，如下所示：

import org.apache.spark.sql.types.{StructType, StructField, StringType, IntegerType}
val mainSchema = StructType(Seq(StructField("name", StringType, false), 
StructField("value", IntegerType, false)))
val mainDf = spark.read.schema(mainSchema).csv("/tmp/b.txt")
val lookupSchema = StructType(Seq(StructField("class_name", StringType, false), StructField("min_value", IntegerType, false), 
StructField("max_value", IntegerType, false)))
val lookupDf = spark.read.schema(lookupSchema).csv("/tmp/a.txt")
val result = mainDf.join(lookupDf, $"value" <= $"max_value" && $"value" > $"min_value")
result.show()

我不确定最有效的方式是这个还是@philantrovert建议的方式（这可能还取决于您使用的Spark版本）。你应该尝试两种方式并自己决定。

火花从一个小文件中查找

2 个答案: