Fix up tests

Author: friendlymatthew

arrow-array/src/array/union_array.rs

@@ -1721,8 +1721,9 @@ mod tests {
             .len(7)
             .buffers(vec![type_ids, value_offsets])
             .child_data(vec![
-                string_array.into_data(),
+                // Child arrays must be in sorted order by type ID: 4, 8, 9
                 int_array.into_data(),
+                string_array.into_data(),
                 float_array.into_data(),
             ])
             .build()
@@ -1833,8 +1834,9 @@ mod tests {
             .len(7)
             .buffers(vec![type_ids, value_offsets])
             .child_data(vec![
-                string_array.into_data(),
+                // Child arrays must be in sorted order by type ID: 4, 8, 9
                 int_array.into_data(),
+                string_array.into_data(),
                 float_array.into_data(),
             ])
             .build()
@@ -1862,9 +1864,10 @@ mod tests {
             ],
         )
         .unwrap();
+        // Child arrays must be in sorted order by type ID: 2, 3
         let children = vec![
-            Arc::new(StringArray::from_iter_values(["a", "b"])) as _,
             Arc::new(StringArray::from_iter_values(["c", "d"])) as _,
+            Arc::new(StringArray::from_iter_values(["a", "b"])) as _,
         ];
 
         let type_ids = vec![3, 3, 2].into();
@@ -1890,9 +1893,10 @@ mod tests {
             "Invalid argument error: Type Ids values must match one of the field type ids"
         );
 
+        // Child arrays must be in sorted order by type ID: 2, 3
         let children = vec![
-            Arc::new(StringArray::from_iter_values(["a", "b"])) as _,
             Arc::new(StringArray::from_iter_values(["c"])) as _,
+            Arc::new(StringArray::from_iter_values(["a", "b"])) as _,
         ];
         let type_ids = ScalarBuffer::from(vec![3_i8, 3, 2]);
         let offsets = Some(vec![0, 1, 0].into());

arrow-avro/src/reader/record.rs

@@ -4330,8 +4330,17 @@ mod tests {
             avro_children.push(AvroDataType::new(codec, Default::default(), None));
             fields.push(arrow_schema::Field::new(name, dt, true));
         }
-        let union_fields = UnionFields::try_new(type_ids, fields).unwrap();
-        let union_codec = Codec::Union(avro_children.into(), union_fields, UnionMode::Dense);
+        let union_fields = UnionFields::try_new(type_ids.clone(), fields).unwrap();
+
+        // UnionFields are sorted by type_id, so we need to reorder avro_children to match
+        let mut sorted_indices: Vec<usize> = (0..type_ids.len()).collect();
+        sorted_indices.sort_by_key(|&i| type_ids[i]);
+        let sorted_avro_children: Vec<AvroDataType> = sorted_indices
+            .iter()
+            .map(|&i| avro_children[i].clone())
+            .collect();
+
+        let union_codec = Codec::Union(sorted_avro_children.into(), union_fields, UnionMode::Dense);
         AvroDataType::new(union_codec, Default::default(), None)
     }
 
@@ -4396,11 +4405,13 @@ mod tests {
             vec![42, 7],
         );
         let mut dec = Decoder::try_new(&union_dt).unwrap();
-        let r1 = encode_avro_long(0);
+        // after sorting by type_id, schema order is [string(7), null(42)]
+        // to encode null, use branch 1; to encode string, use branch 0
+        let r1 = encode_avro_long(1);
         let mut r2 = Vec::new();
-        r2.extend_from_slice(&encode_avro_long(1));
+        r2.extend_from_slice(&encode_avro_long(0));
         r2.extend_from_slice(&encode_avro_bytes(b"abc"));
-        let r3 = encode_avro_long(0);
+        let r3 = encode_avro_long(1);
         dec.decode(&mut AvroCursor::new(&r1)).unwrap();
         dec.decode(&mut AvroCursor::new(&r2)).unwrap();
         dec.decode(&mut AvroCursor::new(&r3)).unwrap();

arrow-schema/src/fields.rs

@@ -318,7 +318,7 @@ impl<'a> IntoIterator for &'a Fields {
 }
 
 /// A cheaply cloneable, owned collection of [`FieldRef`] and their corresponding type ids
-#[derive(Clone, Eq, Ord, PartialOrd)]
+#[derive(Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(transparent))]
 pub struct UnionFields(Arc<[(i8, FieldRef)]>);
@@ -345,21 +345,6 @@ impl std::ops::Index<usize> for UnionFields {
     }
 }
 
-impl PartialEq for UnionFields {
-    fn eq(&self, other: &Self) -> bool {
-        self.len() == other.len() && self.iter().all(|a| other.iter().any(|b| a == b))
-    }
-}
-
-impl Hash for UnionFields {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        let mut v = self.0.iter().collect::<Vec<_>>();
-        v.sort_by_key(|(id, _)| *id);
-
-        v.hash(state);
-    }
-}
-
 impl UnionFields {
     /// Create a new [`UnionFields`] with no fields
     pub fn empty() -> Self {