Implement logical_null_count for more array types (#6704)

Implement Array::logical_null_count() where it's easy to calculate
answer without relying on the default implementation which allocates.

arrow-array/src/array/byte_array.rs

@@ -461,6 +461,11 @@ impl<T: ByteArrayType> Array for GenericByteArray<T> {
         self.nulls.as_ref()
     }
 
+    fn logical_null_count(&self) -> usize {
+        // More efficient that the default implementation
+        self.null_count()
+    }
+
     fn get_buffer_memory_size(&self) -> usize {
         let mut sum = self.value_offsets.inner().inner().capacity();
         sum += self.value_data.capacity();

arrow-array/src/array/byte_view_array.rs

@@ -583,6 +583,11 @@ impl<T: ByteViewType + ?Sized> Array for GenericByteViewArray<T> {
         self.nulls.as_ref()
     }
 
+    fn logical_null_count(&self) -> usize {
+        // More efficient that the default implementation
+        self.null_count()
+    }
+
     fn get_buffer_memory_size(&self) -> usize {
         let mut sum = self.buffers.iter().map(|b| b.capacity()).sum::<usize>();
         sum += self.views.inner().capacity();

arrow-array/src/array/dictionary_array.rs

@@ -866,6 +866,10 @@ impl<K: ArrowDictionaryKeyType, V: Sync> Array for TypedDictionaryArray<'_, K, V
         self.dictionary.logical_nulls()
     }
 
+    fn logical_null_count(&self) -> usize {
+        self.dictionary.logical_null_count()
+    }
+
     fn is_nullable(&self) -> bool {
         self.dictionary.is_nullable()
     }

arrow-array/src/array/fixed_size_binary_array.rs

@@ -610,6 +610,11 @@ impl Array for FixedSizeBinaryArray {
         self.nulls.as_ref()
     }
 
+    fn logical_null_count(&self) -> usize {
+        // More efficient that the default implementation
+        self.null_count()
+    }
+
     fn get_buffer_memory_size(&self) -> usize {
         let mut sum = self.value_data.capacity();
         if let Some(n) = &self.nulls {

arrow-array/src/array/fixed_size_list_array.rs

@@ -409,6 +409,11 @@ impl Array for FixedSizeListArray {
         self.nulls.as_ref()
     }
 
+    fn logical_null_count(&self) -> usize {
+        // More efficient that the default implementation
+        self.null_count()
+    }
+
     fn get_buffer_memory_size(&self) -> usize {
         let mut size = self.values.get_buffer_memory_size();
         if let Some(n) = self.nulls.as_ref() {

arrow-array/src/array/list_array.rs

@@ -493,6 +493,11 @@ impl<OffsetSize: OffsetSizeTrait> Array for GenericListArray<OffsetSize> {
         self.nulls.as_ref()
     }
 
+    fn logical_null_count(&self) -> usize {
+        // More efficient that the default implementation
+        self.null_count()
+    }
+
     fn get_buffer_memory_size(&self) -> usize {
         let mut size = self.values.get_buffer_memory_size();
         size += self.value_offsets.inner().inner().capacity();

arrow-array/src/array/list_view_array.rs

@@ -334,6 +334,11 @@ impl<OffsetSize: OffsetSizeTrait> Array for GenericListViewArray<OffsetSize> {
         self.nulls.as_ref()
     }
 
+    fn logical_null_count(&self) -> usize {
+        // More efficient that the default implementation
+        self.null_count()
+    }
+
     fn get_buffer_memory_size(&self) -> usize {
         let mut size = self.values.get_buffer_memory_size();
         size += self.value_offsets.inner().capacity();

arrow-array/src/array/map_array.rs

@@ -380,6 +380,11 @@ impl Array for MapArray {
         self.nulls.as_ref()
     }
 
+    fn logical_null_count(&self) -> usize {
+        // More efficient that the default implementation
+        self.null_count()
+    }
+
     fn get_buffer_memory_size(&self) -> usize {
         let mut size = self.entries.get_buffer_memory_size();
         size += self.value_offsets.inner().inner().capacity();

arrow-array/src/array/run_array.rs

@@ -596,6 +596,10 @@ impl<R: RunEndIndexType, V: Sync> Array for TypedRunArray<'_, R, V> {
         self.run_array.logical_nulls()
     }
 
+    fn logical_null_count(&self) -> usize {
+        self.run_array.logical_null_count()
+    }
+
     fn is_nullable(&self) -> bool {
         self.run_array.is_nullable()
     }

arrow-array/src/array/struct_array.rs

@@ -378,6 +378,11 @@ impl Array for StructArray {
         self.nulls.as_ref()
     }
 
+    fn logical_null_count(&self) -> usize {
+        // More efficient that the default implementation
+        self.null_count()
+    }
+
     fn get_buffer_memory_size(&self) -> usize {
         let mut size = self.fields.iter().map(|a| a.get_buffer_memory_size()).sum();
         if let Some(n) = self.nulls.as_ref() {