pub struct FlightDataEncoder {
    inner: BoxStream<'static, Result<RecordBatch>>,
    schema: Option<SchemaRef>,
    max_flight_data_size: usize,
    encoder: FlightIpcEncoder,
    app_metadata: Option<Bytes>,
    queue: VecDeque<FlightData>,
    done: bool,
    descriptor: Option<FlightDescriptor>,
    dictionary_handling: DictionaryHandling,
}Expand description
Stream that encodes a stream of record batches to flight data.
See FlightDataEncoderBuilder for details and example.
Fields§
§inner: BoxStream<'static, Result<RecordBatch>>Input stream
schema: Option<SchemaRef>schema, set after the first batch
max_flight_data_size: usizeTarget maximum size of flight data
(see details on FlightDataEncoderBuilder::with_max_flight_data_size).
encoder: FlightIpcEncoderdo the encoding / tracking of dictionaries
app_metadata: Option<Bytes>optional metadata to add to schema FlightData
queue: VecDeque<FlightData>data queued up to send but not yet sent
done: boolIs this stream done (inner is empty or errored)
descriptor: Option<FlightDescriptor>cleared after the first FlightData message is sent
dictionary_handling: DictionaryHandlingDeterimines how DictionaryArrays are encoded for transport.
See DictionaryHandling for more information.
Implementations§
Source§impl FlightDataEncoder
 
impl FlightDataEncoder
fn new( inner: BoxStream<'static, Result<RecordBatch>>, schema: Option<SchemaRef>, max_flight_data_size: usize, options: IpcWriteOptions, app_metadata: Bytes, descriptor: Option<FlightDescriptor>, dictionary_handling: DictionaryHandling, ) -> Self
Sourcepub fn known_schema(&self) -> Option<SchemaRef>
 
pub fn known_schema(&self) -> Option<SchemaRef>
Report the schema of the encoded data when known.
A schema is known when provided via the FlightDataEncoderBuilder::with_schema method.
Sourcefn queue_message(&mut self, data: FlightData)
 
fn queue_message(&mut self, data: FlightData)
Place the FlightData in the queue to send
Sourcefn queue_messages(&mut self, datas: impl IntoIterator<Item = FlightData>)
 
fn queue_messages(&mut self, datas: impl IntoIterator<Item = FlightData>)
Place the FlightData in the queue to send
Sourcefn encode_schema(&mut self, schema: &SchemaRef) -> SchemaRef
 
fn encode_schema(&mut self, schema: &SchemaRef) -> SchemaRef
Encodes schema as a FlightData in self.queue.
Updates self.schema and returns the new schema
Sourcefn encode_batch(&mut self, batch: RecordBatch) -> Result<()>
 
fn encode_batch(&mut self, batch: RecordBatch) -> Result<()>
Encodes batch into one or more FlightData messages in self.queue
Trait Implementations§
Source§impl Stream for FlightDataEncoder
 
impl Stream for FlightDataEncoder
Source§type Item = Result<FlightData, FlightError>
 
type Item = Result<FlightData, FlightError>
Auto Trait Implementations§
impl !Freeze for FlightDataEncoder
impl !RefUnwindSafe for FlightDataEncoder
impl Send for FlightDataEncoder
impl !Sync for FlightDataEncoder
impl Unpin for FlightDataEncoder
impl !UnwindSafe for FlightDataEncoder
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
    T: ?Sized,
 
impl<T> BorrowMut<T> for Twhere
    T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
 
fn borrow_mut(&mut self) -> &mut T
§impl<T> Instrument for T
 
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
 
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
 
fn in_current_span(self) -> Instrumented<Self>
§impl<T> IntoRequest<T> for T
 
impl<T> IntoRequest<T> for T
§fn into_request(self) -> Request<T>
 
fn into_request(self) -> Request<T>
T in a tonic::Request§impl<L> LayerExt<L> for L
 
impl<L> LayerExt<L> for L
§fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>where
    L: Layer<S>,
 
fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>where
    L: Layer<S>,
Layered].§impl<St> StreamExt for Stwhere
    St: Stream + ?Sized,
 
impl<St> StreamExt for Stwhere
    St: Stream + ?Sized,
§fn next(&mut self) -> Next<'_, Self>where
    Self: Unpin,
 
