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::{FieldArray, Print, Table, arr_i32, arr_str32, vec64};

let col1 = FieldArray::from_arr("numbers", arr_i32![1, 2, 3]);
let col2 = FieldArray::from_arr("letters", arr_str32!["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>>) -> Self

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/selection.rs (line 126)

fn create_sample_table() -> Table {
    // Create id column
    let mut id_arr = IntegerArray::<i32>::default();
    for i in 0..10 {
        id_arr.push(i);
    }

    // Create name column
    let mut name_arr = StringArray::<u32>::default();
    let names = ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank", "Grace", "Henry", "Iris", "Jack"];
    for name in names {
        name_arr.push(name.to_string());
    }

    // Create age column
    let mut age_arr = IntegerArray::<i32>::default();
    for i in 0..10 {
        age_arr.push(20 + (i * 3) as i32);
    }

    let col_id = FieldArray::from_arr("id", Array::from_int32(id_arr));
    let col_name = FieldArray::from_arr("name", Array::from_string32(name_arr));
    let col_age = FieldArray::from_arr("age", Array::from_int32(age_arr));

    Table::new("People".to_string(), Some(vec![col_id, col_name, col_age]))
}

examples/broadcasting/test_broadcasting.rs (line 292)

fn test_table_broadcasting() {
    println!("┌─ Test 9: Table Broadcasting");
    println!(
        "│  Operation: Table{{col1:[1,2,3], col2:[4,5,6]}} + Table{{col1:[10,10,10], col2:[20,20,20]}}"
    );
    println!("│  Expected:  Table{{col1:[11,12,13], col2:[24,25,26]}}");

    // Create first table with two columns
    let arr1_col1 = Array::from_int32(IntegerArray::from_slice(&vec64![1, 2, 3]));
    let arr1_col2 = Array::from_int32(IntegerArray::from_slice(&vec64![4, 5, 6]));
    let fa1_col1 = minarrow::FieldArray::from_arr("col1", arr1_col1);
    let fa1_col2 = minarrow::FieldArray::from_arr("col2", arr1_col2);
    let mut table1 = Table::new("table1".to_string(), None);
    table1.add_col(fa1_col1);
    table1.add_col(fa1_col2);

    // Create second table with matching structure
    let arr2_col1 = Array::from_int32(IntegerArray::from_slice(&vec64![10, 10, 10]));
    let arr2_col2 = Array::from_int32(IntegerArray::from_slice(&vec64![20, 20, 20]));
    let fa2_col1 = minarrow::FieldArray::from_arr("col1", arr2_col1);
    let fa2_col2 = minarrow::FieldArray::from_arr("col2", arr2_col2);
    let mut table2 = Table::new("table2".to_string(), None);
    table2.add_col(fa2_col1);
    table2.add_col(fa2_col2);

    match Value::Table(Arc::new(table1)) + Value::Table(Arc::new(table2)) {
        Ok(Value::Table(result)) => {
            if let Array::NumericArray(NumericArray::Int32(col1)) = &result.cols[0].array {
                println!("│  Result col1: {:?}", col1.data.as_slice());
            }
            if let Array::NumericArray(NumericArray::Int32(col2)) = &result.cols[1].array {
                println!("│  Result col2: {:?}", col2.data.as_slice());
            }
            println!("└─ ✓ Passed\n");
        }
        Ok(other) => println!("└─ ✗ Error: Unexpected result type {:?}\n", other),
        Err(e) => println!("└─ ✗ Error: {:?}\n", e),
    }
}

/// Test ArrayView broadcasting - efficient windowed operations
fn test_array_view_broadcasting() {
    #[cfg(feature = "views")]
    {
        println!("┌─ Test 10: ArrayView Broadcasting");
        println!("│  Operation: ArrayView([2,3,4]) + ArrayView([10,10,10])");
        println!("│  Expected:  Array([12,13,14])");

        // Create an array and a view into it
        let arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![1, 2, 3, 4, 5]));
        let view1 = ArrayV::new(arr1, 1, 3); // View of elements [2,3,4]

        let arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![10, 10, 10]));
        let view2 = ArrayV::new(arr2, 0, 3);

        match Value::ArrayView(Arc::new(view1)) + Value::ArrayView(Arc::new(view2)) {
            Ok(Value::Array(arr_arc)) => {
                if let Array::NumericArray(NumericArray::Int32(result)) = arr_arc.as_ref() {
                    println!("│  Result:    {:?}", result.data.as_slice());
                    println!("└─ ✓ Passed\n");
                } else {
                    println!("└─ ✗ Error: Unexpected array type\n");
                }
            }
            Ok(_) => println!("└─ ✗ Error: Unexpected result type\n"),
            Err(e) => println!("└─ ✗ Error: {:?}\n", e),
        }
    }

    #[cfg(not(feature = "views"))]
    {
        println!("┌─ Test 10: ArrayView Broadcasting");
        println!("└─ ⊘ Skipped (views feature not enabled)\n");
    }
}

/// Test SuperArray broadcasting - chunked array operations
fn test_super_array_broadcasting() {
    #[cfg(feature = "chunked")]
    {
        println!("┌─ Test 11: SuperArray (Chunked) Broadcasting");
        println!("│  Operation: SuperArray{{[1,2],[3,4]}} * SuperArray{{[2,2],[2,2]}}");
        println!("│  Expected:  SuperArray{{[2,4],[6,8]}}");

        // Create chunked arrays (multiple field array chunks)
        let chunk1_a = Array::from_int32(IntegerArray::from_slice(&vec64![1, 2]));
        let chunk2_a = Array::from_int32(IntegerArray::from_slice(&vec64![3, 4]));
        let fa1 = minarrow::FieldArray::from_arr("chunk1", chunk1_a);
        let fa2 = minarrow::FieldArray::from_arr("chunk1", chunk2_a);
        let super_arr1 = SuperArray::from_field_array_chunks(vec![fa1, fa2]);

        let chunk1_b = Array::from_int32(IntegerArray::from_slice(&vec64![2, 2]));
        let chunk2_b = Array::from_int32(IntegerArray::from_slice(&vec64![2, 2]));
        let fa3 = minarrow::FieldArray::from_arr("chunk1", chunk1_b);
        let fa4 = minarrow::FieldArray::from_arr("chunk1", chunk2_b);
        let super_arr2 = SuperArray::from_field_array_chunks(vec![fa3, fa4]);

        match Value::SuperArray(Arc::new(super_arr1)) * Value::SuperArray(Arc::new(super_arr2)) {
            Ok(Value::SuperArray(result)) => {
                println!("│  Result with {} chunks:", result.len());
                for i in 0..result.len() {
                    if let Some(fa) = result.chunk(i) {
                        if let Array::NumericArray(NumericArray::Int32(arr)) = &fa.array {
                            println!("│    Chunk {}: {:?}", i, arr.data.as_slice());
                        }
                    }
                }
                println!("└─ ✓ Passed\n");
            }
            Ok(other) => println!("└─ ✗ Error: Unexpected result type {:?}\n", other),
            Err(e) => println!("└─ ✗ Error: {:?}\n", e),
        }
    }

    #[cfg(not(feature = "chunked"))]
    {
        println!("┌─ Test 11: SuperArray (Chunked) Broadcasting");
        println!("└─ ⊘ Skipped (chunked feature not enabled)\n");
    }
}

