update RIGHT and REGEXP_LIKE string functions

fupelaqu · fupelaqu · commit 7cc4dc496997 · 2025-09-30T10:49:41.000+02:00
diff --git a/documentation/functions_string.md b/documentation/functions_string.md
@@ -124,7 +124,7 @@ SELECT SUBSTRING('abcdef' FROM 4) AS s;
 
 ### Function: LEFT
 **Description:**  
-Leftmost characters.
+Returns the leftmost characters from a string.
 
 **Inputs:** 
 - `str` (`VARCHAR`) `,`|`FOR` `length` (`INT`)
@@ -140,7 +140,10 @@ SELECT LEFT('abcdef', 3) AS l;
 
 ### Function: RIGHT
 **Description:**  
-Rightmost characters.
+Returns the rightmost characters from a string.  
+If `length` exceeds the string size, the implementation returns the full string.  
+If `length = 0`, an empty string is returned.  
+If `length < 0`, a validation error is raised.
 
 **Inputs:**
 - `str` (`VARCHAR`) `,`|`FOR` `length` (`INT`)
@@ -174,7 +177,7 @@ SELECT CONCAT(firstName, ' ', lastName) AS full FROM users;
 
 ### Function: REPLACE
 **Description:**  
-Replace substring occurrences.
+Replaces all occurrences of a substring with another substring.
 
 **Inputs:** 
 - `str, search, replace`
@@ -188,26 +191,27 @@ SELECT REPLACE('Mr. John', 'Mr. ', '') AS r;
 -- Result: 'John'
 ```
 
-### Function: REPLACE
+### Function: REVERSE
 **Description:**  
-Replace substring occurrences.
+Reverses the characters in a string.
 
 **Inputs:** 
-- `str, search, replace`
+- `str` (`VARCHAR`)
 
 **Output:**
 - `VARCHAR`
 
 **Example:**
 ```sql
-SELECT REPLACE('Mr. John', 'Mr. ', '') AS r;
--- Result: 'John'
+SELECT REVERSE('abcdef') AS r;
+-- Result: 'fedcba'
 ```
 
 ### Function: POSITION / STRPOS
 **Description:**  
-1-based index, 0 if not found.
-The first position of the `substr` in the `str`, starting at the optional `FROM` position (1-based).
+Returns the 1-based position of the first occurrence of a substring in a string.  
+If the substring is not found, returns 0.  
+An optional FROM position (1-based) can be provided to start the search.
 
 **Inputs:**
 - `substr` `,` | `IN` `str` optional `,` | `FROM` `INT`
@@ -229,17 +233,28 @@ SELECT POSITION('z' IN 'Elasticsearch') AS pos;
 
 ### Function: REGEXP_LIKE / RLIKE
 **Description:**  
-Regex match predicate.
+`REGEXP_LIKE(string, pattern [, match_param])`
+
+Returns `TRUE` if the input string matches the regular expression `pattern`.  
+By default, the match is case-sensitive.
 
 **Inputs:** 
-- `str, pattern`
+- `string`: The input string to test.
+- `pattern`: A regular expression pattern.
+- `match_param` *(optional)*: A string controlling the regex matching behavior.
+    - `'i'`: Case-insensitive match.
+    - `'c'`: Case-sensitive match (default).
+    - `'m'`: Multi-line mode.
+    - `'n'`: Allows the `.` to match newline characters.
 
 **Output:** 
 - `BOOLEAN`
 
-**Example:**
+**Examples:**
 ```sql