fn next(&mut self) -> Next<'_, Self>where
    Self: Unpin,
None if the
stream is finished. Read more§fn try_next<T, E>(&mut self) -> TryNext<'_, Self>
 
fn try_next<T, E>(&mut self) -> TryNext<'_, Self>
§fn map<T, F>(self, f: F) -> Map<Self, F>
 
fn map<T, F>(self, f: F) -> Map<Self, F>
§fn map_while<T, F>(self, f: F) -> MapWhile<Self, F>
 
fn map_while<T, F>(self, f: F) -> MapWhile<Self, F>
None. Read more§fn then<F, Fut>(self, f: F) -> Then<Self, Fut, F>
 
fn then<F, Fut>(self, f: F) -> Then<Self, Fut, F>
§fn merge<U>(self, other: U) -> Merge<Self, U>where
    U: Stream<Item = Self::Item>,
    Self: Sized,
 
fn merge<U>(self, other: U) -> Merge<Self, U>where
    U: Stream<Item = Self::Item>,
    Self: Sized,
§fn filter<F>(self, f: F) -> Filter<Self, F>
 
fn filter<F>(self, f: F) -> Filter<Self, F>
§fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>
 
fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F>
§fn fuse(self) -> Fuse<Self>where
    Self: Sized,
 
fn fuse(self) -> Fuse<Self>where
    Self: Sized,
None. Read more§fn take(self, n: usize) -> Take<Self>where
    Self: Sized,
 
fn take(self, n: usize) -> Take<Self>where
    Self: Sized,
n items of the underlying stream. Read more§fn take_while<F>(self, f: F) -> TakeWhile<Self, F>
 
fn take_while<F>(self, f: F) -> TakeWhile<Self, F>
true. Read more§fn skip(self, n: usize) -> Skip<Self>where
    Self: Sized,
 
fn skip(self, n: usize) -> Skip<Self>where
    Self: Sized,
n first items of the
underlying stream. Read more§fn skip_while<F>(self, f: F) -> SkipWhile<Self, F>
 
fn skip_while<F>(self, f: F) -> SkipWhile<Self, F>
true. Read more§fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F>
 
fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F>
§fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F>
 
fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F>
§fn chain<U>(self, other: U) -> Chain<Self, U>where
    U: Stream<Item = Self::Item>,
    Self: Sized,
 
fn chain<U>(self, other: U) -> Chain<Self, U>where
    U: Stream<Item = Self::Item>,
    Self: Sized,
§fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, B, F>
 
fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, B, F>
§impl<T> StreamExt for Twhere
    T: Stream + ?Sized,
 
impl<T> StreamExt for Twhere
    T: Stream + ?Sized,
§fn next(&mut self) -> Next<'_, Self>where
    Self: Unpin,
 
fn next(&mut self) -> Next<'_, Self>where
    Self: Unpin,
§fn into_future(self) -> StreamFuture<Self>
 
fn into_future(self) -> StreamFuture<Self>
§fn map<T, F>(self, f: F) -> Map<Self, F>
 
fn map<T, F>(self, f: F) -> Map<Self, F>
§fn enumerate(self) -> Enumerate<Self>where
    Self: Sized,
 
fn enumerate(self) -> Enumerate<Self>where
    Self: Sized,
§fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>
 
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>
§fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>
 
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>
§fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>
 
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>
§fn collect<C>(self) -> Collect<Self, C>
 
fn collect<C>(self) -> Collect<Self, C>
§fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>
 
fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>
§fn concat(self) -> Concat<Self>
 
fn concat(self) -> Concat<Self>
§fn count(self) -> Count<Self>where
    Self: Sized,
 
fn count(self) -> Count<Self>where
    Self: Sized,
§fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>
 
fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>
§fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F>
 
fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F>
true if any element in stream satisfied a predicate. Read more§fn all<Fut, F>(self, f: F) -> All<Self, Fut, F>
 
fn all<Fut, F>(self, f: F) -> All<Self, Fut, F>
true if all element in stream satisfied a predicate. Read more§fn flatten(self) -> Flatten<Self>where
    Self::Item: Stream,
    Self: Sized,
 
fn flatten(self) -> Flatten<Self>where
    Self::Item: Stream,
    Self: Sized,
