Struct ColumnFrame 

pub struct ColumnFrame {
    pub index: KeyIndex,
    pub data_frame: Array2<DataValue>,
}

ColumnFrame is used to store the data for the candidates The data is stored in the Array2 with the DataValue values The data is stored in the columns and the columns are indexed by the KeyIndex The KeyIndex is used to access the data by the column Key Memory layout is same like in ndarray - the data is stored in the row-major order

Fields

index: KeyIndex

data_frame: Array2<DataValue>

Implementations

impl ColumnFrame

pub fn new<K: Into<KeyIndex>>(index: K, data_frame: Array2<DataValue>) -> Self

Creates a new ColumnFrame from a column index and a 2D data array.

The number of columns in data_frame must match the number of keys in index.

pub fn keys(&self) -> &[Key]

Returns the ordered slice of column Keys in this frame.

pub fn len(&self) -> usize

Returns the number of rows in this frame.

pub fn is_empty(&self) -> bool

Returns true if the frame contains no rows.

pub fn shrink(&mut self)

Compacts internal storage to reduce memory usage after mutations that may have left over-allocated capacity.

pub fn try_fix_dtype_for_keys(&mut self, force: bool) -> Result<(), Error>

This method will try to fix dtype based on data stored in each column. If dtype is crate::DataType::Unknown this method will replace dtype for “correct” one based on DataValue. NOTE: flag force will enforce this dtype even if dtype is known

pub fn try_fix_dtype(&mut self) -> Result<(), Error>

Attempts to fix the dtype of every column by inspecting stored values.

Columns whose data does not match their declared dtype are cast in-place. Returns Err with a list of (key, message) pairs for columns that failed casting.

pub fn try_fix_column_by_key(&mut self, key: &Key) -> Result<(), Error>

Casts all values in the column identified by key to match the key’s declared dtype.

Returns an error if the key is not found in the frame.

pub fn enforce_dtype_for_column( &mut self, key: &str, dtype: DataType, ) -> Result<(), Error>

Forces all values in the named column to the specified dtype, updating both the stored data and the column’s Key metadata.

Returns an error if the column name does not exist.

pub fn get_mut_view(&mut self) -> ArrayViewMut2<'_, DataValue>

Returns a mutable 2D view over the entire data array.

This allows direct element-level mutation without going through get_mut_by_row_index.

pub fn rename_key(&mut self, old: &str, new: Key) -> Result<(), Error>

Renames a column from old (matched by name) to new.

The new Key can carry a different DataType, which effectively re-declares the column’s type without casting existing values.

pub fn add_alias(&mut self, key: &str, alias: &str) -> Result<(), Error>

Registers alias as an alternative name for the column named key.

After aliasing, select and friends accept both the original name and the alias.

pub fn select_transposed_typed<D: Extract>(&self, keys: &[Key]) -> Vec<Vec<D>>

Selects the data from the ColumnFrame by the given keys If the keys are not provided, the data is selected by the KeyIndex keys The data is returned as the Vec<Vec<DataValue>> If the keys are not found, the empty Vec<Vec<DataValue>> is returned Returns the data in the column-major order

pub fn select_transposed( &self, keys: Option<&[Key]>, ) -> Result<Array2<DataValue>, Error>

Selects the data from the ColumnFrame by the given keys If the keys are not provided, the data is selected by the KeyIndex keys The data is returned as the Array2 with the DataValue values If the keys are not found, the empty Array2 is returned Returns the Array2 with the data in row-major order (same as ndarray default) Note: Despite the method name, the data is NOT transposed - it returns data in row-major order Use this when you want row-oriented access to the selected columns

pub fn select_column(&self, key: &Key) -> Option<ArrayView1<'_, DataValue>>

Selects whole column from the ColumnFrame by the given key If the key is not found, the None is returned If the key is found, the ArrayView1 with the DataValue values is returned

pub fn apply_function<F>(&mut self, keys: &[Key], func: F) -> Result<(), Error>

where F: FnMut(&[Key], &mut ColumnFrame) -> Result<(), Error>,

Applies a user-defined closure to this frame.

The closure receives the provided keys and a mutable reference to the frame, allowing arbitrary in-place transformations.

pub fn validate_entry_access( &self, column: &Key, row_index: usize, ) -> Result<usize, Error>

Validates the access to the entry by the given column Key and row index If the column is not found, an error is returned Error::NotFound If the row index is out of bounds, an error is returned Error::IndexOutOfRange Otherwise, the column index is returned

pub fn get_by_row_index( &self, column: &Key, row_index: usize, ) -> Option<&DataValue>

Returns the value DataValue for the given column defined by Key and row index If the column is not found, None is returned If the row index is out of bounds, None is returned

