Enum mz_storage_types::sources::SourceEnvelope

pub enum SourceEnvelope {
    None(NoneEnvelope),
    Debezium(DebeziumEnvelope),
    Upsert(UpsertEnvelope),
    CdcV2,
}

SourceEnvelopes describe how to turn a stream of messages from SourceDescs into a differential stream, that is, a stream of (data, time, diff) triples.

PostgreSQL sources skip any explicit envelope handling, effectively asserting that SourceEnvelope is None with KeyEnvelope::None.

Variants

None(NoneEnvelope)

The most trivial version is None, which typically produces triples where the diff is 1. However, some sources are able to produce values with more exotic diff’s, such as the posgres source. Currently, this is the only variant usable with those sources.

If the KeyEnvelope is present, include the key columns as an output column of the source with the given properties.

Debezium(DebeziumEnvelope)

Debezium avoids holding onto previously seen values by trusting the required before and after value fields coming from the upstream source.

Upsert(UpsertEnvelope)

Upsert holds onto previously seen values and produces 1 or -1 diffs depending on whether or not the required key outputed by the source has been seen before. This also supports a Debezium mode.

CdcV2

CdcV2 requires sources output messages in a strict form that requires a upstream-provided timeline.

Trait Implementations

impl Arbitrary for SourceEnvelope

type Parameters = (<NoneEnvelope as Arbitrary>::Parameters, <DebeziumEnvelope as Arbitrary>::Parameters, <UpsertEnvelope as Arbitrary>::Parameters)

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

type Strategy = Union<BoxedStrategy<SourceEnvelope>>

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 SourceEnvelope

fn clone(&self) -> SourceEnvelope

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SourceEnvelope

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SourceEnvelope

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SourceEnvelope

fn eq(&self, other: &SourceEnvelope) -> 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 RustType<ProtoSourceEnvelope> for SourceEnvelope

fn into_proto(&self) -> ProtoSourceEnvelope

Convert a Self into a Proto value.

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

Consume and convert a Proto back into a Self value.

impl Serialize for SourceEnvelope

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 SourceEnvelope

impl StructuralEq for SourceEnvelope

impl StructuralPartialEq for SourceEnvelope