Struct Table 

#[repr(C, align(64))]
pub struct Table {
    pub cols: Vec<FieldArray>,
    pub n_rows: usize,
    pub name: String,
}

Table

Description

• Standard columnar table with named columns (FieldArray), a fixed number of rows, and an optional logical table name.
• All columns are required to be equal length and have consistent schema.
• Supports zero-copy slicing, efficient iteration, and bulk operations.
• Equivalent to the RecordBatch in Apache Arrow.

Structure

• cols: A vector of FieldArray, each representing a column with metadata and data.
• n_rows: The logical number of rows (guaranteed equal for all columns).
• name: Optional logical name or alias for this table instance.

Usage

• Use Table as a general-purpose, in-memory columnar data container.
• Good for analytics, and transformation pipelines.
• For batched/partitioned tables, see SuperTable or windowed/chunked abstractions.
• Cast into Polars dataframe via .to_polars() or Apache Arrow via .to_apache_arrow()
• FFI-compatible

Notes

• Table instances are typically lightweight to clone and pass by value.
• For mutation, construct a new table or replace individual columns as needed.
• There is an alias RecordBatch under crate::aliases::RecordBatch

Example

use minarrow::{fa_i32, fa_str32, Print, Table};

let col1 = fa_i32!("numbers", 1, 2, 3);
let col2 = fa_str32!("letters", "x", "y", "z");

let mut tbl = Table::new("Demo".into(), vec![col1, col2].into());
tbl.print();

Fields

cols: Vec<FieldArray>

FieldArrays representing named columns.

n_rows: usize

Number of rows in the table.

name: String

Table name

Implementations

impl Table

pub fn new(name: String, cols: Option<Vec<FieldArray>>) -> Table

Constructs a new Table with a specified name and optional columns. If cols is provided, the number of rows will be inferred from the first column.

Examples found in repository

examples/pycapsule_exchange.rs (lines 163-175)

fn example_2_export_table_stream(py: Python<'_>) -> PyResult<()> {
    println!("Example 2: Export MinArrow table -> PyArrow via __arrow_c_stream__");
    println!("------------------------------------------------------------------");

    let mut ids = IntegerArray::<i32>::default();
    ids.push(1);
    ids.push(2);
    ids.push(3);

    let mut scores = FloatArray::<f64>::default();
    scores.push(9.5);
    scores.push(8.3);
    scores.push(7.1);

    let table = Table::new(
        "results".to_string(),
        Some(vec![
            FieldArray::new(
                Field::new("id", ArrowType::Int32, false, None),
                Array::from_int32(ids),
            ),
            FieldArray::new(
                Field::new("score", ArrowType::Float64, false, None),
                Array::from_float64(scores),
            ),
        ]),
    );
    println!("  Created MinArrow table: 3 rows x 2 columns (id, score)");

    // Export as a stream capsule and extract the raw pointer for PyArrow
    let stream_capsule = to_py::table_to_stream_capsule(&table, py)?;
    let stream_ptr = unsafe {
        pyo3::ffi::PyCapsule_GetPointer(
            stream_capsule.as_ptr(),
            c"arrow_array_stream".as_ptr(),
        )
    } as usize;

    let pyarrow = py.import("pyarrow")?;
    let reader = pyarrow
        .getattr("RecordBatchReader")?
        .call_method1("_import_from_c", (stream_ptr,))?;
    let pa_table = reader.call_method0("read_all")?;

    let num_rows: usize = pa_table.getattr("num_rows")?.extract()?;
    let schema_repr: String = pa_table.getattr("schema")?.call_method0("__repr__")?.extract()?;
    println!("  PyArrow received: {} rows", num_rows);
    println!("  Schema: {}", schema_repr.lines().next().unwrap_or(""));
    println!("  Done.\n");
    Ok(())
}

pub fn new_empty() -> Table

Constructs a new, empty Table with a globally unique name.

pub fn add_col(&mut self, field_array: FieldArray)

Adds a column with a name.