/// Test Cube broadcasting - 3D tensor operations
fn test_cube_broadcasting() {
    #[cfg(feature = "cube")]
    {
        println!("┌─ Test 12: Cube (3D) Broadcasting");
        println!("│  Operation: Cube{{2 tables}} + Cube{{2 tables}}");
        println!("│  Expected:  Element-wise addition across all tables");

        // Create first cube with 2 tables
        // First, create columns for table 1
        let t1_arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![1, 2]));
        let t1_arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![3, 4]));
        let t1_fa1 = minarrow::FieldArray::from_arr("col1", t1_arr1);
        let t1_fa2 = minarrow::FieldArray::from_arr("col2", t1_arr2);

        // Create columns for cube1 via constructor
        let mut cube1 = Cube::new("cube1".to_string(), Some(vec![t1_fa1, t1_fa2]), None);

        // Add second table to cube1
        let t2_arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![5, 6]));
        let t2_arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![7, 8]));
        let t2_fa1 = minarrow::FieldArray::from_arr("col1", t2_arr1);
        let t2_fa2 = minarrow::FieldArray::from_arr("col2", t2_arr2);
        let mut table2 = Table::new("t2".to_string(), None);
        table2.add_col(t2_fa1);
        table2.add_col(t2_fa2);
        cube1.add_table(table2);

        // Create second cube
        let t3_arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![10, 10]));
        let t3_arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![20, 20]));
        let t3_fa1 = minarrow::FieldArray::from_arr("col1", t3_arr1);
        let t3_fa2 = minarrow::FieldArray::from_arr("col2", t3_arr2);
        let mut cube2 = Cube::new("cube2".to_string(), Some(vec![t3_fa1, t3_fa2]), None);

        let t4_arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![30, 30]));
        let t4_arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![40, 40]));
        let t4_fa1 = minarrow::FieldArray::from_arr("col1", t4_arr1);
        let t4_fa2 = minarrow::FieldArray::from_arr("col2", t4_arr2);
        let mut table4 = Table::new("t4".to_string(), None);
        table4.add_col(t4_fa1);
        table4.add_col(t4_fa2);
        cube2.add_table(table4);

        match Value::Cube(Arc::new(cube1)) + Value::Cube(Arc::new(cube2)) {
            Ok(Value::Cube(result)) => {
                println!("│  Result cube with {} tables:", result.n_tables());
                for i in 0..result.n_tables() {
                    println!("│  Table {}:", i);
                    if let Some(table) = result.table(i) {
                        for j in 0..table.n_cols() {
                            let col = &table.cols[j];
                            if let Array::NumericArray(NumericArray::Int32(arr)) = &col.array {
                                println!("│    Column {}: {:?}", j, arr.data.as_slice());
                            }
                        }
                    }
                }
                println!("└─ ✓ Passed\n");
            }
            Ok(other) => println!("└─ ✗ Error: Unexpected result type {:?}\n", other),
            Err(e) => println!("└─ ✗ Error: {:?}\n", e),
        }
    }

    #[cfg(not(feature = "cube"))]
    {
        println!("┌─ Test 12: Cube (3D) Broadcasting");
        println!("└─ ⊘ Skipped (cube feature not enabled)\n");
    }
}

examples/print/print_table.rs (line 70)

fn main() {
    // Inner arrays

    // Numeric
    let col_i32 = IntArr::<i32>::from_slice(&[1, 2, 3, 4, 5]);
    let col_u32 = IntArr::<u32>::from_slice(&[100, 200, 300, 400, 500]);
    let col_i64 = IntArr::<i64>::from_slice(&[10, 20, 30, 40, 50]);
    let col_u64 = IntArr::<u64>::from_slice(&[101, 201, 301, 401, 501]);
    let col_f32 = FltArr::<f32>::from_slice(&[1.1, 2.2, 3.3, 4.4, 5.5]);
    let col_f64 = FltArr::<f64>::from_slice(&[2.2, 3.3, 4.4, 5.5, 6.6]);

    // Boolean with nulls
    let mut col_bool = BoolArr::from_slice(&[true, false, true, false, true]);
    col_bool.set_null_mask(Some(Bitmask::from_bools(&[true, true, true, false, true])));

    // String and Dictionary/Categorical
    let col_str32 = StrArr::<u32>::from_slice(&["red", "blue", "green", "yellow", "purple"]);
    let col_cat32 = CatArr::<u32>::from_values(
        ["apple", "banana", "cherry", "banana", "apple"]
            .iter()
            .copied(),
    );

    // Datetime
    #[cfg(feature = "datetime")]
    let col_dt32 = DatetimeArray::<i32>::from_slice(
        &[1000, 2000, 3000, 4000, 5000],
        Some(TimeUnit::Milliseconds),
    );
    #[cfg(feature = "datetime")]
    let col_dt64 = DatetimeArray::<i64>::from_slice(
        &[
            1_000_000_000,
            2_000_000_000,
            3_000_000_000,
            4_000_000_000,
            5_000_000_000,
        ],
        Some(TimeUnit::Nanoseconds),
    );

    // FieldArray (column) construction
    let fa_i32 = FieldArray::from_arr("int32_col", col_i32);
    let fa_u32 = FieldArray::from_arr("uint32_col", col_u32);
    let fa_i64 = FieldArray::from_arr("int64_col", col_i64);
    let fa_u64 = FieldArray::from_arr("uint64_col", col_u64);
    let fa_f32 = FieldArray::from_arr("float32_col", col_f32);
    let fa_f64 = FieldArray::from_arr("float64_col", col_f64);
    let fa_bool = FieldArray::from_arr("bool_col", col_bool);
    let fa_str32 = FieldArray::from_arr("utf8_col", col_str32);
    let fa_cat32 = FieldArray::from_arr("dict32_col", col_cat32);
    #[cfg(feature = "datetime")]
    let fa_dt32 = FieldArray::from_arr("datetime32_col", col_dt32);
    #[cfg(feature = "datetime")]
    let fa_dt64 = FieldArray::from_arr("datetime64_col", col_dt64);

    // Build Table
    let mut tbl = Table::new("MyTable".to_string(), None);
    tbl.add_col(fa_i32);
    tbl.add_col(fa_u32);
    tbl.add_col(fa_i64);
    tbl.add_col(fa_u64);
    tbl.add_col(fa_f32);
    tbl.add_col(fa_f64);
    tbl.add_col(fa_bool);
    tbl.add_col(fa_str32);
    tbl.add_col(fa_cat32);
    #[cfg(feature = "datetime")]
    tbl.add_col(fa_dt32);
    #[cfg(feature = "datetime")]
    tbl.add_col(fa_dt64);

    // Print the table
    tbl.print();
}

