feat: array-empty

Author: Weijun-H

datafusion/expr/src/built_in_function.rs

@@ -138,6 +138,8 @@ pub enum BuiltinScalarFunction {
     ArrayDims,
     /// array_element
     ArrayElement,
+    /// array_empty
+    ArrayEmpty,
     /// array_length
     ArrayLength,
     /// array_ndims
@@ -360,6 +362,7 @@ impl BuiltinScalarFunction {
             BuiltinScalarFunction::Trunc => Volatility::Immutable,
             BuiltinScalarFunction::ArrayAppend => Volatility::Immutable,
             BuiltinScalarFunction::ArrayConcat => Volatility::Immutable,
+            BuiltinScalarFunction::ArrayEmpty => Volatility::Immutable,
             BuiltinScalarFunction::ArrayHasAll => Volatility::Immutable,
             BuiltinScalarFunction::ArrayHasAny => Volatility::Immutable,
             BuiltinScalarFunction::ArrayHas => Volatility::Immutable,
@@ -538,7 +541,8 @@ impl BuiltinScalarFunction {
             }
             BuiltinScalarFunction::ArrayHasAll
             | BuiltinScalarFunction::ArrayHasAny
-            | BuiltinScalarFunction::ArrayHas => Ok(Boolean),
+            | BuiltinScalarFunction::ArrayHas
+            | BuiltinScalarFunction::ArrayEmpty => Ok(Boolean),
             BuiltinScalarFunction::ArrayDims => {
                 Ok(List(Arc::new(Field::new("item", UInt64, true))))
             }
@@ -832,6 +836,7 @@ impl BuiltinScalarFunction {
                 Signature::variadic_any(self.volatility())
             }
             BuiltinScalarFunction::ArrayDims => Signature::any(1, self.volatility()),
+            BuiltinScalarFunction::ArrayEmpty => Signature::any(1, self.volatility()),
             BuiltinScalarFunction::ArrayElement => Signature::any(2, self.volatility()),
             BuiltinScalarFunction::Flatten => Signature::any(1, self.volatility()),
             BuiltinScalarFunction::ArrayHasAll
@@ -1322,6 +1327,7 @@ fn aliases(func: &BuiltinScalarFunction) -> &'static [&'static str] {
             &["array_concat", "array_cat", "list_concat", "list_cat"]
         }
         BuiltinScalarFunction::ArrayDims => &["array_dims", "list_dims"],
+        BuiltinScalarFunction::ArrayEmpty => &["empty"],
         BuiltinScalarFunction::ArrayElement => &[
             "array_element",
             "array_extract",

datafusion/physical-expr/src/array_expressions.rs

@@ -986,6 +986,36 @@ macro_rules! general_repeat_list {
     }};
 }
 
+/// Array_empty SQL function
+pub fn array_empty(args: &[ArrayRef]) -> Result<ArrayRef> {
+    let array = as_list_array(&args[0])?;
+    let mut builder = UInt8Array::builder(1);
+
+    for arr in array.iter() {
+        if let Some(arr) = arr {
+            let res = match arr.data_type() {
+                DataType::List(_) => {
+                    let arr = downcast_arg!(arr, ListArray);
+                    let mut res = 1;
+                    for i in 0..arr.len() {
+                        if arr.value_length(i) > 0 {
+                            res = 0;
+                            break;
+                        }
+                    }
+                    res
+                }
+                DataType::Null => 1,
+                _ => 0,
+            };
+            builder.append_value(res);
+        } else {
+            builder.append_value(1);
+        }
+    }
+    Ok(Arc::new(builder.finish()))
+}
+
 /// Array_repeat SQL function
 pub fn array_repeat(args: &[ArrayRef]) -> Result<ArrayRef> {
     let element = &args[0];
@@ -2988,6 +3018,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_array_empty() {
+        // array_dims([[1, 2, 3, 4], [5, 6, 7, 8]]) = [2, 4]
+        let list_array = return_nested_array().into_array(1);
+
+        let array = array_empty(&[list_array])
+            .expect("failed to initialize function array_empty");
+        // println!("{:?}", array);
+        let result = array.as_any().downcast_ref::<UInt8Array>();
+
+        assert_eq!(&[1], result.unwrap().values())
+    }
+
     #[test]
     fn test_nested_array_dims() {
         // array_dims([[1, 2, 3, 4], [5, 6, 7, 8]]) = [2, 4]

datafusion/physical-expr/src/functions.rs

@@ -425,6 +425,9 @@ pub fn create_physical_fun(
         BuiltinScalarFunction::ArrayConcat => {
             Arc::new(|args| make_scalar_function(array_expressions::array_concat)(args))
         }
+        BuiltinScalarFunction::ArrayEmpty => {
+            Arc::new(|args| make_scalar_function(array_expressions::array_empty)(args))
+        }
         BuiltinScalarFunction::ArrayHasAll => {
             Arc::new(|args| make_scalar_function(array_expressions::array_has_all)(args))
         }

datafusion/proto/src/generated/prost.rs

@@ -452,6 +452,7 @@ impl From<&protobuf::ScalarFunction> for BuiltinScalarFunction {
             ScalarFunction::ToTimestamp => Self::ToTimestamp,
             ScalarFunction::ArrayAppend => Self::ArrayAppend,
             ScalarFunction::ArrayConcat => Self::ArrayConcat,
+            ScalarFunction::ArrayEmpty => Self::ArrayEmpty,
             ScalarFunction::ArrayHasAll => Self::ArrayHasAll,
             ScalarFunction::ArrayHasAny => Self::ArrayHasAny,
             ScalarFunction::ArrayHas => Self::ArrayHas,

datafusion/proto/src/logical_plan/from_proto.rs

@@ -1451,6 +1451,7 @@ impl TryFrom<&BuiltinScalarFunction> for protobuf::ScalarFunction {
             BuiltinScalarFunction::ToTimestamp => Self::ToTimestamp,
             BuiltinScalarFunction::ArrayAppend => Self::ArrayAppend,
             BuiltinScalarFunction::ArrayConcat => Self::ArrayConcat,
+            BuiltinScalarFunction::ArrayEmpty => Self::ArrayEmpty,
             BuiltinScalarFunction::ArrayHasAll => Self::ArrayHasAll,
             BuiltinScalarFunction::ArrayHasAny => Self::ArrayHasAny,
             BuiltinScalarFunction::ArrayHas => Self::ArrayHas,

datafusion/proto/src/logical_plan/to_proto.rs

@@ -2363,6 +2363,16 @@ from flatten_table;
 [1, 2, 3] [1, 2, 3, 4, 5, 6] [1, 2, 3] [1.0, 2.1, 2.2, 3.2, 3.3, 3.4]
 [1, 2, 3, 4, 5, 6] [8] [1, 2, 3] [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
 
+query B
+select empty(make_array(1));
+----
+0
+
+query B
+select empty(make_array());
+----
+1
+
 ### Delete tables
 
 statement ok