pub fn schema(&self) -> Vec<Arc<Field>>

Builds a schema via the underlying field arrays

pub fn n_cols(&self) -> usize

Returns the number of columns.

pub fn n_rows(&self) -> usize

Returns the number of rows.

pub fn is_empty(&self) -> bool

Returns true if the table is empty (no columns or no rows).

pub fn col_names(&self) -> Vec<&str>

Returns the list of column names.

pub fn rename_columns( &mut self, mapping: &[(&str, &str)], ) -> Result<(), MinarrowError>

Rename columns in place. Each pair is (old_name, new_name).

Returns an error if any old name is not found. This is metadata-only - array data is not touched.

pub fn col_name_index(&self, name: &str) -> Option<usize>

Returns the index of a column by name.

pub fn col_numeric(&self, name: &str) -> Result<NumericArrayV, MinarrowError>

Resolve a named column to a NumericArrayV.

pub fn col_text(&self, name: &str) -> Result<TextArrayV, MinarrowError>

Resolve a named column to a TextArrayV.

pub fn col_bitmask(&self, name: &str) -> Result<BitmaskV, MinarrowError>

Resolve a named column to a BitmaskV.

pub fn remove_col(&mut self, name: &str) -> bool

Removes a column by name.

pub fn remove_col_at(&mut self, idx: usize) -> bool

Removes a column by index.

pub fn clear(&mut self)

Clears all columns and resets row count.

pub fn has_col(&self, name: &str) -> bool

Checks if a column with the given name exists.

pub fn cols(&self) -> &[FieldArray]

Returns all columns as a slice.

pub fn cols_mut(&mut self) -> &mut [FieldArray]

Returns mutable reference to all columns.

pub fn iter(&self) -> Iter<'_, FieldArray>

pub fn iter_mut(&mut self) -> IterMut<'_, FieldArray>

pub fn set_name(&mut self, name: impl Into<String>)

pub fn len(&self) -> usize

pub fn slice_clone(&self, offset: usize, len: usize) -> Table

Returns a new owned Table containing rows [offset, offset+len).

All columns are deeply copied, but only for the affected row(s).

pub fn slice(&self, offset: usize, len: usize) -> TableV

Returns a zero-copy view over rows [offset, offset+len). This view borrows from the parent table and does not copy data.

pub fn map_col<T, F>(&self, col_name: &str, func: F) -> Option<T>

where F: FnOnce(&FieldArray) -> T,

Maps a function over a single column by name, returning the result. Returns None if the column doesn’t exist.

pub fn map_cols_by_name<T, F>(&self, col_names: &[&str], func: F) -> Vec<T>

where F: FnMut(&FieldArray) -> T,

Maps a function over multiple columns by name, returning a Vec of results. Warns if any requested columns are missing.

pub fn map_cols_by_index<T, F>(&self, indices: &[usize], func: F) -> Vec<T>

where F: FnMut(&FieldArray) -> T,

Maps a function over multiple columns by index, returning a Vec of results. Warns if any requested indices are out of bounds.

pub fn map_all_cols<T, F>(&self, func: F) -> Vec<T>

where F: FnMut(&FieldArray) -> T,

Maps a function over all columns, returning a Vec of results.

pub fn apply_cols<E>( &self, f: impl FnMut(&FieldArray) -> Result<FieldArray, E>, ) -> Result<Table, E>

Apply a transformation to each column, producing a new table.

The closure receives each FieldArray and returns a transformed FieldArray. To pass a column through unchanged, clone it. The closure can dispatch on Array variant to handle numeric, text, temporal, and boolean columns differently.

pub fn insert_rows( &mut self, index: usize, other: &Table, ) -> Result<(), MinarrowError>

Inserts rows from another table at the specified index.

This is an O(n) operation where n is the number of rows after the insertion point.

Arguments

• index - Position before which to insert (0 = prepend, n_rows = append)
• other - Table to insert

Requirements

• Both tables must have the same number of columns
• Column names, types, and nullability must match in order
• index must be <= self.n_rows()

