feat: add arrow map alias support (#31)

Signed-off-by: Luke Kim <80174+lukekim@users.noreply.github.com>
Co-authored-by: Luke Kim <80174+lukekim@users.noreply.github.com>

Author: phillipleblanc

vortex-array/src/arrays/extension/compute/cast.rs

@@ -175,7 +175,8 @@ fn convert_temporal_value(value: i64, multiply: i64, divide: i64) -> VortexResul
         vortex_bail!(ComputeError: "Date value {value} overflows target timestamp range");
     }
 
-    Ok(scaled as i64)
+    i64::try_from(scaled)
+        .map_err(|_| vortex_error::vortex_err!(ComputeError: "Date value {value} overflows target timestamp range"))
 }
 
 register_kernel!(CastKernelAdapter(ExtensionVTable).lift());
@@ -291,7 +292,10 @@ mod tests {
         let storage = output.storage().to_primitive();
         assert_eq!(storage.scalar_at(0).as_primitive().as_::<i64>(), Some(0));
         assert!(storage.scalar_at(1).is_null());
-        assert_eq!(storage.scalar_at(2).as_primitive().as_::<i64>(), Some(172_800));
+        assert_eq!(
+            storage.scalar_at(2).as_primitive().as_::<i64>(),
+            Some(172_800)
+        );
     }
 
     #[test]

vortex-array/src/arrow/convert.rs

@@ -13,6 +13,7 @@ use arrow_array::GenericByteArray;
 use arrow_array::GenericByteViewArray;
 use arrow_array::GenericListArray;
 use arrow_array::GenericListViewArray;
+use arrow_array::MapArray as ArrowMapArray;
 use arrow_array::NullArray as ArrowNullArray;
 use arrow_array::OffsetSizeTrait;
 use arrow_array::PrimitiveArray as ArrowPrimitiveArray;
@@ -447,6 +448,20 @@ impl FromArrowArray<&ArrowFixedSizeListArray> for ArrayRef {
     }
 }
 
