(arrow-rs) branch main updated: fix: mark `DataType::Map` as unsupported in `RowConverter` (#7880)

[alamb]

This is an automated email from the ASF dual-hosted git repository.

alamb pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git


The following commit(s) were added to refs/heads/main by this push:
     new 387490a7a9 fix: mark `DataType::Map` as unsupported in `RowConverter` 
(#7880)
387490a7a9 is described below

commit 387490a7a97a9ea6d2fcd0105e6a1abaf819a386
Author: Raz Luvaton <16746759+rluva...@users.noreply.github.com>
AuthorDate: Fri Jul 11 15:24:14 2025 +0300

    fix: mark `DataType::Map` as unsupported in `RowConverter` (#7880)
    
    # Which issue does this PR close?
    
    N/A
    
    # Rationale for this change
    
    `MapArray` is marked as supported in `RowConverter` while it's not
    
    # What changes are included in this PR?
    
    Remove `Map` from supported data type and added test that it is
    correctly reported as unsupported
    
    # Are these changes tested?
    
    added tests
    
    # Are there any user-facing changes?
    yes, but it never worked, as the codec failed on Map DataType when
    trying to create `RowConverter`
    
    Related to:
    - #7879
    
    ---------
    
    Co-authored-by: Andrew Lamb <and...@nerdnetworks.org>
---
 arrow-row/src/lib.rs | 52 ++++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 48 insertions(+), 4 deletions(-)

diff --git a/arrow-row/src/lib.rs b/arrow-row/src/lib.rs
index 2a810f9c31..325d2953c8 100644
--- a/arrow-row/src/lib.rs
+++ b/arrow-row/src/lib.rs
@@ -623,10 +623,9 @@ impl RowConverter {
     fn supports_datatype(d: &DataType) -> bool {
         match d {
             _ if !d.is_nested() => true,
-            DataType::List(f)
-            | DataType::LargeList(f)
-            | DataType::FixedSizeList(f, _)
-            | DataType::Map(f, _) => Self::supports_datatype(f.data_type()),
+            DataType::List(f) | DataType::LargeList(f) | 
DataType::FixedSizeList(f, _) => {
+                Self::supports_datatype(f.data_type())
+            }
             DataType::Struct(f) => f.iter().all(|x| 
Self::supports_datatype(x.data_type())),
             DataType::RunEndEncoded(_, values) => 
Self::supports_datatype(values.data_type()),
             _ => false,
@@ -3119,4 +3118,49 @@ mod tests {
         let rows = converter.convert_columns(&[Arc::new(a) as _]).unwrap();
         assert_eq!(rows.row(0).cmp(&rows.row(1)), Ordering::Less);
     }
+
+    #[test]
+    fn map_should_be_marked_as_unsupported() {
+        let map_data_type = Field::new_map(
+            "map",
+            "entries",
+            Field::new("key", DataType::Utf8, false),
+            Field::new("value", DataType::Utf8, true),
+            false,
+            true,
+        )
+        .data_type()
+        .clone();
+
+        let is_supported = 
RowConverter::supports_fields(&[SortField::new(map_data_type)]);
+
+        assert!(!is_supported, "Map should not be supported");
+    }
+
+    #[test]
+    fn should_fail_to_create_row_converter_for_unsupported_map_type() {
+        let map_data_type = Field::new_map(
+            "map",
+            "entries",
+            Field::new("key", DataType::Utf8, false),
+            Field::new("value", DataType::Utf8, true),
+            false,
+            true,
+        )
+        .data_type()
+        .clone();
+
+        let converter = RowConverter::new(vec![SortField::new(map_data_type)]);
+
+        match converter {
+            Err(ArrowError::NotYetImplemented(message)) => {
+                assert!(
+                    message.contains("Row format support not yet implemented 
for"),
+                    "Expected NotYetImplemented error for map data type, got: 
{message}",
+                );
+            }
+            Err(e) => panic!("Expected NotYetImplemented error, got: {e}"),
+            Ok(_) => panic!("Expected NotYetImplemented error for map data 
type"),
+        }
+    }
 }