examples/ffi/polars_ffi.rs (line 197)

    fn build_minarrow_table() -> Table {
        // Arrays
        #[cfg(feature = "extended_numeric_types")]
        let arr_int8 = Arc::new(minarrow::IntegerArray::<i8>::from_slice(&[1, 2, -1])) as Arc<_>;
        #[cfg(feature = "extended_numeric_types")]
        let arr_int16 =
            Arc::new(minarrow::IntegerArray::<i16>::from_slice(&[10, 20, -10])) as Arc<_>;
        let arr_int32 =
            Arc::new(minarrow::IntegerArray::<i32>::from_slice(&[100, 200, -100])) as Arc<_>;
        let arr_int64 = Arc::new(minarrow::IntegerArray::<i64>::from_slice(&[
            1000, 2000, -1000,
        ])) as Arc<_>;

        #[cfg(feature = "extended_numeric_types")]
        let arr_uint8 = Arc::new(minarrow::IntegerArray::<u8>::from_slice(&[1, 2, 255]))
            as Arc<minarrow::IntegerArray<u8>>;
        #[cfg(feature = "extended_numeric_types")]
        let arr_uint16 = Arc::new(minarrow::IntegerArray::<u16>::from_slice(&[1, 2, 65535]))
            as Arc<minarrow::IntegerArray<u16>>;
        let arr_uint32 = Arc::new(minarrow::IntegerArray::<u32>::from_slice(&[
            1, 2, 4294967295,
        ])) as Arc<minarrow::IntegerArray<u32>>;
        let arr_uint64 = Arc::new(minarrow::IntegerArray::<u64>::from_slice(&[
            1,
            2,
            18446744073709551615,
        ])) as Arc<minarrow::IntegerArray<u64>>;

        let arr_float32 = Arc::new(minarrow::FloatArray::<f32>::from_slice(&[1.5, -0.5, 0.0]))
            as Arc<minarrow::FloatArray<f32>>;
        let arr_float64 = Arc::new(minarrow::FloatArray::<f64>::from_slice(&[1.0, -2.0, 0.0]))
            as Arc<minarrow::FloatArray<f64>>;

        let arr_bool = Arc::new(minarrow::BooleanArray::<()>::from_slice(&[
            true, false, true,
        ])) as Arc<minarrow::BooleanArray<()>>;

        let arr_string32 = Arc::new(minarrow::StringArray::<u32>::from_slice(&[
            "abc", "def", "",
        ])) as Arc<minarrow::StringArray<u32>>;
        let arr_categorical32 = Arc::new(minarrow::CategoricalArray::<u32>::from_slices(
            &[0, 1, 2],
            &["A".to_string(), "B".to_string(), "C".to_string()],
        )) as Arc<minarrow::CategoricalArray<u32>>;

        #[cfg(feature = "datetime")]
        let arr_datetime32 = Arc::new(minarrow::DatetimeArray::<i32> {
            data: minarrow::Buffer::<i32>::from_slice(&[
                1_600_000_000 / 86_400,
                1_600_000_001 / 86_400,
                1_600_000_002 / 86_400,
            ]),
            null_mask: None,
            time_unit: TimeUnit::Days,
        });
        #[cfg(feature = "datetime")]
        let arr_datetime64 = Arc::new(minarrow::DatetimeArray::<i64> {
            data: minarrow::Buffer::<i64>::from_slice(&[
                1_600_000_000_000,
                1_600_000_000_001,
                1_600_000_000_002,
            ]),
            null_mask: None,
            time_unit: TimeUnit::Milliseconds,
        }) as Arc<_>;

        // Wrap in Array enums
        #[cfg(feature = "extended_numeric_types")]
        let minarr_int8 = Array::NumericArray(NumericArray::Int8(arr_int8));
        #[cfg(feature = "extended_numeric_types")]
        let minarr_int16 = Array::NumericArray(NumericArray::Int16(arr_int16));
        let minarr_int32 = Array::NumericArray(NumericArray::Int32(arr_int32));
        let minarr_int64 = Array::NumericArray(NumericArray::Int64(arr_int64));
        #[cfg(feature = "extended_numeric_types")]
        let minarr_uint8 = Array::NumericArray(NumericArray::UInt8(arr_uint8));
        #[cfg(feature = "extended_numeric_types")]
        let minarr_uint16 = Array::NumericArray(NumericArray::UInt16(arr_uint16));
        let minarr_uint32 = Array::NumericArray(NumericArray::UInt32(arr_uint32));
        let minarr_uint64 = Array::NumericArray(NumericArray::UInt64(arr_uint64));
        let minarr_float32 = Array::NumericArray(NumericArray::Float32(arr_float32));
        let minarr_float64 = Array::NumericArray(NumericArray::Float64(arr_float64));
        let minarr_bool = Array::BooleanArray(arr_bool);
        let minarr_string32 = Array::TextArray(TextArray::String32(arr_string32));
        let minarr_categorical32 = Array::TextArray(TextArray::Categorical32(arr_categorical32));
        #[cfg(feature = "datetime")]
        let minarr_datetime32 = Array::TemporalArray(TemporalArray::Datetime32(arr_datetime32));
        #[cfg(feature = "datetime")]
        let minarr_datetime64 = Array::TemporalArray(TemporalArray::Datetime64(arr_datetime64));

        // Fields
        #[cfg(feature = "extended_numeric_types")]
        let field_int8 = Field::new("int8", ArrowType::Int8, false, None);
        #[cfg(feature = "extended_numeric_types")]
        let field_int16 = Field::new("int16", ArrowType::Int16, false, None);
        let field_int32 = Field::new("int32", ArrowType::Int32, false, None);
        let field_int64 = Field::new("int64", ArrowType::Int64, false, None);
        #[cfg(feature = "extended_numeric_types")]
        let field_uint8 = Field::new("uint8", ArrowType::UInt8, false, None);
        #[cfg(feature = "extended_numeric_types")]
        let field_uint16 = Field::new("uint16", ArrowType::UInt16, false, None);
        let field_uint32 = Field::new("uint32", ArrowType::UInt32, false, None);
        let field_uint64 = Field::new("uint64", ArrowType::UInt64, false, None);
        let field_float32 = Field::new("float32", ArrowType::Float32, false, None);
        let field_float64 = Field::new("float64", ArrowType::Float64, false, None);
        let field_bool = Field::new("bool", ArrowType::Boolean, false, None);
        let field_string32 = Field::new("string32", ArrowType::String, false, None);
        let field_categorical32 = Field::new(
            "categorical32",
            ArrowType::Dictionary(CategoricalIndexType::UInt32),
            false,
            None,
        );
        #[cfg(feature = "datetime")]
        let field_datetime32 = Field::new("dt32", ArrowType::Date32, false, None);
        #[cfg(feature = "datetime")]
        let field_datetime64 = Field::new("dt64", ArrowType::Date64, false, None);

        // FieldArrays
        #[cfg(feature = "extended_numeric_types")]
        let fa_int8 = FieldArray::new(field_int8, minarr_int8);
        #[cfg(feature = "extended_numeric_types")]
        let fa_int16 = FieldArray::new(field_int16, minarr_int16);
        let fa_int32 = FieldArray::new(field_int32, minarr_int32);
        let fa_int64 = FieldArray::new(field_int64, minarr_int64);
        #[cfg(feature = "extended_numeric_types")]
        let fa_uint8 = FieldArray::new(field_uint8, minarr_uint8);
        #[cfg(feature = "extended_numeric_types")]
        let fa_uint16 = FieldArray::new(field_uint16, minarr_uint16);
        let fa_uint32 = FieldArray::new(field_uint32, minarr_uint32);
        let fa_uint64 = FieldArray::new(field_uint64, minarr_uint64);
        let fa_float32 = FieldArray::new(field_float32, minarr_float32);
        let fa_float64 = FieldArray::new(field_float64, minarr_float64);
        let fa_bool = FieldArray::new(field_bool, minarr_bool);
        let fa_string32 = FieldArray::new(field_string32, minarr_string32);
        let fa_categorical32 = FieldArray::new(field_categorical32, minarr_categorical32);
        #[cfg(feature = "datetime")]
        let fa_datetime32 = FieldArray::new(field_datetime32, minarr_datetime32);
        #[cfg(feature = "datetime")]
        let fa_datetime64 = FieldArray::new(field_datetime64, minarr_datetime64);

        // Build table
        let mut cols = Vec::new();
        #[cfg(feature = "extended_numeric_types")]
        {
            cols.push(fa_int8);
            cols.push(fa_int16);
        }
        cols.push(fa_int32);
        cols.push(fa_int64);
        #[cfg(feature = "extended_numeric_types")]
        {
            cols.push(fa_uint8);
            cols.push(fa_uint16);
        }
        cols.push(fa_uint32);
        cols.push(fa_uint64);
        cols.push(fa_float32);
        cols.push(fa_float64);
        cols.push(fa_bool);
        cols.push(fa_string32);
        cols.push(fa_categorical32);
        #[cfg(feature = "datetime")]
        {
            cols.push(fa_datetime32);
            cols.push(fa_datetime64);
        }
        Table::new("polars_ffi_test".to_string(), Some(cols))
    }

