Struct OpenFacts 

pub struct OpenFacts {

    pub remote_source: bool,
    pub row_groups: Vec<Vec<usize>>,
    pub remote_files: Option<RemoteFiles>,
    pub remote_objects: Vec<RemoteObject>,
    pub dataset: Option<DatasetAtOpen>,
    pub footers_pending: Option<FootersJoin>,
    pub column_bytes: Vec<(String, usize)>,
    pub parquet_count_dir: Option<PathBuf>,
    pub measurements: Arc<Meter>,
    pub open_notes: Vec<Note>,
    pub not_the_table: Option<&'static str>,
    pub format_read: Option<Arc<Read>>,
    pub delimited: Option<Arc<DelimitedRead>>,
    pub download: Option<TempDownload>,
    pub converted: Vec<TempDownload>,
    pub other_tables: Vec<String>,
    pub pushdown: Option<Arc<dyn Pushdown>>,
    pub hold: Option<Hold>,
    pub read_mode: Option<ReadMode>,
    pub read_as: Option<FileFormat>,
    pub fetched: bool,
    pub detail: Option<Arc<Detail>>,
    pub records: Option<(Arc<dyn Windowed>, usize)>,
    pub units: Vec<(String, String)>,
    pub indexing: Option<Arc<Lines>>,
    pub numbering: Option<Arc<Lines>>,
    pub typing: Typing,
}

What an open learned besides frame and schema, given once via DataTableState::with_open so count, row groups, files and notes agree. Defaults mean not found.

Fields

remote_source: bool

A scan of an object store in place: a buffer is one window of whole row groups.

row_groups: Vec<Vec<usize>>

Each file’s row groups in scan order (one entry for a single object): the count. With remote_files, one per listed file.

remote_files: Option<RemoteFiles>

The files of a remote dataset of many, and how to read some of them.

remote_objects: Vec<RemoteObject>

Each remote object the dataset reads, as the listing or footer found it.

dataset: Option<DatasetAtOpen>

What the footers said about a many-file dataset’s columns.

footers_pending: Option<FootersJoin>

The pass that reads the rest of the footers, for a dataset opened from a few.

column_bytes: Vec<(String, usize)>

Each column’s uncompressed bytes per row, from the footers.

parquet_count_dir: Option<PathBuf>

The local Parquet hive directory whose footers sum to the count.

measurements: Arc<Meter>

What finding and reading the dataset cost.

open_notes: Vec<Note>

What the open itself has to say. See DataTableState::open_notes.

not_the_table: Option<&'static str>

The lake format whose plain files this dataset is. See DataTableState::not_the_table.

format_read: Option<Arc<Read>>

What a read through a format spec found.

delimited: Option<Arc<DelimitedRead>>

What a read through a delimited spec found.

download: Option<TempDownload>

The downloaded file the frame scans, held for as long as the state lives.

converted: Vec<TempDownload>

The files a GPS log was read into, which the frame scans.

other_tables: Vec<String>

The file’s other tables as --table names them, with row counts where known, for Info’s Schema tab. Empty for a file of one.

pushdown: Option<Arc<dyn Pushdown>>

A source that runs the sidebar’s filters and sort itself: a SQLite table.

hold: Option<Hold>

What stops that source’s statements when the dataset goes.

read_mode: Option<ReadMode>

How the open reads the data. See crate::OpenOptions::read_mode.

read_as: Option<FileFormat>

The format the open read as, after sniffing and spec matching (which the name may not say); Copy as Python and the export default follow it.

fetched: bool

Downloaded from a remote source before reading (not a local stream conversion or stdin spool, though held the same way).

detail: Option<Arc<Detail>>

What the file said besides its rows, for the Info panel.

records: Option<(Arc<dyn Windowed>, usize)>

Rows decoded straight from the file by a reader (NumPy array, audio frames), and how many: deep pages and the count need no row index.

units: Vec<(String, String)>

Each column’s unit, where the file says one.

indexing: Option<Arc<Lines>>

Lines still being indexed behind the first rows: the frames grow as they are.

numbering: Option<Arc<Lines>>

The lines of several files, which # numbers by their line in their own file.

typing: Typing

The columns the read gave a type, for the count of what did not fit.

Trait Implementations

impl Default for OpenFacts

fn default() -> Self

Returns the “default value” for a type.