#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommitResponse {
#[prost(message, optional, tag = "1")]
pub commit_timestamp: ::core::option::Option<::prost_types::Timestamp>,
#[prost(message, optional, tag = "2")]
pub commit_stats: ::core::option::Option<commit_response::CommitStats>,
}
pub mod commit_response {
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommitStats {
#[prost(int64, tag = "1")]
pub mutation_count: i64,
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KeyRange {
#[prost(oneof = "key_range::StartKeyType", tags = "1, 2")]
pub start_key_type: ::core::option::Option<key_range::StartKeyType>,
#[prost(oneof = "key_range::EndKeyType", tags = "3, 4")]
pub end_key_type: ::core::option::Option<key_range::EndKeyType>,
}
pub mod key_range {
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum StartKeyType {
#[prost(message, tag = "1")]
StartClosed(::prost_types::ListValue),
#[prost(message, tag = "2")]
StartOpen(::prost_types::ListValue),
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum EndKeyType {
#[prost(message, tag = "3")]
EndClosed(::prost_types::ListValue),
#[prost(message, tag = "4")]
EndOpen(::prost_types::ListValue),
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KeySet {
#[prost(message, repeated, tag = "1")]
pub keys: ::prost::alloc::vec::Vec<::prost_types::ListValue>,
#[prost(message, repeated, tag = "2")]
pub ranges: ::prost::alloc::vec::Vec<KeyRange>,
#[prost(bool, tag = "3")]
pub all: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mutation {
#[prost(oneof = "mutation::Operation", tags = "1, 2, 3, 4, 5")]
pub operation: ::core::option::Option<mutation::Operation>,
}
pub mod mutation {
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Write {
#[prost(string, tag = "1")]
pub table: ::prost::alloc::string::String,
#[prost(string, repeated, tag = "2")]
pub columns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(message, repeated, tag = "3")]
pub values: ::prost::alloc::vec::Vec<::prost_types::ListValue>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Delete {
#[prost(string, tag = "1")]
pub table: ::prost::alloc::string::String,
#[prost(message, optional, tag = "2")]
pub key_set: ::core::option::Option<super::KeySet>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Operation {
#[prost(message, tag = "1")]
Insert(Write),
#[prost(message, tag = "2")]
Update(Write),
#[prost(message, tag = "3")]
InsertOrUpdate(Write),
#[prost(message, tag = "4")]
Replace(Write),
#[prost(message, tag = "5")]
Delete(Delete),
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlanNode {
#[prost(int32, tag = "1")]
pub index: i32,
#[prost(enumeration = "plan_node::Kind", tag = "2")]
pub kind: i32,
#[prost(string, tag = "3")]
pub display_name: ::prost::alloc::string::String,
#[prost(message, repeated, tag = "4")]
pub child_links: ::prost::alloc::vec::Vec<plan_node::ChildLink>,
#[prost(message, optional, tag = "5")]
pub short_representation: ::core::option::Option<plan_node::ShortRepresentation>,
#[prost(message, optional, tag = "6")]
pub metadata: ::core::option::Option<::prost_types::Struct>,
#[prost(message, optional, tag = "7")]
pub execution_stats: ::core::option::Option<::prost_types::Struct>,
}
pub mod plan_node {
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ChildLink {
#[prost(int32, tag = "1")]
pub child_index: i32,
#[prost(string, tag = "2")]
pub r#type: ::prost::alloc::string::String,
#[prost(string, tag = "3")]
pub variable: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ShortRepresentation {
#[prost(string, tag = "1")]
pub description: ::prost::alloc::string::String,
#[prost(map = "string, int32", tag = "2")]
pub subqueries: ::std::collections::HashMap<::prost::alloc::string::String, i32>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Kind {
Unspecified = 0,
Relational = 1,
Scalar = 2,
}
impl Kind {
pub fn as_str_name(&self) -> &'static str {
match self {
Kind::Unspecified => "KIND_UNSPECIFIED",
Kind::Relational => "RELATIONAL",
Kind::Scalar => "SCALAR",
}
}
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryPlan {
#[prost(message, repeated, tag = "1")]
pub plan_nodes: ::prost::alloc::vec::Vec<PlanNode>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TransactionOptions {
#[prost(oneof = "transaction_options::Mode", tags = "1, 3, 2")]
pub mode: ::core::option::Option<transaction_options::Mode>,
}
pub mod transaction_options {
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadWrite {
#[prost(enumeration = "read_write::ReadLockMode", tag = "1")]
pub read_lock_mode: i32,
}
pub mod read_write {
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ReadLockMode {
Unspecified = 0,
Pessimistic = 1,
Optimistic = 2,
}
impl ReadLockMode {
pub fn as_str_name(&self) -> &'static str {
match self {
ReadLockMode::Unspecified => "READ_LOCK_MODE_UNSPECIFIED",
ReadLockMode::Pessimistic => "PESSIMISTIC",
ReadLockMode::Optimistic => "OPTIMISTIC",
}
}
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PartitionedDml {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadOnly {
#[prost(bool, tag = "6")]
pub return_read_timestamp: bool,
#[prost(oneof = "read_only::TimestampBound", tags = "1, 2, 3, 4, 5")]
pub timestamp_bound: ::core::option::Option<read_only::TimestampBound>,
}
pub mod read_only {
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum TimestampBound {
#[prost(bool, tag = "1")]
Strong(bool),
#[prost(message, tag = "2")]
MinReadTimestamp(::prost_types::Timestamp),
#[prost(message, tag = "3")]
MaxStaleness(::prost_types::Duration),
#[prost(message, tag = "4")]
ReadTimestamp(::prost_types::Timestamp),
#[prost(message, tag = "5")]
ExactStaleness(::prost_types::Duration),
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Mode {
#[prost(message, tag = "1")]
ReadWrite(ReadWrite),
#[prost(message, tag = "3")]
PartitionedDml(PartitionedDml),
#[prost(message, tag = "2")]
ReadOnly(ReadOnly),
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Transaction {
#[prost(bytes = "vec", tag = "1")]
pub id: ::prost::alloc::vec::Vec<u8>,
#[prost(message, optional, tag = "2")]
pub read_timestamp: ::core::option::Option<::prost_types::Timestamp>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TransactionSelector {
#[prost(oneof = "transaction_selector::Selector", tags = "1, 2, 3")]
pub selector: ::core::option::Option<transaction_selector::Selector>,
}
pub mod transaction_selector {
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Selector {
#[prost(message, tag = "1")]
SingleUse(super::TransactionOptions),
#[prost(bytes, tag = "2")]
Id(::prost::alloc::vec::Vec<u8>),
#[prost(message, tag = "3")]
Begin(super::TransactionOptions),
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Type {
#[prost(enumeration = "TypeCode", tag = "1")]
pub code: i32,
#[prost(message, optional, boxed, tag = "2")]
pub array_element_type: ::core::option::Option<::prost::alloc::boxed::Box<Type>>,
#[prost(message, optional, tag = "3")]
pub struct_type: ::core::option::Option<StructType>,
#[prost(enumeration = "TypeAnnotationCode", tag = "4")]
pub type_annotation: i32,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StructType {
#[prost(message, repeated, tag = "1")]
pub fields: ::prost::alloc::vec::Vec<struct_type::Field>,
}
pub mod struct_type {
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Field {
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
#[prost(message, optional, tag = "2")]
pub r#type: ::core::option::Option<super::Type>,
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TypeCode {
Unspecified = 0,
Bool = 1,
Int64 = 2,
Float64 = 3,
Timestamp = 4,
Date = 5,
String = 6,
Bytes = 7,
Array = 8,
Struct = 9,
Numeric = 10,
Json = 11,
}
impl TypeCode {
pub fn as_str_name(&self) -> &'static str {
match self {
TypeCode::Unspecified => "TYPE_CODE_UNSPECIFIED",
TypeCode::Bool => "BOOL",
TypeCode::Int64 => "INT64",
TypeCode::Float64 => "FLOAT64",
TypeCode::Timestamp => "TIMESTAMP",
TypeCode::Date => "DATE",
TypeCode::String => "STRING",
TypeCode::Bytes => "BYTES",
TypeCode::Array => "ARRAY",
TypeCode::Struct => "STRUCT",
TypeCode::Numeric => "NUMERIC",
TypeCode::Json => "JSON",
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TypeAnnotationCode {
Unspecified = 0,
PgNumeric = 2,
PgJsonb = 3,
}
impl TypeAnnotationCode {
pub fn as_str_name(&self) -> &'static str {
match self {
TypeAnnotationCode::Unspecified => "TYPE_ANNOTATION_CODE_UNSPECIFIED",
TypeAnnotationCode::PgNumeric => "PG_NUMERIC",
TypeAnnotationCode::PgJsonb => "PG_JSONB",
}
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResultSet {
#[prost(message, optional, tag = "1")]
pub metadata: ::core::option::Option<ResultSetMetadata>,
#[prost(message, repeated, tag = "2")]
pub rows: ::prost::alloc::vec::Vec<::prost_types::ListValue>,
#[prost(message, optional, tag = "3")]
pub stats: ::core::option::Option<ResultSetStats>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PartialResultSet {
#[prost(message, optional, tag = "1")]
pub metadata: ::core::option::Option<ResultSetMetadata>,
#[prost(message, repeated, tag = "2")]
pub values: ::prost::alloc::vec::Vec<::prost_types::Value>,
#[prost(bool, tag = "3")]
pub chunked_value: bool,
#[prost(bytes = "vec", tag = "4")]
pub resume_token: ::prost::alloc::vec::Vec<u8>,
#[prost(message, optional, tag = "5")]
pub stats: ::core::option::Option<ResultSetStats>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResultSetMetadata {
#[prost(message, optional, tag = "1")]
pub row_type: ::core::option::Option<StructType>,
#[prost(message, optional, tag = "2")]
pub transaction: ::core::option::Option<Transaction>,
#[prost(message, optional, tag = "3")]
pub undeclared_parameters: ::core::option::Option<StructType>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ResultSetStats {
#[prost(message, optional, tag = "1")]
pub query_plan: ::core::option::Option<QueryPlan>,
#[prost(message, optional, tag = "2")]
pub query_stats: ::core::option::Option<::prost_types::Struct>,
#[prost(oneof = "result_set_stats::RowCount", tags = "3, 4")]
pub row_count: ::core::option::Option<result_set_stats::RowCount>,
}
pub mod result_set_stats {
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum RowCount {
#[prost(int64, tag = "3")]
RowCountExact(i64),
#[prost(int64, tag = "4")]
RowCountLowerBound(i64),
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateSessionRequest {
#[prost(string, tag = "1")]
pub database: ::prost::alloc::string::String,
#[prost(message, optional, tag = "2")]
pub session: ::core::option::Option<Session>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchCreateSessionsRequest {
#[prost(string, tag = "1")]
pub database: ::prost::alloc::string::String,
#[prost(message, optional, tag = "2")]
pub session_template: ::core::option::Option<Session>,
#[prost(int32, tag = "3")]
pub session_count: i32,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BatchCreateSessionsResponse {
#[prost(message, repeated, tag = "1")]
pub session: ::prost::alloc::vec::Vec<Session>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Session {
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
#[prost(map = "string, string", tag = "2")]
pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
#[prost(message, optional, tag = "3")]
pub create_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(message, optional, tag = "4")]
pub approximate_last_use_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(string, tag = "5")]
pub creator_role: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetSessionRequest {
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSessionsRequest {
#[prost(string, tag = "1")]
pub database: ::prost::alloc::string::String,
#[prost(int32, tag = "2")]
pub page_size: i32,
#[prost(string, tag = "3")]
pub page_token: ::prost::alloc::string::String,
#[prost(string, tag = "4")]
pub filter: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListSessionsResponse {
#[prost(message, repeated, tag = "1")]
pub sessions: ::prost::alloc::vec::Vec<Session>,
#[prost(string, tag = "2")]
pub next_page_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteSessionRequest {
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RequestOptions {
#[prost(enumeration = "request_options::Priority", tag = "1")]
pub priority: i32,
#[prost(string, tag = "2")]
pub request_tag: ::prost::alloc::string::String,
#[prost(string, tag = "3")]
pub transaction_tag: ::prost::alloc::string::String,
}
pub mod request_options {
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Priority {
Unspecified = 0,
Low = 1,
Medium = 2,
High = 3,
}
impl Priority {
pub fn as_str_name(&self) -> &'static str {
match self {
Priority::Unspecified => "PRIORITY_UNSPECIFIED",
Priority::Low => "PRIORITY_LOW",
Priority::Medium => "PRIORITY_MEDIUM",
Priority::High => "PRIORITY_HIGH",
}
}
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecuteSqlRequest {
#[prost(string, tag = "1")]
pub session: ::prost::alloc::string::String,
#[prost(message, optional, tag = "2")]
pub transaction: ::core::option::Option<TransactionSelector>,
#[prost(string, tag = "3")]
pub sql: ::prost::alloc::string::String,
#[prost(message, optional, tag = "4")]
pub params: ::core::option::Option<::prost_types::Struct>,
#[prost(map = "string, message", tag = "5")]
pub param_types: ::std::collections::HashMap<::prost::alloc::string::String, Type>,
#[prost(bytes = "vec", tag = "6")]
pub resume_token: ::prost::alloc::vec::Vec<u8>,
#[prost(enumeration = "execute_sql_request::QueryMode", tag = "7")]
pub query_mode: i32,
#[prost(bytes = "vec", tag = "8")]
pub partition_token: ::prost::alloc::vec::Vec<u8>,
#[prost(int64, tag = "9")]
pub seqno: i64,
#[prost(message, optional, tag = "10")]
pub query_options: ::core::option::Option<execute_sql_request::QueryOptions>,
#[prost(message, optional, tag = "11")]
pub request_options: ::core::option::Option<RequestOptions>,
}
pub mod execute_sql_request {
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryOptions {
#[prost(string, tag = "1")]
pub optimizer_version: ::prost::alloc::string::String,
#[prost(string, tag = "2")]
pub optimizer_statistics_package: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum QueryMode {
Normal = 0,
Plan = 1,
Profile = 2,
}
impl QueryMode {
pub fn as_str_name(&self) -> &'static str {
match self {
QueryMode::Normal => "NORMAL",
QueryMode::Plan => "PLAN",
QueryMode::Profile => "PROFILE",
}
}
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecuteBatchDmlRequest {
#[prost(string, tag = "1")]
pub session: ::prost::alloc::string::String,
#[prost(message, optional, tag = "2")]
pub transaction: ::core::option::Option<TransactionSelector>,
#[prost(message, repeated, tag = "3")]
pub statements: ::prost::alloc::vec::Vec<execute_batch_dml_request::Statement>,
#[prost(int64, tag = "4")]
pub seqno: i64,
#[prost(message, optional, tag = "5")]
pub request_options: ::core::option::Option<RequestOptions>,
}
pub mod execute_batch_dml_request {
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Statement {
#[prost(string, tag = "1")]
pub sql: ::prost::alloc::string::String,
#[prost(message, optional, tag = "2")]
pub params: ::core::option::Option<::prost_types::Struct>,
#[prost(map = "string, message", tag = "3")]
pub param_types: ::std::collections::HashMap<::prost::alloc::string::String, super::Type>,
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecuteBatchDmlResponse {
#[prost(message, repeated, tag = "1")]
pub result_sets: ::prost::alloc::vec::Vec<ResultSet>,
#[prost(message, optional, tag = "2")]
pub status: ::core::option::Option<super::super::rpc::Status>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PartitionOptions {
#[prost(int64, tag = "1")]
pub partition_size_bytes: i64,
#[prost(int64, tag = "2")]
pub max_partitions: i64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PartitionQueryRequest {
#[prost(string, tag = "1")]
pub session: ::prost::alloc::string::String,
#[prost(message, optional, tag = "2")]
pub transaction: ::core::option::Option<TransactionSelector>,
#[prost(string, tag = "3")]
pub sql: ::prost::alloc::string::String,
#[prost(message, optional, tag = "4")]
pub params: ::core::option::Option<::prost_types::Struct>,
#[prost(map = "string, message", tag = "5")]
pub param_types: ::std::collections::HashMap<::prost::alloc::string::String, Type>,
#[prost(message, optional, tag = "6")]
pub partition_options: ::core::option::Option<PartitionOptions>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PartitionReadRequest {
#[prost(string, tag = "1")]
pub session: ::prost::alloc::string::String,
#[prost(message, optional, tag = "2")]
pub transaction: ::core::option::Option<TransactionSelector>,
#[prost(string, tag = "3")]
pub table: ::prost::alloc::string::String,
#[prost(string, tag = "4")]
pub index: ::prost::alloc::string::String,
#[prost(string, repeated, tag = "5")]
pub columns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(message, optional, tag = "6")]
pub key_set: ::core::option::Option<KeySet>,
#[prost(message, optional, tag = "9")]
pub partition_options: ::core::option::Option<PartitionOptions>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Partition {
#[prost(bytes = "vec", tag = "1")]
pub partition_token: ::prost::alloc::vec::Vec<u8>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PartitionResponse {
#[prost(message, repeated, tag = "1")]
pub partitions: ::prost::alloc::vec::Vec<Partition>,
#[prost(message, optional, tag = "2")]
pub transaction: ::core::option::Option<Transaction>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadRequest {
#[prost(string, tag = "1")]
pub session: ::prost::alloc::string::String,
#[prost(message, optional, tag = "2")]
pub transaction: ::core::option::Option<TransactionSelector>,
#[prost(string, tag = "3")]
pub table: ::prost::alloc::string::String,
#[prost(string, tag = "4")]
pub index: ::prost::alloc::string::String,
#[prost(string, repeated, tag = "5")]
pub columns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(message, optional, tag = "6")]
pub key_set: ::core::option::Option<KeySet>,
#[prost(int64, tag = "8")]
pub limit: i64,
#[prost(bytes = "vec", tag = "9")]
pub resume_token: ::prost::alloc::vec::Vec<u8>,
#[prost(bytes = "vec", tag = "10")]
pub partition_token: ::prost::alloc::vec::Vec<u8>,
#[prost(message, optional, tag = "11")]
pub request_options: ::core::option::Option<RequestOptions>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BeginTransactionRequest {
#[prost(string, tag = "1")]
pub session: ::prost::alloc::string::String,
#[prost(message, optional, tag = "2")]
pub options: ::core::option::Option<TransactionOptions>,
#[prost(message, optional, tag = "3")]
pub request_options: ::core::option::Option<RequestOptions>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommitRequest {
#[prost(string, tag = "1")]
pub session: ::prost::alloc::string::String,
#[prost(message, repeated, tag = "4")]
pub mutations: ::prost::alloc::vec::Vec<Mutation>,
#[prost(bool, tag = "5")]
pub return_commit_stats: bool,
#[prost(message, optional, tag = "6")]
pub request_options: ::core::option::Option<RequestOptions>,
#[prost(oneof = "commit_request::Transaction", tags = "2, 3")]
pub transaction: ::core::option::Option<commit_request::Transaction>,
}
pub mod commit_request {
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Transaction {
#[prost(bytes, tag = "2")]
TransactionId(::prost::alloc::vec::Vec<u8>),
#[prost(message, tag = "3")]
SingleUseTransaction(super::TransactionOptions),
}
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RollbackRequest {
#[prost(string, tag = "1")]
pub session: ::prost::alloc::string::String,
#[prost(bytes = "vec", tag = "2")]
pub transaction_id: ::prost::alloc::vec::Vec<u8>,
}
pub mod spanner_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::http::Uri;
use tonic::codegen::*;
#[derive(Debug, Clone)]
pub struct SpannerClient<T> {
inner: tonic::client::Grpc<T>,
}
impl SpannerClient<tonic::transport::Channel> {
pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
where
D: std::convert::TryInto<tonic::transport::Endpoint>,
D::Error: Into<StdError>,
{
let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
Ok(Self::new(conn))
}
}
impl<T> SpannerClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::Error: Into<StdError>,
T::ResponseBody: Body<Data = Bytes> + Send + 'static,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_origin(inner: T, origin: Uri) -> Self {
let inner = tonic::client::Grpc::with_origin(inner, origin);
Self { inner }
}
pub fn with_interceptor<F>(inner: T, interceptor: F) -> SpannerClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T::ResponseBody: Default,
T: tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
Response = http::Response<<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody>,
>,
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: Into<StdError> + Send + Sync,
{
SpannerClient::new(InterceptedService::new(inner, interceptor))
}
#[must_use]
pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.send_compressed(encoding);
self
}
#[must_use]
pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
self.inner = self.inner.accept_compressed(encoding);
self
}
pub async fn create_session(
&mut self,
request: impl tonic::IntoRequest<super::CreateSessionRequest>,
) -> Result<tonic::Response<super::Session>, 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.spanner.v1.Spanner/CreateSession");
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn batch_create_sessions(
&mut self,
request: impl tonic::IntoRequest<super::BatchCreateSessionsRequest>,
) -> Result<tonic::Response<super::BatchCreateSessionsResponse>, 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.spanner.v1.Spanner/BatchCreateSessions");
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn get_session(
&mut self,
request: impl tonic::IntoRequest<super::GetSessionRequest>,
) -> Result<tonic::Response<super::Session>, 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.spanner.v1.Spanner/GetSession");
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn list_sessions(
&mut self,
request: impl tonic::IntoRequest<super::ListSessionsRequest>,
) -> Result<tonic::Response<super::ListSessionsResponse>, 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.spanner.v1.Spanner/ListSessions");
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn delete_session(
&mut self,
request: impl tonic::IntoRequest<super::DeleteSessionRequest>,
) -> Result<tonic::Response<()>, 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.spanner.v1.Spanner/DeleteSession");
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn execute_sql(
&mut self,
request: impl tonic::IntoRequest<super::ExecuteSqlRequest>,
) -> Result<tonic::Response<super::ResultSet>, 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.spanner.v1.Spanner/ExecuteSql");
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn execute_streaming_sql(
&mut self,
request: impl tonic::IntoRequest<super::ExecuteSqlRequest>,
) -> Result<tonic::Response<tonic::codec::Streaming<super::PartialResultSet>>, 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.spanner.v1.Spanner/ExecuteStreamingSql");
self.inner.server_streaming(request.into_request(), path, codec).await
}
pub async fn execute_batch_dml(
&mut self,
request: impl tonic::IntoRequest<super::ExecuteBatchDmlRequest>,
) -> Result<tonic::Response<super::ExecuteBatchDmlResponse>, 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.spanner.v1.Spanner/ExecuteBatchDml");
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn read(
&mut self,
request: impl tonic::IntoRequest<super::ReadRequest>,
) -> Result<tonic::Response<super::ResultSet>, 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.spanner.v1.Spanner/Read");
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn streaming_read(
&mut self,
request: impl tonic::IntoRequest<super::ReadRequest>,
) -> Result<tonic::Response<tonic::codec::Streaming<super::PartialResultSet>>, 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.spanner.v1.Spanner/StreamingRead");
self.inner.server_streaming(request.into_request(), path, codec).await
}
pub async fn begin_transaction(
&mut self,
request: impl tonic::IntoRequest<super::BeginTransactionRequest>,
) -> Result<tonic::Response<super::Transaction>, 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.spanner.v1.Spanner/BeginTransaction");
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn commit(
&mut self,
request: impl tonic::IntoRequest<super::CommitRequest>,
) -> Result<tonic::Response<super::CommitResponse>, 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.spanner.v1.Spanner/Commit");
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn rollback(
&mut self,
request: impl tonic::IntoRequest<super::RollbackRequest>,
) -> Result<tonic::Response<()>, 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.spanner.v1.Spanner/Rollback");
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn partition_query(
&mut self,
request: impl tonic::IntoRequest<super::PartitionQueryRequest>,
) -> Result<tonic::Response<super::PartitionResponse>, 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.spanner.v1.Spanner/PartitionQuery");
self.inner.unary(request.into_request(), path, codec).await
}
pub async fn partition_read(
&mut self,
request: impl tonic::IntoRequest<super::PartitionReadRequest>,
) -> Result<tonic::Response<super::PartitionResponse>, 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.spanner.v1.Spanner/PartitionRead");
self.inner.unary(request.into_request(), path, codec).await
}
}
}