Address revans2/res-life review: simplify LIKE escape validation

- Replace StringUtils.escapeLikeRegex call with a focused O(n) escape
  char validation that only checks the two invalid cases (escape char
  at end of pattern, escape char followed by non-special character).
  This avoids building a full regex string during planning.
- Remove runtime safety net in GpuLike.doColumnar — tagExprForGpu
  already prevents GpuLike from being created for invalid patterns.
- Remove now-unused StringUtils import from stringFunctions.scala.

Signed-off-by: Allen Xu <allxu@nvidia.com>
Made-with: Cursor
Signed-off-by: Allen Xu <allxu@nvidia.com>

Author: wjxiz1992

sql-plugin/src/main/scala/com/nvidia/spark/rapids/GpuOverrides.scala

@@ -3502,20 +3502,31 @@ object GpuOverrides extends Logging {
         ("search", TypeSig.lit(TypeEnum.STRING), TypeSig.STRING)),
       (a, conf, p, r) => new BinaryExprMeta[Like](a, conf, p, r) {
         override def tagExprForGpu(): Unit = {
-          import org.apache.spark.sql.catalyst.util.StringUtils
-          try {
-            a.right match {
-              case l: Literal
-                  if l.value.isInstanceOf[UTF8String] =>
-                StringUtils.escapeLikeRegex(
-                  l.value.toString, a.escapeChar)
-              case _ =>
-            }
-          } catch {
-            case NonFatal(e) =>
-              willNotWorkOnGpu(
-                s"invalid LIKE escape pattern: " +
-                  s"${e.getMessage}")
+          a.right match {
+            case Literal(v: UTF8String, _) =>
+              val pattern = v.toString
+              val esc = a.escapeChar
+              var i = 0
+              while (i < pattern.length) {
+                if (pattern.charAt(i) == esc) {
+                  val j = i + 1
+                  if (j >= pattern.length) {
+                    willNotWorkOnGpu(
+                      "invalid LIKE escape pattern")
+                    return
+                  }
+                  val c = pattern.charAt(j)
+                  if (c != '_' && c != '%' && c != esc) {
+                    willNotWorkOnGpu(
+                      "invalid LIKE escape pattern")
+                    return
+                  }
+                  i = j + 1
+                } else {
+                  i += 1
+                }
+              }
+            case _ =>
           }
         }
         override def convertToGpu(lhs: Expression, rhs: Expression): GpuExpression =

sql-plugin/src/main/scala/org/apache/spark/sql/rapids/stringFunctions.scala

@@ -36,7 +36,6 @@ import com.nvidia.spark.rapids.jni.RegexRewriteUtils
 import com.nvidia.spark.rapids.shims.{NullIntolerantShim, ShimExpression, SparkShimImpl}
 
 import org.apache.spark.sql.catalyst.expressions._
-import org.apache.spark.sql.catalyst.util.StringUtils
 import org.apache.spark.sql.errors.ConvUtils
 import org.apache.spark.sql.rapids.catalyst.expressions._
 import org.apache.spark.sql.types._
@@ -977,19 +976,12 @@ case class GpuLike(left: Expression, right: Expression, escapeChar: Char)
 
   def this(left: Expression, right: Expression) = this(left, right, '\\')
 
-  @transient private var escapeValidated = false
-
   override def toString: String = escapeChar match {
     case '\\' => s"$left gpulike $right"
     case c => s"$left gpulike $right ESCAPE '$c'"
   }
 
   override def doColumnar(lhs: GpuColumnVector, rhs: GpuScalar): ColumnVector = {
-    if (!escapeValidated && rhs.isValid) {
-      StringUtils.escapeLikeRegex(
-        rhs.getValue.toString, escapeChar)
-      escapeValidated = true
-    }
     withResource(Scalar.fromString(Character.toString(escapeChar))) { escapeScalar =>
       lhs.getBase.like(rhs.getBase, escapeScalar)
     }