Simplify regexp_replace optimization: drop regex-syntax, use captures_read

Replace HIR-based regex splitting with a simple string check: strip
trailing `.*$` from anchored patterns and use captures_read with
pre-allocated CaptureLocations for direct extraction. Eliminates
regex-syntax dependency, expand(), and String allocation.

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

Author: Dandandan

datafusion/functions/Cargo.toml

@@ -86,7 +86,6 @@ memchr = { workspace = true }
 num-traits = { workspace = true }
 rand = { workspace = true }
 regex = { workspace = true, optional = true }
-regex-syntax = "0.8.9"
 sha2 = { workspace = true, optional = true }
 unicode-segmentation = { version = "^1.13.2", optional = true }
 uuid = { workspace = true, features = ["v4"], optional = true }

datafusion/functions/src/regex/regexpreplace.rs

@@ -41,7 +41,6 @@ use datafusion_expr::{
 };
 use datafusion_macros::user_doc;
 use regex::Regex;
-use regex_syntax::hir::{Hir, HirKind, Look};
 use std::collections::HashMap;
 use std::sync::{Arc, LazyLock};
 
@@ -200,91 +199,20 @@ fn regex_replace_posix_groups(replacement: &str) -> String {
         .into_owned()
 }
 
-/// Parts of an anchored `^prefix(capture)suffix.*$` pattern, split so
-/// the hot loop can use two `find()` calls (no capture groups).
-struct ExtractParts {
-    prefix_re: Regex,
-    content_re: Regex,
-    suffix_literal: Vec<u8>,
-}
-
-/// For anchored patterns like `^prefix(capture)suffix.*$` where the
-/// replacement is `\1`, split into a prefix regex and a capture-content
-/// regex (without capture groups). The hot loop uses `find()` on each
-/// instead of `captures()` + `expand()`, avoiding capture-group overhead.
-///
-/// Requirements:
-/// - Pattern is `^...$` with trailing `.*` before `$`
-/// - Exactly one capture group, at the top-level concat
-/// - Replacement is exactly `\1` (converted to `${1}`)
-/// - Any suffix between the capture and `.*` must be literal
-fn try_build_extract_parts(pattern: &str, replacement: &str) -> Option<ExtractParts> {
-    if replacement != "${1}" {
-        return None;
-    }
-
-    let hir = regex_syntax::Parser::new().parse(pattern).ok()?;
-    let HirKind::Concat(parts) = hir.kind() else {
-        return None;
-    };
-
-    if parts.len() < 3
-        || !matches!(parts.first()?.kind(), HirKind::Look(Look::Start))
-        || !matches!(parts.last()?.kind(), HirKind::Look(Look::End))
-    {
-        return None;
-    }
-
-    let before_end = &parts[parts.len() - 2];
-    let is_dot_star = matches!(before_end.kind(), HirKind::Repetition(rep)
-        if rep.min == 0
-            && rep.max.is_none()
-            && rep.greedy
-            && matches!(rep.sub.kind(), HirKind::Class(_))
-    );
-    if !is_dot_star {
+/// For anchored patterns like `^...(capture)....*$` where the replacement
+/// is `\1`, build a shorter regex (stripping trailing `.*$`) and use
+/// `captures_read` with `CaptureLocations` for direct extraction — no
+/// `expand()`, no `String` allocation.
+fn try_build_short_extract_regex(pattern: &str, replacement: &str) -> Option<Regex> {
+    if replacement != "${1}" || !pattern.starts_with('^') || !pattern.ends_with(".*$") {
         return None;
     }
-
-    // inner parts: between ^ and .*$
-    let inner_end = parts.len() - 2;
-
-    // Find the sole capture group (must be a direct child of the concat)
-    let capture_positions: Vec<usize> = (1..inner_end)
-        .filter(|&i| matches!(parts[i].kind(), HirKind::Capture(_)))
-        .collect();
-    if capture_positions.len() != 1 {
+    let short = &pattern[..pattern.len() - 3];
+    let re = Regex::new(short).ok()?;
+    if re.captures_len() != 2 {
         return None;
     }
-    let capture_idx = capture_positions[0];
-
-    let HirKind::Capture(cap) = parts[capture_idx].kind() else {
-        return None;
-    };
-
-    // Suffix between capture and .*$ must be all literals
-    let mut suffix_literal = Vec::new();
-    for part in &parts[capture_idx + 1..inner_end] {
-        match part.kind() {
-            HirKind::Literal(lit) => suffix_literal.extend_from_slice(&lit.0),
-            _ => return None,
-        }
-    }
-
-    // Build prefix regex: ^ + parts before capture
-    let prefix_hir = Hir::concat(parts[..capture_idx].to_vec());
-    let prefix_re = Regex::new(&prefix_hir.to_string()).ok()?;
-
-    // Build content regex: ^(capture inner) — anchored so it matches
-    // right where the prefix ended
-    let content_hir = Hir::concat(vec![Hir::look(Look::Start), (*cap.sub).clone()]);
-    let content_re = Regex::new(&content_hir.to_string()).ok()?;
-
-    Some(ExtractParts {
-        prefix_re,
-        content_re,
-        suffix_literal,
-    })
+    Some(re)
 }
 
 /// Replaces substring(s) matching a PCRE-like regular expression.
@@ -545,10 +473,10 @@ fn _regexp_replace_static_pattern_replace<T: OffsetSizeTrait>(
     // with rust ones.
     let replacement = regex_replace_posix_groups(replacement);
 
-    // For anchored patterns like ^prefix(capture)suffix.*$, split into
-    // prefix + content regexes (no capture groups) for faster matching.
-    let extract_parts = if limit == 1 {
-        try_build_extract_parts(&pattern, &replacement)
+    // For anchored patterns like ^...(capture)....*$, build a shorter
+    // regex and use captures_read for direct extraction.
+    let short_re = if limit == 1 {
+        try_build_short_extract_regex(&pattern, &replacement)
     } else {
         None
     };
@@ -569,23 +497,19 @@ fn _regexp_replace_static_pattern_replace<T: OffsetSizeTrait>(
             let mut new_offsets = BufferBuilder::<T>::new(string_array.len() + 1);
             new_offsets.append(T::zero());
 
-            if let Some(ref parts) = extract_parts {
-                // Fast path: two find() calls, no capture groups.
+            if let Some(ref short_re) = short_re {
+                let mut locs = short_re.capture_locations();
                 string_array.iter().for_each(|val| {
                     if let Some(val) = val {
-                        let extracted = parts.prefix_re.find(val).and_then(|pm| {
-                            let rest = &val[pm.end()..];
-                            let cm = parts.content_re.find(rest)?;
-                            let after = &rest.as_bytes()[cm.end()..];
-                            if parts.suffix_literal.is_empty()
-                                || after.starts_with(&parts.suffix_literal)
-                            {
-                                Some(cm.as_str())
+                        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]);
                             } else {
-                                None
+                                vals.append_slice(val.as_bytes());
                             }
-                        });
-                        vals.append_slice(extracted.unwrap_or(val).as_bytes());
+                        } else {
+                            vals.append_slice(val.as_bytes());
+                        }
                     }
                     new_offsets.append(T::from_usize(vals.len()).unwrap());
                 });
@@ -612,22 +536,19 @@ fn _regexp_replace_static_pattern_replace<T: OffsetSizeTrait>(
 
             let mut builder = StringViewBuilder::with_capacity(string_view_array.len());
 
-            if let Some(ref parts) = extract_parts {
+            if let Some(ref short_re) = short_re {
+                let mut locs = short_re.capture_locations();
                 for val in string_view_array.iter() {
                     if let Some(val) = val {
-                        let extracted = parts.prefix_re.find(val).and_then(|pm| {
-                            let rest = &val[pm.end()..];
-                            let cm = parts.content_re.find(rest)?;
-                            let after = &rest.as_bytes()[cm.end()..];
-                            if parts.suffix_literal.is_empty()
-                                || after.starts_with(&parts.suffix_literal)
-                            {
-                                Some(cm.as_str())
+                        if short_re.captures_read(&mut locs, val).is_some() {
+                            if let Some((start, end)) = locs.get(1) {
+                                builder.append_value(&val[start..end]);
                             } else {
-                                None
+                                builder.append_value(val);
                             }
-                        });
-                        builder.append_value(extracted.unwrap_or(val));
+                        } else {
+                            builder.append_value(val);
+                        }
                     } else {
                         builder.append_null();
                     }