feat: Support regexp_replace default empty replacer

Author: MazterQyou

datafusion/core/src/physical_plan/functions.rs

@@ -609,6 +609,7 @@ fn signature(fun: &BuiltinScalarFunction) -> Signature {
         }
         BuiltinScalarFunction::RegexpReplace => Signature::one_of(
             vec![
+                TypeSignature::Exact(vec![DataType::Utf8, DataType::Utf8]),
                 TypeSignature::Exact(vec![
                     DataType::Utf8,
                     DataType::Utf8,
@@ -2266,6 +2267,18 @@ mod tests {
             Utf8,
             StringArray
         );
+        #[cfg(feature = "regex_expressions")]
+        test_function!(
+            RegexpReplace,
+            &[
+                lit(ScalarValue::Utf8(Some("ABCabcABC".to_string()))),
+                lit(ScalarValue::Utf8(Some("(abc)".to_string()))),
+            ],
+            Ok(Some("ABCABC")),
+            &str,
+            Utf8,
+            StringArray
+        );
         #[cfg(not(feature = "regex_expressions"))]
         test_function!(
             RegexpReplace,

datafusion/core/tests/sql/expr.rs

@@ -837,6 +837,7 @@ async fn test_regex_expressions() -> Result<()> {
     test_expression!("regexp_replace('ABCabcABC', '(abc)', 'X', 'i')", "XabcABC");
     test_expression!("regexp_replace('foobarbaz', 'b..', 'X', 'g')", "fooXX");
     test_expression!("regexp_replace('foobarbaz', 'b..', 'X')", "fooXbaz");
+    test_expression!("regexp_replace('foobarbaz', 'b..')", "foobaz");
     test_expression!(
         "regexp_replace('foobarbaz', 'b(..)', 'X\\1Y', 'g')",
         "fooXarYXazY"

datafusion/expr/src/expr_fn.rs

@@ -443,6 +443,7 @@ mod test {
             replacement,
             flags
         );
+        test_nary_scalar_expr!(RegexpReplace, regexp_replace, string, pattern);
         test_scalar_expr!(Replace, replace, string, from, to);
         test_scalar_expr!(Repeat, repeat, string, count);
         test_scalar_expr!(Reverse, reverse, string);

datafusion/physical-expr/src/regex_expressions.rs

@@ -84,6 +84,37 @@ pub fn regexp_replace<T: StringOffsetSizeTrait>(args: &[ArrayRef]) -> Result<Arr
     let mut patterns: HashMap<String, Regex> = HashMap::new();
 
     match args.len() {
+        2 => {
+            let string_array = downcast_string_arg!(args[0], "string", T);
+            let pattern_array = downcast_string_arg!(args[1], "pattern", T);
+
+            let result = string_array
+            .iter()
+            .zip(pattern_array.iter())
+            .map(|(string, pattern)| match (string, pattern) {
+                (Some(string), Some(pattern)) => {
+                    // if patterns hashmap already has regexp then use else else create and return
+                    let re = match patterns.get(pattern) {
+                        Some(re) => Ok(re.clone()),
+                        None => {
+                            match Regex::new(pattern) {
+                                Ok(re) => {
+                                    patterns.insert(pattern.to_string(), re.clone());
+                                    Ok(re)
+                                },
+                                Err(err) => Err(DataFusionError::Execution(err.to_string())),
+                            }
+                        }
+                    };
+
+                    Some(re.map(|re| re.replace(string, ""))).transpose()
+                }
+            _ => Ok(None)
+            })
+            .collect::<Result<GenericStringArray<T>>>()?;
+
+            Ok(Arc::new(result) as ArrayRef)
+        }
         3 => {
             let string_array = downcast_string_arg!(args[0], "string", T);
             let pattern_array = downcast_string_arg!(args[1], "pattern", T);
@@ -172,7 +203,7 @@ pub fn regexp_replace<T: StringOffsetSizeTrait>(args: &[ArrayRef]) -> Result<Arr
             Ok(Arc::new(result) as ArrayRef)
         }
         other => Err(DataFusionError::Internal(format!(
-            "regexp_replace was called with {} arguments. It requires at least 3 and at most 4.",
+            "regexp_replace was called with {} arguments. It requires at least 2 and at most 4.",
             other
         ))),
     }