Struct gapi_grpc::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.

pub 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() -> CellChunk

Returns the “default value” for a type.

impl Message for CellChunk

fn encode_raw<B>(&self, buf: &mut B) where
    B: BufMut, 

fn merge_field<B>(
    &mut self,
    tag: u32,
    wire_type: WireType,
    buf: &mut B,
    ctx: DecodeContext
) -> Result<(), DecodeError> where
    B: Buf, 

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.

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

Encodes the message to a buffer.

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

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

pub fn decode<B>(buf: B) -> Result<Self, DecodeError> where
    Self: Default,
    B: Buf, 

Decodes an instance of the message from a buffer.

pub fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError> where
    Self: Default,
    B: Buf, 

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

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

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

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

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

impl PartialEq<CellChunk> 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: &CellChunk) -> bool

This method tests for !=.

impl StructuralPartialEq for CellChunk