pub fn get_mut_by_row_index( &mut self, column: &Key, row_index: usize, ) -> Option<&mut DataValue>

Returns mutable reference for the value DataValue for the given column defined by Key and row index If the column is not found, None is returned If the row index is out of bounds, None is returned

pub fn select_as_map( &self, keys: Option<&[Key]>, ) -> HashMap<Key, Vec<DataValue>>

Returns the value HashMap<Key, Vec<DataValue>> for the given columns defined by Key. If the keys are not provided, the data is selected by the KeyIndex keys If the keys are not found, the empty HashMap is returned Returns the Array2 with the data in the row-major order

pub fn select(&self, keys: Option<&[Key]>) -> Array2<DataValue>

Returns the value Array2<DataValue> for the given columns defined by Key. If the keys are not provided, the data is selected by the KeyIndex keys If the keys are not found, the empty Array2 is returned Returns the Array2 with the data in the row-major order

This operation clones all selected data. For read-only access, consider using Self::select_column to get a view of a single column without copying.

pub fn select_typed<T: Extract>(&self, keys: Option<&[Key]>) -> Array2<T>

Returns selected columns as a typed 2D array, converting each DataValue via the Extract trait.

This is the typed counterpart of select. If keys is None, all columns are returned. The data is in row-major order (rows × columns).

Type coercion

The Extract trait performs best-effort numeric coercion (e.g. I32 -> f64). Values that cannot be meaningfully converted yield the type’s default (0 for numbers, false for bool, empty string for String).

pub fn push<C: CandidateData>(&mut self, row_candidate: C) -> Result<(), Error>

Pushes the row candidate into the ColumnFrame If the column is not found this method will add the column to the ColumnFrame

This operation clones all values from the candidate. For batch operations, consider using Self::extend instead which can be more efficient.

pub fn remove_column(&mut self, keys: &[Key]) -> Result<Self, Error>

Removes the specified columns from this frame and returns them as a new ColumnFrame.

The remaining columns stay in self with their data intact.

pub fn extend(&mut self, other: Self) -> Result<(), Error>

Extends the ColumnFrame with the data from the other ColumnFrame If the KeyIndex is empty, the ColumnFrame is replaced with the other ColumnFrame If the other KeyIndex is empty, nothing happens If the length of the KeyIndex of the other data frame is greater then current, an error is returned Error::DataSetSizeDoesntMatch If Key from other data frame - extends the KeyIndex and add column to the current ColumnFrame

pub fn replace(&mut self, other: Self) -> Result<(), Error>

Replace the ColumnFrame with the other ColumnFrame If the current KeyIndex is empty, the ColumnFrame is replaced with the other ColumnFrame If the other KeyIndex is empty, nothing happens If the KeyIndex of the other data frame and current doesn’t match an error is returned Error::DataSetSizeDoesntMatch If the Key from other data frame is not present in the current ColumnFrame - extends the KeyIndex and add column to the current ColumnFrame

pub fn join_by_id_inner( &mut self, right: Self, keys: &[Key], ) -> Result<(), Error>

Joins the candidates by the keys in the JoinRelation::JoinById struct. This function creates Index for the keys and then joins the candidates by the keys.

pub fn add_single_column<K: Into<Key>>( &mut self, key: K, column: Array1<DataValue>, ) -> Result<(), Error>

Adds the single column to the current ColumnFrame If the column is already present, an error is returned Error::ColumnAlreadyExists If the length of the column is different from the current data frame, an error is returned Error::DataSetSizeDoesntMatch

pub fn add_columns(&mut self, other: Self) -> Result<(), Error>

Adds the columns from the other ColumnFrame to the current ColumnFrame If the current KeyIndex is empty, the ColumnFrame is replaced with the other ColumnFrame If the other KeyIndex is empty, nothing happens

pub fn broadcast(&mut self, other: Self) -> Result<(), Error>

Broadcasts the data from the other ColumnFrame to the current ColumnFrame If the current KeyIndex is empty, the ColumnFrame is replaced with the other ColumnFrame If the other KeyIndex is empty, nothing happens If the length (number of rows) of the other data frame is greater then 1 an error is returned Error::CannotBroadcast

pub fn cartesian_product(&mut self, other: Self) -> Result<(), Error>

Computes the Cartesian product of the input structures, resulting in all possible combinations of elements. The data is stored in the row-major order The keys are stored in the order they are added - the order is preserved - new keys from the other ColumnFrame are added to the end

pub fn join( &mut self, right: Self, join_type: &JoinRelation, ) -> Result<(), Error>

