perf(parse_regex): revert zero-copy slicing, keep pre-computed capture names

Author: thomasqueirozb

src/stdlib/parse_regex.rs

@@ -25,18 +25,12 @@ contains the whole match.",
     ]
 });
 
-fn parse_regex(
-    bytes: &bytes::Bytes,
-    pattern: &Regex,
-    capture_names: &[KeyString],
-    numeric_groups: bool,
-) -> Resolved {
-    util::with_utf8_bytes(bytes, |s, utf8_bytes| {
-        let parsed = pattern.captures(s).map(|capture| {
-            util::capture_regex_to_map(&capture, capture_names, numeric_groups, utf8_bytes)
-        });
-        Ok(parsed.ok_or("could not find any pattern matches")?.into())
-    })
+fn parse_regex(value: &Value, pattern: &Regex, capture_names: &[KeyString], numeric_groups: bool) -> Resolved {
+    let value = value.try_bytes_utf8_lossy()?;
+    let parsed = pattern
+        .captures(value.as_ref())
+        .map(|capture| util::capture_regex_to_map(&capture, capture_names, numeric_groups));
+    Ok(parsed.ok_or("could not find any pattern matches")?.into())
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -183,12 +177,7 @@ impl FunctionExpression for ParseRegexFn {
             .numeric_groups
             .map_resolve_with_default(ctx, || DEFAULT_NUMERIC_GROUPS.clone())?
             .try_boolean()?;
-        parse_regex(
-            &value.try_bytes()?,
-            &self.pattern,
-            &self.capture_names,
-            numeric_groups,
-        )
+        parse_regex(&value, &self.pattern, &self.capture_names, numeric_groups)
     }
 
     fn type_def(&self, _: &state::TypeState) -> TypeDef {

src/stdlib/parse_regex_all.rs

@@ -17,22 +17,13 @@ contains the whole match.")
     ]
 });
 
-fn parse_regex_all(
-    bytes: &bytes::Bytes,
-    pattern: &Regex,
-    capture_names: &[KeyString],
-    numeric_groups: bool,
-) -> Resolved {
-    util::with_utf8_bytes(bytes, |s, utf8_bytes| {
-        let result: Vec<Value> = pattern
-            .captures_iter(s)
-            .map(|capture| {
-                util::capture_regex_to_map(&capture, capture_names, numeric_groups, utf8_bytes)
-                    .into()
-            })
-            .collect();
-        Ok(result.into())
-    })
+fn parse_regex_all(value: &Value, pattern: &Regex, capture_names: &[KeyString], numeric_groups: bool) -> Resolved {
+    let value = value.try_bytes_utf8_lossy()?;
+    let result: Vec<Value> = pattern
+        .captures_iter(value.as_ref())
+        .map(|capture| util::capture_regex_to_map(&capture, capture_names, numeric_groups).into())
+        .collect();
+    Ok(result.into())
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -192,8 +183,6 @@ impl FunctionExpression for ParseRegexAllFn {
             .as_regex()
             .ok_or_else(|| ExpressionError::from("failed to resolve regex"))?
             .clone();
-        let bytes = value.try_bytes()?;
-
         let capture_names: &[KeyString] = if let Some(names) = &self.capture_names {
             names.as_slice()
         } else {
@@ -204,7 +193,7 @@ impl FunctionExpression for ParseRegexAllFn {
                 .collect::<Vec<_>>()
         };
 
-        parse_regex_all(&bytes, &pattern, capture_names, numeric_groups)
+        parse_regex_all(&value, &pattern, capture_names, numeric_groups)
     }
 
     fn type_def(&self, state: &state::TypeState) -> TypeDef {

src/stdlib/util.rs

@@ -27,29 +27,6 @@ where
     fun(num * multiplier) / multiplier
 }
 
-/// Presents `bytes` as `(&str, &Bytes)` for regex matching and zero-copy slicing.
-///
-/// When `bytes` is valid UTF-8 both references point to the original buffer.
-/// Otherwise a lossy copy is allocated and both references point to that copy,
-/// keeping the regex byte offsets aligned with the buffer used for slicing.
-/// The closure receives `(s, utf8_bytes)` and its return value is forwarded.
-pub(crate) fn with_utf8_bytes<F, T>(bytes: &bytes::Bytes, f: F) -> T
-where
-    F: FnOnce(&str, &bytes::Bytes) -> T,
-{
-    let owned;
-    let (s, utf8_bytes): (&str, &bytes::Bytes) = if let Ok(s) = std::str::from_utf8(bytes) {
-        (s, bytes)
-    } else {
-        owned = bytes::Bytes::from(String::from_utf8_lossy(bytes).into_owned());
-        (
-            std::str::from_utf8(&owned).expect("lossy string is valid UTF-8"),
-            &owned,
-        )
-    };
-    f(s, utf8_bytes)
-}
-
 /// Fills an [`ObjectMap`] from a regex [`Captures`](regex::Captures).
 ///
 /// Named captures are inserted under their group name; numeric groups (when
@@ -59,31 +36,25 @@ where
 /// `capture_names` must be the pre-computed slice of named-group
 /// [`KeyString`]s for the regex (computed once at VRL compile time via
 /// `regex.capture_names().flatten().map(KeyString::from)`).
-///
-/// `utf8_bytes` must be the UTF-8 buffer the regex was run against (as produced by
-/// [`with_utf8_bytes`]).  Each matched substring is returned as a zero-copy
-/// [`bytes::Bytes`] slice of that buffer.
 pub(crate) fn capture_regex_to_map(
     capture: &regex::Captures,
     capture_names: &[KeyString],
     numeric_groups: bool,
-    utf8_bytes: &bytes::Bytes,
 ) -> ObjectMap {
     let names = capture_names.iter().map(|name| {
         let value: Value = match capture.name(name.as_str()) {
-            Some(m) => utf8_bytes.slice(m.start()..m.end()).into(),
+            Some(m) => m.as_str().into(),
             None => Value::Null,
         };
         (name.clone(), value)
     });
 
     if numeric_groups {
-        let indexed = capture.iter().flatten().enumerate().map(|(idx, c)| {
-            (
-                KeyString::from(idx.to_string()),
-                utf8_bytes.slice(c.start()..c.end()).into(),
-            )
-        });
+        let indexed = capture
+            .iter()
+            .flatten()
+            .enumerate()
+            .map(|(idx, c)| (KeyString::from(idx.to_string()), c.as_str().into()));
         indexed.chain(names).collect()
     } else {
         names.collect()