Struct mz_storage_types::sources::SourceData

#[repr(transparent)]
pub struct SourceData(pub Result<Row, DataflowError>);

Tuple Fields

0: Result<Row, DataflowError>

Methods from Deref<Target = Result<Row, DataflowError>>

pub fn is_ok(&self) -> bool

Returns true if the result is Ok.

Examples

let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);

pub fn is_err(&self) -> bool

Returns true if the result is Err.

Examples

let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);

pub fn as_ref(&self) -> Result<&T, &E>

Converts from &Result<T, E> to Result<&T, &E>.

Produces a new Result, containing a reference into the original, leaving the original in place.

Examples

let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));

pub fn as_mut(&mut self) -> Result<&mut T, &mut E>

Converts from &mut Result<T, E> to Result<&mut T, &mut E>.

Examples

fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);

pub fn as_deref(&self) -> Result<&<T as Deref>::Target, &E>

where T: Deref,

Converts from Result<T, E> (or &Result<T, E>) to Result<&<T as Deref>::Target, &E>.

Coerces the Ok variant of the original Result via Deref and returns the new Result.

Examples

let x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&str, &u32> = Ok("hello");
assert_eq!(x.as_deref(), y);

let x: Result<String, u32> = Err(42);
let y: Result<&str, &u32> = Err(&42);
assert_eq!(x.as_deref(), y);

pub fn as_deref_mut(&mut self) -> Result<&mut <T as Deref>::Target, &mut E>

where T: DerefMut,

Converts from Result<T, E> (or &mut Result<T, E>) to Result<&mut <T as DerefMut>::Target, &mut E>.

Coerces the Ok variant of the original Result via DerefMut and returns the new Result.

Examples

let mut s = "HELLO".to_string();
let mut x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&mut str, &mut u32> = Ok(&mut s);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);

let mut i = 42;
let mut x: Result<String, u32> = Err(42);
let y: Result<&mut str, &mut u32> = Err(&mut i);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

The iterator yields one value if the result is Result::Ok, otherwise none.

Examples

let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns a mutable iterator over the possibly contained value.

The iterator yields one value if the result is Result::Ok, otherwise none.

Examples

let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {},
}
assert_eq!(x, Ok(40));

let mut x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter_mut().next(), None);

Trait Implementations

impl Arbitrary for SourceData

type Parameters = <Result<Row, DataflowError> as Arbitrary>::Parameters

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Map<<Result<Row, DataflowError> as Arbitrary>::Strategy, fn(_: Result<Row, DataflowError>) -> SourceData>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_top: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for SourceData

fn clone(&self) -> SourceData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Codec for SourceData

type Storage = ProtoRow

A type used with Self::decode_from for allocation reuse. Set to () if unnecessary.

type Schema = RelationDesc

The type of the associated schema for Self.

fn codec_name() -> String

Name of the codec.

fn encode<B: BufMut>(&self, buf: &mut B)

Encode a key or value for permanent storage.

fn decode(buf: &[u8]) -> Result<Self, String>

Decode a key or value previous encoded with this codec’s Codec::encode.

fn decode_from<'a>( &mut self, buf: &'a [u8], storage: &mut Option<ProtoRow> ) -> Result<(), String>

An alternate form of Self::decode which enables amortizing allocs.

impl Debug for SourceData

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

Formats the value using the given formatter.

impl Default for SourceData

fn default() -> Self

Returns the “default value” for a type.

impl Deref for SourceData

type Target = Result<Row, DataflowError>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for SourceData

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for SourceData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Ord for SourceData

fn cmp(&self, other: &SourceData) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartDecoder<SourceData> for SourceDataDecoder

fn decode(&self, idx: usize, val: &mut SourceData)

Decodes the value at the given index.

impl PartEncoder<SourceData> for SourceDataEncoder

fn encode(&mut self, val: &SourceData)

Encodes the given value into the Part being constructed.

fn finish(self) -> (usize, Vec<DynColumnMut>)

Consumes self returning the columns that were written to.

impl PartialEq for SourceData

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for SourceData

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl RustType<ProtoSourceData> for SourceData

fn into_proto(&self) -> ProtoSourceData

Convert a Self into a Proto value.

fn from_proto(proto: ProtoSourceData) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

impl Schema<SourceData> for RelationDesc

type Encoder = SourceDataEncoder

The associated PartEncoder implementor.

type Decoder = SourceDataDecoder

The associated PartDecoder implementor.

fn columns(&self) -> DynStructCfg

Returns the name and types of the columns in this type.

fn decoder(&self, cols: ColumnsRef) -> Result<Self::Decoder, String>

Returns a Self::Decoder for the given columns.

fn encoder(&self, cols: ColumnsMut) -> Result<Self::Encoder, String>

Returns a Self::Encoder for the given columns.

impl Serialize for SourceData

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SourceData

impl StructuralPartialEq for SourceData