You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by al...@apache.org on 2021/06/23 13:49:09 UTC
[arrow-rs] branch active_release updated: Doctest for
GenericListArray. (#474) (#496)
This is an automated email from the ASF dual-hosted git repository.
alamb pushed a commit to branch active_release
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git
The following commit(s) were added to refs/heads/active_release by this push:
new eb1d1e1 Doctest for GenericListArray. (#474) (#496)
eb1d1e1 is described below
commit eb1d1e158e2cde8c7f8efed5929d89803a12daa6
Author: Andrew Lamb <an...@nerdnetworks.org>
AuthorDate: Wed Jun 23 09:46:16 2021 -0400
Doctest for GenericListArray. (#474) (#496)
* Doctest for GenericListArray.
* Fix linter errors.
* fixup! Fix linter errors.
* fixup! fixup! Fix linter errors.
* Update arrow/src/array/array_list.rs
Co-authored-by: Andrew Lamb <an...@nerdnetworks.org>
* Update arrow/src/array/array_list.rs
Co-authored-by: Andrew Lamb <an...@nerdnetworks.org>
* Update arrow/src/array/array_list.rs
Co-authored-by: Andrew Lamb <an...@nerdnetworks.org>
* fixup! Update arrow/src/array/array_list.rs
Co-authored-by: Andrew Lamb <an...@nerdnetworks.org>
Co-authored-by: Navin <na...@novemberkilo.com>
---
arrow/src/array/array_list.rs | 60 +++++++++++++++++++++++++++++++++++++++++++
1 file changed, 60 insertions(+)
diff --git a/arrow/src/array/array_list.rs b/arrow/src/array/array_list.rs
index 0e33463..f794dbe 100644
--- a/arrow/src/array/array_list.rs
+++ b/arrow/src/array/array_list.rs
@@ -50,6 +50,9 @@ impl OffsetSizeTrait for i64 {
}
}
+/// Generic struct for a primitive Array
+///
+/// For non generic lists, you may wish to consider using [`ListArray`] or [`LargeListArray`]`
pub struct GenericListArray<OffsetSize> {
data: ArrayData,
values: ArrayRef,
@@ -284,10 +287,67 @@ impl<OffsetSize: OffsetSizeTrait> fmt::Debug for GenericListArray<OffsetSize> {
/// A list array where each element is a variable-sized sequence of values with the same
/// type whose memory offsets between elements are represented by a i32.
+///
+/// # Example
+///
+/// ```
+/// # use arrow::array::{Array, ListArray, Int32Array};
+/// # use arrow::datatypes::{DataType, Int32Type};
+/// let data = vec![
+/// Some(vec![Some(0), Some(1), Some(2)]),
+/// None,
+/// Some(vec![Some(3), None, Some(5), Some(19)]),
+/// Some(vec![Some(6), Some(7)]),
+/// ];
+/// let list_array = ListArray::from_iter_primitive::<Int32Type, _, _>(data);
+/// assert_eq!(DataType::Int32, list_array.value_type());
+/// assert_eq!(4, list_array.len());
+/// assert_eq!(1, list_array.null_count());
+/// assert_eq!(3, list_array.value_length(0));
+/// assert_eq!(0, list_array.value_length(1));
+/// assert_eq!(4, list_array.value_length(2));
+/// assert_eq!(
+/// 19,
+/// list_array
+/// .value(2)
+/// .as_any()
+/// .downcast_ref::<Int32Array>()
+/// .unwrap()
+/// .value(3)
+/// )
+/// ```
pub type ListArray = GenericListArray<i32>;
/// A list array where each element is a variable-sized sequence of values with the same
/// type whose memory offsets between elements are represented by a i64.
+/// # Example
+///
+/// ```
+/// # use arrow::array::{Array, LargeListArray, Int64Array};
+/// # use arrow::datatypes::{DataType, Int64Type};
+/// let data = vec![
+/// Some(vec![Some(0), Some(1), Some(2)]),
+/// None,
+/// Some(vec![Some(3), None, Some(5), Some(19)]),
+/// Some(vec![Some(6), Some(7)]),
+/// ];
+/// let list_array = LargeListArray::from_iter_primitive::<Int64Type, _, _>(data);
+/// assert_eq!(DataType::Int64, list_array.value_type());
+/// assert_eq!(4, list_array.len());
+/// assert_eq!(1, list_array.null_count());
+/// assert_eq!(3, list_array.value_length(0));
+/// assert_eq!(0, list_array.value_length(1));
+/// assert_eq!(4, list_array.value_length(2));
+/// assert_eq!(
+/// 19,
+/// list_array
+/// .value(2)
+/// .as_any()
+/// .downcast_ref::<Int64Array>()
+/// .unwrap()
+/// .value(3)
+/// )
+/// ```
pub type LargeListArray = GenericListArray<i64>;
/// A list array where each element is a fixed-size sequence of values with the same