feat[array]: validity in display array

Signed-off-by: Joe Isaacs <[email protected]>

Author: joseph-isaacs

vortex-array/src/compute/zip.rs

@@ -329,7 +329,7 @@ mod tests {
         let result = zip(&const1, &const2, &mask).unwrap();
 
         insta::assert_snapshot!(result.display_tree(), @r"
-        root: vortex.varbinview(utf8?, len=100) nbytes=1.66 kB (100.00%) all_valid
+        root: vortex.varbinview(utf8?, len=100) nbytes=1.66 kB (100.00%) [all_valid]
           metadata: EmptyMetadata
           buffer (align=1): 29 B (1.75%)
           buffer (align=1): 28 B (1.69%)
@@ -348,7 +348,7 @@ mod tests {
         insta::assert_snapshot!(wrapped_result.display_tree(), @r"
         root: vortex.struct({nested=utf8?}, len=100) nbytes=1.66 kB (100.00%)
           metadata: EmptyMetadata
-          nested: vortex.varbinview(utf8?, len=100) nbytes=1.66 kB (100.00%)
+          nested: vortex.varbinview(utf8?, len=100) nbytes=1.66 kB (100.00%) [all_valid]
             metadata: EmptyMetadata
             buffer (align=1): 29 B (1.75%)
             buffer (align=1): 28 B (1.69%)

vortex-array/src/display/tree.rs

@@ -1,15 +1,110 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+use std::fmt::Write;
 use std::fmt::{self};
 
 use humansize::DECIMAL;
 use humansize::format_size;
 
+use crate::Array;
 use crate::ArrayRef;
 use crate::ArrayVisitor;
 use crate::arrays::ChunkedVTable;
 use crate::display::DisplayOptions;
+use crate::expr::stats::Stat;
+use crate::expr::stats::StatsProvider;
+
+/// Display wrapper for array statistics in compact format.
+struct StatsDisplay<'a>(&'a dyn Array);
+
+impl fmt::Display for StatsDisplay<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let stats = self.0.statistics();
+        let mut first = true;
+
+        // Helper to write separator
+        let mut sep = |f: &mut fmt::Formatter<'_>| -> fmt::Result {
+            if first {
+                first = false;
+                f.write_str(" [")
+            } else {
+                f.write_str(", ")
+            }
+        };
+
+        // Null count or validity fallback
+        if let Some(nc) = stats.get(Stat::NullCount) {
+            if let Ok(n) = usize::try_from(&nc.clone().into_inner()) {
+                sep(f)?;
+                write!(f, "nulls={}", n)?;
+            } else {
+                sep(f)?;
+                write!(f, "nulls={}", nc)?;
+            }
+        } else if self.0.dtype().is_nullable() {
+            if self.0.all_valid() {
+                sep(f)?;
+                f.write_str("all_valid")?;
+            } else if self.0.all_invalid() {
+                sep(f)?;
+                f.write_str("all_invalid")?;
+            }
+        }
+
+        // NaN count (only if > 0)
+        if let Some(nan) = stats.get(Stat::NaNCount) {
+            if let Ok(n) = usize::try_from(&nan.clone().into_inner()) {
+                if n > 0 {
+                    sep(f)?;
+                    write!(f, "nan={}", n)?;
+                }
+            }
+        }
+
+        // Min/Max
+        if let Some(min) = stats.get(Stat::Min) {
+            sep(f)?;
+            write!(f, "min={}", min)?;
+        }
+        if let Some(max) = stats.get(Stat::Max) {
+            sep(f)?;
+            write!(f, "max={}", max)?;
+        }
+
+        // Sum
+        if let Some(sum) = stats.get(Stat::Sum) {
+            sep(f)?;
+            write!(f, "sum={}", sum)?;
+        }
+
+        // Boolean flags (compact)
+        if let Some(c) = stats.get(Stat::IsConstant) {
+            if bool::try_from(&c.into_inner()).unwrap_or(false) {
+                sep(f)?;
+                f.write_str("const")?;
+            }
+        }
+        if let Some(s) = stats.get(Stat::IsStrictSorted) {
+            if bool::try_from(&s.into_inner()).unwrap_or(false) {
+                sep(f)?;
+                f.write_str("strict")?;
+            }
+        } else if let Some(s) = stats.get(Stat::IsSorted) {
+            if bool::try_from(&s.into_inner()).unwrap_or(false) {
+                sep(f)?;
+                f.write_str("sorted")?;
+            }
+        }
+
+        // Close bracket if we wrote anything
+        if !first {
+            f.write_char(']')?;
+        }
+
+        Ok(())
+    }
+}
 
 pub(crate) struct TreeDisplayWrapper(pub(crate) ArrayRef);
 
@@ -39,16 +134,6 @@ impl<'a, 'b: 'a> TreeFormatter<'a, 'b> {
         } else {
             100_f64 * nbytes as f64 / total_size as f64
         };
-        // Compute validity status string
-        let validity_str = if !array.dtype().is_nullable() {
-            ""
-        } else if array.all_valid() {
-            " all_valid"
-        } else if array.all_invalid() {
-            " all_invalid"
-        } else {
-            ""
-        };
 
         writeln!(
             self,
@@ -57,7 +142,7 @@ impl<'a, 'b: 'a> TreeFormatter<'a, 'b> {
             array.display_as(DisplayOptions::MetadataOnly),
             format_size(nbytes, DECIMAL),
             percent,
-            validity_str
+            StatsDisplay(array.as_ref()),
         )?;
 
         self.indent(|i| {