Struct DataTableState 

pub struct DataTableState {

    pub lf: LazyFrame,
    pub table_state: TableState,
    pub start_row: usize,
    pub visible_rows: usize,
    pub termcol_index: usize,
    pub visible_termcols: usize,
    pub error: Option<PolarsError>,
    pub suppress_error_display: bool,
    pub schema: Arc<Schema>,
    pub num_rows: usize,
    pub active_query: String,
    pub active_sql_query: String,
    pub active_fuzzy_query: String,
    pub drilled_down_group_key: Option<Vec<String>>,
    pub drilled_down_group_key_columns: Option<Vec<String>>,
    pub partition_columns: Option<Vec<String>>,
    pub polars_streaming: bool,
    /* private fields */
}

Fields

lf: LazyFrame

table_state: TableState

start_row: usize

visible_rows: usize

termcol_index: usize

visible_termcols: usize

error: Option<PolarsError>

suppress_error_display: bool

schema: Arc<Schema>

num_rows: usize

active_query: String

active_sql_query: String

Last executed SQL (Sql tab). Independent from active_query; only one applies to current view.

active_fuzzy_query: String

Last executed fuzzy search (Fuzzy tab). Independent from active_query/active_sql_query.

drilled_down_group_key: Option<Vec<String>>

drilled_down_group_key_columns: Option<Vec<String>>

partition_columns: Option<Vec<String>>

When set, dataset was loaded with hive partitioning; partition column names for Info panel and predicate pushdown.

polars_streaming: bool

When true, use Polars streaming engine for LazyFrame collect when the streaming feature is enabled.

Implementations

impl DataTableState

pub fn new( lf: LazyFrame, pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, polars_streaming: bool, ) -> Result<Self>

pub fn from_lazyframe(lf: LazyFrame, options: &OpenOptions) -> Result<Self>

Create state from an existing LazyFrame (e.g. from Python or in-memory). Uses OpenOptions for display/buffer settings.

pub fn from_schema_and_lazyframe( schema: Arc<Schema>, lf: LazyFrame, options: &OpenOptions, partition_columns: Option<Vec<String>>, ) -> Result<Self>

Create state from a pre-collected schema and LazyFrame (for phased loading). Does not call collect_schema(); df is None so the UI can render headers while the first collect() runs. When partition_columns is Some (e.g. hive), column order is partition cols first.

pub fn reset(&mut self)

