Struct mz_expr::interpret::ResultSpec

pub struct ResultSpec<'a> {
    nullable: bool,
    fallible: bool,
    values: Values<'a>,
}

An approximation of the set of values an expression might have, including whether or not it might be null or an error value. This is generally an overapproximation, in the sense that ResultSpec::may_contain may return true even if the argument is not included in the set. (However, it should never return false when the value is included!)

Fields

nullable: bool

True if the expression may evaluate to Datum::Null.

fallible: bool

True if the expression may evaluate to an error.

values: Values<'a>

The range of possible (non-null) values that the expression may evaluate to.

Implementations

impl<'a> ResultSpec<'a>

pub fn nothing() -> Self

No results match this spec. (For example, an empty table.)

pub fn anything() -> Self

Every result matches this spec.

pub fn any_infallible() -> Self

Every result matches this spec.

pub fn null() -> Self

A spec that only matches null.

pub fn fails() -> Self

A spec that only matches error values.

pub fn has_type(col: &ColumnType, fallible: bool) -> ResultSpec<'a>

A spec that matches all values of a given type.

pub fn value(value: Datum<'a>) -> ResultSpec<'a>

A spec that only matches the given value.

pub fn value_between(min: Datum<'a>, max: Datum<'a>) -> ResultSpec<'a>

A spec that matches values between the given (non-null) min and max.

pub fn value_all() -> ResultSpec<'a>

A spec that matches any non-null value.

pub fn map_spec(map: BTreeMap<Datum<'a>, ResultSpec<'a>>) -> ResultSpec<'a>

A spec that matches Datum::Maps of the given type.

pub fn union(self, other: ResultSpec<'a>) -> ResultSpec<'a>

Given two specs, returns a new spec that matches anything that either original spec would match.

pub fn intersect(self, other: ResultSpec<'a>) -> ResultSpec<'a>

Given two specs, returns a new spec that only matches things that both original specs would match.

pub fn may_contain(&self, value: Datum<'a>) -> bool

Check if a particular value matches the spec.

pub fn may_fail(&self) -> bool

Check if an error value matches the spec.

fn flat_map( &self, is_monotone: bool, result_map: impl FnMut(Result<Datum<'a>, EvalError>) -> ResultSpec<'a>, ) -> ResultSpec<'a>

This method “maps” a function across the ResultSpec.

As mentioned above, ResultSpec represents an approximate set of results. If we actually stored each result in the set, flat_map could be implemented by passing each result to the function one-by-one and unioning the resulting sets. This is possible when our values set is empty or contains a single datum, but when it contains a range, we can’t enumerate all possible values of the set. We handle this by:

• tracking whether the function is monotone, in which case we can map the range by just mapping the endpoints;
• using a safe default when we can’t infer a tighter bound on the set, eg. Self::anything.

Trait Implementations

impl<'a> Clone for ResultSpec<'a>

fn clone(&self) -> ResultSpec<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ResultSpec<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for ResultSpec<'a>

fn eq(&self, other: &ResultSpec<'a>) -> 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<'a> Eq for ResultSpec<'a>

impl<'a> StructuralPartialEq for ResultSpec<'a>