Struct 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], schema: &RelationDesc) -> 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>, schema: &RelationDesc, ) -> Result<(), String>

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

fn validate(val: &Self, desc: &Self::Schema) -> Result<(), String>

Checks that the given value matches the provided schema.

fn encode_schema(schema: &Self::Schema) -> Bytes

Encode a schema for permanent storage.

fn decode_schema(buf: &Bytes) -> Self::Schema

Decode a schema previous encoded with this codec’s Self::encode_schema.

fn encode_to_vec(&self) -> Vec<u8>

Encode a key or value to a Vec.

impl ColumnDecoder<SourceData> for SourceDataColumnarDecoder

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

Decode the value at idx into the buffer val.

fn is_null(&self, idx: usize) -> bool

Returns if the value at idx is null.

fn goodbytes(&self) -> usize

Returns the number of bytes used by this decoder.

fn stats(&self) -> StructStats

Returns statistics for the column. This structure is defined by Persist, but the contents are determined by the client; Persist will preserve them in the part metadata and make them available to readers.

impl ColumnEncoder<SourceData> for SourceDataColumnarEncoder

type FinishedColumn = StructArray

Type of column that this encoder returns when finalized.

fn goodbytes(&self) -> usize

The amount of “actual data” encoded by this encoder so far.

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

Appends val onto this encoder.

fn append_null(&mut self)

Appends a null value onto this encoder.

fn finish(self) -> Self::FinishedColumn

Finish this encoder, returning an immutable column.

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,

Restrict a value to a certain interval.

impl PartialEq for SourceData

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

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 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.

fn into_proto_owned(self) -> Proto

A zero clone version of Self::into_proto that types can optionally implement, otherwise, the default implementation delegates to Self::into_proto.

impl Schema<SourceData> for RelationDesc

type ArrowColumn = StructArray

The type of column we decode from, and encoder will finish into.

type Statistics = StructStats

Statistics we collect for a schema of this type.

type Decoder = SourceDataColumnarDecoder

Type that is able to decode values of T from Self::ArrowColumn.

type Encoder = SourceDataColumnarEncoder

Type that is able to encoder values of T.

fn decoder(&self, col: Self::ArrowColumn) -> Result<Self::Decoder, Error>

Returns a type that is able to decode instances of T from the provider column.

fn encoder(&self) -> Result<Self::Encoder, Error>

Returns a type that can encode values of T.

fn decoder_any(&self, col: &dyn Array) -> Result<Self::Decoder, Error>

Returns a type that is able to decode instances of T from a type erased arrow::array::Array, erroring if the provided array is not Self::ArrowColumn.

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