Struct arrow::record_batch::RecordBatch

pub struct RecordBatch { /* fields omitted */ }

A two-dimensional batch of column-oriented data with a defined schema.

A RecordBatch is a two-dimensional dataset of a number of contiguous arrays, each the same length. A record batch has a schema which must match its arrays’ datatypes.

Record batches are a convenient unit of work for various serialization and computation functions, possibly incremental. See also CSV reader and JSON reader.

Implementations

impl RecordBatch

pub fn try_new(schema: SchemaRef, columns: Vec<ArrayRef>) -> Result<Self>

Creates a RecordBatch from a schema and columns.

Expects the following:

• the vec of columns to not be empty
• the schema and column data types to have equal lengths and match
• each array in columns to have the same length

If the conditions are not met, an error is returned.

Example

use std::sync::Arc;
use arrow::array::Int32Array;
use arrow::datatypes::{Schema, Field, DataType};
use arrow::record_batch::RecordBatch;

let id_array = Int32Array::from(vec![1, 2, 3, 4, 5]);
let schema = Schema::new(vec![
    Field::new("id", DataType::Int32, false)
]);

let batch = RecordBatch::try_new(
    Arc::new(schema),
    vec![Arc::new(id_array)]
)?;

pub fn try_new_with_options(
    schema: SchemaRef,
    columns: Vec<ArrayRef>,
    options: &RecordBatchOptions
) -> Result<Self>

Creates a RecordBatch from a schema and columns, with additional options, such as whether to strictly validate field names.

See RecordBatch::try_new for the expected conditions.

pub fn new_empty(schema: SchemaRef) -> Self

Creates a new empty RecordBatch.

pub fn schema(&self) -> SchemaRef

Returns the Schema of the record batch.

pub fn num_columns(&self) -> usize

Returns the number of columns in the record batch.

Example

use std::sync::Arc;
use arrow::array::Int32Array;
use arrow::datatypes::{Schema, Field, DataType};
use arrow::record_batch::RecordBatch;

let id_array = Int32Array::from(vec![1, 2, 3, 4, 5]);
let schema = Schema::new(vec![
    Field::new("id", DataType::Int32, false)
]);

let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(id_array)])?;

assert_eq!(batch.num_columns(), 1);

pub fn num_rows(&self) -> usize

Returns the number of rows in each column.

Panics

Panics if the RecordBatch contains no columns.

Example

use std::sync::Arc;
use arrow::array::Int32Array;
use arrow::datatypes::{Schema, Field, DataType};
use arrow::record_batch::RecordBatch;

let id_array = Int32Array::from(vec![1, 2, 3, 4, 5]);
let schema = Schema::new(vec![
    Field::new("id", DataType::Int32, false)
]);

let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(id_array)])?;

assert_eq!(batch.num_rows(), 5);

pub fn column(&self, index: usize) -> &ArrayRef

Get a reference to a column’s array by index.

Panics

Panics if index is outside of 0..num_columns.

pub fn columns(&self) -> &[ArrayRef]

Get a reference to all columns in the record batch.

pub fn slice(&self, offset: usize, length: usize) -> RecordBatch

Return a new RecordBatch where each column is sliced according to offset and length

Panics

Panics if offset with length is greater than column length.

pub fn try_from_iter<I, F>(value: I) -> Result<Self> where
    I: IntoIterator<Item = (F, ArrayRef)>,
    F: AsRef<str>, 

Create a RecordBatch from an iterable list of pairs of the form (field_name, array), with the same requirements on fields and arrays as RecordBatch::try_new. This method is often used to create a single RecordBatch from arrays, e.g. for testing.

The resulting schema is marked as nullable for each column if the array for that column is has any nulls. To explicitly specify nullibility, use RecordBatch::try_from_iter_with_nullable

Example:

use std::sync::Arc;
use arrow::array::{ArrayRef, Int32Array, StringArray};
use arrow::datatypes::{Schema, Field, DataType};
use arrow::record_batch::RecordBatch;

let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2]));
let b: ArrayRef = Arc::new(StringArray::from(vec!["a", "b"]));

let record_batch = RecordBatch::try_from_iter(vec![
  ("a", a),
  ("b", b),
]);

pub fn try_from_iter_with_nullable<I, F>(value: I) -> Result<Self> where
    I: IntoIterator<Item = (F, ArrayRef, bool)>,
    F: AsRef<str>, 

Create a RecordBatch from an iterable list of tuples of the form (field_name, array, nullable), with the same requirements on fields and arrays as RecordBatch::try_new. This method is often used to create a single RecordBatch from arrays, e.g. for testing.

Example:

use std::sync::Arc;
use arrow::array::{ArrayRef, Int32Array, StringArray};
use arrow::datatypes::{Schema, Field, DataType};
use arrow::record_batch::RecordBatch;

let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2]));
let b: ArrayRef = Arc::new(StringArray::from(vec![Some("a"), Some("b")]));

// Note neither `a` nor `b` has any actual nulls, but we mark
// b an nullable
let record_batch = RecordBatch::try_from_iter_with_nullable(vec![
  ("a", a, false),
  ("b", b, true),
]);

pub fn concat(schema: &SchemaRef, batches: &[Self]) -> Result<Self>

Concatenates batches together into a single record batch.

Trait Implementations

impl Clone for RecordBatch

fn clone(&self) -> RecordBatch

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RecordBatch

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

Formats the value using the given formatter.

impl From<&'_ StructArray> for RecordBatch

fn from(struct_array: &StructArray) -> Self

Create a record batch from struct array, where each field of the StructArray becomes a Field in the schema.

This currently does not flatten and nested struct types

impl From<RecordBatch> for StructArray

fn from(batch: RecordBatch) -> Self

Performs the conversion.

impl PartialEq<RecordBatch> for RecordBatch

fn eq(&self, other: &RecordBatch) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &RecordBatch) -> bool

This method tests for !=.

impl StructuralPartialEq for RecordBatch