examples/ffi/apache_arrow_ffi.rs (line 195)

    pub(crate) fn run_example() {
        // ---- 1. Build a Minarrow Table with all types ----

        #[cfg(feature = "extended_numeric_types")]
        let arr_int8 = Arc::new(minarrow::IntegerArray::<i8>::from_slice(&[1, 2, -1])) as Arc<_>;
        #[cfg(feature = "extended_numeric_types")]
        let arr_int16 =
            Arc::new(minarrow::IntegerArray::<i16>::from_slice(&[10, 20, -10])) as Arc<_>;
        let arr_int32 =
            Arc::new(minarrow::IntegerArray::<i32>::from_slice(&[100, 200, -100])) as Arc<_>;
        let arr_int64 = Arc::new(minarrow::IntegerArray::<i64>::from_slice(&[
            1000, 2000, -1000,
        ])) as Arc<_>;

        #[cfg(feature = "extended_numeric_types")]
        let arr_uint8 = Arc::new(minarrow::IntegerArray::<u8>::from_slice(&[1, 2, 255]))
            as Arc<minarrow::IntegerArray<u8>>;
        #[cfg(feature = "extended_numeric_types")]
        let arr_uint16 = Arc::new(minarrow::IntegerArray::<u16>::from_slice(&[1, 2, 65535]))
            as Arc<minarrow::IntegerArray<u16>>;
        let arr_uint32 = Arc::new(minarrow::IntegerArray::<u32>::from_slice(&[
            1, 2, 4294967295,
        ])) as Arc<minarrow::IntegerArray<u32>>;
        let arr_uint64 = Arc::new(minarrow::IntegerArray::<u64>::from_slice(&[
            1,
            2,
            18446744073709551615,
        ])) as Arc<minarrow::IntegerArray<u64>>;

        let arr_float32 = Arc::new(minarrow::FloatArray::<f32>::from_slice(&[1.5, -0.5, 0.0]))
            as Arc<minarrow::FloatArray<f32>>;
        let arr_float64 = Arc::new(minarrow::FloatArray::<f64>::from_slice(&[1.0, -2.0, 0.0]))
            as Arc<minarrow::FloatArray<f64>>;

        let arr_bool = Arc::new(minarrow::BooleanArray::<()>::from_slice(&[
            true, false, true,
        ])) as Arc<minarrow::BooleanArray<()>>;

        let arr_string32 = Arc::new(minarrow::StringArray::<u32>::from_slice(&[
            "abc", "def", "",
        ])) as Arc<minarrow::StringArray<u32>>;
        let arr_categorical32 = Arc::new(minarrow::CategoricalArray::<u32>::from_slices(
            &[0, 1, 2],
            &["A".to_string(), "B".to_string(), "C".to_string()],
        )) as Arc<minarrow::CategoricalArray<u32>>;

        #[cfg(feature = "datetime")]
        let arr_datetime32 = Arc::new(minarrow::DatetimeArray::<i32> {
            data: minarrow::Buffer::<i32>::from_slice(&[
                1_600_000_000 / 86_400,
                1_600_000_001 / 86_400,
                1_600_000_002 / 86_400,
            ]),
            null_mask: None,
            time_unit: TimeUnit::Days,
        });
        #[cfg(feature = "datetime")]
        let arr_datetime64 = Arc::new(minarrow::DatetimeArray::<i64> {
            data: minarrow::Buffer::<i64>::from_slice(&[
                1_600_000_000_000,
                1_600_000_000_001,
                1_600_000_000_002,
            ]),
            null_mask: None,
            time_unit: TimeUnit::Milliseconds,
        }) as Arc<_>;

        // ---- 2. Wrap into Array enums ----
        #[cfg(feature = "extended_numeric_types")]
        let minarr_int8 = Array::NumericArray(NumericArray::Int8(arr_int8));
        #[cfg(feature = "extended_numeric_types")]
        let minarr_int16 = Array::NumericArray(NumericArray::Int16(arr_int16));
        let minarr_int32 = Array::NumericArray(NumericArray::Int32(arr_int32));
        let minarr_int64 = Array::NumericArray(NumericArray::Int64(arr_int64));
        #[cfg(feature = "extended_numeric_types")]
        let minarr_uint8 = Array::NumericArray(NumericArray::UInt8(arr_uint8));
        #[cfg(feature = "extended_numeric_types")]
        let minarr_uint16 = Array::NumericArray(NumericArray::UInt16(arr_uint16));
        let minarr_uint32 = Array::NumericArray(NumericArray::UInt32(arr_uint32));
        let minarr_uint64 = Array::NumericArray(NumericArray::UInt64(arr_uint64));
        let minarr_float32 = Array::NumericArray(NumericArray::Float32(arr_float32));
        let minarr_float64 = Array::NumericArray(NumericArray::Float64(arr_float64));
        let minarr_bool = Array::BooleanArray(arr_bool);
        let minarr_string32 = Array::TextArray(TextArray::String32(arr_string32));
        let minarr_categorical32 = Array::TextArray(TextArray::Categorical32(arr_categorical32));
        #[cfg(feature = "datetime")]
        let minarr_datetime32 = Array::TemporalArray(TemporalArray::Datetime32(arr_datetime32));
        #[cfg(feature = "datetime")]
        let minarr_datetime64 = Array::TemporalArray(TemporalArray::Datetime64(arr_datetime64));

        // ---- 3. Build Fields with correct logical types ----
        #[cfg(feature = "extended_numeric_types")]
        let field_int8 = Field::new("int8", ArrowType::Int8, false, None);
        #[cfg(feature = "extended_numeric_types")]
        let field_int16 = Field::new("int16", ArrowType::Int16, false, None);
        let field_int32 = Field::new("int32", ArrowType::Int32, false, None);
        let field_int64 = Field::new("int64", ArrowType::Int64, false, None);
        #[cfg(feature = "extended_numeric_types")]
        let field_uint8 = Field::new("uint8", ArrowType::UInt8, false, None);
        #[cfg(feature = "extended_numeric_types")]
        let field_uint16 = Field::new("uint16", ArrowType::UInt16, false, None);
        let field_uint32 = Field::new("uint32", ArrowType::UInt32, false, None);
        let field_uint64 = Field::new("uint64", ArrowType::UInt64, false, None);
        let field_float32 = Field::new("float32", ArrowType::Float32, false, None);
        let field_float64 = Field::new("float64", ArrowType::Float64, false, None);
        let field_bool = Field::new("bool", ArrowType::Boolean, false, None);
        let field_string32 = Field::new("string32", ArrowType::String, false, None);
        let field_categorical32 = Field::new(
            "categorical32",
            ArrowType::Dictionary(CategoricalIndexType::UInt32),
            false,
            None,
        );

        #[cfg(feature = "datetime")]
        let field_datetime32 = Field::new("dt32", ArrowType::Date32, false, None);
        #[cfg(feature = "datetime")]
        let field_datetime64 = Field::new("dt64", ArrowType::Date64, false, None);

        // ---- 4. Build FieldArrays ----
        #[cfg(feature = "extended_numeric_types")]
        let fa_int8 = FieldArray::new(field_int8, minarr_int8);
        #[cfg(feature = "extended_numeric_types")]
        let fa_int16 = FieldArray::new(field_int16, minarr_int16);
        let fa_int32 = FieldArray::new(field_int32, minarr_int32);
        let fa_int64 = FieldArray::new(field_int64, minarr_int64);
        #[cfg(feature = "extended_numeric_types")]
        let fa_uint8 = FieldArray::new(field_uint8, minarr_uint8);
        #[cfg(feature = "extended_numeric_types")]
        let fa_uint16 = FieldArray::new(field_uint16, minarr_uint16);
        let fa_uint32 = FieldArray::new(field_uint32, minarr_uint32);
        let fa_uint64 = FieldArray::new(field_uint64, minarr_uint64);
        let fa_float32 = FieldArray::new(field_float32, minarr_float32);
        let fa_float64 = FieldArray::new(field_float64, minarr_float64);
        let fa_bool = FieldArray::new(field_bool, minarr_bool);
        let fa_string32 = FieldArray::new(field_string32, minarr_string32);
        let fa_categorical32 = FieldArray::new(field_categorical32, minarr_categorical32);
        #[cfg(feature = "datetime")]
        let fa_datetime32 = FieldArray::new(field_datetime32, minarr_datetime32);
        #[cfg(feature = "datetime")]
        let fa_datetime64 = FieldArray::new(field_datetime64, minarr_datetime64);

        // ---- 5. Build Table ----
        let mut cols = Vec::new();
        #[cfg(feature = "extended_numeric_types")]
        {
            cols.push(fa_int8);
            cols.push(fa_int16);
        }
        cols.push(fa_int32);
        cols.push(fa_int64);
        #[cfg(feature = "extended_numeric_types")]
        {
            cols.push(fa_uint8);
            cols.push(fa_uint16);
        }
        cols.push(fa_uint32);
        cols.push(fa_uint64);
        cols.push(fa_float32);
        cols.push(fa_float64);
        cols.push(fa_bool);
        cols.push(fa_string32);
        cols.push(fa_categorical32);
        #[cfg(feature = "datetime")]
        {
            cols.push(fa_datetime32);
            cols.push(fa_datetime64);
        }
        let minarrow_table = Table::new("ffi_test".to_string(), Some(cols));

        // ---- 6. Export each column over FFI, import into Arrow-RS, and roundtrip back to Minarrow ----
        for (_, col) in minarrow_table.cols.iter().enumerate() {
            let array_arc = Arc::new(col.array.clone());
            let schema = Schema::from(vec![(*col.field).clone()]);

            // println!("Minarrow Pre-roundtrip for '{:?}':\n{:#?}", *col.field, array_arc);

            let (c_arr, c_schema) = export_to_c(array_arc.clone(), schema);

            // SAFETY: Arrow-RS expects raw pointers to FFI_ArrowArray/Schema
            let arr_ptr = c_arr as *mut FFI_ArrowArray;
            let schema_ptr = c_schema as *mut FFI_ArrowSchema;
            let arrow_array = unsafe { arr_ptr.read() };
            let arrow_schema = unsafe { schema_ptr.read() };
            let array_data = unsafe { arrow_from_ffi(arrow_array, &arrow_schema) }
                .expect("Arrow FFI import failed");
            let field_name = &col.field.name;
            println!(
                "Imported field '{}' as Arrow type {:?}",
                field_name,
                array_data.data_type()
            );
            println!("Arrow-RS values for '{}':", field_name);
            println!("  {:?}", array_data);

            // Convert ArrayData to ArrayRef
            let array_ref: ArrayRef = make_array(array_data.clone());

            // Pretty print as a table
            let arrow_schema = Arc::new(arrow::datatypes::Schema::new(vec![
                arrow::datatypes::Field::new(field_name, array_ref.data_type().clone(), false),
            ]));
            let batch = RecordBatch::try_new(arrow_schema, vec![array_ref.clone()]).unwrap();
            println!("Arrow-RS pretty-print for '{}':", field_name);
            arrow::util::pretty::print_batches(&[batch]).unwrap();

            // ---- 7. Export Arrow-RS back to Minarrow FFI, roundtrip ----
            let (ffi_out_arr, ffi_out_schema) =
                arrow_to_ffi(&array_data).expect("Arrow to FFI failed");

            // Correctly allocate Arrow-RS FFI structs on the heap and cast as raw pointers to your C ABI structs
            let ffi_out_arr_box = Box::new(ffi_out_arr);
            let ffi_out_schema_box = Box::new(ffi_out_schema);

            let arr_ptr =
                Box::into_raw(ffi_out_arr_box) as *const minarrow::ffi::arrow_c_ffi::ArrowArray;
            let schema_ptr =
                Box::into_raw(ffi_out_schema_box) as *const minarrow::ffi::arrow_c_ffi::ArrowSchema;

            // Now import back into minarrow using your real FFI import
            let minarr_back_array: Arc<Array> = unsafe { import_from_c(arr_ptr, schema_ptr) };

            println!(
                "Minarrow array (roundtrip) for '{}':\n{:#?}",
                field_name, minarr_back_array
            );

            // ---- 8. Validate roundtrip equality ----
            assert_eq!(
                &col.array,
                minarr_back_array.as_ref(),
                "Roundtrip array does not match for field {}",
                field_name
            );
        }

        println!("FFI roundtrip test completed for all supported types.");
    }

