ARROW-11310: [Rust] implement JSON writer

rust/arrow/src/array/array_list.rs

@@ -24,7 +24,7 @@ use num::Num;
 
 use super::{
     array::print_long_array, make_array, raw_pointer::RawPtrBox, Array, ArrayDataRef,
-    ArrayRef,
+    ArrayRef, GenericListArrayIter,
 };
 use crate::datatypes::ArrowNativeType;
 use crate::datatypes::*;
@@ -102,6 +102,20 @@ impl<OffsetSize: OffsetSizeTrait> GenericListArray<OffsetSize> {
     fn value_offset_at(&self, i: usize) -> OffsetSize {
         unsafe { *self.value_offsets.as_ptr().add(i) }
     }
+
+    /// constructs a new iterator
+    pub fn iter<'a>(&'a self) -> GenericListArrayIter<'a, OffsetSize> {
+        GenericListArrayIter::<'a, OffsetSize>::new(&self)
+    }
+}
+
+impl<'a, S: OffsetSizeTrait> IntoIterator for &'a GenericListArray<S> {
+    type Item = Option<ArrayRef>;
+    type IntoIter = GenericListArrayIter<'a, S>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        GenericListArrayIter::<'a, S>::new(self)
+    }
 }
 
 impl<OffsetSize: OffsetSizeTrait> From<ArrayDataRef> for GenericListArray<OffsetSize> {

rust/arrow/src/array/cast.rs

@@ -40,12 +40,25 @@ where
         .expect("Unable to downcast to dictionary array")
 }
 
-pub fn as_list_array<S: OffsetSizeTrait>(arr: &ArrayRef) -> &GenericListArray<S> {
+#[doc = "Force downcast ArrayRef to GenericListArray"]
+pub fn as_generic_list_array<S: OffsetSizeTrait>(arr: &ArrayRef) -> &GenericListArray<S> {
     arr.as_any()
         .downcast_ref::<GenericListArray<S>>()
         .expect("Unable to downcast to list array")
 }
 
+#[doc = "Force downcast ArrayRef to ListArray"]
+#[inline]
+pub fn as_list_array(arr: &ArrayRef) -> &ListArray {
+    as_generic_list_array::<i32>(arr)
+}
+
+#[doc = "Force downcast ArrayRef to LargeListArray"]
+#[inline]
+pub fn as_large_list_array(arr: &ArrayRef) -> &LargeListArray {
+    as_generic_list_array::<i64>(arr)
+}
+
 macro_rules! array_downcast_fn {
     ($name: ident, $arrty: ty, $arrty_str:expr) => {
         #[doc = "Force downcast ArrayRef to "]

rust/arrow/src/array/iterator.rs

@@ -18,8 +18,9 @@
 use crate::datatypes::ArrowPrimitiveType;
 
 use super::{
-    Array, BinaryOffsetSizeTrait, BooleanArray, GenericBinaryArray, GenericStringArray,
-    PrimitiveArray, StringOffsetSizeTrait,
+    Array, ArrayRef, BinaryOffsetSizeTrait, BooleanArray, GenericBinaryArray,
+    GenericListArray, GenericStringArray, OffsetSizeTrait, PrimitiveArray,
+    StringOffsetSizeTrait,
 };
 
 /// an iterator that returns Some(T) or None, that can be used on any PrimitiveArray
@@ -238,6 +239,47 @@ impl<'a, T: BinaryOffsetSizeTrait> std::iter::Iterator for GenericBinaryIter<'a,
     }
 }
 
+#[derive(Debug)]
+pub struct GenericListArrayIter<'a, S>
+where
+    S: OffsetSizeTrait,
+{
+    array: &'a GenericListArray<S>,
+    i: usize,
+    len: usize,
+}
+
+impl<'a, S: OffsetSizeTrait> GenericListArrayIter<'a, S> {
+    pub fn new(array: &'a GenericListArray<S>) -> Self {
+        GenericListArrayIter::<S> {
+            array,
+            i: 0,
+            len: array.len(),
+        }
+    }
+}
+
+impl<'a, S: OffsetSizeTrait> std::iter::Iterator for GenericListArrayIter<'a, S> {
+    type Item = Option<ArrayRef>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let i = self.i;
+        if i >= self.len {
+            None
+        } else if self.array.is_null(i) {
+            self.i += 1;
+            Some(None)
+        } else {
+            self.i += 1;
+            Some(Some(self.array.value(i)))
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len - self.i, Some(self.len - self.i))
+    }
+}
+
 /// all arrays have known size.
 impl<'a, T: BinaryOffsetSizeTrait> std::iter::ExactSizeIterator
     for GenericBinaryIter<'a, T>

rust/arrow/src/array/mod.rs

@@ -271,8 +271,9 @@ pub use self::ord::{build_compare, DynComparator};
 // --------------------- Array downcast helper functions ---------------------
 
 pub use self::cast::{
-    as_boolean_array, as_dictionary_array, as_largestring_array, as_list_array,
-    as_null_array, as_primitive_array, as_string_array, as_struct_array,
+    as_boolean_array, as_dictionary_array, as_generic_list_array, as_large_list_array,
+    as_largestring_array, as_list_array, as_null_array, as_primitive_array,
+    as_string_array, as_struct_array,
 };
 
 // ------------------------------ C Data Interface ---------------------------

rust/arrow/src/compute/kernels/sort.rs

@@ -501,7 +501,7 @@ where
         .downcast_ref::<FixedSizeListArray>()
         .map_or_else(
             || {
-                let values = as_list_array::<S>(values);
+                let values = as_generic_list_array::<S>(values);
                 value_indices
                     .iter()
                     .copied()

rust/arrow/src/json/mod.rs

@@ -18,6 +18,8 @@
 //! Transfer data between the Arrow memory format and JSON line-delimited records.
 
 pub mod reader;
+pub mod writer;
 
 pub use self::reader::Reader;
 pub use self::reader::ReaderBuilder;
+pub use self::writer::Writer;