Struct RecordBatch

pub struct RecordBatch {
    pub schema: SchemaRef,
    columns: Vec<VectorRef>,
    df_record_batch: DfRecordBatch,
}

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

Fields

schema: SchemaRef

columns: Vec<VectorRef>

df_record_batch: DfRecordBatch

Implementations

impl RecordBatch

pub fn new<I: IntoIterator<Item = VectorRef>>( schema: SchemaRef, columns: I, ) -> Result<RecordBatch>

Create a new RecordBatch from schema and columns.

pub fn new_empty(schema: SchemaRef) -> RecordBatch

Create an empty RecordBatch from schema.

pub fn try_project(&self, indices: &[usize]) -> Result<Self>

pub fn try_from_df_record_batch( schema: SchemaRef, df_record_batch: DfRecordBatch, ) -> Result<RecordBatch>

Create a new RecordBatch from schema and df_record_batch.

This method doesn’t check the schema.

pub fn df_record_batch(&self) -> &DfRecordBatch

pub fn into_df_record_batch(self) -> DfRecordBatch

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

pub fn column(&self, idx: usize) -> &VectorRef

pub fn column_by_name(&self, name: &str) -> Option<&VectorRef>

pub fn num_columns(&self) -> usize

pub fn num_rows(&self) -> usize

pub fn rows(&self) -> RecordBatchRowIterator<'_>

Create an iterator to traverse the data by row

pub fn column_vectors( &self, table_name: &str, table_schema: SchemaRef, ) -> Result<HashMap<String, VectorRef>>

pub fn pretty_print(&self) -> String

Pretty display this record batch like a table

pub fn slice(&self, offset: usize, len: usize) -> Result<RecordBatch>

Return a slice record batch starts from offset, with len rows

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 PartialEq for RecordBatch

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RecordBatch

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RecordBatch