Merge pull request #216 from influxdata/crepererum/reduce-evil-boilerplate

refactor: reduce boilerplate in `evil` payload

Author: crepererum

guests/evil/src/common.rs

@@ -1,6 +1,6 @@
 //! Methods used by multiple payloads.
 
-use std::{hash::Hash, sync::Arc};
+use std::{fmt::Debug, hash::Hash, ops::Deref, sync::Arc};
 
 use arrow::{array::StringArray, datatypes::DataType};
 use datafusion_common::{Result as DataFusionResult, cast::as_string_array};
@@ -21,13 +21,61 @@ pub(crate) fn udfs_empty(_source: String) -> DataFusionResult<Vec<Arc<dyn Scalar
     Ok(vec![])
 }
 
+/// A container that shadows its inner dynamic value.
+///
+/// This is mostly used to simplify the handling of `Box<dyn Fn(...) -> ...>`.
+///
+/// The actual value is ignored for [`Debug`], [`PartialEq`], [`Eq`], and [`Hash`].
+pub(crate) struct DynBox<T>(pub(crate) Box<T>)
+where
+    T: ?Sized;
+
+impl<T> Debug for DynBox<T>
+where
+    T: ?Sized,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("DynBox").finish_non_exhaustive()
+    }
+}
+
+impl<T> PartialEq<Self> for DynBox<T>
+where
+    T: ?Sized,
+{
+    fn eq(&self, _other: &Self) -> bool {
+        true
+    }
+}
+
+impl<T> Eq for DynBox<T> where T: ?Sized {}
+
+impl<T> Hash for DynBox<T>
+where
+    T: ?Sized,
+{
+    fn hash<H: std::hash::Hasher>(&self, _state: &mut H) {}
+}
+
+impl<T> Deref for DynBox<T>
+where
+    T: ?Sized,
+{
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
 /// UDF that produces a string from one input.
+#[derive(Debug, PartialEq, Eq, Hash)]
 pub(crate) struct String1Udf {
     /// Name.
     name: &'static str,
 
     /// String producer.
-    effect: Box<dyn Fn(String) -> Result<String, String> + Send + Sync>,
+    effect: DynBox<dyn Fn(String) -> Result<String, String> + Send + Sync>,
 
     /// Signature of the UDF.
     ///
@@ -43,42 +91,12 @@ impl String1Udf {
     {
         Self {
             name,
-            effect: Box::new(effect),
+            effect: DynBox(Box::new(effect)),
             signature: Signature::uniform(1, vec![DataType::Utf8], Volatility::Immutable),
         }
     }
 }
 
-impl std::fmt::Debug for String1Udf {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let Self {
-            name,
-            effect: _,
-            signature,
-        } = self;
-
-        f.debug_struct("StringUdf")
-            .field("name", name)
-            .field("effect", &"<EFFECT>")
-            .field("signature", signature)
-            .finish()
-    }
-}
-
-impl PartialEq<Self> for String1Udf {
-    fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
-    }
-}
-
-impl Eq for String1Udf {}
-
-impl Hash for String1Udf {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.name.hash(state);
-    }
-}
-
 impl ScalarUDFImpl for String1Udf {
     fn as_any(&self) -> &dyn std::any::Any {
         self

guests/evil/src/env.rs

@@ -3,20 +3,20 @@ use std::{hash::Hash, io::Read, sync::Arc};
 
 use arrow::datatypes::DataType;
 use datafusion_common::{Result as DataFusionResult, ScalarValue};
-use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility};
+use datafusion_expr::{
+    ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, TypeSignature, Volatility,
+};
+
+use crate::common::DynBox;
 
 /// UDF that produces a string.
+#[derive(Debug, PartialEq, Eq, Hash)]
 struct StringUdf {
     /// Name.
     name: &'static str,
 
     /// String producer.
-    effect: Box<dyn Fn() -> Option<String> + Send + Sync>,
-
-    /// Signature of the UDF.
-    ///
-    /// We store this here because [`ScalarUDFImpl::signature`] requires us to return a reference.
-    signature: Signature,
+    effect: DynBox<dyn Fn() -> Option<String> + Send + Sync>,
 }
 
 impl StringUdf {
@@ -27,42 +27,11 @@ impl StringUdf {
     {
         Self {
             name,
-            effect: Box::new(effect),
-            signature: Signature::uniform(0, vec![], Volatility::Immutable),
+            effect: DynBox(Box::new(effect)),
         }
     }
 }
 
-impl std::fmt::Debug for StringUdf {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let Self {
-            name,
-            effect: _,
-            signature,
-        } = self;
-
-        f.debug_struct("StringUdf")
-            .field("name", name)
-            .field("effect", &"<EFFECT>")
-            .field("signature", signature)
-            .finish()
-    }
-}
-
-impl PartialEq<Self> for StringUdf {
-    fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
-    }
-}
-
-impl Eq for StringUdf {}
-
-impl Hash for StringUdf {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.name.hash(state);
-    }
-}
-
 impl ScalarUDFImpl for StringUdf {
     fn as_any(&self) -> &dyn std::any::Any {
         self
@@ -73,7 +42,12 @@ impl ScalarUDFImpl for StringUdf {
     }
 
     fn signature(&self) -> &Signature {
-        &self.signature
+        static S: Signature = Signature {
+            type_signature: TypeSignature::Uniform(0, vec![]),
+            volatility: Volatility::Immutable,
+        };
+
+        &S
     }
 
     fn return_type(&self, _arg_types: &[DataType]) -> DataFusionResult<DataType> {

guests/evil/src/fs.rs

@@ -5,15 +5,16 @@ use arrow::{array::StringArray, datatypes::DataType};
 use datafusion_common::{Result as DataFusionResult, cast::as_string_array};
 use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility};
 
-use crate::common::String1Udf;
+use crate::common::{DynBox, String1Udf};
 
 /// UDF that produces a string from two inputs.
+#[derive(Debug, PartialEq, Eq, Hash)]
 struct String2Udf {
     /// Name.
     name: &'static str,
 
     /// String producer.
-    effect: Box<dyn Fn(String, String) -> Result<String, String> + Send + Sync>,
+    effect: DynBox<dyn Fn(String, String) -> Result<String, String> + Send + Sync>,
 
     /// Signature of the UDF.
     ///
@@ -29,42 +30,12 @@ impl String2Udf {
     {
         Self {
             name,
-            effect: Box::new(effect),
+            effect: DynBox(Box::new(effect)),
             signature: Signature::uniform(2, vec![DataType::Utf8], Volatility::Immutable),
         }
     }
 }
 
-impl std::fmt::Debug for String2Udf {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let Self {
-            name,
-            effect: _,
-            signature,
-        } = self;
-
-        f.debug_struct("StringUdf")
-            .field("name", name)
-            .field("effect", &"<EFFECT>")
-            .field("signature", signature)
-            .finish()
-    }
-}
-
-impl PartialEq<Self> for String2Udf {
-    fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
-    }
-}
-
-impl Eq for String2Udf {}
-
-impl Hash for String2Udf {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.name.hash(state);
-    }
-}
-
 impl ScalarUDFImpl for String2Udf {
     fn as_any(&self) -> &dyn std::any::Any {
         self

guests/evil/src/runtime.rs

@@ -3,20 +3,20 @@ use std::{hash::Hash, sync::Arc};
 
 use arrow::datatypes::DataType;
 use datafusion_common::{Result as DataFusionResult, ScalarValue};
-use datafusion_expr::{ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility};
+use datafusion_expr::{
+    ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, TypeSignature, Volatility,
+};
+
+use crate::common::DynBox;
 
 /// UDF that executes a side effect.
+#[derive(Debug, PartialEq, Eq, Hash)]
 struct SideEffect {
     /// Name.
     name: &'static str,
 
     /// Side effect.
-    effect: Box<dyn Fn() + Send + Sync>,
-
-    /// Signature of the UDF.
-    ///
-    /// We store this here because [`ScalarUDFImpl::signature`] requires us to return a reference.
-    signature: Signature,
+    effect: DynBox<dyn Fn() + Send + Sync>,
 }
 
 impl SideEffect {
@@ -27,42 +27,11 @@ impl SideEffect {
     {
         Self {
             name,
-            effect: Box::new(effect),
-            signature: Signature::uniform(0, vec![], Volatility::Immutable),
+            effect: DynBox(Box::new(effect)),
         }
     }
 }
 
-impl std::fmt::Debug for SideEffect {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let Self {
-            name,
-            effect: _,
-            signature,
-        } = self;
-
-        f.debug_struct("SideEffect")
-            .field("name", name)
-            .field("effect", &"<EFFECT>")
-            .field("signature", signature)
-            .finish()
-    }
-}
-
-impl PartialEq<Self> for SideEffect {
-    fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
-    }
-}
-
-impl Eq for SideEffect {}
-
-impl Hash for SideEffect {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.name.hash(state);
-    }
-}
-
 impl ScalarUDFImpl for SideEffect {
     fn as_any(&self) -> &dyn std::any::Any {
         self
@@ -73,7 +42,12 @@ impl ScalarUDFImpl for SideEffect {
     }
 
     fn signature(&self) -> &Signature {
-        &self.signature
+        static S: Signature = Signature {
+            type_signature: TypeSignature::Uniform(0, vec![]),
+            volatility: Volatility::Immutable,
+        };
+
+        &S
     }
 
     fn return_type(&self, _arg_types: &[DataType]) -> DataFusionResult<DataType> {