Joins the candidates with the other candidates by the JoinRelation policy. For JoinBy::AddColumns the columns are added to the existing structure via Self::add_columns For JoinBy::Replace the columns are replaced with the new columns For JoinBy::Extend the candidates are extended via Self::extend For JoinBy::Broadcast each candidate is extended with the values of the other candidates Self::broadcast For JoinBy::CartesianProduct the candidates are multiplied by the other candidates For JoinBy::JoinById the candidates are joined by the keys in the JoinRelation::JoinById struct see Self::join_by_id_inner

pub fn get_single_column(&self, key: &Key) -> Option<ArrayView1<'_, DataValue>>

Returns a read-only view of a single column, or None if the key is absent.

This is a zero-copy operation — the returned ArrayView1 borrows directly from the underlying storage.

pub fn get_single_column_typed<T: Extract>( &self, key: &Key, ) -> Option<Array1<T>>

Returns a column extracted into a typed Array1<T>, where each DataValue is converted via the Extract trait.

This is a convenience wrapper around get_single_column that maps every element through T::extract, producing an owned array of the target type. Returns None if the key does not exist in the frame.

Type coercion

The Extract trait performs best-effort numeric coercion (e.g. I32 -> f64). Values that cannot be meaningfully converted yield the type’s default (0 for numbers, false for bool, empty string for String).

pub fn sorted(&self, key: &Key) -> Result<SortedDataFrame<'_>, Error>

Returns a SortedDataFrame view sorted ascending by the given column.

Null values are pushed to the end. Ties are broken by original row order. Use SortedDataFrame::topn to efficiently extract the first/last N rows.

pub fn filter(&self, filter: &FilterRules) -> Result<Self, Error>

Returns a new ColumnFrame containing only rows that match the filter expression.

The filter is applied against each row and matching row indices are collected, de-duplicated, and used to build the result.

Trait Implementations

impl AddAssign<HashMap<String, DataValue>> for ColumnFrame

fn add_assign(&mut self, rhs: HashMap<String, DataValue>)

Performs the += operation.

impl AddAssign for ColumnFrame

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for ColumnFrame

fn clone(&self) -> ColumnFrame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ColumnFrame

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

Formats the value using the given formatter.

impl Default for ColumnFrame

fn default() -> ColumnFrame

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ColumnFrame

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ColumnFrame

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

Formats the value using the given formatter.

impl DivAssign<HashMap<String, DataValue>> for ColumnFrame

fn div_assign(&mut self, rhs: HashMap<String, DataValue>)

Performs the /= operation.

impl DivAssign for ColumnFrame

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl From<ColumnFrame> for DataFrame

fn from(dataframe: ColumnFrame) -> Self

Converts to this type from the input type.

impl From<HashMap<String, ArrayBase<OwnedRepr<DataValue>, Dim<[usize; 1]>>>> for ColumnFrame

fn from(dataframe: HashMap<String, Array1<DataValue>>) -> Self

Converts to this type from the input type.

impl From<HashMap<String, Vec<DataValue>>> for ColumnFrame

NOTE: Because of randomnes of the key order in the hashmap, the order of the keys are sorted!

fn from(dataframe: HashMap<String, Vec<DataValue>>) -> Self

Converts to this type from the input type.

impl From<SizedHashMap<SmartString<LazyCompact>, Vec<DataValue>>> for ColumnFrame

fn from(dataframe: MLChefMap) -> Self

Converts to this type from the input type.

impl From<Vec<(Key, Vec<DataValue>)>> for ColumnFrame

fn from(dataframe: Vec<(Key, Vec<DataValue>)>) -> Self

Converts to this type from the input type.

impl From<Vec<HashMap<Key, DataValue>>> for ColumnFrame

NOTE: Because of randomnes of the key order in the hashmap, the order of the keys are sorted!

fn from(dataframe: Vec<HashMap<Key, DataValue>>) -> Self

Converts to this type from the input type.

impl From<Vec<SizedHashMap<Key, DataValue>>> for ColumnFrame

NOTE: Because of randomnes of the key order in the hashmap, the order of the keys are sorted!

fn from(dataframe: Vec<HashMap<Key, DataValue>>) -> Self

Converts to this type from the input type.

impl MulAssign<HashMap<String, DataValue>> for ColumnFrame

fn mul_assign(&mut self, rhs: HashMap<String, DataValue>)

Performs the *= operation.

impl MulAssign for ColumnFrame

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl PartialEq for ColumnFrame

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SubAssign<HashMap<String, DataValue>> for ColumnFrame

fn sub_assign(&mut self, rhs: HashMap<String, DataValue>)

Performs the -= operation.

impl SubAssign for ColumnFrame

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Eq for ColumnFrame

impl StructuralPartialEq for ColumnFrame