Struct LeasedBatchPart

pub struct LeasedBatchPart<T> {
    pub(crate) metrics: Arc<Metrics>,
    pub(crate) shard_id: ShardId,
    pub(crate) reader_id: LeasedReaderId,
    pub(crate) filter: FetchBatchFilter<T>,
    pub(crate) desc: Description<T>,
    pub(crate) part: BatchPart<T>,
    pub(crate) leased_seqno: SeqNo,
    pub(crate) lease: Option<Lease>,
    pub(crate) filter_pushdown_audit: bool,
}

A token representing one fetch-able batch part.

It is tradeable via crate::fetch::fetch_batch for the resulting data stored in the part.

Exchange

You can exchange LeasedBatchPart:

• If leased_seqno.is_none()
• By converting it to SerdeLeasedBatchPart through Self::into_exchangeable_part. SerdeLeasedBatchPart is exchangeable, including over the network.

n.b. Self::into_exchangeable_part is known to be equivalent to SerdeLeasedBatchPart::from(self), but we want the additional warning message to be visible and sufficiently scary.

Panics

LeasedBatchPart panics when dropped unless a very strict set of invariants are held:

LeasedBatchPart may only be dropped if it:

• Does not have a leased SeqNo (i.e. self.leased_seqno.is_none()`)

In any other circumstance, dropping LeasedBatchPart panics.

Fields

metrics: Arc<Metrics>

shard_id: ShardId

reader_id: LeasedReaderId

filter: FetchBatchFilter<T>

desc: Description<T>

part: BatchPart<T>

leased_seqno: SeqNo

The SeqNo from which this part originated; we track this value as to ensure the SeqNo isn’t garbage collected while a read still depends on it.

lease: Option<Lease>

The lease that prevents this part from being GCed. Code should ensure that this lease lives as long as the part is needed.

filter_pushdown_audit: bool

Implementations

impl<T> LeasedBatchPart<T>

where T: Timestamp + Codec64,

pub(crate) fn into_exchangeable_part( self, ) -> (SerdeLeasedBatchPart, Option<Lease>)

Takes self into a SerdeLeasedBatchPart, which allows self to be exchanged (potentially across the network).

!!!WARNING!!!

This method also returns the Lease associated with the given part, since that can’t travel across process boundaries. The caller is responsible for ensuring that the lease is held for as long as the batch part may be in use: dropping it too early may cause a fetch to fail.

pub fn encoded_size_bytes(&self) -> usize

The encoded size of this part in bytes

pub fn request_filter_pushdown_audit(&mut self)

The filter has indicated we don’t need this part, we can verify the ongoing end-to-end correctness of corner cases via “audit”. This means we fetch the part like normal and if the MFP keeps anything from it, then something has gone horribly wrong.

pub fn stats(&self) -> Option<PartStats>

Returns the pushdown stats for this part.

pub fn maybe_optimize(&mut self, cfg: &ConfigSet, key: ArrayRef, val: ArrayRef)

Apply any relevant projection pushdown optimizations, assuming that the data in the part is equivalent to the provided key and value.

Trait Implementations

impl<T: Debug> Debug for LeasedBatchPart<T>

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

Formats the value using the given formatter.

impl<T> Drop for LeasedBatchPart<T>

fn drop(&mut self)

For details, see LeasedBatchPart.

impl<T: Timestamp + Codec64> RustType<(ProtoLeasedBatchPart, Arc<Metrics>)> for LeasedBatchPart<T>

fn into_proto(&self) -> (ProtoLeasedBatchPart, Arc<Metrics>)

Convert a Self into a Proto value.

fn from_proto( proto: (ProtoLeasedBatchPart, Arc<Metrics>), ) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

fn into_proto_owned(self) -> Proto

A zero clone version of Self::into_proto that types can optionally implement, otherwise, the default implementation delegates to Self::into_proto.