Errors

• IndexError if index > n_rows
• IncompatibleTypeError if column schemas don’t match

pub fn split(self, index: usize) -> Result<SuperTable, MinarrowError>

Splits the Table at the specified row index, consuming self and returning a SuperTable with two Table batches.

Splits the underlying buffers, allocating new storage for the second half.

Trait Implementations

impl AsRef<Table> for PyRecordBatch

fn as_ref(&self) -> &Table

Converts this type into a shared reference of the (usually inferred) input type.

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 ColumnSelection for Table

Available on crate features views and select only.

type View = TableV

The view type returned by multi-field selection e.g. TableV

type ColumnView = ArrayV

A single column view by index e.g. ArrayV

type ColumnOwned = FieldArray

An owned single field by name via .get() e.g. FieldArray for Table, Arc for Cube

fn c<S>(&self, selection: S) -> TableV

where S: FieldSelector,

Select fields/columns by name, index, or range

fn get(&self, field: &str) -> Option<FieldArray>

Get a single field by name, returning an owned value.

fn col_ix(&self, idx: usize) -> Option<ArrayV>

Get a single column view by index

fn col_vec(&self) -> Vec<ArrayV>

Get all columns as views

fn get_cols(&self) -> Vec<Arc<Field>>

Get the fields for field resolution

fn col(&self, name: &str) -> Self::View

Alias for c - select column by name

impl Concatenate for Table

fn concat(self, other: Table) -> Result<Table, MinarrowError>

Concatenates two tables vertically (row-wise).

Requirements

• Both tables must have the same number of columns
• Column names, types, and nullability must match in order

Returns

A new Table with rows from self followed by rows from other

Errors

• IncompatibleTypeError if column schemas don’t match

impl Debug for Table

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

Formats the value using the given formatter.

impl Default for Table

fn default() -> Table

Returns the “default value” for a type.

impl Display for Table

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

Formats the value using the given formatter.

impl From<PyRecordBatch> for Table

fn from(value: PyRecordBatch) -> Self

Converts to this type from the input type.

impl From<Table> for PyRecordBatch

fn from(table: Table) -> Self

Converts to this type from the input type.

impl From<TableV> for Table

TableV -> Table conversion. Respects active column selection.

fn from(view: TableV) -> Table

Converts to this type from the input type.

impl FromIterator<Table> for SuperTable

fn from_iter<T>(iter: T) -> SuperTable

where T: IntoIterator<Item = Table>,

Creates a value from an iterator.

impl<'a> IntoIterator for &'a Table

type Item = &'a FieldArray

The type of the elements being iterated over.

type IntoIter = Iter<'a, FieldArray>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Table as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut Table

type Item = &'a mut FieldArray

The type of the elements being iterated over.

type IntoIter = IterMut<'a, FieldArray>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut Table as IntoIterator>::IntoIter

Creates an iterator from a value.

impl IntoIterator for Table

type Item = FieldArray

The type of the elements being iterated over.

type IntoIter = <Vec<FieldArray> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Table as IntoIterator>::IntoIter

Creates an iterator from a value.

impl PartialEq for Table

fn eq(&self, other: &Table) -> 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 RowSelection for Table

Available on crate features views and select only.

type View = TableV

The view type returned by selection operations

fn r<S>(&self, selection: S) -> TableV

where S: DataSelector,

Select rows by index or range

fn get_row_count(&self) -> usize

Get the count for data resolution

impl Shape for Table

fn shape(&self) -> ShapeDim

Returns arbitrary Shape dimension for any data shape

fn shape_1d(&self) -> usize

Returns the first dimension shape

fn shape_2d(&self) -> (usize, usize)

Returns the first and second dimension shapes

fn shape_3d(&self) -> (usize, usize, usize)

Returns the first, second and third dimension shapes

fn shape_4d(&self) -> (usize, usize, usize, usize)

Returns the first, second, third and fourth dimension shapes

impl StructuralPartialEq for Table