Struct Parquet 

pub struct Parquet { /* private fields */ }

A parquet file kept in a store, answering spans of rows.

let sms = Parquet::at(store, "data/sms")?;
memory.identify("sms", "Parquet");
memory.freeze("sms", Some(sms.version().to_string()));   // and it cost no bytes

Declaring it resolves the name and stops there: a graph that names a dataset has not opened it. And it keeps the digest, not the name, so a dataset rebound mid-run does not change what that run is reading — resolving once is what makes the version true.

Implementations

impl Parquet

pub fn at( store: Arc<dyn Store>, name: impl Into<String>, ) -> Result<Self, ParquetError>

The parquet file bound under this name, or why there is none.

One resolve and no bytes: what this costs is what makes stating a version affordable at all.

pub fn version(&self) -> &str

What this dataset is, for the key of everything computed from it: the digest of the content, which the store had already worked out. This is what lets a source be settled without reading itself.

pub fn name(&self) -> &str

The name it was declared under, which is the graph’s word and not the data’s.

pub fn read(&self, span: Span) -> Result<Frame, ParquetError>

The rows that span names. Short is not an error: the last span is whatever is left, and one past the end is a frame with no rows.

Trait Implementations

impl Debug for Parquet

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

Without the bytes, and without the store: what identifies it is the name it was declared under and the content it settled on.

impl Node for Parquet

fn forward(&self, input: &Value, _ctx: &Ctx<'_>) -> Result<Value, NodeError>

A span in, a Frame out.