pub fn new_empty() -> Self

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.

Examples found in repository

examples/broadcasting/test_broadcasting.rs (line 293)

fn test_table_broadcasting() {
    println!("┌─ Test 9: Table Broadcasting");
    println!(
        "│  Operation: Table{{col1:[1,2,3], col2:[4,5,6]}} + Table{{col1:[10,10,10], col2:[20,20,20]}}"
    );
    println!("│  Expected:  Table{{col1:[11,12,13], col2:[24,25,26]}}");

    // Create first table with two columns
    let arr1_col1 = Array::from_int32(IntegerArray::from_slice(&vec64![1, 2, 3]));
    let arr1_col2 = Array::from_int32(IntegerArray::from_slice(&vec64![4, 5, 6]));
    let fa1_col1 = minarrow::FieldArray::from_arr("col1", arr1_col1);
    let fa1_col2 = minarrow::FieldArray::from_arr("col2", arr1_col2);
    let mut table1 = Table::new("table1".to_string(), None);
    table1.add_col(fa1_col1);
    table1.add_col(fa1_col2);

    // Create second table with matching structure
    let arr2_col1 = Array::from_int32(IntegerArray::from_slice(&vec64![10, 10, 10]));
    let arr2_col2 = Array::from_int32(IntegerArray::from_slice(&vec64![20, 20, 20]));
    let fa2_col1 = minarrow::FieldArray::from_arr("col1", arr2_col1);
    let fa2_col2 = minarrow::FieldArray::from_arr("col2", arr2_col2);
    let mut table2 = Table::new("table2".to_string(), None);
    table2.add_col(fa2_col1);
    table2.add_col(fa2_col2);

    match Value::Table(Arc::new(table1)) + Value::Table(Arc::new(table2)) {
        Ok(Value::Table(result)) => {
            if let Array::NumericArray(NumericArray::Int32(col1)) = &result.cols[0].array {
                println!("│  Result col1: {:?}", col1.data.as_slice());
            }
            if let Array::NumericArray(NumericArray::Int32(col2)) = &result.cols[1].array {
                println!("│  Result col2: {:?}", col2.data.as_slice());
            }
            println!("└─ ✓ Passed\n");
        }
        Ok(other) => println!("└─ ✗ Error: Unexpected result type {:?}\n", other),
        Err(e) => println!("└─ ✗ Error: {:?}\n", e),
    }
}

/// Test ArrayView broadcasting - efficient windowed operations
fn test_array_view_broadcasting() {
    #[cfg(feature = "views")]
    {
        println!("┌─ Test 10: ArrayView Broadcasting");
        println!("│  Operation: ArrayView([2,3,4]) + ArrayView([10,10,10])");
        println!("│  Expected:  Array([12,13,14])");

        // Create an array and a view into it
        let arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![1, 2, 3, 4, 5]));
        let view1 = ArrayV::new(arr1, 1, 3); // View of elements [2,3,4]

        let arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![10, 10, 10]));
        let view2 = ArrayV::new(arr2, 0, 3);

        match Value::ArrayView(Arc::new(view1)) + Value::ArrayView(Arc::new(view2)) {
            Ok(Value::Array(arr_arc)) => {
                if let Array::NumericArray(NumericArray::Int32(result)) = arr_arc.as_ref() {
                    println!("│  Result:    {:?}", result.data.as_slice());
                    println!("└─ ✓ Passed\n");
                } else {
                    println!("└─ ✗ Error: Unexpected array type\n");
                }
            }
            Ok(_) => println!("└─ ✗ Error: Unexpected result type\n"),
            Err(e) => println!("└─ ✗ Error: {:?}\n", e),
        }
    }

    #[cfg(not(feature = "views"))]
    {
        println!("┌─ Test 10: ArrayView Broadcasting");
        println!("└─ ⊘ Skipped (views feature not enabled)\n");
    }
}

