Run cargo-fmt on datafusion-functions/core

datafusion/functions/src/core/mod.rs

@@ -29,4 +29,3 @@ export_functions!(
     (nullif, arg_1 arg_2, "returns NULL if value1 equals value2; otherwise it returns value1. This can be used to perform the inverse operation of the COALESCE expression."),
     (nvl, arg_1 arg_2, "returns value2 if value1 is NULL; otherwise it returns value1")
 );
-

datafusion/functions/src/core/nullif.rs

@@ -18,15 +18,15 @@
 //! Encoding expressions
 
 use arrow::datatypes::DataType;
-use datafusion_common::{internal_err, Result, DataFusionError};
+use datafusion_common::{internal_err, DataFusionError, Result};
 use datafusion_expr::ColumnarValue;
 
-use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};
-use std::any::Any;
 use arrow::array::Array;
 use arrow::compute::kernels::cmp::eq;
 use arrow::compute::kernels::nullif::nullif;
 use datafusion_common::ScalarValue;
+use datafusion_expr::{ScalarUDFImpl, Signature, Volatility};
+use std::any::Any;
 
 #[derive(Debug)]
 pub(super) struct NullIfFunc {
@@ -52,14 +52,14 @@ static SUPPORTED_NULLIF_TYPES: &[DataType] = &[
     DataType::LargeUtf8,
 ];
 
-
 impl NullIfFunc {
     pub fn new() -> Self {
         Self {
-            signature:
-            Signature::uniform(2, SUPPORTED_NULLIF_TYPES.to_vec(),
+            signature: Signature::uniform(
+                2,
+                SUPPORTED_NULLIF_TYPES.to_vec(),
                 Volatility::Immutable,
-            )
+            ),
         }
     }
 }
@@ -78,19 +78,20 @@ impl ScalarUDFImpl for NullIfFunc {
 
     fn return_type(&self, arg_types: &[DataType]) -> Result<DataType> {
         // NULLIF has two args and they might get coerced, get a preview of this
-        let coerced_types = datafusion_expr::type_coercion::functions::data_types(arg_types, &self.signature);
-        coerced_types.map(|typs| typs[0].clone())
-            .map_err(|e| e.context("Failed to coerce arguments for NULLIF")
-        )
+        let coerced_types = datafusion_expr::type_coercion::functions::data_types(
+            arg_types,
+            &self.signature,
+        );
+        coerced_types
+            .map(|typs| typs[0].clone())
+            .map_err(|e| e.context("Failed to coerce arguments for NULLIF"))
     }
 
     fn invoke(&self, args: &[ColumnarValue]) -> Result<ColumnarValue> {
         nullif_func(args)
     }
 }
 
-
-
 /// Implements NULLIF(expr1, expr2)
 /// Args: 0 - left expr is any array
 ///       1 - if the left is equal to this expr2, then the result is NULL, otherwise left value is passed.

datafusion/functions/src/core/nvl.rs

@@ -15,12 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use arrow::array::Array;
+use arrow::compute::is_not_null;
+use arrow::compute::kernels::zip::zip;
 use arrow::datatypes::DataType;
-use datafusion_common::{internal_err, Result, DataFusionError};
+use datafusion_common::{internal_err, DataFusionError, Result};
 use datafusion_expr::{ColumnarValue, ScalarUDFImpl, Signature, Volatility};
-use arrow::compute::kernels::zip::zip;
-use arrow::compute::is_not_null;
-use arrow::array::Array;
 
 #[derive(Debug)]
 pub(super) struct NVLFunc {
@@ -50,8 +50,9 @@ static SUPPORTED_NVL_TYPES: &[DataType] = &[
 impl NVLFunc {
     pub fn new() -> Self {
         Self {
-            signature:
-            Signature::uniform(2, SUPPORTED_NVL_TYPES.to_vec(),
+            signature: Signature::uniform(
+                2,
+                SUPPORTED_NVL_TYPES.to_vec(),
                 Volatility::Immutable,
             ),
             aliases: vec![String::from("ifnull")],
@@ -74,10 +75,13 @@ impl ScalarUDFImpl for NVLFunc {
 
     fn return_type(&self, arg_types: &[DataType]) -> Result<DataType> {
         // NVL has two args and they might get coerced, get a preview of this
-        let coerced_types = datafusion_expr::type_coercion::functions::data_types(arg_types, &self.signature);
-        coerced_types.map(|typs| typs[0].clone())
-            .map_err(|e| e.context("Failed to coerce arguments for NVL")
-        )
+        let coerced_types = datafusion_expr::type_coercion::functions::data_types(
+            arg_types,
+            &self.signature,
+        );
+        coerced_types
+            .map(|typs| typs[0].clone())
+            .map_err(|e| e.context("Failed to coerce arguments for NVL"))
     }
 
     fn invoke(&self, args: &[ColumnarValue]) -> Result<ColumnarValue> {
@@ -199,8 +203,11 @@ mod tests {
         let result = nvl_func(&[a, lit_array])?;
         let result = result.into_array(0).expect("Failed to convert to array");
 
-        let expected =
-            Arc::new(BooleanArray::from(vec![Some(true), Some(false), Some(false)])) as ArrayRef;
+        let expected = Arc::new(BooleanArray::from(vec![
+            Some(true),
+            Some(false),
+            Some(false),
+        ])) as ArrayRef;
 
         assert_eq!(expected.as_ref(), result.as_ref());
         Ok(())
@@ -255,7 +262,9 @@ mod tests {
         let b_null = ColumnarValue::Scalar(ScalarValue::Int32(Some(2i32)));
 
         let result_null = nvl_func(&[a_null, b_null])?;
-        let result_null = result_null.into_array(1).expect("Failed to convert to array");
+        let result_null = result_null
+            .into_array(1)
+            .expect("Failed to convert to array");
 
         let expected_null = Arc::new(Int32Array::from(vec![Some(2i32)])) as ArrayRef;
 

datafusion/functions/src/lib.rs

@@ -84,7 +84,11 @@ use log::debug;
 #[macro_use]
 pub mod macros;
 
-make_package!(core, "core_expressions", "Core datafusion expressions");
+/// Core datafusion expressions
+/// Enabled via feature flag `core_expressions`
+#[cfg(feature = "core_expressions")]
+pub mod core;
+make_stub_package!(core, "core_expressions");
 
 make_package!(
     encoding,

datafusion/functions/src/macros.rs

@@ -122,6 +122,30 @@ macro_rules! make_package {
     };
 }
 
+/// Macro creates a sub module if the feature is not enabled
+///
+/// The rationale for providing stub functions is to help users to configure datafusion
+/// properly (so they get an error telling them why a function is not available)
+/// instead of getting a cryptic "no function found" message at runtime.
+
+macro_rules! make_stub_package {
+    ($name:ident, $feature:literal) => {
+        #[cfg(not(feature = $feature))]
+        #[doc = concat!("Disabled. Enable via feature flag `", $feature, "`")]
+        pub mod $name {
+            use datafusion_expr::ScalarUDF;
+            use log::debug;
+            use std::sync::Arc;
+
+            /// Returns an empty list of functions when the feature is not enabled
+            pub fn functions() -> Vec<Arc<ScalarUDF>> {
+                debug!("{} functions disabled", stringify!($name));
+                vec![]
+            }
+        }
+    };
+}
+
 /// Invokes a function on each element of an array and returns the result as a new array
 ///
 /// $ARG: ArrayRef