What a click on the table lands on: the row on screen, counted from the top (none
on the header), and the column (none on the rail or the row numbers).
What the worker that reads a fill needs to make it the buffer: the rows on hand it
runs on from or up to, the view, and the caps, as they were when it was planned.
What reading every footer turned up, and everything built from it that the dataset
has to be given together — the schema and the scans that read at that schema.
What an open learned about a dataset besides its frame and schema: given to the
state once, by DataTableState::with_open, so the count, the row groups, the
files and the notes all describe the same open. Each field’s default means the open
did not find it.
A view’s sample: the step between the source and the query. The view’s frames
scan Self::frame, the chunks kept so far, which grows as the draw goes on.
The view as it stood before a query or view replaced it: a checkpoint. A query plans
without reading anything and can still fail once it runs — a value that will not
cast — and then the table goes back to this, rows and all, rather than keep a
frame that fails on every scroll. Frames and buffers are shared, not copied.
The most columns a pivot may make. Past it the table, the schema and every view
of them slow to a crawl; a pivot on a column with this many values is almost
always a mistake (an id or a timestamp picked for Columns).
Builds a scan of some of a dataset’s files, as the full scan reads them, with the
columns named in the second argument read as text from every file rather than as
the type most rows have.
Reads every footer of a dataset that opened from a couple of them, and returns what
they say. None when they could not be read, in which case the dataset stays as it
opened. Blocks, and counts itself off against the progress it is given.