Struct Rows 

pub struct Rows {
    pub(crate) buffer: Vec<u8>,
    pub(crate) offsets: Vec<usize>,
    pub(crate) config: RowConfig,
}

A row-oriented representation of arrow data, that is normalized for comparison.

See the module level documentation and RowConverter for more details.

Fields

buffer: Vec<u8>

Underlying row bytes

offsets: Vec<usize>

Row i has data &buffer[offsets[i]..offsets[i+1]]

config: RowConfig

The config for these rows

Implementations

impl Rows

pub fn push(&mut self, row: Row<'_>)

Append a Row to this Rows

pub fn reserve(&mut self, row_capacity: usize, data_capacity: usize)

Reserve capacity for row_capacity rows with a total length of data_capacity

pub fn row(&self, row: usize) -> Row<'_>

Returns the row at index row

pub unsafe fn row_unchecked(&self, index: usize) -> Row<'_>

Returns the row at index without bounds checking

Safety

Caller must ensure that index is less than the number of offsets (#rows + 1)

pub fn row_len(&self, row: usize) -> usize

Returns the number of bytes the row at index row is occupying, that is, what is the length of the returned Row::data will be.

pub fn lengths(&self) -> RowLengthIter<'_>

Get an iterator over the lengths of each row in this Rows

pub fn clear(&mut self)

Sets the length of this Rows to 0

pub fn num_rows(&self) -> usize

Returns the number of Row in this Rows

pub fn iter(&self) -> RowsIter<'_>

Returns an iterator over the Row in this Rows

pub fn size(&self) -> usize

Returns the size of this instance in bytes

Includes the size of Self.

pub fn try_into_binary(self) -> Result<BinaryArray, ArrowError>

Create a [BinaryArray] from the Rows data without reallocating the underlying bytes.

let converter = RowConverter::new(vec![SortField::new(DataType::Utf8)]).unwrap();
let array = StringArray::from(vec!["hello", "world", "a", "a", "hello"]);
let rows = converter.convert_columns(&[Arc::new(array)]).unwrap();

// We can convert rows into binary format and back.
let values: Vec<OwnedRow> = rows.iter().map(|r| r.owned()).collect();
let binary = rows.try_into_binary().expect("known-small array");
let parser = converter.parser();
let parsed: Vec<OwnedRow> =
  binary.iter().flatten().map(|b| parser.parse(b).owned()).collect();
assert_eq!(values, parsed);

Errors

This function will return an error if there is more data than can be stored in a [BinaryArray] – i.e. if the total data size is more than 2GiB.

Trait Implementations

impl Debug for Rows

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

Formats the value using the given formatter.

impl<'a> IntoIterator for &'a Rows

type Item = Row<'a>

The type of the elements being iterated over.

type IntoIter = RowsIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.