§fn flatten_unordered(
    self,
    limit: impl Into<Option<usize>>,
) -> FlattenUnorderedWithFlowController<Self, ()>
 
fn flatten_unordered( self, limit: impl Into<Option<usize>>, ) -> FlattenUnorderedWithFlowController<Self, ()>
§fn flat_map_unordered<U, F>(
    self,
    limit: impl Into<Option<usize>>,
    f: F,
) -> FlatMapUnordered<Self, U, F>
 
fn flat_map_unordered<U, F>( self, limit: impl Into<Option<usize>>, f: F, ) -> FlatMapUnordered<Self, U, F>
StreamExt::map] but flattens nested Streams
and polls them concurrently, yielding items in any order, as they made
available. Read more§fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F>
 
fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F>
StreamExt::fold] that holds internal state
and produces a new stream. Read more§fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F>
 
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F>
true. Read more§fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>
 
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F>
true. Read more§fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>
 
fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut>
§fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>
 
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>
§fn for_each_concurrent<Fut, F>(
    self,
    limit: impl Into<Option<usize>>,
    f: F,
) -> ForEachConcurrent<Self, Fut, F>
 
fn for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F, ) -> ForEachConcurrent<Self, Fut, F>
§fn take(self, n: usize) -> Take<Self>where
    Self: Sized,
 
fn take(self, n: usize) -> Take<Self>where
    Self: Sized,
n items of the underlying stream. Read more§fn skip(self, n: usize) -> Skip<Self>where
    Self: Sized,
 
fn skip(self, n: usize) -> Skip<Self>where
    Self: Sized,
n items of the underlying stream. Read more§fn catch_unwind(self) -> CatchUnwind<Self>where
    Self: Sized + UnwindSafe,
 
fn catch_unwind(self) -> CatchUnwind<Self>where
    Self: Sized + UnwindSafe,
§fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a>>
 
fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a>>
§fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>>where
    Self: Sized + 'a,
 
fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>>where
    Self: Sized + 'a,
§fn buffered(self, n: usize) -> Buffered<Self>
 
fn buffered(self, n: usize) -> Buffered<Self>
§fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>
 
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>
§fn zip<St>(self, other: St) -> Zip<Self, St>where
    St: Stream,
    Self: Sized,
 
fn zip<St>(self, other: St) -> Zip<Self, St>where
    St: Stream,
    Self: Sized,
§fn chain<St>(self, other: St) -> Chain<Self, St>where
    St: Stream<Item = Self::Item>,
    Self: Sized,
 
fn chain<St>(self, other: St) -> Chain<Self, St>where
    St: Stream<Item = Self::Item>,
    Self: Sized,
§fn peekable(self) -> Peekable<Self>where
    Self: Sized,
 
fn peekable(self) -> Peekable<Self>where
    Self: Sized,
peek method. Read more§fn chunks(self, capacity: usize) -> Chunks<Self>where
    Self: Sized,
 
fn chunks(self, capacity: usize) -> Chunks<Self>where
    Self: Sized,
§fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>where
    Self: Sized,
 
fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>where
    Self: Sized,
§fn forward<S>(self, sink: S) -> Forward<Self, S>where
    S: Sink<Self::Ok, Error = Self::Error>,
    Self: Sized + TryStream,
 
fn forward<S>(self, sink: S) -> Forward<Self, S>where
    S: Sink<Self::Ok, Error = Self::Error>,
    Self: Sized + TryStream,
§fn inspect<F>(self, f: F) -> Inspect<Self, F>
 
fn inspect<F>(self, f: F) -> Inspect<Self, F>
§fn left_stream<B>(self) -> Either<Self, B>where
    B: Stream<Item = Self::Item>,
    Self: Sized,
 
fn left_stream<B>(self) -> Either<Self, B>where
    B: Stream<Item = Self::Item>,
    Self: Sized,
§fn right_stream<B>(self) -> Either<B, Self>where
    B: Stream<Item = Self::Item>,
    Self: Sized,
 
fn right_stream<B>(self) -> Either<B, Self>where
    B: Stream<Item = Self::Item>,
    Self: Sized,
§fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>where
    Self: Unpin,
 
fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>where
    Self: Unpin,
Stream::poll_next] on Unpin
stream types.§fn select_next_some(&mut self) -> SelectNextSome<'_, Self>where
    Self: Unpin + FusedStream,
 
