Struct DataView 

pub struct DataView { /* private fields */ }

A view over a DataTable that can filter, sort, and project columns without modifying the underlying data

Implementations

impl DataView

pub fn new(source: Arc<DataTable>) -> Self

Create a new view showing all data from the table

pub fn with_columns(self, columns: Vec<usize>) -> Self

Create a view with specific columns

pub fn hide_column(&mut self, display_index: usize) -> bool

Hide a column by display index (cannot hide pinned columns)

pub fn hide_column_by_name(&mut self, column_name: &str) -> bool

Hide a column by name (cannot hide pinned columns)

pub fn detect_empty_columns(&self) -> Vec<usize>

Detect columns that are entirely empty (NULL or empty string) in visible rows

pub fn hide_empty_columns(&mut self) -> usize

Hide all columns that are entirely empty Returns the number of columns hidden

pub fn unhide_all_columns(&mut self)

Unhide all columns (restore to the base column projection) This restores to the original column selection, not necessarily all source columns

pub fn hide_all_columns(&mut self)

Hide all columns (clear all visible columns)

pub fn has_visible_columns(&self) -> bool

Check if any columns are visible

pub fn move_column_left(&mut self, display_column_index: usize) -> bool

Move a column left in the view (respects pinned columns) With wraparound: moving left from first unpinned position moves to last

pub fn move_column_right(&mut self, display_column_index: usize) -> bool

Move a column right in the view (respects pinned columns) With wraparound: moving right from last position moves to first

pub fn move_column_left_by_name(&mut self, column_name: &str) -> bool

Move a column by name to the left

pub fn move_column_right_by_name(&mut self, column_name: &str) -> bool

Move a column by name to the right

pub fn get_hidden_column_names(&self) -> Vec<String>

Get the names of hidden columns (columns in source but not visible)

pub fn has_hidden_columns(&self) -> bool

Check if there are any hidden columns

pub fn pin_column(&mut self, display_index: usize) -> Result<()>

Pin a column by display index (move it to the pinned area on the left)

pub fn pin_column_by_name(&mut self, column_name: &str) -> Result<()>

Pin a column by name

pub fn unpin_column(&mut self, display_index: usize) -> bool

Unpin a column by display index (move it back to regular visible columns)

pub fn unpin_column_by_name(&mut self, column_name: &str) -> bool

Unpin a column by name

pub fn clear_pinned_columns(&mut self)

Clear all pinned columns

pub fn is_column_pinned(&self, display_index: usize) -> bool

Check if a column at display index is pinned

pub fn get_pinned_columns(&self) -> &[usize]

Get pinned column indices

pub fn get_pinned_column_names(&self) -> Vec<String>

Get the names of pinned columns

pub fn get_display_columns(&self) -> Vec<usize>

Get display order of columns (pinned first, then visible)

pub fn get_display_column_names(&self) -> Vec<String>

Get display column names in order (pinned first, then visible)

pub fn set_max_pinned_columns(&mut self, max: usize)

Set maximum number of pinned columns

pub fn with_rows(self, rows: Vec<usize>) -> Self

Create a view with specific rows

pub fn with_limit(self, limit: usize, offset: usize) -> Self

Apply limit and offset

pub fn filter<F>(self, predicate: F) -> Self

where F: Fn(&DataTable, usize) -> bool,

Filter rows based on a predicate

pub fn apply_text_filter(&mut self, pattern: &str, case_sensitive: bool)

Apply a text filter to the view (filters visible rows)

pub fn clear_filter(&mut self)

Clear all filters (both text and fuzzy) and restore all base rows

pub fn has_filter(&self) -> bool

Check if any filter is active (text or fuzzy)

pub fn get_filter_pattern(&self) -> Option<&str>

Get the current text filter pattern

pub fn get_fuzzy_filter_pattern(&self) -> Option<&str>

Get the current fuzzy filter pattern

pub fn apply_fuzzy_filter(&mut self, pattern: &str, case_insensitive: bool)

Apply a fuzzy filter to the view Supports both fuzzy matching and exact matching (when pattern starts with ’)

pub fn get_fuzzy_filter_indices(&self) -> Vec<usize>

Get indices of rows that match the fuzzy filter (for compatibility)

pub fn get_visible_rows(&self) -> Vec<usize>

Get the visible row indices

pub fn sort_by(self, column_index: usize, ascending: bool) -> Result<Self>

Sort rows by a column (consuming version - returns new Self) The column_index parameter is the index in the VISIBLE columns

pub fn apply_sort(&mut self, column_index: usize, ascending: bool) -> Result<()>

Sort rows by a column (mutable version - modifies in place) The column_index parameter is the index in the VISIBLE columns

pub fn apply_multi_sort(&mut self, sort_columns: &[(usize, bool)]) -> Result<()>

Apply multi-column sorting Each tuple contains (source_column_index, ascending)

pub fn toggle_sort(&mut self, column_index: usize) -> Result<()>

Toggle sort on a column - cycles through Ascending -> Descending -> None The column_index parameter is the index in the VISIBLE columns

pub fn get_sort_state(&self) -> &SortState

Get the current sort state

