risingwave_pb/

stream_plan.rs

// This file is @generated by prost-build.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Dispatchers {
    #[prost(message, repeated, tag = "1")]
    pub dispatchers: ::prost::alloc::vec::Vec<Dispatcher>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpstreamSinkInfo {
    #[prost(uint32, tag = "1", wrapper = "crate::id::FragmentId")]
    pub upstream_fragment_id: crate::id::FragmentId,
    #[prost(message, repeated, tag = "2")]
    pub sink_output_schema: ::prost::alloc::vec::Vec<super::plan_common::Field>,
    #[prost(message, repeated, tag = "3")]
    pub project_exprs: ::prost::alloc::vec::Vec<super::expr::ExprNode>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AddMutation {
    /// New dispatchers for each actor.
    #[prost(map = "uint32, message", tag = "1", wrapper = "crate::id::ActorId")]
    pub actor_dispatchers: ::std::collections::HashMap<crate::id::ActorId, Dispatchers>,
    /// All actors to be added (to the main connected component of the graph) in this update.
    #[prost(uint32, repeated, tag = "3", wrapper = "crate::id::ActorId")]
    pub added_actors: ::prost::alloc::vec::Vec<crate::id::ActorId>,
    /// We may embed a source change split mutation here.
    /// `Source` and `SourceBackfill` are handled together here.
    /// TODO: we may allow multiple mutations in a single barrier.
    #[prost(map = "uint32, message", tag = "2", wrapper = "crate::id::ActorId")]
    pub actor_splits: ::std::collections::HashMap<
        crate::id::ActorId,
        super::source::ConnectorSplits,
    >,
    /// We may embed a pause mutation here.
    /// TODO: we may allow multiple mutations in a single barrier.
    #[prost(bool, tag = "4")]
    pub pause: bool,
    #[prost(message, repeated, tag = "5")]
    pub subscriptions_to_add: ::prost::alloc::vec::Vec<SubscriptionUpstreamInfo>,
    /// nodes which should be paused initially.
    #[prost(uint32, repeated, tag = "6", wrapper = "crate::id::FragmentId")]
    pub backfill_nodes_to_pause: ::prost::alloc::vec::Vec<crate::id::FragmentId>,
    /// CDC table snapshot splits
    #[prost(message, optional, tag = "7")]
    pub actor_cdc_table_snapshot_splits: ::core::option::Option<
        super::source::CdcTableSnapshotSplitsWithGeneration,
    >,
    /// Use downstream_fragment_id as keys.
    #[prost(map = "uint32, message", tag = "8", wrapper = "crate::id::FragmentId")]
    pub new_upstream_sinks: ::std::collections::HashMap<
        crate::id::FragmentId,
        add_mutation::NewUpstreamSink,
    >,
    /// All actors to be dropped while adding the new streaming job.
    #[prost(uint32, repeated, tag = "9", wrapper = "crate::id::ActorId")]
    pub dropped_actors: ::prost::alloc::vec::Vec<crate::id::ActorId>,
    /// Sink ids whose log store must be drained before this add barrier can be collected.
    #[prost(uint32, repeated, tag = "10", wrapper = "crate::id::SinkId")]
    pub sink_log_store_flush: ::prost::alloc::vec::Vec<crate::id::SinkId>,
}
/// Nested message and enum types in `AddMutation`.
pub mod add_mutation {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct NewUpstreamSink {
        #[prost(message, optional, tag = "1")]
        pub info: ::core::option::Option<super::UpstreamSinkInfo>,
        #[prost(message, repeated, tag = "2")]
        pub upstream_actors: ::prost::alloc::vec::Vec<super::super::common::ActorInfo>,
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StopMutation {
    #[prost(uint32, repeated, tag = "1", wrapper = "crate::id::ActorId")]
    pub actors: ::prost::alloc::vec::Vec<crate::id::ActorId>,
    /// Only sink-fragment in the sink job is recorded.
    #[prost(uint32, repeated, tag = "2", wrapper = "crate::id::FragmentId")]
    pub dropped_sink_fragments: ::prost::alloc::vec::Vec<crate::id::FragmentId>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateMutation {
    /// Dispatcher updates.
    #[prost(message, repeated, tag = "1")]
    pub dispatcher_update: ::prost::alloc::vec::Vec<update_mutation::DispatcherUpdate>,
    /// Merge updates.
    #[prost(message, repeated, tag = "2")]
    pub merge_update: ::prost::alloc::vec::Vec<update_mutation::MergeUpdate>,
    /// Vnode bitmap updates for each actor.
    #[prost(map = "uint32, message", tag = "3", wrapper = "crate::id::ActorId")]
    pub actor_vnode_bitmap_update: ::std::collections::HashMap<
        crate::id::ActorId,
        super::common::Buffer,
    >,
    /// All actors to be dropped in this update.
    #[prost(uint32, repeated, tag = "4", wrapper = "crate::id::ActorId")]
    pub dropped_actors: ::prost::alloc::vec::Vec<crate::id::ActorId>,
    /// Source updates.
    /// `Source` and `SourceBackfill` are handled together here.
    #[prost(map = "uint32, message", tag = "5", wrapper = "crate::id::ActorId")]
    pub actor_splits: ::std::collections::HashMap<
        crate::id::ActorId,
        super::source::ConnectorSplits,
    >,
    /// When modifying the Materialized View, we need to recreate the Dispatcher from the old upstream to the new TableFragment.
    /// Consistent with the semantics in AddMutation.
    #[prost(map = "uint32, message", tag = "6", wrapper = "crate::id::ActorId")]
    pub actor_new_dispatchers: ::std::collections::HashMap<
        crate::id::ActorId,
        Dispatchers,
    >,
    /// CDC table snapshot splits
    #[prost(message, optional, tag = "7")]
    pub actor_cdc_table_snapshot_splits: ::core::option::Option<
        super::source::CdcTableSnapshotSplitsWithGeneration,
    >,
    #[prost(map = "uint32, message", tag = "8")]
    pub sink_schema_change: ::std::collections::HashMap<u32, SinkSchemaChange>,
    #[prost(message, repeated, tag = "9")]
    pub subscriptions_to_drop: ::prost::alloc::vec::Vec<SubscriptionUpstreamInfo>,
    #[prost(message, optional, tag = "10")]
    pub iceberg_pk_index_compaction: ::core::option::Option<
        IcebergPkIndexCompactionContext,
    >,
}
/// Nested message and enum types in `UpdateMutation`.
pub mod update_mutation {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct DispatcherUpdate {
        /// Dispatcher can be uniquely identified by a combination of actor id and dispatcher id.
        #[prost(uint32, tag = "1", wrapper = "crate::id::ActorId")]
        pub actor_id: crate::id::ActorId,
        #[prost(uint32, tag = "2", wrapper = "crate::id::FragmentId")]
        pub dispatcher_id: crate::id::FragmentId,
        /// The hash mapping for consistent hash.
        /// For dispatcher types other than HASH, this is ignored.
        #[prost(message, optional, tag = "3")]
        pub hash_mapping: ::core::option::Option<super::ActorMapping>,
        /// Added downstream actors.
        #[prost(uint32, repeated, tag = "4", wrapper = "crate::id::ActorId")]
        pub added_downstream_actor_id: ::prost::alloc::vec::Vec<crate::id::ActorId>,
        /// Removed downstream actors.
        #[prost(uint32, repeated, tag = "5", wrapper = "crate::id::ActorId")]
        pub removed_downstream_actor_id: ::prost::alloc::vec::Vec<crate::id::ActorId>,
    }
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MergeUpdate {
        /// Merge executor can be uniquely identified by a combination of actor id and upstream fragment id.
        #[prost(uint32, tag = "1", wrapper = "crate::id::ActorId")]
        pub actor_id: crate::id::ActorId,
        #[prost(uint32, tag = "2", wrapper = "crate::id::FragmentId")]
        pub upstream_fragment_id: crate::id::FragmentId,
        /// * For scaling, this is always `None`.
        /// * For plan change, the upstream fragment will be changed to a new one, and this will be `Some`.
        ///   In this case, all the upstream actors should be removed and replaced by the `new` ones.
        #[prost(uint32, optional, tag = "5", wrapper = "crate::id::FragmentId")]
        pub new_upstream_fragment_id: ::core::option::Option<crate::id::FragmentId>,
        /// Added upstream actors.
        #[prost(message, repeated, tag = "3")]
        pub added_upstream_actors: ::prost::alloc::vec::Vec<
            super::super::common::ActorInfo,
        >,
        /// Removed upstream actors.
        /// Note: this is empty for replace job.
        #[prost(uint32, repeated, tag = "4", wrapper = "crate::id::ActorId")]
        pub removed_upstream_actor_id: ::prost::alloc::vec::Vec<crate::id::ActorId>,
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SourceChangeSplitMutation {
    /// `Source` and `SourceBackfill` are handled together here.
    #[prost(map = "uint32, message", tag = "2", wrapper = "crate::id::ActorId")]
    pub actor_splits: ::std::collections::HashMap<
        crate::id::ActorId,
        super::source::ConnectorSplits,
    >,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct PauseMutation {}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ResumeMutation {}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ThrottleMutation {
    #[prost(map = "uint32, message", tag = "1", wrapper = "crate::id::FragmentId")]
    pub fragment_throttle: ::std::collections::HashMap<
        crate::id::FragmentId,
        throttle_mutation::ThrottleConfig,
    >,
}
/// Nested message and enum types in `ThrottleMutation`.
pub mod throttle_mutation {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ThrottleConfig {
        #[prost(uint32, optional, tag = "1")]
        pub rate_limit: ::core::option::Option<u32>,
        #[prost(enumeration = "super::super::common::ThrottleType", tag = "2")]
        pub throttle_type: i32,
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SubscriptionUpstreamInfo {
    /// can either be subscription_id or table_id of creating TableFragments
    #[prost(uint32, tag = "1", wrapper = "crate::id::SubscriberId")]
    pub subscriber_id: crate::id::SubscriberId,
    #[prost(uint32, tag = "2", wrapper = "crate::id::TableId")]
    pub upstream_mv_table_id: crate::id::TableId,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DropSubscriptionsMutation {
    #[prost(message, repeated, tag = "1")]
    pub info: ::prost::alloc::vec::Vec<SubscriptionUpstreamInfo>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectorPropsChangeMutation {
    #[prost(map = "uint32, message", tag = "1")]
    pub connector_props_infos: ::std::collections::HashMap<
        u32,
        connector_props_change_mutation::ConnectorPropsInfo,
    >,
}
/// Nested message and enum types in `ConnectorPropsChangeMutation`.
pub mod connector_props_change_mutation {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ConnectorPropsInfo {
        #[prost(map = "string, string", tag = "1")]
        pub connector_props_info: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StartFragmentBackfillMutation {
    #[prost(uint32, repeated, tag = "1", wrapper = "crate::id::FragmentId")]
    pub fragment_ids: ::prost::alloc::vec::Vec<crate::id::FragmentId>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RefreshStartMutation {
    /// Table ID to start refresh operation.
    #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
    pub table_id: crate::id::TableId,
    /// Associated source ID for this refresh operation.
    #[prost(uint32, tag = "2", wrapper = "crate::id::SourceId")]
    pub associated_source_id: crate::id::SourceId,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListFinishMutation {
    /// Associated source ID for this list operation.
    #[prost(uint32, tag = "1", wrapper = "crate::id::SourceId")]
    pub associated_source_id: crate::id::SourceId,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LoadFinishMutation {
    /// Associated source ID for this load operation.
    #[prost(uint32, tag = "1", wrapper = "crate::id::SourceId")]
    pub associated_source_id: crate::id::SourceId,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ResetSourceMutation {
    /// Source ID to reset
    #[prost(uint32, tag = "1")]
    pub source_id: u32,
}
/// Inject specific offsets into source splits (UNSAFE - admin only).
/// This overwrites the stored offsets and can cause data duplication or loss.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InjectSourceOffsetsMutation {
    /// Source ID to inject offsets for
    #[prost(uint32, tag = "1")]
    pub source_id: u32,
    /// Split ID -> offset (JSON-encoded based on connector type)
    #[prost(map = "string, string", tag = "2")]
    pub split_offsets: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Context for an ongoing iceberg pk-index compaction.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct IcebergPkIndexCompactionContext {
    #[prost(uint32, tag = "1", wrapper = "crate::id::SinkId")]
    pub sink_id: crate::id::SinkId,
    #[prost(uint64, tag = "2", wrapper = "crate::id::IcebergCompactionTaskId")]
    pub task_id: crate::id::IcebergCompactionTaskId,
    #[prost(enumeration = "iceberg_pk_index_compaction_context::Phase", tag = "3")]
    pub phase: i32,
    /// Required for PHASE_BEGIN and absent for PHASE_END.
    #[prost(message, optional, tag = "4")]
    pub resolver_task_input: ::core::option::Option<
        iceberg_pk_index_compaction_context::ResolverTaskInput,
    >,
}
/// Nested message and enum types in `IcebergPkIndexCompactionContext`.
pub mod iceberg_pk_index_compaction_context {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ResolverTaskInput {
        #[prost(string, repeated, tag = "1")]
        pub output_data_file_paths: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
        #[prost(string, repeated, tag = "2")]
        pub input_data_file_paths: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
        #[prost(int64, tag = "3")]
        pub read_snapshot_id: i64,
    }
    #[derive(prost_helpers::AnyPB)]
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Phase {
        Unspecified = 0,
        Begin = 1,
        End = 2,
    }
    impl Phase {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "PHASE_UNSPECIFIED",
                Self::Begin => "PHASE_BEGIN",
                Self::End => "PHASE_END",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PHASE_UNSPECIFIED" => Some(Self::Unspecified),
                "PHASE_BEGIN" => Some(Self::Begin),
                "PHASE_END" => Some(Self::End),
                _ => None,
            }
        }
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BarrierMutation {
    #[prost(
        oneof = "barrier_mutation::Mutation",
        tags = "3, 4, 5, 6, 7, 8, 10, 12, 13, 14, 15, 16, 17, 18, 19"
    )]
    pub mutation: ::core::option::Option<barrier_mutation::Mutation>,
}
/// Nested message and enum types in `BarrierMutation`.
pub mod barrier_mutation {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Mutation {
        /// Add new dispatchers to some actors, used for creating materialized views.
        #[prost(message, tag = "3")]
        Add(super::AddMutation),
        /// Stop a set of actors, used for dropping materialized views. Empty dispatchers will be
        /// automatically removed.
        #[prost(message, tag = "4")]
        Stop(super::StopMutation),
        /// Update outputs and hash mappings for some dispatchers, used for scaling and replace table.
        #[prost(message, tag = "5")]
        Update(super::UpdateMutation),
        /// Change the split of some sources.
        #[prost(message, tag = "6")]
        Splits(super::SourceChangeSplitMutation),
        /// Pause the dataflow of the whole streaming graph, only used for scaling.
        #[prost(message, tag = "7")]
        Pause(super::PauseMutation),
        /// Resume the dataflow of the whole streaming graph, only used for scaling.
        #[prost(message, tag = "8")]
        Resume(super::ResumeMutation),
        /// Alter the RateLimit of some specific executors
        #[prost(message, tag = "10")]
        Throttle(super::ThrottleMutation),
        /// Drop subscription on mv
        #[prost(message, tag = "12")]
        DropSubscriptions(super::DropSubscriptionsMutation),
        /// Alter sink/connector/source props
        #[prost(message, tag = "13")]
        ConnectorPropsChange(super::ConnectorPropsChangeMutation),
        /// Start backfilling for specific fragments
        /// This is separated from `ThrottleMutation::NO_RATE_LIMIT`.
        /// This is because user may concurrently rate limit + use backfill order control.
        /// If we use rate limit to pause / resume backfill fragments, if user manually
        /// resumes some fragments, this will overwrite the backfill order configuration.
        #[prost(message, tag = "14")]
        StartFragmentBackfill(super::StartFragmentBackfillMutation),
        /// Start refresh signal for refreshing tables
        #[prost(message, tag = "15")]
        RefreshStart(super::RefreshStartMutation),
        /// Load finish signal for refreshing tables
        #[prost(message, tag = "16")]
        LoadFinish(super::LoadFinishMutation),
        /// List finish signal for refreshing tables
        #[prost(message, tag = "17")]
        ListFinish(super::ListFinishMutation),
        /// Reset CDC source offset to latest
        #[prost(message, tag = "18")]
        ResetSource(super::ResetSourceMutation),
        /// Inject specific offsets into source splits (UNSAFE)
        #[prost(message, tag = "19")]
        InjectSourceOffsets(super::InjectSourceOffsetsMutation),
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Barrier {
    #[prost(message, optional, tag = "1")]
    pub epoch: ::core::option::Option<super::data::Epoch>,
    #[prost(message, optional, tag = "3")]
    pub mutation: ::core::option::Option<BarrierMutation>,
    /// Used for tracing.
    #[prost(map = "string, string", tag = "2")]
    pub tracing_context: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// The kind of the barrier.
    #[prost(enumeration = "barrier::BarrierKind", tag = "9")]
    pub kind: i32,
}
/// Nested message and enum types in `Barrier`.
pub mod barrier {
    #[derive(prost_helpers::AnyPB)]
    #[derive(::enum_as_inner::EnumAsInner)]
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum BarrierKind {
        Unspecified = 0,
        /// The first barrier after a fresh start or recovery.
        /// There will be no data associated with the previous epoch of the barrier.
        Initial = 1,
        /// A normal barrier. Data should be flushed locally.
        Barrier = 2,
        /// A checkpoint barrier. Data should be synchorized to the shared storage.
        Checkpoint = 3,
    }
    impl BarrierKind {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
                Self::Initial => "BARRIER_KIND_INITIAL",
                Self::Barrier => "BARRIER_KIND_BARRIER",
                Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "BARRIER_KIND_UNSPECIFIED" => Some(Self::Unspecified),
                "BARRIER_KIND_INITIAL" => Some(Self::Initial),
                "BARRIER_KIND_BARRIER" => Some(Self::Barrier),
                "BARRIER_KIND_CHECKPOINT" => Some(Self::Checkpoint),
                _ => None,
            }
        }
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Watermark {
    /// The reference to the watermark column in the stream's schema.
    #[prost(message, optional, tag = "1")]
    pub column: ::core::option::Option<super::expr::InputRef>,
    /// The watermark value, there will be no record having a greater value in the watermark column.
    #[prost(message, optional, tag = "3")]
    pub val: ::core::option::Option<super::data::Datum>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamMessage {
    #[prost(oneof = "stream_message::StreamMessage", tags = "1, 2, 3")]
    pub stream_message: ::core::option::Option<stream_message::StreamMessage>,
}
/// Nested message and enum types in `StreamMessage`.
pub mod stream_message {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum StreamMessage {
        #[prost(message, tag = "1")]
        StreamChunk(super::super::data::StreamChunk),
        #[prost(message, tag = "2")]
        Barrier(super::Barrier),
        #[prost(message, tag = "3")]
        Watermark(super::Watermark),
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamMessageBatch {
    #[prost(oneof = "stream_message_batch::StreamMessageBatch", tags = "1, 2, 3")]
    pub stream_message_batch: ::core::option::Option<
        stream_message_batch::StreamMessageBatch,
    >,
}
/// Nested message and enum types in `StreamMessageBatch`.
pub mod stream_message_batch {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct BarrierBatch {
        #[prost(message, repeated, tag = "1")]
        pub barriers: ::prost::alloc::vec::Vec<super::Barrier>,
    }
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum StreamMessageBatch {
        #[prost(message, tag = "1")]
        StreamChunk(super::super::data::StreamChunk),
        #[prost(message, tag = "2")]
        BarrierBatch(BarrierBatch),
        #[prost(message, tag = "3")]
        Watermark(super::Watermark),
    }
}
/// Hash mapping for compute node. Stores mapping from virtual node to actor id.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ActorMapping {
    #[prost(uint32, repeated, tag = "1")]
    pub original_indices: ::prost::alloc::vec::Vec<u32>,
    #[prost(uint32, repeated, tag = "2", wrapper = "crate::id::ActorId")]
    pub data: ::prost::alloc::vec::Vec<crate::id::ActorId>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Columns {
    #[prost(message, repeated, tag = "1")]
    pub columns: ::prost::alloc::vec::Vec<super::plan_common::ColumnCatalog>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamSource {
    #[prost(uint32, tag = "1", wrapper = "crate::id::SourceId")]
    pub source_id: crate::id::SourceId,
    #[prost(message, optional, tag = "2")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    #[prost(uint32, optional, tag = "3")]
    pub row_id_index: ::core::option::Option<u32>,
    #[prost(message, repeated, tag = "4")]
    pub columns: ::prost::alloc::vec::Vec<super::plan_common::ColumnCatalog>,
    #[prost(btree_map = "string, string", tag = "6")]
    pub with_properties: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    #[prost(message, optional, tag = "7")]
    pub info: ::core::option::Option<super::catalog::StreamSourceInfo>,
    #[prost(string, tag = "8")]
    pub source_name: ::prost::alloc::string::String,
    /// Source rate limit
    #[prost(uint32, optional, tag = "9")]
    pub rate_limit: ::core::option::Option<u32>,
    #[prost(btree_map = "string, message", tag = "10")]
    pub secret_refs: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        super::secret::SecretRef,
    >,
    /// Downstream columns are used by list node to know which columns are needed.
    #[prost(message, optional, tag = "11")]
    pub downstream_columns: ::core::option::Option<Columns>,
    #[prost(message, optional, tag = "12")]
    pub refresh_mode: ::core::option::Option<super::plan_common::SourceRefreshMode>,
    #[prost(uint32, optional, tag = "13", wrapper = "crate::id::TableId")]
    pub associated_table_id: ::core::option::Option<crate::id::TableId>,
    /// List reads this dedicated Fetch queue at committed checkpoints to confirm phase completion.
    /// The frontend sets only `table_id` to reference the paired Fetch state table; meta fills the
    /// rest of the descriptor from that table's catalog when building the actor graph.
    #[prost(message, optional, tag = "14")]
    pub iceberg_fetch_state_table: ::core::option::Option<
        super::plan_common::StorageTableDesc,
    >,
}
/// copy contents from StreamSource to prevent compatibility issues in the future
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamFsFetch {
    #[prost(uint32, tag = "1", wrapper = "crate::id::SourceId")]
    pub source_id: crate::id::SourceId,
    #[prost(message, optional, tag = "2")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    #[prost(uint32, optional, tag = "3")]
    pub row_id_index: ::core::option::Option<u32>,
    #[prost(message, repeated, tag = "4")]
    pub columns: ::prost::alloc::vec::Vec<super::plan_common::ColumnCatalog>,
    #[prost(btree_map = "string, string", tag = "6")]
    pub with_properties: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    #[prost(message, optional, tag = "7")]
    pub info: ::core::option::Option<super::catalog::StreamSourceInfo>,
    #[prost(string, tag = "8")]
    pub source_name: ::prost::alloc::string::String,
    /// Source rate limit
    #[prost(uint32, optional, tag = "9")]
    pub rate_limit: ::core::option::Option<u32>,
    #[prost(btree_map = "string, message", tag = "10")]
    pub secret_refs: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        super::secret::SecretRef,
    >,
    #[prost(message, optional, tag = "11")]
    pub refresh_mode: ::core::option::Option<super::plan_common::SourceRefreshMode>,
    #[prost(uint32, optional, tag = "12", wrapper = "crate::id::TableId")]
    pub associated_table_id: ::core::option::Option<crate::id::TableId>,
}
/// The executor only for receiving barrier from the meta service. It always resides in the leaves
/// of the streaming graph.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct BarrierRecvNode {}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SourceNode {
    /// The source node can contain either a stream source or nothing. So here we extract all
    /// information about stream source to a message, and here it will be an `Option` in Rust.
    #[prost(message, optional, tag = "1")]
    pub source_inner: ::core::option::Option<StreamSource>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamFsFetchNode {
    #[prost(message, optional, tag = "1")]
    pub node_inner: ::core::option::Option<StreamFsFetch>,
}
/// / It's input must be a `MergeNode`, which connects to the upstream source job.
/// / See `StreamSourceScan::adhoc_to_stream_prost` for the plan.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SourceBackfillNode {
    #[prost(uint32, tag = "1", wrapper = "crate::id::SourceId")]
    pub upstream_source_id: crate::id::SourceId,
    #[prost(uint32, optional, tag = "2")]
    pub row_id_index: ::core::option::Option<u32>,
    #[prost(message, repeated, tag = "3")]
    pub columns: ::prost::alloc::vec::Vec<super::plan_common::ColumnCatalog>,
    #[prost(message, optional, tag = "4")]
    pub info: ::core::option::Option<super::catalog::StreamSourceInfo>,
    #[prost(string, tag = "5")]
    pub source_name: ::prost::alloc::string::String,
    #[prost(btree_map = "string, string", tag = "6")]
    pub with_properties: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Backfill rate limit
    #[prost(uint32, optional, tag = "7")]
    pub rate_limit: ::core::option::Option<u32>,
    /// `| partition_id | backfill_progress |`
    #[prost(message, optional, tag = "8")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    #[prost(btree_map = "string, message", tag = "9")]
    pub secret_refs: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        super::secret::SecretRef,
    >,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SinkDesc {
    #[prost(uint32, tag = "1", wrapper = "crate::id::SinkId")]
    pub id: crate::id::SinkId,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub definition: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "5")]
    pub plan_pk: ::prost::alloc::vec::Vec<super::common::ColumnOrder>,
    #[prost(uint32, repeated, tag = "6")]
    pub downstream_pk: ::prost::alloc::vec::Vec<u32>,
    #[prost(uint32, repeated, tag = "7")]
    pub distribution_key: ::prost::alloc::vec::Vec<u32>,
    #[prost(btree_map = "string, string", tag = "8")]
    pub properties: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// to be deprecated
    #[prost(enumeration = "super::catalog::SinkType", tag = "9")]
    pub sink_type: i32,
    #[prost(message, repeated, tag = "10")]
    pub column_catalogs: ::prost::alloc::vec::Vec<super::plan_common::ColumnCatalog>,
    #[prost(string, tag = "11")]
    pub db_name: ::prost::alloc::string::String,
    /// If the sink is from table or mv, this is name of the table/mv. Otherwise
    /// it is the name of the sink itself.
    #[prost(string, tag = "12")]
    pub sink_from_name: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "13")]
    pub format_desc: ::core::option::Option<super::catalog::SinkFormatDesc>,
    #[prost(uint32, optional, tag = "14")]
    pub target_table: ::core::option::Option<u32>,
    #[prost(uint64, optional, tag = "15")]
    pub extra_partition_col_idx: ::core::option::Option<u64>,
    #[prost(btree_map = "string, message", tag = "16")]
    pub secret_refs: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        super::secret::SecretRef,
    >,
    /// Backward-compatible replacement for `SINK_TYPE_FORCE_APPEND_ONLY`.
    ///
    /// Should not directly access this field. Use method `ignore_delete()` instead.
    #[prost(bool, tag = "17")]
    pub raw_ignore_delete: bool,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SinkNode {
    #[prost(message, optional, tag = "1")]
    pub sink_desc: ::core::option::Option<SinkDesc>,
    /// A sink with a kv log store should have a table.
    #[prost(message, optional, tag = "2")]
    pub table: ::core::option::Option<super::catalog::Table>,
    #[prost(enumeration = "SinkLogStoreType", tag = "3")]
    pub log_store_type: i32,
    #[prost(uint32, optional, tag = "4")]
    pub rate_limit: ::core::option::Option<u32>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IcebergWithPkIndexWriterNode {
    #[prost(message, optional, tag = "1")]
    pub sink_desc: ::core::option::Option<SinkDesc>,
    #[prost(message, optional, tag = "2")]
    pub pk_index_table: ::core::option::Option<super::catalog::Table>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct IcebergWithPkIndexPositionDeleteMergerNode {
    #[prost(message, optional, tag = "1")]
    pub sink_desc: ::core::option::Option<SinkDesc>,
}
/// Leaf of the inactive pk-index compaction pipeline rendered with the sink job.
///
/// This message existed in release-3.1, but no producer emitted it into a stream graph, so the old
/// fields were never persisted as part of an actor definition.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompactionResolverNode {
    /// Placeholder from frontend; replaced with the actual job ID by Meta.
    #[prost(uint32, tag = "1", wrapper = "crate::id::SinkId")]
    pub sink_id: crate::id::SinkId,
    #[prost(btree_map = "string, string", tag = "2")]
    pub properties: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    #[prost(btree_map = "string, message", tag = "3")]
    pub secret_refs: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        super::secret::SecretRef,
    >,
    /// The order defines the primary-key order in resolver output rows.
    #[prost(message, repeated, tag = "4")]
    pub pk_columns: ::prost::alloc::vec::Vec<compaction_resolver_node::PkColumn>,
}
/// Nested message and enum types in `CompactionResolverNode`.
pub mod compaction_resolver_node {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct PkColumn {
        /// Column position in the Iceberg data-file row.
        #[prost(uint32, tag = "1")]
        pub data_file_index: u32,
        /// Type and identity of the corresponding primary-key column.
        #[prost(message, optional, tag = "2")]
        pub column_desc: ::core::option::Option<super::super::plan_common::ColumnDesc>,
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProjectNode {
    #[prost(message, repeated, tag = "1")]
    pub select_list: ::prost::alloc::vec::Vec<super::expr::ExprNode>,
    /// this two field is expressing a list of usize pair, which means when project receives a
    /// watermark with `watermark_input_cols\[i\]` column index, it should derive a new watermark
    /// with `watermark_output_cols\[i\]`th expression
    #[prost(uint32, repeated, tag = "2")]
    pub watermark_input_cols: ::prost::alloc::vec::Vec<u32>,
    #[prost(uint32, repeated, tag = "3")]
    pub watermark_output_cols: ::prost::alloc::vec::Vec<u32>,
    #[prost(uint32, repeated, tag = "4")]
    pub nondecreasing_exprs: ::prost::alloc::vec::Vec<u32>,
    /// Whether there are likely no-op updates in the output chunks, so that eliminating them with
    /// `StreamChunk::eliminate_adjacent_noop_update` could be beneficial.
    #[prost(bool, tag = "5")]
    pub noop_update_hint: bool,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FilterNode {
    #[prost(message, optional, tag = "1")]
    pub search_condition: ::core::option::Option<super::expr::ExprNode>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ChangeLogNode {
    /// Whether or not there is an op in the final output.
    #[prost(bool, tag = "1")]
    pub need_op: bool,
    #[prost(uint32, repeated, tag = "2")]
    pub distribution_keys: ::prost::alloc::vec::Vec<u32>,
    #[prost(uint32, repeated, tag = "4")]
    pub stream_keys: ::prost::alloc::vec::Vec<u32>,
    #[prost(oneof = "change_log_node::Mode", tags = "3")]
    pub mode: ::core::option::Option<change_log_node::Mode>,
}
/// Nested message and enum types in `ChangeLogNode`.
pub mod change_log_node {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Keyed {
        /// Input column indices in KEY but absent from distribution_keys.
        /// Compaction uses stream_keys, distribution_keys, and these columns.
        /// We retain distribution_keys in compaction for backward compatibility:
        /// older keyed plans stored the full KEY there, so this list defaults to empty.
        #[prost(uint32, repeated, tag = "1")]
        pub additional_key_columns: ::prost::alloc::vec::Vec<u32>,
    }
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Mode {
        #[prost(message, tag = "3")]
        Keyed(Keyed),
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CdcFilterNode {
    #[prost(message, optional, tag = "1")]
    pub search_condition: ::core::option::Option<super::expr::ExprNode>,
    #[prost(uint32, tag = "2", wrapper = "crate::id::SourceId")]
    pub upstream_source_id: crate::id::SourceId,
}
/// A materialized view is regarded as a table.
/// In addition, we also specify primary key to MV for efficient point lookup during update and deletion.
///
/// The node will be used for both create mv and create index.
///
/// * When creating mv, `pk == distribution_key == column_orders`.
/// * When creating index, `column_orders` will contain both
///   arrange columns and pk columns, while distribution key will be arrange columns.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MaterializeNode {
    #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
    pub table_id: crate::id::TableId,
    /// Column indexes and orders of primary key.
    #[prost(message, repeated, tag = "2")]
    pub column_orders: ::prost::alloc::vec::Vec<super::common::ColumnOrder>,
    /// Primary materialized table that stores the final result data.
    /// Purpose: This is the main table that users query against. It contains the
    /// complete materialized view results with all columns from the SELECT clause.
    /// Schema: Matches the output schema of the materialized view query
    /// PK: Determined by the stream key of the materialized view
    /// Distribution: Hash distributed by primary key columns for parallel processing
    #[prost(message, optional, tag = "3")]
    pub table: ::core::option::Option<super::catalog::Table>,
    /// Staging table for refreshable materialized views during refresh operations.
    /// Purpose: Temporary storage for collecting new/updated data during refresh.
    /// This allows atomic replacement of old data with refreshed data.
    /// Schema: Contains only the primary key columns from the main table (pk-only table)
    /// - All PK columns with same data types as main table
    /// - Same primary key definition as main table
    /// Usage: Active only during refresh operations, empty otherwise
    /// Lifecycle: Created -> populated during refresh -> merged with main table -> cleared
    #[prost(message, optional, tag = "5")]
    pub staging_table: ::core::option::Option<super::catalog::Table>,
    /// Progress tracking table for refreshable materialized views.
    /// Purpose: Tracks refresh operation progress per VirtualNode to enable fault-tolerant
    /// resumable refresh operations. Stores checkpoint information for recovery.
    /// Schema: Simplified variable-length schema (following backfill pattern):
    /// - vnode (i32): VirtualNode identifier (PK)
    /// - current_pos...: Current processing position (variable PK fields from upstream)
    /// - is_completed (bool): Whether this vnode has completed processing
    /// - processed_rows (i64): Number of rows processed so far in this vnode
    /// PK: vnode (allows efficient per-vnode progress lookup and updates)
    /// Distribution: Hash distributed by vnode for parallel progress tracking
    /// Usage: Persists across refresh operations for resumability
    /// Note: Stage info is now tracked in MaterializeExecutor memory for simplicity
    #[prost(message, optional, tag = "6")]
    pub refresh_progress_table: ::core::option::Option<super::catalog::Table>,
    /// Whether the table can clean itself by TTL watermark, i.e., is defined with `WATERMARK ... WITH TTL`.
    #[prost(bool, tag = "7")]
    pub cleaned_by_ttl_watermark: bool,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AggCallState {
    #[prost(oneof = "agg_call_state::Inner", tags = "1, 3")]
    pub inner: ::core::option::Option<agg_call_state::Inner>,
}
/// Nested message and enum types in `AggCallState`.
pub mod agg_call_state {
    /// the state is stored in the intermediate state table. used for count/sum/append-only extreme.
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct ValueState {}
    /// use the some column of the Upstream's materialization as the AggCall's state, used for extreme/string_agg/array_agg.
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MaterializedInputState {
        #[prost(message, optional, tag = "1")]
        pub table: ::core::option::Option<super::super::catalog::Table>,
        /// for constructing state table column mapping
        #[prost(uint32, repeated, tag = "2")]
        pub included_upstream_indices: ::prost::alloc::vec::Vec<u32>,
        #[prost(uint32, repeated, tag = "3")]
        pub table_value_indices: ::prost::alloc::vec::Vec<u32>,
        #[prost(message, repeated, tag = "4")]
        pub order_columns: ::prost::alloc::vec::Vec<super::super::common::ColumnOrder>,
    }
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Inner {
        #[prost(message, tag = "1")]
        ValueState(ValueState),
        #[prost(message, tag = "3")]
        MaterializedInputState(MaterializedInputState),
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SimpleAggNode {
    #[prost(message, repeated, tag = "1")]
    pub agg_calls: ::prost::alloc::vec::Vec<super::expr::AggCall>,
    #[prost(message, repeated, tag = "3")]
    pub agg_call_states: ::prost::alloc::vec::Vec<AggCallState>,
    #[prost(message, optional, tag = "4")]
    pub intermediate_state_table: ::core::option::Option<super::catalog::Table>,
    /// Whether to optimize for append only stream.
    /// It is true when the input is append-only
    #[prost(bool, tag = "5")]
    pub is_append_only: bool,
    #[prost(map = "uint32, message", tag = "6")]
    pub distinct_dedup_tables: ::std::collections::HashMap<u32, super::catalog::Table>,
    #[prost(uint32, tag = "7")]
    pub row_count_index: u32,
    #[prost(enumeration = "AggNodeVersion", tag = "8")]
    pub version: i32,
    /// Required by the downstream `RowMergeNode`,
    /// currently only used by the `approx_percentile`'s two phase plan
    #[prost(bool, tag = "9")]
    pub must_output_per_barrier: bool,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HashAggNode {
    #[prost(uint32, repeated, tag = "1")]
    pub group_key: ::prost::alloc::vec::Vec<u32>,
    #[prost(message, repeated, tag = "2")]
    pub agg_calls: ::prost::alloc::vec::Vec<super::expr::AggCall>,
    #[prost(message, repeated, tag = "3")]
    pub agg_call_states: ::prost::alloc::vec::Vec<AggCallState>,
    #[prost(message, optional, tag = "4")]
    pub intermediate_state_table: ::core::option::Option<super::catalog::Table>,
    /// Whether to optimize for append only stream.
    /// It is true when the input is append-only
    #[prost(bool, tag = "5")]
    pub is_append_only: bool,
    #[prost(map = "uint32, message", tag = "6")]
    pub distinct_dedup_tables: ::std::collections::HashMap<u32, super::catalog::Table>,
    #[prost(uint32, tag = "7")]
    pub row_count_index: u32,
    #[prost(bool, tag = "8")]
    pub emit_on_window_close: bool,
    #[prost(enumeration = "AggNodeVersion", tag = "9")]
    pub version: i32,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TopNNode {
    /// 0 means no limit as limit of 0 means this node should be optimized away
    #[prost(uint64, tag = "1")]
    pub limit: u64,
    #[prost(uint64, tag = "2")]
    pub offset: u64,
    #[prost(message, optional, tag = "3")]
    pub table: ::core::option::Option<super::catalog::Table>,
    #[prost(message, repeated, tag = "4")]
    pub order_by: ::prost::alloc::vec::Vec<super::common::ColumnOrder>,
    #[prost(bool, tag = "5")]
    pub with_ties: bool,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GroupTopNNode {
    /// 0 means no limit as limit of 0 means this node should be optimized away
    #[prost(uint64, tag = "1")]
    pub limit: u64,
    #[prost(uint64, tag = "2")]
    pub offset: u64,
    #[prost(uint32, repeated, tag = "3")]
    pub group_key: ::prost::alloc::vec::Vec<u32>,
    #[prost(message, optional, tag = "4")]
    pub table: ::core::option::Option<super::catalog::Table>,
    #[prost(message, repeated, tag = "5")]
    pub order_by: ::prost::alloc::vec::Vec<super::common::ColumnOrder>,
    #[prost(bool, tag = "6")]
    pub with_ties: bool,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeltaExpression {
    #[prost(enumeration = "super::expr::expr_node::Type", tag = "1")]
    pub delta_type: i32,
    #[prost(message, optional, tag = "2")]
    pub delta: ::core::option::Option<super::expr::ExprNode>,
}
/// Deprecated: Use InequalityPairV2 instead.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InequalityPair {
    /// Input index of greater side of inequality.
    #[prost(uint32, tag = "1")]
    pub key_required_larger: u32,
    /// Input index of less side of inequality.
    #[prost(uint32, tag = "2")]
    pub key_required_smaller: u32,
    /// Whether this condition is used to clean state table of `HashJoinExecutor`.
    #[prost(bool, tag = "3")]
    pub clean_state: bool,
    /// greater >= less + delta_expression, if `None`, it represents that greater >= less
    #[prost(message, optional, tag = "4")]
    pub delta_expression: ::core::option::Option<DeltaExpression>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InequalityPairV2 {
    /// Index of the left side of the inequality (from left input).
    #[prost(uint32, tag = "1")]
    pub left_idx: u32,
    /// Index of the right side of the inequality (from right input, NOT offset by left_cols_num).
    #[prost(uint32, tag = "2")]
    pub right_idx: u32,
    /// Whether this condition is used to clean left state table of `HashJoinExecutor`.
    #[prost(bool, tag = "3")]
    pub clean_left_state: bool,
    /// Whether this condition is used to clean right state table of `HashJoinExecutor`.
    #[prost(bool, tag = "4")]
    pub clean_right_state: bool,
    /// Comparison operator: left_col `<op>` right_col (e.g., \<, \<=, >, >=).
    #[prost(enumeration = "InequalityType", tag = "5")]
    pub op: i32,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct JoinKeyWatermarkIndex {
    /// Index in `left_key`/`right_key`.
    #[prost(uint32, tag = "1")]
    pub index: u32,
    /// Whether watermark on this join key triggers state cleaning of the counterpart.
    #[prost(bool, tag = "2")]
    pub do_state_cleaning: bool,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HashJoinWatermarkHandleDesc {
    /// Join-key positions whose watermarks should be aligned across both sides.
    #[prost(message, repeated, tag = "1")]
    pub watermark_indices_in_jk: ::prost::alloc::vec::Vec<JoinKeyWatermarkIndex>,
    /// Inequality pairs used for watermark generation / state cleaning.
    #[prost(message, repeated, tag = "2")]
    pub inequality_pairs: ::prost::alloc::vec::Vec<InequalityPairV2>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HashJoinNode {
    #[prost(enumeration = "super::plan_common::JoinType", tag = "1")]
    pub join_type: i32,
    #[prost(int32, repeated, tag = "2")]
    pub left_key: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, tag = "3")]
    pub right_key: ::prost::alloc::vec::Vec<i32>,
    #[prost(message, optional, tag = "4")]
    pub condition: ::core::option::Option<super::expr::ExprNode>,
    /// Used for internal table states.
    #[prost(message, optional, tag = "6")]
    pub left_table: ::core::option::Option<super::catalog::Table>,
    /// Used for internal table states.
    #[prost(message, optional, tag = "7")]
    pub right_table: ::core::option::Option<super::catalog::Table>,
    /// Used for internal table states.
    #[prost(message, optional, tag = "8")]
    pub left_degree_table: ::core::option::Option<super::catalog::Table>,
    /// Used for internal table states.
    #[prost(message, optional, tag = "9")]
    pub right_degree_table: ::core::option::Option<super::catalog::Table>,
    /// The output indices of current node
    #[prost(uint32, repeated, tag = "10")]
    pub output_indices: ::prost::alloc::vec::Vec<u32>,
    /// Left deduped input pk indices. The pk of the left_table and
    /// left_degree_table is  \[left_join_key | left_deduped_input_pk_indices\]
    /// and is expected to be the shortest key which starts with
    /// the join key and satisfies unique constrain.
    #[prost(uint32, repeated, tag = "11")]
    pub left_deduped_input_pk_indices: ::prost::alloc::vec::Vec<u32>,
    /// Right deduped input pk indices. The pk of the right_table and
    /// right_degree_table is  \[right_join_key | right_deduped_input_pk_indices\]
    /// and is expected to be the shortest key which starts with
    /// the join key and satisfies unique constrain.
    #[prost(uint32, repeated, tag = "12")]
    pub right_deduped_input_pk_indices: ::prost::alloc::vec::Vec<u32>,
    #[prost(bool, repeated, tag = "13")]
    pub null_safe: ::prost::alloc::vec::Vec<bool>,
    /// Whether to optimize for append only stream.
    /// It is true when the input is append-only
    #[prost(bool, tag = "14")]
    pub is_append_only: bool,
    /// Which encoding will be used to encode join rows in operator cache.
    /// Deprecated. Use the one from `StreamingDeveloperConfig` instead.
    #[deprecated]
    #[prost(enumeration = "JoinEncodingType", tag = "15")]
    pub join_encoding_type: i32,
    /// Description of watermark-based and other state cleaning strategies.
    #[prost(message, optional, tag = "17")]
    pub watermark_handle_desc: ::core::option::Option<HashJoinWatermarkHandleDesc>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AsOfJoinNode {
    #[prost(enumeration = "super::plan_common::AsOfJoinType", tag = "1")]
    pub join_type: i32,
    #[prost(int32, repeated, tag = "2")]
    pub left_key: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, tag = "3")]
    pub right_key: ::prost::alloc::vec::Vec<i32>,
    /// Used for internal table states.
    #[prost(message, optional, tag = "4")]
    pub left_table: ::core::option::Option<super::catalog::Table>,
    /// Used for internal table states.
    #[prost(message, optional, tag = "5")]
    pub right_table: ::core::option::Option<super::catalog::Table>,
    /// The output indices of current node
    #[prost(uint32, repeated, tag = "6")]
    pub output_indices: ::prost::alloc::vec::Vec<u32>,
    /// Left deduped input pk indices. The pk of the left_table and
    /// The pk of the left_table is  \[left_join_key | left_inequality_key | left_deduped_input_pk_indices\]
    /// left_inequality_key is not used but for forward compatibility.
    #[prost(uint32, repeated, tag = "7")]
    pub left_deduped_input_pk_indices: ::prost::alloc::vec::Vec<u32>,
    /// Right deduped input pk indices.
    /// The pk of the right_table is  \[right_join_key | right_inequality_key | right_deduped_input_pk_indices\]
    /// right_inequality_key is not used but for forward compatibility.
    #[prost(uint32, repeated, tag = "8")]
    pub right_deduped_input_pk_indices: ::prost::alloc::vec::Vec<u32>,
    #[prost(bool, repeated, tag = "9")]
    pub null_safe: ::prost::alloc::vec::Vec<bool>,
    #[prost(message, optional, tag = "10")]
    pub asof_desc: ::core::option::Option<super::plan_common::AsOfJoinDesc>,
    /// Which encoding will be used to encode join rows in operator cache.
    /// Deprecated. Use the one from `StreamingDeveloperConfig` instead.
    #[deprecated]
    #[prost(enumeration = "JoinEncodingType", tag = "11")]
    pub join_encoding_type: i32,
    /// Whether to use the cache-based implementation (true) or the no-cache implementation (false).
    /// Controlled by session variable `streaming_asof_join_use_cache`.
    /// Optional so that legacy plans (without this field) default to true (cache-based).
    #[prost(bool, optional, tag = "12")]
    pub use_cache: ::core::option::Option<bool>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TemporalJoinNode {
    #[prost(enumeration = "super::plan_common::JoinType", tag = "1")]
    pub join_type: i32,
    #[prost(int32, repeated, tag = "2")]
    pub left_key: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, tag = "3")]
    pub right_key: ::prost::alloc::vec::Vec<i32>,
    #[prost(bool, repeated, tag = "4")]
    pub null_safe: ::prost::alloc::vec::Vec<bool>,
    #[prost(message, optional, tag = "5")]
    pub condition: ::core::option::Option<super::expr::ExprNode>,
    /// The output indices of current node
    #[prost(uint32, repeated, tag = "6")]
    pub output_indices: ::prost::alloc::vec::Vec<u32>,
    /// The table desc of the lookup side table.
    #[prost(message, optional, tag = "7")]
    pub table_desc: ::core::option::Option<super::plan_common::StorageTableDesc>,
    /// The output indices of the lookup side table
    #[prost(uint32, repeated, tag = "8")]
    pub table_output_indices: ::prost::alloc::vec::Vec<u32>,
    /// The state table used for non-append-only temporal join.
    #[prost(message, optional, tag = "9")]
    pub memo_table: ::core::option::Option<super::catalog::Table>,
    /// If it is a nested lool temporal join
    #[prost(bool, tag = "10")]
    pub is_nested_loop: bool,
    /// Whether lookup-side changes are broadcast to every temporal join actor.
    #[prost(bool, tag = "11")]
    pub is_broadcast: bool,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DynamicFilterNode {
    #[prost(uint32, tag = "1")]
    pub left_key: u32,
    /// Must be one of \<, \<=, >, >=
    #[prost(message, optional, tag = "2")]
    pub condition: ::core::option::Option<super::expr::ExprNode>,
    /// Left table stores all states with predicate possibly not NULL.
    #[prost(message, optional, tag = "3")]
    pub left_table: ::core::option::Option<super::catalog::Table>,
    /// Right table stores single value from RHS of predicate.
    #[prost(message, optional, tag = "4")]
    pub right_table: ::core::option::Option<super::catalog::Table>,
    /// If the right side's change always make the condition more relaxed.
    /// In other words, make more record in the left side satisfy the condition.
    /// If this is true, we need to store LHS records which do not match the condition in the internal table.
    /// When the condition changes, we will tell downstream to insert the LHS records which now match the condition.
    /// If this is false, we need to store RHS records which match the condition in the internal table.
    /// When the condition changes, we will tell downstream to delete the LHS records which now no longer match the condition.
    #[deprecated]
    #[prost(bool, tag = "5")]
    pub condition_always_relax: bool,
    /// Whether the dynamic filter can clean its left state table by watermark.
    #[prost(bool, tag = "6")]
    pub cleaned_by_watermark: bool,
}
/// Delta join with two indexes. This is a pseudo plan node generated on frontend. On meta
/// service, it will be rewritten into lookup joins.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeltaIndexJoinNode {
    #[prost(enumeration = "super::plan_common::JoinType", tag = "1")]
    pub join_type: i32,
    #[prost(int32, repeated, tag = "2")]
    pub left_key: ::prost::alloc::vec::Vec<i32>,
    #[prost(int32, repeated, tag = "3")]
    pub right_key: ::prost::alloc::vec::Vec<i32>,
    #[prost(message, optional, tag = "4")]
    pub condition: ::core::option::Option<super::expr::ExprNode>,
    /// Table id of the left index.
    #[prost(uint32, tag = "7", wrapper = "crate::id::TableId")]
    pub left_table_id: crate::id::TableId,
    /// Table id of the right index.
    #[prost(uint32, tag = "8", wrapper = "crate::id::TableId")]
    pub right_table_id: crate::id::TableId,
    /// Info about the left index
    #[prost(message, optional, tag = "9")]
    pub left_info: ::core::option::Option<ArrangementInfo>,
    /// Info about the right index
    #[prost(message, optional, tag = "10")]
    pub right_info: ::core::option::Option<ArrangementInfo>,
    /// the output indices of current node
    #[prost(uint32, repeated, tag = "11")]
    pub output_indices: ::prost::alloc::vec::Vec<u32>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HopWindowNode {
    #[prost(uint32, tag = "1")]
    pub time_col: u32,
    #[prost(message, optional, tag = "2")]
    pub window_slide: ::core::option::Option<super::data::Interval>,
    #[prost(message, optional, tag = "3")]
    pub window_size: ::core::option::Option<super::data::Interval>,
    #[prost(uint32, repeated, tag = "4")]
    pub output_indices: ::prost::alloc::vec::Vec<u32>,
    #[prost(message, repeated, tag = "5")]
    pub window_start_exprs: ::prost::alloc::vec::Vec<super::expr::ExprNode>,
    #[prost(message, repeated, tag = "6")]
    pub window_end_exprs: ::prost::alloc::vec::Vec<super::expr::ExprNode>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MergeNode {
    /// **WARNING**: Use this field with caution.
    ///
    /// `upstream_actor_id` stored in the plan node in `Fragment` meta model cannot be directly used.
    /// See `compose_fragment`.
    /// The field is deprecated because the upstream actor info is provided separately instead of
    /// injected here in the node.
    #[deprecated]
    #[prost(uint32, repeated, packed = "false", tag = "1")]
    pub upstream_actor_id: ::prost::alloc::vec::Vec<u32>,
    #[prost(uint32, tag = "2", wrapper = "crate::id::FragmentId")]
    pub upstream_fragment_id: crate::id::FragmentId,
    /// Type of the upstream dispatcher. If there's always one upstream according to this
    /// type, the compute node may use the `ReceiverExecutor` as an optimization.
    #[prost(enumeration = "DispatcherType", tag = "3")]
    pub upstream_dispatcher_type: i32,
    /// The schema of input columns. Already deprecated.
    #[deprecated]
    #[prost(message, repeated, tag = "4")]
    pub fields: ::prost::alloc::vec::Vec<super::plan_common::Field>,
    /// Deprecated. Executors that need to support an empty upstream use an explicit runtime
    /// constructor instead.
    #[deprecated]
    #[prost(bool, tag = "5")]
    pub allow_empty_upstream: bool,
}
/// passed from frontend to meta, used by fragmenter to generate `MergeNode`
/// and maybe `DispatcherNode` later.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExchangeNode {
    #[prost(message, optional, tag = "1")]
    pub strategy: ::core::option::Option<DispatchStrategy>,
}
/// StreamScanNode reads data from upstream table first, and then pass all events to downstream.
/// It always these 2 inputs in the following order:
///
/// 1. A MergeNode (as a placeholder) of upstream.
/// 1. A BatchPlanNode for the snapshot read.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamScanNode {
    #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
    pub table_id: crate::id::TableId,
    /// The columns from the upstream table that'll be internally required by this stream scan node.
    ///
    /// * For non-backfill stream scan node, it's the same as the output columns.
    /// * For backfill stream scan node, there're additionally primary key columns.
    #[prost(int32, repeated, tag = "2")]
    pub upstream_column_ids: ::prost::alloc::vec::Vec<i32>,
    /// The columns to be output by this stream scan node. The index is based on the internal required columns.
    ///
    /// * For non-backfill stream scan node, it's simply all the columns.
    /// * For backfill stream scan node, this strips the primary key columns if they're unnecessary.
    #[prost(uint32, repeated, tag = "3")]
    pub output_indices: ::prost::alloc::vec::Vec<u32>,
    /// Generally, the barrier needs to be rearranged during the MV creation process, so that data can
    /// be flushed to shared buffer periodically, instead of making the first epoch from batch query extra
    /// large. However, in some cases, e.g., shared state, the barrier cannot be rearranged in StreamScanNode.
    /// StreamScanType is used to decide which implementation for the StreamScanNode.
    #[prost(enumeration = "StreamScanType", tag = "4")]
    pub stream_scan_type: i32,
    /// / The state table used by Backfill operator for persisting internal state
    #[prost(message, optional, tag = "5")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    /// The upstream materialized view info used by backfill.
    /// Used iff `ChainType::Backfill`.
    #[prost(message, optional, tag = "7")]
    pub table_desc: ::core::option::Option<super::plan_common::StorageTableDesc>,
    /// The backfill rate limit for the stream scan node.
    #[prost(uint32, optional, tag = "8")]
    pub rate_limit: ::core::option::Option<u32>,
    /// Snapshot read every N barriers
    #[deprecated]
    #[prost(uint32, tag = "9")]
    pub snapshot_read_barrier_interval: u32,
    /// The state table used by ArrangementBackfill to replicate upstream mview's state table.
    /// Used iff `ChainType::ArrangementBackfill`.
    #[prost(message, optional, tag = "10")]
    pub arrangement_table: ::core::option::Option<super::catalog::Table>,
    #[prost(uint64, optional, tag = "11")]
    pub snapshot_backfill_epoch: ::core::option::Option<u64>,
    /// Full scan range pushdown (eq_conds + range bounds on PK).
    #[prost(message, optional, tag = "13")]
    pub pk_scan_range: ::core::option::Option<super::batch_plan::ScanRange>,
}
/// Config options for CDC backfill
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StreamCdcScanOptions {
    /// Whether skip the backfill and only consume from upstream.
    #[prost(bool, tag = "1")]
    pub disable_backfill: bool,
    #[prost(uint32, tag = "2")]
    pub snapshot_barrier_interval: u32,
    #[prost(uint32, tag = "3")]
    pub snapshot_batch_size: u32,
    #[prost(uint32, tag = "4")]
    pub backfill_parallelism: u32,
    #[prost(uint64, tag = "5")]
    pub backfill_num_rows_per_split: u64,
    #[prost(bool, tag = "6")]
    pub backfill_as_even_splits: bool,
    #[prost(uint32, tag = "7")]
    pub backfill_split_pk_column_index: u32,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamCdcScanNode {
    #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
    pub table_id: crate::id::TableId,
    /// The columns from the upstream table that'll be internally required by this stream scan node.
    /// Contains Primary Keys and Output columns.
    #[prost(int32, repeated, tag = "2")]
    pub upstream_column_ids: ::prost::alloc::vec::Vec<i32>,
    /// Strips the primary key columns if they're unnecessary.
    #[prost(uint32, repeated, tag = "3")]
    pub output_indices: ::prost::alloc::vec::Vec<u32>,
    /// The state table used by CdcBackfill operator for persisting internal state
    #[prost(message, optional, tag = "4")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    /// The external table that will be backfilled for CDC.
    #[prost(message, optional, tag = "5")]
    pub cdc_table_desc: ::core::option::Option<super::plan_common::ExternalTableDesc>,
    /// The backfill rate limit for the stream cdc scan node.
    #[prost(uint32, optional, tag = "6")]
    pub rate_limit: ::core::option::Option<u32>,
    /// Whether skip the backfill and only consume from upstream.
    /// keep it for backward compatibility, new stream plan will use `options.disable_backfill`
    #[prost(bool, tag = "7")]
    pub disable_backfill: bool,
    #[prost(message, optional, tag = "8")]
    pub options: ::core::option::Option<StreamCdcScanOptions>,
}
/// BatchPlanNode is used for mv on mv snapshot read.
/// BatchPlanNode is supposed to carry a batch plan that can be optimized with the streaming plan_common.
/// Currently, streaming to batch push down is not yet supported, BatchPlanNode is simply a table scan.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchPlanNode {
    #[prost(message, optional, tag = "1")]
    pub table_desc: ::core::option::Option<super::plan_common::StorageTableDesc>,
    #[prost(int32, repeated, tag = "2")]
    pub column_ids: ::prost::alloc::vec::Vec<i32>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArrangementInfo {
    /// Order key of the arrangement, including order by columns and pk from the materialize
    /// executor.
    #[prost(message, repeated, tag = "1")]
    pub arrange_key_orders: ::prost::alloc::vec::Vec<super::common::ColumnOrder>,
    /// Column descs of the arrangement
    #[prost(message, repeated, tag = "2")]
    pub column_descs: ::prost::alloc::vec::Vec<super::plan_common::ColumnDesc>,
    /// Used to build storage table by stream lookup join of delta join.
    #[prost(message, optional, tag = "4")]
    pub table_desc: ::core::option::Option<super::plan_common::StorageTableDesc>,
    /// Output index columns
    #[prost(uint32, repeated, tag = "5")]
    pub output_col_idx: ::prost::alloc::vec::Vec<u32>,
}
/// Special node for shared state, which will only be produced in fragmenter. ArrangeNode will
/// produce a special Materialize executor, which materializes data for downstream to query.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArrangeNode {
    /// Info about the arrangement
    #[prost(message, optional, tag = "1")]
    pub table_info: ::core::option::Option<ArrangementInfo>,
    /// Hash key of the materialize node, which is a subset of pk.
    #[prost(uint32, repeated, tag = "2")]
    pub distribution_key: ::prost::alloc::vec::Vec<u32>,
    /// Used for internal table states.
    #[prost(message, optional, tag = "3")]
    pub table: ::core::option::Option<super::catalog::Table>,
}
/// Special node for shared state. LookupNode will join an arrangement with a stream.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LookupNode {
    /// Join key of the arrangement side
    #[prost(int32, repeated, tag = "1")]
    pub arrange_key: ::prost::alloc::vec::Vec<i32>,
    /// Join key of the stream side
    #[prost(int32, repeated, tag = "2")]
    pub stream_key: ::prost::alloc::vec::Vec<i32>,
    /// Whether to join the current epoch of arrangement
    #[prost(bool, tag = "3")]
    pub use_current_epoch: bool,
    /// Sometimes we need to re-order the output data to meet the requirement of schema.
    /// By default, lookup executor will produce `<arrangement side, stream side>`. We
    /// will then apply the column mapping to the combined result.
    #[prost(int32, repeated, tag = "4")]
    pub column_mapping: ::prost::alloc::vec::Vec<i32>,
    /// Info about the arrangement
    #[prost(message, optional, tag = "7")]
    pub arrangement_table_info: ::core::option::Option<ArrangementInfo>,
    #[prost(oneof = "lookup_node::ArrangementTableId", tags = "5, 6")]
    pub arrangement_table_id: ::core::option::Option<lookup_node::ArrangementTableId>,
}
/// Nested message and enum types in `LookupNode`.
pub mod lookup_node {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum ArrangementTableId {
        /// Table Id of the arrangement (when created along with join plan)
        #[prost(uint32, tag = "5", wrapper = "crate::id::TableId")]
        TableId(crate::id::TableId),
        /// Table Id of the arrangement (when using index)
        #[prost(uint32, tag = "6", wrapper = "crate::id::TableId")]
        IndexId(crate::id::TableId),
    }
}
/// WatermarkFilter needs to filter the upstream data by the water mark.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct WatermarkFilterNode {
    /// The watermark descs
    #[prost(message, repeated, tag = "1")]
    pub watermark_descs: ::prost::alloc::vec::Vec<super::catalog::WatermarkDesc>,
    /// The tables used to persist watermarks, the key is vnode.
    #[prost(message, repeated, tag = "2")]
    pub tables: ::prost::alloc::vec::Vec<super::catalog::Table>,
}
/// Acts like a merger, but on different inputs.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UnionNode {}
/// Special node for shared state. Merge and align barrier from upstreams. Pipe inputs in order.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LookupUnionNode {
    #[prost(uint32, repeated, tag = "1")]
    pub order: ::prost::alloc::vec::Vec<u32>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExpandNode {
    #[prost(message, repeated, tag = "1")]
    pub column_subsets: ::prost::alloc::vec::Vec<expand_node::Subset>,
}
/// Nested message and enum types in `ExpandNode`.
pub mod expand_node {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Subset {
        #[prost(uint32, repeated, tag = "1")]
        pub column_indices: ::prost::alloc::vec::Vec<u32>,
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProjectSetNode {
    #[prost(message, repeated, tag = "1")]
    pub select_list: ::prost::alloc::vec::Vec<super::expr::ProjectSetSelectItem>,
    /// this two field is expressing a list of usize pair, which means when project receives a
    /// watermark with `watermark_input_cols\[i\]` column index, it should derive a new watermark
    /// with `watermark_output_cols\[i\]`th expression
    #[prost(uint32, repeated, tag = "2")]
    pub watermark_input_cols: ::prost::alloc::vec::Vec<u32>,
    #[prost(uint32, repeated, tag = "3")]
    pub watermark_expr_indices: ::prost::alloc::vec::Vec<u32>,
    #[prost(uint32, repeated, tag = "4")]
    pub nondecreasing_exprs: ::prost::alloc::vec::Vec<u32>,
}
/// Sorts inputs and outputs ordered data based on watermark.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SortNode {
    /// Persists data above watermark.
    #[prost(message, optional, tag = "1")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    /// Column index of watermark to perform sorting.
    #[prost(uint32, tag = "2")]
    pub sort_column_index: u32,
}
/// Merges two streams from streaming and batch for data manipulation.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DmlNode {
    /// Id of the table on which DML performs.
    #[prost(uint32, tag = "1", wrapper = "crate::id::TableId")]
    pub table_id: crate::id::TableId,
    /// Version of the table.
    #[prost(uint64, tag = "3")]
    pub table_version_id: u64,
    /// Column descriptions of the table.
    #[prost(message, repeated, tag = "2")]
    pub column_descs: ::prost::alloc::vec::Vec<super::plan_common::ColumnDesc>,
    #[prost(uint32, optional, tag = "4")]
    pub rate_limit: ::core::option::Option<u32>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RowIdGenNode {
    #[prost(uint64, tag = "1")]
    pub row_id_index: u64,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NowModeUpdateCurrent {}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NowModeGenerateSeries {
    #[prost(message, optional, tag = "1")]
    pub start_timestamp: ::core::option::Option<super::data::Datum>,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<super::data::Datum>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct NowNode {
    /// Persists emitted 'now'.
    #[prost(message, optional, tag = "1")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    #[prost(oneof = "now_node::Mode", tags = "101, 102")]
    pub mode: ::core::option::Option<now_node::Mode>,
}
/// Nested message and enum types in `NowNode`.
pub mod now_node {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Mode {
        #[prost(message, tag = "101")]
        UpdateCurrent(super::NowModeUpdateCurrent),
        #[prost(message, tag = "102")]
        GenerateSeries(super::NowModeGenerateSeries),
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ValuesNode {
    #[prost(message, repeated, tag = "1")]
    pub tuples: ::prost::alloc::vec::Vec<values_node::ExprTuple>,
    #[prost(message, repeated, tag = "2")]
    pub fields: ::prost::alloc::vec::Vec<super::plan_common::Field>,
}
/// Nested message and enum types in `ValuesNode`.
pub mod values_node {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ExprTuple {
        #[prost(message, repeated, tag = "1")]
        pub cells: ::prost::alloc::vec::Vec<super::super::expr::ExprNode>,
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DedupNode {
    #[prost(message, optional, tag = "1")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    #[prost(uint32, repeated, tag = "2")]
    pub dedup_column_indices: ::prost::alloc::vec::Vec<u32>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NoOpNode {}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EowcOverWindowNode {
    #[prost(message, repeated, tag = "1")]
    pub calls: ::prost::alloc::vec::Vec<super::expr::WindowFunction>,
    #[prost(uint32, repeated, tag = "2")]
    pub partition_by: ::prost::alloc::vec::Vec<u32>,
    /// use `repeated` in case of future extension, now only one column is allowed
    #[prost(message, repeated, tag = "3")]
    pub order_by: ::prost::alloc::vec::Vec<super::common::ColumnOrder>,
    #[prost(message, optional, tag = "4")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    /// Optional state table for persisting window function intermediate states.
    /// Used for numbering functions (row_number/rank/dense_rank), and with `watermark_trigger_table`.
    #[prost(message, optional, tag = "5")]
    pub intermediate_state_table: ::core::option::Option<super::catalog::Table>,
    /// Indexes partitions by the watermark of the order key that may close their windows. Present iff
    /// some call may be closed by watermark, in which case `intermediate_state_table` has a trailing
    /// `progress` column storing `window_function.EowcPartitionProgress`.
    #[prost(message, optional, tag = "6")]
    pub watermark_trigger_table: ::core::option::Option<super::catalog::Table>,
    #[prost(enumeration = "EowcOverWindowNodeVersion", tag = "7")]
    pub version: i32,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OverWindowNode {
    #[prost(message, repeated, tag = "1")]
    pub calls: ::prost::alloc::vec::Vec<super::expr::WindowFunction>,
    #[prost(uint32, repeated, tag = "2")]
    pub partition_by: ::prost::alloc::vec::Vec<u32>,
    #[prost(message, repeated, tag = "3")]
    pub order_by: ::prost::alloc::vec::Vec<super::common::ColumnOrder>,
    #[prost(message, optional, tag = "4")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    /// Deprecated. Use the one from `StreamingDeveloperConfig` instead.
    #[deprecated]
    #[prost(enumeration = "OverWindowCachePolicy", tag = "5")]
    pub cache_policy: i32,
    /// Whether the executor is allowed to clean up state rows in recently touched partitions that
    /// can never be accessed again, driven by the watermark on the first `order_by` column. The
    /// optimizer only enables this when the input is append-only, all window frames are bounded
    /// `ROWS` frames, and the first `order_by` column is a watermark column.
    #[prost(bool, tag = "6")]
    pub enable_state_cleaning: bool,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, ::prost::Message)]
pub struct LocalApproxPercentileNode {
    #[prost(double, tag = "1")]
    pub base: f64,
    #[prost(uint32, tag = "2")]
    pub percentile_index: u32,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GlobalApproxPercentileNode {
    #[prost(double, tag = "1")]
    pub base: f64,
    #[prost(double, tag = "2")]
    pub quantile: f64,
    #[prost(message, optional, tag = "3")]
    pub bucket_state_table: ::core::option::Option<super::catalog::Table>,
    #[prost(message, optional, tag = "4")]
    pub count_state_table: ::core::option::Option<super::catalog::Table>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RowMergeNode {
    #[prost(message, optional, tag = "1")]
    pub lhs_mapping: ::core::option::Option<super::catalog::ColIndexMapping>,
    #[prost(message, optional, tag = "2")]
    pub rhs_mapping: ::core::option::Option<super::catalog::ColIndexMapping>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SyncLogStoreNode {
    #[prost(message, optional, tag = "1")]
    pub log_store_table: ::core::option::Option<super::catalog::Table>,
    /// Deprecated. Use the one from `StreamingDeveloperConfig` instead.
    #[deprecated]
    #[prost(uint32, optional, tag = "2")]
    pub pause_duration_ms: ::core::option::Option<u32>,
    /// Deprecated. Use the one from `StreamingDeveloperConfig` instead.
    #[deprecated]
    #[prost(uint32, optional, tag = "3")]
    pub buffer_size: ::core::option::Option<u32>,
    #[prost(bool, tag = "4")]
    pub aligned: bool,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MaterializedExprsNode {
    #[prost(message, repeated, tag = "1")]
    pub exprs: ::prost::alloc::vec::Vec<super::expr::ExprNode>,
    #[prost(message, optional, tag = "2")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    #[prost(uint32, optional, tag = "3")]
    pub state_clean_col_idx: ::core::option::Option<u32>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VectorIndexWriteNode {
    #[prost(message, optional, tag = "1")]
    pub table: ::core::option::Option<super::catalog::Table>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VectorIndexLookupJoinNode {
    #[prost(message, optional, tag = "1")]
    pub reader_desc: ::core::option::Option<super::plan_common::VectorIndexReaderDesc>,
    #[prost(uint32, tag = "2")]
    pub vector_column_idx: u32,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpstreamSinkUnionNode {
    /// It is always empty in the persisted metadata, and get filled before we spawn the actors.
    /// The actual upstream info may be added and removed dynamically at runtime.
    #[prost(message, repeated, tag = "1")]
    pub init_upstreams: ::prost::alloc::vec::Vec<UpstreamSinkInfo>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LocalityProviderNode {
    /// Column indices that define locality
    #[prost(uint32, repeated, tag = "1")]
    pub locality_columns: ::prost::alloc::vec::Vec<u32>,
    /// State table for buffering input data
    #[prost(message, optional, tag = "2")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    /// Progress table for tracking backfill progress
    #[prost(message, optional, tag = "3")]
    pub progress_table: ::core::option::Option<super::catalog::Table>,
    /// Rate limit of the drain phase, set by `BACKFILL_RATE_LIMIT`.
    #[prost(uint32, optional, tag = "4")]
    pub rate_limit: ::core::option::Option<u32>,
    /// Ephemeral sorted log table for buffering and re-ordering amplified input
    /// within an epoch after backfill is finished. Only present when the sort
    /// buffer feature is enabled at plan time.
    #[prost(message, optional, tag = "5")]
    pub sort_buffer_table: ::core::option::Option<super::catalog::Table>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EowcGapFillNode {
    #[prost(uint32, tag = "1")]
    pub time_column_index: u32,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<super::expr::ExprNode>,
    #[prost(uint32, repeated, tag = "3")]
    pub fill_columns: ::prost::alloc::vec::Vec<u32>,
    #[prost(string, repeated, tag = "4")]
    pub fill_strategies: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "6")]
    pub prev_row_table: ::core::option::Option<super::catalog::Table>,
    #[prost(uint32, repeated, tag = "7")]
    pub partition_by_indices: ::prost::alloc::vec::Vec<u32>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GapFillNode {
    #[prost(uint32, tag = "1")]
    pub time_column_index: u32,
    #[prost(message, optional, tag = "2")]
    pub interval: ::core::option::Option<super::expr::ExprNode>,
    #[prost(uint32, repeated, tag = "3")]
    pub fill_columns: ::prost::alloc::vec::Vec<u32>,
    #[prost(string, repeated, tag = "4")]
    pub fill_strategies: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "5")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    #[prost(uint32, repeated, tag = "6")]
    pub partition_by_indices: ::prost::alloc::vec::Vec<u32>,
    #[prost(uint32, repeated, tag = "7")]
    pub pointer_key_indices: ::prost::alloc::vec::Vec<u32>,
}
/// SQL:2016 MATCH_RECOGNIZE (row pattern recognition). v1: append-only input,
/// ONE ROW PER MATCH. PARTITION BY / ORDER BY are input column indices.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchRecognizeNode {
    #[prost(uint32, repeated, tag = "1")]
    pub partition_by: ::prost::alloc::vec::Vec<u32>,
    /// ORDER BY keys, carried as ColumnOrder like every other ordered streaming node. v1 only supports
    /// the default ascending order (the binder rejects DESC / explicit NULLS); the executor asserts it.
    #[prost(message, repeated, tag = "2")]
    pub order_by: ::prost::alloc::vec::Vec<super::common::ColumnOrder>,
    #[prost(message, repeated, tag = "3")]
    pub measures: ::prost::alloc::vec::Vec<MatchRecognizeMeasure>,
    #[prost(message, repeated, tag = "5")]
    pub defines: ::prost::alloc::vec::Vec<MatchRecognizeDefine>,
    /// The PATTERN clause as a structured tree (the v1 subset: variables, concatenation, alternation,
    /// quantification and PERMUTE; anchors and exclusions are rejected at parse time). Field 7
    /// previously carried the pattern as text; it is now reserved.
    #[prost(message, optional, tag = "12")]
    pub pattern_node: ::core::option::Option<MatchRecognizePatternNode>,
    /// Rows referenced by live partial matches, keyed (partition..., order..., seq): the retained
    /// window the matcher re-feeds on recovery. Input arrives already ordered (see `input_mode`), so
    /// this holds only what live matches still need -- there is no out-of-order buffer here.
    #[prost(message, optional, tag = "8")]
    pub state_table: ::core::option::Option<super::catalog::Table>,
    /// AFTER MATCH SKIP strategy.
    #[prost(message, optional, tag = "9")]
    pub after_match_skip: ::core::option::Option<MatchRecognizeAfterMatchSkip>,
    /// WITHIN span check: a predicate over a synthetic `\[last_order_key, first_order_key\]` row
    /// (`InputRef(0) - InputRef(1) <= interval`). Absent when there is no WITHIN clause.
    #[prost(message, optional, tag = "11")]
    pub within: ::core::option::Option<super::expr::ExprNode>,
    /// WITHIN deadline: `first_order_key + interval` over a synthetic `\[first_order_key\]` row
    /// (`InputRef(0) + interval`). The watermark at which a partial starting at that row expires;
    /// used to wake an idle partition to evict it. Absent when there is no WITHIN clause.
    #[prost(message, optional, tag = "15")]
    pub within_deadline: ::core::option::Option<super::expr::ExprNode>,
    /// How the ordered-input requirement is satisfied. EVENT_TIME: an EowcSort upstream (same
    /// fragment) emits rows in full ORDER BY order, strictly below each forwarded watermark.
    /// PROCESSING_TIME (not yet planned): rows are matched in observed arrival order.
    #[prost(enumeration = "MatchRecognizeInputMode", tag = "16")]
    pub input_mode: i32,
}
/// A node in the structured row pattern tree, mirroring the executor-side pattern AST. Groups and
/// anchors are not represented: parenthesized groups are flattened during lowering, and anchors /
/// exclusions are rejected at planning time (not supported in v1).
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchRecognizePatternNode {
    #[prost(oneof = "match_recognize_pattern_node::Node", tags = "1, 2, 3, 4, 5")]
    pub node: ::core::option::Option<match_recognize_pattern_node::Node>,
}
/// Nested message and enum types in `MatchRecognizePatternNode`.
pub mod match_recognize_pattern_node {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Node {
        /// A pattern variable, e.g. `A`.
        #[prost(string, tag = "1")]
        Var(::prost::alloc::string::String),
        /// Concatenation, e.g. `A B C`.
        #[prost(message, tag = "2")]
        Concat(super::MatchRecognizePatternSeq),
        /// Alternation, e.g. `A | B | C`.
        #[prost(message, tag = "3")]
        Alternation(super::MatchRecognizePatternSeq),
        /// A quantified sub-pattern, e.g. `A+`.
        #[prost(message, tag = "4")]
        Quantified(::prost::alloc::boxed::Box<super::MatchRecognizeQuantifiedPattern>),
        /// `PERMUTE(a, b, ...)`.
        #[prost(message, tag = "5")]
        Permute(super::MatchRecognizePermutePattern),
    }
}
/// An ordered list of sub-patterns (the operands of a concatenation or alternation).
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchRecognizePatternSeq {
    #[prost(message, repeated, tag = "1")]
    pub patterns: ::prost::alloc::vec::Vec<MatchRecognizePatternNode>,
}
/// `PERMUTE(a, b, ...)` over the listed pattern variables.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MatchRecognizePermutePattern {
    #[prost(string, repeated, tag = "1")]
    pub vars: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// A sub-pattern with a quantifier, e.g. `A+`, `A*?`, `A{1,3}`.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchRecognizeQuantifiedPattern {
    #[prost(message, optional, boxed, tag = "1")]
    pub inner: ::core::option::Option<
        ::prost::alloc::boxed::Box<MatchRecognizePatternNode>,
    >,
    #[prost(message, optional, tag = "2")]
    pub quantifier: ::core::option::Option<MatchRecognizeQuantifier>,
    /// A trailing `?` (e.g. `A*?`) — prefer the fewest repetitions.
    #[prost(bool, tag = "3")]
    pub reluctant: bool,
}
/// A row-pattern quantifier.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MatchRecognizeQuantifier {
    #[prost(enumeration = "match_recognize_quantifier::Kind", tag = "1")]
    pub kind: i32,
    /// For RANGE: minimum repetitions (defaults to 0).
    #[prost(uint32, tag = "2")]
    pub min: u32,
    /// For RANGE: maximum repetitions; absent means unbounded.
    #[prost(uint32, optional, tag = "3")]
    pub max: ::core::option::Option<u32>,
}
/// Nested message and enum types in `MatchRecognizeQuantifier`.
pub mod match_recognize_quantifier {
    #[derive(prost_helpers::AnyPB)]
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Kind {
        Unspecified = 0,
        /// `*`
        Star = 1,
        /// `+`
        Plus = 2,
        /// `?`
        Question = 3,
        /// `{min,max}` (and its `{n}`, `{n,}`, `{,m}` forms).
        Range = 4,
    }
    impl Kind {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "KIND_UNSPECIFIED",
                Self::Star => "KIND_STAR",
                Self::Plus => "KIND_PLUS",
                Self::Question => "KIND_QUESTION",
                Self::Range => "KIND_RANGE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "KIND_UNSPECIFIED" => Some(Self::Unspecified),
                "KIND_STAR" => Some(Self::Star),
                "KIND_PLUS" => Some(Self::Plus),
                "KIND_QUESTION" => Some(Self::Question),
                "KIND_RANGE" => Some(Self::Range),
                _ => None,
            }
        }
    }
}
/// A DEFINE predicate. The condition is evaluated, per candidate row during matching, over a
/// synthetic row whose i-th column is produced by slots\[i\] from the candidate row, its physical
/// neighbours, and the in-progress match's labels.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchRecognizeDefine {
    #[prost(string, tag = "1")]
    pub symbol: ::prost::alloc::string::String,
    /// Predicate over the synthetic slot row: an InputRef(i) reads slots\[i\].
    #[prost(message, optional, tag = "2")]
    pub condition: ::core::option::Option<super::expr::ExprNode>,
    #[prost(message, repeated, tag = "3")]
    pub slots: ::prost::alloc::vec::Vec<MatchRecognizeDefineSlot>,
}
/// The AFTER MATCH SKIP clause: where the scan resumes after an emitted match.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MatchRecognizeAfterMatchSkip {
    #[prost(enumeration = "match_recognize_after_match_skip::Mode", tag = "1")]
    pub mode: i32,
    /// Target pattern variable, for TO_FIRST / TO_LAST only.
    #[prost(string, optional, tag = "2")]
    pub target: ::core::option::Option<::prost::alloc::string::String>,
}
/// Nested message and enum types in `MatchRecognizeAfterMatchSkip`.
pub mod match_recognize_after_match_skip {
    #[derive(prost_helpers::AnyPB)]
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Mode {
        Unspecified = 0,
        /// Resume past the match's last row (the default).
        PastLastRow = 1,
        /// Resume at the row after the match's first row.
        ToNextRow = 2,
        /// Resume at the first / last row bound to `target` within the match.
        ToFirst = 3,
        ToLast = 4,
    }
    impl Mode {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "MODE_UNSPECIFIED",
                Self::PastLastRow => "MODE_PAST_LAST_ROW",
                Self::ToNextRow => "MODE_TO_NEXT_ROW",
                Self::ToFirst => "MODE_TO_FIRST",
                Self::ToLast => "MODE_TO_LAST",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "MODE_UNSPECIFIED" => Some(Self::Unspecified),
                "MODE_PAST_LAST_ROW" => Some(Self::PastLastRow),
                "MODE_TO_NEXT_ROW" => Some(Self::ToNextRow),
                "MODE_TO_FIRST" => Some(Self::ToFirst),
                "MODE_TO_LAST" => Some(Self::ToLast),
                _ => None,
            }
        }
    }
}
/// One input a DEFINE predicate reads.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct MatchRecognizeDefineSlot {
    #[prost(enumeration = "match_recognize_define_slot::Kind", tag = "1")]
    pub kind: i32,
    #[prost(string, repeated, tag = "2")]
    pub vars: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(uint32, tag = "3")]
    pub col_idx: u32,
    #[prost(uint32, tag = "4")]
    pub offset: u32,
}
/// Nested message and enum types in `MatchRecognizeDefineSlot`.
pub mod match_recognize_define_slot {
    #[derive(prost_helpers::AnyPB)]
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Kind {
        Unspecified = 0,
        /// The candidate row's own column.
        SelfCol = 1,
        /// PREV(col, offset) / NEXT(col, offset): a physical-offset row's column.
        Prev = 2,
        Next = 3,
        /// FIRST(var.col) / LAST(var.col): RUNNING navigation — the first / last row of the match so
        /// far that belongs to `vars`. The candidate row belongs to `vars` whenever `vars` contains the
        /// variable being defined: its label is still tentative, so it is not yet among the match's
        /// labels, but the standard counts it (a `var.col` reference *is* RUNNING LAST of that column).
        RunningFirst = 4,
        RunningLast = 5,
    }
    impl Kind {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "KIND_UNSPECIFIED",
                Self::SelfCol => "KIND_SELF_COL",
                Self::Prev => "KIND_PREV",
                Self::Next => "KIND_NEXT",
                Self::RunningFirst => "KIND_RUNNING_FIRST",
                Self::RunningLast => "KIND_RUNNING_LAST",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "KIND_UNSPECIFIED" => Some(Self::Unspecified),
                "KIND_SELF_COL" => Some(Self::SelfCol),
                "KIND_PREV" => Some(Self::Prev),
                "KIND_NEXT" => Some(Self::Next),
                "KIND_RUNNING_FIRST" => Some(Self::RunningFirst),
                "KIND_RUNNING_LAST" => Some(Self::RunningLast),
                _ => None,
            }
        }
    }
}
/// One MEASURES item. The expression is evaluated over a synthetic per-match row whose i-th column is
/// produced by `slots\[i\]`; the executor materializes that row once the match and its per-row pattern
/// variable labels are known.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchRecognizeMeasure {
    /// Expression over the synthetic row: an InputRef(i) reads slots\[i\].
    #[prost(message, optional, tag = "1")]
    pub expr: ::core::option::Option<super::expr::ExprNode>,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "3")]
    pub slots: ::prost::alloc::vec::Vec<MatchRecognizeMeasureSlot>,
}
/// One navigation input of a measure expression.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MatchRecognizeMeasureSlot {
    #[prost(enumeration = "match_recognize_measure_slot::Kind", tag = "1")]
    pub kind: i32,
    /// The pattern variables this slot navigates over: one for a plain variable, several for a SUBSET
    /// union variable. Empty for CLASSIFIER. A row matches if its label is any of these.
    #[prost(string, repeated, tag = "2")]
    pub vars: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(uint32, tag = "3")]
    pub col_idx: u32,
    #[prost(message, optional, tag = "4")]
    pub data_type: ::core::option::Option<super::data::DataType>,
    /// The aggregate to run for KIND_SUM, over a single input column (the projected `col_idx`) of
    /// the rows labeled by `vars`. Its single arg is an InputRef to column 0.
    #[prost(message, optional, tag = "5")]
    pub agg_call: ::core::option::Option<super::expr::AggCall>,
}
/// Nested message and enum types in `MatchRecognizeMeasureSlot`.
pub mod match_recognize_measure_slot {
    #[derive(prost_helpers::AnyPB)]
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Kind {
        Unspecified = 0,
        /// LAST(var.col): column value of the last row labeled `var` in the match (also the meaning of
        /// a bare `var.col` under ONE ROW PER MATCH FINAL semantics).
        Last = 1,
        /// FIRST(var.col): column value of the first such row.
        First = 2,
        /// CLASSIFIER(): the pattern variable bound to the match's last row (`var`/`col_idx` unused).
        Classifier = 3,
        /// COUNT(\*): number of rows in the match (`var`/`col_idx` unused).
        CountStar = 4,
        /// COUNT(var.col): number of rows labeled `var` whose `col` is non-null.
        Count = 5,
        /// MIN(var.col) / MAX(var.col): min / max of `col` over rows labeled `var`.
        Min = 6,
        Max = 7,
        /// SUM(var.col): evaluated by `agg_call` over the rows labeled `var`. (AVG is lowered by the
        /// planner into a SUM slot plus a COUNT slot and a division expression.)
        Sum = 8,
    }
    impl Kind {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Unspecified => "KIND_UNSPECIFIED",
                Self::Last => "KIND_LAST",
                Self::First => "KIND_FIRST",
                Self::Classifier => "KIND_CLASSIFIER",
                Self::CountStar => "KIND_COUNT_STAR",
                Self::Count => "KIND_COUNT",
                Self::Min => "KIND_MIN",
                Self::Max => "KIND_MAX",
                Self::Sum => "KIND_SUM",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "KIND_UNSPECIFIED" => Some(Self::Unspecified),
                "KIND_LAST" => Some(Self::Last),
                "KIND_FIRST" => Some(Self::First),
                "KIND_CLASSIFIER" => Some(Self::Classifier),
                "KIND_COUNT_STAR" => Some(Self::CountStar),
                "KIND_COUNT" => Some(Self::Count),
                "KIND_MIN" => Some(Self::Min),
                "KIND_MAX" => Some(Self::Max),
                "KIND_SUM" => Some(Self::Sum),
                _ => None,
            }
        }
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamNode {
    /// The id for the operator. This is local per mview.
    /// TODO: should better be a uint32.
    #[prost(uint64, tag = "1", wrapper = "crate::id::StreamNodeLocalOperatorId")]
    pub operator_id: crate::id::StreamNodeLocalOperatorId,
    /// Child node in plan aka. upstream nodes in the streaming DAG
    #[prost(message, repeated, tag = "3")]
    pub input: ::prost::alloc::vec::Vec<StreamNode>,
    #[prost(uint32, repeated, tag = "2")]
    pub stream_key: ::prost::alloc::vec::Vec<u32>,
    #[prost(enumeration = "stream_node::StreamKind", tag = "24")]
    pub stream_kind: i32,
    #[prost(string, tag = "18")]
    pub identity: ::prost::alloc::string::String,
    /// The schema of the plan node
    #[prost(message, repeated, tag = "19")]
    pub fields: ::prost::alloc::vec::Vec<super::plan_common::Field>,
    #[prost(
        oneof = "stream_node::NodeBody",
        tags = "100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159"
    )]
    pub node_body: ::core::option::Option<stream_node::NodeBody>,
}
/// Nested message and enum types in `StreamNode`.
pub mod stream_node {
    /// This field used to be a `bool append_only`.
    /// Enum variants are ordered for backwards compatibility.
    #[derive(prost_helpers::AnyPB)]
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum StreamKind {
        /// buf:lint:ignore ENUM_ZERO_VALUE_SUFFIX
        Retract = 0,
        AppendOnly = 1,
        Upsert = 2,
    }
    impl StreamKind {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Self::Retract => "STREAM_KIND_RETRACT",
                Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
                Self::Upsert => "STREAM_KIND_UPSERT",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STREAM_KIND_RETRACT" => Some(Self::Retract),
                "STREAM_KIND_APPEND_ONLY" => Some(Self::AppendOnly),
                "STREAM_KIND_UPSERT" => Some(Self::Upsert),
                _ => None,
            }
        }
    }
    #[derive(prost_helpers::AnyPB)]
    #[derive(::enum_as_inner::EnumAsInner, ::strum::Display, ::strum::EnumDiscriminants)]
    #[derive(::prost_helpers::StreamNodeBodyVariants)]
    #[strum_discriminants(derive(::strum::Display, Hash))]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum NodeBody {
        #[prost(message, tag = "100")]
        Source(::prost::alloc::boxed::Box<super::SourceNode>),
        #[prost(message, tag = "101")]
        Project(::prost::alloc::boxed::Box<super::ProjectNode>),
        #[prost(message, tag = "102")]
        Filter(::prost::alloc::boxed::Box<super::FilterNode>),
        #[prost(message, tag = "103")]
        Materialize(::prost::alloc::boxed::Box<super::MaterializeNode>),
        #[prost(message, tag = "104")]
        StatelessSimpleAgg(::prost::alloc::boxed::Box<super::SimpleAggNode>),
        #[prost(message, tag = "105")]
        SimpleAgg(::prost::alloc::boxed::Box<super::SimpleAggNode>),
        #[prost(message, tag = "106")]
        HashAgg(::prost::alloc::boxed::Box<super::HashAggNode>),
        #[prost(message, tag = "107")]
        AppendOnlyTopN(::prost::alloc::boxed::Box<super::TopNNode>),
        #[prost(message, tag = "108")]
        HashJoin(::prost::alloc::boxed::Box<super::HashJoinNode>),
        #[prost(message, tag = "109")]
        TopN(::prost::alloc::boxed::Box<super::TopNNode>),
        #[prost(message, tag = "110")]
        HopWindow(::prost::alloc::boxed::Box<super::HopWindowNode>),
        #[prost(message, tag = "111")]
        Merge(::prost::alloc::boxed::Box<super::MergeNode>),
        #[prost(message, tag = "112")]
        Exchange(::prost::alloc::boxed::Box<super::ExchangeNode>),
        #[prost(message, tag = "113")]
        StreamScan(::prost::alloc::boxed::Box<super::StreamScanNode>),
        #[prost(message, tag = "114")]
        BatchPlan(::prost::alloc::boxed::Box<super::BatchPlanNode>),
        #[prost(message, tag = "115")]
        Lookup(::prost::alloc::boxed::Box<super::LookupNode>),
        #[prost(message, tag = "116")]
        Arrange(::prost::alloc::boxed::Box<super::ArrangeNode>),
        #[prost(message, tag = "117")]
        LookupUnion(::prost::alloc::boxed::Box<super::LookupUnionNode>),
        #[prost(message, tag = "118")]
        Union(super::UnionNode),
        #[prost(message, tag = "119")]
        DeltaIndexJoin(::prost::alloc::boxed::Box<super::DeltaIndexJoinNode>),
        #[prost(message, tag = "120")]
        Sink(::prost::alloc::boxed::Box<super::SinkNode>),
        #[prost(message, tag = "121")]
        Expand(::prost::alloc::boxed::Box<super::ExpandNode>),
        #[prost(message, tag = "122")]
        DynamicFilter(::prost::alloc::boxed::Box<super::DynamicFilterNode>),
        #[prost(message, tag = "123")]
        ProjectSet(::prost::alloc::boxed::Box<super::ProjectSetNode>),
        #[prost(message, tag = "124")]
        GroupTopN(::prost::alloc::boxed::Box<super::GroupTopNNode>),
        #[prost(message, tag = "125")]
        Sort(::prost::alloc::boxed::Box<super::SortNode>),
        #[prost(message, tag = "126")]
        WatermarkFilter(::prost::alloc::boxed::Box<super::WatermarkFilterNode>),
        #[prost(message, tag = "127")]
        Dml(::prost::alloc::boxed::Box<super::DmlNode>),
        #[prost(message, tag = "128")]
        RowIdGen(::prost::alloc::boxed::Box<super::RowIdGenNode>),
        #[prost(message, tag = "129")]
        Now(::prost::alloc::boxed::Box<super::NowNode>),
        #[prost(message, tag = "130")]
        AppendOnlyGroupTopN(::prost::alloc::boxed::Box<super::GroupTopNNode>),
        #[prost(message, tag = "131")]
        TemporalJoin(::prost::alloc::boxed::Box<super::TemporalJoinNode>),
        #[prost(message, tag = "132")]
        BarrierRecv(::prost::alloc::boxed::Box<super::BarrierRecvNode>),
        #[prost(message, tag = "133")]
        Values(::prost::alloc::boxed::Box<super::ValuesNode>),
        #[prost(message, tag = "134")]
        AppendOnlyDedup(::prost::alloc::boxed::Box<super::DedupNode>),
        #[prost(message, tag = "135")]
        NoOp(super::NoOpNode),
        #[prost(message, tag = "136")]
        EowcOverWindow(::prost::alloc::boxed::Box<super::EowcOverWindowNode>),
        #[prost(message, tag = "137")]
        OverWindow(::prost::alloc::boxed::Box<super::OverWindowNode>),
        #[prost(message, tag = "138")]
        StreamFsFetch(::prost::alloc::boxed::Box<super::StreamFsFetchNode>),
        #[prost(message, tag = "139")]
        StreamCdcScan(::prost::alloc::boxed::Box<super::StreamCdcScanNode>),
        #[prost(message, tag = "140")]
        CdcFilter(::prost::alloc::boxed::Box<super::CdcFilterNode>),
        #[prost(message, tag = "142")]
        SourceBackfill(::prost::alloc::boxed::Box<super::SourceBackfillNode>),
        #[prost(message, tag = "143")]
        Changelog(::prost::alloc::boxed::Box<super::ChangeLogNode>),
        #[prost(message, tag = "144")]
        LocalApproxPercentile(
            ::prost::alloc::boxed::Box<super::LocalApproxPercentileNode>,
        ),
        #[prost(message, tag = "145")]
        GlobalApproxPercentile(
            ::prost::alloc::boxed::Box<super::GlobalApproxPercentileNode>,
        ),
        #[prost(message, tag = "146")]
        RowMerge(::prost::alloc::boxed::Box<super::RowMergeNode>),
        #[prost(message, tag = "147")]
        AsOfJoin(::prost::alloc::boxed::Box<super::AsOfJoinNode>),
        #[prost(message, tag = "148")]
        SyncLogStore(::prost::alloc::boxed::Box<super::SyncLogStoreNode>),
        #[prost(message, tag = "149")]
        MaterializedExprs(::prost::alloc::boxed::Box<super::MaterializedExprsNode>),
        #[prost(message, tag = "150")]
        VectorIndexWrite(::prost::alloc::boxed::Box<super::VectorIndexWriteNode>),
        #[prost(message, tag = "151")]
        UpstreamSinkUnion(::prost::alloc::boxed::Box<super::UpstreamSinkUnionNode>),
        #[prost(message, tag = "152")]
        LocalityProvider(::prost::alloc::boxed::Box<super::LocalityProviderNode>),
        #[prost(message, tag = "153")]
        EowcGapFill(::prost::alloc::boxed::Box<super::EowcGapFillNode>),
        #[prost(message, tag = "154")]
        GapFill(::prost::alloc::boxed::Box<super::GapFillNode>),
        #[prost(message, tag = "155")]
        VectorIndexLookupJoin(
            ::prost::alloc::boxed::Box<super::VectorIndexLookupJoinNode>,
        ),
        #[prost(message, tag = "156")]
        IcebergWithPkIndexWriter(
            ::prost::alloc::boxed::Box<super::IcebergWithPkIndexWriterNode>,
        ),
        #[prost(message, tag = "157")]
        IcebergWithPkIndexPositionDeleteMerger(
            ::prost::alloc::boxed::Box<super::IcebergWithPkIndexPositionDeleteMergerNode>,
        ),
        #[prost(message, tag = "158")]
        MatchRecognize(::prost::alloc::boxed::Box<super::MatchRecognizeNode>),
        #[prost(message, tag = "159")]
        CompactionResolver(::prost::alloc::boxed::Box<super::CompactionResolverNode>),
    }
}
/// The method to map the upstream columns in the dispatcher before dispatching.
///
/// * For intra-job exchange, typically the upstream and downstream columns are the same. `indices`
///   will be `0..len` and `types` will be empty.
///
/// * For inter-job exchange,
///
///   * if the downstream only requires a subset of the upstream columns, `indices` will be the
///     indices of the required columns in the upstream columns.
///   * if some columns are added to the upstream, `indices` will help to maintain the same schema
///     from the view of the downstream.
///   * if some columns are altered to different (composite) types, `types` will be used to convert
///     the upstream columns to the downstream columns to maintain the same schema.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DispatchOutputMapping {
    /// Indices of the columns to output.
    #[prost(uint32, repeated, tag = "1")]
    pub indices: ::prost::alloc::vec::Vec<u32>,
    /// Besides the indices, we may also need to convert the types of some columns.
    ///
    /// * If no type conversion is needed, this field will be empty.
    /// * If type conversion is needed, this will have the same length as `indices`. Only columns with
    ///   type conversion will have `upstream` and `downstream` field set.
    #[prost(message, repeated, tag = "2")]
    pub types: ::prost::alloc::vec::Vec<dispatch_output_mapping::TypePair>,
}
/// Nested message and enum types in `DispatchOutputMapping`.
pub mod dispatch_output_mapping {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct TypePair {
        #[prost(message, optional, tag = "1")]
        pub upstream: ::core::option::Option<super::super::data::DataType>,
        #[prost(message, optional, tag = "2")]
        pub downstream: ::core::option::Option<super::super::data::DataType>,
    }
}
/// The property of an edge in the fragment graph.
/// This is essientially a "logical" version of `Dispatcher`. See the doc of `Dispatcher` for more details.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DispatchStrategy {
    #[prost(enumeration = "DispatcherType", tag = "1")]
    pub r#type: i32,
    #[prost(uint32, repeated, tag = "2")]
    pub dist_key_indices: ::prost::alloc::vec::Vec<u32>,
    #[prost(message, optional, tag = "3")]
    pub output_mapping: ::core::option::Option<DispatchOutputMapping>,
}
/// A dispatcher redistribute messages.
/// We encode both the type and other usage information in the proto.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Dispatcher {
    #[prost(enumeration = "DispatcherType", tag = "1")]
    pub r#type: i32,
    /// Indices of the columns to be used for hashing.
    /// For dispatcher types other than HASH, this is ignored.
    #[prost(uint32, repeated, tag = "2")]
    pub dist_key_indices: ::prost::alloc::vec::Vec<u32>,
    /// The method to map the upstream columns in the dispatcher before dispatching.
    #[prost(message, optional, tag = "6")]
    pub output_mapping: ::core::option::Option<DispatchOutputMapping>,
    /// The hash mapping for consistent hash.
    /// For dispatcher types other than HASH, this is ignored.
    #[prost(message, optional, tag = "3")]
    pub hash_mapping: ::core::option::Option<ActorMapping>,
    /// Dispatcher can be uniquely identified by a combination of actor id and dispatcher id.
    /// This is exactly the same as its downstream fragment id.
    #[prost(uint32, tag = "4", wrapper = "crate::id::FragmentId")]
    pub dispatcher_id: crate::id::FragmentId,
    /// Number of downstreams decides how many endpoints a dispatcher should dispatch.
    #[prost(uint32, repeated, tag = "5", wrapper = "crate::id::ActorId")]
    pub downstream_actor_id: ::prost::alloc::vec::Vec<crate::id::ActorId>,
}
/// A StreamActor is a running fragment of the overall stream graph,
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamActor {
    #[prost(uint32, tag = "1", wrapper = "crate::id::ActorId")]
    pub actor_id: crate::id::ActorId,
    #[prost(uint32, tag = "2", wrapper = "crate::id::FragmentId")]
    pub fragment_id: crate::id::FragmentId,
    #[prost(message, repeated, tag = "4")]
    pub dispatcher: ::prost::alloc::vec::Vec<Dispatcher>,
    /// Vnodes that the executors in this actor own.
    /// If the fragment is a singleton, this field will not be set and leave a `None`.
    #[prost(message, optional, tag = "8")]
    pub vnode_bitmap: ::core::option::Option<super::common::Buffer>,
    /// The SQL definition of this materialized view. Used for debugging only.
    #[prost(string, tag = "9")]
    pub mview_definition: ::prost::alloc::string::String,
    /// Provide the necessary context, e.g. session info like time zone, for the actor.
    #[prost(message, optional, tag = "10")]
    pub expr_context: ::core::option::Option<super::plan_common::ExprContext>,
    /// The config override for this actor.
    #[prost(string, tag = "11")]
    pub config_override: ::prost::alloc::string::String,
}
/// The streaming context associated with a stream plan
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StreamContext {
    /// The timezone associated with the streaming plan. Only applies to MV for now.
    #[prost(string, tag = "1")]
    pub timezone: ::prost::alloc::string::String,
    /// The partial config of this job to override the global config.
    #[prost(string, tag = "2")]
    pub config_override: ::prost::alloc::string::String,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BackfillOrder {
    #[prost(map = "uint32, message", tag = "1", wrapper = "crate::id::RelationId")]
    pub order: ::std::collections::HashMap<
        crate::id::RelationId,
        super::common::Uint32Vector,
    >,
}
/// Representation of a graph of stream fragments.
/// Generated by the fragmenter in the frontend, only used in DDL requests and never persisted.
///
/// For the persisted form, see `TableFragments`.
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StreamFragmentGraph {
    /// all the fragments in the graph.
    #[prost(map = "uint32, message", tag = "1", wrapper = "crate::id::FragmentId")]
    pub fragments: ::std::collections::HashMap<
        crate::id::FragmentId,
        stream_fragment_graph::StreamFragment,
    >,
    /// edges between fragments.
    #[prost(message, repeated, tag = "2")]
    pub edges: ::prost::alloc::vec::Vec<stream_fragment_graph::StreamFragmentEdge>,
    #[prost(uint32, repeated, tag = "3", wrapper = "crate::id::TableId")]
    pub dependent_table_ids: ::prost::alloc::vec::Vec<crate::id::TableId>,
    #[prost(uint32, tag = "4")]
    pub table_ids_cnt: u32,
    #[prost(message, optional, tag = "5")]
    pub ctx: ::core::option::Option<StreamContext>,
    /// If none, default parallelism will be applied.
    #[prost(message, optional, tag = "6")]
    pub parallelism: ::core::option::Option<stream_fragment_graph::Parallelism>,
    /// Parallelism to use during backfill. Falls back to `parallelism` if unset.
    #[prost(message, optional, tag = "9")]
    pub backfill_parallelism: ::core::option::Option<stream_fragment_graph::Parallelism>,
    /// The adaptive parallelism strategy for this streaming job, if explicitly set.
    #[prost(string, tag = "10")]
    pub adaptive_parallelism_strategy: ::prost::alloc::string::String,
    /// The adaptive parallelism strategy for the backfill override, if explicitly set.
    #[prost(string, tag = "11")]
    pub backfill_adaptive_parallelism_strategy: ::prost::alloc::string::String,
    /// Specified max parallelism, i.e., expected vnode count for the graph.
    ///
    /// The scheduler on the meta service will use this as a hint to decide the vnode count
    /// for each fragment.
    ///
    /// Note that the actual vnode count may be different from this value.
    /// For example, a no-shuffle exchange between current fragment graph and an existing
    /// upstream fragment graph requires two fragments to be in the same distribution,
    /// thus the same vnode count.
    #[prost(uint32, tag = "7")]
    pub max_parallelism: u32,
    /// The backfill order strategy for the fragments.
    #[prost(message, optional, tag = "8")]
    pub backfill_order: ::core::option::Option<BackfillOrder>,
}
/// Nested message and enum types in `StreamFragmentGraph`.
pub mod stream_fragment_graph {
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct StreamFragment {
        /// 0-based on frontend, and will be rewritten to global id on meta.
        #[prost(uint32, tag = "1", wrapper = "crate::id::FragmentId")]
        pub fragment_id: crate::id::FragmentId,
        /// root stream node in this fragment.
        #[prost(message, optional, tag = "2")]
        pub node: ::core::option::Option<super::StreamNode>,
        /// Bitwise-OR of `FragmentTypeFlag`s
        #[prost(uint32, tag = "3")]
        pub fragment_type_mask: u32,
        /// Mark whether this fragment requires exactly one actor.
        /// Note: if this is `false`, the fragment may still be a singleton according to the scheduler.
        /// One should check `meta.Fragment.distribution_type` for the final result.
        #[prost(bool, tag = "4")]
        pub requires_singleton: bool,
    }
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct StreamFragmentEdge {
        /// Dispatch strategy for the fragment.
        #[prost(message, optional, tag = "1")]
        pub dispatch_strategy: ::core::option::Option<super::DispatchStrategy>,
        /// A unique identifier of this edge. Generally it should be exchange node's operator id. When
        /// rewriting fragments into delta joins or when inserting 1-to-1 exchange, there will be
        /// virtual links generated.
        #[prost(uint64, tag = "3")]
        pub link_id: u64,
        #[prost(uint32, tag = "4", wrapper = "crate::id::FragmentId")]
        pub upstream_id: crate::id::FragmentId,
        #[prost(uint32, tag = "5", wrapper = "crate::id::FragmentId")]
        pub downstream_id: crate::id::FragmentId,
    }
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct Parallelism {
        #[prost(uint64, tag = "1")]
        pub parallelism: u64,
    }
}
/// Schema change operation for sink
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SinkSchemaChange {
    /// Original schema before this change.
    /// Used for validation and conflict detection.
    #[prost(message, repeated, tag = "1")]
    pub original_schema: ::prost::alloc::vec::Vec<super::plan_common::Field>,
    /// Schema change operation (mutually exclusive)
    #[prost(oneof = "sink_schema_change::Op", tags = "2, 3")]
    pub op: ::core::option::Option<sink_schema_change::Op>,
}
/// Nested message and enum types in `SinkSchemaChange`.
pub mod sink_schema_change {
    /// Schema change operation (mutually exclusive)
    #[derive(prost_helpers::AnyPB)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Op {
        /// Add new columns to the schema
        #[prost(message, tag = "2")]
        AddColumns(super::SinkAddColumnsOp),
        /// Drop columns from the schema
        #[prost(message, tag = "3")]
        DropColumns(super::SinkDropColumnsOp),
    }
}
/// Add columns operation
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SinkAddColumnsOp {
    /// Columns to add
    #[prost(message, repeated, tag = "1")]
    pub fields: ::prost::alloc::vec::Vec<super::plan_common::Field>,
}
/// Drop columns operation
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SinkDropColumnsOp {
    /// Column names to drop
    #[prost(string, repeated, tag = "1")]
    pub column_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum SinkLogStoreType {
    /// / Default value is the normal in memory log store to be backward compatible with the previously unset value
    Unspecified = 0,
    KvLogStore = 1,
    InMemoryLogStore = 2,
}
impl SinkLogStoreType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
            Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
            Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Some(Self::KvLogStore),
            "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Some(Self::InMemoryLogStore),
            _ => None,
        }
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(prost_helpers::Version)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum AggNodeVersion {
    Unspecified = 0,
    /// <https://github.com/risingwavelabs/risingwave/issues/12140#issuecomment-1776289808>
    Issue12140 = 1,
    /// <https://github.com/risingwavelabs/risingwave/issues/13465#issuecomment-1821016508>
    Issue13465 = 2,
}
impl AggNodeVersion {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
            Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
            Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "AGG_NODE_VERSION_UNSPECIFIED" => Some(Self::Unspecified),
            "AGG_NODE_VERSION_ISSUE_12140" => Some(Self::Issue12140),
            "AGG_NODE_VERSION_ISSUE_13465" => Some(Self::Issue13465),
            _ => None,
        }
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum InequalityType {
    Unspecified = 0,
    LessThan = 1,
    LessThanOrEqual = 2,
    GreaterThan = 3,
    GreaterThanOrEqual = 4,
}
impl InequalityType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "INEQUALITY_TYPE_UNSPECIFIED",
            Self::LessThan => "INEQUALITY_TYPE_LESS_THAN",
            Self::LessThanOrEqual => "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL",
            Self::GreaterThan => "INEQUALITY_TYPE_GREATER_THAN",
            Self::GreaterThanOrEqual => "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "INEQUALITY_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "INEQUALITY_TYPE_LESS_THAN" => Some(Self::LessThan),
            "INEQUALITY_TYPE_LESS_THAN_OR_EQUAL" => Some(Self::LessThanOrEqual),
            "INEQUALITY_TYPE_GREATER_THAN" => Some(Self::GreaterThan),
            "INEQUALITY_TYPE_GREATER_THAN_OR_EQUAL" => Some(Self::GreaterThanOrEqual),
            _ => None,
        }
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum JoinEncodingType {
    Unspecified = 0,
    MemoryOptimized = 1,
    CpuOptimized = 2,
}
impl JoinEncodingType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "UNSPECIFIED",
            Self::MemoryOptimized => "MEMORY_OPTIMIZED",
            Self::CpuOptimized => "CPU_OPTIMIZED",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "UNSPECIFIED" => Some(Self::Unspecified),
            "MEMORY_OPTIMIZED" => Some(Self::MemoryOptimized),
            "CPU_OPTIMIZED" => Some(Self::CpuOptimized),
            _ => None,
        }
    }
}
/// Decides which kind of Executor will be used
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum StreamScanType {
    Unspecified = 0,
    /// ChainExecutor. Deprecated: only for existing persisted legacy jobs.
    #[deprecated]
    Chain = 1,
    /// RearrangedChainExecutor. Deprecated: only for existing persisted legacy jobs.
    #[deprecated]
    Rearrange = 2,
    /// BackfillExecutor. Deprecated: only for existing persisted legacy jobs.
    #[deprecated]
    Backfill = 3,
    /// ChainExecutor with upstream_only = true
    UpstreamOnly = 4,
    /// ArrangementBackfillExecutor
    ArrangementBackfill = 5,
    /// SnapshotBackfillExecutor
    SnapshotBackfill = 6,
    /// SnapshotBackfillExecutor
    CrossDbSnapshotBackfill = 7,
}
impl StreamScanType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
            #[allow(deprecated)]
            Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
            #[allow(deprecated)]
            Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
            #[allow(deprecated)]
            Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
            Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
            Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
            Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
            Self::CrossDbSnapshotBackfill => {
                "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL"
            }
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "STREAM_SCAN_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "STREAM_SCAN_TYPE_CHAIN" => Some(#[allow(deprecated)] Self::Chain),
            "STREAM_SCAN_TYPE_REARRANGE" => Some(#[allow(deprecated)] Self::Rearrange),
            "STREAM_SCAN_TYPE_BACKFILL" => Some(#[allow(deprecated)] Self::Backfill),
            "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Some(Self::UpstreamOnly),
            "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Some(Self::ArrangementBackfill),
            "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Some(Self::SnapshotBackfill),
            "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => {
                Some(Self::CrossDbSnapshotBackfill)
            }
            _ => None,
        }
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(prost_helpers::Version)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum EowcOverWindowNodeVersion {
    /// Rows are output when the windows are closed by later rows, judged conservatively.
    Unspecified = 0,
    /// Rows are output once the windows are closed, by later rows or by the watermark of the order key.
    /// <https://github.com/risingwavelabs/risingwave/issues/17119>
    Issue17119 = 1,
}
impl EowcOverWindowNodeVersion {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "EOWC_OVER_WINDOW_NODE_VERSION_UNSPECIFIED",
            Self::Issue17119 => "EOWC_OVER_WINDOW_NODE_VERSION_ISSUE_17119",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "EOWC_OVER_WINDOW_NODE_VERSION_UNSPECIFIED" => Some(Self::Unspecified),
            "EOWC_OVER_WINDOW_NODE_VERSION_ISSUE_17119" => Some(Self::Issue17119),
            _ => None,
        }
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum OverWindowCachePolicy {
    Unspecified = 0,
    Full = 1,
    Recent = 2,
    RecentFirstN = 3,
    RecentLastN = 4,
}
impl OverWindowCachePolicy {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
            Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
            Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
            Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
            Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Some(Self::Unspecified),
            "OVER_WINDOW_CACHE_POLICY_FULL" => Some(Self::Full),
            "OVER_WINDOW_CACHE_POLICY_RECENT" => Some(Self::Recent),
            "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Some(Self::RecentFirstN),
            "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Some(Self::RecentLastN),
            _ => None,
        }
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum MatchRecognizeInputMode {
    Unspecified = 0,
    EventTime = 1,
    ProcessingTime = 2,
}
impl MatchRecognizeInputMode {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED",
            Self::EventTime => "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME",
            Self::ProcessingTime => "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "MATCH_RECOGNIZE_INPUT_MODE_UNSPECIFIED" => Some(Self::Unspecified),
            "MATCH_RECOGNIZE_INPUT_MODE_EVENT_TIME" => Some(Self::EventTime),
            "MATCH_RECOGNIZE_INPUT_MODE_PROCESSING_TIME" => Some(Self::ProcessingTime),
            _ => None,
        }
    }
}
#[derive(prost_helpers::AnyPB)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum DispatcherType {
    Unspecified = 0,
    /// Dispatch by hash key, hashed by consistent hash.
    Hash = 1,
    /// Broadcast to all downstreams.
    ///
    /// Note a broadcast cannot be represented as multiple simple dispatchers, since they are
    /// different when we update dispatchers during scaling.
    Broadcast = 2,
    /// Only one downstream.
    Simple = 3,
    /// A special kind of exchange that doesn't involve shuffle. The upstream actor will be directly
    /// piped into the downstream actor, if there are the same number of actors. If number of actors
    /// are not the same, should use hash instead. Should be only used when distribution is the same.
    NoShuffle = 4,
}
impl DispatcherType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
            Self::Hash => "DISPATCHER_TYPE_HASH",
            Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
            Self::Simple => "DISPATCHER_TYPE_SIMPLE",
            Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DISPATCHER_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "DISPATCHER_TYPE_HASH" => Some(Self::Hash),
            "DISPATCHER_TYPE_BROADCAST" => Some(Self::Broadcast),
            "DISPATCHER_TYPE_SIMPLE" => Some(Self::Simple),
            "DISPATCHER_TYPE_NO_SHUFFLE" => Some(Self::NoShuffle),
            _ => None,
        }
    }
}