fn select_next_some(&mut self) -> SelectNextSome<'_, Self>where
    Self: Unpin + FusedStream,
§impl<S, T, E> TryStream for S
 
impl<S, T, E> TryStream for S
§impl<S> TryStreamExt for Swhere
    S: TryStream + ?Sized,
 
impl<S> TryStreamExt for Swhere
    S: TryStream + ?Sized,
§fn err_into<E>(self) -> ErrInto<Self, E>
 
fn err_into<E>(self) -> ErrInto<Self, E>
§fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>
 
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F>
§fn map_err<E, F>(self, f: F) -> MapErr<Self, F>
 
fn map_err<E, F>(self, f: F) -> MapErr<Self, F>
§fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>
 
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F>
f. Read more§fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>
 
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F>
f. Read more§fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>
 
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>
§fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>
 
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F>
§fn into_stream(self) -> IntoStream<Self>where
    Self: Sized,
 
fn into_stream(self) -> IntoStream<Self>where
    Self: Sized,
§fn try_next(&mut self) -> TryNext<'_, Self>where
    Self: Unpin,
 
fn try_next(&mut self) -> TryNext<'_, Self>where
    Self: Unpin,
§fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F>
 
fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F>
§fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F>
 
fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F>
true. Read more§fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F>
 
fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F>
true. Read more§fn try_for_each_concurrent<Fut, F>(
    self,
    limit: impl Into<Option<usize>>,
    f: F,
) -> TryForEachConcurrent<Self, Fut, F>
 
fn try_for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F, ) -> TryForEachConcurrent<Self, Fut, F>
§fn try_collect<C>(self) -> TryCollect<Self, C>
 
fn try_collect<C>(self) -> TryCollect<Self, C>
§fn try_chunks(self, capacity: usize) -> TryChunks<Self>where
    Self: Sized,
 
fn try_chunks(self, capacity: usize) -> TryChunks<Self>where
    Self: Sized,
§fn try_ready_chunks(self, capacity: usize) -> TryReadyChunks<Self>where
    Self: Sized,
 
fn try_ready_chunks(self, capacity: usize) -> TryReadyChunks<Self>where
    Self: Sized,
§fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F>
 
fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F>
§fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F>
 
fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F>
§fn try_flatten_unordered(
    self,
    limit: impl Into<Option<usize>>,
) -> TryFlattenUnordered<Self>
 
fn try_flatten_unordered( self, limit: impl Into<Option<usize>>, ) -> TryFlattenUnordered<Self>
§fn try_flatten(self) -> TryFlatten<Self>
 
fn try_flatten(self) -> TryFlatten<Self>
§fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F>
 
fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F>
§fn try_concat(self) -> TryConcat<Self>
 
fn try_concat(self) -> TryConcat<Self>
§fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self>where
    Self::Ok: TryFuture<Error = Self::Error>,
    Self: Sized,
 
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self>where
    Self::Ok: TryFuture<Error = Self::Error>,
    Self: Sized,
§fn try_buffered(self, n: usize) -> TryBuffered<Self>where
    Self::Ok: TryFuture<Error = Self::Error>,
    Self: Sized,
 
fn try_buffered(self, n: usize) -> TryBuffered<Self>where
    Self::Ok: TryFuture<Error = Self::Error>,
    Self: Sized,
§fn try_poll_next_unpin(
    &mut self,
    cx: &mut Context<'_>,
) -> Poll<Option<Result<Self::Ok, Self::Error>>>where
    Self: Unpin,
 
fn try_poll_next_unpin(
    &mut self,
    cx: &mut Context<'_>,
) -> Poll<Option<Result<Self::Ok, Self::Error>>>where
    Self: Unpin,
TryStream::try_poll_next] on Unpin
stream types.§fn into_async_read(self) -> IntoAsyncRead<Self>
 
fn into_async_read(self) -> IntoAsyncRead<Self>
AsyncBufRead. Read more§fn try_all<Fut, F>(self, f: F) -> TryAll<Self, Fut, F>
 
fn try_all<Fut, F>(self, f: F) -> TryAll<Self, Fut, F>
Err is encountered or if an Ok item is found
that does not satisfy the predicate. Read more