@ -246,7 +246,7 @@ pub mod value_range {
/// RowFilter.Chain and RowFilter.Interleave documentation.
///
/// The total serialized size of a RowFilter message must not
/// exceed 4096 bytes, and RowFilters may not be nested within each other
/// exceed 20 48 0 bytes, and RowFilters may not be nested within each other
/// (in Chains or Interleaves) to a depth of more than 20.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
@ -623,6 +623,130 @@ pub mod read_modify_write_rule {
IncrementAmount ( i64 ) ,
}
}
/// NOTE: This API is intended to be used by Apache Beam BigtableIO.
/// A partition of a change stream.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct StreamPartition {
/// The row range covered by this partition and is specified by
/// [`start_key_closed`, `end_key_open`).
#[ prost(message, optional, tag = " 1 " ) ]
pub row_range : ::core ::option ::Option < RowRange > ,
}
/// NOTE: This API is intended to be used by Apache Beam BigtableIO.
/// The information required to continue reading the data from multiple
/// `StreamPartitions` from where a previous read left off.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct StreamContinuationTokens {
/// List of continuation tokens.
#[ prost(message, repeated, tag = " 1 " ) ]
pub tokens : ::prost ::alloc ::vec ::Vec < StreamContinuationToken > ,
}
/// NOTE: This API is intended to be used by Apache Beam BigtableIO.
/// The information required to continue reading the data from a
/// `StreamPartition` from where a previous read left off.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct StreamContinuationToken {
/// The partition that this token applies to.
#[ prost(message, optional, tag = " 1 " ) ]
pub partition : ::core ::option ::Option < StreamPartition > ,
/// An encoded position in the stream to restart reading from.
#[ prost(string, tag = " 2 " ) ]
pub token : ::prost ::alloc ::string ::String ,
}
/// ReadIterationStats captures information about the iteration of rows or cells
/// over the course of a read, e.g. how many results were scanned in a read
/// operation versus the results returned.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct ReadIterationStats {
/// The rows seen (scanned) as part of the request. This includes the count of
/// rows returned, as captured below.
#[ prost(int64, tag = " 1 " ) ]
pub rows_seen_count : i64 ,
/// The rows returned as part of the request.
#[ prost(int64, tag = " 2 " ) ]
pub rows_returned_count : i64 ,
/// The cells seen (scanned) as part of the request. This includes the count of
/// cells returned, as captured below.
#[ prost(int64, tag = " 3 " ) ]
pub cells_seen_count : i64 ,
/// The cells returned as part of the request.
#[ prost(int64, tag = " 4 " ) ]
pub cells_returned_count : i64 ,
}
/// RequestLatencyStats provides a measurement of the latency of the request as
/// it interacts with different systems over its lifetime, e.g. how long the
/// request took to execute within a frontend server.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct RequestLatencyStats {
/// The latency measured by the frontend server handling this request, from
/// when the request was received, to when this value is sent back in the
/// response. For more context on the component that is measuring this latency,
/// see: <https://cloud.google.com/bigtable/docs/overview>
///
/// Note: This value may be slightly shorter than the value reported into
/// aggregate latency metrics in Monitoring for this request
/// (<https://cloud.google.com/bigtable/docs/monitoring-instance>) as this value
/// needs to be sent in the response before the latency measurement including
/// that transmission is finalized.
///
/// Note: This value includes the end-to-end latency of contacting nodes in
/// the targeted cluster, e.g. measuring from when the first byte arrives at
/// the frontend server, to when this value is sent back as the last value in
/// the response, including any latency incurred by contacting nodes, waiting
/// for results from nodes, and finally sending results from nodes back to the
/// caller.
#[ prost(message, optional, tag = " 1 " ) ]
pub frontend_server_latency : ::core ::option ::Option < ::prost_types ::Duration > ,
}
/// FullReadStatsView captures all known information about a read.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct FullReadStatsView {
/// Iteration stats describe how efficient the read is, e.g. comparing
/// rows seen vs. rows returned or cells seen vs cells returned can provide an
/// indication of read efficiency (the higher the ratio of seen to retuned the
/// better).
#[ prost(message, optional, tag = " 1 " ) ]
pub read_iteration_stats : ::core ::option ::Option < ReadIterationStats > ,
/// Request latency stats describe the time taken to complete a request, from
/// the server side.
#[ prost(message, optional, tag = " 2 " ) ]
pub request_latency_stats : ::core ::option ::Option < RequestLatencyStats > ,
}
/// RequestStats is the container for additional information pertaining to a
/// single request, helpful for evaluating the performance of the sent request.
/// Currently, there are the following supported methods:
/// * google.bigtable.v2.ReadRows
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct RequestStats {
/// Information pertaining to each request type received. The type is chosen
/// based on the requested view.
///
/// See the messages above for additional context.
#[ prost(oneof = " request_stats::StatsView " , tags = " 1 " ) ]
pub stats_view : ::core ::option ::Option < request_stats ::StatsView > ,
}
/// Nested message and enum types in `RequestStats`.
pub mod request_stats {
/// Information pertaining to each request type received. The type is chosen
/// based on the requested view.
///
/// See the messages above for additional context.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Oneof) ]
pub enum StatsView {
/// Available with the ReadRowsRequest.RequestStatsView.REQUEST_STATS_FULL
/// view, see package google.bigtable.v2.
#[ prost(message, tag = " 1 " ) ]
FullReadStatsView ( super ::FullReadStatsView ) ,
}
}
/// Request message for Bigtable.ReadRows.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
@ -636,17 +760,85 @@ pub struct ReadRowsRequest {
/// "default" application profile will be used.
#[ prost(string, tag = " 5 " ) ]
pub app_profile_id : ::prost ::alloc ::string ::String ,
/// The row keys and/or ranges to read. If not specified, reads from all rows.
/// The row keys and/or ranges to read sequentially. If not specified, reads
/// from all rows.
#[ prost(message, optional, tag = " 2 " ) ]
pub rows : ::core ::option ::Option < RowSet > ,
/// The filter to apply to the contents of the specified row(s). If unset,
/// reads the entirety of each row.
#[ prost(message, optional, tag = " 3 " ) ]
pub filter : ::core ::option ::Option < RowFilter > ,
/// The read will terminate after committing to N rows' worth of results. The
/// The read will stop after committing to N rows' worth of results. The
/// default (zero) is to return all results.
#[ prost(int64, tag = " 4 " ) ]
pub rows_limit : i64 ,
/// The view into RequestStats, as described above.
#[ prost(enumeration = " read_rows_request::RequestStatsView " , tag = " 6 " ) ]
pub request_stats_view : i32 ,
/// Experimental API - Please note that this API is currently experimental
/// and can change in the future.
///
/// Return rows in lexiographical descending order of the row keys. The row
/// contents will not be affected by this flag.
///
/// Example result set:
///```ignore
/// [
/// {key: "k2", "f:col1": "v1", "f:col2": "v1"},
/// {key: "k1", "f:col1": "v2", "f:col2": "v2"}
/// ]
#[ prost(bool, tag = " 7 " ) ]
pub reversed : bool ,
}
/// Nested message and enum types in `ReadRowsRequest`.
pub mod read_rows_request {
/// The desired view into RequestStats that should be returned in the response.
///
/// See also: RequestStats message.
#[ derive(
Clone ,
Copy ,
Debug ,
PartialEq ,
Eq ,
Hash ,
PartialOrd ,
Ord ,
::prost ::Enumeration
) ]
#[ repr(i32) ]
pub enum RequestStatsView {
/// The default / unset value. The API will default to the NONE option below.
Unspecified = 0 ,
/// Do not include any RequestStats in the response. This will leave the
/// RequestStats embedded message unset in the response.
RequestStatsNone = 1 ,
/// Include the full set of available RequestStats in the response,
/// applicable to this read.
RequestStatsFull = 2 ,
}
impl RequestStatsView {
/// String value of the enum field names used in the ProtoBuf definition.
///
/// The values are not transformed in any way and thus are considered stable
/// (if the ProtoBuf definition does not change) and safe for programmatic use.
pub fn as_str_name ( & self ) -> & 'static str {
match self {
RequestStatsView ::Unspecified = > " REQUEST_STATS_VIEW_UNSPECIFIED " ,
RequestStatsView ::RequestStatsNone = > " REQUEST_STATS_NONE " ,
RequestStatsView ::RequestStatsFull = > " REQUEST_STATS_FULL " ,
}
}
/// Creates an enum from field names used in the ProtoBuf definition.
pub fn from_str_name ( value : & str ) -> ::core ::option ::Option < Self > {
match value {
" REQUEST_STATS_VIEW_UNSPECIFIED " = > Some ( Self ::Unspecified ) ,
" REQUEST_STATS_NONE " = > Some ( Self ::RequestStatsNone ) ,
" REQUEST_STATS_FULL " = > Some ( Self ::RequestStatsFull ) ,
_ = > None ,
}
}
}
}
/// Response message for Bigtable.ReadRows.
#[ allow(clippy::derive_partial_eq_without_eq) ]
@ -664,6 +856,28 @@ pub struct ReadRowsResponse {
/// key, allowing the client to skip that work on a retry.
#[ prost(bytes = " vec " , tag = " 2 " ) ]
pub last_scanned_row_key : ::prost ::alloc ::vec ::Vec < u8 > ,
///
/// If requested, provide enhanced query performance statistics. The semantics
/// dictate:
/// * request_stats is empty on every (streamed) response, except
/// * request_stats has non-empty information after all chunks have been
/// streamed, where the ReadRowsResponse message only contains
/// request_stats.
/// * For example, if a read request would have returned an empty
/// response instead a single ReadRowsResponse is streamed with empty
/// chunks and request_stats filled.
///
/// Visually, response messages will stream as follows:
/// ... -> {chunks: \[...\]} -> {chunks: [], request_stats: {...}}
/// \______________________/ \________________________________/
/// Primary response Trailer of RequestStats info
///
/// Or if the read did not return any values:
/// {chunks: [], request_stats: {...}}
/// \________________________________/
/// Trailer of RequestStats info
#[ prost(message, optional, tag = " 3 " ) ]
pub request_stats : ::core ::option ::Option < RequestStats > ,
}
/// Nested message and enum types in `ReadRowsResponse`.
pub mod read_rows_response {
@ -780,8 +994,8 @@ pub struct SampleRowKeysResponse {
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct MutateRowRequest {
/// Required. The unique name of the table to which the mutation should be applied.
/// Values are of the form
/// Required. The unique name of the table to which the mutation should be
/// applied. Values are of the form
/// `projects/<project>/instances/<instance>/tables/<table>`.
#[ prost(string, tag = " 1 " ) ]
pub table_name : ::prost ::alloc ::string ::String ,
@ -792,9 +1006,9 @@ pub struct MutateRowRequest {
/// Required. The key of the row to which the mutation should be applied.
#[ prost(bytes = " vec " , tag = " 2 " ) ]
pub row_key : ::prost ::alloc ::vec ::Vec < u8 > ,
/// Required. Changes to be atomically applied to the specified row. Entries are applied
/// in order, meaning that earlier mutations can be masked by later ones.
/// Must contain at least one entry and at most 100000.
/// Required. Changes to be atomically applied to the specified row. Entries
/// are applied in order, meaning that earlier mutations can be masked by later
/// ones. Must contain at least one entry and at most 100000.
#[ prost(message, repeated, tag = " 3 " ) ]
pub mutations : ::prost ::alloc ::vec ::Vec < Mutation > ,
}
@ -806,7 +1020,8 @@ pub struct MutateRowResponse {}
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct MutateRowsRequest {
/// Required. The unique name of the table to which the mutations should be applied.
/// Required. The unique name of the table to which the mutations should be
/// applied.
#[ prost(string, tag = " 1 " ) ]
pub table_name : ::prost ::alloc ::string ::String ,
/// This value specifies routing for replication. If not specified, the
@ -830,10 +1045,9 @@ pub mod mutate_rows_request {
/// The key of the row to which the `mutations` should be applied.
#[ prost(bytes = " vec " , tag = " 1 " ) ]
pub row_key : ::prost ::alloc ::vec ::Vec < u8 > ,
/// Required. Changes to be atomically applied to the specified row. Mutations are
/// applied in order, meaning that earlier mutations can be masked by
/// later ones.
/// You must specify at least one mutation.
/// Required. Changes to be atomically applied to the specified row.
/// Mutations are applied in order, meaning that earlier mutations can be
/// masked by later ones. You must specify at least one mutation.
#[ prost(message, repeated, tag = " 2 " ) ]
pub mutations : ::prost ::alloc ::vec ::Vec < super ::Mutation > ,
}
@ -845,6 +1059,11 @@ pub struct MutateRowsResponse {
/// One or more results for Entries from the batch request.
#[ prost(message, repeated, tag = " 1 " ) ]
pub entries : ::prost ::alloc ::vec ::Vec < mutate_rows_response ::Entry > ,
/// Information about how client should limit the rate (QPS). Primirily used by
/// supported official Cloud Bigtable clients. If unset, the rate limit info is
/// not provided by the server.
#[ prost(message, optional, tag = " 3 " ) ]
pub rate_limit_info : ::core ::option ::Option < RateLimitInfo > ,
}
/// Nested message and enum types in `MutateRowsResponse`.
pub mod mutate_rows_response {
@ -864,13 +1083,36 @@ pub mod mutate_rows_response {
pub status : ::core ::option ::Option < super ::super ::super ::rpc ::Status > ,
}
}
/// Information about how client should adjust the load to Bigtable.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct RateLimitInfo {
/// Time that clients should wait before adjusting the target rate again.
/// If clients adjust rate too frequently, the impact of the previous
/// adjustment may not have been taken into account and may
/// over-throttle or under-throttle. If clients adjust rate too slowly, they
/// will not be responsive to load changes on server side, and may
/// over-throttle or under-throttle.
#[ prost(message, optional, tag = " 1 " ) ]
pub period : ::core ::option ::Option < ::prost_types ::Duration > ,
/// If it has been at least one `period` since the last load adjustment, the
/// client should multiply the current load by this value to get the new target
/// load. For example, if the current load is 100 and `factor` is 0.8, the new
/// target load should be 80. After adjusting, the client should ignore
/// `factor` until another `period` has passed.
///
/// The client can measure its load using any unit that's comparable over time
/// For example, QPS can be used as long as each request involves a similar
/// amount of work.
#[ prost(double, tag = " 2 " ) ]
pub factor : f64 ,
}
/// Request message for Bigtable.CheckAndMutateRow.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct CheckAndMutateRowRequest {
/// Required. The unique name of the table to which the conditional mutation should be
/// applied.
/// Values are of the form
/// Required. The unique name of the table to which the conditional mutation
/// should be applied. Values are of the form
/// `projects/<project>/instances/<instance>/tables/<table>`.
#[ prost(string, tag = " 1 " ) ]
pub table_name : ::prost ::alloc ::string ::String ,
@ -878,7 +1120,8 @@ pub struct CheckAndMutateRowRequest {
/// "default" application profile will be used.
#[ prost(string, tag = " 7 " ) ]
pub app_profile_id : ::prost ::alloc ::string ::String ,
/// Required. The key of the row to which the conditional mutation should be applied.
/// Required. The key of the row to which the conditional mutation should be
/// applied.
#[ prost(bytes = " vec " , tag = " 2 " ) ]
pub row_key : ::prost ::alloc ::vec ::Vec < u8 > ,
/// The filter to be applied to the contents of the specified row. Depending
@ -911,13 +1154,30 @@ pub struct CheckAndMutateRowResponse {
#[ prost(bool, tag = " 1 " ) ]
pub predicate_matched : bool ,
}
/// Request message for client connection keep-alive and warming.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct PingAndWarmRequest {
/// Required. The unique name of the instance to check permissions for as well
/// as respond. Values are of the form
/// `projects/<project>/instances/<instance>`.
#[ prost(string, tag = " 1 " ) ]
pub name : ::prost ::alloc ::string ::String ,
/// This value specifies routing for replication. If not specified, the
/// "default" application profile will be used.
#[ prost(string, tag = " 2 " ) ]
pub app_profile_id : ::prost ::alloc ::string ::String ,
}
/// Response message for Bigtable.PingAndWarm connection keepalive and warming.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct PingAndWarmResponse { }
/// Request message for Bigtable.ReadModifyWriteRow.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct ReadModifyWriteRowRequest {
/// Required. The unique name of the table to which the read/modify/write rules should be
/// applied.
/// Values are of the form
/// Required. The unique name of the table to which the read/modify/write rules
/// should be applied. Values are of the form
/// `projects/<project>/instances/<instance>/tables/<table>`.
#[ prost(string, tag = " 1 " ) ]
pub table_name : ::prost ::alloc ::string ::String ,
@ -925,12 +1185,13 @@ pub struct ReadModifyWriteRowRequest {
/// "default" application profile will be used.
#[ prost(string, tag = " 4 " ) ]
pub app_profile_id : ::prost ::alloc ::string ::String ,
/// Required. The key of the row to which the read/modify/write rules should be applied.
/// Required. The key of the row to which the read/modify/write rules should be
/// applied.
#[ prost(bytes = " vec " , tag = " 2 " ) ]
pub row_key : ::prost ::alloc ::vec ::Vec < u8 > ,
/// Required. Rules specifying how the specified row's contents are to be transformed
/// into writes. Entries are applied in order, meaning that earlier rules will
/// affect the results of later ones.
/// Required. Rules specifying how the specified row's contents are to be
/// transformed into writes. Entries are applied in order, meaning that earlier
/// rules will affect the results of later ones.
#[ prost(message, repeated, tag = " 3 " ) ]
pub rules : ::prost ::alloc ::vec ::Vec < ReadModifyWriteRule > ,
}
@ -942,6 +1203,312 @@ pub struct ReadModifyWriteRowResponse {
#[ prost(message, optional, tag = " 1 " ) ]
pub row : ::core ::option ::Option < Row > ,
}
/// NOTE: This API is intended to be used by Apache Beam BigtableIO.
/// Request message for Bigtable.GenerateInitialChangeStreamPartitions.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct GenerateInitialChangeStreamPartitionsRequest {
/// Required. The unique name of the table from which to get change stream
/// partitions. Values are of the form
/// `projects/<project>/instances/<instance>/tables/<table>`.
/// Change streaming must be enabled on the table.
#[ prost(string, tag = " 1 " ) ]
pub table_name : ::prost ::alloc ::string ::String ,
/// This value specifies routing for replication. If not specified, the
/// "default" application profile will be used.
/// Single cluster routing must be configured on the profile.
#[ prost(string, tag = " 2 " ) ]
pub app_profile_id : ::prost ::alloc ::string ::String ,
}
/// NOTE: This API is intended to be used by Apache Beam BigtableIO.
/// Response message for Bigtable.GenerateInitialChangeStreamPartitions.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct GenerateInitialChangeStreamPartitionsResponse {
/// A partition of the change stream.
#[ prost(message, optional, tag = " 1 " ) ]
pub partition : ::core ::option ::Option < StreamPartition > ,
}
/// NOTE: This API is intended to be used by Apache Beam BigtableIO.
/// Request message for Bigtable.ReadChangeStream.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct ReadChangeStreamRequest {
/// Required. The unique name of the table from which to read a change stream.
/// Values are of the form
/// `projects/<project>/instances/<instance>/tables/<table>`.
/// Change streaming must be enabled on the table.
#[ prost(string, tag = " 1 " ) ]
pub table_name : ::prost ::alloc ::string ::String ,
/// This value specifies routing for replication. If not specified, the
/// "default" application profile will be used.
/// Single cluster routing must be configured on the profile.
#[ prost(string, tag = " 2 " ) ]
pub app_profile_id : ::prost ::alloc ::string ::String ,
/// The partition to read changes from.
#[ prost(message, optional, tag = " 3 " ) ]
pub partition : ::core ::option ::Option < StreamPartition > ,
/// If specified, OK will be returned when the stream advances beyond
/// this time. Otherwise, changes will be continuously delivered on the stream.
/// This value is inclusive and will be truncated to microsecond granularity.
#[ prost(message, optional, tag = " 5 " ) ]
pub end_time : ::core ::option ::Option < ::prost_types ::Timestamp > ,
/// If specified, the duration between `Heartbeat` messages on the stream.
/// Otherwise, defaults to 5 seconds.
#[ prost(message, optional, tag = " 7 " ) ]
pub heartbeat_duration : ::core ::option ::Option < ::prost_types ::Duration > ,
/// Options for describing where we want to start reading from the stream.
#[ prost(oneof = " read_change_stream_request::StartFrom " , tags = " 4, 6 " ) ]
pub start_from : ::core ::option ::Option < read_change_stream_request ::StartFrom > ,
}
/// Nested message and enum types in `ReadChangeStreamRequest`.
pub mod read_change_stream_request {
/// Options for describing where we want to start reading from the stream.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Oneof) ]
pub enum StartFrom {
/// Start reading the stream at the specified timestamp. This timestamp must
/// be within the change stream retention period, less than or equal to the
/// current time, and after change stream creation, whichever is greater.
/// This value is inclusive and will be truncated to microsecond granularity.
#[ prost(message, tag = " 4 " ) ]
StartTime ( ::prost_types ::Timestamp ) ,
/// Tokens that describe how to resume reading a stream where reading
/// previously left off. If specified, changes will be read starting at the
/// the position. Tokens are delivered on the stream as part of `Heartbeat`
/// and `CloseStream` messages.
///
/// If a single token is provided, the token’ s partition must exactly match
/// the request’ s partition. If multiple tokens are provided, as in the case
/// of a partition merge, the union of the token partitions must exactly
/// cover the request’ s partition. Otherwise, INVALID_ARGUMENT will be
/// returned.
#[ prost(message, tag = " 6 " ) ]
ContinuationTokens ( super ::StreamContinuationTokens ) ,
}
}
/// NOTE: This API is intended to be used by Apache Beam BigtableIO.
/// Response message for Bigtable.ReadChangeStream.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct ReadChangeStreamResponse {
/// The data or control message on the stream.
#[ prost(oneof = " read_change_stream_response::StreamRecord " , tags = " 1, 2, 3 " ) ]
pub stream_record : ::core ::option ::Option < read_change_stream_response ::StreamRecord > ,
}
/// Nested message and enum types in `ReadChangeStreamResponse`.
pub mod read_change_stream_response {
/// A partial or complete mutation.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct MutationChunk {
/// If set, then the mutation is a `SetCell` with a chunked value across
/// multiple messages.
#[ prost(message, optional, tag = " 1 " ) ]
pub chunk_info : ::core ::option ::Option < mutation_chunk ::ChunkInfo > ,
/// If this is a continuation of a chunked message (`chunked_value_offset` >
/// 0), ignore all fields except the `SetCell`'s value and merge it with
/// the previous message by concatenating the value fields.
#[ prost(message, optional, tag = " 2 " ) ]
pub mutation : ::core ::option ::Option < super ::Mutation > ,
}
/// Nested message and enum types in `MutationChunk`.
pub mod mutation_chunk {
/// Information about the chunking of this mutation.
/// Only `SetCell` mutations can be chunked, and all chunks for a `SetCell`
/// will be delivered contiguously with no other mutation types interleaved.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct ChunkInfo {
/// The total value size of all the chunks that make up the `SetCell`.
#[ prost(int32, tag = " 1 " ) ]
pub chunked_value_size : i32 ,
/// The byte offset of this chunk into the total value size of the
/// mutation.
#[ prost(int32, tag = " 2 " ) ]
pub chunked_value_offset : i32 ,
/// When true, this is the last chunk of a chunked `SetCell`.
#[ prost(bool, tag = " 3 " ) ]
pub last_chunk : bool ,
}
}
/// A message corresponding to one or more mutations to the partition
/// being streamed. A single logical `DataChange` message may also be split
/// across a sequence of multiple individual messages. Messages other than
/// the first in a sequence will only have the `type` and `chunks` fields
/// populated, with the final message in the sequence also containing `done`
/// set to true.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct DataChange {
/// The type of the mutation.
#[ prost(enumeration = " data_change::Type " , tag = " 1 " ) ]
pub r#type : i32 ,
/// The cluster where the mutation was applied.
/// Not set when `type` is `GARBAGE_COLLECTION`.
#[ prost(string, tag = " 2 " ) ]
pub source_cluster_id : ::prost ::alloc ::string ::String ,
/// The row key for all mutations that are part of this `DataChange`.
/// If the `DataChange` is chunked across multiple messages, then this field
/// will only be set for the first message.
#[ prost(bytes = " vec " , tag = " 3 " ) ]
pub row_key : ::prost ::alloc ::vec ::Vec < u8 > ,
/// The timestamp at which the mutation was applied on the Bigtable server.
#[ prost(message, optional, tag = " 4 " ) ]
pub commit_timestamp : ::core ::option ::Option < ::prost_types ::Timestamp > ,
/// A value that lets stream consumers reconstruct Bigtable's
/// conflict resolution semantics.
/// <https://cloud.google.com/bigtable/docs/writes#conflict-resolution>
/// In the event that the same row key, column family, column qualifier,
/// timestamp are modified on different clusters at the same
/// `commit_timestamp`, the mutation with the larger `tiebreaker` will be the
/// one chosen for the eventually consistent state of the system.
#[ prost(int32, tag = " 5 " ) ]
pub tiebreaker : i32 ,
/// The mutations associated with this change to the partition.
/// May contain complete mutations or chunks of a multi-message chunked
/// `DataChange` record.
#[ prost(message, repeated, tag = " 6 " ) ]
pub chunks : ::prost ::alloc ::vec ::Vec < MutationChunk > ,
/// When true, indicates that the entire `DataChange` has been read
/// and the client can safely process the message.
#[ prost(bool, tag = " 8 " ) ]
pub done : bool ,
/// An encoded position for this stream's partition to restart reading from.
/// This token is for the StreamPartition from the request.
#[ prost(string, tag = " 9 " ) ]
pub token : ::prost ::alloc ::string ::String ,
/// An estimate of the commit timestamp that is usually lower than or equal
/// to any timestamp for a record that will be delivered in the future on the
/// stream. It is possible that, under particular circumstances that a future
/// record has a timestamp is is lower than a previously seen timestamp. For
/// an example usage see
/// <https://beam.apache.org/documentation/basics/#watermarks>
#[ prost(message, optional, tag = " 10 " ) ]
pub estimated_low_watermark : ::core ::option ::Option < ::prost_types ::Timestamp > ,
}
/// Nested message and enum types in `DataChange`.
pub mod data_change {
/// The type of mutation.
#[ derive(
Clone ,
Copy ,
Debug ,
PartialEq ,
Eq ,
Hash ,
PartialOrd ,
Ord ,
::prost ::Enumeration
) ]
#[ repr(i32) ]
pub enum Type {
/// The type is unspecified.
Unspecified = 0 ,
/// A user-initiated mutation.
User = 1 ,
/// A system-initiated mutation as part of garbage collection.
/// <https://cloud.google.com/bigtable/docs/garbage-collection>
GarbageCollection = 2 ,
/// This is a continuation of a multi-message change.
Continuation = 3 ,
}
impl Type {
/// String value of the enum field names used in the ProtoBuf definition.
///
/// The values are not transformed in any way and thus are considered stable
/// (if the ProtoBuf definition does not change) and safe for programmatic use.
pub fn as_str_name ( & self ) -> & 'static str {
match self {
Type ::Unspecified = > " TYPE_UNSPECIFIED " ,
Type ::User = > " USER " ,
Type ::GarbageCollection = > " GARBAGE_COLLECTION " ,
Type ::Continuation = > " CONTINUATION " ,
}
}
/// Creates an enum from field names used in the ProtoBuf definition.
pub fn from_str_name ( value : & str ) -> ::core ::option ::Option < Self > {
match value {
" TYPE_UNSPECIFIED " = > Some ( Self ::Unspecified ) ,
" USER " = > Some ( Self ::User ) ,
" GARBAGE_COLLECTION " = > Some ( Self ::GarbageCollection ) ,
" CONTINUATION " = > Some ( Self ::Continuation ) ,
_ = > None ,
}
}
}
}
/// A periodic message with information that can be used to checkpoint
/// the state of a stream.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct Heartbeat {
/// A token that can be provided to a subsequent `ReadChangeStream` call
/// to pick up reading at the current stream position.
#[ prost(message, optional, tag = " 1 " ) ]
pub continuation_token : ::core ::option ::Option < super ::StreamContinuationToken > ,
/// An estimate of the commit timestamp that is usually lower than or equal
/// to any timestamp for a record that will be delivered in the future on the
/// stream. It is possible that, under particular circumstances that a future
/// record has a timestamp is is lower than a previously seen timestamp. For
/// an example usage see
/// <https://beam.apache.org/documentation/basics/#watermarks>
#[ prost(message, optional, tag = " 2 " ) ]
pub estimated_low_watermark : ::core ::option ::Option < ::prost_types ::Timestamp > ,
}
/// A message indicating that the client should stop reading from the stream.
/// If status is OK and `continuation_tokens` & `new_partitions` are empty, the
/// stream has finished (for example if there was an `end_time` specified).
/// If `continuation_tokens` & `new_partitions` are present, then a change in
/// partitioning requires the client to open a new stream for each token to
/// resume reading. Example:
/// [B, D) ends
/// |
/// v
/// new_partitions: [A, C) [C, E)
/// continuation_tokens.partitions: [B,C) [C,D)
/// ^---^ ^---^
/// ^ ^
/// | |
/// | StreamContinuationToken 2
/// |
/// StreamContinuationToken 1
/// To read the new partition [A,C), supply the continuation tokens whose
/// ranges cover the new partition, for example ContinuationToken[A,B) &
/// ContinuationToken[B,C).
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Message) ]
pub struct CloseStream {
/// The status of the stream.
#[ prost(message, optional, tag = " 1 " ) ]
pub status : ::core ::option ::Option < super ::super ::super ::rpc ::Status > ,
/// If non-empty, contains the information needed to resume reading their
/// associated partitions.
#[ prost(message, repeated, tag = " 2 " ) ]
pub continuation_tokens : ::prost ::alloc ::vec ::Vec <
super ::StreamContinuationToken ,
> ,
/// If non-empty, contains the new partitions to start reading from, which
/// are related to but not necessarily identical to the partitions for the
/// above `continuation_tokens`.
#[ prost(message, repeated, tag = " 3 " ) ]
pub new_partitions : ::prost ::alloc ::vec ::Vec < super ::StreamPartition > ,
}
/// The data or control message on the stream.
#[ allow(clippy::derive_partial_eq_without_eq) ]
#[ derive(Clone, PartialEq, ::prost::Oneof) ]
pub enum StreamRecord {
/// A mutation to the partition.
#[ prost(message, tag = " 1 " ) ]
DataChange ( DataChange ) ,
/// A periodic heartbeat message.
#[ prost(message, tag = " 2 " ) ]
Heartbeat ( Heartbeat ) ,
/// An indication that the stream should be closed.
#[ prost(message, tag = " 3 " ) ]
CloseStream ( CloseStream ) ,
}
}
/// Generated client implementations.
pub mod bigtable_client {
#![ allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value) ]
@ -956,7 +1523,7 @@ pub mod bigtable_client {
/// Attempt to create a new client by connecting to a given endpoint.
pub async fn connect < D > ( dst : D ) -> Result < Self , tonic ::transport ::Error >
where
D : std::convert :: TryInto< tonic ::transport ::Endpoint > ,
D : TryInto< tonic ::transport ::Endpoint > ,
D ::Error : Into < StdError > ,
{
let conn = tonic ::transport ::Endpoint ::new ( dst ) ? . connect ( ) . await ? ;
@ -1012,6 +1579,22 @@ pub mod bigtable_client {
self . inner = self . inner . accept_compressed ( encoding ) ;
self
}
/// Limits the maximum size of a decoded message.
///
/// Default: `4MB`
#[ must_use ]
pub fn max_decoding_message_size ( mut self , limit : usize ) -> Self {
self . inner = self . inner . max_decoding_message_size ( limit ) ;
self
}
/// Limits the maximum size of an encoded message.
///
/// Default: `usize::MAX`
#[ must_use ]
pub fn max_encoding_message_size ( mut self , limit : usize ) -> Self {
self . inner = self . inner . max_encoding_message_size ( limit ) ;
self
}
/// Streams back the contents of all requested rows in key order, optionally
/// applying the same Reader filter to each. Depending on their size,
/// rows and cells may be broken up across multiple responses, but
@ -1020,7 +1603,7 @@ pub mod bigtable_client {
pub async fn read_rows (
& mut self ,
request : impl tonic ::IntoRequest < super ::ReadRowsRequest > ,
) -> Result <
) -> std ::result ::Result <
tonic ::Response < tonic ::codec ::Streaming < super ::ReadRowsResponse > > ,
tonic ::Status ,
> {
@ -1037,7 +1620,10 @@ pub mod bigtable_client {
let path = http ::uri ::PathAndQuery ::from_static (
" /google.bigtable.v2.Bigtable/ReadRows " ,
) ;
self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await
let mut req = request . into_request ( ) ;
req . extensions_mut ( )
. insert ( GrpcMethod ::new ( " google.bigtable.v2.Bigtable " , " ReadRows " ) ) ;
self . inner . server_streaming ( req , path , codec ) . await
}
/// Returns a sample of row keys in the table. The returned row keys will
/// delimit contiguous sections of the table of approximately equal size,
@ -1046,7 +1632,7 @@ pub mod bigtable_client {
pub async fn sample_row_keys (
& mut self ,
request : impl tonic ::IntoRequest < super ::SampleRowKeysRequest > ,
) -> Result <
) -> std ::result ::Result <
tonic ::Response < tonic ::codec ::Streaming < super ::SampleRowKeysResponse > > ,
tonic ::Status ,
> {
@ -1063,14 +1649,20 @@ pub mod bigtable_client {
let path = http ::uri ::PathAndQuery ::from_static (
" /google.bigtable.v2.Bigtable/SampleRowKeys " ,
) ;
self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await
let mut req = request . into_request ( ) ;
req . extensions_mut ( )
. insert ( GrpcMethod ::new ( " google.bigtable.v2.Bigtable " , " SampleRowKeys " ) ) ;
self . inner . server_streaming ( req , path , codec ) . await
}
/// Mutates a row atomically. Cells already present in the row are left
/// unchanged unless explicitly changed by `mutation`.
pub async fn mutate_row (
& mut self ,
request : impl tonic ::IntoRequest < super ::MutateRowRequest > ,
) -> Result < tonic ::Response < super ::MutateRowResponse > , tonic ::Status > {
) -> std ::result ::Result <
tonic ::Response < super ::MutateRowResponse > ,
tonic ::Status ,
> {
self . inner
. ready ( )
. await
@ -1084,7 +1676,10 @@ pub mod bigtable_client {
let path = http ::uri ::PathAndQuery ::from_static (
" /google.bigtable.v2.Bigtable/MutateRow " ,
) ;
self . inner . unary ( request . into_request ( ) , path , codec ) . await
let mut req = request . into_request ( ) ;
req . extensions_mut ( )
. insert ( GrpcMethod ::new ( " google.bigtable.v2.Bigtable " , " MutateRow " ) ) ;
self . inner . unary ( req , path , codec ) . await
}
/// Mutates multiple rows in a batch. Each individual row is mutated
/// atomically as in MutateRow, but the entire batch is not executed
@ -1092,7 +1687,7 @@ pub mod bigtable_client {
pub async fn mutate_rows (
& mut self ,
request : impl tonic ::IntoRequest < super ::MutateRowsRequest > ,
) -> Result <
) -> std ::result ::Result <
tonic ::Response < tonic ::codec ::Streaming < super ::MutateRowsResponse > > ,
tonic ::Status ,
> {
@ -1109,13 +1704,19 @@ pub mod bigtable_client {
let path = http ::uri ::PathAndQuery ::from_static (
" /google.bigtable.v2.Bigtable/MutateRows " ,
) ;
self . inner . server_streaming ( request . into_request ( ) , path , codec ) . await
let mut req = request . into_request ( ) ;
req . extensions_mut ( )
. insert ( GrpcMethod ::new ( " google.bigtable.v2.Bigtable " , " MutateRows " ) ) ;
self . inner . server_streaming ( req , path , codec ) . await
}
/// Mutates a row atomically based on the output of a predicate Reader filter.
pub async fn check_and_mutate_row (
& mut self ,
request : impl tonic ::IntoRequest < super ::CheckAndMutateRowRequest > ,
) -> Result < tonic ::Response < super ::CheckAndMutateRowResponse > , tonic ::Status > {
) -> std ::result ::Result <
tonic ::Response < super ::CheckAndMutateRowResponse > ,
tonic ::Status ,
> {
self . inner
. ready ( )
. await
@ -1129,7 +1730,39 @@ pub mod bigtable_client {
let path = http ::uri ::PathAndQuery ::from_static (
" /google.bigtable.v2.Bigtable/CheckAndMutateRow " ,
) ;
self . inner . unary ( request . into_request ( ) , path , codec ) . await
let mut req = request . into_request ( ) ;
req . extensions_mut ( )
. insert (
GrpcMethod ::new ( " google.bigtable.v2.Bigtable " , " CheckAndMutateRow " ) ,
) ;
self . inner . unary ( req , path , codec ) . await
}
/// Warm up associated instance metadata for this connection.
/// This call is not required but may be useful for connection keep-alive.
pub async fn ping_and_warm (
& mut self ,
request : impl tonic ::IntoRequest < super ::PingAndWarmRequest > ,
) -> std ::result ::Result <
tonic ::Response < super ::PingAndWarmResponse > ,
tonic ::Status ,
> {
self . inner
. ready ( )
. await
. map_err ( | e | {
tonic ::Status ::new (
tonic ::Code ::Unknown ,
format! ( " Service was not ready: {} " , e . into ( ) ) ,
)
} ) ? ;
let codec = tonic ::codec ::ProstCodec ::default ( ) ;
let path = http ::uri ::PathAndQuery ::from_static (
" /google.bigtable.v2.Bigtable/PingAndWarm " ,
) ;
let mut req = request . into_request ( ) ;
req . extensions_mut ( )
. insert ( GrpcMethod ::new ( " google.bigtable.v2.Bigtable " , " PingAndWarm " ) ) ;
self . inner . unary ( req , path , codec ) . await
}
/// Modifies a row atomically on the server. The method reads the latest
/// existing timestamp and value from the specified columns and writes a new
@ -1139,7 +1772,10 @@ pub mod bigtable_client {
pub async fn read_modify_write_row (
& mut self ,
request : impl tonic ::IntoRequest < super ::ReadModifyWriteRowRequest > ,
) -> Result < tonic ::Response < super ::ReadModifyWriteRowResponse > , tonic ::Status > {
) -> std ::result ::Result <
tonic ::Response < super ::ReadModifyWriteRowResponse > ,
tonic ::Status ,
> {
self . inner
. ready ( )
. await
@ -1153,7 +1789,85 @@ pub mod bigtable_client {
let path = http ::uri ::PathAndQuery ::from_static (
" /google.bigtable.v2.Bigtable/ReadModifyWriteRow " ,
) ;
self . inner . unary ( request . into_request ( ) , path , codec ) . await
let mut req = request . into_request ( ) ;
req . extensions_mut ( )
. insert (
GrpcMethod ::new ( " google.bigtable.v2.Bigtable " , " ReadModifyWriteRow " ) ,
) ;
self . inner . unary ( req , path , codec ) . await
}
/// NOTE: This API is intended to be used by Apache Beam BigtableIO.
/// Returns the current list of partitions that make up the table's
/// change stream. The union of partitions will cover the entire keyspace.
/// Partitions can be read with `ReadChangeStream`.
pub async fn generate_initial_change_stream_partitions (
& mut self ,
request : impl tonic ::IntoRequest <
super ::GenerateInitialChangeStreamPartitionsRequest ,
> ,
) -> std ::result ::Result <
tonic ::Response <
tonic ::codec ::Streaming <
super ::GenerateInitialChangeStreamPartitionsResponse ,
> ,
> ,
tonic ::Status ,
> {
self . inner
. ready ( )
. await
. map_err ( | e | {
tonic ::Status ::new (
tonic ::Code ::Unknown ,
format! ( " Service was not ready: {} " , e . into ( ) ) ,
)
} ) ? ;
let codec = tonic ::codec ::ProstCodec ::default ( ) ;
let path = http ::uri ::PathAndQuery ::from_static (
" /google.bigtable.v2.Bigtable/GenerateInitialChangeStreamPartitions " ,
) ;
let mut req = request . into_request ( ) ;
req . extensions_mut ( )
. insert (
GrpcMethod ::new (
" google.bigtable.v2.Bigtable " ,
" GenerateInitialChangeStreamPartitions " ,
) ,
) ;
self . inner . server_streaming ( req , path , codec ) . await
}
/// NOTE: This API is intended to be used by Apache Beam BigtableIO.
/// Reads changes from a table's change stream. Changes will
/// reflect both user-initiated mutations and mutations that are caused by
/// garbage collection.
pub async fn read_change_stream (
& mut self ,
request : impl tonic ::IntoRequest < super ::ReadChangeStreamRequest > ,
) -> std ::result ::Result <
tonic ::Response <
tonic ::codec ::Streaming < super ::ReadChangeStreamResponse > ,
> ,
tonic ::Status ,
> {
self . inner
. ready ( )
. await
. map_err ( | e | {
tonic ::Status ::new (
tonic ::Code ::Unknown ,
format! ( " Service was not ready: {} " , e . into ( ) ) ,
)
} ) ? ;
let codec = tonic ::codec ::ProstCodec ::default ( ) ;
let path = http ::uri ::PathAndQuery ::from_static (
" /google.bigtable.v2.Bigtable/ReadChangeStream " ,
) ;
let mut req = request . into_request ( ) ;
req . extensions_mut ( )
. insert (
GrpcMethod ::new ( " google.bigtable.v2.Bigtable " , " ReadChangeStream " ) ,
) ;
self . inner . server_streaming ( req , path , codec ) . await
}
}
}