pub fn from_parquet( path: &Path, pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

pub fn from_parquet_paths( paths: &[impl AsRef<Path>], pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

Load multiple Parquet files and concatenate them into one LazyFrame (same schema assumed).

pub fn from_ipc( path: &Path, pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

Load a single Arrow IPC / Feather v2 file (lazy).

pub fn from_ipc_paths( paths: &[impl AsRef<Path>], pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

Load multiple Arrow IPC / Feather files and concatenate into one LazyFrame.

pub fn from_avro( path: &Path, pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

Load a single Avro file (eager read, then lazy).

pub fn from_avro_paths( paths: &[impl AsRef<Path>], pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

Load multiple Avro files and concatenate into one LazyFrame.

pub fn from_excel( path: &Path, pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, excel_sheet: Option<&str>, ) -> Result<Self>

Load a single Excel file (xls, xlsx, xlsm, xlsb) using calamine (eager read, then lazy). Sheet is selected by 0-based index or name via excel_sheet.

pub fn from_orc( path: &Path, pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

Load a single ORC file (eager read via orc-rust → Arrow, then convert to Polars, then lazy). ORC is read fully into memory; see loading-data docs for large-file notes.

pub fn from_orc_paths( paths: &[impl AsRef<Path>], pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

Load multiple ORC files and concatenate into one LazyFrame.

pub fn scan_parquet_hive(path: &Path) -> Result<LazyFrame>

Build a LazyFrame for hive-partitioned Parquet only (no schema collection, no partition discovery). Use this for phased loading so “Scanning input” is instant; schema and partition handling happen in DoLoadSchema.

pub fn scan_parquet_hive_with_schema( path: &Path, schema: Arc<Schema>, ) -> Result<LazyFrame>

Build a LazyFrame for hive-partitioned Parquet with a pre-computed schema (avoids slow collect_schema across all files).

pub fn schema_from_one_hive_parquet( path: &Path, ) -> Result<(Arc<Schema>, Vec<String>)>

Infer schema from one parquet file in a hive directory and merge with partition columns (Utf8). Returns (merged_schema, partition_columns). Use with scan_parquet_hive_with_schema to avoid slow collect_schema(). Only supported when path is a directory (not a glob). Returns Err if no parquet file found or read fails.

pub fn discover_hive_partition_columns(path: &Path) -> Vec<String>

Discover hive partition column names (public for phased loading). Directory: single-spine walk; glob: parse pattern.

pub fn from_parquet_hive( path: &Path, pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

Load Parquet with Hive partitioning from a directory or glob path. When path is a directory, partition columns are discovered from path structure. When path contains glob (e.g. **/*.parquet), partition columns are inferred from the pattern (e.g. year=*/month=*). Partition columns are moved to the left in the initial LazyFrame before state is created.

Performance: The slow part is Polars, not our code. scan_parquet + collect_schema() trigger path expansion (full directory tree or glob) and parquet metadata reads; we only do a single-spine walk for partition key discovery and cheap schema/select work.

pub fn set_row_numbers(&mut self, enabled: bool)

pub fn toggle_row_numbers(&mut self)

pub fn row_start_index(&self) -> usize

Row number display start (0 or 1); used by go-to-line to interpret user input.

pub fn from_csv(path: &Path, options: &OpenOptions) -> Result<Self>

pub fn from_csv_customize<F>( path: &Path, pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, func: F, ) -> Result<Self>

where F: FnOnce(LazyCsvReader) -> LazyCsvReader,

pub fn from_csv_paths( paths: &[impl AsRef<Path>], options: &OpenOptions, ) -> Result<Self>

Load multiple CSV files (uncompressed) and concatenate into one LazyFrame.

pub fn from_ndjson( path: &Path, pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

pub fn from_ndjson_paths( paths: &[impl AsRef<Path>], pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

Load multiple NDJSON files and concatenate into one LazyFrame.

pub fn from_json( path: &Path, pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

pub fn from_json_lines( path: &Path, pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

pub fn from_json_paths( paths: &[impl AsRef<Path>], pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

Load multiple JSON (array) files and concatenate into one LazyFrame.

pub fn from_json_lines_paths( paths: &[impl AsRef<Path>], pages_lookahead: Option<usize>, pages_lookback: Option<usize>, max_buffered_rows: Option<usize>, max_buffered_mb: Option<usize>, row_numbers: bool, row_start_index: usize, ) -> Result<Self>

Load multiple JSON Lines files and concatenate into one LazyFrame.

pub fn from_delimited( path: &Path, delimiter: u8, options: &OpenOptions, ) -> Result<Self>

pub fn scroll_would_trigger_collect(&self, rows: i64) -> bool

Returns true if a scroll by rows would trigger a collect (view would leave the buffer). Used so the UI only shows the throbber when actual data loading will occur.

pub fn collect(&mut self)

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

Returns the cached row count when valid (same value shown in the control bar). Use this to avoid an extra full scan for analysis/describe when the table has already been collected.

pub fn select_next(&mut self)

pub fn page_down(&mut self)

pub fn select_previous(&mut self)

pub fn scroll_to(&mut self, index: usize)

pub fn scroll_to_row_centered(&mut self, row_index: usize)

Scroll so that the given row index is centered in the view when possible (respects table bounds). Selects that row. Used by go-to-line.

pub fn scroll_to_end(&mut self)

Jump to the last page; buffer is trimmed/loaded as needed. Selects the last row.

pub fn half_page_down(&mut self)

pub fn half_page_up(&mut self)

pub fn page_up(&mut self)

pub fn scroll_right(&mut self)

pub fn scroll_left(&mut self)

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

pub fn set_column_order(&mut self, order: Vec<String>)

pub fn set_locked_columns(&mut self, count: usize)

pub fn locked_columns_count(&self) -> usize

pub fn get_filters(&self) -> &[FilterStatement]

pub fn get_sort_columns(&self) -> &[String]

pub fn get_sort_ascending(&self) -> bool

pub fn get_column_order(&self) -> &[String]

pub fn get_active_query(&self) -> &str

pub fn get_active_sql_query(&self) -> &str

pub fn get_active_fuzzy_query(&self) -> &str

pub fn last_pivot_spec(&self) -> Option<&PivotSpec>

pub fn last_melt_spec(&self) -> Option<&MeltSpec>

pub fn is_grouped(&self) -> bool

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

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

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

Estimated heap size in bytes of the currently buffered slice (locked + scrollable), if collected.

pub fn buffered_rows(&self) -> usize

Number of rows currently in the buffer. 0 if no buffer loaded.

pub fn display_df(&self) -> Option<&DataFrame>

Current scrollable display buffer. None until first collect().

pub fn display_slice_df(&self) -> Option<DataFrame>

Visible-window slice of the display buffer (same as passed to render_dataframe).

pub fn max_buffered_rows(&self) -> usize

Maximum buffer size in rows (0 = no limit).

pub fn max_buffered_mb(&self) -> usize

Maximum buffer size in MiB (0 = no limit).

pub fn drill_down_into_group(&mut self, group_index: usize) -> Result<()>

pub fn drill_up(&mut self) -> Result<()>

pub fn get_analysis_dataframe(&self) -> Result<DataFrame>

pub fn get_analysis_context(&self) -> AnalysisContext

pub fn pivot(&mut self, spec: &PivotSpec) -> Result<()>

Pivot the current LazyFrame (long → wide). Never uses original_lf. Collects current lf, runs pivot_stable, then replaces lf with result. We use pivot_stable for all aggregation types: Polars’ non-stable pivot() prints “unstable pivot not yet supported, using stable pivot” to stdout, which corrupts the TUI.

pub fn melt(&mut self, spec: &MeltSpec) -> Result<()>

Melt the current LazyFrame (wide → long). Never uses original_lf.

pub fn is_drilled_down(&self) -> bool

pub fn sort(&mut self, columns: Vec<String>, ascending: bool)

pub fn reverse(&mut self)

pub fn filter(&mut self, filters: Vec<FilterStatement>)

pub fn query(&mut self, query: String)

pub fn sql_query(&mut self, sql: String)

Execute a SQL query against the current LazyFrame (registered as table “df”). Empty SQL resets to original state. Does not call collect(); the event loop does that via AppEvent::Collect.

pub fn fuzzy_search(&mut self, query: String)

Fuzzy search: filter rows where any string column matches the query. Query is split on whitespace; each token must match (in order, case-insensitive) in some string column. Empty query resets to original_lf.