Struct SubscribeRequestView 

pub struct SubscribeRequestView<'a> {
    pub table: &'a str,
    pub where_sql: &'a str,
    pub since_sequence_number: Option<u64>,
    pub __buffa_unknown_fields: UnknownFieldsView<'a>,
}

Stream every batch whose rows match where_sql.

Fields

table: &'a str

Table name registered in the server-side KvSchema.

Field 1: table

where_sql: &'a str

Scalar SQL boolean expression over this table’s columns (no WHERE keyword). Compiled once before subscribing, then evaluated for each batch. Empty means “emit every decoded row”. Subqueries, aggregates, window functions, and row-expanding expressions are not supported. Stable time functions use the subscription start time. Volatile functions run for each batch. Bounded to keep server-side compile cost predictable.

Field 2: where_sql

since_sequence_number: Option<u64>

Resume cursor over the underlying store batch log. Use SubscribeResponse.sequence_number + 1 to resume after a disconnect.

Field 3: since_sequence_number

__buffa_unknown_fields: UnknownFieldsView<'a>

Trait Implementations

impl<'a> Clone for SubscribeRequestView<'a>

fn clone(&self) -> SubscribeRequestView<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SubscribeRequestView<'a>

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

Formats the value using the given formatter.

impl<'a> Default for SubscribeRequestView<'a>

fn default() -> SubscribeRequestView<'a>

Returns the “default value” for a type.

impl<'v> DefaultViewInstance for SubscribeRequestView<'v>

fn default_view_instance<'a>() -> &'a Self

where Self: 'a,

Return a reference to the single default view instance.

impl<'a> MessageName for SubscribeRequestView<'a>

const PACKAGE: &'static str = "sql.v1"

The protobuf package the message is declared in.

const NAME: &'static str = "SubscribeRequest"

The unqualified message name, with . between nesting levels.

const FULL_NAME: &'static str = "sql.v1.SubscribeRequest"

The fully-qualified protobuf type name with no leading dot.

const TYPE_URL: &'static str = "type.googleapis.com/sql.v1.SubscribeRequest"

The google.protobuf.Any.type_url form for this message.

impl<'a> MessageView<'a> for SubscribeRequestView<'a>

type Owned = SubscribeRequest

The corresponding owned message type.

fn decode_view(buf: &'a [u8]) -> Result<Self, DecodeError>

Decode a view from a buffer, borrowing string/bytes fields directly.

fn decode_view_with_ctx( buf: &'a [u8], ctx: DecodeContext<'_>, ) -> Result<Self, DecodeError>

Decode a view under custom decode limits.

fn merge_view_field( &mut self, tag: Tag, cur: &'a [u8], before_tag: &'a [u8], ctx: DecodeContext<'_>, ) -> Result<&'a [u8], DecodeError>

Decode one field’s payload into this view (generated per message).

fn to_owned_message(&self) -> Result<SubscribeRequest, DecodeError>

Convert this view to the owned message type.

fn to_owned_from_source( &self, __buffa_src: Option<&Bytes>, ) -> Result<SubscribeRequest, DecodeError>

Convert this view to the owned message type, optionally slicing bytes::Bytes-typed fields from source instead of copying.

fn decode_view_ctx( buf: &'a [u8], ctx: DecodeContext<'_>, ) -> Result<Self, DecodeError>

where Self: Default,

Decode a view under an explicit DecodeContext (remaining recursion depth and unknown-field allowance), driving the provided tag loop over merge_view_field.

fn merge_into_view( &mut self, buf: &'a [u8], ctx: DecodeContext<'_>, ) -> Result<(), DecodeError>

Merge fields from buf into this view (proto merge semantics): repeated fields append, singular fields last-wins, singular message fields merge recursively.

impl<'__a> Serialize for SubscribeRequestView<'__a>

Serializes this view as protobuf JSON.

Implicit-presence fields with default values are omitted, required fields are always emitted, explicit-presence (optional) fields are emitted only when set, bytes fields are base64-encoded, and enum values are their proto name strings.

This impl uses serialize_map(None) because the number of emitted fields depends on default-omission rules; serializers that require known map lengths (e.g. bincode) will return a runtime error. Use the owned message type for those formats.

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

Serialize this value into the given Serde serializer.

impl<'a> ViewEncode<'a> for SubscribeRequestView<'a>

fn compute_size(&self, _cache: &mut SizeCache) -> u32

Compute the encoded byte size of this view, recording nested sub-message sizes in cache for write_to to consume.

fn write_to(&self, _cache: &mut SizeCache, buf: &mut impl EncodeSink)

Write this view’s encoded bytes to a buffer, consuming nested-message sizes from cache (populated by a prior compute_size call on the same cache).

fn encode(&self, buf: &mut impl EncodeSink)

Compute size, then write. Primary view-encode entry point.

fn try_encode(&self, buf: &mut impl EncodeSink) -> Result<(), EncodeError>

Encode, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

fn encode_with_cache(&self, cache: &mut SizeCache, buf: &mut impl EncodeSink)

Encode using a caller-supplied SizeCache, for reuse across many encodes in a hot loop. Clears the cache first.

fn try_encode_with_cache( &self, cache: &mut SizeCache, buf: &mut impl EncodeSink, ) -> Result<(), EncodeError>

Encode with a caller-supplied SizeCache, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES). Clears the cache first.

fn try_encode_bounded( &self, max_bytes: u32, buf: &mut impl EncodeSink, ) -> Result<u32, EncodeError>

Encode this view into buf only if its encoded size fits within max_bytes, using a single size pass that is then reused for the write.

fn try_encode_bounded_with_cache( &self, max_bytes: u32, cache: &mut SizeCache, buf: &mut impl EncodeSink, ) -> Result<u32, EncodeError>

Like try_encode_bounded but reuses an existing SizeCache, clearing it first.

fn encoded_len(&self) -> u32

Compute the encoded byte size of this view.

fn try_encoded_len(&self) -> Result<u32, EncodeError>

Compute the encoded byte size, returning an error instead of panicking if it exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

fn encode_length_delimited(&self, buf: &mut impl EncodeSink)

Encode this view as a length-delimited byte sequence.

fn try_encode_length_delimited( &self, buf: &mut impl EncodeSink, ) -> Result<(), EncodeError>

Encode as a length-delimited byte sequence, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

fn encode_to_vec(&self) -> Vec<u8>

Encode this view to a new Vec<u8>.

fn try_encode_to_vec(&self) -> Result<Vec<u8>, EncodeError>

Encode to a new Vec<u8>, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

fn encode_to_bytes(&self) -> Bytes

Encode this view to a new bytes::Bytes.

fn try_encode_to_bytes(&self) -> Result<Bytes, EncodeError>

Encode to a new bytes::Bytes, returning an error instead of panicking if the encoded size exceeds the 2 GiB protobuf limit (MAX_MESSAGE_BYTES).

impl ViewReborrow for SubscribeRequestView<'static>

type Reborrowed<'b> = SubscribeRequestView<'b>

The same view type with its lifetime shortened to 'b.

fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b>

Coerce &'b Self (= &'b FooView<'static>) to &'b Self::Reborrowed<'b> (= &'b FooView<'b>). The canonical body is just this; the compiler accepts it via standard lifetime variance for covariant view types.