Added Debug and PartialEq for MapArray

src/array/equal/mod.rs

@@ -165,6 +165,18 @@ impl PartialEq<&dyn Array> for UnionArray {
     }
 }
 
+impl PartialEq<MapArray> for MapArray {
+    fn eq(&self, other: &Self) -> bool {
+        map::equal(self, other)
+    }
+}
+
+impl PartialEq<&dyn Array> for MapArray {
+    fn eq(&self, other: &&dyn Array) -> bool {
+        equal(self, *other)
+    }
+}
+
 /// Logically compares two [`Array`]s.
 /// Two arrays are logically equal if and only if:
 /// * their data types are equal

src/array/map/fmt.rs

@@ -0,0 +1,24 @@
+use std::fmt::{Debug, Formatter, Result, Write};
+
+use super::super::fmt::{get_display, write_vec};
+use super::MapArray;
+
+pub fn write_value<W: Write>(
+    array: &MapArray,
+    index: usize,
+    null: &'static str,
+    f: &mut W,
+) -> Result {
+    let values = array.value(index);
+    let writer = |f: &mut W, index| get_display(values.as_ref(), null)(f, index);
+    write_vec(f, writer, None, values.len(), null, false)
+}
+
+impl Debug for MapArray {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        let writer = |f: &mut Formatter, index| write_value(self, index, "None", f);
+
+        write!(f, "MapArray")?;
+        write_vec(f, writer, self.validity.as_ref(), self.len(), "None", false)
+    }
+}

src/array/map/mod.rs

@@ -10,11 +10,12 @@ use crate::{
 use super::{new_empty_array, specification::try_check_offsets, Array};
 
 mod ffi;
+mod fmt;
 mod iterator;
 pub use iterator::*;
 
 /// An array representing a (key, value), both of arbitrary logical types.
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct MapArray {
     data_type: DataType,
     // invariant: field.len() == offsets.len() - 1

src/array/mod.rs

@@ -240,7 +240,7 @@ impl std::fmt::Debug for dyn Array + '_ {
                     fmt_dyn!(self, DictionaryArray::<$T>, f)
                 })
             }
-            Map => todo!(),
+            Map => fmt_dyn!(self, MapArray, f),
         }
     }
 }

src/io/parquet/read/deserialize/binary/basic.rs

@@ -68,7 +68,8 @@ pub(super) struct Required<'a> {
 
 impl<'a> Required<'a> {
     pub fn new(page: &'a DataPage) -> Self {
-        let values = SizedBinaryIter::new(page.buffer(), page.num_values());
+        let (_, _, values) = utils::split_buffer(page);
+        let values = SizedBinaryIter::new(values, page.num_values());
 
         Self { values }
     }

src/io/parquet/read/deserialize/binary/nested.rs

@@ -120,6 +120,7 @@ impl<'a, O: Offset> utils::Decoder<'a> for BinaryDecoder<O> {
                 }
             }
             State::OptionalDictionary(page_validity, page_values) => {
+                println!("optional_dict");
                 let dict_values = page_values.dict.values();
                 let dict_offsets = page_values.dict.offsets();
 

src/io/parquet/read/deserialize/boolean/basic.rs

@@ -55,8 +55,9 @@ struct FilteredRequired<'a> {
 
 impl<'a> FilteredRequired<'a> {
     pub fn new(page: &'a DataPage) -> Self {
+        let (_, _, values) = utils::split_buffer(page);
         // todo: replace this by an iterator over slices, for faster deserialization
-        let values = BitmapIter::new(page.buffer(), 0, page.num_values());
+        let values = BitmapIter::new(values, 0, page.num_values());
 
         let rows = get_selected_rows(page);
         let values = SliceFilteredIter::new(values, rows);

src/io/parquet/read/deserialize/boolean/nested.rs

@@ -25,8 +25,9 @@ struct Required<'a> {
 
 impl<'a> Required<'a> {
     pub fn new(page: &'a DataPage) -> Self {
+        let (_, _, values) = utils::split_buffer(page);
         Self {
-            values: page.buffer(),
+            values,
             offset: 0,
             length: page.num_values(),
         }