Struct Range

pub struct Range<D> {
    pub inner: Option<RangeInner<D>>,
}

A range of values along the domain D.

D is generic to facilitate interoperating over multiple representation, e.g. Datum and mz_pgrepr::Value. Because of the latter, we have to “manually derive” traits over Range.

Also notable, is that Datums themselves store ranges as Range<DatumNested<'a>>, which lets us avoid unnecessary boxing of the range’s finite bounds, which are most often expressed as Datum.

Fields

inner: Option<RangeInner<D>>

None value represents empty range

Implementations

impl<D> Range<D>

pub fn new(inner: Option<(RangeLowerBound<D>, RangeUpperBound<D>)>) -> Range<D>

Create a new range.

Note that when constructing Range<Datum<'a>>, the range must still be canonicalized. If this becomes a common operation, we should consider addinga new_canonical function that performs both steps.

pub fn internal_flag_bits(&self) -> u8

Get the flag bits appropriate to use in our internal (i.e. row) encoding of range values.

Note that this differs from the flags appropriate to encode with Postgres, which has UB_INFINITE and LB_INCLUSIVE in the alternate position.

pub fn pg_flag_bits(&self) -> u8

Get the flag bits appropriate to use in PG-compatible encodings of range values.

Note that this differs from the flags appropriate for our internal encoding, which has UB_INFINITE and LB_INCLUSIVE in the alternate position.

pub fn into_bounds<F, O>(self, conv: F) -> Range<O>

where F: Fn(D) -> O,

Converts self from having bounds of type D to type O, converting the current bounds using conv.

impl<'a, B: Copy + Ord + PartialOrd + Display + Debug> Range<B>

where Datum<'a>: From<B>,

Range implementations meant to work with Range<Datum> and Range<DatumNested>.

pub fn contains_elem<T: RangeOps<'a>>(&self, elem: &T) -> bool

where <T as TryFrom<Datum<'a>>>::Error: Debug,

pub fn contains_range(&self, other: &Range<B>) -> bool

pub fn overlaps(&self, other: &Range<B>) -> bool

pub fn before(&self, other: &Range<B>) -> bool

pub fn after(&self, other: &Range<B>) -> bool

pub fn overleft(&self, other: &Range<B>) -> bool

pub fn overright(&self, other: &Range<B>) -> bool

pub fn adjacent(&self, other: &Range<B>) -> bool

pub fn union(&self, other: &Range<B>) -> Result<Range<B>, InvalidRangeError>

pub fn intersection(&self, other: &Range<B>) -> Range<B>

pub fn difference( &self, other: &Range<B>, ) -> Result<Range<Datum<'a>>, InvalidRangeError>

impl<'a> Range<Datum<'a>>

pub fn canonicalize(&mut self) -> Result<(), InvalidRangeError>

Canonicalize the range by PG’s heuristics, which are:

• Infinite bounds are always exclusive
• If type has step:
• Exclusive lower bounds are rewritten as inclusive += step
• Inclusive lower bounds are rewritten as exclusive += step
• Ranges are empty if lower >= upper after prev. step unless range type does not have step and both bounds are inclusive

Panics

• If the upper and lower bounds are finite and of different types.

Trait Implementations

impl<D: Clone> Clone for Range<D>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, E> DatumType<'a, E> for Range<Datum<'a>>

fn nullable() -> bool

Whether this Rust type can represent NULL values

fn fallible() -> bool

Whether this Rust type can represent errors

fn try_from_result( res: Result<Datum<'a>, E>, ) -> Result<Self, Result<Datum<'a>, E>>

Try to convert a Result whose Ok variant is a Datum into this native Rust type (Self). If it fails the error variant will contain the original result.

fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E>

Convert this Rust type into a Result containing a Datum, or an error

impl<'a, E> DatumType<'a, E> for Range<DatumNested<'a>>

fn nullable() -> bool

Whether this Rust type can represent NULL values

fn fallible() -> bool

Whether this Rust type can represent errors

fn try_from_result( res: Result<Datum<'a>, E>, ) -> Result<Self, Result<Datum<'a>, E>>

Try to convert a Result whose Ok variant is a Datum into this native Rust type (Self). If it fails the error variant will contain the original result.

fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E>

Convert this Rust type into a Result containing a Datum, or an error

impl<D: Debug> Debug for Range<D>

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

Formats the value using the given formatter.

impl<D: Display> Display for Range<D>

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

Formats the value using the given formatter.

impl<'a, T: FromSql<'a>> FromSql<'a> for Range<T>

fn from_sql( ty: &PgType, raw: &'a [u8], ) -> Result<Range<T>, Box<dyn Error + Sync + Send>>

Creates a new value of this type from a buffer of data of the specified Postgres Type in its binary format.

fn accepts(ty: &PgType) -> bool

Determines if a value of this type can be created from the specified Postgres Type.

fn from_sql_null(ty: &Type) -> Result<Self, Box<dyn Error + Send + Sync>>

Creates a new value of this type from a NULL SQL value.

fn from_sql_nullable( ty: &Type, raw: Option<&'a [u8]>, ) -> Result<Self, Box<dyn Error + Send + Sync>>

A convenience function that delegates to from_sql and from_sql_null depending on the value of raw.

impl<D: Hash> Hash for Range<D>

fn hash<H: Hasher>(&self, hasher: &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<D: Ord> Ord for Range<D>

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.

impl<D: PartialEq> PartialEq for Range<D>

fn eq(&self, other: &Self) -> 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<D: Ord + PartialOrd> PartialOrd for Range<D>

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<D: Copy> Copy for Range<D>

impl<D: Eq> Eq for Range<D>