/// Test SuperArray broadcasting - chunked array operations
fn test_super_array_broadcasting() {
    #[cfg(feature = "chunked")]
    {
        println!("┌─ Test 11: SuperArray (Chunked) Broadcasting");
        println!("│  Operation: SuperArray{{[1,2],[3,4]}} * SuperArray{{[2,2],[2,2]}}");
        println!("│  Expected:  SuperArray{{[2,4],[6,8]}}");

        // Create chunked arrays (multiple field array chunks)
        let chunk1_a = Array::from_int32(IntegerArray::from_slice(&vec64![1, 2]));
        let chunk2_a = Array::from_int32(IntegerArray::from_slice(&vec64![3, 4]));
        let fa1 = minarrow::FieldArray::from_arr("chunk1", chunk1_a);
        let fa2 = minarrow::FieldArray::from_arr("chunk1", chunk2_a);
        let super_arr1 = SuperArray::from_field_array_chunks(vec![fa1, fa2]);

        let chunk1_b = Array::from_int32(IntegerArray::from_slice(&vec64![2, 2]));
        let chunk2_b = Array::from_int32(IntegerArray::from_slice(&vec64![2, 2]));
        let fa3 = minarrow::FieldArray::from_arr("chunk1", chunk1_b);
        let fa4 = minarrow::FieldArray::from_arr("chunk1", chunk2_b);
        let super_arr2 = SuperArray::from_field_array_chunks(vec![fa3, fa4]);

        match Value::SuperArray(Arc::new(super_arr1)) * Value::SuperArray(Arc::new(super_arr2)) {
            Ok(Value::SuperArray(result)) => {
                println!("│  Result with {} chunks:", result.len());
                for i in 0..result.len() {
                    if let Some(fa) = result.chunk(i) {
                        if let Array::NumericArray(NumericArray::Int32(arr)) = &fa.array {
                            println!("│    Chunk {}: {:?}", i, arr.data.as_slice());
                        }
                    }
                }
                println!("└─ ✓ Passed\n");
            }
            Ok(other) => println!("└─ ✗ Error: Unexpected result type {:?}\n", other),
            Err(e) => println!("└─ ✗ Error: {:?}\n", e),
        }
    }

    #[cfg(not(feature = "chunked"))]
    {
        println!("┌─ Test 11: SuperArray (Chunked) Broadcasting");
        println!("└─ ⊘ Skipped (chunked feature not enabled)\n");
    }
}

/// Test Cube broadcasting - 3D tensor operations
fn test_cube_broadcasting() {
    #[cfg(feature = "cube")]
    {
        println!("┌─ Test 12: Cube (3D) Broadcasting");
        println!("│  Operation: Cube{{2 tables}} + Cube{{2 tables}}");
        println!("│  Expected:  Element-wise addition across all tables");

        // Create first cube with 2 tables
        // First, create columns for table 1
        let t1_arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![1, 2]));
        let t1_arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![3, 4]));
        let t1_fa1 = minarrow::FieldArray::from_arr("col1", t1_arr1);
        let t1_fa2 = minarrow::FieldArray::from_arr("col2", t1_arr2);

        // Create columns for cube1 via constructor
        let mut cube1 = Cube::new("cube1".to_string(), Some(vec![t1_fa1, t1_fa2]), None);

        // Add second table to cube1
        let t2_arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![5, 6]));
        let t2_arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![7, 8]));
        let t2_fa1 = minarrow::FieldArray::from_arr("col1", t2_arr1);
        let t2_fa2 = minarrow::FieldArray::from_arr("col2", t2_arr2);
        let mut table2 = Table::new("t2".to_string(), None);
        table2.add_col(t2_fa1);
        table2.add_col(t2_fa2);
        cube1.add_table(table2);

        // Create second cube
        let t3_arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![10, 10]));
        let t3_arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![20, 20]));
        let t3_fa1 = minarrow::FieldArray::from_arr("col1", t3_arr1);
        let t3_fa2 = minarrow::FieldArray::from_arr("col2", t3_arr2);
        let mut cube2 = Cube::new("cube2".to_string(), Some(vec![t3_fa1, t3_fa2]), None);

        let t4_arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![30, 30]));
        let t4_arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![40, 40]));
        let t4_fa1 = minarrow::FieldArray::from_arr("col1", t4_arr1);
        let t4_fa2 = minarrow::FieldArray::from_arr("col2", t4_arr2);
        let mut table4 = Table::new("t4".to_string(), None);
        table4.add_col(t4_fa1);
        table4.add_col(t4_fa2);
        cube2.add_table(table4);

        match Value::Cube(Arc::new(cube1)) + Value::Cube(Arc::new(cube2)) {
            Ok(Value::Cube(result)) => {
                println!("│  Result cube with {} tables:", result.n_tables());
                for i in 0..result.n_tables() {
                    println!("│  Table {}:", i);
                    if let Some(table) = result.table(i) {
                        for j in 0..table.n_cols() {
                            let col = &table.cols[j];
                            if let Array::NumericArray(NumericArray::Int32(arr)) = &col.array {
                                println!("│    Column {}: {:?}", j, arr.data.as_slice());
                            }
                        }
                    }
                }
                println!("└─ ✓ Passed\n");
            }
            Ok(other) => println!("└─ ✗ Error: Unexpected result type {:?}\n", other),
            Err(e) => println!("└─ ✗ Error: {:?}\n", e),
        }
    }

    #[cfg(not(feature = "cube"))]
    {
        println!("┌─ Test 12: Cube (3D) Broadcasting");
        println!("└─ ⊘ Skipped (cube feature not enabled)\n");
    }
}

examples/print/print_table.rs (line 71)

fn main() {
    // Inner arrays

    // Numeric
    let col_i32 = IntArr::<i32>::from_slice(&[1, 2, 3, 4, 5]);
    let col_u32 = IntArr::<u32>::from_slice(&[100, 200, 300, 400, 500]);
    let col_i64 = IntArr::<i64>::from_slice(&[10, 20, 30, 40, 50]);
    let col_u64 = IntArr::<u64>::from_slice(&[101, 201, 301, 401, 501]);
    let col_f32 = FltArr::<f32>::from_slice(&[1.1, 2.2, 3.3, 4.4, 5.5]);
    let col_f64 = FltArr::<f64>::from_slice(&[2.2, 3.3, 4.4, 5.5, 6.6]);

    // Boolean with nulls
    let mut col_bool = BoolArr::from_slice(&[true, false, true, false, true]);
    col_bool.set_null_mask(Some(Bitmask::from_bools(&[true, true, true, false, true])));

    // String and Dictionary/Categorical
    let col_str32 = StrArr::<u32>::from_slice(&["red", "blue", "green", "yellow", "purple"]);
    let col_cat32 = CatArr::<u32>::from_values(
        ["apple", "banana", "cherry", "banana", "apple"]
            .iter()
            .copied(),
    );

    // Datetime
    #[cfg(feature = "datetime")]
    let col_dt32 = DatetimeArray::<i32>::from_slice(
        &[1000, 2000, 3000, 4000, 5000],
        Some(TimeUnit::Milliseconds),
    );
    #[cfg(feature = "datetime")]
    let col_dt64 = DatetimeArray::<i64>::from_slice(
        &[
            1_000_000_000,
            2_000_000_000,
            3_000_000_000,
            4_000_000_000,
            5_000_000_000,
        ],
        Some(TimeUnit::Nanoseconds),
    );

    // FieldArray (column) construction
    let fa_i32 = FieldArray::from_arr("int32_col", col_i32);
    let fa_u32 = FieldArray::from_arr("uint32_col", col_u32);
    let fa_i64 = FieldArray::from_arr("int64_col", col_i64);
    let fa_u64 = FieldArray::from_arr("uint64_col", col_u64);
    let fa_f32 = FieldArray::from_arr("float32_col", col_f32);
    let fa_f64 = FieldArray::from_arr("float64_col", col_f64);
    let fa_bool = FieldArray::from_arr("bool_col", col_bool);
    let fa_str32 = FieldArray::from_arr("utf8_col", col_str32);
    let fa_cat32 = FieldArray::from_arr("dict32_col", col_cat32);
    #[cfg(feature = "datetime")]
    let fa_dt32 = FieldArray::from_arr("datetime32_col", col_dt32);
    #[cfg(feature = "datetime")]
    let fa_dt64 = FieldArray::from_arr("datetime64_col", col_dt64);

    // Build Table
    let mut tbl = Table::new("MyTable".to_string(), None);
    tbl.add_col(fa_i32);
    tbl.add_col(fa_u32);
    tbl.add_col(fa_i64);
    tbl.add_col(fa_u64);
    tbl.add_col(fa_f32);
    tbl.add_col(fa_f64);
    tbl.add_col(fa_bool);
    tbl.add_col(fa_str32);
    tbl.add_col(fa_cat32);
    #[cfg(feature = "datetime")]
    tbl.add_col(fa_dt32);
    #[cfg(feature = "datetime")]
    tbl.add_col(fa_dt64);

    // Print the table
    tbl.print();
}

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.

