Method replacen

datafusion/functions/src/regex/regexpreplace.rs:244–276

Applies the direct-extraction fast path when it preserves the result of `Regex::replacen`; otherwise falls back to the full regex replacement.

(
        &mut self,
        val: &'a str,
        limit: usize,
        replacement: &str,
    )

    /// Applies the direct-extraction fast path when it preserves the result of
    /// `Regex::replacen`; otherwise falls back to the full regex replacement.
    fn replacen<'a>(
        &mut self,
        val: &'a str,
        limit: usize,
        replacement: &str,
    ) -> Cow<'a, str> {
        // If this pattern is not eligible for direct extraction, use the full regex.
        let Some(ShortRegex { short_re, locs }) = self.short_re.as_mut() else {
            return self.re.replacen(val, limit, replacement);
        };

        // If the shortened regex does not match, the original anchored regex would
        // also leave the input unchanged.
        if short_re.captures_read(locs, val).is_none() {
            return Cow::Borrowed(val);
        };

        // `captures_read` succeeded, so the overall shortened match is present.
        let match_end = locs.get(0).unwrap().1;
        if memchr(b'\n', &val.as_bytes()[match_end..]).is_some() {
            // If there is a newline after the match, we can't use the short
            // regex since it won't match across lines. Fall back to the full
            // regex replacement.
            return self.re.replacen(val, limit, replacement);
        };
        // The fast path only applies to `${1}` replacements, so the result is
        // either capture group 1 or the empty string if that group did not match.
        if let Some((start, end)) = locs.get(1) {
            Cow::Borrowed(&val[start..end])
        } else {
            Cow::Borrowed("")
        }
    }
}

/// For anchored patterns like `^...(capture)....*$` where the replacement