Struct DataFrame

pub struct DataFrame {
    pub sample: Sample,
}

This data store works as follows:

Each data item (e.g. DataFrame) is simply appended to a data file.

An IndexEntry is appended to a corresponding index file. Each IndexEntry contains the timestamp (e.g. key) of the data item, its offset into the data file, the length of the data entry, and a CRC of the data entry as well as a CRC of itself. It also contains flags that can indicate if the corresponding data is compressed and how it is compressed.

The CRCs in the index entry give us an atomicity guarantee - if they are not present and correct, we treat it as if the entry never existed.

In dictionary compression mode, the index file may be padded with zeros (i.e. empty index entries). Thus empty index entries are not considered to be corrupt, but we ignore such entries as they do not point to any data.

Data and Index files are append-only and never modified (only ever removed).

Data and Index files are sharded by SHARD_TIME - e.g. any one file only contains data or index entries whose timestamps are congruent modulo SHARD_TIME. This allows data and index files to be cleaned up by just unlinking the files.

Fields

sample: Sample

Trait Implementations

impl Clone for DataFrame

fn clone(&self) -> DataFrame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DataFrame

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

Formats the value using the given formatter.

impl Default for DataFrame

fn default() -> DataFrame

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DataFrame

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DataFrame

fn eq(&self, other: &DataFrame) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for DataFrame

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DataFrame