Enum Cause 

#[non_exhaustive]
pub enum Cause {
    Flatten,
    Compare,
    Scalar,
    Logic,
    Cast,
    Aggregate,
    Select,
}

What made a call take the slow path.

Not exhaustive, because the whole reason this exists is that the list of forms is going to grow. F1 adds bit packed, run length and FSST columns, and each of them arrives with its own set of kernels that do not handle it yet.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Flatten

A compact column was copied out into a plain one.

Compare

A comparison read a value at a time.

Scalar

A scalar function read a value at a time.

Logic

Three valued logic read a value at a time.

Cast

A conversion read a value at a time.

Aggregate

An aggregate read a value at a time.

Select

Turning a vector of flags into the rows it keeps read a value at a time.

Implementations

impl Cause

pub const ALL: [Self; 7]

Every cause, in the order a tally prints them.

pub const fn name(self) -> &'static str

The name in the document and in the report.

pub const fn slot(self) -> usize

Where this cause sits in an array with one slot per cause.

Public because a tally is not the only thing that wants one slot per cause. The operator counters keep an atomic per cause and index it with this, which beats a map on a path that is taken once per chunk.

Trait Implementations

impl Clone for Cause

fn clone(&self) -> Cause

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Cause

impl Debug for Cause

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

Formats the value using the given formatter.

impl Eq for Cause

impl Hash for Cause

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 PartialEq for Cause

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Cause