Feature convert fcts

src/main/scala/spl/catalyst/SplToCatalyst.scala

@@ -212,6 +212,9 @@ object SplToCatalyst extends Logging {
       Literal(null)
     case "isnotnull" =>
       IsNotNull(attrOrExpr(ctx, call.args.head))
+    case "memk" =>
+      val field = attrOrExpr(ctx, call.args.head)
+      callMemk(ctx, field)
     case _ =>
       val approx = s"${call.name}(${call.args.map(_.toString).mkString(",")})"
       throw new ConversionFailure(s"Unknown SPL function: $approx")
@@ -223,6 +226,18 @@ object SplToCatalyst extends Logging {
     }
   }
 
+  private def callMemk(ctx: LogicalContext, field: Expression): Expression = {
+    val regex = Literal.create("(?i)^(\\d*\\.?\\d+)([kmg])$")
+    val size = Cast(RegExpExtract(field, regex, Literal.create(1)), DoubleType)
+    val format = Upper(RegExpExtract(field, regex, Literal.create(2)))
+    val multiplier = CaseWhen(Seq(
+      (EqualTo(format, Literal.create("K")), Literal.create(1.0)),
+      (EqualTo(format, Literal.create("M")), Literal.create(1024.0)),
+      (EqualTo(format, Literal.create("G")), Literal.create(1024.0 * 1024.0))
+    ), Literal.create(1.0))
+    Multiply(size, multiplier)
+  }
+
   private def callCidrMatch(ctx: LogicalContext, cidr: Expression, ip: Expression): Expression = {
     ip match {
       case str: Literal => CidrMatch(cidr, str)

src/main/scala/spl/pyspark/PythonGenerator.scala

@@ -187,6 +187,13 @@ object PythonGenerator {
         s".otherwise(${expressionCode(falseVal.get)})"
       } else ""
       s"F.when(${expressionCode(pred)}, ${expressionCode(trueVal)})$otherwiseStmt"
+    case CaseWhen(branches: Seq[(Expression, Expression)], elseValue: Option[Expression]) =>
+      // ToDo add all branches to when statement + consolidate both CaseWhen cases
+      val otherwiseStmt = if (elseValue.isDefined) {
+        s".otherwise(${expressionCode(elseValue.get)})"
+      } else ""
+      s"F.when(${expressionCode(branches.head._1)}, ${expressionCode(branches.head._2)})" +
+      s"${otherwiseStmt}"
     case In(attr, items) =>
       s"${expressionCode(attr)}.isin(${items.map(expressionCode).mkString(", ")})"
     case UnresolvedAlias(child, aliasFunc) =>

src/test/scala/spl/catalyst/SplToCatalystTest.scala

@@ -850,6 +850,32 @@ class SplToCatalystTest extends AnyFunSuite with PlanTestBase {
         )
     }
 
+    test("memk(x)") {
+        val regex = Literal("(?i)^(\\d*\\.?\\d+)([kmg])$")
+        val format = Upper(RegExpExtract(UnresolvedAttribute("x"), regex, Literal.create(2)))
+        check(ast.SearchCommand(
+            ast.Call("memk", Seq(
+                ast.Field("x")
+            ))),
+            (_, tree) => {
+                Filter(
+                    Multiply(
+                        Cast(RegExpExtract(
+                            UnresolvedAttribute("x"),
+                            regex,
+                            Literal.create(1)),
+                            DoubleType),
+                        CaseWhen(Seq(
+                            (EqualTo(format, Literal("K")), Literal.create(1.0)),
+                            (EqualTo(format, Literal("M")), Literal.create(1024.0)),
+                            (EqualTo(format, Literal("G")), Literal.create(1024.0 * 1024.0))
+                        ), Literal.create(1.0))
+                    ),
+                    tree)
+            }
+        )
+    }
+
     test("round(x)") {
         check(ast.SearchCommand(
             ast.Call("round", Seq(