Struct Peek

pub struct Peek<T = Timestamp> {
    pub target: PeekTarget,
    pub literal_constraints: Option<Vec<Row>>,
    pub uuid: Uuid,
    pub timestamp: T,
    pub finishing: RowSetFinishing,
    pub map_filter_project: SafeMfpPlan,
    pub otel_ctx: OpenTelemetryContext,
}

Peek a collection, either in an arrangement or Persist.

This request elicits data from the worker, by naming the collection and some actions to apply to the results before returning them.

The timestamp member must be valid for the arrangement that is referenced by id. This means that AllowCompaction for this arrangement should not pass timestamp before this command. Subsequent commands may arbitrarily compact the arrangements; the dataflow runners are responsible for ensuring that they can correctly answer the Peek.

Fields

target: PeekTarget

Target-specific metadata.

literal_constraints: Option<Vec<Row>>

If Some, then look up only the given keys from the collection (instead of a full scan). The vector is never empty.

uuid: Uuid

The identifier of this peek request.

Used in responses and cancellation requests.

timestamp: T

The logical timestamp at which the collection is queried.

finishing: RowSetFinishing

Actions to apply to the result set before returning them.

map_filter_project: SafeMfpPlan

Linear operation to apply in-line on each result.

otel_ctx: OpenTelemetryContext

An OpenTelemetryContext to forward trace information along to the compute worker to allow associating traces between the compute controller and the compute worker.

Trait Implementations

impl<T: Arbitrary> Arbitrary for Peek<T>

type Parameters = (<PeekTarget as Arbitrary>::Parameters, <T as Arbitrary>::Parameters, <RowSetFinishing as Arbitrary>::Parameters, <SafeMfpPlan as Arbitrary>::Parameters)

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

type Strategy = Map<(<PeekTarget as Arbitrary>::Strategy, BoxedStrategy<Option<Vec<Row>>>, BoxedStrategy<Uuid>, <T as Arbitrary>::Strategy, <RowSetFinishing as Arbitrary>::Strategy, <SafeMfpPlan as Arbitrary>::Strategy, BoxedStrategy<OpenTelemetryContext>), fn(_: (PeekTarget, Option<Vec<Row>>, Uuid, T, RowSetFinishing, SafeMfpPlan, OpenTelemetryContext)) -> Peek<T>>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_top: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl<T: Clone> Clone for Peek<T>

fn clone(&self) -> Peek<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Peek<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Peek<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq> PartialEq for Peek<T>

fn eq(&self, other: &Peek<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RustType<ProtoPeek> for Peek

fn into_proto(&self) -> ProtoPeek

Convert a Self into a Proto value.

fn from_proto(x: ProtoPeek) -> Result<Self, TryFromProtoError>

Consume and convert a Proto back into a Self value.

fn into_proto_owned(self) -> Proto

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

impl<T> Serialize for Peek<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for Peek<T>