Enum Phase 

pub enum Phase {
    Read,
    Parse,
    Reason,
    ParseDictionary,
    ParseEncode,
    ParseChunk,
    FrequentObjects,
    Dictionary,
    Encode,
    CardDerive,
    Pyramid,
    TextIndex,
    LabelsSchema,
    DictionarySection,
    IndexPermutations,
    NamedGraphs,
    Serialize,
    StarterQueries,
    Write,
    ContentHash,
}

One phase of a build. A closed set, so a reader of the record knows every name it can meet, and a writer can size a record before the build has run.

Variants

Read

Reading the input .rete back (repyramid, recard).

Parse

Reading and parsing the inputs into memory (the in-RAM text path).

Reason

--materialize / --reason: the reasoner over the default graph.

ParseDictionary

The two-pass streaming build’s first pass: read + parse + observe every term, then sort the dictionary.

ParseEncode

The two-pass streaming build’s second pass: read + parse + encode.

ParseChunk

The memory-bounded build’s single pass: read + parse + spill chunks.

FrequentObjects

The memory-bounded build’s --frequent-objects pass: one k-way walk of the chunks’ object counts that picks the terms to promote.

Dictionary

Building the dictionary from parsed statements (in-RAM), or merging the chunk dictionaries (memory-bounded).

Encode

Encoding statements to id-triples (in-RAM), or remapping the chunks’ local ids to global ones (memory-bounded).

CardDerive

Deriving the Dataset Card.

Pyramid

The community pyramid.

TextIndex

The full-text index.

LabelsSchema

The LABEL_INDEX and SCHEMA sections.

DictionarySection

Compressing and serializing the dictionary section.

IndexPermutations

Sorting and tiling the index permutations (and, in-RAM, the named graphs’ indexes).

NamedGraphs

The memory-bounded build’s named-graph indexes or quad index.

Serialize

Assembling the file image in memory.

StarterQueries

Running the card’s starter queries against the finished file.

Write

Writing the file to disk.

ContentHash

Folding the content hash over the written sections for a card placed after the data (the memory-bounded build, rete recard --in-place): the card is hashed first, so the rest of the hash can only be folded once it exists — one read of every hashed section.

Implementations

impl Phase

pub const ALL: [Phase; 20]

Every phase, in declaration order.

pub fn as_str(self) -> &'static str

The name the build record stores.

Trait Implementations

impl Clone for Phase

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Phase

impl Debug for Phase

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

Formats the value using the given formatter.

impl Eq for Phase

impl Hash for Phase

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Phase

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Phase

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Phase

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Phase