@@ -8,6 +8,7 @@ use vortex_dtype::FieldNames;
88use vortex_dtype:: Nullability ;
99use vortex_dtype:: PType ;
1010use vortex_error:: VortexResult ;
11+ use vortex_mask:: Mask ;
1112
1213use crate :: Array ;
1314use crate :: IntoArray ;
@@ -150,3 +151,193 @@ fn test_uncompressed_size_in_bytes() -> VortexResult<()> {
150151 assert_eq ! ( uncompressed_size, Some ( 4000 ) ) ;
151152 Ok ( ( ) )
152153}
154+
155+ #[ test]
156+ fn test_masked_fields_without_validity_pushed_down ( ) -> VortexResult < ( ) > {
157+ // Create a nullable struct with struct-level nulls at positions 1 and 3
158+ // Fields are non-nullable, so struct validity should be applied to all fields
159+ let field_a = PrimitiveArray :: new ( buffer ! [ 10i32 , 20 , 30 , 40 ] , Validity :: NonNullable ) ;
160+ let field_b = PrimitiveArray :: new ( buffer ! [ 100i32 , 200 , 300 , 400 ] , Validity :: NonNullable ) ;
161+
162+ let struct_validity = Validity :: Array (
163+ BoolArray :: from_iter ( [ true , false , true , false ] ) . into_array ( ) , // positions 1, 3 are null
164+ ) ;
165+ let expected_mask = Mask :: from_iter ( [ true , false , true , false ] ) ;
166+
167+ let struct_array = StructArray :: try_new (
168+ FieldNames :: from ( [ "a" , "b" ] ) ,
169+ vec ! [ field_a. into_array( ) , field_b. into_array( ) ] ,
170+ 4 ,
171+ struct_validity,
172+ ) ?;
173+
174+ // Verify validity is NOT pushed down by default
175+ assert ! ( !struct_array. has_validity_pushed_down( ) ) ;
176+
177+ // === Test masked_fields ===
178+ let masked = struct_array. masked_fields ( ) ?;
179+ assert_eq ! ( masked. len( ) , 2 ) ;
180+
181+ // Both fields should have struct validity applied
182+ assert ! ( masked[ 0 ] . dtype( ) . is_nullable( ) ) ;
183+ assert_eq ! ( masked[ 0 ] . validity_mask( ) ?, expected_mask) ;
184+ assert ! ( masked[ 1 ] . dtype( ) . is_nullable( ) ) ;
185+ assert_eq ! ( masked[ 1 ] . validity_mask( ) ?, expected_mask) ;
186+
187+ // === Test field_by_name ===
188+ let field_a_by_name = struct_array. field_by_name ( "a" ) ?;
189+ assert ! ( field_a_by_name. dtype( ) . is_nullable( ) ) ;
190+ assert_eq ! ( field_a_by_name. validity_mask( ) ?, expected_mask) ;
191+
192+ let field_b_by_name = struct_array. field_by_name ( "b" ) ?;
193+ assert ! ( field_b_by_name. dtype( ) . is_nullable( ) ) ;
194+ assert_eq ! ( field_b_by_name. validity_mask( ) ?, expected_mask) ;
195+
196+ Ok ( ( ) )
197+ }
198+
199+ #[ test]
200+ fn test_masked_fields_with_validity_pushed_down ( ) -> VortexResult < ( ) > {
201+ // Create nullable fields where validity has already been pushed down
202+ // (child nulls include struct nulls at positions 1 and 3)
203+ let field_a = PrimitiveArray :: new (
204+ buffer ! [ 10i32 , 20 , 30 , 40 ] ,
205+ Validity :: Array ( BoolArray :: from_iter ( [ true , false , true , false ] ) . into_array ( ) ) ,
206+ ) ;
207+ let field_b = PrimitiveArray :: new (
208+ buffer ! [ 100i32 , 200 , 300 , 400 ] ,
209+ Validity :: Array ( BoolArray :: from_iter ( [ true , false , true , false ] ) . into_array ( ) ) ,
210+ ) ;
211+
212+ let struct_validity =
213+ Validity :: Array ( BoolArray :: from_iter ( [ true , false , true , false ] ) . into_array ( ) ) ;
214+ let expected_mask = Mask :: from_iter ( [ true , false , true , false ] ) ;
215+
216+ let struct_array = StructArray :: try_new (
217+ FieldNames :: from ( [ "a" , "b" ] ) ,
218+ vec ! [ field_a. into_array( ) , field_b. into_array( ) ] ,
219+ 4 ,
220+ struct_validity,
221+ ) ?
222+ . with_validity_pushed_down ( true ) ;
223+
224+ // Verify validity IS pushed down
225+ assert ! ( struct_array. has_validity_pushed_down( ) ) ;
226+
227+ // === Test masked_fields ===
228+ let masked = struct_array. masked_fields ( ) ?;
229+ assert_eq ! ( masked. len( ) , 2 ) ;
230+
231+ // Nullable fields returned as-is (validity already pushed)
232+ assert ! ( masked[ 0 ] . dtype( ) . is_nullable( ) ) ;
233+ assert_eq ! ( masked[ 0 ] . validity_mask( ) ?, expected_mask) ;
234+ assert ! ( masked[ 1 ] . dtype( ) . is_nullable( ) ) ;
235+ assert_eq ! ( masked[ 1 ] . validity_mask( ) ?, expected_mask) ;
236+
237+ // === Test field_by_name ===
238+ let field_a_by_name = struct_array. field_by_name ( "a" ) ?;
239+ assert ! ( field_a_by_name. dtype( ) . is_nullable( ) ) ;
240+ assert_eq ! ( field_a_by_name. validity_mask( ) ?, expected_mask) ;
241+
242+ let field_b_by_name = struct_array. field_by_name ( "b" ) ?;
243+ assert ! ( field_b_by_name. dtype( ) . is_nullable( ) ) ;
244+ assert_eq ! ( field_b_by_name. validity_mask( ) ?, expected_mask) ;
245+
246+ Ok ( ( ) )
247+ }
248+
249+ #[ test]
250+ fn test_masked_fields_mixed_nullability_with_pushed_down ( ) -> VortexResult < ( ) > {
251+ // Create a struct with mixed nullable and non-nullable fields
252+ // Nullable field has validity pushed down, non-nullable field needs masking
253+ let nullable_field = PrimitiveArray :: new (
254+ buffer ! [ 10i32 , 20 , 30 , 40 ] ,
255+ Validity :: Array ( BoolArray :: from_iter ( [ true , false , true , false ] ) . into_array ( ) ) ,
256+ ) ;
257+ let non_nullable_field =
258+ PrimitiveArray :: new ( buffer ! [ 100i32 , 200 , 300 , 400 ] , Validity :: NonNullable ) ;
259+
260+ let struct_validity =
261+ Validity :: Array ( BoolArray :: from_iter ( [ true , false , true , false ] ) . into_array ( ) ) ;
262+ let expected_mask = Mask :: from_iter ( [ true , false , true , false ] ) ;
263+
264+ let struct_array = StructArray :: try_new (
265+ FieldNames :: from ( [ "nullable" , "non_nullable" ] ) ,
266+ vec ! [ nullable_field. into_array( ) , non_nullable_field. into_array( ) ] ,
267+ 4 ,
268+ struct_validity,
269+ ) ?
270+ . with_validity_pushed_down ( true ) ;
271+
272+ assert ! ( struct_array. has_validity_pushed_down( ) ) ;
273+
274+ // === Test masked_fields ===
275+ let masked = struct_array. masked_fields ( ) ?;
276+
277+ // Nullable field: returned as-is (validity already pushed down)
278+ assert ! ( masked[ 0 ] . dtype( ) . is_nullable( ) ) ;
279+ assert_eq ! ( masked[ 0 ] . validity_mask( ) ?, expected_mask) ;
280+
281+ // Non-nullable field: struct validity applied (becomes nullable)
282+ assert ! ( masked[ 1 ] . dtype( ) . is_nullable( ) ) ;
283+ assert_eq ! ( masked[ 1 ] . validity_mask( ) ?, expected_mask) ;
284+
285+ // === Test field_by_name ===
286+ let nullable_by_name = struct_array. field_by_name ( "nullable" ) ?;
287+ assert ! ( nullable_by_name. dtype( ) . is_nullable( ) ) ;
288+ assert_eq ! ( nullable_by_name. validity_mask( ) ?, expected_mask) ;
289+
290+ let non_nullable_by_name = struct_array. field_by_name ( "non_nullable" ) ?;
291+ assert ! ( non_nullable_by_name. dtype( ) . is_nullable( ) ) ;
292+ assert_eq ! ( non_nullable_by_name. validity_mask( ) ?, expected_mask) ;
293+
294+ Ok ( ( ) )
295+ }
296+
297+ #[ test]
298+ fn test_masked_fields_non_nullable_struct ( ) -> VortexResult < ( ) > {
299+ // Non-nullable struct: fields should be returned unchanged
300+ let field_a = PrimitiveArray :: new ( buffer ! [ 10i32 , 20 , 30 , 40 ] , Validity :: NonNullable ) ;
301+ let field_b = PrimitiveArray :: new (
302+ buffer ! [ 100i32 , 200 , 300 , 400 ] ,
303+ Validity :: Array ( BoolArray :: from_iter ( [ true , true , false , true ] ) . into_array ( ) ) ,
304+ ) ;
305+ let expected_mask_all_valid = Mask :: new_true ( 4 ) ;
306+ let expected_mask_b = Mask :: from_iter ( [ true , true , false , true ] ) ;
307+
308+ let struct_array = StructArray :: try_new (
309+ FieldNames :: from ( [ "a" , "b" ] ) ,
310+ vec ! [ field_a. into_array( ) , field_b. into_array( ) ] ,
311+ 4 ,
312+ Validity :: NonNullable ,
313+ ) ?;
314+
315+ // Non-nullable struct cannot have validity pushed down
316+ assert ! ( !struct_array. has_validity_pushed_down( ) ) ;
317+
318+ // with_validity_pushed_down should be a no-op for non-nullable structs
319+ let struct_array = struct_array. with_validity_pushed_down ( true ) ;
320+ assert ! ( !struct_array. has_validity_pushed_down( ) ) ;
321+
322+ // === Test masked_fields ===
323+ let masked = struct_array. masked_fields ( ) ?;
324+
325+ // Non-nullable field: stays non-nullable (no struct validity to apply)
326+ assert ! ( !masked[ 0 ] . dtype( ) . is_nullable( ) ) ;
327+ assert_eq ! ( masked[ 0 ] . validity_mask( ) ?, expected_mask_all_valid) ;
328+
329+ // Nullable field: keeps its own validity
330+ assert ! ( masked[ 1 ] . dtype( ) . is_nullable( ) ) ;
331+ assert_eq ! ( masked[ 1 ] . validity_mask( ) ?, expected_mask_b) ;
332+
333+ // === Test field_by_name ===
334+ let field_a_by_name = struct_array. field_by_name ( "a" ) ?;
335+ assert ! ( !field_a_by_name. dtype( ) . is_nullable( ) ) ;
336+ assert_eq ! ( field_a_by_name. validity_mask( ) ?, expected_mask_all_valid) ;
337+
338+ let field_b_by_name = struct_array. field_by_name ( "b" ) ?;
339+ assert ! ( field_b_by_name. dtype( ) . is_nullable( ) ) ;
340+ assert_eq ! ( field_b_by_name. validity_mask( ) ?, expected_mask_b) ;
341+
342+ Ok ( ( ) )
343+ }
0 commit comments