Struct mz_storage_client::types::sources::IngestionDescription

pub struct IngestionDescription<S = (), C = GenericSourceConnection> {
    pub desc: SourceDesc<C>,
    pub source_imports: BTreeMap<GlobalId, S>,
    pub ingestion_metadata: S,
    pub source_exports: BTreeMap<GlobalId, SourceExport<S>>,
    pub instance_id: StorageInstanceId,
    pub remap_collection_id: GlobalId,
}

A description of a source ingestion

Fields

desc: SourceDesc<C>

The source description

source_imports: BTreeMap<GlobalId, S>

Source collections made available to this ingestion.

ingestion_metadata: S

Additional storage controller metadata needed to ingest this source

source_exports: BTreeMap<GlobalId, SourceExport<S>>

Collections to be exported by this ingestion.

instance_id: StorageInstanceId

The ID of the instance in which to install the source.

remap_collection_id: GlobalId

The ID of this ingestion’s remap/progress collection.

Implementations

impl<S> IngestionDescription<S>

pub fn subsource_ids(&self) -> impl Iterator<Item = GlobalId> + '_

Return an iterator over the GlobalIds of self’s subsources.

Trait Implementations

impl<S> Arbitrary for IngestionDescription<S>where
    S: Arbitrary + 'static,

type Strategy = BoxedStrategy<IngestionDescription<S, GenericSourceConnection>>

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

type Parameters = ()

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

fn arbitrary_with(_: 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<S: Clone, C: Clone> Clone for IngestionDescription<S, C>

fn clone(&self) -> IngestionDescription<S, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug, C: Debug> Debug for IngestionDescription<S, C>

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

Formats the value using the given formatter.

impl<'de, S, C> Deserialize<'de> for IngestionDescription<S, C>where
    S: Deserialize<'de>,
    C: Deserialize<'de>,

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

Deserialize this value from the given Serde deserializer.

impl<S: PartialEq, C: PartialEq> PartialEq<IngestionDescription<S, C>> for IngestionDescription<S, C>

fn eq(&self, other: &IngestionDescription<S, C>) -> 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<T: Timestamp + Lattice + Codec64> ResumptionFrontierCalculator<T> for IngestionDescription<CollectionMetadata>

type State = Vec<WriteHandle<SourceData, (), T, i64>, Global>

Opaque state that a ResumptionFrontierCalculator needs to repeatedly (and efficiently) calculate a resumption frontier.

fn initialize_state<'life0, 'life1, 'async_trait>(
    &'life0 self,
    client_cache: &'life1 PersistClientCache
) -> Pin<Box<dyn Future<Output = Self::State> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Creates an opaque state type that can be used to efficiently calculate a new resumption frontier when needed.

fn calculate_resumption_frontier<'life0, 'life1, 'async_trait>(
    &'life0 self,
    handles: &'life1 mut Self::State
) -> Pin<Box<dyn Future<Output = Antichain<T>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Calculates a new, safe resumption frontier.

impl RustType<ProtoIngestionDescription> for IngestionDescription<CollectionMetadata>

fn into_proto(&self) -> ProtoIngestionDescription

Convert a Self into a Proto value.

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

Consume and convert a Proto back into a Self value.

impl<S, C> Serialize for IngestionDescription<S, C>where
    S: Serialize,
    C: Serialize,

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

Serialize this value into the given Serde serializer.

impl<S: Eq, C: Eq> Eq for IngestionDescription<S, C>

impl<S, C> StructuralEq for IngestionDescription<S, C>

impl<S, C> StructuralPartialEq for IngestionDescription<S, C>