test(stdlib): Benchmark for del function

Author: JakubOnderka

benches/stdlib.rs

@@ -4,7 +4,9 @@ use criterion::{Criterion, criterion_group, criterion_main};
 use regex::Regex;
 
 use std::{env, path::PathBuf};
-use vrl::{bench_function, btreemap, compiler::prelude::*, func_args, value};
+use vrl::{
+    bench_function, bench_query_function, btreemap, compiler::prelude::*, func_args, query, value,
+};
 
 use crate::value::Value;
 
@@ -31,8 +33,7 @@ criterion_group!(
               decode_punycode,
               decrypt,
               dns_lookup,
-              // TODO: Cannot pass a Path to bench_function
-              //del,
+              del,
               decrypt_ip,
               downcase,
               encode_base16,
@@ -3173,3 +3174,27 @@ bench_function! {
         want: Ok(value!("2001:db8::1")),
     }
 }
+
+bench_query_function! {
+    del => vrl::stdlib::Del;
+
+    default {
+        args: {
+            let mut hashmap = func_args![];
+            hashmap.insert("target", query!(".test"));
+            hashmap
+        },
+        event: btreemap! { "test" => true },
+        want: Ok(value!(true)),
+    }
+
+    compact {
+        args: {
+            let mut hashmap = func_args![compact: true];
+            hashmap.insert("target", query!(".test"));
+            hashmap
+        },
+        event: btreemap! { "test" => true },
+        want: Ok(value!(true)),
+    }
+}

src/compiler/function.rs

@@ -564,7 +564,7 @@ fn required<T>(argument: Option<T>) -> T {
 #[cfg(any(test, feature = "test"))]
 mod test_impls {
     use super::{ArgumentList, HashMap, Span, Value};
-    use crate::compiler::expression::FunctionArgument;
+    use crate::compiler::expression::{Expr, FunctionArgument};
     use crate::compiler::parser::Node;
 
     impl From<HashMap<&'static str, Value>> for ArgumentList {
@@ -579,6 +579,15 @@ mod test_impls {
         }
     }
 
+    impl From<HashMap<&'static str, Expr>> for ArgumentList {
+        fn from(map: HashMap<&'static str, Expr>) -> Self {
+            Self {
+                arguments: map,
+                closure: None,
+            }
+        }
+    }
+
     impl From<ArgumentList> for Vec<(&'static str, Option<FunctionArgument>)> {
         fn from(args: ArgumentList) -> Self {
             args.arguments

src/compiler/test_util.rs

@@ -18,15 +18,25 @@ macro_rules! test_type_def {
     };
 }
 
+#[macro_export]
+macro_rules! query {
+    ($query:expr_2021) => {
+        $crate::compiler::expression::Expr::Query($crate::compiler::expression::Query::new(
+            $crate::compiler::expression::Target::External($crate::path::PathPrefix::Event),
+            $crate::path::parse_value_path($query).expect("invalid path"),
+        ))
+    };
+}
+
 #[macro_export]
 macro_rules! func_args {
     () => (
-        ::std::collections::HashMap::<&'static str, $crate::value::Value>::default()
+        ::std::collections::HashMap::<&'static str, $crate::compiler::expression::Expr>::default()
     );
     ($($k:tt: $v:expr_2021),+ $(,)?) => {
-        vec![$((stringify!($k), $v.into())),+]
+        [$((stringify!($k), $crate::value::Value::from($v).into())),+]
             .into_iter()
-            .collect::<::std::collections::HashMap<&'static str, $crate::value::Value>>()
+            .collect::<::std::collections::HashMap<&'static str, $crate::compiler::expression::Expr>>()
     };
 }
 
@@ -58,6 +68,34 @@ macro_rules! bench_function {
     };
 }
 
+#[macro_export]
+macro_rules! bench_query_function {
+    ($name:tt => $func:path; $($case:ident { args: $args:expr_2021, event: $event:expr_2021, want: $(Ok($ok:expr_2021))? $(Err($err:expr_2021))? $(,)* })+) => {
+        fn $name(c: &mut criterion::Criterion) {
+            let mut group = c.benchmark_group(&format!("vrl_stdlib/functions/{}", stringify!($name)));
+            group.throughput(criterion::Throughput::Elements(1));
+            $(
+                group.bench_function(&stringify!($case).to_string(), |b| {
+                    let mut state = $crate::compiler::state::TypeState::default();
+
+                    let (expression, want) = $crate::__prep_bench_or_test!($func, &state, $args, $(Ok($crate::value::Value::from($ok)))? $(Err($err.to_owned()))?);
+                    let expression = expression.unwrap();
+                    let mut runtime_state = $crate::compiler::state::RuntimeState::default();
+                    let mut target: $crate::value::Value = $event.into();
+                    let tz = $crate::compiler::TimeZone::Named(chrono_tz::Tz::UTC);
+                    let mut ctx = $crate::compiler::Context::new(&mut target, &mut runtime_state, &tz);
+
+                    b.iter(|| {
+                        let got = expression.resolve(&mut ctx).map_err(|e| e.to_string());
+                        debug_assert_eq!(got, want);
+                        got
+                    })
+                });
+            )+
+        }
+    };
+}
+
 #[macro_export]
 macro_rules! test_function {