Regex 数据帧列上的spark scala模式匹配

我是R出身。我可以在R中的数据帧列上实现模式搜索，但现在在spark scala中难以实现。任何帮助都将不胜感激

问题陈述被分解成细节，只是为了恰当地描述它 DF:

我正在寻找一个模式搜索UDF，它返回模式的所有匹配项，然后从第二列返回相应的Freq值

例如：对于pattern

135322

，我想找出第一个col案例中的所有匹配项。它应该从Freq col返回相应的Freq number。 比如

265,36,18,11,8,4,2

对于模式

112107112107

它应该只返回

7

，因为有一个匹配的模式

这就是最终结果的样子

          Case                           Freq   results
            135322                       265    256+36+18+11+8+4+2
     183201,135322                        36    36+4+2
     135322,135322                        18    18+4
     135322,121200                        11    11+2
     121200,135322                         8    8+2
     112107,112107                         7    7
     183201,135322,135322                  4    4
     112107,135322,183201,121200,80000     2    2

到目前为止，我尝试的是：

val text= DF.select("case").collect().map(_.getString(0)).mkString("|")

 //search function for pattern search

 val valsum = udf((txt: String, pattern : String)=> { 
    txt.split("\\|").count(_.contains(pattern)) 
  } )

 //apply the UDF on the first col 
 val dfValSum = DF.withColumn("results", valsum( lit(text),DF("case")))  

这个有效

import common.Spark.sparkSession
import java.util.regex.Pattern
import util.control.Breaks._

object playground extends App {

  import org.apache.spark.sql.functions._

  val pattern = "135322,121200" // Pattern you want to search for

  // udf declaration
  val coder: ((String, String) => Boolean) = (caseCol: String, pattern: String) =>
    {
      var result = true
      val splitPattern = pattern.split(",")
      val splitCaseCol = caseCol.split(",")
      var foundAtIndex = -1

      for (i <- 0 to splitPattern.length - 1) {
        breakable {
          for (j <- 0 to splitCaseCol.length - 1) {
            if (j > foundAtIndex) {
              println(splitCaseCol(j))
              if (splitCaseCol(j) == splitPattern(i)) {
                result = true
                foundAtIndex = j
                break
              } else result = false
            } else result = false
          }
        }
      }
      println(caseCol, result)
      (result)
    }

  // registering the udf  
  val udfFilter = udf(coder)

  //reading the input file
  val df = sparkSession.read.option("delimiter", "\t").option("header", "true").csv("output.txt")

  //calling the function and aggregating
  df.filter(udfFilter(col("Case"), lit(pattern))).agg(lit(pattern), sum("Freq")).toDF("pattern","sum").show

}

如果输入是

1353221353221322

输出为

+-------------+----+
|      pattern| sum|
+-------------+----+
|135322,121200|13.0|
+-------------+----+

+-------------+----+
|      pattern| sum|
+-------------+----+
|135322,135322|22.0|
+-------------+----+

---

你好，桑契特。我想得到每个匹配模式的频率之和。如为

135322121200

as模式。有两个匹配项，一个是第四行，另一个是最后一行。因此，频率之和为（11+2）=13。对于模式

183201135322135322135322

它将只匹配一个。因此4。这有意义吗？给我一点时间。它也必须遵循顺序吗？如您所述，135322121200应返回第四行和最后一行，但第五行也具有相同的值

135322121200

和

121200135322

是不同的模式。它必须遵循最新的答案。看看解决方案，让我知道这是否可行。

+-------------+----+
|      pattern| sum|
+-------------+----+
|135322,135322|22.0|
+-------------+----+