Struct arrow::array::builder::GenericListBuilder

source ·
pub struct GenericListBuilder<OffsetSize, T>
where OffsetSize: OffsetSizeTrait, T: ArrayBuilder,
{ /* private fields */ }
Expand description

Builder for GenericListArray

Use ListBuilder to build ListArrays and LargeListBuilder to build LargeListArrays.

§Example

Here is code that constructs a ListArray with the contents: [[A,B,C], [], NULL, [D], [NULL, F]]

let values_builder = StringBuilder::new();
let mut builder = ListBuilder::new(values_builder);

// [A, B, C]
builder.values().append_value("A");
builder.values().append_value("B");
builder.values().append_value("C");
builder.append(true);

// [ ] (empty list)
builder.append(true);

// Null
builder.values().append_value("?"); // irrelevant
builder.append(false);

// [D]
builder.values().append_value("D");
builder.append(true);

// [NULL, F]
builder.values().append_null();
builder.values().append_value("F");
builder.append(true);

// Build the array
let array = builder.finish();

// Values is a string array
// "A", "B" "C", "?", "D", NULL, "F"
assert_eq!(
  array.values().as_ref(),
  &StringArray::from(vec![
    Some("A"), Some("B"), Some("C"),
    Some("?"), Some("D"), None,
    Some("F")
  ])
);

// Offsets are indexes into the values array
assert_eq!(
  array.value_offsets(),
  &[0, 3, 3, 4, 5, 7]
);

Implementations§

source§

impl<OffsetSize, T> GenericListBuilder<OffsetSize, T>
where OffsetSize: OffsetSizeTrait, T: ArrayBuilder,

source

pub fn new(values_builder: T) -> GenericListBuilder<OffsetSize, T>

Creates a new GenericListBuilder from a given values array builder

source

pub fn with_capacity( values_builder: T, capacity: usize, ) -> GenericListBuilder<OffsetSize, T>

Creates a new GenericListBuilder from a given values array builder capacity is the number of items to pre-allocate space for in this builder

source

pub fn with_field( self, field: impl Into<Arc<Field>>, ) -> GenericListBuilder<OffsetSize, T>

Override the field passed to GenericListArray::new

By default a nullable field is created with the name item

Note: Self::finish and Self::finish_cloned will panic if the field’s data type does not match that of T

source§

impl<OffsetSize, T> GenericListBuilder<OffsetSize, T>
where OffsetSize: OffsetSizeTrait, T: ArrayBuilder + 'static,

source

pub fn values(&mut self) -> &mut T

Returns the child array builder as a mutable reference.

This mutable reference can be used to append values into the child array builder, but you must call append to delimit each distinct list value.

source

pub fn values_ref(&self) -> &T

Returns the child array builder as an immutable reference

source

pub fn append(&mut self, is_valid: bool)

Finish the current variable-length list array slot

§Panics

Panics if the length of Self::values exceeds OffsetSize::MAX

source

pub fn append_value<I, V>(&mut self, i: I)
where T: Extend<Option<V>>, I: IntoIterator<Item = Option<V>>,

Append a value to this GenericListBuilder

let mut builder = ListBuilder::new(Int32Builder::new());

builder.append_value([Some(1), Some(2), Some(3)]);
builder.append_value([]);
builder.append_value([None]);

let array = builder.finish();
assert_eq!(array.len(), 3);

assert_eq!(array.value_offsets(), &[0, 3, 3, 4]);
let values = array.values().as_primitive::<Int32Type>();
assert_eq!(values, &Int32Array::from(vec![Some(1), Some(2), Some(3), None]));

This is an alternative API to appending directly to Self::values and delimiting the result with Self::append

let mut builder = ListBuilder::new(Int32Builder::new());

builder.values().append_value(1);
builder.values().append_value(2);
builder.values().append_value(3);
builder.append(true);
builder.append(true);
builder.values().append_null();
builder.append(true);

let array = builder.finish();
assert_eq!(array.len(), 3);

assert_eq!(array.value_offsets(), &[0, 3, 3, 4]);
let values = array.values().as_primitive::<Int32Type>();
assert_eq!(values, &Int32Array::from(vec![Some(1), Some(2), Some(3), None]));
source

pub fn append_null(&mut self)

Append a null to this GenericListBuilder

See Self::append_value for an example use.

source

pub fn append_option<I, V>(&mut self, i: Option<I>)
where T: Extend<Option<V>>, I: IntoIterator<Item = Option<V>>,

Appends an optional value into this GenericListBuilder

If Some calls Self::append_value otherwise calls Self::append_null

source

pub fn finish(&mut self) -> GenericListArray<OffsetSize>

Builds the GenericListArray and reset this builder.

source

pub fn finish_cloned(&self) -> GenericListArray<OffsetSize>

Builds the GenericListArray without resetting the builder.

source

pub fn offsets_slice(&self) -> &[OffsetSize]

Returns the current offsets buffer as a slice

Trait Implementations§

source§

impl<OffsetSize, T> ArrayBuilder for GenericListBuilder<OffsetSize, T>
where OffsetSize: OffsetSizeTrait, T: ArrayBuilder + 'static,

source§

fn as_any(&self) -> &(dyn Any + 'static)

Returns the builder as a non-mutable Any reference.

source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the builder as a mutable Any reference.

source§

fn into_box_any(self: Box<GenericListBuilder<OffsetSize, T>>) -> Box<dyn Any>

Returns the boxed builder as a box of Any.

source§

fn len(&self) -> usize

Returns the number of array slots in the builder

source§

fn finish(&mut self) -> Arc<dyn Array>

Builds the array and reset this builder.

source§

fn finish_cloned(&self) -> Arc<dyn Array>

Builds the array without resetting the builder.

source§

fn is_empty(&self) -> bool

Returns whether number of array slots is zero
source§

impl<OffsetSize, T> Debug for GenericListBuilder<OffsetSize, T>
where OffsetSize: Debug + OffsetSizeTrait, T: Debug + ArrayBuilder,

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
source§

impl<O, T> Default for GenericListBuilder<O, T>

source§

fn default() -> GenericListBuilder<O, T>

Returns the “default value” for a type. Read more
source§

impl<O, B, V, E> Extend<Option<V>> for GenericListBuilder<O, B>
where O: OffsetSizeTrait, B: ArrayBuilder + Extend<E>, V: IntoIterator<Item = E>,

source§

fn extend<T>(&mut self, iter: T)
where T: IntoIterator<Item = Option<V>>,

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more

Auto Trait Implementations§

§

impl<OffsetSize, T> Freeze for GenericListBuilder<OffsetSize, T>
where T: Freeze,

§

impl<OffsetSize, T> RefUnwindSafe for GenericListBuilder<OffsetSize, T>
where T: RefUnwindSafe, OffsetSize: RefUnwindSafe,

§

impl<OffsetSize, T> Send for GenericListBuilder<OffsetSize, T>

§

impl<OffsetSize, T> Sync for GenericListBuilder<OffsetSize, T>

§

impl<OffsetSize, T> Unpin for GenericListBuilder<OffsetSize, T>
where T: Unpin, OffsetSize: Unpin,

§

impl<OffsetSize, T> UnwindSafe for GenericListBuilder<OffsetSize, T>
where T: UnwindSafe, OffsetSize: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> Allocation for T
where T: RefUnwindSafe + Send + Sync,