Examples found in repository

examples/broadcasting/test_broadcasting.rs (line 451)

fn test_cube_broadcasting() {
    #[cfg(feature = "cube")]
    {
        println!("┌─ Test 12: Cube (3D) Broadcasting");
        println!("│  Operation: Cube{{2 tables}} + Cube{{2 tables}}");
        println!("│  Expected:  Element-wise addition across all tables");

        // Create first cube with 2 tables
        // First, create columns for table 1
        let t1_arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![1, 2]));
        let t1_arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![3, 4]));
        let t1_fa1 = minarrow::FieldArray::from_arr("col1", t1_arr1);
        let t1_fa2 = minarrow::FieldArray::from_arr("col2", t1_arr2);

        // Create columns for cube1 via constructor
        let mut cube1 = Cube::new("cube1".to_string(), Some(vec![t1_fa1, t1_fa2]), None);

        // Add second table to cube1
        let t2_arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![5, 6]));
        let t2_arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![7, 8]));
        let t2_fa1 = minarrow::FieldArray::from_arr("col1", t2_arr1);
        let t2_fa2 = minarrow::FieldArray::from_arr("col2", t2_arr2);
        let mut table2 = Table::new("t2".to_string(), None);
        table2.add_col(t2_fa1);
        table2.add_col(t2_fa2);
        cube1.add_table(table2);

        // Create second cube
        let t3_arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![10, 10]));
        let t3_arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![20, 20]));
        let t3_fa1 = minarrow::FieldArray::from_arr("col1", t3_arr1);
        let t3_fa2 = minarrow::FieldArray::from_arr("col2", t3_arr2);
        let mut cube2 = Cube::new("cube2".to_string(), Some(vec![t3_fa1, t3_fa2]), None);

        let t4_arr1 = Array::from_int32(IntegerArray::from_slice(&vec64![30, 30]));
        let t4_arr2 = Array::from_int32(IntegerArray::from_slice(&vec64![40, 40]));
        let t4_fa1 = minarrow::FieldArray::from_arr("col1", t4_arr1);
        let t4_fa2 = minarrow::FieldArray::from_arr("col2", t4_arr2);
        let mut table4 = Table::new("t4".to_string(), None);
        table4.add_col(t4_fa1);
        table4.add_col(t4_fa2);
        cube2.add_table(table4);

        match Value::Cube(Arc::new(cube1)) + Value::Cube(Arc::new(cube2)) {
            Ok(Value::Cube(result)) => {
                println!("│  Result cube with {} tables:", result.n_tables());
                for i in 0..result.n_tables() {
                    println!("│  Table {}:", i);
                    if let Some(table) = result.table(i) {
                        for j in 0..table.n_cols() {
                            let col = &table.cols[j];
                            if let Array::NumericArray(NumericArray::Int32(arr)) = &col.array {
                                println!("│    Column {}: {:?}", j, arr.data.as_slice());
                            }
                        }
                    }
                }
                println!("└─ ✓ Passed\n");
            }
            Ok(other) => println!("└─ ✗ Error: Unexpected result type {:?}\n", other),
            Err(e) => println!("└─ ✗ Error: {:?}\n", e),
        }
    }

    #[cfg(not(feature = "cube"))]
    {
        println!("┌─ Test 12: Cube (3D) Broadcasting");
        println!("└─ ⊘ Skipped (cube feature not enabled)\n");
    }
}

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(&self, idx: usize) -> Option<&FieldArray>

Returns a column by index.

Examples found in repository

examples/selection.rs (line 65)

fn main() {
    // Create a sample table
    let table = create_sample_table();

    println!("Original table:");
    println!("{}\n", table);

    // Table-specific API
    println!("=== Table-specific API ===\n");

    println!("table.c(&[\"name\", \"age\"]).r(1..4)");
    let view1 = table.c(&["name", "age"]).r(1..4);
    println!("{}\n", view1);

    println!("table.c(&[0, 2]).r(&[0, 2, 4])");
    let view2 = table.c(&[0, 2]).r(&[0, 2, 4]);
    println!("{}\n", view2);

    println!("table.c(0..2).r(0..5)");
    let view3 = table.c(0..2).r(0..5);
    println!("{}\n", view3);

    println!("table.c(1).r(&[2, 4, 6])");
    let view4 = table.c(1).r(&[2, 4, 6]);
    println!("{}\n", view4);

    // Aliased API
    println!("=== Aliases ===\n");

    println!("table.f(&[\"id\", \"age\"]).d(0..3)");
    let view5 = table.f(&["id", "age"]).d(0..3);
    println!("{}\n", view5);

    println!("table.fields(&[\"name\"]).data(1..5)");
    let view6 = table.fields(&["name"]).data(1..5);
    println!("{}\n", view6);

    println!("table.f(0..2).d(&[0, 3, 6, 9])");
    let view7 = table.f(0..2).d(&[0, 3, 6, 9]);
    println!("{}\n", view7);

    println!("table.y(2).x(..5)");
    let view8 = table.y(2).x(..5);
    println!("{}\n", view8);

    println!("table.fields(1..).data(5..)");
    let view9 = table.fields(1..).data(5..);
    println!("{}\n", view9);

    // Materialise selections
    println!("=== Materialisation ===\n");

    println!("table.f(&[\"name\", \"age\"]).d(0..3).to_table()");
    let view = table.f(&["name", "age"]).d(0..3);
    let materialised = view.to_table();
    println!("{}\n", materialised);

    // Array and FieldArray selection
    println!("=== Array & FieldArray Selection ===\n");

    // Get a single column as FieldArray
    let age_col = table.col(2).unwrap().clone();
    println!("Original age column (FieldArray):");
    println!("  Field: {} ({})", age_col.field.name, age_col.arrow_type());
    println!("  Length: {}", age_col.len());
    println!("  Values: {:?}\n", (0..age_col.len()).map(|i| age_col.array.inner::<IntegerArray<i32>>().get(i).unwrap()).collect::<Vec<_>>());

    // Select specific rows from FieldArray using .d()
    println!("age_col.d(&[1, 3, 5, 7])");
    let age_view = age_col.d(&[1, 3, 5, 7]);
    println!("  View length: {}", age_view.len());
    println!("  Selected indices: {:?}\n", (0..age_view.len()).map(|i| age_view.get::<IntegerArray<i32>>(i).unwrap()).collect::<Vec<_>>());

    // ArrayV selection (direct array view)
    let id_array = Array::from_int32({
        let mut arr = IntegerArray::<i32>::default();
        for i in 0..10 {
            arr.push(i * 10);
        }
        arr
    });
    let id_view = ArrayV::from(id_array);
    println!("Original ArrayV:");
    println!("  Length: {}", id_view.len());
    println!("  Values: {:?}\n", (0..id_view.len()).map(|i| id_view.get::<IntegerArray<i32>>(i).unwrap()).collect::<Vec<_>>());

    // Select from ArrayV using .data() and .x() aliases
    println!("id_view.data(0..5)");
    let id_selected1 = id_view.data(0..5);
    println!("  Length: {}", id_selected1.len());
    println!("  Values: {:?}\n", (0..id_selected1.len()).map(|i| id_selected1.get::<IntegerArray<i32>>(i).unwrap()).collect::<Vec<_>>());

    println!("id_view.x(&[2, 4, 6, 8])");
    let id_selected2 = id_view.x(&[2, 4, 6, 8]);
    println!("  Length: {}", id_selected2.len());
    println!("  Values: {:?}", (0..id_selected2.len()).map(|i| id_selected2.get::<IntegerArray<i32>>(i).unwrap()).collect::<Vec<_>>());
}

