Enum Column 

pub enum Column {
    Int(Vec<i64>),
    Float(Vec<f64>),
    Str(Vec<String>),
    Bool(Vec<bool>),
    Categorical {
        levels: Vec<String>,
        codes: Vec<u32>,
    },
    CategoricalAdaptive(Box<CategoricalColumn>),
    DateTime(Vec<i64>),
}

A single column in a DataFrame.

Variants

Int(Vec<i64>)

64-bit signed integer column.

Float(Vec<f64>)

64-bit floating-point column.

Str(Vec<String>)

UTF-8 string column.

Bool(Vec<bool>)

Boolean column.

Categorical

Categorical column: sorted unique level names + per-row index into levels.

Fields

levels: Vec<String>

codes: Vec<u32>

CategoricalAdaptive(Box<CategoricalColumn>)

Adaptive-width categorical column wrapping Phase 1’s byte_dict::CategoricalColumn. Backed by AdaptiveCodes (U8/U16/U32/U64 auto-promoting at 256 / 65 536 / 2³² thresholds) and a ByteDictionary with optional shared/frozen state.

Coexists with Column::Categorical rather than replacing it — existing column readers continue to use the simpler (Vec<String>, Vec<u32>) storage; new code that needs adaptive widths or shared dictionaries opts into this variant via Column::categorical_adaptive(...).

DateTime(Vec<i64>)

DateTime column: epoch milliseconds.

Implementations

impl Column

pub fn len(&self) -> usize

Returns the number of rows in this column.

pub fn is_empty(&self) -> bool

Returns true if the column has zero rows.

pub fn type_name(&self) -> &'static str

Returns the human-readable type name of this column variant.

pub fn get_display(&self, idx: usize) -> String

Get a display-friendly value at index.

pub fn categorical_adaptive(cc: CategoricalColumn) -> Self

Construct a Column::CategoricalAdaptive from a CategoricalColumn. New-style categorical column with adaptive code widths.

pub fn to_legacy_categorical(&self) -> Column

Materialize any Column::CategoricalAdaptive into a Column::Categorical for consumption by legacy code paths. For non-adaptive variants this returns self.clone(). For adaptive variants with non-UTF-8 levels or null values this returns Column::Str (display-equivalent) — preserves the consumer’s per-row read semantics while avoiding silent data loss.

This is the universal back-compat shim for the 19 column-reader match sites added before the adaptive variant existed. New code should switch on the variant directly.

pub fn to_categorical_column(&self) -> Option<CategoricalColumn>

Convert a Column::Categorical to a byte_dict::CategoricalColumn.

Uses CategoryOrdering::Explicit to pin the level→code mapping exactly as it stands in the source column, so round-tripping back via from_categorical_column yields byte-identical levels and codes. Returns None for non-categorical variants.

pub fn from_categorical_column(cat: &CategoricalColumn) -> Option<Self>

Build a Column::Categorical from a byte_dict::CategoricalColumn.

Iterates the dictionary in code order to reconstruct levels, and the codes via AdaptiveCodes::iter() cast to u32. Returns None if any level is not valid UTF-8 (the byte dictionary is byte-keyed; Column::Categorical is String-keyed) or if cardinality exceeds u32::MAX (would not fit in Vec<u32> codes). Null-bearing categorical columns also return None for now — Column::Categorical does not carry a null bitmap.

Trait Implementations

impl Clone for Column

fn clone(&self) -> Column

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Column

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

Formats the value using the given formatter.