refactor(vortex-geo): drop redundant all-true filter guards

ArrayRef::filter collapses an all-true mask back to the input (Filter's reduce
rule + optimize), so the if valid.all_true() guards in GeometryAabb::accumulate
and the execute helpers were redundant. Filter unconditionally; all-valid
inputs pass through unchanged.

Signed-off-by: Nemo Yu <zyu379@wisc.edu>

Author: HarukiMoriarty

vortex-geo/src/aggregate_fn/aabb.rs

@@ -204,13 +204,10 @@ impl AggregateFnVTable for GeometryAabb {
         };
         // Drop null rows before reading coordinates: a null geometry's storage holds placeholder
         // coordinates (e.g. `(0, 0)`) that would otherwise widen the zone box and drag it toward
-        // the origin.
+        // the origin. `filter` collapses an all-true mask back to the input, so a null-free batch
+        // passes through unchanged.
         let valid = array.validity()?.execute_mask(array.len(), ctx)?;
-        let array = if valid.all_true() {
-            array
-        } else {
-            array.filter(valid)?
-        };
+        let array = array.filter(valid)?;
         // Null rows are gone, so every coordinate below belongs to a present geometry — the
         // `unmasked_field_by_name` reads are therefore safe. Min/max the raw x/y buffers directly:
         // cheap, and avoids `to_geometry`'s panic on empty points (which decoding would hit).

vortex-geo/src/scalar_fn/execute.rs

@@ -188,13 +188,9 @@ where
 {
     let len = column.len();
     let valid = column.validity()?.execute_mask(len, ctx)?;
-    // Decode only the non-null rows, since a null row has no geometry to decode. The common
-    // all-valid case decodes the column directly and skips the filter.
-    let decoded = if valid.all_true() {
-        geometries(column, ctx)?
-    } else {
-        geometries(&column.filter(valid.clone())?, ctx)?
-    };
+    // Drop the null rows before decoding, since a null row has no geometry to decode. `filter`
+    // collapses an all-true mask, so an all-valid column passes through unchanged.
+    let decoded = geometries(&column.filter(valid.clone())?, ctx)?;
     let values = decoded.iter().map(f).collect();
     Ok(T::build_array(len, &valid, values, nullability))
 }
@@ -217,15 +213,10 @@ where
     let b_present = b.validity()?.execute_mask(len, ctx)?;
     // A row survives only where both columns are present.
     let valid = &a_present & &b_present;
-    // Keep only the rows valid in both columns, so decoding never sees a null geometry. The
-    // common all-valid case decodes the columns directly and skips the filter.
-    let (a, b) = if valid.all_true() {
-        (a.clone(), b.clone())
-    } else {
-        (a.filter(valid.clone())?, b.filter(valid.clone())?)
-    };
-    let ag = geometries(&a, ctx)?;
-    let bg = geometries(&b, ctx)?;
+    // Keep only the rows valid in both columns, so decoding never sees a null geometry. `filter`
+    // collapses an all-true mask, so all-valid columns pass through unchanged.
+    let ag = geometries(&a.filter(valid.clone())?, ctx)?;
+    let bg = geometries(&b.filter(valid.clone())?, ctx)?;
     let values = ag.iter().zip(&bg).map(|(x, y)| compute(x, y)).collect();
     Ok(T::build_array(len, &valid, values, nullability))
 }