-SELECT REGEXP_LIKE(email, '.*@example\.com') AS ok FROM users;
+SELECT REGEXP_LIKE('Hello', 'HEL');         -- false
+SELECT REGEXP_LIKE('Hello', 'HEL', 'i');    -- true
+SELECT REGEXP_LIKE('abc\nxyz', '^xyz', 'm') -- true
 ```
 
 [Back to index](./README.md)
diff --git a/es6/sql-bridge/src/test/scala/app/softnetwork/elastic/sql/SQLQuerySpec.scala b/es6/sql-bridge/src/test/scala/app/softnetwork/elastic/sql/SQLQuerySpec.scala
@@ -2481,7 +2481,7 @@ class SQLQuerySpec extends AnyFlatSpec with Matchers {
       |    "r": {
       |      "script": {
       |        "lang": "painless",
-      |        "source": "(def arg0 = (!doc.containsKey('identifier2') || doc['identifier2'].empty ? null : doc['identifier2'].value); (arg0 == null) ? null : 3 == 0 ? \"\" : 3 > arg0.length() ? null : arg0.substring(arg0.length() - 3))"
+      |        "source": "(def arg0 = (!doc.containsKey('identifier2') || doc['identifier2'].empty ? null : doc['identifier2'].value); (arg0 == null) ? null : 3 == 0 ? \"\" : arg0.substring(arg0.length() - Math.min(3, arg0.length())))"
       |      }
       |    },
       |    "rep": {
@@ -2505,7 +2505,7 @@ class SQLQuerySpec extends AnyFlatSpec with Matchers {
       |    "reg": {
       |      "script": {
       |        "lang": "painless",
-      |        "source": "(def arg0 = (!doc.containsKey('identifier2') || doc['identifier2'].empty ? null : doc['identifier2'].value); (arg0 == null) ? null : arg0.matches(\"soft\"))"
+      |        "source": "(def arg0 = (!doc.containsKey('identifier2') || doc['identifier2'].empty ? null : doc['identifier2'].value); (arg0 == null) ? null : java.util.regex.Pattern.compile(\"soft\", java.util.regex.Pattern.CASE_INSENSITIVE | java.util.regex.Pattern.MULTILINE).matcher(arg0).find())"
       |      }
       |    }
       |  },
@@ -2553,6 +2553,9 @@ class SQLQuerySpec extends AnyFlatSpec with Matchers {
       .replaceAll(":(\\d)", " : $1")
       .replaceAll("new", "new ")
       .replaceAll(""",\\"le""", """, \\"le""")
+      .replaceAll(":arg", " : arg")
+      .replaceAll(",java", ", java")
+      .replaceAll("\\|java", " | java")
   }
 
   it should "handle top hits aggregation" in {
diff --git a/sql/bridge/src/test/scala/app/softnetwork/elastic/sql/SQLQuerySpec.scala b/sql/bridge/src/test/scala/app/softnetwork/elastic/sql/SQLQuerySpec.scala
@@ -2470,7 +2470,7 @@ class SQLQuerySpec extends AnyFlatSpec with Matchers {
         |    "r": {
         |      "script": {
         |        "lang": "painless",
-        |        "source": "(def arg0 = (!doc.containsKey('identifier2') || doc['identifier2'].empty ? null : doc['identifier2'].value); (arg0 == null) ? null : 3 == 0 ? \"\" : 3 > arg0.length() ? null : arg0.substring(arg0.length() - 3))"
+        |        "source": "(def arg0 = (!doc.containsKey('identifier2') || doc['identifier2'].empty ? null : doc['identifier2'].value); (arg0 == null) ? null : 3 == 0 ? \"\" : arg0.substring(arg0.length() - Math.min(3, arg0.length())))"
         |      }
         |    },
         |    "rep": {
@@ -2494,7 +2494,7 @@ class SQLQuerySpec extends AnyFlatSpec with Matchers {
         |    "reg": {
         |      "script": {
         |        "lang": "painless",
-        |        "source": "(def arg0 = (!doc.containsKey('identifier2') || doc['identifier2'].empty ? null : doc['identifier2'].value); (arg0 == null) ? null : arg0.matches(\"soft\"))"
+        |        "source": "(def arg0 = (!doc.containsKey('identifier2') || doc['identifier2'].empty ? null : doc['identifier2'].value); (arg0 == null) ? null : java.util.regex.Pattern.compile(\"soft\", java.util.regex.Pattern.CASE_INSENSITIVE | java.util.regex.Pattern.MULTILINE).matcher(arg0).find())"
         |      }
         |    }
         |  },
@@ -2542,6 +2542,9 @@ class SQLQuerySpec extends AnyFlatSpec with Matchers {
         .replaceAll(":(\\d)", " : $1")
         .replaceAll("new", "new ")
         .replaceAll(""",\\"le""", """, \\"le""")
+        .replaceAll(":arg", " : arg")
+        .replaceAll(",java", ", java")
+        .replaceAll("\\|java", " | java")
   }
 
   it should "handle top hits aggregation" in {
diff --git a/sql/src/main/scala/app/softnetwork/elastic/sql/function/string/package.scala b/sql/src/main/scala/app/softnetwork/elastic/sql/function/string/package.scala
@@ -54,11 +54,31 @@ package object string {
     override lazy val words: List[String] = List(sql, "STRPOS")
     override def painless: String = ".indexOf"
   }
+
   case object RegexpLike extends Expr("REGEXP_LIKE") with StringOp {
     override lazy val words: List[String] = List(sql, "REGEXP")
     override def painless: String = ".matches"
   }
 
+  case class MatchFlags(flags: String) extends PainlessScript {
+    override def sql: String = s"'$flags'"
+    override def painless: String = flags.toCharArray
+      .map {
+        case 'i' => "java.util.regex.Pattern.CASE_INSENSITIVE"
+        case 'c' => "0"
+        case 'n' => "java.util.regex.Pattern.DOTALL"
+        case 'm' => "java.util.regex.Pattern.MULTILINE"
+        case _   => ""
+      }
+      .filter(_.nonEmpty)
+      .mkString(" | ") match {
+      case "" => "0"
+      case s  => s
+    }
+
+    override def nullable: Boolean = false
+  }
+
   sealed trait StringFunction[Out <: SQLType]
       extends TransformFunction[SQLVarchar, Out]
       with FunctionWithIdentifier {
@@ -191,7 +211,7 @@ package object string {
     override def toPainlessCall(callArgs: List[String]): String = {
       callArgs match {
         case List(arg0, arg1) =>
-          s"""$arg1 == 0 ? "" : $arg1 > $arg0.length() ? null : $arg0.substring($arg0.length() - $arg1)"""
+          s"""$arg1 == 0 ? "" : $arg0.substring($arg0.length() - Math.min($arg1, $arg0.length()))"""
         case _ => throw new IllegalArgumentException("RIGHT requires 2 arguments")
       }
     }
@@ -274,20 +294,25 @@ package object string {
     override def toSQL(base: String): String = sql
   }
 
-  case class RegexpLike(str: PainlessScript, pattern: PainlessScript)
-      extends StringFunction[SQLBool] {
+  case class RegexpLike(
+    str: PainlessScript,
+    pattern: PainlessScript,
+    matchFlags: Option[MatchFlags] = None
+  ) extends StringFunction[SQLBool] {
     override def outputType: SQLBool = SQLTypes.Boolean
 
     override def stringOp: StringOp = RegexpLike
 
-    override def args: List[PainlessScript] = List(str, pattern)
+    override def args: List[PainlessScript] = List(str, pattern) ++ matchFlags.toList
 
     override def nullable: Boolean = str.nullable || pattern.nullable
 
     override def toPainlessCall(callArgs: List[String]): String = {
       callArgs match {
-        case List(arg0, arg1) => s"$arg0.matches($arg1)"
-        case _ => throw new IllegalArgumentException("REGEXP_LIKE requires 2 arguments")
+        case List(arg0, arg1) => s"java.util.regex.Pattern.compile($arg1).matcher($arg0).find()"
+        case List(arg0, arg1, arg2) =>
+          s"java.util.regex.Pattern.compile($arg1, $arg2).matcher($arg0).find()"
+        case _ => throw new IllegalArgumentException("REGEXP_LIKE requires 2 or 3 arguments")
       }
     }
 
diff --git a/sql/src/main/scala/app/softnetwork/elastic/sql/parser/function/string/package.scala b/sql/src/main/scala/app/softnetwork/elastic/sql/parser/function/string/package.scala
@@ -52,9 +52,16 @@ package object string {
       }
 
     def regexp: PackratParser[StringFunction[SQLBool]] =
-      RegexpLike.regex ~ start ~ valueExpr ~ separator ~ valueExpr ~ end ^^ {
-        case _ ~ _ ~ str ~ _ ~ pattern ~ _ =>
-          RegexpLike(str, pattern)
+      RegexpLike.regex ~ start ~ valueExpr ~ separator ~ valueExpr ~ (separator ~ literal).? ~ end ^^ {
+        case _ ~ _ ~ str ~ _ ~ pattern ~ flags ~ _ =>
+          RegexpLike(
+            str,
+            pattern,
+            flags match {
+              case Some(_ ~ f) => Some(MatchFlags(f.value))
+              case _           => None
+            }
+          )
       }
 
     def stringFunctionWithIdentifier: PackratParser[Identifier] =
diff --git a/sql/src/test/scala/app/softnetwork/elastic/sql/SQLParserSpec.scala b/sql/src/test/scala/app/softnetwork/elastic/sql/SQLParserSpec.scala
@@ -163,7 +163,7 @@ object Queries {
     "SELECT identifier, (ABS(identifier) + 1.0) * 2, CEIL(identifier), FLOOR(identifier), SQRT(identifier), EXP(identifier), LOG(identifier), LOG10(identifier), POW(identifier, 3), ROUND(identifier), ROUND(identifier, 2), SIGN(identifier), COS(identifier), ACOS(identifier), SIN(identifier), ASIN(identifier), TAN(identifier), ATAN(identifier), ATAN2(identifier, 3.0) FROM Table WHERE SQRT(identifier) > 100.0"
 
   val string: String =
-    "SELECT identifier, LENGTH(identifier2) AS len, LOWER(identifier2) AS low, UPPER(identifier2) AS upp, SUBSTRING(identifier2, 1, 3) AS sub, TRIM(identifier2) AS tr, LTRIM(identifier2) AS ltr, RTRIM(identifier2) AS rtr, CONCAT(identifier2, '_test', 1) AS con, LEFT(identifier2, 5) AS l, RIGHT(identifier2, 3) AS r, REPLACE(identifier2, 'el', 'le') AS rep, REVERSE(identifier2) AS rev, POSITION('soft', identifier2, 1) AS pos, REGEXP_LIKE(identifier2, 'soft') AS reg FROM Table WHERE LENGTH(TRIM(identifier2)) > 10"
+    "SELECT identifier, LENGTH(identifier2) AS len, LOWER(identifier2) AS low, UPPER(identifier2) AS upp, SUBSTRING(identifier2, 1, 3) AS sub, TRIM(identifier2) AS tr, LTRIM(identifier2) AS ltr, RTRIM(identifier2) AS rtr, CONCAT(identifier2, '_test', 1) AS con, LEFT(identifier2, 5) AS l, RIGHT(identifier2, 3) AS r, REPLACE(identifier2, 'el', 'le') AS rep, REVERSE(identifier2) AS rev, POSITION('soft', identifier2, 1) AS pos, REGEXP_LIKE(identifier2, 'soft', 'im') AS reg FROM Table WHERE LENGTH(TRIM(identifier2)) > 10"
 
   val topHits: String =
     "SELECT department AS dept, firstName, CAST(hire_date AS DATE) AS hire_date, COUNT(DISTINCT salary) AS cnt, FIRST_VALUE(salary) OVER (PARTITION BY department ORDER BY hire_date ASC) AS first_salary, LAST_VALUE(salary) OVER (PARTITION BY department ORDER BY hire_date ASC) AS last_salary, ARRAY_AGG(name) OVER (PARTITION BY department ORDER BY hire_date ASC, salary DESC LIMIT 1000) AS employees FROM emp"