pub fn get_visible_column_indices(&self) -> Vec<usize>

Get the visible column indices (for debugging) Returns the internal visible_columns array which maps visual positions to source column indices

pub fn clear_sort(&mut self)

Clear the current sort and restore original row order

pub fn add_virtual_column(&mut self, virtual_column: VirtualColumn)

Add a virtual column to the view

pub fn add_row_numbers(&mut self, position: VirtualColumnPosition)

Add a row number virtual column

pub fn remove_virtual_columns(&mut self, name: &str)

Remove all virtual columns of a specific type by name

pub fn toggle_row_numbers(&mut self)

Toggle row numbers on/off

pub fn has_row_numbers(&self) -> bool

Check if row numbers are currently shown

pub fn get_all_column_names(&self) -> Vec<String>

Get all column names including virtual columns in display order

pub fn row_count(&self) -> usize

Get the number of visible rows

pub fn column_count(&self) -> usize

Get the number of visible columns (including pinned and virtual)

pub fn column_names(&self) -> Vec<String>

Get column names for visible columns (including virtual columns in correct positions)

pub fn get_row(&self, index: usize) -> Option<DataRow>

Get a row by index (respecting limit/offset) including virtual columns

pub fn get_rows(&self) -> Vec<DataRow>

Get all visible rows (respecting limit/offset)

pub fn source(&self) -> &DataTable

Get the source DataTable

pub fn source_arc(&self) -> Arc<DataTable>

Get the source DataTable as Arc (for memory-efficient sharing)

pub fn is_column_visible(&self, index: usize) -> bool

Check if a column index is visible (either pinned or regular visible)

pub fn visible_column_indices(&self) -> &[usize]

Get visible column indices (not including pinned)

pub fn display_column_indices(&self) -> Vec<usize>

Get all display column indices (pinned + visible)

pub fn visible_row_indices(&self) -> &[usize]

Get visible row indices (before limit/offset)

pub fn shrink_to_fit(&mut self)

Optimize memory usage by shrinking vectors to fit

pub fn search_columns(&mut self, pattern: &str)

Start or update column search with a pattern

pub fn clear_column_search(&mut self)

Clear column search

pub fn next_column_match(&mut self) -> Option<usize>

Go to next column search match

pub fn prev_column_match(&mut self) -> Option<usize>

Go to previous column search match

pub fn column_search_pattern(&self) -> Option<&str>

Get current column search pattern

pub fn get_matching_columns(&self) -> &[(usize, String)]

Get matching columns from search

pub fn current_column_match_index(&self) -> usize

Get current column match index

pub fn get_current_column_match(&self) -> Option<usize>

Get current column match (visible column index)

pub fn has_column_search(&self) -> bool

Check if column search is active

pub fn to_json(&self) -> Value

Export the visible data as JSON Returns an array of objects where each object represents a row

pub fn to_csv(&self) -> Result<String>

Export the visible data as CSV string

pub fn to_tsv(&self) -> Result<String>

Export the visible data as TSV (Tab-Separated Values) string

pub fn get_column_values(&self, column_index: usize) -> Vec<String>

Get all values from a specific column (respecting filters and visible rows)

pub fn get_cell_value( &self, row_index: usize, column_index: usize, ) -> Option<String>

Get a single cell value (respecting filters)

pub fn get_row_values(&self, row_index: usize) -> Option<Vec<String>>

Get a row as string values (respecting filters)

pub fn get_row_visual_values(&self, row_index: usize) -> Option<Vec<String>>

Get row values in visual column order (only visible columns) This returns data in the same order as get_display_column_names()

pub fn get_column_index_mapping(&self) -> Vec<(usize, String, usize)>

Get column index mapping for debugging Returns a mapping of visible column index -> (column name, datatable index)

pub fn get_column_debug_info(&self) -> String

Get debug information about column visibility and ordering

Trait Implementations

impl Clone for DataView

fn clone(&self) -> DataView

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl DataProvider for DataView

fn get_row(&self, index: usize) -> Option<Vec<String>>

Get a single row by index Returns None if the index is out of bounds

fn get_column_names(&self) -> Vec<String>

Get the column names/headers

fn get_row_count(&self) -> usize

Get the total number of rows

fn get_column_count(&self) -> usize

Get the total number of columns

fn get_column_widths(&self) -> Vec<usize>

Get the display width for each column Used for rendering column widths in the TUI

fn get_visible_rows(&self, start: usize, count: usize) -> Vec<Vec<String>>

Get multiple rows for efficient rendering This is an optimization to avoid multiple get_row calls

fn get_cell_value(&self, row: usize, col: usize) -> Option<String>

Get a single cell value Returns None if row or column index is out of bounds

fn get_display_value(&self, row: usize, col: usize) -> String

Get a display-formatted cell value Returns empty string if indices are out of bounds

fn get_column_type(&self, _column_index: usize) -> DataType

Get the data type of a specific column This should be cached/determined at load time, not computed on each call

fn get_column_types(&self) -> Vec<DataType>

Get data types for all columns Returns a vector where index corresponds to column index

impl Debug for DataView

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

Formats the value using the given formatter.