Enum mz_repr::Datum

source · [−]

pub enum Datum<'a> {
Show 24 variants    False,
    True,
    Int16(i16),
    Int32(i32),
    Int64(i64),
    UInt8(u8),
    UInt32(u32),
    Float32(OrderedFloat<f32>),
    Float64(OrderedFloat<f64>),
    Date(NaiveDate),
    Time(NaiveTime),
    Timestamp(NaiveDateTime),
    TimestampTz(DateTime<Utc>),
    Interval(Interval),
    Bytes(&'a [u8]),
    String(&'a str),
    Array(Array<'a>),
    List(DatumList<'a>),
    Map(DatumMap<'a>),
    Numeric(OrderedDecimal<Numeric>),
    JsonNull,
    Uuid(Uuid),
    Dummy,
    Null,
}

Expand description

A single value.

Note that Datum must always derive Eq to enforce equality with repr::Row.

Variants

`False`

The false boolean value.

`True`

The true boolean value.

`Int16(i16)`

A 16-bit signed integer.

`Int32(i32)`

A 32-bit signed integer.

`Int64(i64)`

A 64-bit signed integer.

`UInt8(u8)`

An 8-bit unsigned integer.

`UInt32(u32)`

A 32-bit unsigned integer.

`TimestampTz(DateTime<Utc>)`

A date and time, with a timezone.

`Interval(Interval)`

A span of time.

`Bytes(&'a [u8])`

A sequence of untyped bytes.

`String(&'a str)`

A sequence of Unicode codepoints encoded as UTF-8.

`Array(Array<'a>)`

Unlike Datum::List, arrays are like tensors and are not permitted to be ragged.

`List(DatumList<'a>)`

A sequence of Datums.

Unlike Datum::Array, lists are permitted to be ragged.

`Map(DatumMap<'a>)`

A mapping from string keys to Datums.

`Numeric(OrderedDecimal<Numeric>)`

An exact decimal number, possibly with a fractional component, with up to 39 digits of precision.

`JsonNull`

An unknown value within a JSON-typed Datum.

This variant is distinct from Datum::Null as a null datum is distinct from a non-null datum that contains the JSON value null.

`Uuid(Uuid)`

A universally unique identifier.

`Dummy`

A placeholder value.

Dummy values are never meant to be observed. Many operations on Datum panic if called on this variant.

Dummies are useful as placeholders in e.g. a Vec<Datum>, where it is known that a certain element of the vector is never observed and therefore needn’t be computed, but where some Datum must still be provided to maintain the shape of the vector. While any valid datum could be used for this purpose, having a dedicated variant makes it obvious when these optimizations have gone awry. If we used e.g. Datum::Null, an unexpected Datum::Null could indicate any number of problems: bad user data, bad function metadata, or a bad optimization.

`Null`

An unknown value.

Enum mz_repr::Datum

Variants

False

True

Int16(i16)

Int32(i32)

Int64(i64)

UInt8(u8)

UInt32(u32)

Float32(OrderedFloat<f32>)

Float64(OrderedFloat<f64>)

Date(NaiveDate)

Time(NaiveTime)

Timestamp(NaiveDateTime)

TimestampTz(DateTime<Utc>)

Interval(Interval)

Bytes(&'a [u8])

String(&'a str)

Array(Array<'a>)

List(DatumList<'a>)

Map(DatumMap<'a>)

Numeric(OrderedDecimal<Numeric>)

JsonNull

Uuid(Uuid)

Dummy

Null

Implementations

impl<'a> Datum<'a>

pub fn is_null(&self) -> bool

pub fn unwrap_bool(&self) -> bool

pub fn unwrap_int16(&self) -> i16

pub fn unwrap_int32(&self) -> i32

pub fn unwrap_int64(&self) -> i64

pub fn unwrap_uint8(&self) -> u8

pub fn unwrap_uint32(&self) -> u32

pub fn unwrap_ordered_float32(&self) -> OrderedFloat<f32>

pub fn unwrap_ordered_float64(&self) -> OrderedFloat<f64>

pub fn unwrap_float32(&self) -> f32

pub fn unwrap_float64(&self) -> f64

pub fn unwrap_date(&self) -> NaiveDate

pub fn unwrap_time(&self) -> NaiveTime

pub fn unwrap_timestamp(&self) -> NaiveDateTime

pub fn unwrap_timestamptz(&self) -> DateTime<Utc>

pub fn unwrap_interval(&self) -> Interval

pub fn unwrap_str(&self) -> &'a str

pub fn unwrap_bytes(&self) -> &'a [u8]ⓘNotable traits for &'_ [u8]impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]

pub fn unwrap_uuid(&self) -> Uuid

pub fn unwrap_array(&self) -> Array<'a>

pub fn unwrap_list(&self) -> DatumList<'a>

pub fn unwrap_map(&self) -> DatumMap<'a>

pub fn unwrap_numeric(&self) -> OrderedDecimal<Numeric>

pub fn is_instance_of(self, column_type: &ColumnType) -> bool

impl Datum<'_>

pub fn empty_array() -> Datum<'static>

pub fn empty_list() -> Datum<'static>

Trait Implementations

impl<'a> Clone for Datum<'a>

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

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

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

fn nullable() -> bool

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

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

impl<'a> Debug for Datum<'a>

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

impl Display for Datum<'_>

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

impl<'a> From<&'a [u8]> for Datum<'a>

fn from(b: &'a [u8]) -> Datum<'a>

impl<'a> From<&'a PropDatum> for Datum<'a>

fn from(pd: &'a PropDatum) -> Self

impl<'a> From<&'a str> for Datum<'a>

fn from(s: &'a str) -> Datum<'a>

impl<'a> From<DateTime<Utc>> for Datum<'a>

fn from(dt: DateTime<Utc>) -> Datum<'a>

impl<'a> From<Decimal<NUMERIC_DATUM_WIDTH_USIZE>> for Datum<'a>

fn from(n: Numeric) -> Datum<'a>

impl<'a> From<Duration> for Datum<'a>

fn from(duration: Duration) -> Datum<'a>

impl<'a> From<Interval> for Datum<'a>

`False`

`True`

`Int16(i16)`

`Int32(i32)`

`Int64(i64)`

`UInt8(u8)`

`UInt32(u32)`

`Float32(OrderedFloat<f32>)`

`Float64(OrderedFloat<f64>)`

`Date(NaiveDate)`

`Time(NaiveTime)`

`Timestamp(NaiveDateTime)`

`TimestampTz(DateTime<Utc>)`

`Interval(Interval)`

`Bytes(&'a [u8])`

`String(&'a str)`

`Array(Array<'a>)`

`List(DatumList<'a>)`

`Map(DatumMap<'a>)`

`Numeric(OrderedDecimal<Numeric>)`

`JsonNull`

`Uuid(Uuid)`

`Dummy`

`Null`

pub fn unwrap_bytes(&self) -> &'a [u8 ]ⓘNotable traits for &'_ [u8 ]`impl<'_> Read for &'_ [u8]impl<'_> Write for &'_ mut [u8]`

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

impl<'a> From<&'a [u8 ]> for Datum<'a>

fn from(b: &'a [u8 ]) -> Datum<'a>

impl<'a, T> From<Option<T>> for Datum<'a> where
Datum<'a>: From<T>,

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

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