risingwave_frontend::scheduler::distributed::query_manager

Struct DistributedQueryStream

pub struct DistributedQueryStream {
    chunk_rx: Receiver<Result<DataChunk, SchedulerError>>,
    query_id: QueryId,
    query_execution_info: Arc<RwLock<QueryExecutionInfo>>,
}

Fields§

§chunk_rx: Receiver<Result<DataChunk, SchedulerError>>§query_id: QueryId§query_execution_info: Arc<RwLock<QueryExecutionInfo>>

Implementations§

source §

Trait Implementations§

source §

impl Drop for DistributedQueryStream

source §

fn drop(&mut self)

§

fn subset( self, ) -> Result<CNil, <Choices as CoproductSubsetter<CNil, HNil>>::Remainder>

Extract a subset of the possible types in a coproduct (or get the remaining possibilities) Read more

§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.

§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source §

impl<T> IntoEither for T

source §

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

source §

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

source §

impl<T> IntoRequest<T> for T

source §

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request

§

impl<T> IntoResult<T> for T

§

fn into_result(self) -> Result<T, <T as IntoResult<T>>::Err>

§

impl<Unshared, Shared> IntoShared<Shared> for Unshared
where Shared: FromUnshared<Unshared>,

§

fn into_shared(self) -> Shared

Creates a shared type from an unshared type.

source §

impl<T> IntoStreamingRequest for T
where T: Stream + Send + 'static,

source §

type Stream = T

The RPC request stream type

source §

type Message = <T as Stream>::Item

The RPC request type

Equivalent to RelabeledMetricVec::with_metric_level_relabel_n.

source §

fn relabel_debug_1( self, relabel_threshold: MetricLevel, ) -> RelabeledMetricVec<M>

Equivalent to RelabeledMetricVec::with_metric_level_relabel_n with metric_level set to MetricLevel::Debug and relabel_num set to 1.

§

§

type Remainder = Source

§

fn sculpt(self) -> (HNil, <Source as Sculptor<HNil, HNil>>::Remainder)

Consumes the current HList and returns an HList with the requested shape. Read more

source §

impl<T> SerTo<T> for T

source §

fn ser_to(self) -> Result<T, SinkError>

§

Boxes the stream and changes its type to dyn Stream + 'a. Read more

§

§

