gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Bump tonic, prost, tarpc, tokio (#15013)

Browse Source 
* Update tonic & prost, and regenerate proto

* Reignore doc code

* Revert pull #14367, but pin tokio to v0.2 for jsonrpc

* Bump backoff and goauth -> and therefore tokio

* Bump tokio in faucet, net-utils

* Bump remaining tokio, plus tarpc
This commit is contained in:
Tyera Eulberg
2021-02-05 00:21:53 -07:00
committed by GitHub
parent 863f08f8d3
commit d1563f0ccd
33 changed files with 927 additions and 689 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
storage-bigtable/proto/google.bigtable.v2.rs
View File

@ -5,12 +5,12 @@ pub struct Row {
/// The unique key which identifies this row within its table. This is the same
/// key that's used to identify the row in, for example, a MutateRowRequest.
/// May contain any non-empty byte string up to 4KiB in length.
#[prost(bytes, tag = "1")]
pub key: std::vec::Vec<u8>,
#[prost(bytes = "vec", tag = "1")]
pub key: ::prost::alloc::vec::Vec<u8>,
/// May be empty, but only if the entire row is empty.
/// The mutual ordering of column families is not specified.
#[prost(message, repeated, tag = "2")]
pub families: ::std::vec::Vec<Family>,
pub families: ::prost::alloc::vec::Vec<Family>,
}
/// Specifies (some of) the contents of a single row/column family intersection
/// of a table.
@ -23,10 +23,10 @@ pub struct Family {
/// produce cells in a sentinel family with an empty name.
/// Must be no greater than 64 characters in length.
#[prost(string, tag = "1")]
pub name: std::string::String,
pub name: ::prost::alloc::string::String,
/// Must not be empty. Sorted in order of increasing "qualifier".
#[prost(message, repeated, tag = "2")]
pub columns: ::std::vec::Vec<Column>,
pub columns: ::prost::alloc::vec::Vec<Column>,
}
/// Specifies (some of) the contents of a single row/column intersection of a
/// table.
@ -37,11 +37,11 @@ pub struct Column {
/// which sets its `column_qualifier_regex_filter` field.
/// May contain any byte string, including the empty string, up to 16kiB in
/// length.
#[prost(bytes, tag = "1")]
pub qualifier: std::vec::Vec<u8>,
#[prost(bytes = "vec", tag = "1")]
pub qualifier: ::prost::alloc::vec::Vec<u8>,
/// Must not be empty. Sorted in order of decreasing "timestamp_micros".
#[prost(message, repeated, tag = "2")]
pub cells: ::std::vec::Vec<Cell>,
pub cells: ::prost::alloc::vec::Vec<Cell>,
}
/// Specifies (some of) the contents of a single row/column/timestamp of a table.
#[derive(Clone, PartialEq, ::prost::Message)]
@ -57,11 +57,11 @@ pub struct Cell {
/// The value stored in the cell.
/// May contain any byte string, including the empty string, up to 100MiB in
/// length.
#[prost(bytes, tag = "2")]
pub value: std::vec::Vec<u8>,
#[prost(bytes = "vec", tag = "2")]
pub value: ::prost::alloc::vec::Vec<u8>,
/// Labels applied to the cell by a [RowFilter][google.bigtable.v2.RowFilter].
#[prost(string, repeated, tag = "3")]
pub labels: ::std::vec::Vec<std::string::String>,
pub labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Specifies a contiguous range of rows.
#[derive(Clone, PartialEq, ::prost::Message)]
@ -69,12 +69,13 @@ pub struct RowRange {
/// The row key at which to start the range.
/// If neither field is set, interpreted as the empty string, inclusive.
#[prost(oneof = "row_range::StartKey", tags = "1, 2")]
pub start_key: ::std::option::Option<row_range::StartKey>,
pub start_key: ::core::option::Option<row_range::StartKey>,
/// The row key at which to end the range.
/// If neither field is set, interpreted as the infinite row key, exclusive.
#[prost(oneof = "row_range::EndKey", tags = "3, 4")]
pub end_key: ::std::option::Option<row_range::EndKey>,
pub end_key: ::core::option::Option<row_range::EndKey>,
}
/// Nested message and enum types in `RowRange`.
pub mod row_range {
/// The row key at which to start the range.
/// If neither field is set, interpreted as the empty string, inclusive.
@ -82,10 +83,10 @@ pub mod row_range {
pub enum StartKey {
/// Used when giving an inclusive lower bound for the range.
#[prost(bytes, tag = "1")]
StartKeyClosed(std::vec::Vec<u8>),
StartKeyClosed(::prost::alloc::vec::Vec<u8>),
/// Used when giving an exclusive lower bound for the range.
#[prost(bytes, tag = "2")]
StartKeyOpen(std::vec::Vec<u8>),
StartKeyOpen(::prost::alloc::vec::Vec<u8>),
}
/// The row key at which to end the range.
/// If neither field is set, interpreted as the infinite row key, exclusive.
@ -93,21 +94,21 @@ pub mod row_range {
pub enum EndKey {
/// Used when giving an exclusive upper bound for the range.
#[prost(bytes, tag = "3")]
EndKeyOpen(std::vec::Vec<u8>),
EndKeyOpen(::prost::alloc::vec::Vec<u8>),
/// Used when giving an inclusive upper bound for the range.
#[prost(bytes, tag = "4")]
EndKeyClosed(std::vec::Vec<u8>),
EndKeyClosed(::prost::alloc::vec::Vec<u8>),
}
}
/// Specifies a non-contiguous set of rows.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RowSet {
/// Single rows included in the set.
#[prost(bytes, repeated, tag = "1")]
pub row_keys: ::std::vec::Vec<std::vec::Vec<u8>>,
#[prost(bytes = "vec", repeated, tag = "1")]
pub row_keys: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
/// Contiguous row ranges included in the set.
#[prost(message, repeated, tag = "2")]
pub row_ranges: ::std::vec::Vec<RowRange>,
pub row_ranges: ::prost::alloc::vec::Vec<RowRange>,
}
/// Specifies a contiguous range of columns within a single column family.
/// The range spans from &lt;column_family&gt;:&lt;start_qualifier&gt; to
@ -117,16 +118,17 @@ pub struct RowSet {
pub struct ColumnRange {
/// The name of the column family within which this range falls.
#[prost(string, tag = "1")]
pub family_name: std::string::String,
pub family_name: ::prost::alloc::string::String,
/// The column qualifier at which to start the range (within `column_family`).
/// If neither field is set, interpreted as the empty string, inclusive.
#[prost(oneof = "column_range::StartQualifier", tags = "2, 3")]
pub start_qualifier: ::std::option::Option<column_range::StartQualifier>,
pub start_qualifier: ::core::option::Option<column_range::StartQualifier>,
/// The column qualifier at which to end the range (within `column_family`).
/// If neither field is set, interpreted as the infinite string, exclusive.
#[prost(oneof = "column_range::EndQualifier", tags = "4, 5")]
pub end_qualifier: ::std::option::Option<column_range::EndQualifier>,
pub end_qualifier: ::core::option::Option<column_range::EndQualifier>,
}
/// Nested message and enum types in `ColumnRange`.
pub mod column_range {
/// The column qualifier at which to start the range (within `column_family`).
/// If neither field is set, interpreted as the empty string, inclusive.
@ -134,10 +136,10 @@ pub mod column_range {
pub enum StartQualifier {
/// Used when giving an inclusive lower bound for the range.
#[prost(bytes, tag = "2")]
StartQualifierClosed(std::vec::Vec<u8>),
StartQualifierClosed(::prost::alloc::vec::Vec<u8>),
/// Used when giving an exclusive lower bound for the range.
#[prost(bytes, tag = "3")]
StartQualifierOpen(std::vec::Vec<u8>),
StartQualifierOpen(::prost::alloc::vec::Vec<u8>),
}
/// The column qualifier at which to end the range (within `column_family`).
/// If neither field is set, interpreted as the infinite string, exclusive.
@ -145,10 +147,10 @@ pub mod column_range {
pub enum EndQualifier {
/// Used when giving an inclusive upper bound for the range.
#[prost(bytes, tag = "4")]
EndQualifierClosed(std::vec::Vec<u8>),
EndQualifierClosed(::prost::alloc::vec::Vec<u8>),
/// Used when giving an exclusive upper bound for the range.
#[prost(bytes, tag = "5")]
EndQualifierOpen(std::vec::Vec<u8>),
EndQualifierOpen(::prost::alloc::vec::Vec<u8>),
}
}
/// Specified a contiguous range of microsecond timestamps.
@ -167,12 +169,13 @@ pub struct ValueRange {
/// The value at which to start the range.
/// If neither field is set, interpreted as the empty string, inclusive.
#[prost(oneof = "value_range::StartValue", tags = "1, 2")]
pub start_value: ::std::option::Option<value_range::StartValue>,
pub start_value: ::core::option::Option<value_range::StartValue>,
/// The value at which to end the range.
/// If neither field is set, interpreted as the infinite string, exclusive.
#[prost(oneof = "value_range::EndValue", tags = "3, 4")]
pub end_value: ::std::option::Option<value_range::EndValue>,
pub end_value: ::core::option::Option<value_range::EndValue>,
}
/// Nested message and enum types in `ValueRange`.
pub mod value_range {
/// The value at which to start the range.
/// If neither field is set, interpreted as the empty string, inclusive.
@ -180,10 +183,10 @@ pub mod value_range {
pub enum StartValue {
/// Used when giving an inclusive lower bound for the range.
#[prost(bytes, tag = "1")]
StartValueClosed(std::vec::Vec<u8>),
StartValueClosed(::prost::alloc::vec::Vec<u8>),
/// Used when giving an exclusive lower bound for the range.
#[prost(bytes, tag = "2")]
StartValueOpen(std::vec::Vec<u8>),
StartValueOpen(::prost::alloc::vec::Vec<u8>),
}
/// The value at which to end the range.
/// If neither field is set, interpreted as the infinite string, exclusive.
@ -191,10 +194,10 @@ pub mod value_range {
pub enum EndValue {
/// Used when giving an inclusive upper bound for the range.
#[prost(bytes, tag = "3")]
EndValueClosed(std::vec::Vec<u8>),
EndValueClosed(::prost::alloc::vec::Vec<u8>),
/// Used when giving an exclusive upper bound for the range.
#[prost(bytes, tag = "4")]
EndValueOpen(std::vec::Vec<u8>),
EndValueOpen(::prost::alloc::vec::Vec<u8>),
}
}
/// Takes a row as input and produces an alternate view of the row based on
@ -238,8 +241,9 @@ pub struct RowFilter {
oneof = "row_filter::Filter",
tags = "1, 2, 3, 16, 17, 18, 4, 14, 5, 6, 7, 8, 9, 15, 10, 11, 12, 13, 19"
)]
pub filter: ::std::option::Option<row_filter::Filter>,
pub filter: ::core::option::Option<row_filter::Filter>,
}
/// Nested message and enum types in `RowFilter`.
pub mod row_filter {
/// A RowFilter which sends rows through several RowFilters in sequence.
#[derive(Clone, PartialEq, ::prost::Message)]
@ -248,7 +252,7 @@ pub mod row_filter {
/// in row -> f(0) -> intermediate row -> f(1) -> ... -> f(N) -> out row
/// The full chain is executed atomically.
#[prost(message, repeated, tag = "1")]
pub filters: ::std::vec::Vec<super::RowFilter>,
pub filters: ::prost::alloc::vec::Vec<super::RowFilter>,
}
/// A RowFilter which sends each row to each of several component
/// RowFilters and interleaves the results.
@ -280,7 +284,7 @@ pub mod row_filter {
///
/// All interleaved filters are executed atomically.
#[prost(message, repeated, tag = "1")]
pub filters: ::std::vec::Vec<super::RowFilter>,
pub filters: ::prost::alloc::vec::Vec<super::RowFilter>,
}
/// A RowFilter which evaluates one of two possible RowFilters, depending on
/// whether or not a predicate RowFilter outputs any cells from the input row.
@ -294,16 +298,16 @@ pub mod row_filter {
/// If `predicate_filter` outputs any cells, then `true_filter` will be
/// evaluated on the input row. Otherwise, `false_filter` will be evaluated.
#[prost(message, optional, boxed, tag = "1")]
pub predicate_filter: ::std::option::Option<::std::boxed::Box<super::RowFilter>>,
pub predicate_filter: ::core::option::Option<::prost::alloc::boxed::Box<super::RowFilter>>,
/// The filter to apply to the input row if `predicate_filter` returns any
/// results. If not provided, no results will be returned in the true case.
#[prost(message, optional, boxed, tag = "2")]
pub true_filter: ::std::option::Option<::std::boxed::Box<super::RowFilter>>,
pub true_filter: ::core::option::Option<::prost::alloc::boxed::Box<super::RowFilter>>,
/// The filter to apply to the input row if `predicate_filter` does not
/// return any results. If not provided, no results will be returned in the
/// false case.
#[prost(message, optional, boxed, tag = "3")]
pub false_filter: ::std::option::Option<::std::boxed::Box<super::RowFilter>>,
pub false_filter: ::core::option::Option<::prost::alloc::boxed::Box<super::RowFilter>>,
}
/// Which of the possible RowFilter types to apply. If none are set, this
/// RowFilter returns all cells in the input row.
@ -320,7 +324,7 @@ pub mod row_filter {
/// Applies one of two possible RowFilters to the data based on the output of
/// a predicate RowFilter.
#[prost(message, tag = "3")]
Condition(Box<Condition>),
Condition(::prost::alloc::boxed::Box<Condition>),
/// ADVANCED USE ONLY.
/// Hook for introspection into the RowFilter. Outputs all cells directly to
/// the output of the read rather than to any parent filter. Consider the
@ -398,7 +402,7 @@ pub mod row_filter {
/// will not match the new line character `\n`, which may be present in a
/// binary key.
#[prost(bytes, tag = "4")]
RowKeyRegexFilter(std::vec::Vec<u8>),
RowKeyRegexFilter(::prost::alloc::vec::Vec<u8>),
/// Matches all cells from a row with probability p, and matches no cells
/// from the row with probability 1-p.
#[prost(double, tag = "14")]
@ -410,7 +414,7 @@ pub mod row_filter {
/// `\n`, it is sufficient to use `.` as a full wildcard when matching
/// column family names.
#[prost(string, tag = "5")]
FamilyNameRegexFilter(std::string::String),
FamilyNameRegexFilter(::prost::alloc::string::String),
/// Matches only cells from columns whose qualifiers satisfy the given RE2
/// regex.
/// Note that, since column qualifiers can contain arbitrary bytes, the `\C`
@ -418,7 +422,7 @@ pub mod row_filter {
/// character will not match the new line character `\n`, which may be
/// present in a binary qualifier.
#[prost(bytes, tag = "6")]
ColumnQualifierRegexFilter(std::vec::Vec<u8>),
ColumnQualifierRegexFilter(::prost::alloc::vec::Vec<u8>),
/// Matches only cells from columns within the given range.
#[prost(message, tag = "7")]
ColumnRangeFilter(super::ColumnRange),
@ -431,7 +435,7 @@ pub mod row_filter {
/// will not match the new line character `\n`, which may be present in a
/// binary value.
#[prost(bytes, tag = "9")]
ValueRegexFilter(std::vec::Vec<u8>),
ValueRegexFilter(::prost::alloc::vec::Vec<u8>),
/// Matches only cells with values that fall within the given range.
#[prost(message, tag = "15")]
ValueRangeFilter(super::ValueRange),
@ -470,7 +474,7 @@ pub mod row_filter {
/// will be applied to separate copies of the input. This may be relaxed in
/// the future.
#[prost(string, tag = "19")]
ApplyLabelTransformer(std::string::String),
ApplyLabelTransformer(::prost::alloc::string::String),
}
}
/// Specifies a particular change to be made to the contents of a row.
@ -478,8 +482,9 @@ pub mod row_filter {
pub struct Mutation {
/// Which of the possible Mutation types to apply.
#[prost(oneof = "mutation::Mutation", tags = "1, 2, 3, 4")]
pub mutation: ::std::option::Option<mutation::Mutation>,
pub mutation: ::core::option::Option<mutation::Mutation>,
}
/// Nested message and enum types in `Mutation`.
pub mod mutation {
/// A Mutation which sets the value of the specified cell.
#[derive(Clone, PartialEq, ::prost::Message)]
@ -487,11 +492,11 @@ pub mod mutation {
/// The name of the family into which new data should be written.
/// Must match `[-_.a-zA-Z0-9]+`
#[prost(string, tag = "1")]
pub family_name: std::string::String,
pub family_name: ::prost::alloc::string::String,
/// The qualifier of the column into which new data should be written.
/// Can be any byte string, including the empty string.
#[prost(bytes, tag = "2")]
pub column_qualifier: std::vec::Vec<u8>,
#[prost(bytes = "vec", tag = "2")]
pub column_qualifier: ::prost::alloc::vec::Vec<u8>,
/// The timestamp of the cell into which new data should be written.
/// Use -1 for current Bigtable server time.
/// Otherwise, the client should set this value itself, noting that the
@ -500,8 +505,8 @@ pub mod mutation {
#[prost(int64, tag = "3")]
pub timestamp_micros: i64,
/// The value to be written into the specified cell.
#[prost(bytes, tag = "4")]
pub value: std::vec::Vec<u8>,
#[prost(bytes = "vec", tag = "4")]
pub value: ::prost::alloc::vec::Vec<u8>,
}
/// A Mutation which deletes cells from the specified column, optionally
/// restricting the deletions to a given timestamp range.
@ -510,14 +515,14 @@ pub mod mutation {
/// The name of the family from which cells should be deleted.
/// Must match `[-_.a-zA-Z0-9]+`
#[prost(string, tag = "1")]
pub family_name: std::string::String,
pub family_name: ::prost::alloc::string::String,
/// The qualifier of the column from which cells should be deleted.
/// Can be any byte string, including the empty string.
#[prost(bytes, tag = "2")]
pub column_qualifier: std::vec::Vec<u8>,
#[prost(bytes = "vec", tag = "2")]
pub column_qualifier: ::prost::alloc::vec::Vec<u8>,
/// The range of timestamps within which cells should be deleted.
#[prost(message, optional, tag = "3")]
pub time_range: ::std::option::Option<super::TimestampRange>,
pub time_range: ::core::option::Option<super::TimestampRange>,
}
/// A Mutation which deletes all cells from the specified column family.
#[derive(Clone, PartialEq, ::prost::Message)]
@ -525,7 +530,7 @@ pub mod mutation {
/// The name of the family from which cells should be deleted.
/// Must match `[-_.a-zA-Z0-9]+`
#[prost(string, tag = "1")]
pub family_name: std::string::String,
pub family_name: ::prost::alloc::string::String,
}
/// A Mutation which deletes all cells from the containing row.
#[derive(Clone, PartialEq, ::prost::Message)]
@ -554,17 +559,18 @@ pub struct ReadModifyWriteRule {
/// The name of the family to which the read/modify/write should be applied.
/// Must match `[-_.a-zA-Z0-9]+`
#[prost(string, tag = "1")]
pub family_name: std::string::String,
pub family_name: ::prost::alloc::string::String,
/// The qualifier of the column to which the read/modify/write should be
/// applied.
/// Can be any byte string, including the empty string.
#[prost(bytes, tag = "2")]
pub column_qualifier: std::vec::Vec<u8>,
#[prost(bytes = "vec", tag = "2")]
pub column_qualifier: ::prost::alloc::vec::Vec<u8>,
/// The rule used to determine the column's new latest value from its current
/// latest value.
#[prost(oneof = "read_modify_write_rule::Rule", tags = "3, 4")]
pub rule: ::std::option::Option<read_modify_write_rule::Rule>,
pub rule: ::core::option::Option<read_modify_write_rule::Rule>,
}
/// Nested message and enum types in `ReadModifyWriteRule`.
pub mod read_modify_write_rule {
/// The rule used to determine the column's new latest value from its current
/// latest value.
@ -574,7 +580,7 @@ pub mod read_modify_write_rule {
/// If the targeted cell is unset, it will be treated as containing the
/// empty string.
#[prost(bytes, tag = "3")]
AppendValue(std::vec::Vec<u8>),
AppendValue(::prost::alloc::vec::Vec<u8>),
/// Rule specifying that `increment_amount` be added to the existing value.
/// If the targeted cell is unset, it will be treated as containing a zero.
/// Otherwise, the targeted cell must contain an 8-byte value (interpreted
@ -590,18 +596,18 @@ pub struct ReadRowsRequest {
/// Values are of the form
/// `projects/<project>/instances/<instance>/tables/<table>`.
#[prost(string, tag = "1")]
pub table_name: std::string::String,
pub table_name: ::prost::alloc::string::String,
/// This value specifies routing for replication. If not specified, the
/// "default" application profile will be used.
#[prost(string, tag = "5")]
pub app_profile_id: std::string::String,
pub app_profile_id: ::prost::alloc::string::String,
/// The row keys and/or ranges to read. If not specified, reads from all rows.
#[prost(message, optional, tag = "2")]
pub rows: ::std::option::Option<RowSet>,
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: ::std::option::Option<RowFilter>,
pub filter: ::core::option::Option<RowFilter>,
/// The read will terminate after committing to N rows' worth of results. The
/// default (zero) is to return all results.
#[prost(int64, tag = "4")]
@ -612,7 +618,7 @@ pub struct ReadRowsRequest {
pub struct ReadRowsResponse {
/// A collection of a row's contents as part of the read request.
#[prost(message, repeated, tag = "1")]
pub chunks: ::std::vec::Vec<read_rows_response::CellChunk>,
pub chunks: ::prost::alloc::vec::Vec<read_rows_response::CellChunk>,
/// Optionally the server might return the row key of the last row it
/// has scanned. The client can use this to construct a more
/// efficient retry request if needed: any row keys or portions of
@ -620,9 +626,10 @@ pub struct ReadRowsResponse {
/// This is primarily useful for cases where the server has read a
/// lot of data that was filtered out since the last committed row
/// key, allowing the client to skip that work on a retry.
#[prost(bytes, tag = "2")]
pub last_scanned_row_key: std::vec::Vec<u8>,
#[prost(bytes = "vec", tag = "2")]
pub last_scanned_row_key: ::prost::alloc::vec::Vec<u8>,
}
/// Nested message and enum types in `ReadRowsResponse`.
pub mod read_rows_response {
/// Specifies a piece of a row's contents returned as part of the read
/// response stream.
@ -632,8 +639,8 @@ pub mod read_rows_response {
/// 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.
#[prost(bytes, tag = "1")]
pub row_key: std::vec::Vec<u8>,
#[prost(bytes = "vec", tag = "1")]
pub row_key: ::prost::alloc::vec::Vec<u8>,
/// 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
@ -641,14 +648,14 @@ pub mod read_rows_response {
/// explicitly for the presence of this message, not just for
/// `family_name.value` being non-empty.
#[prost(message, optional, tag = "2")]
pub family_name: ::std::option::Option<::std::string::String>,
pub family_name: ::core::option::Option<::prost::alloc::string::String>,
/// 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.
#[prost(message, optional, tag = "3")]
pub qualifier: ::std::option::Option<::std::vec::Vec<u8>>,
pub qualifier: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
/// 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
@ -663,14 +670,14 @@ pub mod read_rows_response {
/// [RowFilter][google.bigtable.v2.RowFilter]. Labels are only set
/// on the first CellChunk per cell.
#[prost(string, repeated, tag = "5")]
pub labels: ::std::vec::Vec<std::string::String>,
pub labels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// 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.
#[prost(bytes, tag = "6")]
pub value: std::vec::Vec<u8>,
#[prost(bytes = "vec", tag = "6")]
pub value: ::prost::alloc::vec::Vec<u8>,
/// 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
@ -679,8 +686,9 @@ pub mod read_rows_response {
pub value_size: i32,
/// Signals to the client concerning previous CellChunks received.
#[prost(oneof = "cell_chunk::RowStatus", tags = "8, 9")]
pub row_status: ::std::option::Option<cell_chunk::RowStatus>,
pub row_status: ::core::option::Option<cell_chunk::RowStatus>,
}
/// Nested message and enum types in `CellChunk`.
pub mod cell_chunk {
/// Signals to the client concerning previous CellChunks received.
#[derive(Clone, PartialEq, ::prost::Oneof)]
@ -703,11 +711,11 @@ pub struct SampleRowKeysRequest {
/// Values are of the form
/// `projects/<project>/instances/<instance>/tables/<table>`.
#[prost(string, tag = "1")]
pub table_name: std::string::String,
pub table_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: std::string::String,
pub app_profile_id: ::prost::alloc::string::String,
}
/// Response message for Bigtable.SampleRowKeys.
#[derive(Clone, PartialEq, ::prost::Message)]
@ -719,8 +727,8 @@ pub struct SampleRowKeysResponse {
/// Note that row keys in this list may not have ever been written to or read
/// from, and users should therefore not make any assumptions about the row key
/// structure that are specific to their use case.
#[prost(bytes, tag = "1")]
pub row_key: std::vec::Vec<u8>,
#[prost(bytes = "vec", tag = "1")]
pub row_key: ::prost::alloc::vec::Vec<u8>,
/// Approximate total storage space used by all rows in the table which precede
/// `row_key`. Buffering the contents of all rows between two subsequent
/// samples would require space roughly equal to the difference in their
@ -735,19 +743,19 @@ pub struct MutateRowRequest {
/// Values are of the form
/// `projects/<project>/instances/<instance>/tables/<table>`.
#[prost(string, tag = "1")]
pub table_name: std::string::String,
pub table_name: ::prost::alloc::string::String,
/// This value specifies routing for replication. If not specified, the
/// "default" application profile will be used.
#[prost(string, tag = "4")]
pub app_profile_id: std::string::String,
pub app_profile_id: ::prost::alloc::string::String,
/// Required. The key of the row to which the mutation should be applied.
#[prost(bytes, tag = "2")]
pub row_key: std::vec::Vec<u8>,
#[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.
#[prost(message, repeated, tag = "3")]
pub mutations: ::std::vec::Vec<Mutation>,
pub mutations: ::prost::alloc::vec::Vec<Mutation>,
}
/// Response message for Bigtable.MutateRow.
#[derive(Clone, PartialEq, ::prost::Message)]
@ -757,32 +765,33 @@ pub struct MutateRowResponse {}
pub struct MutateRowsRequest {
/// Required. The unique name of the table to which the mutations should be applied.
#[prost(string, tag = "1")]
pub table_name: std::string::String,
pub table_name: ::prost::alloc::string::String,
/// This value specifies routing for replication. If not specified, the
/// "default" application profile will be used.
#[prost(string, tag = "3")]
pub app_profile_id: std::string::String,
pub app_profile_id: ::prost::alloc::string::String,
/// Required. The row keys and corresponding mutations to be applied in bulk.
/// Each entry is applied as an atomic mutation, but the entries may be
/// applied in arbitrary order (even between entries for the same row).
/// At least one entry must be specified, and in total the entries can
/// contain at most 100000 mutations.
#[prost(message, repeated, tag = "2")]
pub entries: ::std::vec::Vec<mutate_rows_request::Entry>,
pub entries: ::prost::alloc::vec::Vec<mutate_rows_request::Entry>,
}
/// Nested message and enum types in `MutateRowsRequest`.
pub mod mutate_rows_request {
/// A mutation for a given row.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Entry {
/// The key of the row to which the `mutations` should be applied.
#[prost(bytes, tag = "1")]
pub row_key: std::vec::Vec<u8>,
#[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.
#[prost(message, repeated, tag = "2")]
pub mutations: ::std::vec::Vec<super::Mutation>,
pub mutations: ::prost::alloc::vec::Vec<super::Mutation>,
}
}
/// Response message for BigtableService.MutateRows.
@ -790,8 +799,9 @@ pub mod mutate_rows_request {
pub struct MutateRowsResponse {
/// One or more results for Entries from the batch request.
#[prost(message, repeated, tag = "1")]
pub entries: ::std::vec::Vec<mutate_rows_response::Entry>,
pub entries: ::prost::alloc::vec::Vec<mutate_rows_response::Entry>,
}
/// Nested message and enum types in `MutateRowsResponse`.
pub mod mutate_rows_response {
/// The result of applying a passed mutation in the original request.
#[derive(Clone, PartialEq, ::prost::Message)]
@ -805,7 +815,7 @@ pub mod mutate_rows_response {
/// for one Entry to fail due to an error with another Entry. In the event
/// that this occurs, the same error will be reported for both entries.
#[prost(message, optional, tag = "2")]
pub status: ::std::option::Option<super::super::super::rpc::Status>,
pub status: ::core::option::Option<super::super::super::rpc::Status>,
}
}
/// Request message for Bigtable.CheckAndMutateRow.
@ -816,34 +826,34 @@ pub struct CheckAndMutateRowRequest {
/// Values are of the form
/// `projects/<project>/instances/<instance>/tables/<table>`.
#[prost(string, tag = "1")]
pub table_name: std::string::String,
pub table_name: ::prost::alloc::string::String,
/// This value specifies routing for replication. If not specified, the
/// "default" application profile will be used.
#[prost(string, tag = "7")]
pub app_profile_id: std::string::String,
pub app_profile_id: ::prost::alloc::string::String,
/// Required. The key of the row to which the conditional mutation should be applied.
#[prost(bytes, tag = "2")]
pub row_key: std::vec::Vec<u8>,
#[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
/// on whether or not any results are yielded, either `true_mutations` or
/// `false_mutations` will be executed. If unset, checks that the row contains
/// any values at all.
#[prost(message, optional, tag = "6")]
pub predicate_filter: ::std::option::Option<RowFilter>,
pub predicate_filter: ::core::option::Option<RowFilter>,
/// Changes to be atomically applied to the specified row if `predicate_filter`
/// yields at least one cell when applied to `row_key`. Entries are applied in
/// order, meaning that earlier mutations can be masked by later ones.
/// Must contain at least one entry if `false_mutations` is empty, and at most
/// 100000.
#[prost(message, repeated, tag = "4")]
pub true_mutations: ::std::vec::Vec<Mutation>,
pub true_mutations: ::prost::alloc::vec::Vec<Mutation>,
/// Changes to be atomically applied to the specified row if `predicate_filter`
/// does not yield any cells when applied to `row_key`. Entries are applied in
/// order, meaning that earlier mutations can be masked by later ones.
/// Must contain at least one entry if `true_mutations` is empty, and at most
/// 100000.
#[prost(message, repeated, tag = "5")]
pub false_mutations: ::std::vec::Vec<Mutation>,
pub false_mutations: ::prost::alloc::vec::Vec<Mutation>,
}
/// Response message for Bigtable.CheckAndMutateRow.
#[derive(Clone, PartialEq, ::prost::Message)]
@ -861,26 +871,26 @@ pub struct ReadModifyWriteRowRequest {
/// Values are of the form
/// `projects/<project>/instances/<instance>/tables/<table>`.
#[prost(string, tag = "1")]
pub table_name: std::string::String,
pub table_name: ::prost::alloc::string::String,
/// This value specifies routing for replication. If not specified, the
/// "default" application profile will be used.
#[prost(string, tag = "4")]
pub app_profile_id: std::string::String,
pub app_profile_id: ::prost::alloc::string::String,
/// Required. The key of the row to which the read/modify/write rules should be applied.
#[prost(bytes, tag = "2")]
pub row_key: std::vec::Vec<u8>,
#[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.
#[prost(message, repeated, tag = "3")]
pub rules: ::std::vec::Vec<ReadModifyWriteRule>,
pub rules: ::prost::alloc::vec::Vec<ReadModifyWriteRule>,
}
/// Response message for Bigtable.ReadModifyWriteRow.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadModifyWriteRowResponse {
/// A Row containing the new contents of all cells modified by the request.
#[prost(message, optional, tag = "1")]
pub row: ::std::option::Option<Row>,
pub row: ::core::option::Option<Row>,
}
#[doc = r" Generated client implementations."]
pub mod bigtable_client {