Simplified version.

Author: viirya

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/codegen/CodeGenerator.scala

@@ -309,17 +309,12 @@ class CodegenContext {
       funcCode: String,
       inlineToOuterClass: Boolean = false): String = {
     val newFunction = addNewFunctionInternal(funcName, funcCode, inlineToOuterClass)
-    qualifiedFunctionName(newFunction)
-  }
-
-  // Returns the name of the function, qualified by class if it will be inlined to a private,
-  // inner class
-  private[this] def qualifiedFunctionName(functionSpec: NewFunctionSpec): String =
-    functionSpec match {
+    newFunction match {
       case NewFunctionSpec(functionName, None, None) => functionName
       case NewFunctionSpec(functionName, Some(_), Some(innerClassInstance)) =>
         innerClassInstance + "." + functionName
     }
+  }
 
   private[this] def addNewFunctionInternal(
       funcName: String,
@@ -800,19 +795,14 @@ class CodegenContext {
    * @param returnType the return type of the split function.
    * @param makeSplitFunction makes split function body, e.g. add preparation or cleanup.
    * @param foldFunctions folds the split function calls.
-   * @param makeFunctionCallback a callback function that is called after each function split.
-   *                             The name of split function will be passed into the callback.
-   * @param mergeSplit When true, try to merge split methods.
    */
   def splitExpressionsWithCurrentInputs(
       expressions: Seq[String],
       funcName: String = "apply",
       extraArguments: Seq[(String, String)] = Nil,
       returnType: String = "void",
       makeSplitFunction: String => String = identity,
-      foldFunctions: Seq[String] => String = _.mkString("", ";\n", ";"),
-      makeFunctionCallback: String => Unit = identity,
-      mergeSplit: Boolean = true): String = {
+      foldFunctions: Seq[String] => String = _.mkString("", ";\n", ";")): String = {
     // TODO: support whole stage codegen
     if (INPUT_ROW == null || currentVars != null) {
       expressions.mkString("\n")
@@ -823,9 +813,7 @@ class CodegenContext {
         ("InternalRow", INPUT_ROW) +: extraArguments,
         returnType,
         makeSplitFunction,
-        foldFunctions,
-        makeFunctionCallback,
-        mergeSplit)
+        foldFunctions)
     }
   }
 
@@ -841,19 +829,14 @@ class CodegenContext {
    * @param returnType the return type of the split function.
    * @param makeSplitFunction makes split function body, e.g. add preparation or cleanup.
    * @param foldFunctions folds the split function calls.
-   * @param makeFunctionCallback a callback function that is called after each function split.
-   *                             The name of split function will be passed into the callback.
-   * @param mergeSplit When true, try to merge split methods.
    */
   def splitExpressions(
       expressions: Seq[String],
       funcName: String,
       arguments: Seq[(String, String)],
       returnType: String = "void",
       makeSplitFunction: String => String = identity,
-      foldFunctions: Seq[String] => String = _.mkString("", ";\n", ";"),
-      makeFunctionCallback: String => Unit = identity,
-      mergeSplit: Boolean = true): String = {
+      foldFunctions: Seq[String] => String = _.mkString("", ";\n", ";")): String = {
     val blocks = buildCodeBlocks(expressions)
 
     if (blocks.length == 1) {
@@ -869,9 +852,7 @@ class CodegenContext {
            |  ${makeSplitFunction(body)}
            |}
          """.stripMargin
-        val functionSpec = addNewFunctionInternal(name, code, inlineToOuterClass = false)
-        makeFunctionCallback(qualifiedFunctionName(functionSpec))
-        functionSpec
+        addNewFunctionInternal(name, code, inlineToOuterClass = false)
       }
 
       val (outerClassFunctions, innerClassFunctions) = functions.partition(_.innerClassName.isEmpty)
@@ -885,8 +866,7 @@ class CodegenContext {
         arguments,
         returnType,
         makeSplitFunction,
-        foldFunctions,
-        mergeSplit)
+        foldFunctions)
 
       foldFunctions(outerClassFunctionCalls ++ innerClassFunctionCalls)
     }
@@ -934,7 +914,6 @@ class CodegenContext {
    * @param returnType the return type of the split function.
    * @param makeSplitFunction makes split function body, e.g. add preparation or cleanup.
    * @param foldFunctions folds the split function calls.
-   * @param mergeSplit When true, try to merge split methods.
    * @return an [[Iterable]] containing the methods' invocations
    */
   private def generateInnerClassesFunctionCalls(
@@ -943,8 +922,7 @@ class CodegenContext {
       arguments: Seq[(String, String)],
       returnType: String,
       makeSplitFunction: String => String,
-      foldFunctions: Seq[String] => String,
-      mergeSplit: Boolean = true): Iterable[String] = {
+      foldFunctions: Seq[String] => String): Iterable[String] = {
     val innerClassToFunctions = mutable.LinkedHashMap.empty[(String, String), Seq[String]]
     functions.foreach(f => {
       val key = (f.innerClassName.get, f.innerClassInstance.get)
@@ -960,7 +938,7 @@ class CodegenContext {
         // for performance reasons, the functions are prepended, instead of appended,
         // thus here they are in reversed order
         val orderedFunctions = innerClassFunctions.reverse
-        if (mergeSplit && orderedFunctions.size > CodeGenerator.MERGE_SPLIT_METHODS_THRESHOLD) {
+        if (orderedFunctions.size > CodeGenerator.MERGE_SPLIT_METHODS_THRESHOLD) {
           // Adding a new function to each inner class which contains the invocation of all the
           // ones which have been added to that inner class. For example,
           //   private class NestedClass {

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/stringExpressions.scala

@@ -289,55 +289,61 @@ case class Elt(children: Seq[Expression])
     val index = indexExpr.genCode(ctx)
     val strings = stringExprs.map(_.genCode(ctx))
     val indexVal = ctx.freshName("index")
+
+    // -1 means the given index doesn't match indices of strings in split function.
+    val NOT_MATCHED = -1
+    // 0 means the given index matches one of indices of strings in split function.
+    val MATCHED = 0
+    val resultState = ctx.freshName("eltResultState")
+
     val stringVal = ctx.freshName("stringVal")
+    ctx.addMutableState(ctx.javaType(dataType), stringVal)
+
     val assignStringValue = strings.zipWithIndex.map { case (eval, index) =>
       s"""
-        case ${index + 1}:
-          ${eval.code}
-          $stringVal = ${eval.isNull} ? null : ${eval.value};
-          break;
-      """
+         |if ($indexVal == ${index + 1}) {
+         |  ${eval.code}
+         |  $stringVal = ${eval.isNull} ? null : ${eval.value};
+         |  $resultState = (byte)$MATCHED;
+         |  continue;
+         |}
+      """.stripMargin
     }
 
-    var prevFunc = "null"
-    var codes = ctx.splitExpressionsWithCurrentInputs(
+    val codes = ctx.splitExpressionsWithCurrentInputs(
       expressions = assignStringValue,
       funcName = "eltFunc",
       extraArguments = ("int", indexVal) :: Nil,
-      returnType = "UTF8String",
+      returnType = ctx.JAVA_BYTE,
       makeSplitFunction = body =>
         s"""
-           |UTF8String $stringVal = null;
-           |switch ($indexVal) {
+           |${ctx.JAVA_BYTE} $resultState = $NOT_MATCHED;
+           |do {
            |  $body
-           |  default:
-           |    return $prevFunc;
-           |}
-           |return $stringVal;
-        """.stripMargin,
-      foldFunctions = funcs => s"UTF8String $stringVal = ${funcs.last};",
-      makeFunctionCallback = f => prevFunc = s"$f(${ctx.INPUT_ROW}, $indexVal)",
-      mergeSplit = false)
-
-    // If no any functions split, wraps all cases in a single switch.
-    if (prevFunc == "null") {
-      codes =
+           |} while (false);
+           |return $resultState;
+         """.stripMargin,
+      foldFunctions = _.map { funcCall =>
         s"""
-           |UTF8String $stringVal = null;
-           |switch ($indexVal) {
-           |  $codes
+           |$resultState = $funcCall;
+           |if ($resultState != $NOT_MATCHED) {
+           |  continue;
            |}
-        """.stripMargin
-    }
+         """.stripMargin
+      }.mkString)
 
     ev.copy(
       s"""
-      ${index.code}
-      final int $indexVal = ${index.value};
-      $codes
-      UTF8String ${ev.value} = $stringVal;
-      final boolean ${ev.isNull} = ${ev.value} == null;
-    """)
+         |${index.code}
+         |final int $indexVal = ${index.value};
+         |${ctx.JAVA_BYTE} $resultState = $NOT_MATCHED;
+         |$stringVal = ${ctx.defaultValue(dataType)};
+         |do {
+         |  $codes
+         |} while (false);
+         |final UTF8String ${ev.value} = $stringVal;
+         |final boolean ${ev.isNull} = ${ev.value} == null;
+       """.stripMargin)
   }
 }