Struct mz_compute_client::command::Peek

pub struct Peek<T = Timestamp> {
    pub id: GlobalId,
    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 at an arrangement.

This request elicits data from the worker, by naming an arrangement 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

id: GlobalId

The identifier of the arrangement.

literal_constraints: Option<Vec<Row>>

If Some, then look up only the given keys from the arrangement (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 arrangement 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 = (<GlobalId 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<(<GlobalId as Arbitrary>::Strategy, BoxedStrategy<Option<Vec<Row, Global>>>, BoxedStrategy<Uuid>, <T as Arbitrary>::Strategy, <RowSetFinishing as Arbitrary>::Strategy, <SafeMfpPlan as Arbitrary>::Strategy, BoxedStrategy<OpenTelemetryContext>), fn(_: (GlobalId, Option<Vec<Row, Global>>, 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<Peek<T>> for Peek<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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.

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>