fn ratelimit_stream<D, C, MW>( self, limiter: &'a RateLimiter<NotKeyed, D, C, MW>, ) -> RatelimitedStream<'a, S, D, C, MW>
where D: DirectStateStore, C: Clock + ReasonablyRealtime, MW: RateLimitingMiddleware<<C as Clock>::Instant>,

Limits the rate at which the stream produces items. Read more

§

fn ratelimit_stream_with_jitter<D, C, MW>( self, limiter: &'a RateLimiter<NotKeyed, D, C, MW>, jitter: Jitter, ) -> RatelimitedStream<'a, S, D, C, MW>
where D: DirectStateStore, C: Clock + ReasonablyRealtime, MW: RateLimitingMiddleware<<C as Clock>::Instant>,

Limits the rate at which the stream produces items, with a randomized wait period. Read more

§

Performs the conversion.

source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

source §

type Error = >::Error

The type returned in the event of a conversion error.

source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

§

impl<S, T, E> TryStream for S
where S: Stream<Item = Result<T, E>> + ?Sized,

§

type Ok = T

The type of successful values yielded by this future

§

type Error = E

The type of failures yielded by this future

§

fn try_poll_next( self: Pin<&mut S>, cx: &mut Context<'_>, ) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>

Poll this TryStream as if it were a Stream. Read more

§

Attempt to execute a predicate over an asynchronous stream and evaluate if any items satisfy the predicate. Exits early if an Err is encountered or if an Ok item is found that satisfies the predicate. Read more

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more

§

fn with_current_subscriber(self) -> WithDispatch<Self>

§

Struct DistributedQueryStreamCopy item path

Fields§

Implementations§

impl DistributedQueryStream

pub fn query_id(&self) -> &QueryId

Trait Implementations§

impl Drop for DistributedQueryStream

fn drop(&mut self)

impl Stream for DistributedQueryStream

type Item = Result<DataChunk, Box<dyn Error + Sync + Send>>

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

fn size_hint(&self) -> (usize, Option<usize>)

Auto Trait Implementations§

impl Freeze for DistributedQueryStream

impl !RefUnwindSafe for DistributedQueryStream

impl Send for DistributedQueryStream

impl Sync for DistributedQueryStream

impl Unpin for DistributedQueryStream

impl !UnwindSafe for DistributedQueryStream

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> Conv for T

fn conv<T>(self) -> Twhere Self: Into<T>,

impl<Choices> CoproductSubsetter<CNil, HNil> for Choices

type Remainder = Choices

fn subset( self, ) -> Result<CNil, <Choices as CoproductSubsetter<CNil, HNil>>::Remainder>

impl<T> Downcast for Twhere T: Any,

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

fn as_any(&self) -> &(dyn Any + 'static)

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

impl<T> DowncastSync for Twhere T: Any + Send + Sync,

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

impl<E, S, T> FirstAnswer<T, E> for Swhere S: Stream<Item = Result<T, E>> + Unpin, E: From<ProtoError>,

fn first_answer(self) -> FirstAnswerFuture<Self>

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self>where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>where &'a Self: for<'a> IntoIterator,

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> FutureExt for T

fn with_context(self, otel_cx: Context) -> WithContext<Self>

fn with_current_context(self) -> WithContext<Self>

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T> InstrumentStream for Twhere T: Stream,

fn instrument(self, span: Span) -> Instrumented<T>

fn instrument_with<S>(self, make_span: S) -> WithInstrumented<T, S>where S: FnMut() -> Span,

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T> IntoRequest<T> for T

fn into_request(self) -> Request<T>

impl<T> IntoResult<T> for T

type Err = Infallible

fn into_result(self) -> Result<T, <T as IntoResult<T>>::Err>

impl<Unshared, Shared> IntoShared<Shared> for Unsharedwhere Shared: FromUnshared<Unshared>,

fn into_shared(self) -> Shared

impl<T> IntoStreamingRequest for Twhere T: Stream + Send + 'static,

type Stream = T

type Message = <T as Stream>::Item

fn into_streaming_request(self) -> Request<T>

Struct DistributedQueryStream

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn conv<T>(self) -> T
where Self: Into<T>,

impl<T> Downcast for T
where T: Any,

impl<T> DowncastSync for T
where T: Any + Send + Sync,

impl<E, S, T> FirstAnswer<T, E> for S
where S: Stream<Item = Result<T, E>> + Unpin, E: From<ProtoError>,

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

impl<T> InstrumentStream for T
where T: Stream,

fn instrument_with<S>(self, make_span: S) -> WithInstrumented<T, S>
where S: FnMut() -> Span,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<Unshared, Shared> IntoShared<Shared> for Unshared
where Shared: FromUnshared<Unshared>,

impl<T> IntoStreamingRequest for T
where T: Stream + Send + 'static,

impl<T, U, I> LiftInto<U, I> for T
where U: LiftFrom<T, I>,

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

impl<St> RwTryStreamExt for St
where St: TryStream,

fn try_buffered_with_fence(self, n: usize) -> TryBufferedWithFence<St>
where <St as TryStream>::Ok: TryFuture<Error = <St as TryStream>::Error> + MaybeFence,

impl<S> StreamExt for S
where S: Stream + ?Sized,

fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>
where Self: Unpin,

fn next(&mut self) -> NextFuture<'_, Self>
where Self: Unpin,

fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self>
where Self: Stream<Item = Result<T, E>> + Unpin,

fn count(self) -> CountFuture<Self>
where Self: Sized,

fn map<T, F>(self, f: F) -> Map<Self, F>
where Self: Sized, F: FnMut(Self::Item) -> T,

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
where Self: Sized, U: Stream, F: FnMut(Self::Item) -> U,

fn flatten(self) -> Flatten<Self>
where Self: Sized, Self::Item: Stream,

fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut>
where Self: Sized, F: FnMut(Self::Item) -> Fut, Fut: Future,

fn filter<P>(self, predicate: P) -> Filter<Self, P>
where Self: Sized, P: FnMut(&Self::Item) -> bool,

fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>
where Self: Sized, F: FnMut(Self::Item) -> Option<T>,

fn take(self, n: usize) -> Take<Self>
where Self: Sized,

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
where Self: Sized, P: FnMut(&Self::Item) -> bool,

fn skip(self, n: usize) -> Skip<Self>
where Self: Sized,

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
where Self: Sized, P: FnMut(&Self::Item) -> bool,

fn step_by(self, step: usize) -> StepBy<Self>
where Self: Sized,

fn chain<U>(self, other: U) -> Chain<Self, U>
where Self: Sized, U: Stream<Item = Self::Item>,

fn cloned<'a, T>(self) -> Cloned<Self>
where Self: Sized + Stream<Item = &'a T>, T: Clone + 'a,

fn copied<'a, T>(self) -> Copied<Self>
where Self: Sized + Stream<Item = &'a T>, T: Copy + 'a,

fn collect<C>(self) -> CollectFuture<Self, C>
where Self: Sized, C: Default + Extend<Self::Item>,

fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C>
where Self: Sized + Stream<Item = Result<T, E>>, C: Default + Extend<T>,

fn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B>
where Self: Sized, B: Default + Extend<Self::Item>, P: FnMut(&Self::Item) -> bool,

fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T>
where Self: Sized, F: FnMut(T, Self::Item) -> T,

fn try_fold<T, E, F, B>( &mut self, init: B, f: F, ) -> TryFoldFuture<'_, Self, F, B>
where Self: Sized + Stream<Item = Result<T, E>> + Unpin, F: FnMut(B, T) -> Result<B, E>,

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

fn fuse(self) -> Fuse<Self>
where Self: Sized,

fn cycle(self) -> Cycle<Self>
where Self: Sized + Clone,

fn enumerate(self) -> Enumerate<Self>
where Self: Sized,

fn inspect<F>(self, f: F) -> Inspect<Self, F>
where Self: Sized, F: FnMut(&Self::Item),

fn nth(&mut self, n: usize) -> NthFuture<'_, Self>
where Self: Unpin,