Add a new method to check for compatible datatypes

The new method will look if two datatypes are compatible which each other,
ignoring the field order and length and fail if missing and not nullable.

Array data type comparison will use the equals_datatype instead of
comparing the enums itself.

Author: nl5887

arrow/src/compute/kernels/concat.rs

@@ -62,7 +62,7 @@ pub fn concat(arrays: &[&dyn Array]) -> Result<ArrayRef> {
 
     if arrays
         .iter()
-        .any(|array| array.data_type() != arrays[0].data_type())
+        .any(|array| !array.data_type().equals_datatype(arrays[0].data_type()))
     {
         return Err(ArrowError::InvalidArgumentError(
             "It is not possible to concatenate arrays of different data types."

arrow/src/datatypes/datatype.rs

@@ -669,6 +669,45 @@ impl DataType {
         )
     }
 
+    /// Compares the datatype with another for compatibility.
+    pub fn compatible_datatype(&self, other: &DataType) -> bool {
+        match (&self, other) {
+            (DataType::List(a), DataType::List(b))
+            | (DataType::LargeList(a), DataType::LargeList(b)) => {
+                a.is_nullable() == b.is_nullable()
+                    && a.data_type().equals_datatype(b.data_type())
+            }
+            (DataType::FixedSizeList(a, a_size), DataType::FixedSizeList(b, b_size)) => {
+                a_size == b_size
+                    && a.is_nullable() == b.is_nullable()
+                    && a.data_type().equals_datatype(b.data_type())
+            }
+            (DataType::Struct(a), DataType::Struct(b)) => {
+                a.iter()
+                    .all(|a| match b.iter().find(|f| f.name().eq(a.name())) {
+                        Some(b) => {
+                            a.is_nullable() == b.is_nullable()
+                                && a.data_type().equals_datatype(b.data_type())
+                        }
+                        None => a.is_nullable(),
+                    })
+                    && b.iter()
+                        .all(|b| match a.iter().find(|f| f.name().eq(b.name())) {
+                            Some(a) => {
+                                a.is_nullable() == b.is_nullable()
+                                    && a.data_type().equals_datatype(b.data_type())
+                            }
+                            None => b.is_nullable(),
+                        })
+            }
+            (
+                DataType::Map(a_field, a_is_sorted),
+                DataType::Map(b_field, b_is_sorted),
+            ) => a_field == b_field && a_is_sorted == b_is_sorted,
+            _ => self == other,
+        }
+    }
+
     /// Compares the datatype with another, ignoring nested field names
     /// and metadata.
     pub(crate) fn equals_datatype(&self, other: &DataType) -> bool {