Struct Table 

pub struct Table {
    pub(crate) record_batches: Vec<RecordBatch>,
    pub(crate) schema: SchemaRef,
}

This is a convenience wrapper around Vec<RecordBatch> that tries to simplify conversion from and to pyarrow.Table.

This could be used in circumstances where you either want to consume a pyarrow.Table directly (although technically, since pyarrow.Table implements the ArrayStreamReader PyCapsule interface, one could also consume a PyArrowType<ArrowArrayStreamReader> instead) or, more importantly, where one wants to export a pyarrow.Table from a Vec<RecordBatch> from the Rust side.

#[pyfunction]
fn return_table(...) -> PyResult<PyArrowType<Table>> {
    let batches: Vec<RecordBatch>;
    let schema: SchemaRef;
    PyArrowType(Table::try_new(batches, schema).map_err(|err| err.into_py_err(py))?)
}

Fields

record_batches: Vec<RecordBatch>

schema: SchemaRef

Implementations

impl Table

pub fn try_new( record_batches: Vec<RecordBatch>, schema: SchemaRef, ) -> Result<Self, ArrowError>

pub fn record_batches(&self) -> &[RecordBatch]

pub fn schema(&self) -> SchemaRef

pub fn into_inner(self) -> (Vec<RecordBatch>, SchemaRef)

Trait Implementations

impl Clone for Table

fn clone(&self) -> Table

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl FromPyArrow for Table

Convert a pyarrow.Table (or any other ArrowArrayStream compliant object) into Table

fn from_pyarrow_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self>

Convert a Python object to an arrow-rs type.

impl IntoPyArrow for Table

Convert a Table into pyarrow.Table.

fn into_pyarrow(self, py: Python<'_>) -> PyResult<Bound<'_, PyAny>>

Convert the implemented type into a Python object while consuming it.

impl TryFrom<Box<dyn RecordBatchReader<Item = Result<RecordBatch, ArrowError>>>> for Table

type Error = ArrowError

The type returned in the event of a conversion error.

fn try_from(value: Box<dyn RecordBatchReader>) -> Result<Self, ArrowError>

Performs the conversion.