Struct KafkaSinkConnection

pub struct KafkaSinkConnection<C: ConnectionAccess = InlinedConnection> {

    pub connection_id: CatalogItemId,
    pub connection: C::Kafka,
    pub format: KafkaSinkFormat<C>,
    pub relation_key_indices: Option<Vec<usize>>,
    pub key_desc_and_indices: Option<(RelationDesc, Vec<usize>)>,
    pub headers_index: Option<usize>,
    pub value_desc: RelationDesc,
    pub partition_by: Option<MirScalarExpr>,
    pub topic: String,
    pub topic_options: KafkaTopicOptions,
    pub compression_type: KafkaSinkCompressionType,
    pub progress_group_id: KafkaIdStyle,
    pub transactional_id: KafkaIdStyle,
    pub topic_metadata_refresh_interval: Duration,
}

Fields

connection_id: CatalogItemId

connection: C::Kafka

format: KafkaSinkFormat<C>

relation_key_indices: Option<Vec<usize>>

A natural key of the sinked relation (view or source).

key_desc_and_indices: Option<(RelationDesc, Vec<usize>)>

The user-specified key for the sink.

headers_index: Option<usize>

The index of the column containing message headers value, if any.

value_desc: RelationDesc

partition_by: Option<MirScalarExpr>

An expression that, if present, computes a hash value that should be used to determine the partition for each message.

topic: String

topic_options: KafkaTopicOptions

Options to use when creating the topic if it doesn’t already exist.

compression_type: KafkaSinkCompressionType

progress_group_id: KafkaIdStyle

transactional_id: KafkaIdStyle

topic_metadata_refresh_interval: Duration

Implementations

impl KafkaSinkConnection

pub fn client_id( &self, configs: &ConfigSet, connection_context: &ConnectionContext, sink_id: GlobalId, ) -> String

Returns the client ID to register with librdkafka with.

The caller is responsible for providing the sink ID as it is not known to KafkaSinkConnection.

pub fn progress_topic( &self, connection_context: &ConnectionContext, ) -> Cow<'_, str>

Returns the name of the progress topic to use for the sink.

pub fn progress_group_id( &self, connection_context: &ConnectionContext, sink_id: GlobalId, ) -> String

Returns the ID for the consumer group the sink will use to read the progress topic on resumption.

The caller is responsible for providing the sink ID as it is not known to KafkaSinkConnection.

pub fn transactional_id( &self, connection_context: &ConnectionContext, sink_id: GlobalId, ) -> String

Returns the transactional ID to use for the sink.

The caller is responsible for providing the sink ID as it is not known to KafkaSinkConnection.

impl<C: ConnectionAccess> KafkaSinkConnection<C>

pub fn alter_compatible( &self, id: GlobalId, other: &KafkaSinkConnection<C>, ) -> Result<(), AlterError>

Determines if self is compatible with another StorageSinkConnection, in such a way that it is possible to turn self into other through a valid series of transformations (e.g. no transformation or ALTER CONNECTION).

Trait Implementations

impl<C: ConnectionAccess + Arbitrary> Arbitrary for KafkaSinkConnection<C>

where C::Kafka: Arbitrary,

type Parameters = (<CatalogItemId as Arbitrary>::Parameters, <<C as ConnectionAccess>::Kafka as Arbitrary>::Parameters, <KafkaSinkFormat<C> as Arbitrary>::Parameters, <Option<Vec<usize>> as Arbitrary>::Parameters, <Option<(RelationDesc, Vec<usize>)> as Arbitrary>::Parameters, <Option<usize> as Arbitrary>::Parameters, <RelationDesc as Arbitrary>::Parameters, <Option<MirScalarExpr> as Arbitrary>::Parameters, <String as Arbitrary>::Parameters, (<KafkaTopicOptions as Arbitrary>::Parameters, <KafkaSinkCompressionType as Arbitrary>::Parameters, <KafkaIdStyle as Arbitrary>::Parameters, <KafkaIdStyle as Arbitrary>::Parameters, <Duration as Arbitrary>::Parameters))

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

type Strategy = Map<(<CatalogItemId as Arbitrary>::Strategy, <<C as ConnectionAccess>::Kafka as Arbitrary>::Strategy, <KafkaSinkFormat<C> as Arbitrary>::Strategy, <Option<Vec<usize>> as Arbitrary>::Strategy, <Option<(RelationDesc, Vec<usize>)> as Arbitrary>::Strategy, <Option<usize> as Arbitrary>::Strategy, <RelationDesc as Arbitrary>::Strategy, <Option<MirScalarExpr> as Arbitrary>::Strategy, <String as Arbitrary>::Strategy, (<KafkaTopicOptions as Arbitrary>::Strategy, <KafkaSinkCompressionType as Arbitrary>::Strategy, <KafkaIdStyle as Arbitrary>::Strategy, <KafkaIdStyle as Arbitrary>::Strategy, <Duration as Arbitrary>::Strategy)), fn(_: (CatalogItemId, <C as ConnectionAccess>::Kafka, KafkaSinkFormat<C>, Option<Vec<usize>>, Option<(RelationDesc, Vec<usize>)>, Option<usize>, RelationDesc, Option<MirScalarExpr>, String, (KafkaTopicOptions, KafkaSinkCompressionType, KafkaIdStyle, KafkaIdStyle, Duration))) -> KafkaSinkConnection<C>>

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<C: Clone + ConnectionAccess> Clone for KafkaSinkConnection<C>

where C::Kafka: Clone,

fn clone(&self) -> KafkaSinkConnection<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug + ConnectionAccess> Debug for KafkaSinkConnection<C>

where C::Kafka: Debug,

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

Formats the value using the given formatter.

impl<'de, C> Deserialize<'de> for KafkaSinkConnection<C>

where C: Deserialize<'de> + ConnectionAccess, C::Kafka: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R: ConnectionResolver> IntoInlineConnection<KafkaSinkConnection, R> for KafkaSinkConnection<ReferencedConnection>

fn into_inline_connection(self, r: R) -> KafkaSinkConnection

impl<C: PartialEq + ConnectionAccess> PartialEq for KafkaSinkConnection<C>

where C::Kafka: PartialEq,

fn eq(&self, other: &KafkaSinkConnection<C>) -> 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 RustType<ProtoKafkaSinkConnectionV2> for KafkaSinkConnection

fn into_proto(&self) -> ProtoKafkaSinkConnectionV2

Convert a Self into a Proto value.

fn from_proto( proto: ProtoKafkaSinkConnectionV2, ) -> 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<C> Serialize for KafkaSinkConnection<C>

where C: Serialize + ConnectionAccess, C::Kafka: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<C: Eq + ConnectionAccess> Eq for KafkaSinkConnection<C>

where C::Kafka: Eq,

impl<C: ConnectionAccess> StructuralPartialEq for KafkaSinkConnection<C>