[SPARK-32193][SQL][DOCS] Update regexp usage in SQL docs

docs/sql-migration-guide.md

@@ -30,6 +30,8 @@ license: |
 
   - In Spark 3.1, `from_unixtime`, `unix_timestamp`,`to_unix_timestamp`, `to_timestamp` and `to_date` will fail if the specified datetime pattern is invalid. In Spark 3.0 or earlier, they result `NULL`.
 
+  - In Spark 3.1, we can use regexp function, it is the alias of rlike funtion, which functions the same with rike funtion.
+
 ## Upgrading from Spark SQL 3.0 to 3.0.1
 
 - In Spark 3.0, JSON datasource and JSON function `schema_of_json` infer TimestampType from string values if they match to the pattern defined by the JSON option `timestampFormat`. Since version 3.0.1, the timestamp type inference is disabled by default. Set the JSON option `inferTimestamp` to `true` to enable such type inference.

docs/sql-ref-syntax-qry-select-like.md

@@ -26,7 +26,7 @@ A LIKE predicate is used to search for a specific pattern.
 ### Syntax
 
 ```sql
-[ NOT ] { LIKE search_pattern [ ESCAPE esc_char ] | RLIKE regex_pattern }
+[ NOT ] { LIKE search_pattern [ ESCAPE esc_char ] | RLIKE regex_pattern | REGEXP regex_pattern}
 ```
 
 ### Parameters

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/FunctionRegistry.scala

@@ -359,6 +359,7 @@ object FunctionRegistry {
     expression[StringReplace]("replace"),
     expression[Overlay]("overlay"),
     expression[RLike]("rlike"),
+    expression[RLike]("regexp", true),
     expression[StringRPad]("rpad"),
     expression[StringTrimRight]("rtrim"),
     expression[Sentences]("sentences"),

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/dsl/package.scala

@@ -102,6 +102,7 @@ package object dsl {
     def like(other: Expression, escapeChar: Char = '\\'): Expression =
       Like(expr, other, escapeChar)
     def rlike(other: Expression): Expression = RLike(expr, other)
+    def regexp(other: Expression): Expression = RLike(expr, other)
     def contains(other: Expression): Expression = Contains(expr, other)
     def startsWith(other: Expression): Expression = StartsWith(expr, other)
     def endsWith(other: Expression): Expression = EndsWith(expr, other)

sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/RegexpExpressionsSuite.scala

@@ -234,6 +234,43 @@ class RegexpExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper {
     }
   }
 
+  test("SPARK-32193: add alias for rlike function") {
+    checkLiteralRow(Literal.create(null, StringType) regexp _, "abdef", null)
+    checkEvaluation("abdef" regexp Literal.create(null, StringType), null)
+    checkEvaluation(Literal.create(null, StringType) regexp Literal.create(null, StringType), null)
+    checkEvaluation("abdef" regexp NonFoldableLiteral.create("abdef", StringType), true)
+    checkEvaluation("abdef" regexp NonFoldableLiteral.create(null, StringType), null)
+    checkEvaluation(
+      Literal.create(null, StringType) regexp NonFoldableLiteral.create("abdef", StringType), null)
+    checkEvaluation(
+      Literal.create(null, StringType) regexp NonFoldableLiteral.create(null, StringType), null)
+
+    checkLiteralRow("abdef" regexp _, "abdef", true)
+    checkLiteralRow("abbbbc" regexp _, "a.*c", true)
+
+    checkLiteralRow("fofo" regexp _, "^fo", true)
+    checkLiteralRow("fo\no" regexp _, "^fo\no$", true)
+    checkLiteralRow("Bn" regexp _, "^Ba*n", true)
+    checkLiteralRow("afofo" regexp _, "fo", true)
+    checkLiteralRow("afofo" regexp _, "^fo", false)
+    checkLiteralRow("Baan" regexp _, "^Ba?n", false)
+    checkLiteralRow("axe" regexp _, "pi|apa", false)
+    checkLiteralRow("pip" regexp _, "^(pi)*$", false)
+
+    checkLiteralRow("abc"  regexp _, "^ab", true)
+    checkLiteralRow("abc"  regexp _, "^bc", false)
+    checkLiteralRow("abc"  regexp _, "^ab", true)
+    checkLiteralRow("abc"  regexp _, "^bc", false)
+
+    intercept[java.util.regex.PatternSyntaxException] {
+      evaluateWithoutCodegen("abbbbc" regexp "**")
+    }
+    intercept[java.util.regex.PatternSyntaxException] {
+      val regex = 'a.string.at(0)
+      evaluateWithoutCodegen("abbbbc" regexp regex, create_row("**"))
+    }
+  }
+
   test("RegexReplace") {
     val row1 = create_row("100-200", "(\\d+)", "num")
     val row2 = create_row("100-200", "(\\d+)", "###")

sql/core/src/test/resources/sql-functions/sql-expression-schema.md

@@ -209,6 +209,7 @@
 | org.apache.spark.sql.catalyst.expressions.Pow | power | SELECT power(2, 3) | struct<POWER(CAST(2 AS DOUBLE), CAST(3 AS DOUBLE)):double> |
 | org.apache.spark.sql.catalyst.expressions.Quarter | quarter | SELECT quarter('2016-08-31') | struct<quarter(CAST(2016-08-31 AS DATE)):int> |
 | org.apache.spark.sql.catalyst.expressions.RLike | rlike | SELECT '%SystemDrive%\Users\John' rlike '%SystemDrive%\\Users.*' | struct<%SystemDrive%UsersJohn RLIKE %SystemDrive%\Users.*:boolean> |
+| org.apache.spark.sql.catalyst.expressions.RLike | regexp | SELECT '%SystemDrive%\Users\John' regexp '%SystemDrive%\\Users.*' | struct<%SystemDrive%UsersJohn REGEXP %SystemDrive%\Users.*:boolean> |
 | org.apache.spark.sql.catalyst.expressions.Rand | random | SELECT random() | struct<rand():double> |
 | org.apache.spark.sql.catalyst.expressions.Rand | rand | SELECT rand() | struct<rand():double> |
 | org.apache.spark.sql.catalyst.expressions.Randn | randn | SELECT randn() | struct<randn():double> |