Struct OpenOptions 

pub struct OpenOptions {

    pub delimiter: Option<u8>,
    pub has_header: Option<bool>,
    pub skip_lines: Option<usize>,
    pub skip_rows: Option<usize>,
    pub skip_tail_rows: Option<usize>,
    pub compression: Option<CompressionFormat>,
    pub format: Option<FileFormat>,
    pub pages_lookahead: Option<usize>,
    pub pages_lookback: Option<usize>,
    pub max_buffered_rows: Option<usize>,
    pub max_buffered_mb: Option<usize>,
    pub row_numbers: bool,
    pub row_numbers_auto: bool,
    pub row_start_index: usize,
    pub hive: bool,
    pub left_out: Vec<(FileFormat, usize)>,
    pub read_as_plain_files_of: Option<&'static str>,
    pub files_disagree: Disagreement,
    pub single_spine_schema: bool,
    pub view: Option<String>,
    pub parse_dates: bool,
    pub parse_strings: Option<ParseStringsTarget>,
    pub parse_strings_sample_rows: usize,
    pub decompress_in_memory: bool,
    pub temp_dir: Option<PathBuf>,
    pub table: Option<String>,
    pub polars_streaming: bool,
    pub null_values: Option<Vec<String>>,
    pub infer_schema_length: Option<usize>,
    pub ignore_errors: bool,
    pub comment_char: Option<String>,
    pub header_rows: Vec<usize>,
    pub header_join: String,
    pub skip_initial_space: bool,
    pub typed_dialect: TypedDialect,
    pub debug: bool,
    pub splits: Option<Arc<Splits>>,
    pub arrow_parts: Option<Arc<Vec<Part>>>,
    pub spec_file: Option<PathBuf>,
    pub spec_fetched: Option<Arc<Spec>>,
    pub dicts: Vec<PathBuf>,
    pub spec_name: Option<String>,
    pub format_read: Option<Arc<Read>>,
    pub read_python: Vec<String>,
    pub normalize: bool,
    pub sqlite: Option<Arc<SqliteOpen>>,
    pub opened: Option<Arc<Opened>>,
    pub delimited: Option<Arc<DelimitedRead>>,
    pub read_mode: Option<ReadMode>,
    pub format_guessed: bool,
    pub read_notes: Vec<Note>,
    pub typing: Typing,
    pub hex: bool,
    pub record_size: Option<usize>,
    pub follow: bool,
    pub tail: Option<Arc<Tail>>,
    pub spool: Option<Arc<SpoolHandle>>,
    pub pipe: bool,
    pub tee: Option<PathBuf>,
    pub tee_raw: bool,
    pub force: bool,
    pub prepared: Option<Handoff>,
    pub download_unasked: Option<UnaskedDownload>,
}

Fields

delimiter: Option<u8>

has_header: Option<bool>

skip_lines: Option<usize>

skip_rows: Option<usize>

skip_tail_rows: Option<usize>

Skip this many rows at the end of the file (e.g. vendor footer or trailing garbage). Applied after load for CSV.

compression: Option<CompressionFormat>

format: Option<FileFormat>

When set, bypass extension-based format detection and use this format (e.g. for URLs or temp files without extension).

pages_lookahead: Option<usize>

pages_lookback: Option<usize>

max_buffered_rows: Option<usize>

max_buffered_mb: Option<usize>

row_numbers: bool

row_numbers_auto: bool

Neither the flag nor the config said: # is on for text and logs (crate::config::RowNumbers::Auto), decided once the format is known.

row_start_index: usize

hive: bool

When true, use hive load path for directory/glob; single file uses normal load.

left_out: Vec<(FileFormat, usize)>

Data files in the opened directory this read passes over, by format and count: a mixed directory reads as its commonest format, and the dataset says what it left out. Empty for every other open.

read_as_plain_files_of: Option<&'static str>

Set ("Delta", "Iceberg" or "Hudi") when a lake table’s plain files are read. They are not the table (deleted rows, old versions and compaction leftovers count), so a note and a footer chip always say so.

files_disagree: Disagreement

How the directory’s files differed, for footerless formats only (Parquet footers give the exact per-column version).

single_spine_schema: bool

When true (default), infer Hive/partitioned Parquet schema from one file for faster “Reading schema”. When false, use Polars collect_schema().

view: Option<String>

--view NAME: the view to apply to the dataset named on the command line, once it is on screen. Applied to that open only; what later opens get is [views] auto_apply’s business.

parse_dates: bool

When true, CSV and JSON string columns that look like dates or ISO 8601 timestamps become Date or Datetime.

parse_strings: Option<ParseStringsTarget>

When set, trim and parse CSV string columns: None = off, Some(true) = all columns, Some(cols) = those columns only.

parse_strings_sample_rows: usize

Sample size (rows) for inferring types when parse_strings is enabled; single file or multiple/partitioned.

decompress_in_memory: bool

When true, decompress a compressed CSV, TSV or PSV into memory (eager read). When false (default), decompress to a temp file and use lazy scan.

temp_dir: Option<PathBuf>

Directory for decompression temp files. None = system default (e.g. TMPDIR).

table: Option<String>

--table: which table of a file that holds several: an NMEA log’s sentence types, an Excel sheet (0-based index or name), a spec’s variant. None is the file’s main table.

polars_streaming: bool

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

null_values: Option<Vec<String>>

Null value specs for CSV: global strings and/or “COL=VAL” for per-column. Empty = use Polars default.

infer_schema_length: Option<usize>

Number of rows to use when inferring CSV schema. None = Polars default (100). Larger values reduce risk of inferring wrong type (e.g. int then N/A).

