Fix correctness bugs in regexp_replace optimization

- Non-participating capture group now returns empty string instead of original input
- Newline in remainder after short match falls back to full regex

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Dandandan

datafusion/functions/src/regex/regexpreplace.rs

@@ -502,10 +502,17 @@ fn _regexp_replace_static_pattern_replace<T: OffsetSizeTrait>(
                 string_array.iter().for_each(|val| {
                     if let Some(val) = val {
                         if short_re.captures_read(&mut locs, val).is_some() {
-                            if let Some((start, end)) = locs.get(1) {
-                                vals.append_slice(&val.as_bytes()[start..end]);
+                            let match_end = locs.get(0).unwrap().1;
+                            if !val[match_end..].contains('\n') {
+                                if let Some((start, end)) = locs.get(1) {
+                                    vals.append_slice(&val.as_bytes()[start..end]);
+                                }
+                                // else: empty replacement (group didn't participate)
                             } else {
-                                vals.append_slice(val.as_bytes());
+                                // Fallback: newline in remainder means .*$ wouldn't match
+                                let result =
+                                    re.replacen(val, limit, replacement.as_str());
+                                vals.append_slice(result.as_bytes());
                             }
                         } else {
                             vals.append_slice(val.as_bytes());
@@ -541,10 +548,18 @@ fn _regexp_replace_static_pattern_replace<T: OffsetSizeTrait>(
                 for val in string_view_array.iter() {
                     if let Some(val) = val {
                         if short_re.captures_read(&mut locs, val).is_some() {
-                            if let Some((start, end)) = locs.get(1) {
-                                builder.append_value(&val[start..end]);
+                            let match_end = locs.get(0).unwrap().1;
+                            if !val[match_end..].contains('\n') {
+                                if let Some((start, end)) = locs.get(1) {
+                                    builder.append_value(&val[start..end]);
+                                } else {
+                                    builder.append_value("");
+                                }
                             } else {
-                                builder.append_value(val);
+                                // Fallback: newline in remainder means .*$ wouldn't match
+                                let result =
+                                    re.replacen(val, limit, replacement.as_str());
+                                builder.append_value(result);
                             }
                         } else {
                             builder.append_value(val);

datafusion/sqllogictest/test_files/regexp/regexp_replace.slt

@@ -143,19 +143,15 @@ test.org
 example.com
 not-a-url
 
-# If the overall pattern matches but capture group 1 does not participate,
-# regexp_replace(..., '\1') should substitute the empty string, not keep
-# the original input.
-query B
-SELECT regexp_replace('bzzz', '^(a)?b.*$', '\1') = '';
+# Test non-participating capture group returns empty string
+query T
+SELECT regexp_replace('bzzz', '^(a)?b.*$', '\1');
 ----
-true
+(empty)
 
-# Stripping trailing .*$ must not change match semantics for inputs with
-# newlines when the original pattern does not use the 's' flag.
+# Test that newlines prevent the optimization from incorrectly matching
 query B
-SELECT regexp_replace(concat('http://x/', chr(10), 'rest'), '^https?://([^/]+)/.*$', '\1')
-       = concat('http://x/', chr(10), 'rest');
+SELECT regexp_replace(concat('http://x/', chr(10), 'rest'), '^https?://([^/]+)/.*$', '\1') = concat('http://x/', chr(10), 'rest');
 ----
 true