+impl FromArrowArray<&ArrowMapArray> for ArrayRef {
+    fn from_arrow(value: &ArrowMapArray, nullable: bool) -> Self {
+        // Arrow Map is logically List<Struct<key, value>> with i32 offsets.
+        // We convert it to a ListArray of structs.
+        let entries = Self::from_arrow(value.entries() as &dyn ArrowArray, false);
+        let offsets = value.offsets().clone().into_array();
+        let nulls = nulls(value.nulls(), nullable);
+
+        ListArray::try_new(entries, offsets, nulls)
+            .vortex_expect("Failed to convert Arrow MapArray to Vortex ListArray")
+            .into_array()
+    }
+}
+
 impl FromArrowArray<&ArrowNullArray> for ArrayRef {
     fn from_arrow(value: &ArrowNullArray, nullable: bool) -> Self {
         assert!(nullable);
@@ -508,6 +523,7 @@ impl FromArrowArray<&dyn ArrowArray> for ArrayRef {
             DataType::ListView(_) => Self::from_arrow(array.as_list_view::<i32>(), nullable),
             DataType::LargeListView(_) => Self::from_arrow(array.as_list_view::<i64>(), nullable),
             DataType::FixedSizeList(..) => Self::from_arrow(array.as_fixed_size_list(), nullable),
+            DataType::Map(..) => Self::from_arrow(array.as_map(), nullable),
             DataType::Null => Self::from_arrow(as_null_array(array), nullable),
             DataType::Timestamp(u, _) => match u {
                 ArrowTimeUnit::Second => {
@@ -675,6 +691,7 @@ mod tests {
     use crate::arrays::VarBinVTable;
     use crate::arrays::VarBinViewVTable;
     use crate::arrow::FromArrowArray as _;
+    use crate::arrow::executor::ArrowArrayExecutor as _;
 
     // Test primitive array conversions
     #[test]
@@ -1757,4 +1774,54 @@ mod tests {
 
         ArrayRef::from_arrow(null_struct_array_with_non_nullable_field.as_ref(), true);
     }
+
+    #[test]
+    fn test_map_array_conversion() {
+        use arrow_array::MapArray;
+        use arrow_array::builder::MapBuilder;
+        use arrow_array::builder::StringBuilder;
+
+        // Build a MapArray: map<string, int32>
+        let mut builder = MapBuilder::new(None, StringBuilder::new(), Int32Builder::new());
+        // First map entry: {"a": 1, "b": 2}
+        builder.keys().append_value("a");
+        builder.values().append_value(1);
+        builder.keys().append_value("b");
+        builder.values().append_value(2);
+        builder.append(true).unwrap();
+
+        // Second map entry: null
+        builder.append(false).unwrap();
+
+        // Third map entry: {"c": 3}
+        builder.keys().append_value("c");
+        builder.values().append_value(3);
+        builder.append(true).unwrap();
+
+        let arrow_map = builder.finish();
+        assert_eq!(arrow_map.len(), 3);
+
+        // Convert Arrow MapArray → Vortex ListArray
+        let vortex_array = ArrayRef::from_arrow(&arrow_map, true);
+        assert_eq!(vortex_array.len(), 3);
+
+        // Verify it's stored as List<Struct<key, value>>
+        let list_array = vortex_array.as_::<ListVTable>();
+        assert_eq!(list_array.elements().len(), 3); // 3 total key-value pairs
+        let struct_elements = list_array.elements().as_::<StructVTable>();
+        assert_eq!(struct_elements.names().len(), 2); // key and value fields
+
+        // Convert back to Arrow as a MapArray
+        let map_dtype = arrow_map.data_type().clone();
+        let arrow_back = vortex_array
+            .execute_arrow(&map_dtype, &crate::LEGACY_SESSION)
+            .unwrap();
+        let map_back = arrow_back
+            .as_any()
+            .downcast_ref::<MapArray>()
+            .expect("Should be a MapArray");
+        assert_eq!(map_back.len(), 3);
+        assert_eq!(map_back.entries().len(), 3);
+        assert!(map_back.is_null(1)); // Second entry was null
+    }
 }

vortex-array/src/arrow/executor/map.rs

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::Arc;
+
+use arrow_array::ArrayRef as ArrowArrayRef;
+use arrow_array::MapArray as ArrowMapArray;
+use arrow_array::StructArray as ArrowStructArray;
+use arrow_schema::FieldRef;
+use vortex_error::VortexResult;
+use vortex_error::vortex_bail;
+use vortex_session::VortexSession;
+
+use crate::ArrayRef;
+use crate::arrow::executor::list::to_arrow_list;
+
+/// Convert a Vortex List<Struct<key, value>> array into an Arrow MapArray.
+pub(super) fn to_arrow_map(
+    array: ArrayRef,
+    entries_field: &FieldRef,
+    ordered: bool,
+    session: &VortexSession,
+) -> VortexResult<ArrowArrayRef> {
+    // First, convert to Arrow ListArray<i32> since Map uses i32 offsets.
+    let list_array = to_arrow_list::<i32>(array, entries_field, session)?;
+
+    // Downcast to GenericListArray<i32> to extract its components.
+    let Some(list_array) = list_array
+        .as_any()
+        .downcast_ref::<arrow_array::GenericListArray<i32>>()
+    else {
+        vortex_bail!("to_arrow_list returned a non-ListArray when building a MapArray");
+    };
+
+    // Extract components from the ListArray.
+    let (_list_field, offsets, entries, nulls) = list_array.clone().into_parts();
+
+    // The entries should be a StructArray. Downcast it.
+    let Some(entries_struct) = entries.as_any().downcast_ref::<ArrowStructArray>() else {
+        vortex_bail!("Map entries must be a StructArray");
+    };
+    let entries_struct = entries_struct.clone();
+
+    // Build the MapArray from the components.
+    let map_array = ArrowMapArray::try_new(
+        entries_field.clone(),
+        offsets,
+        entries_struct,
+        nulls,
+        ordered,
+    )?;
+
+    Ok(Arc::new(map_array))
+}

vortex-array/src/arrow/executor/mod.rs

@@ -9,6 +9,7 @@ mod dictionary;
 mod fixed_size_list;
 mod list;
 mod list_view;
+mod map;
 mod null;
 mod primitive;
 mod run_end;
@@ -28,7 +29,6 @@ use vortex_error::vortex_bail;
 use vortex_error::vortex_ensure;
 use vortex_session::VortexSession;
 
-use crate::Array;
 use crate::ArrayRef;
 use crate::arrow::executor::bool::to_arrow_bool;
 use crate::arrow::executor::byte::to_arrow_byte_array;
@@ -38,6 +38,7 @@ use crate::arrow::executor::dictionary::to_arrow_dictionary;
 use crate::arrow::executor::fixed_size_list::to_arrow_fixed_list;
 use crate::arrow::executor::list::to_arrow_list;
 use crate::arrow::executor::list_view::to_arrow_list_view;
+use crate::arrow::executor::map::to_arrow_map;
 use crate::arrow::executor::null::to_arrow_null;
 use crate::arrow::executor::primitive::to_arrow_primitive;
 use crate::arrow::executor::run_end::to_arrow_run_end;
@@ -138,8 +139,10 @@ impl ArrowArrayExecutor for ArrayRef {
             DataType::RunEndEncoded(ends_type, values_type) => {
                 to_arrow_run_end(self, ends_type.data_type(), values_type, session)
             }
+            DataType::Map(entries_field, ordered) => {
+                to_arrow_map(self, entries_field, *ordered, session)
+            }
             DataType::FixedSizeBinary(_)
-            | DataType::Map(..)
             | DataType::Duration(_)
             | DataType::Interval(_)
             | DataType::Union(..) => {

vortex-dtype/src/arrow.rs

@@ -148,6 +148,14 @@ impl FromArrowType<(&DataType, Nullability)> for DType {
             | DataType::LargeListView(e) => {
                 DType::List(Arc::new(Self::from_arrow(e.as_ref())), nullability)
             }
+            DataType::Map(entries_field, _ordered) => {
+                // Map is logically List<Struct<key, value>>.
+                // The entries_field contains a Struct type with the key and value fields.
+                DType::List(
+                    Arc::new(Self::from_arrow(entries_field.as_ref())),
+                    nullability,
+                )
+            }
             DataType::FixedSizeList(e, size) => DType::FixedSizeList(
                 Arc::new(Self::from_arrow(e.as_ref())),
                 *size as u32,