ignore_errors: bool

When true, CSV reader ignores parse errors and continues with the next batch.

comment_char: Option<String>

CSV lines starting with this are comments, wherever they are (commentChar).

header_rows: Vec<usize>

The 1-based lines, counted from the top of the file, that hold a CSV’s header (headerRows). Empty = Polars’ own header. A layout flag, like skip_lines.

header_join: String

What joins a column’s pieces when header_rows names several lines.

skip_initial_space: bool

Ignore the spaces after a CSV delimiter (skipInitialSpace).

typed_dialect: TypedDialect

Which dialect options were typed on the command line, so a spec leaves them.

debug: bool

The debug overlay (session info, performance, query): DATUI_DEBUG=1.

splits: Option<Arc<Splits>>

The split of a Hugging Face cache directory this read chose, the others and the map() files it left out. Found by the read, or by a bucket listing, and carried to the dataset as left_out is. None for every other open.

arrow_parts: Option<Arc<Vec<Part>>>

Where each Arrow input’s rows are once its streams are converted: the IPC files read in place and the streams’ rows in the converted file the scan names. Set by the load, after a conversion or a bucket’s listing, never by a request.

spec_file: Option<PathBuf>

--format FILE: read the path through this format spec, whatever else matches it. A URL is fetched when the open starts, into spec_fetched.

spec_fetched: Option<Arc<Spec>>

The spec a remote spec_file names, fetched by the open (Phase::ReadingSpec).

dicts: Vec<PathBuf>

--dict FILE: FIX dictionaries and DBC files over the search path’s, each taken by the reader of its kind.

spec_name: Option<String>

The format spec named by --format NAME, or picked with b.

format_read: Option<Arc<Read>>

What a read through a format spec found, carried from the scan to the dataset.

read_python: Vec<String>

What the open did to the rows its reader gave — CSV column names trimmed, text columns typed — as Python method calls for Copy as Python. Found by the scan, carried to the dataset as left_out is. Empty for every other open.

normalize: bool

[read] audio_float: integer audio samples as float in [-1, 1].

sqlite: Option<Arc<SqliteOpen>>

A SQLite table opened in place, carried from the scan to the dataset.

opened: Option<Arc<Opened>>

What the reader found besides the frame: a window read straight from the file, its row count, its Info panel tab, other tables and notes. Found by the scan and carried to the dataset as left_out is. None for a reader with nothing to add.

delimited: Option<Arc<DelimitedRead>>

The delimited spec the file is read through, once chosen: its dialect is in these options, and the read’s units and metadata ride with it to the dataset.

read_mode: Option<ReadMode>

How the scan found the data is read: lazily, through a copy, or into memory. Found by the scan and carried to the dataset for the Info panel’s Read: line.

format_guessed: bool

The format was guessed from the first bytes of text no format’s signature claims, rather than named, so a note can say how to read it otherwise.

read_notes: Vec<Note>

What the read of several files found to say of them, for the dataset’s notes. Found by the scan and carried to the dataset as left_out is.

typing: Typing

The columns the read gave a type and the frame before, carried to the dataset as left_out is, for the count of the values that did not fit.

hex: bool

--hex: show the file’s bytes in the hex view, whatever it holds.

record_size: Option<usize>

--hex-width N: the bytes a row of the hex view holds.

follow: bool

--follow: show rows as they are appended to the file, or arrive on standard input, until stopped.

tail: Option<Arc<Tail>>

Where the followed file’s complete records end, counted by the scan and carried to the dataset as left_out is, for its watcher to read on from.

spool: Option<Arc<SpoolHandle>>

Standard input still being copied to the file a follow reads.

pipe: bool

Standard input shown as it arrives without --follow: read by the follow’s watcher until it ends, the view staying where it is rather than at the end.

tee: Option<PathBuf>

--tee FILE: standard input is recorded to FILE, which is what is read.

tee_raw: bool

--tee-raw: FILE is the bytes exactly as they came, a WAV header included.

force: bool

--force: FILE may replace a file that is there.

prepared: Option<Handoff>

The dataset the home screen’s preview built and read the first page of, for this open to install rather than read again. Taken once.

download_unasked: Option<UnaskedDownload>

A file of the built-in catalog: downloaded without asking when it is small.

Implementations

impl OpenOptions

pub fn new() -> Self

impl OpenOptions

pub fn separator_or(&self, format_default: u8) -> u8

The separator a delimited file is read with: --delimiter when given, else the one its format implies (FileFormat::separator).

pub fn header_rows(&self) -> Option<&[usize]>

The lines --header-rows named, unless the file is being read without a header (--no-header, or H), which reads them as data.

pub fn csv_try_parse_dates(&self) -> bool

When loading CSV: use Polars try_parse_dates only if parse_strings is not set. When parse_strings is set we do our own date parsing (with strict: false), so we disable Polars’ try_parse_dates to avoid “could not find an appropriate format” errors.

pub fn effective_cloud(&self, cloud: &CloudConfig) -> CloudConfig

The S3 settings every cloud path uses: environment over [cloud] config. run() folds this into the App’s config so opening, sizing, downloading, discovery and listing agree. The environment is read here, so OpenOptions::default() callers (Python) honor it too.

impl OpenOptions

pub fn from_args_and_config(args: &Args, config: &AppConfig) -> Self

The options the command line and the config give an open. The config has had -c laid over it; a flag here beats both.

Trait Implementations

impl Clone for OpenOptions

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for OpenOptions

fn default() -> Self

Returns the “default value” for a type.

impl From<&Args> for OpenOptions

fn from(args: &Args) -> Self

Converts to this type from the input type.