remove arrow from Canonical::empty (#2105)

Arrow Lists are nullable but elements of those lists are not. In
`Identity::return_dtype`, previous behaviour returned `list(i64?)?` when
given `list(i64)?`

Author: onursatici

vortex-array/src/canonical.rs

@@ -16,13 +16,14 @@ use arrow_schema::{DataType, Field, FieldRef, Fields};
 use itertools::Itertools;
 use vortex_datetime_dtype::{is_temporal_ext_type, TemporalMetadata, TimeUnit};
 use vortex_dtype::{DType, NativePType, PType};
-use vortex_error::{vortex_bail, VortexError, VortexResult};
+use vortex_error::{vortex_bail, VortexError, VortexExpect, VortexResult};
 
 use crate::array::{
     varbinview_as_arrow, BoolArray, ExtensionArray, ListArray, NullArray, PrimitiveArray,
     StructArray, TemporalArray, VarBinViewArray,
 };
 use crate::arrow::{infer_data_type, FromArrowArray};
+use crate::builders::builder_with_capacity;
 use crate::compute::try_cast;
 use crate::encoding::Encoding;
 use crate::stats::ArrayStatistics;
@@ -100,13 +101,12 @@ impl Canonical {
 
 impl Canonical {
     // Create an empty canonical array of the given dtype.
-    pub fn empty(dtype: &DType) -> VortexResult<Canonical> {
-        let arrow_dtype = infer_data_type(dtype)?;
-        ArrayData::from_arrow(
-            arrow_array::new_empty_array(&arrow_dtype),
-            dtype.is_nullable(),
-        )
-        .into_canonical()
+    pub fn empty(dtype: &DType) -> Canonical {
+        Self::try_empty(dtype).vortex_expect("Cannot build an empty array")
+    }
+
+    pub fn try_empty(dtype: &DType) -> VortexResult<Canonical> {
+        builder_with_capacity(dtype, 0).finish()?.into_canonical()
     }
 }
 

vortex-array/src/compute/compare.rs

@@ -124,7 +124,7 @@ pub fn compare(
         DType::Bool((left.dtype().is_nullable() || right.dtype().is_nullable()).into());
 
     if left.is_empty() {
-        return Ok(Canonical::empty(&result_dtype)?.into_array());
+        return Ok(Canonical::empty(&result_dtype).into_array());
     }
 
     // Always try to put constants on the right-hand side so encodings can optimise themselves.

vortex-array/src/compute/filter.rs

@@ -54,7 +54,7 @@ pub fn filter(array: &ArrayData, mask: &Mask) -> VortexResult<ArrayData> {
 
     // Fast-path for empty mask.
     if true_count == 0 {
-        return Ok(Canonical::empty(array.dtype())?.into());
+        return Ok(Canonical::empty(array.dtype()).into());
     }
 
     // Fast-path for full mask

vortex-expr/src/identity.rs

@@ -50,6 +50,10 @@ pub fn ident() -> ExprRef {
 
 #[cfg(test)]
 mod tests {
+    use std::sync::Arc;
+
+    use vortex_dtype::{DType, Nullability, PType};
+
     use crate::{ident, test_harness};
 
     #[test]
@@ -58,4 +62,13 @@ mod tests {
         assert_eq!(ident().return_dtype(&dtype).unwrap(), dtype);
         assert_eq!(ident().return_dtype(&dtype).unwrap(), dtype);
     }
+
+    #[test]
+    fn list_dtype() {
+        let in_dtype = DType::List(
+            Arc::new(DType::Primitive(PType::I64, Nullability::NonNullable)),
+            Nullability::Nullable,
+        );
+        assert_eq!(ident().return_dtype(&in_dtype).unwrap(), in_dtype);
+    }
 }

vortex-expr/src/lib.rs

@@ -69,7 +69,7 @@ pub trait VortexExpr: Debug + Send + Sync + DynEq + DynHash + Display {
 
     /// Compute the type of the array returned by [VortexExpr::evaluate].
     fn return_dtype(&self, scope_dtype: &DType) -> VortexResult<DType> {
-        let empty = Canonical::empty(scope_dtype)?.into_array();
+        let empty = Canonical::empty(scope_dtype).into_array();
         self.unchecked_evaluate(&empty)
             .map(|array| array.dtype().clone())
     }