Struct bigtable_rs::google::bigtable::v2::read_rows_response::CellChunk

pub struct CellChunk {
    pub row_key: Vec<u8>,
    pub family_name: Option<String>,
    pub qualifier: Option<Vec<u8>>,
    pub timestamp_micros: i64,
    pub labels: Vec<String>,
    pub value: Vec<u8>,
    pub value_size: i32,
    pub row_status: Option<RowStatus>,
}

Specifies a piece of a row’s contents returned as part of the read response stream.

Fields

row_key: Vec<u8>

The row key for this chunk of data. If the row key is empty, this CellChunk is a continuation of the same row as the previous CellChunk in the response stream, even if that CellChunk was in a previous ReadRowsResponse message.

family_name: Option<String>

The column family name for this chunk of data. If this message is not present this CellChunk is a continuation of the same column family as the previous CellChunk. The empty string can occur as a column family name in a response so clients must check explicitly for the presence of this message, not just for family_name.value being non-empty.

qualifier: Option<Vec<u8>>

The column qualifier for this chunk of data. If this message is not present, this CellChunk is a continuation of the same column as the previous CellChunk. Column qualifiers may be empty so clients must check for the presence of this message, not just for qualifier.value being non-empty.

timestamp_micros: i64

The cell’s stored timestamp, which also uniquely identifies it within its column. Values are always expressed in microseconds, but individual tables may set a coarser granularity to further restrict the allowed values. For example, a table which specifies millisecond granularity will only allow values of timestamp_micros which are multiples of 1000. Timestamps are only set in the first CellChunk per cell (for cells split into multiple chunks).

labels: Vec<String>

Labels applied to the cell by a [RowFilter][google.bigtable.v2.RowFilter]. Labels are only set on the first CellChunk per cell.

value: Vec<u8>

The value stored in the cell. Cell values can be split across multiple CellChunks. In that case only the value field will be set in CellChunks after the first: the timestamp and labels will only be present in the first CellChunk, even if the first CellChunk came in a previous ReadRowsResponse.

value_size: i32

If this CellChunk is part of a chunked cell value and this is not the final chunk of that cell, value_size will be set to the total length of the cell value. The client can use this size to pre-allocate memory to hold the full cell value.

row_status: Option<RowStatus>

Signals to the client concerning previous CellChunks received.

Trait Implementations

impl Clone for CellChunk

fn clone(&self) -> CellChunk

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CellChunk

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

Formats the value using the given formatter.

impl Default for CellChunk

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CellChunk

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Message for CellChunk

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message to a buffer.

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

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited( &self, buf: &mut impl BufMut, ) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message with a length-delimiter to a buffer.

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

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for CellChunk

fn eq(&self, other: &CellChunk) -> 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 Serialize for CellChunk

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CellChunk