pub fn col_by_name(&self, name: &str) -> Option<&FieldArray>

Returns a column by name.

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

Returns the list of column names.

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

Returns the index of a column by name.

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.

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 slice_clone(&self, offset: usize, len: usize) -> Self

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 c<S: FieldSelector>(&self, selection: S) -> TableV

Select columns by names, indices, or ranges (table-specific convenience method).

This method delegates to .f() from the Selection trait. For compatibility across dimensions, prefer using .f(), .fields(), or .y().

Example

use minarrow::Table;

// Select columns by names
let view = table.c(&["A", "B", "C"]);

// Select columns by indices
let view = table.c(&[0, 1, 2]);

// Select columns by range
let view = table.c(0..3);

// Single column
let view = table.c("A");

Examples found in repository

examples/selection.rs (line 15)

fn main() {
    // Create a sample table
    let table = create_sample_table();

    println!("Original table:");
    println!("{}\n", table);

    // Table-specific API
    println!("=== Table-specific API ===\n");

    println!("table.c(&[\"name\", \"age\"]).r(1..4)");
    let view1 = table.c(&["name", "age"]).r(1..4);
    println!("{}\n", view1);

    println!("table.c(&[0, 2]).r(&[0, 2, 4])");
    let view2 = table.c(&[0, 2]).r(&[0, 2, 4]);
    println!("{}\n", view2);

    println!("table.c(0..2).r(0..5)");
    let view3 = table.c(0..2).r(0..5);
    println!("{}\n", view3);

    println!("table.c(1).r(&[2, 4, 6])");
    let view4 = table.c(1).r(&[2, 4, 6]);
    println!("{}\n", view4);

    // Aliased API
    println!("=== Aliases ===\n");

    println!("table.f(&[\"id\", \"age\"]).d(0..3)");
    let view5 = table.f(&["id", "age"]).d(0..3);
    println!("{}\n", view5);

    println!("table.fields(&[\"name\"]).data(1..5)");
    let view6 = table.fields(&["name"]).data(1..5);
    println!("{}\n", view6);

    println!("table.f(0..2).d(&[0, 3, 6, 9])");
    let view7 = table.f(0..2).d(&[0, 3, 6, 9]);
    println!("{}\n", view7);

    println!("table.y(2).x(..5)");
    let view8 = table.y(2).x(..5);
    println!("{}\n", view8);

    println!("table.fields(1..).data(5..)");
    let view9 = table.fields(1..).data(5..);
    println!("{}\n", view9);

    // Materialise selections
    println!("=== Materialisation ===\n");

    println!("table.f(&[\"name\", \"age\"]).d(0..3).to_table()");
    let view = table.f(&["name", "age"]).d(0..3);
    let materialised = view.to_table();
    println!("{}\n", materialised);

    // Array and FieldArray selection
    println!("=== Array & FieldArray Selection ===\n");

    // Get a single column as FieldArray
    let age_col = table.col(2).unwrap().clone();
    println!("Original age column (FieldArray):");
    println!("  Field: {} ({})", age_col.field.name, age_col.arrow_type());
    println!("  Length: {}", age_col.len());
    println!("  Values: {:?}\n", (0..age_col.len()).map(|i| age_col.array.inner::<IntegerArray<i32>>().get(i).unwrap()).collect::<Vec<_>>());

    // Select specific rows from FieldArray using .d()
    println!("age_col.d(&[1, 3, 5, 7])");
    let age_view = age_col.d(&[1, 3, 5, 7]);
    println!("  View length: {}", age_view.len());
    println!("  Selected indices: {:?}\n", (0..age_view.len()).map(|i| age_view.get::<IntegerArray<i32>>(i).unwrap()).collect::<Vec<_>>());

    // ArrayV selection (direct array view)
    let id_array = Array::from_int32({
        let mut arr = IntegerArray::<i32>::default();
        for i in 0..10 {
            arr.push(i * 10);
        }
        arr
    });
    let id_view = ArrayV::from(id_array);
    println!("Original ArrayV:");
    println!("  Length: {}", id_view.len());
    println!("  Values: {:?}\n", (0..id_view.len()).map(|i| id_view.get::<IntegerArray<i32>>(i).unwrap()).collect::<Vec<_>>());

    // Select from ArrayV using .data() and .x() aliases
    println!("id_view.data(0..5)");
    let id_selected1 = id_view.data(0..5);
    println!("  Length: {}", id_selected1.len());
    println!("  Values: {:?}\n", (0..id_selected1.len()).map(|i| id_selected1.get::<IntegerArray<i32>>(i).unwrap()).collect::<Vec<_>>());

    println!("id_view.x(&[2, 4, 6, 8])");
    let id_selected2 = id_view.x(&[2, 4, 6, 8]);
    println!("  Length: {}", id_selected2.len());
    println!("  Values: {:?}", (0..id_selected2.len()).map(|i| id_selected2.get::<IntegerArray<i32>>(i).unwrap()).collect::<Vec<_>>());
}

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

Select rows by indices or ranges (table-specific convenience method).

This method delegates to .d() from the Selection trait. For compatibility across dimensions, prefer using .d(), .data(), or .x().

Example

use minarrow::Table;

// Select rows by range
let view = table.r(10..20);

// Select specific rows
let view = table.r(&[1, 5, 10, 15]);

// Single row
let view = table.r(5);

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.

impl Table

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

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

pub fn to_apache_arrow(&self) -> RecordBatch

Export each column to arrow-rs ArrayRef and build a RecordBatch.

The Arrow schema is derived from the imported array dtypes while preserving the original field names and nullability flags.

pub fn to_polars(&self) -> DataFrame

Casts the table to a Polars DataFrame

Trait Implementations

impl Add for Table

type Output = Result<Table, MinarrowError>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl ByteSize for Table

ByteSize for Table - sum of all column arrays

fn est_bytes(&self) -> usize

Returns the estimated byte size of this object in memory.

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

fn concat(self, other: Self) -> Result<Self, 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 DataSelection for Table

Available on crate features views and select only.

type View = TableV

The view type returned by selection operations

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

Select data (rows) by index or range

fn get_data_count(&self) -> usize

Get the count for data resolution

fn data<S: DataSelector>(&self, selection: S) -> Self::View

Explicit alias for .d() - select data

fn x<S: DataSelector>(&self, selection: S) -> Self::View

Spatial alias for .d() - X-axis (horizontal, data dimension)

impl Debug for Table

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

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

Formats the value using the given formatter.

impl Div for Table

type Output = Result<Table, MinarrowError>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl FieldSelection for Table

Available on crate features views and select only.

type View = TableV

The view type returned by selection operations

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

Select fields (columns) by name or index

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

Get the fields for field resolution

fn fields<S: FieldSelector>(&self, selection: S) -> Self::View

Explicit alias for .f() - select fields

fn y<S: FieldSelector>(&self, selection: S) -> Self::View

Spatial alias for .f() - Y-axis (vertical, schema dimension)

impl From<Table> for TableV

Table -> TableV conversion

fn from(table: Table) -> Self

Converts to this type from the input type.

impl From<Table> for Value

fn from(v: Table) -> Self

Converts to this type from the input type.

impl From<TableV> for Table

TableV -> Table conversion

fn from(view: TableV) -> Self

Converts to this type from the input type.

impl FromIterator<Table> for SuperTable

fn from_iter<T: IntoIterator<Item = Table>>(iter: T) -> Self

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) -> Self::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) -> Self::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) -> Self::IntoIter

Creates an iterator from a value.

impl Mul for Table

type Output = Result<Table, MinarrowError>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

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

type Output = Result<Table, MinarrowError>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

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

type Output = Result<Table, MinarrowError>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl TryFrom<Value> for Table

type Error = MinarrowError

The type returned in the event of a conversion error.

fn try_from(v: Value) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for Table