google-cloud-rust-raw 0.14.0

// This file is generated by rust-protobuf 2.28.0. Do not edit
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `google/spanner/v1/spanner.proto`

/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_28_0;

#[derive(PartialEq,Clone,Default)]
pub struct CreateSessionRequest {
    // message fields
    pub database: ::std::string::String,
    pub session: ::protobuf::SingularPtrField<Session>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CreateSessionRequest {
    fn default() -> &'a CreateSessionRequest {
        <CreateSessionRequest as ::protobuf::Message>::default_instance()
    }
}

impl CreateSessionRequest {
    pub fn new() -> CreateSessionRequest {
        ::std::default::Default::default()
    }

    // string database = 1;


    pub fn get_database(&self) -> &str {
        &self.database
    }
    pub fn clear_database(&mut self) {
        self.database.clear();
    }

    // Param is passed by value, moved
    pub fn set_database(&mut self, v: ::std::string::String) {
        self.database = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_database(&mut self) -> &mut ::std::string::String {
        &mut self.database
    }

    // Take field
    pub fn take_database(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.database, ::std::string::String::new())
    }

    // .google.spanner.v1.Session session = 2;


    pub fn get_session(&self) -> &Session {
        self.session.as_ref().unwrap_or_else(|| <Session as ::protobuf::Message>::default_instance())
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    pub fn has_session(&self) -> bool {
        self.session.is_some()
    }

    // Param is passed by value, moved
    pub fn set_session(&mut self, v: Session) {
        self.session = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session(&mut self) -> &mut Session {
        if self.session.is_none() {
            self.session.set_default();
        }
        self.session.as_mut().unwrap()
    }

    // Take field
    pub fn take_session(&mut self) -> Session {
        self.session.take().unwrap_or_else(|| Session::new())
    }
}

impl ::protobuf::Message for CreateSessionRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.session {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.database)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.session)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.database.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.database);
        }
        if let Some(ref v) = self.session.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.database.is_empty() {
            os.write_string(1, &self.database)?;
        }
        if let Some(ref v) = self.session.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CreateSessionRequest {
        CreateSessionRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "database",
                |m: &CreateSessionRequest| { &m.database },
                |m: &mut CreateSessionRequest| { &mut m.database },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Session>>(
                "session",
                |m: &CreateSessionRequest| { &m.session },
                |m: &mut CreateSessionRequest| { &mut m.session },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CreateSessionRequest>(
                "CreateSessionRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CreateSessionRequest {
        static instance: ::protobuf::rt::LazyV2<CreateSessionRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CreateSessionRequest::new)
    }
}

impl ::protobuf::Clear for CreateSessionRequest {
    fn clear(&mut self) {
        self.database.clear();
        self.session.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CreateSessionRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CreateSessionRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct BatchCreateSessionsRequest {
    // message fields
    pub database: ::std::string::String,
    pub session_template: ::protobuf::SingularPtrField<Session>,
    pub session_count: i32,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a BatchCreateSessionsRequest {
    fn default() -> &'a BatchCreateSessionsRequest {
        <BatchCreateSessionsRequest as ::protobuf::Message>::default_instance()
    }
}

impl BatchCreateSessionsRequest {
    pub fn new() -> BatchCreateSessionsRequest {
        ::std::default::Default::default()
    }

    // string database = 1;


    pub fn get_database(&self) -> &str {
        &self.database
    }
    pub fn clear_database(&mut self) {
        self.database.clear();
    }

    // Param is passed by value, moved
    pub fn set_database(&mut self, v: ::std::string::String) {
        self.database = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_database(&mut self) -> &mut ::std::string::String {
        &mut self.database
    }

    // Take field
    pub fn take_database(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.database, ::std::string::String::new())
    }

    // .google.spanner.v1.Session session_template = 2;


    pub fn get_session_template(&self) -> &Session {
        self.session_template.as_ref().unwrap_or_else(|| <Session as ::protobuf::Message>::default_instance())
    }
    pub fn clear_session_template(&mut self) {
        self.session_template.clear();
    }

    pub fn has_session_template(&self) -> bool {
        self.session_template.is_some()
    }

    // Param is passed by value, moved
    pub fn set_session_template(&mut self, v: Session) {
        self.session_template = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session_template(&mut self) -> &mut Session {
        if self.session_template.is_none() {
            self.session_template.set_default();
        }
        self.session_template.as_mut().unwrap()
    }

    // Take field
    pub fn take_session_template(&mut self) -> Session {
        self.session_template.take().unwrap_or_else(|| Session::new())
    }

    // int32 session_count = 3;


    pub fn get_session_count(&self) -> i32 {
        self.session_count
    }
    pub fn clear_session_count(&mut self) {
        self.session_count = 0;
    }

    // Param is passed by value, moved
    pub fn set_session_count(&mut self, v: i32) {
        self.session_count = v;
    }
}

impl ::protobuf::Message for BatchCreateSessionsRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.session_template {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.database)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.session_template)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.session_count = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.database.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.database);
        }
        if let Some(ref v) = self.session_template.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.session_count != 0 {
            my_size += ::protobuf::rt::value_size(3, self.session_count, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.database.is_empty() {
            os.write_string(1, &self.database)?;
        }
        if let Some(ref v) = self.session_template.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.session_count != 0 {
            os.write_int32(3, self.session_count)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> BatchCreateSessionsRequest {
        BatchCreateSessionsRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "database",
                |m: &BatchCreateSessionsRequest| { &m.database },
                |m: &mut BatchCreateSessionsRequest| { &mut m.database },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Session>>(
                "session_template",
                |m: &BatchCreateSessionsRequest| { &m.session_template },
                |m: &mut BatchCreateSessionsRequest| { &mut m.session_template },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "session_count",
                |m: &BatchCreateSessionsRequest| { &m.session_count },
                |m: &mut BatchCreateSessionsRequest| { &mut m.session_count },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<BatchCreateSessionsRequest>(
                "BatchCreateSessionsRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static BatchCreateSessionsRequest {
        static instance: ::protobuf::rt::LazyV2<BatchCreateSessionsRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(BatchCreateSessionsRequest::new)
    }
}

impl ::protobuf::Clear for BatchCreateSessionsRequest {
    fn clear(&mut self) {
        self.database.clear();
        self.session_template.clear();
        self.session_count = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for BatchCreateSessionsRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for BatchCreateSessionsRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct BatchCreateSessionsResponse {
    // message fields
    pub session: ::protobuf::RepeatedField<Session>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a BatchCreateSessionsResponse {
    fn default() -> &'a BatchCreateSessionsResponse {
        <BatchCreateSessionsResponse as ::protobuf::Message>::default_instance()
    }
}

impl BatchCreateSessionsResponse {
    pub fn new() -> BatchCreateSessionsResponse {
        ::std::default::Default::default()
    }

    // repeated .google.spanner.v1.Session session = 1;


    pub fn get_session(&self) -> &[Session] {
        &self.session
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    // Param is passed by value, moved
    pub fn set_session(&mut self, v: ::protobuf::RepeatedField<Session>) {
        self.session = v;
    }

    // Mutable pointer to the field.
    pub fn mut_session(&mut self) -> &mut ::protobuf::RepeatedField<Session> {
        &mut self.session
    }

    // Take field
    pub fn take_session(&mut self) -> ::protobuf::RepeatedField<Session> {
        ::std::mem::replace(&mut self.session, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for BatchCreateSessionsResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.session {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.session)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.session {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.session {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> BatchCreateSessionsResponse {
        BatchCreateSessionsResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Session>>(
                "session",
                |m: &BatchCreateSessionsResponse| { &m.session },
                |m: &mut BatchCreateSessionsResponse| { &mut m.session },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<BatchCreateSessionsResponse>(
                "BatchCreateSessionsResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static BatchCreateSessionsResponse {
        static instance: ::protobuf::rt::LazyV2<BatchCreateSessionsResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(BatchCreateSessionsResponse::new)
    }
}

impl ::protobuf::Clear for BatchCreateSessionsResponse {
    fn clear(&mut self) {
        self.session.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for BatchCreateSessionsResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for BatchCreateSessionsResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Session {
    // message fields
    pub name: ::std::string::String,
    pub labels: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
    pub create_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    pub approximate_last_use_time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Session {
    fn default() -> &'a Session {
        <Session as ::protobuf::Message>::default_instance()
    }
}

impl Session {
    pub fn new() -> Session {
        ::std::default::Default::default()
    }

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        &mut self.name
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.name, ::std::string::String::new())
    }

    // repeated .google.spanner.v1.Session.LabelsEntry labels = 2;


    pub fn get_labels(&self) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &self.labels
    }
    pub fn clear_labels(&mut self) {
        self.labels.clear();
    }

    // Param is passed by value, moved
    pub fn set_labels(&mut self, v: ::std::collections::HashMap<::std::string::String, ::std::string::String>) {
        self.labels = v;
    }

    // Mutable pointer to the field.
    pub fn mut_labels(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        &mut self.labels
    }

    // Take field
    pub fn take_labels(&mut self) -> ::std::collections::HashMap<::std::string::String, ::std::string::String> {
        ::std::mem::replace(&mut self.labels, ::std::collections::HashMap::new())
    }

    // .google.protobuf.Timestamp create_time = 3;


    pub fn get_create_time(&self) -> &::protobuf::well_known_types::Timestamp {
        self.create_time.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
    }
    pub fn clear_create_time(&mut self) {
        self.create_time.clear();
    }

    pub fn has_create_time(&self) -> bool {
        self.create_time.is_some()
    }

    // Param is passed by value, moved
    pub fn set_create_time(&mut self, v: ::protobuf::well_known_types::Timestamp) {
        self.create_time = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_create_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
        if self.create_time.is_none() {
            self.create_time.set_default();
        }
        self.create_time.as_mut().unwrap()
    }

    // Take field
    pub fn take_create_time(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.create_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }

    // .google.protobuf.Timestamp approximate_last_use_time = 4;


    pub fn get_approximate_last_use_time(&self) -> &::protobuf::well_known_types::Timestamp {
        self.approximate_last_use_time.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
    }
    pub fn clear_approximate_last_use_time(&mut self) {
        self.approximate_last_use_time.clear();
    }

    pub fn has_approximate_last_use_time(&self) -> bool {
        self.approximate_last_use_time.is_some()
    }

    // Param is passed by value, moved
    pub fn set_approximate_last_use_time(&mut self, v: ::protobuf::well_known_types::Timestamp) {
        self.approximate_last_use_time = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_approximate_last_use_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
        if self.approximate_last_use_time.is_none() {
            self.approximate_last_use_time.set_default();
        }
        self.approximate_last_use_time.as_mut().unwrap()
    }

    // Take field
    pub fn take_approximate_last_use_time(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.approximate_last_use_time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }
}

impl ::protobuf::Message for Session {
    fn is_initialized(&self) -> bool {
        for v in &self.create_time {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.approximate_last_use_time {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                2 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(wire_type, is, &mut self.labels)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.create_time)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.approximate_last_use_time)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.labels);
        if let Some(ref v) = self.create_time.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.approximate_last_use_time.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(2, &self.labels, os)?;
        if let Some(ref v) = self.create_time.as_ref() {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.approximate_last_use_time.as_ref() {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> Session {
        Session::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &Session| { &m.name },
                |m: &mut Session| { &mut m.name },
            ));
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeString>(
                "labels",
                |m: &Session| { &m.labels },
                |m: &mut Session| { &mut m.labels },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                "create_time",
                |m: &Session| { &m.create_time },
                |m: &mut Session| { &mut m.create_time },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                "approximate_last_use_time",
                |m: &Session| { &m.approximate_last_use_time },
                |m: &mut Session| { &mut m.approximate_last_use_time },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Session>(
                "Session",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static Session {
        static instance: ::protobuf::rt::LazyV2<Session> = ::protobuf::rt::LazyV2::INIT;
        instance.get(Session::new)
    }
}

impl ::protobuf::Clear for Session {
    fn clear(&mut self) {
        self.name.clear();
        self.labels.clear();
        self.create_time.clear();
        self.approximate_last_use_time.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Session {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Session {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct GetSessionRequest {
    // message fields
    pub name: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a GetSessionRequest {
    fn default() -> &'a GetSessionRequest {
        <GetSessionRequest as ::protobuf::Message>::default_instance()
    }
}

impl GetSessionRequest {
    pub fn new() -> GetSessionRequest {
        ::std::default::Default::default()
    }

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        &mut self.name
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.name, ::std::string::String::new())
    }
}

impl ::protobuf::Message for GetSessionRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> GetSessionRequest {
        GetSessionRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &GetSessionRequest| { &m.name },
                |m: &mut GetSessionRequest| { &mut m.name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetSessionRequest>(
                "GetSessionRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static GetSessionRequest {
        static instance: ::protobuf::rt::LazyV2<GetSessionRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(GetSessionRequest::new)
    }
}

impl ::protobuf::Clear for GetSessionRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for GetSessionRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for GetSessionRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ListSessionsRequest {
    // message fields
    pub database: ::std::string::String,
    pub page_size: i32,
    pub page_token: ::std::string::String,
    pub filter: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ListSessionsRequest {
    fn default() -> &'a ListSessionsRequest {
        <ListSessionsRequest as ::protobuf::Message>::default_instance()
    }
}

impl ListSessionsRequest {
    pub fn new() -> ListSessionsRequest {
        ::std::default::Default::default()
    }

    // string database = 1;


    pub fn get_database(&self) -> &str {
        &self.database
    }
    pub fn clear_database(&mut self) {
        self.database.clear();
    }

    // Param is passed by value, moved
    pub fn set_database(&mut self, v: ::std::string::String) {
        self.database = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_database(&mut self) -> &mut ::std::string::String {
        &mut self.database
    }

    // Take field
    pub fn take_database(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.database, ::std::string::String::new())
    }

    // int32 page_size = 2;


    pub fn get_page_size(&self) -> i32 {
        self.page_size
    }
    pub fn clear_page_size(&mut self) {
        self.page_size = 0;
    }

    // Param is passed by value, moved
    pub fn set_page_size(&mut self, v: i32) {
        self.page_size = v;
    }

    // string page_token = 3;


    pub fn get_page_token(&self) -> &str {
        &self.page_token
    }
    pub fn clear_page_token(&mut self) {
        self.page_token.clear();
    }

    // Param is passed by value, moved
    pub fn set_page_token(&mut self, v: ::std::string::String) {
        self.page_token = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_page_token(&mut self) -> &mut ::std::string::String {
        &mut self.page_token
    }

    // Take field
    pub fn take_page_token(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.page_token, ::std::string::String::new())
    }

    // string filter = 4;


    pub fn get_filter(&self) -> &str {
        &self.filter
    }
    pub fn clear_filter(&mut self) {
        self.filter.clear();
    }

    // Param is passed by value, moved
    pub fn set_filter(&mut self, v: ::std::string::String) {
        self.filter = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_filter(&mut self) -> &mut ::std::string::String {
        &mut self.filter
    }

    // Take field
    pub fn take_filter(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.filter, ::std::string::String::new())
    }
}

impl ::protobuf::Message for ListSessionsRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.database)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.page_size = tmp;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.filter)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.database.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.database);
        }
        if self.page_size != 0 {
            my_size += ::protobuf::rt::value_size(2, self.page_size, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.page_token);
        }
        if !self.filter.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.filter);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.database.is_empty() {
            os.write_string(1, &self.database)?;
        }
        if self.page_size != 0 {
            os.write_int32(2, self.page_size)?;
        }
        if !self.page_token.is_empty() {
            os.write_string(3, &self.page_token)?;
        }
        if !self.filter.is_empty() {
            os.write_string(4, &self.filter)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ListSessionsRequest {
        ListSessionsRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "database",
                |m: &ListSessionsRequest| { &m.database },
                |m: &mut ListSessionsRequest| { &mut m.database },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "page_size",
                |m: &ListSessionsRequest| { &m.page_size },
                |m: &mut ListSessionsRequest| { &mut m.page_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "page_token",
                |m: &ListSessionsRequest| { &m.page_token },
                |m: &mut ListSessionsRequest| { &mut m.page_token },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "filter",
                |m: &ListSessionsRequest| { &m.filter },
                |m: &mut ListSessionsRequest| { &mut m.filter },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListSessionsRequest>(
                "ListSessionsRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ListSessionsRequest {
        static instance: ::protobuf::rt::LazyV2<ListSessionsRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ListSessionsRequest::new)
    }
}

impl ::protobuf::Clear for ListSessionsRequest {
    fn clear(&mut self) {
        self.database.clear();
        self.page_size = 0;
        self.page_token.clear();
        self.filter.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ListSessionsRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ListSessionsRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ListSessionsResponse {
    // message fields
    pub sessions: ::protobuf::RepeatedField<Session>,
    pub next_page_token: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ListSessionsResponse {
    fn default() -> &'a ListSessionsResponse {
        <ListSessionsResponse as ::protobuf::Message>::default_instance()
    }
}

impl ListSessionsResponse {
    pub fn new() -> ListSessionsResponse {
        ::std::default::Default::default()
    }

    // repeated .google.spanner.v1.Session sessions = 1;


    pub fn get_sessions(&self) -> &[Session] {
        &self.sessions
    }
    pub fn clear_sessions(&mut self) {
        self.sessions.clear();
    }

    // Param is passed by value, moved
    pub fn set_sessions(&mut self, v: ::protobuf::RepeatedField<Session>) {
        self.sessions = v;
    }

    // Mutable pointer to the field.
    pub fn mut_sessions(&mut self) -> &mut ::protobuf::RepeatedField<Session> {
        &mut self.sessions
    }

    // Take field
    pub fn take_sessions(&mut self) -> ::protobuf::RepeatedField<Session> {
        ::std::mem::replace(&mut self.sessions, ::protobuf::RepeatedField::new())
    }

    // string next_page_token = 2;


    pub fn get_next_page_token(&self) -> &str {
        &self.next_page_token
    }
    pub fn clear_next_page_token(&mut self) {
        self.next_page_token.clear();
    }

    // Param is passed by value, moved
    pub fn set_next_page_token(&mut self, v: ::std::string::String) {
        self.next_page_token = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_next_page_token(&mut self) -> &mut ::std::string::String {
        &mut self.next_page_token
    }

    // Take field
    pub fn take_next_page_token(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.next_page_token, ::std::string::String::new())
    }
}

impl ::protobuf::Message for ListSessionsResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.sessions {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.sessions)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.sessions {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if !self.next_page_token.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.next_page_token);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.sessions {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if !self.next_page_token.is_empty() {
            os.write_string(2, &self.next_page_token)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ListSessionsResponse {
        ListSessionsResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Session>>(
                "sessions",
                |m: &ListSessionsResponse| { &m.sessions },
                |m: &mut ListSessionsResponse| { &mut m.sessions },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "next_page_token",
                |m: &ListSessionsResponse| { &m.next_page_token },
                |m: &mut ListSessionsResponse| { &mut m.next_page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListSessionsResponse>(
                "ListSessionsResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ListSessionsResponse {
        static instance: ::protobuf::rt::LazyV2<ListSessionsResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ListSessionsResponse::new)
    }
}

impl ::protobuf::Clear for ListSessionsResponse {
    fn clear(&mut self) {
        self.sessions.clear();
        self.next_page_token.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ListSessionsResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ListSessionsResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct DeleteSessionRequest {
    // message fields
    pub name: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a DeleteSessionRequest {
    fn default() -> &'a DeleteSessionRequest {
        <DeleteSessionRequest as ::protobuf::Message>::default_instance()
    }
}

impl DeleteSessionRequest {
    pub fn new() -> DeleteSessionRequest {
        ::std::default::Default::default()
    }

    // string name = 1;


    pub fn get_name(&self) -> &str {
        &self.name
    }
    pub fn clear_name(&mut self) {
        self.name.clear();
    }

    // Param is passed by value, moved
    pub fn set_name(&mut self, v: ::std::string::String) {
        self.name = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_name(&mut self) -> &mut ::std::string::String {
        &mut self.name
    }

    // Take field
    pub fn take_name(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.name, ::std::string::String::new())
    }
}

impl ::protobuf::Message for DeleteSessionRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.name)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> DeleteSessionRequest {
        DeleteSessionRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "name",
                |m: &DeleteSessionRequest| { &m.name },
                |m: &mut DeleteSessionRequest| { &mut m.name },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<DeleteSessionRequest>(
                "DeleteSessionRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static DeleteSessionRequest {
        static instance: ::protobuf::rt::LazyV2<DeleteSessionRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(DeleteSessionRequest::new)
    }
}

impl ::protobuf::Clear for DeleteSessionRequest {
    fn clear(&mut self) {
        self.name.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for DeleteSessionRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for DeleteSessionRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ExecuteSqlRequest {
    // message fields
    pub session: ::std::string::String,
    pub transaction: ::protobuf::SingularPtrField<super::transaction::TransactionSelector>,
    pub sql: ::std::string::String,
    pub params: ::protobuf::SingularPtrField<::protobuf::well_known_types::Struct>,
    pub param_types: ::std::collections::HashMap<::std::string::String, super::type_pb::Type>,
    pub resume_token: ::std::vec::Vec<u8>,
    pub query_mode: ExecuteSqlRequest_QueryMode,
    pub partition_token: ::std::vec::Vec<u8>,
    pub seqno: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ExecuteSqlRequest {
    fn default() -> &'a ExecuteSqlRequest {
        <ExecuteSqlRequest as ::protobuf::Message>::default_instance()
    }
}

impl ExecuteSqlRequest {
    pub fn new() -> ExecuteSqlRequest {
        ::std::default::Default::default()
    }

    // string session = 1;


    pub fn get_session(&self) -> &str {
        &self.session
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    // Param is passed by value, moved
    pub fn set_session(&mut self, v: ::std::string::String) {
        self.session = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session(&mut self) -> &mut ::std::string::String {
        &mut self.session
    }

    // Take field
    pub fn take_session(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.session, ::std::string::String::new())
    }

    // .google.spanner.v1.TransactionSelector transaction = 2;


    pub fn get_transaction(&self) -> &super::transaction::TransactionSelector {
        self.transaction.as_ref().unwrap_or_else(|| <super::transaction::TransactionSelector as ::protobuf::Message>::default_instance())
    }
    pub fn clear_transaction(&mut self) {
        self.transaction.clear();
    }

    pub fn has_transaction(&self) -> bool {
        self.transaction.is_some()
    }

    // Param is passed by value, moved
    pub fn set_transaction(&mut self, v: super::transaction::TransactionSelector) {
        self.transaction = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_transaction(&mut self) -> &mut super::transaction::TransactionSelector {
        if self.transaction.is_none() {
            self.transaction.set_default();
        }
        self.transaction.as_mut().unwrap()
    }

    // Take field
    pub fn take_transaction(&mut self) -> super::transaction::TransactionSelector {
        self.transaction.take().unwrap_or_else(|| super::transaction::TransactionSelector::new())
    }

    // string sql = 3;


    pub fn get_sql(&self) -> &str {
        &self.sql
    }
    pub fn clear_sql(&mut self) {
        self.sql.clear();
    }

    // Param is passed by value, moved
    pub fn set_sql(&mut self, v: ::std::string::String) {
        self.sql = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sql(&mut self) -> &mut ::std::string::String {
        &mut self.sql
    }

    // Take field
    pub fn take_sql(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.sql, ::std::string::String::new())
    }

    // .google.protobuf.Struct params = 4;


    pub fn get_params(&self) -> &::protobuf::well_known_types::Struct {
        self.params.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Struct as ::protobuf::Message>::default_instance())
    }
    pub fn clear_params(&mut self) {
        self.params.clear();
    }

    pub fn has_params(&self) -> bool {
        self.params.is_some()
    }

    // Param is passed by value, moved
    pub fn set_params(&mut self, v: ::protobuf::well_known_types::Struct) {
        self.params = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_params(&mut self) -> &mut ::protobuf::well_known_types::Struct {
        if self.params.is_none() {
            self.params.set_default();
        }
        self.params.as_mut().unwrap()
    }

    // Take field
    pub fn take_params(&mut self) -> ::protobuf::well_known_types::Struct {
        self.params.take().unwrap_or_else(|| ::protobuf::well_known_types::Struct::new())
    }

    // repeated .google.spanner.v1.ExecuteSqlRequest.ParamTypesEntry param_types = 5;


    pub fn get_param_types(&self) -> &::std::collections::HashMap<::std::string::String, super::type_pb::Type> {
        &self.param_types
    }
    pub fn clear_param_types(&mut self) {
        self.param_types.clear();
    }

    // Param is passed by value, moved
    pub fn set_param_types(&mut self, v: ::std::collections::HashMap<::std::string::String, super::type_pb::Type>) {
        self.param_types = v;
    }

    // Mutable pointer to the field.
    pub fn mut_param_types(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, super::type_pb::Type> {
        &mut self.param_types
    }

    // Take field
    pub fn take_param_types(&mut self) -> ::std::collections::HashMap<::std::string::String, super::type_pb::Type> {
        ::std::mem::replace(&mut self.param_types, ::std::collections::HashMap::new())
    }

    // bytes resume_token = 6;


    pub fn get_resume_token(&self) -> &[u8] {
        &self.resume_token
    }
    pub fn clear_resume_token(&mut self) {
        self.resume_token.clear();
    }

    // Param is passed by value, moved
    pub fn set_resume_token(&mut self, v: ::std::vec::Vec<u8>) {
        self.resume_token = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_resume_token(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.resume_token
    }

    // Take field
    pub fn take_resume_token(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.resume_token, ::std::vec::Vec::new())
    }

    // .google.spanner.v1.ExecuteSqlRequest.QueryMode query_mode = 7;


    pub fn get_query_mode(&self) -> ExecuteSqlRequest_QueryMode {
        self.query_mode
    }
    pub fn clear_query_mode(&mut self) {
        self.query_mode = ExecuteSqlRequest_QueryMode::NORMAL;
    }

    // Param is passed by value, moved
    pub fn set_query_mode(&mut self, v: ExecuteSqlRequest_QueryMode) {
        self.query_mode = v;
    }

    // bytes partition_token = 8;


    pub fn get_partition_token(&self) -> &[u8] {
        &self.partition_token
    }
    pub fn clear_partition_token(&mut self) {
        self.partition_token.clear();
    }

    // Param is passed by value, moved
    pub fn set_partition_token(&mut self, v: ::std::vec::Vec<u8>) {
        self.partition_token = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_partition_token(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.partition_token
    }

    // Take field
    pub fn take_partition_token(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.partition_token, ::std::vec::Vec::new())
    }

    // int64 seqno = 9;


    pub fn get_seqno(&self) -> i64 {
        self.seqno
    }
    pub fn clear_seqno(&mut self) {
        self.seqno = 0;
    }

    // Param is passed by value, moved
    pub fn set_seqno(&mut self, v: i64) {
        self.seqno = v;
    }
}

impl ::protobuf::Message for ExecuteSqlRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.transaction {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.params {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.sql)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.params)?;
                },
                5 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::type_pb::Type>>(wire_type, is, &mut self.param_types)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.resume_token)?;
                },
                7 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.query_mode, 7, &mut self.unknown_fields)?
                },
                8 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.partition_token)?;
                },
                9 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.seqno = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.session.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.session);
        }
        if let Some(ref v) = self.transaction.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.sql.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.sql);
        }
        if let Some(ref v) = self.params.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::type_pb::Type>>(5, &self.param_types);
        if !self.resume_token.is_empty() {
            my_size += ::protobuf::rt::bytes_size(6, &self.resume_token);
        }
        if self.query_mode != ExecuteSqlRequest_QueryMode::NORMAL {
            my_size += ::protobuf::rt::enum_size(7, self.query_mode);
        }
        if !self.partition_token.is_empty() {
            my_size += ::protobuf::rt::bytes_size(8, &self.partition_token);
        }
        if self.seqno != 0 {
            my_size += ::protobuf::rt::value_size(9, self.seqno, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.session.is_empty() {
            os.write_string(1, &self.session)?;
        }
        if let Some(ref v) = self.transaction.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if !self.sql.is_empty() {
            os.write_string(3, &self.sql)?;
        }
        if let Some(ref v) = self.params.as_ref() {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::type_pb::Type>>(5, &self.param_types, os)?;
        if !self.resume_token.is_empty() {
            os.write_bytes(6, &self.resume_token)?;
        }
        if self.query_mode != ExecuteSqlRequest_QueryMode::NORMAL {
            os.write_enum(7, ::protobuf::ProtobufEnum::value(&self.query_mode))?;
        }
        if !self.partition_token.is_empty() {
            os.write_bytes(8, &self.partition_token)?;
        }
        if self.seqno != 0 {
            os.write_int64(9, self.seqno)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ExecuteSqlRequest {
        ExecuteSqlRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "session",
                |m: &ExecuteSqlRequest| { &m.session },
                |m: &mut ExecuteSqlRequest| { &mut m.session },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::transaction::TransactionSelector>>(
                "transaction",
                |m: &ExecuteSqlRequest| { &m.transaction },
                |m: &mut ExecuteSqlRequest| { &mut m.transaction },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "sql",
                |m: &ExecuteSqlRequest| { &m.sql },
                |m: &mut ExecuteSqlRequest| { &mut m.sql },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Struct>>(
                "params",
                |m: &ExecuteSqlRequest| { &m.params },
                |m: &mut ExecuteSqlRequest| { &mut m.params },
            ));
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::type_pb::Type>>(
                "param_types",
                |m: &ExecuteSqlRequest| { &m.param_types },
                |m: &mut ExecuteSqlRequest| { &mut m.param_types },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "resume_token",
                |m: &ExecuteSqlRequest| { &m.resume_token },
                |m: &mut ExecuteSqlRequest| { &mut m.resume_token },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<ExecuteSqlRequest_QueryMode>>(
                "query_mode",
                |m: &ExecuteSqlRequest| { &m.query_mode },
                |m: &mut ExecuteSqlRequest| { &mut m.query_mode },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "partition_token",
                |m: &ExecuteSqlRequest| { &m.partition_token },
                |m: &mut ExecuteSqlRequest| { &mut m.partition_token },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "seqno",
                |m: &ExecuteSqlRequest| { &m.seqno },
                |m: &mut ExecuteSqlRequest| { &mut m.seqno },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ExecuteSqlRequest>(
                "ExecuteSqlRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ExecuteSqlRequest {
        static instance: ::protobuf::rt::LazyV2<ExecuteSqlRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ExecuteSqlRequest::new)
    }
}

impl ::protobuf::Clear for ExecuteSqlRequest {
    fn clear(&mut self) {
        self.session.clear();
        self.transaction.clear();
        self.sql.clear();
        self.params.clear();
        self.param_types.clear();
        self.resume_token.clear();
        self.query_mode = ExecuteSqlRequest_QueryMode::NORMAL;
        self.partition_token.clear();
        self.seqno = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ExecuteSqlRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ExecuteSqlRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum ExecuteSqlRequest_QueryMode {
    NORMAL = 0,
    PLAN = 1,
    PROFILE = 2,
}

impl ::protobuf::ProtobufEnum for ExecuteSqlRequest_QueryMode {
    fn value(&self) -> i32 {
        *self as i32
    }

    fn from_i32(value: i32) -> ::std::option::Option<ExecuteSqlRequest_QueryMode> {
        match value {
            0 => ::std::option::Option::Some(ExecuteSqlRequest_QueryMode::NORMAL),
            1 => ::std::option::Option::Some(ExecuteSqlRequest_QueryMode::PLAN),
            2 => ::std::option::Option::Some(ExecuteSqlRequest_QueryMode::PROFILE),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [ExecuteSqlRequest_QueryMode] = &[
            ExecuteSqlRequest_QueryMode::NORMAL,
            ExecuteSqlRequest_QueryMode::PLAN,
            ExecuteSqlRequest_QueryMode::PROFILE,
        ];
        values
    }

    fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            ::protobuf::reflect::EnumDescriptor::new_pb_name::<ExecuteSqlRequest_QueryMode>("ExecuteSqlRequest.QueryMode", file_descriptor_proto())
        })
    }
}

impl ::std::marker::Copy for ExecuteSqlRequest_QueryMode {
}

impl ::std::default::Default for ExecuteSqlRequest_QueryMode {
    fn default() -> Self {
        ExecuteSqlRequest_QueryMode::NORMAL
    }
}

impl ::protobuf::reflect::ProtobufValue for ExecuteSqlRequest_QueryMode {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ExecuteBatchDmlRequest {
    // message fields
    pub session: ::std::string::String,
    pub transaction: ::protobuf::SingularPtrField<super::transaction::TransactionSelector>,
    pub statements: ::protobuf::RepeatedField<ExecuteBatchDmlRequest_Statement>,
    pub seqno: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ExecuteBatchDmlRequest {
    fn default() -> &'a ExecuteBatchDmlRequest {
        <ExecuteBatchDmlRequest as ::protobuf::Message>::default_instance()
    }
}

impl ExecuteBatchDmlRequest {
    pub fn new() -> ExecuteBatchDmlRequest {
        ::std::default::Default::default()
    }

    // string session = 1;


    pub fn get_session(&self) -> &str {
        &self.session
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    // Param is passed by value, moved
    pub fn set_session(&mut self, v: ::std::string::String) {
        self.session = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session(&mut self) -> &mut ::std::string::String {
        &mut self.session
    }

    // Take field
    pub fn take_session(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.session, ::std::string::String::new())
    }

    // .google.spanner.v1.TransactionSelector transaction = 2;


    pub fn get_transaction(&self) -> &super::transaction::TransactionSelector {
        self.transaction.as_ref().unwrap_or_else(|| <super::transaction::TransactionSelector as ::protobuf::Message>::default_instance())
    }
    pub fn clear_transaction(&mut self) {
        self.transaction.clear();
    }

    pub fn has_transaction(&self) -> bool {
        self.transaction.is_some()
    }

    // Param is passed by value, moved
    pub fn set_transaction(&mut self, v: super::transaction::TransactionSelector) {
        self.transaction = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_transaction(&mut self) -> &mut super::transaction::TransactionSelector {
        if self.transaction.is_none() {
            self.transaction.set_default();
        }
        self.transaction.as_mut().unwrap()
    }

    // Take field
    pub fn take_transaction(&mut self) -> super::transaction::TransactionSelector {
        self.transaction.take().unwrap_or_else(|| super::transaction::TransactionSelector::new())
    }

    // repeated .google.spanner.v1.ExecuteBatchDmlRequest.Statement statements = 3;


    pub fn get_statements(&self) -> &[ExecuteBatchDmlRequest_Statement] {
        &self.statements
    }
    pub fn clear_statements(&mut self) {
        self.statements.clear();
    }

    // Param is passed by value, moved
    pub fn set_statements(&mut self, v: ::protobuf::RepeatedField<ExecuteBatchDmlRequest_Statement>) {
        self.statements = v;
    }

    // Mutable pointer to the field.
    pub fn mut_statements(&mut self) -> &mut ::protobuf::RepeatedField<ExecuteBatchDmlRequest_Statement> {
        &mut self.statements
    }

    // Take field
    pub fn take_statements(&mut self) -> ::protobuf::RepeatedField<ExecuteBatchDmlRequest_Statement> {
        ::std::mem::replace(&mut self.statements, ::protobuf::RepeatedField::new())
    }

    // int64 seqno = 4;


    pub fn get_seqno(&self) -> i64 {
        self.seqno
    }
    pub fn clear_seqno(&mut self) {
        self.seqno = 0;
    }

    // Param is passed by value, moved
    pub fn set_seqno(&mut self, v: i64) {
        self.seqno = v;
    }
}

impl ::protobuf::Message for ExecuteBatchDmlRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.transaction {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.statements {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.statements)?;
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.seqno = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.session.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.session);
        }
        if let Some(ref v) = self.transaction.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.statements {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.seqno != 0 {
            my_size += ::protobuf::rt::value_size(4, self.seqno, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.session.is_empty() {
            os.write_string(1, &self.session)?;
        }
        if let Some(ref v) = self.transaction.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        for v in &self.statements {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if self.seqno != 0 {
            os.write_int64(4, self.seqno)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ExecuteBatchDmlRequest {
        ExecuteBatchDmlRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "session",
                |m: &ExecuteBatchDmlRequest| { &m.session },
                |m: &mut ExecuteBatchDmlRequest| { &mut m.session },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::transaction::TransactionSelector>>(
                "transaction",
                |m: &ExecuteBatchDmlRequest| { &m.transaction },
                |m: &mut ExecuteBatchDmlRequest| { &mut m.transaction },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ExecuteBatchDmlRequest_Statement>>(
                "statements",
                |m: &ExecuteBatchDmlRequest| { &m.statements },
                |m: &mut ExecuteBatchDmlRequest| { &mut m.statements },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "seqno",
                |m: &ExecuteBatchDmlRequest| { &m.seqno },
                |m: &mut ExecuteBatchDmlRequest| { &mut m.seqno },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ExecuteBatchDmlRequest>(
                "ExecuteBatchDmlRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ExecuteBatchDmlRequest {
        static instance: ::protobuf::rt::LazyV2<ExecuteBatchDmlRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ExecuteBatchDmlRequest::new)
    }
}

impl ::protobuf::Clear for ExecuteBatchDmlRequest {
    fn clear(&mut self) {
        self.session.clear();
        self.transaction.clear();
        self.statements.clear();
        self.seqno = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ExecuteBatchDmlRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ExecuteBatchDmlRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ExecuteBatchDmlRequest_Statement {
    // message fields
    pub sql: ::std::string::String,
    pub params: ::protobuf::SingularPtrField<::protobuf::well_known_types::Struct>,
    pub param_types: ::std::collections::HashMap<::std::string::String, super::type_pb::Type>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ExecuteBatchDmlRequest_Statement {
    fn default() -> &'a ExecuteBatchDmlRequest_Statement {
        <ExecuteBatchDmlRequest_Statement as ::protobuf::Message>::default_instance()
    }
}

impl ExecuteBatchDmlRequest_Statement {
    pub fn new() -> ExecuteBatchDmlRequest_Statement {
        ::std::default::Default::default()
    }

    // string sql = 1;


    pub fn get_sql(&self) -> &str {
        &self.sql
    }
    pub fn clear_sql(&mut self) {
        self.sql.clear();
    }

    // Param is passed by value, moved
    pub fn set_sql(&mut self, v: ::std::string::String) {
        self.sql = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sql(&mut self) -> &mut ::std::string::String {
        &mut self.sql
    }

    // Take field
    pub fn take_sql(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.sql, ::std::string::String::new())
    }

    // .google.protobuf.Struct params = 2;


    pub fn get_params(&self) -> &::protobuf::well_known_types::Struct {
        self.params.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Struct as ::protobuf::Message>::default_instance())
    }
    pub fn clear_params(&mut self) {
        self.params.clear();
    }

    pub fn has_params(&self) -> bool {
        self.params.is_some()
    }

    // Param is passed by value, moved
    pub fn set_params(&mut self, v: ::protobuf::well_known_types::Struct) {
        self.params = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_params(&mut self) -> &mut ::protobuf::well_known_types::Struct {
        if self.params.is_none() {
            self.params.set_default();
        }
        self.params.as_mut().unwrap()
    }

    // Take field
    pub fn take_params(&mut self) -> ::protobuf::well_known_types::Struct {
        self.params.take().unwrap_or_else(|| ::protobuf::well_known_types::Struct::new())
    }

    // repeated .google.spanner.v1.ExecuteBatchDmlRequest.Statement.ParamTypesEntry param_types = 3;


    pub fn get_param_types(&self) -> &::std::collections::HashMap<::std::string::String, super::type_pb::Type> {
        &self.param_types
    }
    pub fn clear_param_types(&mut self) {
        self.param_types.clear();
    }

    // Param is passed by value, moved
    pub fn set_param_types(&mut self, v: ::std::collections::HashMap<::std::string::String, super::type_pb::Type>) {
        self.param_types = v;
    }

    // Mutable pointer to the field.
    pub fn mut_param_types(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, super::type_pb::Type> {
        &mut self.param_types
    }

    // Take field
    pub fn take_param_types(&mut self) -> ::std::collections::HashMap<::std::string::String, super::type_pb::Type> {
        ::std::mem::replace(&mut self.param_types, ::std::collections::HashMap::new())
    }
}

impl ::protobuf::Message for ExecuteBatchDmlRequest_Statement {
    fn is_initialized(&self) -> bool {
        for v in &self.params {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.sql)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.params)?;
                },
                3 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::type_pb::Type>>(wire_type, is, &mut self.param_types)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.sql.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.sql);
        }
        if let Some(ref v) = self.params.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::type_pb::Type>>(3, &self.param_types);
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.sql.is_empty() {
            os.write_string(1, &self.sql)?;
        }
        if let Some(ref v) = self.params.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::type_pb::Type>>(3, &self.param_types, os)?;
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ExecuteBatchDmlRequest_Statement {
        ExecuteBatchDmlRequest_Statement::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "sql",
                |m: &ExecuteBatchDmlRequest_Statement| { &m.sql },
                |m: &mut ExecuteBatchDmlRequest_Statement| { &mut m.sql },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Struct>>(
                "params",
                |m: &ExecuteBatchDmlRequest_Statement| { &m.params },
                |m: &mut ExecuteBatchDmlRequest_Statement| { &mut m.params },
            ));
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::type_pb::Type>>(
                "param_types",
                |m: &ExecuteBatchDmlRequest_Statement| { &m.param_types },
                |m: &mut ExecuteBatchDmlRequest_Statement| { &mut m.param_types },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ExecuteBatchDmlRequest_Statement>(
                "ExecuteBatchDmlRequest.Statement",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ExecuteBatchDmlRequest_Statement {
        static instance: ::protobuf::rt::LazyV2<ExecuteBatchDmlRequest_Statement> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ExecuteBatchDmlRequest_Statement::new)
    }
}

impl ::protobuf::Clear for ExecuteBatchDmlRequest_Statement {
    fn clear(&mut self) {
        self.sql.clear();
        self.params.clear();
        self.param_types.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ExecuteBatchDmlRequest_Statement {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ExecuteBatchDmlRequest_Statement {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ExecuteBatchDmlResponse {
    // message fields
    pub result_sets: ::protobuf::RepeatedField<super::result_set::ResultSet>,
    pub status: ::protobuf::SingularPtrField<super::status::Status>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ExecuteBatchDmlResponse {
    fn default() -> &'a ExecuteBatchDmlResponse {
        <ExecuteBatchDmlResponse as ::protobuf::Message>::default_instance()
    }
}

impl ExecuteBatchDmlResponse {
    pub fn new() -> ExecuteBatchDmlResponse {
        ::std::default::Default::default()
    }

    // repeated .google.spanner.v1.ResultSet result_sets = 1;


    pub fn get_result_sets(&self) -> &[super::result_set::ResultSet] {
        &self.result_sets
    }
    pub fn clear_result_sets(&mut self) {
        self.result_sets.clear();
    }

    // Param is passed by value, moved
    pub fn set_result_sets(&mut self, v: ::protobuf::RepeatedField<super::result_set::ResultSet>) {
        self.result_sets = v;
    }

    // Mutable pointer to the field.
    pub fn mut_result_sets(&mut self) -> &mut ::protobuf::RepeatedField<super::result_set::ResultSet> {
        &mut self.result_sets
    }

    // Take field
    pub fn take_result_sets(&mut self) -> ::protobuf::RepeatedField<super::result_set::ResultSet> {
        ::std::mem::replace(&mut self.result_sets, ::protobuf::RepeatedField::new())
    }

    // .google.rpc.Status status = 2;


    pub fn get_status(&self) -> &super::status::Status {
        self.status.as_ref().unwrap_or_else(|| <super::status::Status as ::protobuf::Message>::default_instance())
    }
    pub fn clear_status(&mut self) {
        self.status.clear();
    }

    pub fn has_status(&self) -> bool {
        self.status.is_some()
    }

    // Param is passed by value, moved
    pub fn set_status(&mut self, v: super::status::Status) {
        self.status = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_status(&mut self) -> &mut super::status::Status {
        if self.status.is_none() {
            self.status.set_default();
        }
        self.status.as_mut().unwrap()
    }

    // Take field
    pub fn take_status(&mut self) -> super::status::Status {
        self.status.take().unwrap_or_else(|| super::status::Status::new())
    }
}

impl ::protobuf::Message for ExecuteBatchDmlResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.result_sets {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.status {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.result_sets)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.status)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.result_sets {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.status.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.result_sets {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(ref v) = self.status.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ExecuteBatchDmlResponse {
        ExecuteBatchDmlResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::result_set::ResultSet>>(
                "result_sets",
                |m: &ExecuteBatchDmlResponse| { &m.result_sets },
                |m: &mut ExecuteBatchDmlResponse| { &mut m.result_sets },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::status::Status>>(
                "status",
                |m: &ExecuteBatchDmlResponse| { &m.status },
                |m: &mut ExecuteBatchDmlResponse| { &mut m.status },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ExecuteBatchDmlResponse>(
                "ExecuteBatchDmlResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ExecuteBatchDmlResponse {
        static instance: ::protobuf::rt::LazyV2<ExecuteBatchDmlResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ExecuteBatchDmlResponse::new)
    }
}

impl ::protobuf::Clear for ExecuteBatchDmlResponse {
    fn clear(&mut self) {
        self.result_sets.clear();
        self.status.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ExecuteBatchDmlResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ExecuteBatchDmlResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct PartitionOptions {
    // message fields
    pub partition_size_bytes: i64,
    pub max_partitions: i64,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a PartitionOptions {
    fn default() -> &'a PartitionOptions {
        <PartitionOptions as ::protobuf::Message>::default_instance()
    }
}

impl PartitionOptions {
    pub fn new() -> PartitionOptions {
        ::std::default::Default::default()
    }

    // int64 partition_size_bytes = 1;


    pub fn get_partition_size_bytes(&self) -> i64 {
        self.partition_size_bytes
    }
    pub fn clear_partition_size_bytes(&mut self) {
        self.partition_size_bytes = 0;
    }

    // Param is passed by value, moved
    pub fn set_partition_size_bytes(&mut self, v: i64) {
        self.partition_size_bytes = v;
    }

    // int64 max_partitions = 2;


    pub fn get_max_partitions(&self) -> i64 {
        self.max_partitions
    }
    pub fn clear_max_partitions(&mut self) {
        self.max_partitions = 0;
    }

    // Param is passed by value, moved
    pub fn set_max_partitions(&mut self, v: i64) {
        self.max_partitions = v;
    }
}

impl ::protobuf::Message for PartitionOptions {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.partition_size_bytes = tmp;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.max_partitions = tmp;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if self.partition_size_bytes != 0 {
            my_size += ::protobuf::rt::value_size(1, self.partition_size_bytes, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.max_partitions != 0 {
            my_size += ::protobuf::rt::value_size(2, self.max_partitions, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if self.partition_size_bytes != 0 {
            os.write_int64(1, self.partition_size_bytes)?;
        }
        if self.max_partitions != 0 {
            os.write_int64(2, self.max_partitions)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> PartitionOptions {
        PartitionOptions::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "partition_size_bytes",
                |m: &PartitionOptions| { &m.partition_size_bytes },
                |m: &mut PartitionOptions| { &mut m.partition_size_bytes },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "max_partitions",
                |m: &PartitionOptions| { &m.max_partitions },
                |m: &mut PartitionOptions| { &mut m.max_partitions },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PartitionOptions>(
                "PartitionOptions",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static PartitionOptions {
        static instance: ::protobuf::rt::LazyV2<PartitionOptions> = ::protobuf::rt::LazyV2::INIT;
        instance.get(PartitionOptions::new)
    }
}

impl ::protobuf::Clear for PartitionOptions {
    fn clear(&mut self) {
        self.partition_size_bytes = 0;
        self.max_partitions = 0;
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for PartitionOptions {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for PartitionOptions {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct PartitionQueryRequest {
    // message fields
    pub session: ::std::string::String,
    pub transaction: ::protobuf::SingularPtrField<super::transaction::TransactionSelector>,
    pub sql: ::std::string::String,
    pub params: ::protobuf::SingularPtrField<::protobuf::well_known_types::Struct>,
    pub param_types: ::std::collections::HashMap<::std::string::String, super::type_pb::Type>,
    pub partition_options: ::protobuf::SingularPtrField<PartitionOptions>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a PartitionQueryRequest {
    fn default() -> &'a PartitionQueryRequest {
        <PartitionQueryRequest as ::protobuf::Message>::default_instance()
    }
}

impl PartitionQueryRequest {
    pub fn new() -> PartitionQueryRequest {
        ::std::default::Default::default()
    }

    // string session = 1;


    pub fn get_session(&self) -> &str {
        &self.session
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    // Param is passed by value, moved
    pub fn set_session(&mut self, v: ::std::string::String) {
        self.session = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session(&mut self) -> &mut ::std::string::String {
        &mut self.session
    }

    // Take field
    pub fn take_session(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.session, ::std::string::String::new())
    }

    // .google.spanner.v1.TransactionSelector transaction = 2;


    pub fn get_transaction(&self) -> &super::transaction::TransactionSelector {
        self.transaction.as_ref().unwrap_or_else(|| <super::transaction::TransactionSelector as ::protobuf::Message>::default_instance())
    }
    pub fn clear_transaction(&mut self) {
        self.transaction.clear();
    }

    pub fn has_transaction(&self) -> bool {
        self.transaction.is_some()
    }

    // Param is passed by value, moved
    pub fn set_transaction(&mut self, v: super::transaction::TransactionSelector) {
        self.transaction = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_transaction(&mut self) -> &mut super::transaction::TransactionSelector {
        if self.transaction.is_none() {
            self.transaction.set_default();
        }
        self.transaction.as_mut().unwrap()
    }

    // Take field
    pub fn take_transaction(&mut self) -> super::transaction::TransactionSelector {
        self.transaction.take().unwrap_or_else(|| super::transaction::TransactionSelector::new())
    }

    // string sql = 3;


    pub fn get_sql(&self) -> &str {
        &self.sql
    }
    pub fn clear_sql(&mut self) {
        self.sql.clear();
    }

    // Param is passed by value, moved
    pub fn set_sql(&mut self, v: ::std::string::String) {
        self.sql = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_sql(&mut self) -> &mut ::std::string::String {
        &mut self.sql
    }

    // Take field
    pub fn take_sql(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.sql, ::std::string::String::new())
    }

    // .google.protobuf.Struct params = 4;


    pub fn get_params(&self) -> &::protobuf::well_known_types::Struct {
        self.params.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Struct as ::protobuf::Message>::default_instance())
    }
    pub fn clear_params(&mut self) {
        self.params.clear();
    }

    pub fn has_params(&self) -> bool {
        self.params.is_some()
    }

    // Param is passed by value, moved
    pub fn set_params(&mut self, v: ::protobuf::well_known_types::Struct) {
        self.params = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_params(&mut self) -> &mut ::protobuf::well_known_types::Struct {
        if self.params.is_none() {
            self.params.set_default();
        }
        self.params.as_mut().unwrap()
    }

    // Take field
    pub fn take_params(&mut self) -> ::protobuf::well_known_types::Struct {
        self.params.take().unwrap_or_else(|| ::protobuf::well_known_types::Struct::new())
    }

    // repeated .google.spanner.v1.PartitionQueryRequest.ParamTypesEntry param_types = 5;


    pub fn get_param_types(&self) -> &::std::collections::HashMap<::std::string::String, super::type_pb::Type> {
        &self.param_types
    }
    pub fn clear_param_types(&mut self) {
        self.param_types.clear();
    }

    // Param is passed by value, moved
    pub fn set_param_types(&mut self, v: ::std::collections::HashMap<::std::string::String, super::type_pb::Type>) {
        self.param_types = v;
    }

    // Mutable pointer to the field.
    pub fn mut_param_types(&mut self) -> &mut ::std::collections::HashMap<::std::string::String, super::type_pb::Type> {
        &mut self.param_types
    }

    // Take field
    pub fn take_param_types(&mut self) -> ::std::collections::HashMap<::std::string::String, super::type_pb::Type> {
        ::std::mem::replace(&mut self.param_types, ::std::collections::HashMap::new())
    }

    // .google.spanner.v1.PartitionOptions partition_options = 6;


    pub fn get_partition_options(&self) -> &PartitionOptions {
        self.partition_options.as_ref().unwrap_or_else(|| <PartitionOptions as ::protobuf::Message>::default_instance())
    }
    pub fn clear_partition_options(&mut self) {
        self.partition_options.clear();
    }

    pub fn has_partition_options(&self) -> bool {
        self.partition_options.is_some()
    }

    // Param is passed by value, moved
    pub fn set_partition_options(&mut self, v: PartitionOptions) {
        self.partition_options = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_partition_options(&mut self) -> &mut PartitionOptions {
        if self.partition_options.is_none() {
            self.partition_options.set_default();
        }
        self.partition_options.as_mut().unwrap()
    }

    // Take field
    pub fn take_partition_options(&mut self) -> PartitionOptions {
        self.partition_options.take().unwrap_or_else(|| PartitionOptions::new())
    }
}

impl ::protobuf::Message for PartitionQueryRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.transaction {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.params {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.partition_options {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.sql)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.params)?;
                },
                5 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::type_pb::Type>>(wire_type, is, &mut self.param_types)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.partition_options)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.session.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.session);
        }
        if let Some(ref v) = self.transaction.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.sql.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.sql);
        }
        if let Some(ref v) = self.params.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::type_pb::Type>>(5, &self.param_types);
        if let Some(ref v) = self.partition_options.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.session.is_empty() {
            os.write_string(1, &self.session)?;
        }
        if let Some(ref v) = self.transaction.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if !self.sql.is_empty() {
            os.write_string(3, &self.sql)?;
        }
        if let Some(ref v) = self.params.as_ref() {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::type_pb::Type>>(5, &self.param_types, os)?;
        if let Some(ref v) = self.partition_options.as_ref() {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> PartitionQueryRequest {
        PartitionQueryRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "session",
                |m: &PartitionQueryRequest| { &m.session },
                |m: &mut PartitionQueryRequest| { &mut m.session },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::transaction::TransactionSelector>>(
                "transaction",
                |m: &PartitionQueryRequest| { &m.transaction },
                |m: &mut PartitionQueryRequest| { &mut m.transaction },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "sql",
                |m: &PartitionQueryRequest| { &m.sql },
                |m: &mut PartitionQueryRequest| { &mut m.sql },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Struct>>(
                "params",
                |m: &PartitionQueryRequest| { &m.params },
                |m: &mut PartitionQueryRequest| { &mut m.params },
            ));
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeMessage<super::type_pb::Type>>(
                "param_types",
                |m: &PartitionQueryRequest| { &m.param_types },
                |m: &mut PartitionQueryRequest| { &mut m.param_types },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<PartitionOptions>>(
                "partition_options",
                |m: &PartitionQueryRequest| { &m.partition_options },
                |m: &mut PartitionQueryRequest| { &mut m.partition_options },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PartitionQueryRequest>(
                "PartitionQueryRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static PartitionQueryRequest {
        static instance: ::protobuf::rt::LazyV2<PartitionQueryRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(PartitionQueryRequest::new)
    }
}

impl ::protobuf::Clear for PartitionQueryRequest {
    fn clear(&mut self) {
        self.session.clear();
        self.transaction.clear();
        self.sql.clear();
        self.params.clear();
        self.param_types.clear();
        self.partition_options.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for PartitionQueryRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for PartitionQueryRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct PartitionReadRequest {
    // message fields
    pub session: ::std::string::String,
    pub transaction: ::protobuf::SingularPtrField<super::transaction::TransactionSelector>,
    pub table: ::std::string::String,
    pub index: ::std::string::String,
    pub columns: ::protobuf::RepeatedField<::std::string::String>,
    pub key_set: ::protobuf::SingularPtrField<super::keys::KeySet>,
    pub partition_options: ::protobuf::SingularPtrField<PartitionOptions>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a PartitionReadRequest {
    fn default() -> &'a PartitionReadRequest {
        <PartitionReadRequest as ::protobuf::Message>::default_instance()
    }
}

impl PartitionReadRequest {
    pub fn new() -> PartitionReadRequest {
        ::std::default::Default::default()
    }

    // string session = 1;


    pub fn get_session(&self) -> &str {
        &self.session
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    // Param is passed by value, moved
    pub fn set_session(&mut self, v: ::std::string::String) {
        self.session = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session(&mut self) -> &mut ::std::string::String {
        &mut self.session
    }

    // Take field
    pub fn take_session(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.session, ::std::string::String::new())
    }

    // .google.spanner.v1.TransactionSelector transaction = 2;


    pub fn get_transaction(&self) -> &super::transaction::TransactionSelector {
        self.transaction.as_ref().unwrap_or_else(|| <super::transaction::TransactionSelector as ::protobuf::Message>::default_instance())
    }
    pub fn clear_transaction(&mut self) {
        self.transaction.clear();
    }

    pub fn has_transaction(&self) -> bool {
        self.transaction.is_some()
    }

    // Param is passed by value, moved
    pub fn set_transaction(&mut self, v: super::transaction::TransactionSelector) {
        self.transaction = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_transaction(&mut self) -> &mut super::transaction::TransactionSelector {
        if self.transaction.is_none() {
            self.transaction.set_default();
        }
        self.transaction.as_mut().unwrap()
    }

    // Take field
    pub fn take_transaction(&mut self) -> super::transaction::TransactionSelector {
        self.transaction.take().unwrap_or_else(|| super::transaction::TransactionSelector::new())
    }

    // string table = 3;


    pub fn get_table(&self) -> &str {
        &self.table
    }
    pub fn clear_table(&mut self) {
        self.table.clear();
    }

    // Param is passed by value, moved
    pub fn set_table(&mut self, v: ::std::string::String) {
        self.table = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_table(&mut self) -> &mut ::std::string::String {
        &mut self.table
    }

    // Take field
    pub fn take_table(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.table, ::std::string::String::new())
    }

    // string index = 4;


    pub fn get_index(&self) -> &str {
        &self.index
    }
    pub fn clear_index(&mut self) {
        self.index.clear();
    }

    // Param is passed by value, moved
    pub fn set_index(&mut self, v: ::std::string::String) {
        self.index = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_index(&mut self) -> &mut ::std::string::String {
        &mut self.index
    }

    // Take field
    pub fn take_index(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.index, ::std::string::String::new())
    }

    // repeated string columns = 5;


    pub fn get_columns(&self) -> &[::std::string::String] {
        &self.columns
    }
    pub fn clear_columns(&mut self) {
        self.columns.clear();
    }

    // Param is passed by value, moved
    pub fn set_columns(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.columns = v;
    }

    // Mutable pointer to the field.
    pub fn mut_columns(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.columns
    }

    // Take field
    pub fn take_columns(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.columns, ::protobuf::RepeatedField::new())
    }

    // .google.spanner.v1.KeySet key_set = 6;


    pub fn get_key_set(&self) -> &super::keys::KeySet {
        self.key_set.as_ref().unwrap_or_else(|| <super::keys::KeySet as ::protobuf::Message>::default_instance())
    }
    pub fn clear_key_set(&mut self) {
        self.key_set.clear();
    }

    pub fn has_key_set(&self) -> bool {
        self.key_set.is_some()
    }

    // Param is passed by value, moved
    pub fn set_key_set(&mut self, v: super::keys::KeySet) {
        self.key_set = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_key_set(&mut self) -> &mut super::keys::KeySet {
        if self.key_set.is_none() {
            self.key_set.set_default();
        }
        self.key_set.as_mut().unwrap()
    }

    // Take field
    pub fn take_key_set(&mut self) -> super::keys::KeySet {
        self.key_set.take().unwrap_or_else(|| super::keys::KeySet::new())
    }

    // .google.spanner.v1.PartitionOptions partition_options = 9;


    pub fn get_partition_options(&self) -> &PartitionOptions {
        self.partition_options.as_ref().unwrap_or_else(|| <PartitionOptions as ::protobuf::Message>::default_instance())
    }
    pub fn clear_partition_options(&mut self) {
        self.partition_options.clear();
    }

    pub fn has_partition_options(&self) -> bool {
        self.partition_options.is_some()
    }

    // Param is passed by value, moved
    pub fn set_partition_options(&mut self, v: PartitionOptions) {
        self.partition_options = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_partition_options(&mut self) -> &mut PartitionOptions {
        if self.partition_options.is_none() {
            self.partition_options.set_default();
        }
        self.partition_options.as_mut().unwrap()
    }

    // Take field
    pub fn take_partition_options(&mut self) -> PartitionOptions {
        self.partition_options.take().unwrap_or_else(|| PartitionOptions::new())
    }
}

impl ::protobuf::Message for PartitionReadRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.transaction {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.key_set {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.partition_options {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.index)?;
                },
                5 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.columns)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.key_set)?;
                },
                9 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.partition_options)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.session.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.session);
        }
        if let Some(ref v) = self.transaction.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.table.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.table);
        }
        if !self.index.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.index);
        }
        for value in &self.columns {
            my_size += ::protobuf::rt::string_size(5, &value);
        };
        if let Some(ref v) = self.key_set.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.partition_options.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.session.is_empty() {
            os.write_string(1, &self.session)?;
        }
        if let Some(ref v) = self.transaction.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if !self.table.is_empty() {
            os.write_string(3, &self.table)?;
        }
        if !self.index.is_empty() {
            os.write_string(4, &self.index)?;
        }
        for v in &self.columns {
            os.write_string(5, &v)?;
        };
        if let Some(ref v) = self.key_set.as_ref() {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if let Some(ref v) = self.partition_options.as_ref() {
            os.write_tag(9, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> PartitionReadRequest {
        PartitionReadRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "session",
                |m: &PartitionReadRequest| { &m.session },
                |m: &mut PartitionReadRequest| { &mut m.session },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::transaction::TransactionSelector>>(
                "transaction",
                |m: &PartitionReadRequest| { &m.transaction },
                |m: &mut PartitionReadRequest| { &mut m.transaction },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "table",
                |m: &PartitionReadRequest| { &m.table },
                |m: &mut PartitionReadRequest| { &mut m.table },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "index",
                |m: &PartitionReadRequest| { &m.index },
                |m: &mut PartitionReadRequest| { &mut m.index },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "columns",
                |m: &PartitionReadRequest| { &m.columns },
                |m: &mut PartitionReadRequest| { &mut m.columns },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::keys::KeySet>>(
                "key_set",
                |m: &PartitionReadRequest| { &m.key_set },
                |m: &mut PartitionReadRequest| { &mut m.key_set },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<PartitionOptions>>(
                "partition_options",
                |m: &PartitionReadRequest| { &m.partition_options },
                |m: &mut PartitionReadRequest| { &mut m.partition_options },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PartitionReadRequest>(
                "PartitionReadRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static PartitionReadRequest {
        static instance: ::protobuf::rt::LazyV2<PartitionReadRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(PartitionReadRequest::new)
    }
}

impl ::protobuf::Clear for PartitionReadRequest {
    fn clear(&mut self) {
        self.session.clear();
        self.transaction.clear();
        self.table.clear();
        self.index.clear();
        self.columns.clear();
        self.key_set.clear();
        self.partition_options.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for PartitionReadRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for PartitionReadRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct Partition {
    // message fields
    pub partition_token: ::std::vec::Vec<u8>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a Partition {
    fn default() -> &'a Partition {
        <Partition as ::protobuf::Message>::default_instance()
    }
}

impl Partition {
    pub fn new() -> Partition {
        ::std::default::Default::default()
    }

    // bytes partition_token = 1;


    pub fn get_partition_token(&self) -> &[u8] {
        &self.partition_token
    }
    pub fn clear_partition_token(&mut self) {
        self.partition_token.clear();
    }

    // Param is passed by value, moved
    pub fn set_partition_token(&mut self, v: ::std::vec::Vec<u8>) {
        self.partition_token = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_partition_token(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.partition_token
    }

    // Take field
    pub fn take_partition_token(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.partition_token, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for Partition {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.partition_token)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.partition_token.is_empty() {
            my_size += ::protobuf::rt::bytes_size(1, &self.partition_token);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.partition_token.is_empty() {
            os.write_bytes(1, &self.partition_token)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> Partition {
        Partition::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "partition_token",
                |m: &Partition| { &m.partition_token },
                |m: &mut Partition| { &mut m.partition_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<Partition>(
                "Partition",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static Partition {
        static instance: ::protobuf::rt::LazyV2<Partition> = ::protobuf::rt::LazyV2::INIT;
        instance.get(Partition::new)
    }
}

impl ::protobuf::Clear for Partition {
    fn clear(&mut self) {
        self.partition_token.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for Partition {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for Partition {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct PartitionResponse {
    // message fields
    pub partitions: ::protobuf::RepeatedField<Partition>,
    pub transaction: ::protobuf::SingularPtrField<super::transaction::Transaction>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a PartitionResponse {
    fn default() -> &'a PartitionResponse {
        <PartitionResponse as ::protobuf::Message>::default_instance()
    }
}

impl PartitionResponse {
    pub fn new() -> PartitionResponse {
        ::std::default::Default::default()
    }

    // repeated .google.spanner.v1.Partition partitions = 1;


    pub fn get_partitions(&self) -> &[Partition] {
        &self.partitions
    }
    pub fn clear_partitions(&mut self) {
        self.partitions.clear();
    }

    // Param is passed by value, moved
    pub fn set_partitions(&mut self, v: ::protobuf::RepeatedField<Partition>) {
        self.partitions = v;
    }

    // Mutable pointer to the field.
    pub fn mut_partitions(&mut self) -> &mut ::protobuf::RepeatedField<Partition> {
        &mut self.partitions
    }

    // Take field
    pub fn take_partitions(&mut self) -> ::protobuf::RepeatedField<Partition> {
        ::std::mem::replace(&mut self.partitions, ::protobuf::RepeatedField::new())
    }

    // .google.spanner.v1.Transaction transaction = 2;


    pub fn get_transaction(&self) -> &super::transaction::Transaction {
        self.transaction.as_ref().unwrap_or_else(|| <super::transaction::Transaction as ::protobuf::Message>::default_instance())
    }
    pub fn clear_transaction(&mut self) {
        self.transaction.clear();
    }

    pub fn has_transaction(&self) -> bool {
        self.transaction.is_some()
    }

    // Param is passed by value, moved
    pub fn set_transaction(&mut self, v: super::transaction::Transaction) {
        self.transaction = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_transaction(&mut self) -> &mut super::transaction::Transaction {
        if self.transaction.is_none() {
            self.transaction.set_default();
        }
        self.transaction.as_mut().unwrap()
    }

    // Take field
    pub fn take_transaction(&mut self) -> super::transaction::Transaction {
        self.transaction.take().unwrap_or_else(|| super::transaction::Transaction::new())
    }
}

impl ::protobuf::Message for PartitionResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.partitions {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.transaction {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.partitions)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        for value in &self.partitions {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.transaction.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        for v in &self.partitions {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let Some(ref v) = self.transaction.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> PartitionResponse {
        PartitionResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<Partition>>(
                "partitions",
                |m: &PartitionResponse| { &m.partitions },
                |m: &mut PartitionResponse| { &mut m.partitions },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::transaction::Transaction>>(
                "transaction",
                |m: &PartitionResponse| { &m.transaction },
                |m: &mut PartitionResponse| { &mut m.transaction },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PartitionResponse>(
                "PartitionResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static PartitionResponse {
        static instance: ::protobuf::rt::LazyV2<PartitionResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(PartitionResponse::new)
    }
}

impl ::protobuf::Clear for PartitionResponse {
    fn clear(&mut self) {
        self.partitions.clear();
        self.transaction.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for PartitionResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for PartitionResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct ReadRequest {
    // message fields
    pub session: ::std::string::String,
    pub transaction: ::protobuf::SingularPtrField<super::transaction::TransactionSelector>,
    pub table: ::std::string::String,
    pub index: ::std::string::String,
    pub columns: ::protobuf::RepeatedField<::std::string::String>,
    pub key_set: ::protobuf::SingularPtrField<super::keys::KeySet>,
    pub limit: i64,
    pub resume_token: ::std::vec::Vec<u8>,
    pub partition_token: ::std::vec::Vec<u8>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a ReadRequest {
    fn default() -> &'a ReadRequest {
        <ReadRequest as ::protobuf::Message>::default_instance()
    }
}

impl ReadRequest {
    pub fn new() -> ReadRequest {
        ::std::default::Default::default()
    }

    // string session = 1;


    pub fn get_session(&self) -> &str {
        &self.session
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    // Param is passed by value, moved
    pub fn set_session(&mut self, v: ::std::string::String) {
        self.session = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session(&mut self) -> &mut ::std::string::String {
        &mut self.session
    }

    // Take field
    pub fn take_session(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.session, ::std::string::String::new())
    }

    // .google.spanner.v1.TransactionSelector transaction = 2;


    pub fn get_transaction(&self) -> &super::transaction::TransactionSelector {
        self.transaction.as_ref().unwrap_or_else(|| <super::transaction::TransactionSelector as ::protobuf::Message>::default_instance())
    }
    pub fn clear_transaction(&mut self) {
        self.transaction.clear();
    }

    pub fn has_transaction(&self) -> bool {
        self.transaction.is_some()
    }

    // Param is passed by value, moved
    pub fn set_transaction(&mut self, v: super::transaction::TransactionSelector) {
        self.transaction = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_transaction(&mut self) -> &mut super::transaction::TransactionSelector {
        if self.transaction.is_none() {
            self.transaction.set_default();
        }
        self.transaction.as_mut().unwrap()
    }

    // Take field
    pub fn take_transaction(&mut self) -> super::transaction::TransactionSelector {
        self.transaction.take().unwrap_or_else(|| super::transaction::TransactionSelector::new())
    }

    // string table = 3;


    pub fn get_table(&self) -> &str {
        &self.table
    }
    pub fn clear_table(&mut self) {
        self.table.clear();
    }

    // Param is passed by value, moved
    pub fn set_table(&mut self, v: ::std::string::String) {
        self.table = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_table(&mut self) -> &mut ::std::string::String {
        &mut self.table
    }

    // Take field
    pub fn take_table(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.table, ::std::string::String::new())
    }

    // string index = 4;


    pub fn get_index(&self) -> &str {
        &self.index
    }
    pub fn clear_index(&mut self) {
        self.index.clear();
    }

    // Param is passed by value, moved
    pub fn set_index(&mut self, v: ::std::string::String) {
        self.index = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_index(&mut self) -> &mut ::std::string::String {
        &mut self.index
    }

    // Take field
    pub fn take_index(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.index, ::std::string::String::new())
    }

    // repeated string columns = 5;


    pub fn get_columns(&self) -> &[::std::string::String] {
        &self.columns
    }
    pub fn clear_columns(&mut self) {
        self.columns.clear();
    }

    // Param is passed by value, moved
    pub fn set_columns(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) {
        self.columns = v;
    }

    // Mutable pointer to the field.
    pub fn mut_columns(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> {
        &mut self.columns
    }

    // Take field
    pub fn take_columns(&mut self) -> ::protobuf::RepeatedField<::std::string::String> {
        ::std::mem::replace(&mut self.columns, ::protobuf::RepeatedField::new())
    }

    // .google.spanner.v1.KeySet key_set = 6;


    pub fn get_key_set(&self) -> &super::keys::KeySet {
        self.key_set.as_ref().unwrap_or_else(|| <super::keys::KeySet as ::protobuf::Message>::default_instance())
    }
    pub fn clear_key_set(&mut self) {
        self.key_set.clear();
    }

    pub fn has_key_set(&self) -> bool {
        self.key_set.is_some()
    }

    // Param is passed by value, moved
    pub fn set_key_set(&mut self, v: super::keys::KeySet) {
        self.key_set = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_key_set(&mut self) -> &mut super::keys::KeySet {
        if self.key_set.is_none() {
            self.key_set.set_default();
        }
        self.key_set.as_mut().unwrap()
    }

    // Take field
    pub fn take_key_set(&mut self) -> super::keys::KeySet {
        self.key_set.take().unwrap_or_else(|| super::keys::KeySet::new())
    }

    // int64 limit = 8;


    pub fn get_limit(&self) -> i64 {
        self.limit
    }
    pub fn clear_limit(&mut self) {
        self.limit = 0;
    }

    // Param is passed by value, moved
    pub fn set_limit(&mut self, v: i64) {
        self.limit = v;
    }

    // bytes resume_token = 9;


    pub fn get_resume_token(&self) -> &[u8] {
        &self.resume_token
    }
    pub fn clear_resume_token(&mut self) {
        self.resume_token.clear();
    }

    // Param is passed by value, moved
    pub fn set_resume_token(&mut self, v: ::std::vec::Vec<u8>) {
        self.resume_token = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_resume_token(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.resume_token
    }

    // Take field
    pub fn take_resume_token(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.resume_token, ::std::vec::Vec::new())
    }

    // bytes partition_token = 10;


    pub fn get_partition_token(&self) -> &[u8] {
        &self.partition_token
    }
    pub fn clear_partition_token(&mut self) {
        self.partition_token.clear();
    }

    // Param is passed by value, moved
    pub fn set_partition_token(&mut self, v: ::std::vec::Vec<u8>) {
        self.partition_token = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_partition_token(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.partition_token
    }

    // Take field
    pub fn take_partition_token(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.partition_token, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for ReadRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.transaction {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.key_set {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.table)?;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.index)?;
                },
                5 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.columns)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.key_set)?;
                },
                8 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int64()?;
                    self.limit = tmp;
                },
                9 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.resume_token)?;
                },
                10 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.partition_token)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.session.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.session);
        }
        if let Some(ref v) = self.transaction.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if !self.table.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.table);
        }
        if !self.index.is_empty() {
            my_size += ::protobuf::rt::string_size(4, &self.index);
        }
        for value in &self.columns {
            my_size += ::protobuf::rt::string_size(5, &value);
        };
        if let Some(ref v) = self.key_set.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if self.limit != 0 {
            my_size += ::protobuf::rt::value_size(8, self.limit, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.resume_token.is_empty() {
            my_size += ::protobuf::rt::bytes_size(9, &self.resume_token);
        }
        if !self.partition_token.is_empty() {
            my_size += ::protobuf::rt::bytes_size(10, &self.partition_token);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.session.is_empty() {
            os.write_string(1, &self.session)?;
        }
        if let Some(ref v) = self.transaction.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if !self.table.is_empty() {
            os.write_string(3, &self.table)?;
        }
        if !self.index.is_empty() {
            os.write_string(4, &self.index)?;
        }
        for v in &self.columns {
            os.write_string(5, &v)?;
        };
        if let Some(ref v) = self.key_set.as_ref() {
            os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        if self.limit != 0 {
            os.write_int64(8, self.limit)?;
        }
        if !self.resume_token.is_empty() {
            os.write_bytes(9, &self.resume_token)?;
        }
        if !self.partition_token.is_empty() {
            os.write_bytes(10, &self.partition_token)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> ReadRequest {
        ReadRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "session",
                |m: &ReadRequest| { &m.session },
                |m: &mut ReadRequest| { &mut m.session },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::transaction::TransactionSelector>>(
                "transaction",
                |m: &ReadRequest| { &m.transaction },
                |m: &mut ReadRequest| { &mut m.transaction },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "table",
                |m: &ReadRequest| { &m.table },
                |m: &mut ReadRequest| { &mut m.table },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "index",
                |m: &ReadRequest| { &m.index },
                |m: &mut ReadRequest| { &mut m.index },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "columns",
                |m: &ReadRequest| { &m.columns },
                |m: &mut ReadRequest| { &mut m.columns },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::keys::KeySet>>(
                "key_set",
                |m: &ReadRequest| { &m.key_set },
                |m: &mut ReadRequest| { &mut m.key_set },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
                "limit",
                |m: &ReadRequest| { &m.limit },
                |m: &mut ReadRequest| { &mut m.limit },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "resume_token",
                |m: &ReadRequest| { &m.resume_token },
                |m: &mut ReadRequest| { &mut m.resume_token },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "partition_token",
                |m: &ReadRequest| { &m.partition_token },
                |m: &mut ReadRequest| { &mut m.partition_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ReadRequest>(
                "ReadRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static ReadRequest {
        static instance: ::protobuf::rt::LazyV2<ReadRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(ReadRequest::new)
    }
}

impl ::protobuf::Clear for ReadRequest {
    fn clear(&mut self) {
        self.session.clear();
        self.transaction.clear();
        self.table.clear();
        self.index.clear();
        self.columns.clear();
        self.key_set.clear();
        self.limit = 0;
        self.resume_token.clear();
        self.partition_token.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for ReadRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for ReadRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct BeginTransactionRequest {
    // message fields
    pub session: ::std::string::String,
    pub options: ::protobuf::SingularPtrField<super::transaction::TransactionOptions>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a BeginTransactionRequest {
    fn default() -> &'a BeginTransactionRequest {
        <BeginTransactionRequest as ::protobuf::Message>::default_instance()
    }
}

impl BeginTransactionRequest {
    pub fn new() -> BeginTransactionRequest {
        ::std::default::Default::default()
    }

    // string session = 1;


    pub fn get_session(&self) -> &str {
        &self.session
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    // Param is passed by value, moved
    pub fn set_session(&mut self, v: ::std::string::String) {
        self.session = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session(&mut self) -> &mut ::std::string::String {
        &mut self.session
    }

    // Take field
    pub fn take_session(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.session, ::std::string::String::new())
    }

    // .google.spanner.v1.TransactionOptions options = 2;


    pub fn get_options(&self) -> &super::transaction::TransactionOptions {
        self.options.as_ref().unwrap_or_else(|| <super::transaction::TransactionOptions as ::protobuf::Message>::default_instance())
    }
    pub fn clear_options(&mut self) {
        self.options.clear();
    }

    pub fn has_options(&self) -> bool {
        self.options.is_some()
    }

    // Param is passed by value, moved
    pub fn set_options(&mut self, v: super::transaction::TransactionOptions) {
        self.options = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_options(&mut self) -> &mut super::transaction::TransactionOptions {
        if self.options.is_none() {
            self.options.set_default();
        }
        self.options.as_mut().unwrap()
    }

    // Take field
    pub fn take_options(&mut self) -> super::transaction::TransactionOptions {
        self.options.take().unwrap_or_else(|| super::transaction::TransactionOptions::new())
    }
}

impl ::protobuf::Message for BeginTransactionRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.options {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.options)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.session.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.session);
        }
        if let Some(ref v) = self.options.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.session.is_empty() {
            os.write_string(1, &self.session)?;
        }
        if let Some(ref v) = self.options.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> BeginTransactionRequest {
        BeginTransactionRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "session",
                |m: &BeginTransactionRequest| { &m.session },
                |m: &mut BeginTransactionRequest| { &mut m.session },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::transaction::TransactionOptions>>(
                "options",
                |m: &BeginTransactionRequest| { &m.options },
                |m: &mut BeginTransactionRequest| { &mut m.options },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<BeginTransactionRequest>(
                "BeginTransactionRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static BeginTransactionRequest {
        static instance: ::protobuf::rt::LazyV2<BeginTransactionRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(BeginTransactionRequest::new)
    }
}

impl ::protobuf::Clear for BeginTransactionRequest {
    fn clear(&mut self) {
        self.session.clear();
        self.options.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for BeginTransactionRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for BeginTransactionRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CommitRequest {
    // message fields
    pub session: ::std::string::String,
    pub mutations: ::protobuf::RepeatedField<super::mutation::Mutation>,
    // message oneof groups
    pub transaction: ::std::option::Option<CommitRequest_oneof_transaction>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CommitRequest {
    fn default() -> &'a CommitRequest {
        <CommitRequest as ::protobuf::Message>::default_instance()
    }
}

#[derive(Clone,PartialEq,Debug)]
pub enum CommitRequest_oneof_transaction {
    transaction_id(::std::vec::Vec<u8>),
    single_use_transaction(super::transaction::TransactionOptions),
}

impl CommitRequest {
    pub fn new() -> CommitRequest {
        ::std::default::Default::default()
    }

    // string session = 1;


    pub fn get_session(&self) -> &str {
        &self.session
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    // Param is passed by value, moved
    pub fn set_session(&mut self, v: ::std::string::String) {
        self.session = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session(&mut self) -> &mut ::std::string::String {
        &mut self.session
    }

    // Take field
    pub fn take_session(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.session, ::std::string::String::new())
    }

    // bytes transaction_id = 2;


    pub fn get_transaction_id(&self) -> &[u8] {
        match self.transaction {
            ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(ref v)) => v,
            _ => &[],
        }
    }
    pub fn clear_transaction_id(&mut self) {
        self.transaction = ::std::option::Option::None;
    }

    pub fn has_transaction_id(&self) -> bool {
        match self.transaction {
            ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_transaction_id(&mut self, v: ::std::vec::Vec<u8>) {
        self.transaction = ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(v))
    }

    // Mutable pointer to the field.
    pub fn mut_transaction_id(&mut self) -> &mut ::std::vec::Vec<u8> {
        if let ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(_)) = self.transaction {
        } else {
            self.transaction = ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(::std::vec::Vec::new()));
        }
        match self.transaction {
            ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_transaction_id(&mut self) -> ::std::vec::Vec<u8> {
        if self.has_transaction_id() {
            match self.transaction.take() {
                ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::vec::Vec::new()
        }
    }

    // .google.spanner.v1.TransactionOptions single_use_transaction = 3;


    pub fn get_single_use_transaction(&self) -> &super::transaction::TransactionOptions {
        match self.transaction {
            ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(ref v)) => v,
            _ => <super::transaction::TransactionOptions as ::protobuf::Message>::default_instance(),
        }
    }
    pub fn clear_single_use_transaction(&mut self) {
        self.transaction = ::std::option::Option::None;
    }

    pub fn has_single_use_transaction(&self) -> bool {
        match self.transaction {
            ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_single_use_transaction(&mut self, v: super::transaction::TransactionOptions) {
        self.transaction = ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(v))
    }

    // Mutable pointer to the field.
    pub fn mut_single_use_transaction(&mut self) -> &mut super::transaction::TransactionOptions {
        if let ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(_)) = self.transaction {
        } else {
            self.transaction = ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(super::transaction::TransactionOptions::new()));
        }
        match self.transaction {
            ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_single_use_transaction(&mut self) -> super::transaction::TransactionOptions {
        if self.has_single_use_transaction() {
            match self.transaction.take() {
                ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(v)) => v,
                _ => panic!(),
            }
        } else {
            super::transaction::TransactionOptions::new()
        }
    }

    // repeated .google.spanner.v1.Mutation mutations = 4;


    pub fn get_mutations(&self) -> &[super::mutation::Mutation] {
        &self.mutations
    }
    pub fn clear_mutations(&mut self) {
        self.mutations.clear();
    }

    // Param is passed by value, moved
    pub fn set_mutations(&mut self, v: ::protobuf::RepeatedField<super::mutation::Mutation>) {
        self.mutations = v;
    }

    // Mutable pointer to the field.
    pub fn mut_mutations(&mut self) -> &mut ::protobuf::RepeatedField<super::mutation::Mutation> {
        &mut self.mutations
    }

    // Take field
    pub fn take_mutations(&mut self) -> ::protobuf::RepeatedField<super::mutation::Mutation> {
        ::std::mem::replace(&mut self.mutations, ::protobuf::RepeatedField::new())
    }
}

impl ::protobuf::Message for CommitRequest {
    fn is_initialized(&self) -> bool {
        if let Some(CommitRequest_oneof_transaction::single_use_transaction(ref v)) = self.transaction {
            if !v.is_initialized() {
                return false;
            }
        }
        for v in &self.mutations {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?;
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.transaction = ::std::option::Option::Some(CommitRequest_oneof_transaction::transaction_id(is.read_bytes()?));
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.transaction = ::std::option::Option::Some(CommitRequest_oneof_transaction::single_use_transaction(is.read_message()?));
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.mutations)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.session.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.session);
        }
        for value in &self.mutations {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let ::std::option::Option::Some(ref v) = self.transaction {
            match v {
                &CommitRequest_oneof_transaction::transaction_id(ref v) => {
                    my_size += ::protobuf::rt::bytes_size(2, &v);
                },
                &CommitRequest_oneof_transaction::single_use_transaction(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.session.is_empty() {
            os.write_string(1, &self.session)?;
        }
        for v in &self.mutations {
            os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        if let ::std::option::Option::Some(ref v) = self.transaction {
            match v {
                &CommitRequest_oneof_transaction::transaction_id(ref v) => {
                    os.write_bytes(2, v)?;
                },
                &CommitRequest_oneof_transaction::single_use_transaction(ref v) => {
                    os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
            };
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CommitRequest {
        CommitRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "session",
                |m: &CommitRequest| { &m.session },
                |m: &mut CommitRequest| { &mut m.session },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>(
                "transaction_id",
                CommitRequest::has_transaction_id,
                CommitRequest::get_transaction_id,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::transaction::TransactionOptions>(
                "single_use_transaction",
                CommitRequest::has_single_use_transaction,
                CommitRequest::get_single_use_transaction,
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::mutation::Mutation>>(
                "mutations",
                |m: &CommitRequest| { &m.mutations },
                |m: &mut CommitRequest| { &mut m.mutations },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CommitRequest>(
                "CommitRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CommitRequest {
        static instance: ::protobuf::rt::LazyV2<CommitRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CommitRequest::new)
    }
}

impl ::protobuf::Clear for CommitRequest {
    fn clear(&mut self) {
        self.session.clear();
        self.transaction = ::std::option::Option::None;
        self.transaction = ::std::option::Option::None;
        self.mutations.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CommitRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CommitRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct CommitResponse {
    // message fields
    pub commit_timestamp: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a CommitResponse {
    fn default() -> &'a CommitResponse {
        <CommitResponse as ::protobuf::Message>::default_instance()
    }
}

impl CommitResponse {
    pub fn new() -> CommitResponse {
        ::std::default::Default::default()
    }

    // .google.protobuf.Timestamp commit_timestamp = 1;


    pub fn get_commit_timestamp(&self) -> &::protobuf::well_known_types::Timestamp {
        self.commit_timestamp.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Timestamp as ::protobuf::Message>::default_instance())
    }
    pub fn clear_commit_timestamp(&mut self) {
        self.commit_timestamp.clear();
    }

    pub fn has_commit_timestamp(&self) -> bool {
        self.commit_timestamp.is_some()
    }

    // Param is passed by value, moved
    pub fn set_commit_timestamp(&mut self, v: ::protobuf::well_known_types::Timestamp) {
        self.commit_timestamp = ::protobuf::SingularPtrField::some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_commit_timestamp(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
        if self.commit_timestamp.is_none() {
            self.commit_timestamp.set_default();
        }
        self.commit_timestamp.as_mut().unwrap()
    }

    // Take field
    pub fn take_commit_timestamp(&mut self) -> ::protobuf::well_known_types::Timestamp {
        self.commit_timestamp.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
    }
}

impl ::protobuf::Message for CommitResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.commit_timestamp {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.commit_timestamp)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let Some(ref v) = self.commit_timestamp.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if let Some(ref v) = self.commit_timestamp.as_ref() {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> CommitResponse {
        CommitResponse::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
                "commit_timestamp",
                |m: &CommitResponse| { &m.commit_timestamp },
                |m: &mut CommitResponse| { &mut m.commit_timestamp },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CommitResponse>(
                "CommitResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static CommitResponse {
        static instance: ::protobuf::rt::LazyV2<CommitResponse> = ::protobuf::rt::LazyV2::INIT;
        instance.get(CommitResponse::new)
    }
}

impl ::protobuf::Clear for CommitResponse {
    fn clear(&mut self) {
        self.commit_timestamp.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for CommitResponse {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for CommitResponse {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

#[derive(PartialEq,Clone,Default)]
pub struct RollbackRequest {
    // message fields
    pub session: ::std::string::String,
    pub transaction_id: ::std::vec::Vec<u8>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

impl<'a> ::std::default::Default for &'a RollbackRequest {
    fn default() -> &'a RollbackRequest {
        <RollbackRequest as ::protobuf::Message>::default_instance()
    }
}

impl RollbackRequest {
    pub fn new() -> RollbackRequest {
        ::std::default::Default::default()
    }

    // string session = 1;


    pub fn get_session(&self) -> &str {
        &self.session
    }
    pub fn clear_session(&mut self) {
        self.session.clear();
    }

    // Param is passed by value, moved
    pub fn set_session(&mut self, v: ::std::string::String) {
        self.session = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_session(&mut self) -> &mut ::std::string::String {
        &mut self.session
    }

    // Take field
    pub fn take_session(&mut self) -> ::std::string::String {
        ::std::mem::replace(&mut self.session, ::std::string::String::new())
    }

    // bytes transaction_id = 2;


    pub fn get_transaction_id(&self) -> &[u8] {
        &self.transaction_id
    }
    pub fn clear_transaction_id(&mut self) {
        self.transaction_id.clear();
    }

    // Param is passed by value, moved
    pub fn set_transaction_id(&mut self, v: ::std::vec::Vec<u8>) {
        self.transaction_id = v;
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_transaction_id(&mut self) -> &mut ::std::vec::Vec<u8> {
        &mut self.transaction_id
    }

    // Take field
    pub fn take_transaction_id(&mut self) -> ::std::vec::Vec<u8> {
        ::std::mem::replace(&mut self.transaction_id, ::std::vec::Vec::new())
    }
}

impl ::protobuf::Message for RollbackRequest {
    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.session)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.transaction_id)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.session.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.session);
        }
        if !self.transaction_id.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.transaction_id);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.session.is_empty() {
            os.write_string(1, &self.session)?;
        }
        if !self.transaction_id.is_empty() {
            os.write_bytes(2, &self.transaction_id)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn get_cached_size(&self) -> u32 {
        self.cached_size.get()
    }

    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
        &self.unknown_fields
    }

    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
        &mut self.unknown_fields
    }

    fn as_any(&self) -> &dyn (::std::any::Any) {
        self as &dyn (::std::any::Any)
    }
    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
        self as &mut dyn (::std::any::Any)
    }
    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
        self
    }

    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
        Self::descriptor_static()
    }

    fn new() -> RollbackRequest {
        RollbackRequest::new()
    }

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
        descriptor.get(|| {
            let mut fields = ::std::vec::Vec::new();
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "session",
                |m: &RollbackRequest| { &m.session },
                |m: &mut RollbackRequest| { &mut m.session },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "transaction_id",
                |m: &RollbackRequest| { &m.transaction_id },
                |m: &mut RollbackRequest| { &mut m.transaction_id },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<RollbackRequest>(
                "RollbackRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

    fn default_instance() -> &'static RollbackRequest {
        static instance: ::protobuf::rt::LazyV2<RollbackRequest> = ::protobuf::rt::LazyV2::INIT;
        instance.get(RollbackRequest::new)
    }
}

impl ::protobuf::Clear for RollbackRequest {
    fn clear(&mut self) {
        self.session.clear();
        self.transaction_id.clear();
        self.unknown_fields.clear();
    }
}

impl ::std::fmt::Debug for RollbackRequest {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::protobuf::text_format::fmt(self, f)
    }
}

impl ::protobuf::reflect::ProtobufValue for RollbackRequest {
    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
        ::protobuf::reflect::ReflectValueRef::Message(self)
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x1fgoogle/spanner/v1/spanner.proto\x12\x11google.spanner.v1\x1a\x1cgo\
    ogle/api/annotations.proto\x1a\x17google/api/client.proto\x1a\x1fgoogle/\
    api/field_behavior.proto\x1a\x19google/api/resource.proto\x1a\x1bgoogle/\
    protobuf/empty.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1fgoogle/p\
    rotobuf/timestamp.proto\x1a\x17google/rpc/status.proto\x1a\x1cgoogle/spa\
    nner/v1/keys.proto\x1a\x20google/spanner/v1/mutation.proto\x1a\"google/s\
    panner/v1/result_set.proto\x1a#google/spanner/v1/transaction.proto\x1a\
    \x1cgoogle/spanner/v1/type.proto\"\x91\x01\n\x14CreateSessionRequest\x12\
    C\n\x08database\x18\x01\x20\x01(\tR\x08databaseB'\xfaA!\n\x1fspanner.goo\
    gleapis.com/Database\xe0A\x02\x124\n\x07session\x18\x02\x20\x01(\x0b2\
    \x1a.google.spanner.v1.SessionR\x07session\"\xd2\x01\n\x1aBatchCreateSes\
    sionsRequest\x12C\n\x08database\x18\x01\x20\x01(\tR\x08databaseB'\xfaA!\
    \n\x1fspanner.googleapis.com/Database\xe0A\x02\x12E\n\x10session_templat\
    e\x18\x02\x20\x01(\x0b2\x1a.google.spanner.v1.SessionR\x0fsessionTemplat\
    e\x12(\n\rsession_count\x18\x03\x20\x01(\x05R\x0csessionCountB\x03\xe0A\
    \x02\"S\n\x1bBatchCreateSessionsResponse\x124\n\x07session\x18\x01\x20\
    \x03(\x0b2\x1a.google.spanner.v1.SessionR\x07session\"\xa2\x03\n\x07Sess\
    ion\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12>\n\x06labels\x18\
    \x02\x20\x03(\x0b2&.google.spanner.v1.Session.LabelsEntryR\x06labels\x12\
    ;\n\x0bcreate_time\x18\x03\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\
    \ncreateTime\x12U\n\x19approximate_last_use_time\x18\x04\x20\x01(\x0b2\
    \x1a.google.protobuf.TimestampR\x16approximateLastUseTime\x1a9\n\x0bLabe\
    lsEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\
    \x18\x02\x20\x01(\tR\x05value:\x028\x01:t\xeaAq\n\x1espanner.googleapis.\
    com/Session\x12Oprojects/{project}/instances/{instance}/databases/{datab\
    ase}/sessions/{session}\"O\n\x11GetSessionRequest\x12:\n\x04name\x18\x01\
    \x20\x01(\tR\x04nameB&\xfaA\x20\n\x1espanner.googleapis.com/Session\xe0A\
    \x02\"\xae\x01\n\x13ListSessionsRequest\x12C\n\x08database\x18\x01\x20\
    \x01(\tR\x08databaseB'\xfaA!\n\x1fspanner.googleapis.com/Database\xe0A\
    \x02\x12\x1b\n\tpage_size\x18\x02\x20\x01(\x05R\x08pageSize\x12\x1d\n\np\
    age_token\x18\x03\x20\x01(\tR\tpageToken\x12\x16\n\x06filter\x18\x04\x20\
    \x01(\tR\x06filter\"v\n\x14ListSessionsResponse\x126\n\x08sessions\x18\
    \x01\x20\x03(\x0b2\x1a.google.spanner.v1.SessionR\x08sessions\x12&\n\x0f\
    next_page_token\x18\x02\x20\x01(\tR\rnextPageToken\"R\n\x14DeleteSession\
    Request\x12:\n\x04name\x18\x01\x20\x01(\tR\x04nameB&\xfaA\x20\n\x1espann\
    er.googleapis.com/Session\xe0A\x02\"\xf7\x04\n\x11ExecuteSqlRequest\x12@\
    \n\x07session\x18\x01\x20\x01(\tR\x07sessionB&\xfaA\x20\n\x1espanner.goo\
    gleapis.com/Session\xe0A\x02\x12H\n\x0btransaction\x18\x02\x20\x01(\x0b2\
    &.google.spanner.v1.TransactionSelectorR\x0btransaction\x12\x15\n\x03sql\
    \x18\x03\x20\x01(\tR\x03sqlB\x03\xe0A\x02\x12/\n\x06params\x18\x04\x20\
    \x01(\x0b2\x17.google.protobuf.StructR\x06params\x12U\n\x0bparam_types\
    \x18\x05\x20\x03(\x0b24.google.spanner.v1.ExecuteSqlRequest.ParamTypesEn\
    tryR\nparamTypes\x12!\n\x0cresume_token\x18\x06\x20\x01(\x0cR\x0bresumeT\
    oken\x12M\n\nquery_mode\x18\x07\x20\x01(\x0e2..google.spanner.v1.Execute\
    SqlRequest.QueryModeR\tqueryMode\x12'\n\x0fpartition_token\x18\x08\x20\
    \x01(\x0cR\x0epartitionToken\x12\x14\n\x05seqno\x18\t\x20\x01(\x03R\x05s\
    eqno\x1aV\n\x0fParamTypesEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03k\
    ey\x12-\n\x05value\x18\x02\x20\x01(\x0b2\x17.google.spanner.v1.TypeR\x05\
    value:\x028\x01\".\n\tQueryMode\x12\n\n\x06NORMAL\x10\0\x12\x08\n\x04PLA\
    N\x10\x01\x12\x0b\n\x07PROFILE\x10\x02\"\xad\x04\n\x16ExecuteBatchDmlReq\
    uest\x12@\n\x07session\x18\x01\x20\x01(\tR\x07sessionB&\xfaA\x20\n\x1esp\
    anner.googleapis.com/Session\xe0A\x02\x12M\n\x0btransaction\x18\x02\x20\
    \x01(\x0b2&.google.spanner.v1.TransactionSelectorR\x0btransactionB\x03\
    \xe0A\x02\x12X\n\nstatements\x18\x03\x20\x03(\x0b23.google.spanner.v1.Ex\
    ecuteBatchDmlRequest.StatementR\nstatementsB\x03\xe0A\x02\x12\x19\n\x05s\
    eqno\x18\x04\x20\x01(\x03R\x05seqnoB\x03\xe0A\x02\x1a\x8c\x02\n\tStateme\
    nt\x12\x10\n\x03sql\x18\x01\x20\x01(\tR\x03sql\x12/\n\x06params\x18\x02\
    \x20\x01(\x0b2\x17.google.protobuf.StructR\x06params\x12d\n\x0bparam_typ\
    es\x18\x03\x20\x03(\x0b2C.google.spanner.v1.ExecuteBatchDmlRequest.State\
    ment.ParamTypesEntryR\nparamTypes\x1aV\n\x0fParamTypesEntry\x12\x10\n\
    \x03key\x18\x01\x20\x01(\tR\x03key\x12-\n\x05value\x18\x02\x20\x01(\x0b2\
    \x17.google.spanner.v1.TypeR\x05value:\x028\x01\"\x84\x01\n\x17ExecuteBa\
    tchDmlResponse\x12=\n\x0bresult_sets\x18\x01\x20\x03(\x0b2\x1c.google.sp\
    anner.v1.ResultSetR\nresultSets\x12*\n\x06status\x18\x02\x20\x01(\x0b2\
    \x12.google.rpc.StatusR\x06status\"k\n\x10PartitionOptions\x120\n\x14par\
    tition_size_bytes\x18\x01\x20\x01(\x03R\x12partitionSizeBytes\x12%\n\x0e\
    max_partitions\x18\x02\x20\x01(\x03R\rmaxPartitions\"\xf0\x03\n\x15Parti\
    tionQueryRequest\x12@\n\x07session\x18\x01\x20\x01(\tR\x07sessionB&\xfaA\
    \x20\n\x1espanner.googleapis.com/Session\xe0A\x02\x12H\n\x0btransaction\
    \x18\x02\x20\x01(\x0b2&.google.spanner.v1.TransactionSelectorR\x0btransa\
    ction\x12\x15\n\x03sql\x18\x03\x20\x01(\tR\x03sqlB\x03\xe0A\x02\x12/\n\
    \x06params\x18\x04\x20\x01(\x0b2\x17.google.protobuf.StructR\x06params\
    \x12Y\n\x0bparam_types\x18\x05\x20\x03(\x0b28.google.spanner.v1.Partitio\
    nQueryRequest.ParamTypesEntryR\nparamTypes\x12P\n\x11partition_options\
    \x18\x06\x20\x01(\x0b2#.google.spanner.v1.PartitionOptionsR\x10partition\
    Options\x1aV\n\x0fParamTypesEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\
    \x03key\x12-\n\x05value\x18\x02\x20\x01(\x0b2\x17.google.spanner.v1.Type\
    R\x05value:\x028\x01\"\xf8\x02\n\x14PartitionReadRequest\x12@\n\x07sessi\
    on\x18\x01\x20\x01(\tR\x07sessionB&\xfaA\x20\n\x1espanner.googleapis.com\
    /Session\xe0A\x02\x12H\n\x0btransaction\x18\x02\x20\x01(\x0b2&.google.sp\
    anner.v1.TransactionSelectorR\x0btransaction\x12\x19\n\x05table\x18\x03\
    \x20\x01(\tR\x05tableB\x03\xe0A\x02\x12\x14\n\x05index\x18\x04\x20\x01(\
    \tR\x05index\x12\x18\n\x07columns\x18\x05\x20\x03(\tR\x07columns\x127\n\
    \x07key_set\x18\x06\x20\x01(\x0b2\x19.google.spanner.v1.KeySetR\x06keySe\
    tB\x03\xe0A\x02\x12P\n\x11partition_options\x18\t\x20\x01(\x0b2#.google.\
    spanner.v1.PartitionOptionsR\x10partitionOptions\"4\n\tPartition\x12'\n\
    \x0fpartition_token\x18\x01\x20\x01(\x0cR\x0epartitionToken\"\x93\x01\n\
    \x11PartitionResponse\x12<\n\npartitions\x18\x01\x20\x03(\x0b2\x1c.googl\
    e.spanner.v1.PartitionR\npartitions\x12@\n\x0btransaction\x18\x02\x20\
    \x01(\x0b2\x1e.google.spanner.v1.TransactionR\x0btransaction\"\x84\x03\n\
    \x0bReadRequest\x12@\n\x07session\x18\x01\x20\x01(\tR\x07sessionB&\xfaA\
    \x20\n\x1espanner.googleapis.com/Session\xe0A\x02\x12H\n\x0btransaction\
    \x18\x02\x20\x01(\x0b2&.google.spanner.v1.TransactionSelectorR\x0btransa\
    ction\x12\x19\n\x05table\x18\x03\x20\x01(\tR\x05tableB\x03\xe0A\x02\x12\
    \x14\n\x05index\x18\x04\x20\x01(\tR\x05index\x12\x1d\n\x07columns\x18\
    \x05\x20\x03(\tR\x07columnsB\x03\xe0A\x02\x127\n\x07key_set\x18\x06\x20\
    \x01(\x0b2\x19.google.spanner.v1.KeySetR\x06keySetB\x03\xe0A\x02\x12\x14\
    \n\x05limit\x18\x08\x20\x01(\x03R\x05limit\x12!\n\x0cresume_token\x18\t\
    \x20\x01(\x0cR\x0bresumeToken\x12'\n\x0fpartition_token\x18\n\x20\x01(\
    \x0cR\x0epartitionToken\"\xa1\x01\n\x17BeginTransactionRequest\x12@\n\
    \x07session\x18\x01\x20\x01(\tR\x07sessionB&\xfaA\x20\n\x1espanner.googl\
    eapis.com/Session\xe0A\x02\x12D\n\x07options\x18\x02\x20\x01(\x0b2%.goog\
    le.spanner.v1.TransactionOptionsR\x07optionsB\x03\xe0A\x02\"\xa3\x02\n\r\
    CommitRequest\x12@\n\x07session\x18\x01\x20\x01(\tR\x07sessionB&\xfaA\
    \x20\n\x1espanner.googleapis.com/Session\xe0A\x02\x12'\n\x0etransaction_\
    id\x18\x02\x20\x01(\x0cH\0R\rtransactionId\x12]\n\x16single_use_transact\
    ion\x18\x03\x20\x01(\x0b2%.google.spanner.v1.TransactionOptionsH\0R\x14s\
    ingleUseTransaction\x129\n\tmutations\x18\x04\x20\x03(\x0b2\x1b.google.s\
    panner.v1.MutationR\tmutationsB\r\n\x0btransaction\"W\n\x0eCommitRespons\
    e\x12E\n\x10commit_timestamp\x18\x01\x20\x01(\x0b2\x1a.google.protobuf.T\
    imestampR\x0fcommitTimestamp\"\x7f\n\x0fRollbackRequest\x12@\n\x07sessio\
    n\x18\x01\x20\x01(\tR\x07sessionB&\xfaA\x20\n\x1espanner.googleapis.com/\
    Session\xe0A\x02\x12*\n\x0etransaction_id\x18\x02\x20\x01(\x0cR\rtransac\
    tionIdB\x03\xe0A\x022\xc0\x16\n\x07Spanner\x12\xa6\x01\n\rCreateSession\
    \x12'.google.spanner.v1.CreateSessionRequest\x1a\x1a.google.spanner.v1.S\
    ession\"P\x82\xd3\xe4\x93\x02?\":/v1/{database=projects/*/instances/*/da\
    tabases/*}/sessions:\x01*\xdaA\x08database\x12\xe0\x01\n\x13BatchCreateS\
    essions\x12-.google.spanner.v1.BatchCreateSessionsRequest\x1a..google.sp\
    anner.v1.BatchCreateSessionsResponse\"j\x82\xd3\xe4\x93\x02K\"F/v1/{data\
    base=projects/*/instances/*/databases/*}/sessions:batchCreate:\x01*\xdaA\
    \x16database,session_count\x12\x97\x01\n\nGetSession\x12$.google.spanner\
    .v1.GetSessionRequest\x1a\x1a.google.spanner.v1.Session\"G\x82\xd3\xe4\
    \x93\x02:\x128/v1/{name=projects/*/instances/*/databases/*/sessions/*}\
    \xdaA\x04name\x12\xae\x01\n\x0cListSessions\x12&.google.spanner.v1.ListS\
    essionsRequest\x1a'.google.spanner.v1.ListSessionsResponse\"M\x82\xd3\
    \xe4\x93\x02<\x12:/v1/{database=projects/*/instances/*/databases/*}/sess\
    ions\xdaA\x08database\x12\x99\x01\n\rDeleteSession\x12'.google.spanner.v\
    1.DeleteSessionRequest\x1a\x16.google.protobuf.Empty\"G\x82\xd3\xe4\x93\
    \x02:*8/v1/{name=projects/*/instances/*/databases/*/sessions/*}\xdaA\x04\
    name\x12\xa3\x01\n\nExecuteSql\x12$.google.spanner.v1.ExecuteSqlRequest\
    \x1a\x1c.google.spanner.v1.ResultSet\"Q\x82\xd3\xe4\x93\x02K\"F/v1/{sess\
    ion=projects/*/instances/*/databases/*/sessions/*}:executeSql:\x01*\x12\
    \xbe\x01\n\x13ExecuteStreamingSql\x12$.google.spanner.v1.ExecuteSqlReque\
    st\x1a#.google.spanner.v1.PartialResultSet\"Z\x82\xd3\xe4\x93\x02T\"O/v1\
    /{session=projects/*/instances/*/databases/*/sessions/*}:executeStreamin\
    gSql:\x01*0\x01\x12\xc0\x01\n\x0fExecuteBatchDml\x12).google.spanner.v1.\
    ExecuteBatchDmlRequest\x1a*.google.spanner.v1.ExecuteBatchDmlResponse\"V\
    \x82\xd3\xe4\x93\x02P\"K/v1/{session=projects/*/instances/*/databases/*/\
    sessions/*}:executeBatchDml:\x01*\x12\x91\x01\n\x04Read\x12\x1e.google.s\
    panner.v1.ReadRequest\x1a\x1c.google.spanner.v1.ResultSet\"K\x82\xd3\xe4\
    \x93\x02E\"@/v1/{session=projects/*/instances/*/databases/*/sessions/*}:\
    read:\x01*\x12\xac\x01\n\rStreamingRead\x12\x1e.google.spanner.v1.ReadRe\
    quest\x1a#.google.spanner.v1.PartialResultSet\"T\x82\xd3\xe4\x93\x02N\"I\
    /v1/{session=projects/*/instances/*/databases/*/sessions/*}:streamingRea\
    d:\x01*0\x01\x12\xc9\x01\n\x10BeginTransaction\x12*.google.spanner.v1.Be\
    ginTransactionRequest\x1a\x1e.google.spanner.v1.Transaction\"i\x82\xd3\
    \xe4\x93\x02Q\"L/v1/{session=projects/*/instances/*/databases/*/sessions\
    /*}:beginTransaction:\x01*\xdaA\x0fsession,options\x12\xeb\x01\n\x06Comm\
    it\x12\x20.google.spanner.v1.CommitRequest\x1a!.google.spanner.v1.Commit\
    Response\"\x9b\x01\x82\xd3\xe4\x93\x02G\"B/v1/{session=projects/*/instan\
    ces/*/databases/*/sessions/*}:commit:\x01*\xdaA\x20session,transaction_i\
    d,mutations\xdaA(session,single_use_transaction,mutations\x12\xb0\x01\n\
    \x08Rollback\x12\".google.spanner.v1.RollbackRequest\x1a\x16.google.prot\
    obuf.Empty\"h\x82\xd3\xe4\x93\x02I\"D/v1/{session=projects/*/instances/*\
    /databases/*/sessions/*}:rollback:\x01*\xdaA\x16session,transaction_id\
    \x12\xb7\x01\n\x0ePartitionQuery\x12(.google.spanner.v1.PartitionQueryRe\
    quest\x1a$.google.spanner.v1.PartitionResponse\"U\x82\xd3\xe4\x93\x02O\"\
    J/v1/{session=projects/*/instances/*/databases/*/sessions/*}:partitionQu\
    ery:\x01*\x12\xb4\x01\n\rPartitionRead\x12'.google.spanner.v1.PartitionR\
    eadRequest\x1a$.google.spanner.v1.PartitionResponse\"T\x82\xd3\xe4\x93\
    \x02N\"I/v1/{session=projects/*/instances/*/databases/*/sessions/*}:part\
    itionRead:\x01*\x1aw\xd2A[https://www.googleapis.com/auth/cloud-platform\
    ,https://www.googleapis.com/auth/spanner.data\xcaA\x16spanner.googleapis\
    .comB\xf7\x01\n\x15com.google.spanner.v1B\x0cSpannerProtoP\x01Z8google.g\
    olang.org/genproto/googleapis/spanner/v1;spanner\xaa\x02\x17Google.Cloud\
    .Spanner.V1\xca\x02\x17Google\\Cloud\\Spanner\\V1\xeaA_\n\x1fspanner.goo\
    gleapis.com/Database\x12<projects/{project}/instances/{instance}/databas\
    es/{database}J\x8d\x96\x02\n\x07\x12\x05\x0f\0\x90\x07\x01\n\xbe\x04\n\
    \x01\x0c\x12\x03\x0f\0\x122\xb3\x04\x20Copyright\x202019\x20Google\x20LL\
    C.\n\n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202\
    .0\x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20fil\
    e\x20except\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20m\
    ay\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\
    \x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20requ\
    ired\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\
    \x20software\n\x20distributed\x20under\x20the\x20License\x20is\x20distri\
    buted\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\
    \x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\
    \x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20lan\
    guage\x20governing\x20permissions\x20and\n\x20limitations\x20under\x20th\
    e\x20License.\n\n\n\x08\n\x01\x02\x12\x03\x11\0\x1a\n\t\n\x02\x03\0\x12\
    \x03\x13\0&\n\t\n\x02\x03\x01\x12\x03\x14\0!\n\t\n\x02\x03\x02\x12\x03\
    \x15\0)\n\t\n\x02\x03\x03\x12\x03\x16\0#\n\t\n\x02\x03\x04\x12\x03\x17\0\
    %\n\t\n\x02\x03\x05\x12\x03\x18\0&\n\t\n\x02\x03\x06\x12\x03\x19\0)\n\t\
    \n\x02\x03\x07\x12\x03\x1a\0!\n\t\n\x02\x03\x08\x12\x03\x1b\0&\n\t\n\x02\
    \x03\t\x12\x03\x1c\0*\n\t\n\x02\x03\n\x12\x03\x1d\0,\n\t\n\x02\x03\x0b\
    \x12\x03\x1e\0-\n\t\n\x02\x03\x0c\x12\x03\x1f\0&\n\x08\n\x01\x08\x12\x03\
    !\04\n\t\n\x02\x08%\x12\x03!\04\n\x08\n\x01\x08\x12\x03\"\0O\n\t\n\x02\
    \x08\x0b\x12\x03\"\0O\n\x08\n\x01\x08\x12\x03#\0\"\n\t\n\x02\x08\n\x12\
    \x03#\0\"\n\x08\n\x01\x08\x12\x03$\0-\n\t\n\x02\x08\x08\x12\x03$\0-\n\
    \x08\n\x01\x08\x12\x03%\0.\n\t\n\x02\x08\x01\x12\x03%\0.\n\x08\n\x01\x08\
    \x12\x03&\04\n\t\n\x02\x08)\x12\x03&\04\n\t\n\x01\x08\x12\x04+\0.\x02\n\
    \xc1\x01\n\x04\x08\x9d\x08\0\x12\x04+\0.\x02\x1a\xb2\x01\x20The\x20Datab\
    ase\x20resource\x20is\x20defined\x20in\x20`google.spanner.admin.database\
    .v1`.\n\x20Because\x20this\x20is\x20a\x20separate,\x20independent\x20API\
    \x20(technically),\x20we\x20redefine\n\x20the\x20resource\x20name\x20pat\
    tern\x20here.\n\n\x9d\x01\n\x02\x06\0\x12\x054\0\xaa\x02\x01\x1a\x8f\x01\
    \x20Cloud\x20Spanner\x20API\n\n\x20The\x20Cloud\x20Spanner\x20API\x20can\
    \x20be\x20used\x20to\x20manage\x20sessions\x20and\x20execute\n\x20transa\
    ctions\x20on\x20data\x20stored\x20in\x20Cloud\x20Spanner\x20databases.\n\
    \n\n\n\x03\x06\0\x01\x12\x034\x08\x0f\n\n\n\x03\x06\0\x03\x12\x035\x02>\
    \n\x0c\n\x05\x06\0\x03\x99\x08\x12\x035\x02>\n\x0b\n\x03\x06\0\x03\x12\
    \x046\x0285\n\r\n\x05\x06\0\x03\x9a\x08\x12\x046\x0285\n\xe7\x06\n\x04\
    \x06\0\x02\0\x12\x04M\x02S\x03\x1a\xd8\x06\x20Creates\x20a\x20new\x20ses\
    sion.\x20A\x20session\x20can\x20be\x20used\x20to\x20perform\n\x20transac\
    tions\x20that\x20read\x20and/or\x20modify\x20data\x20in\x20a\x20Cloud\
    \x20Spanner\x20database.\n\x20Sessions\x20are\x20meant\x20to\x20be\x20re\
    used\x20for\x20many\x20consecutive\n\x20transactions.\n\n\x20Sessions\
    \x20can\x20only\x20execute\x20one\x20transaction\x20at\x20a\x20time.\x20\
    To\x20execute\n\x20multiple\x20concurrent\x20read-write/write-only\x20tr\
    ansactions,\x20create\n\x20multiple\x20sessions.\x20Note\x20that\x20stan\
    dalone\x20reads\x20and\x20queries\x20use\x20a\n\x20transaction\x20intern\
    ally,\x20and\x20count\x20toward\x20the\x20one\x20transaction\n\x20limit.\
    \n\n\x20Active\x20sessions\x20use\x20additional\x20server\x20resources,\
    \x20so\x20it\x20is\x20a\x20good\x20idea\x20to\n\x20delete\x20idle\x20and\
    \x20unneeded\x20sessions.\n\x20Aside\x20from\x20explicit\x20deletes,\x20\
    Cloud\x20Spanner\x20can\x20delete\x20sessions\x20for\x20which\x20no\n\
    \x20operations\x20are\x20sent\x20for\x20more\x20than\x20an\x20hour.\x20I\
    f\x20a\x20session\x20is\x20deleted,\n\x20requests\x20to\x20it\x20return\
    \x20`NOT_FOUND`.\n\n\x20Idle\x20sessions\x20can\x20be\x20kept\x20alive\
    \x20by\x20sending\x20a\x20trivial\x20SQL\x20query\n\x20periodically,\x20\
    e.g.,\x20`\"SELECT\x201\"`.\n\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03M\x06\
    \x13\n\x0c\n\x05\x06\0\x02\0\x02\x12\x03M\x14(\n\x0c\n\x05\x06\0\x02\0\
    \x03\x12\x03M3:\n\r\n\x05\x06\0\x02\0\x04\x12\x04N\x04Q\x06\n\x11\n\t\
    \x06\0\x02\0\x04\xb0\xca\xbc\"\x12\x04N\x04Q\x06\n\x0c\n\x05\x06\0\x02\0\
    \x04\x12\x03R\x046\n\x0f\n\x08\x06\0\x02\0\x04\x9b\x08\0\x12\x03R\x046\n\
    \xbf\x01\n\x04\x06\0\x02\x01\x12\x04Y\x02`\x03\x1a\xb0\x01\x20Creates\
    \x20multiple\x20new\x20sessions.\n\n\x20This\x20API\x20can\x20be\x20used\
    \x20to\x20initialize\x20a\x20session\x20cache\x20on\x20the\x20clients.\n\
    \x20See\x20https://goo.gl/TgSFN2\x20for\x20best\x20practices\x20on\x20se\
    ssion\x20cache\x20management.\n\n\x0c\n\x05\x06\0\x02\x01\x01\x12\x03Y\
    \x06\x19\n\x0c\n\x05\x06\0\x02\x01\x02\x12\x03Y\x1a4\n\x0c\n\x05\x06\0\
    \x02\x01\x03\x12\x03Z\x0f*\n\r\n\x05\x06\0\x02\x01\x04\x12\x04[\x04^\x06\
    \n\x11\n\t\x06\0\x02\x01\x04\xb0\xca\xbc\"\x12\x04[\x04^\x06\n\x0c\n\x05\
    \x06\0\x02\x01\x04\x12\x03_\x04D\n\x0f\n\x08\x06\0\x02\x01\x04\x9b\x08\0\
    \x12\x03_\x04D\n\x9d\x01\n\x04\x06\0\x02\x02\x12\x04e\x02j\x03\x1a\x8e\
    \x01\x20Gets\x20a\x20session.\x20Returns\x20`NOT_FOUND`\x20if\x20the\x20\
    session\x20does\x20not\x20exist.\n\x20This\x20is\x20mainly\x20useful\x20\
    for\x20determining\x20whether\x20a\x20session\x20is\x20still\n\x20alive.\
    \n\n\x0c\n\x05\x06\0\x02\x02\x01\x12\x03e\x06\x10\n\x0c\n\x05\x06\0\x02\
    \x02\x02\x12\x03e\x11\"\n\x0c\n\x05\x06\0\x02\x02\x03\x12\x03e-4\n\r\n\
    \x05\x06\0\x02\x02\x04\x12\x04f\x04h\x06\n\x11\n\t\x06\0\x02\x02\x04\xb0\
    \xca\xbc\"\x12\x04f\x04h\x06\n\x0c\n\x05\x06\0\x02\x02\x04\x12\x03i\x042\
    \n\x0f\n\x08\x06\0\x02\x02\x04\x9b\x08\0\x12\x03i\x042\n7\n\x04\x06\0\
    \x02\x03\x12\x04m\x02r\x03\x1a)\x20Lists\x20all\x20sessions\x20in\x20a\
    \x20given\x20database.\n\n\x0c\n\x05\x06\0\x02\x03\x01\x12\x03m\x06\x12\
    \n\x0c\n\x05\x06\0\x02\x03\x02\x12\x03m\x13&\n\x0c\n\x05\x06\0\x02\x03\
    \x03\x12\x03m1E\n\r\n\x05\x06\0\x02\x03\x04\x12\x04n\x04p\x06\n\x11\n\t\
    \x06\0\x02\x03\x04\xb0\xca\xbc\"\x12\x04n\x04p\x06\n\x0c\n\x05\x06\0\x02\
    \x03\x04\x12\x03q\x046\n\x0f\n\x08\x06\0\x02\x03\x04\x9b\x08\0\x12\x03q\
    \x046\n\xb5\x01\n\x04\x06\0\x02\x04\x12\x04w\x02|\x03\x1a\xa6\x01\x20End\
    s\x20a\x20session,\x20releasing\x20server\x20resources\x20associated\x20\
    with\x20it.\x20This\x20will\n\x20asynchronously\x20trigger\x20cancellati\
    on\x20of\x20any\x20operations\x20that\x20are\x20running\x20with\n\x20thi\
    s\x20session.\n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\x03w\x06\x13\n\x0c\n\
    \x05\x06\0\x02\x04\x02\x12\x03w\x14(\n\x0c\n\x05\x06\0\x02\x04\x03\x12\
    \x03w3H\n\r\n\x05\x06\0\x02\x04\x04\x12\x04x\x04z\x06\n\x11\n\t\x06\0\
    \x02\x04\x04\xb0\xca\xbc\"\x12\x04x\x04z\x06\n\x0c\n\x05\x06\0\x02\x04\
    \x04\x12\x03{\x042\n\x0f\n\x08\x06\0\x02\x04\x04\x9b\x08\0\x12\x03{\x042\
    \n\xed\x04\n\x04\x06\0\x02\x05\x12\x06\x8b\x01\x02\x90\x01\x03\x1a\xdc\
    \x04\x20Executes\x20an\x20SQL\x20statement,\x20returning\x20all\x20resul\
    ts\x20in\x20a\x20single\x20reply.\x20This\n\x20method\x20cannot\x20be\
    \x20used\x20to\x20return\x20a\x20result\x20set\x20larger\x20than\x2010\
    \x20MiB;\n\x20if\x20the\x20query\x20yields\x20more\x20data\x20than\x20th\
    at,\x20the\x20query\x20fails\x20with\n\x20a\x20`FAILED_PRECONDITION`\x20\
    error.\n\n\x20Operations\x20inside\x20read-write\x20transactions\x20migh\
    t\x20return\x20`ABORTED`.\x20If\n\x20this\x20occurs,\x20the\x20applicati\
    on\x20should\x20restart\x20the\x20transaction\x20from\n\x20the\x20beginn\
    ing.\x20See\x20[Transaction][google.spanner.v1.Transaction]\x20for\x20mo\
    re\n\x20details.\n\n\x20Larger\x20result\x20sets\x20can\x20be\x20fetched\
    \x20in\x20streaming\x20fashion\x20by\x20calling\n\x20[ExecuteStreamingSq\
    l][google.spanner.v1.Spanner.ExecuteStreamingSql]\n\x20instead.\n\n\r\n\
    \x05\x06\0\x02\x05\x01\x12\x04\x8b\x01\x06\x10\n\r\n\x05\x06\0\x02\x05\
    \x02\x12\x04\x8b\x01\x11\"\n\r\n\x05\x06\0\x02\x05\x03\x12\x04\x8b\x01-6\
    \n\x0f\n\x05\x06\0\x02\x05\x04\x12\x06\x8c\x01\x04\x8f\x01\x06\n\x13\n\t\
    \x06\0\x02\x05\x04\xb0\xca\xbc\"\x12\x06\x8c\x01\x04\x8f\x01\x06\n\xd7\
    \x02\n\x04\x06\0\x02\x06\x12\x06\x97\x01\x02\x9c\x01\x03\x1a\xc6\x02\x20\
    Like\x20[ExecuteSql][google.spanner.v1.Spanner.ExecuteSql],\x20except\
    \x20returns\x20the\n\x20result\x20set\x20as\x20a\x20stream.\x20Unlike\n\
    \x20[ExecuteSql][google.spanner.v1.Spanner.ExecuteSql],\x20there\x20is\
    \x20no\x20limit\x20on\n\x20the\x20size\x20of\x20the\x20returned\x20resul\
    t\x20set.\x20However,\x20no\x20individual\x20row\x20in\x20the\n\x20resul\
    t\x20set\x20can\x20exceed\x20100\x20MiB,\x20and\x20no\x20column\x20value\
    \x20can\x20exceed\x2010\x20MiB.\n\n\r\n\x05\x06\0\x02\x06\x01\x12\x04\
    \x97\x01\x06\x19\n\r\n\x05\x06\0\x02\x06\x02\x12\x04\x97\x01\x1a+\n\r\n\
    \x05\x06\0\x02\x06\x06\x12\x04\x97\x016<\n\r\n\x05\x06\0\x02\x06\x03\x12\
    \x04\x97\x01=M\n\x0f\n\x05\x06\0\x02\x06\x04\x12\x06\x98\x01\x04\x9b\x01\
    \x06\n\x13\n\t\x06\0\x02\x06\x04\xb0\xca\xbc\"\x12\x06\x98\x01\x04\x9b\
    \x01\x06\n\x86\x05\n\x04\x06\0\x02\x07\x12\x06\xaa\x01\x02\xb0\x01\x03\
    \x1a\xf5\x04\x20Executes\x20a\x20batch\x20of\x20SQL\x20DML\x20statements\
    .\x20This\x20method\x20allows\x20many\x20statements\n\x20to\x20be\x20run\
    \x20with\x20lower\x20latency\x20than\x20submitting\x20them\x20sequential\
    ly\x20with\n\x20[ExecuteSql][google.spanner.v1.Spanner.ExecuteSql].\n\n\
    \x20Statements\x20are\x20executed\x20in\x20sequential\x20order.\x20A\x20\
    request\x20can\x20succeed\x20even\x20if\n\x20a\x20statement\x20fails.\
    \x20The\n\x20[ExecuteBatchDmlResponse.status][google.spanner.v1.ExecuteB\
    atchDmlResponse.status]\n\x20field\x20in\x20the\x20response\x20provides\
    \x20information\x20about\x20the\x20statement\x20that\x20failed.\n\x20Cli\
    ents\x20must\x20inspect\x20this\x20field\x20to\x20determine\x20whether\
    \x20an\x20error\x20occurred.\n\n\x20Execution\x20stops\x20after\x20the\
    \x20first\x20failed\x20statement;\x20the\x20remaining\x20statements\n\
    \x20are\x20not\x20executed.\n\n\r\n\x05\x06\0\x02\x07\x01\x12\x04\xaa\
    \x01\x06\x15\n\r\n\x05\x06\0\x02\x07\x02\x12\x04\xaa\x01\x16,\n\r\n\x05\
    \x06\0\x02\x07\x03\x12\x04\xab\x01\x0f&\n\x0f\n\x05\x06\0\x02\x07\x04\
    \x12\x06\xac\x01\x04\xaf\x01\x06\n\x13\n\t\x06\0\x02\x07\x04\xb0\xca\xbc\
    \"\x12\x06\xac\x01\x04\xaf\x01\x06\n\xb2\x05\n\x04\x06\0\x02\x08\x12\x06\
    \xc0\x01\x02\xc5\x01\x03\x1a\xa1\x05\x20Reads\x20rows\x20from\x20the\x20\
    database\x20using\x20key\x20lookups\x20and\x20scans,\x20as\x20a\n\x20sim\
    ple\x20key/value\x20style\x20alternative\x20to\n\x20[ExecuteSql][google.\
    spanner.v1.Spanner.ExecuteSql].\x20\x20This\x20method\x20cannot\x20be\n\
    \x20used\x20to\x20return\x20a\x20result\x20set\x20larger\x20than\x2010\
    \x20MiB;\x20if\x20the\x20read\x20matches\x20more\n\x20data\x20than\x20th\
    at,\x20the\x20read\x20fails\x20with\x20a\x20`FAILED_PRECONDITION`\n\x20e\
    rror.\n\n\x20Reads\x20inside\x20read-write\x20transactions\x20might\x20r\
    eturn\x20`ABORTED`.\x20If\n\x20this\x20occurs,\x20the\x20application\x20\
    should\x20restart\x20the\x20transaction\x20from\n\x20the\x20beginning.\
    \x20See\x20[Transaction][google.spanner.v1.Transaction]\x20for\x20more\n\
    \x20details.\n\n\x20Larger\x20result\x20sets\x20can\x20be\x20yielded\x20\
    in\x20streaming\x20fashion\x20by\x20calling\n\x20[StreamingRead][google.\
    spanner.v1.Spanner.StreamingRead]\x20instead.\n\n\r\n\x05\x06\0\x02\x08\
    \x01\x12\x04\xc0\x01\x06\n\n\r\n\x05\x06\0\x02\x08\x02\x12\x04\xc0\x01\
    \x0b\x16\n\r\n\x05\x06\0\x02\x08\x03\x12\x04\xc0\x01!*\n\x0f\n\x05\x06\0\
    \x02\x08\x04\x12\x06\xc1\x01\x04\xc4\x01\x06\n\x13\n\t\x06\0\x02\x08\x04\
    \xb0\xca\xbc\"\x12\x06\xc1\x01\x04\xc4\x01\x06\n\xbf\x02\n\x04\x06\0\x02\
    \t\x12\x06\xcc\x01\x02\xd1\x01\x03\x1a\xae\x02\x20Like\x20[Read][google.\
    spanner.v1.Spanner.Read],\x20except\x20returns\x20the\x20result\x20set\n\
    \x20as\x20a\x20stream.\x20Unlike\x20[Read][google.spanner.v1.Spanner.Rea\
    d],\x20there\x20is\x20no\n\x20limit\x20on\x20the\x20size\x20of\x20the\
    \x20returned\x20result\x20set.\x20However,\x20no\x20individual\x20row\
    \x20in\n\x20the\x20result\x20set\x20can\x20exceed\x20100\x20MiB,\x20and\
    \x20no\x20column\x20value\x20can\x20exceed\n\x2010\x20MiB.\n\n\r\n\x05\
    \x06\0\x02\t\x01\x12\x04\xcc\x01\x06\x13\n\r\n\x05\x06\0\x02\t\x02\x12\
    \x04\xcc\x01\x14\x1f\n\r\n\x05\x06\0\x02\t\x06\x12\x04\xcc\x01*0\n\r\n\
    \x05\x06\0\x02\t\x03\x12\x04\xcc\x011A\n\x0f\n\x05\x06\0\x02\t\x04\x12\
    \x06\xcd\x01\x04\xd0\x01\x06\n\x13\n\t\x06\0\x02\t\x04\xb0\xca\xbc\"\x12\
    \x06\xcd\x01\x04\xd0\x01\x06\n\x88\x02\n\x04\x06\0\x02\n\x12\x06\xd8\x01\
    \x02\xde\x01\x03\x1a\xf7\x01\x20Begins\x20a\x20new\x20transaction.\x20Th\
    is\x20step\x20can\x20often\x20be\x20skipped:\n\x20[Read][google.spanner.\
    v1.Spanner.Read],\n\x20[ExecuteSql][google.spanner.v1.Spanner.ExecuteSql\
    ]\x20and\n\x20[Commit][google.spanner.v1.Spanner.Commit]\x20can\x20begin\
    \x20a\x20new\x20transaction\x20as\x20a\n\x20side-effect.\n\n\r\n\x05\x06\
    \0\x02\n\x01\x12\x04\xd8\x01\x06\x16\n\r\n\x05\x06\0\x02\n\x02\x12\x04\
    \xd8\x01\x17.\n\r\n\x05\x06\0\x02\n\x03\x12\x04\xd8\x019D\n\x0f\n\x05\
    \x06\0\x02\n\x04\x12\x06\xd9\x01\x04\xdc\x01\x06\n\x13\n\t\x06\0\x02\n\
    \x04\xb0\xca\xbc\"\x12\x06\xd9\x01\x04\xdc\x01\x06\n\r\n\x05\x06\0\x02\n\
    \x04\x12\x04\xdd\x01\x04=\n\x10\n\x08\x06\0\x02\n\x04\x9b\x08\0\x12\x04\
    \xdd\x01\x04=\n\xb6\x03\n\x04\x06\0\x02\x0b\x12\x06\xe8\x01\x02\xf0\x01\
    \x03\x1a\xa5\x03\x20Commits\x20a\x20transaction.\x20The\x20request\x20in\
    cludes\x20the\x20mutations\x20to\x20be\n\x20applied\x20to\x20rows\x20in\
    \x20the\x20database.\n\n\x20`Commit`\x20might\x20return\x20an\x20`ABORTE\
    D`\x20error.\x20This\x20can\x20occur\x20at\x20any\x20time;\n\x20commonly\
    ,\x20the\x20cause\x20is\x20conflicts\x20with\x20concurrent\n\x20transact\
    ions.\x20However,\x20it\x20can\x20also\x20happen\x20for\x20a\x20variety\
    \x20of\x20other\n\x20reasons.\x20If\x20`Commit`\x20returns\x20`ABORTED`,\
    \x20the\x20caller\x20should\x20re-attempt\n\x20the\x20transaction\x20fro\
    m\x20the\x20beginning,\x20re-using\x20the\x20same\x20session.\n\n\r\n\
    \x05\x06\0\x02\x0b\x01\x12\x04\xe8\x01\x06\x0c\n\r\n\x05\x06\0\x02\x0b\
    \x02\x12\x04\xe8\x01\r\x1a\n\r\n\x05\x06\0\x02\x0b\x03\x12\x04\xe8\x01%3\
    \n\x0f\n\x05\x06\0\x02\x0b\x04\x12\x06\xe9\x01\x04\xec\x01\x06\n\x13\n\t\
    \x06\0\x02\x0b\x04\xb0\xca\xbc\"\x12\x06\xe9\x01\x04\xec\x01\x06\n\r\n\
    \x05\x06\0\x02\x0b\x04\x12\x04\xed\x01\x04N\n\x10\n\x08\x06\0\x02\x0b\
    \x04\x9b\x08\0\x12\x04\xed\x01\x04N\n\x0f\n\x05\x06\0\x02\x0b\x04\x12\
    \x06\xee\x01\x04\xef\x013\n\x12\n\x08\x06\0\x02\x0b\x04\x9b\x08\x01\x12\
    \x06\xee\x01\x04\xef\x013\n\xd8\x03\n\x04\x06\0\x02\x0c\x12\x06\xfb\x01\
    \x02\x81\x02\x03\x1a\xc7\x03\x20Rolls\x20back\x20a\x20transaction,\x20re\
    leasing\x20any\x20locks\x20it\x20holds.\x20It\x20is\x20a\x20good\n\x20id\
    ea\x20to\x20call\x20this\x20for\x20any\x20transaction\x20that\x20include\
    s\x20one\x20or\x20more\n\x20[Read][google.spanner.v1.Spanner.Read]\x20or\
    \n\x20[ExecuteSql][google.spanner.v1.Spanner.ExecuteSql]\x20requests\x20\
    and\x20ultimately\n\x20decides\x20not\x20to\x20commit.\n\n\x20`Rollback`\
    \x20returns\x20`OK`\x20if\x20it\x20successfully\x20aborts\x20the\x20tran\
    saction,\x20the\n\x20transaction\x20was\x20already\x20aborted,\x20or\x20\
    the\x20transaction\x20is\x20not\n\x20found.\x20`Rollback`\x20never\x20re\
    turns\x20`ABORTED`.\n\n\r\n\x05\x06\0\x02\x0c\x01\x12\x04\xfb\x01\x06\
    \x0e\n\r\n\x05\x06\0\x02\x0c\x02\x12\x04\xfb\x01\x0f\x1e\n\r\n\x05\x06\0\
    \x02\x0c\x03\x12\x04\xfb\x01)>\n\x0f\n\x05\x06\0\x02\x0c\x04\x12\x06\xfc\
    \x01\x04\xff\x01\x06\n\x13\n\t\x06\0\x02\x0c\x04\xb0\xca\xbc\"\x12\x06\
    \xfc\x01\x04\xff\x01\x06\n\r\n\x05\x06\0\x02\x0c\x04\x12\x04\x80\x02\x04\
    D\n\x10\n\x08\x06\0\x02\x0c\x04\x9b\x08\0\x12\x04\x80\x02\x04D\n\xf0\x05\
    \n\x04\x06\0\x02\r\x12\x06\x8f\x02\x02\x94\x02\x03\x1a\xdf\x05\x20Create\
    s\x20a\x20set\x20of\x20partition\x20tokens\x20that\x20can\x20be\x20used\
    \x20to\x20execute\x20a\x20query\n\x20operation\x20in\x20parallel.\x20\
    \x20Each\x20of\x20the\x20returned\x20partition\x20tokens\x20can\x20be\
    \x20used\n\x20by\x20[ExecuteStreamingSql][google.spanner.v1.Spanner.Exec\
    uteStreamingSql]\x20to\n\x20specify\x20a\x20subset\x20of\x20the\x20query\
    \x20result\x20to\x20read.\x20\x20The\x20same\x20session\x20and\n\x20read\
    -only\x20transaction\x20must\x20be\x20used\x20by\x20the\x20PartitionQuer\
    yRequest\x20used\x20to\n\x20create\x20the\x20partition\x20tokens\x20and\
    \x20the\x20ExecuteSqlRequests\x20that\x20use\x20the\n\x20partition\x20to\
    kens.\n\n\x20Partition\x20tokens\x20become\x20invalid\x20when\x20the\x20\
    session\x20used\x20to\x20create\x20them\n\x20is\x20deleted,\x20is\x20idl\
    e\x20for\x20too\x20long,\x20begins\x20a\x20new\x20transaction,\x20or\x20\
    becomes\x20too\n\x20old.\x20\x20When\x20any\x20of\x20these\x20happen,\
    \x20it\x20is\x20not\x20possible\x20to\x20resume\x20the\x20query,\x20and\
    \n\x20the\x20whole\x20operation\x20must\x20be\x20restarted\x20from\x20th\
    e\x20beginning.\n\n\r\n\x05\x06\0\x02\r\x01\x12\x04\x8f\x02\x06\x14\n\r\
    \n\x05\x06\0\x02\r\x02\x12\x04\x8f\x02\x15*\n\r\n\x05\x06\0\x02\r\x03\
    \x12\x04\x8f\x025F\n\x0f\n\x05\x06\0\x02\r\x04\x12\x06\x90\x02\x04\x93\
    \x02\x06\n\x13\n\t\x06\0\x02\r\x04\xb0\xca\xbc\"\x12\x06\x90\x02\x04\x93\
    \x02\x06\n\x85\x07\n\x04\x06\0\x02\x0e\x12\x06\xa4\x02\x02\xa9\x02\x03\
    \x1a\xf4\x06\x20Creates\x20a\x20set\x20of\x20partition\x20tokens\x20that\
    \x20can\x20be\x20used\x20to\x20execute\x20a\x20read\n\x20operation\x20in\
    \x20parallel.\x20\x20Each\x20of\x20the\x20returned\x20partition\x20token\
    s\x20can\x20be\x20used\n\x20by\x20[StreamingRead][google.spanner.v1.Span\
    ner.StreamingRead]\x20to\x20specify\x20a\n\x20subset\x20of\x20the\x20rea\
    d\x20result\x20to\x20read.\x20\x20The\x20same\x20session\x20and\x20read-\
    only\n\x20transaction\x20must\x20be\x20used\x20by\x20the\x20PartitionRea\
    dRequest\x20used\x20to\x20create\x20the\n\x20partition\x20tokens\x20and\
    \x20the\x20ReadRequests\x20that\x20use\x20the\x20partition\x20tokens.\
    \x20\x20There\n\x20are\x20no\x20ordering\x20guarantees\x20on\x20rows\x20\
    returned\x20among\x20the\x20returned\x20partition\n\x20tokens,\x20or\x20\
    even\x20within\x20each\x20individual\x20StreamingRead\x20call\x20issued\
    \x20with\x20a\n\x20partition_token.\n\n\x20Partition\x20tokens\x20become\
    \x20invalid\x20when\x20the\x20session\x20used\x20to\x20create\x20them\n\
    \x20is\x20deleted,\x20is\x20idle\x20for\x20too\x20long,\x20begins\x20a\
    \x20new\x20transaction,\x20or\x20becomes\x20too\n\x20old.\x20\x20When\
    \x20any\x20of\x20these\x20happen,\x20it\x20is\x20not\x20possible\x20to\
    \x20resume\x20the\x20read,\x20and\n\x20the\x20whole\x20operation\x20must\
    \x20be\x20restarted\x20from\x20the\x20beginning.\n\n\r\n\x05\x06\0\x02\
    \x0e\x01\x12\x04\xa4\x02\x06\x13\n\r\n\x05\x06\0\x02\x0e\x02\x12\x04\xa4\
    \x02\x14(\n\r\n\x05\x06\0\x02\x0e\x03\x12\x04\xa4\x023D\n\x0f\n\x05\x06\
    \0\x02\x0e\x04\x12\x06\xa5\x02\x04\xa8\x02\x06\n\x13\n\t\x06\0\x02\x0e\
    \x04\xb0\xca\xbc\"\x12\x06\xa5\x02\x04\xa8\x02\x06\nY\n\x02\x04\0\x12\
    \x06\xad\x02\0\xb8\x02\x01\x1aK\x20The\x20request\x20for\x20[CreateSessi\
    on][google.spanner.v1.Spanner.CreateSession].\n\n\x0b\n\x03\x04\0\x01\
    \x12\x04\xad\x02\x08\x1c\nM\n\x04\x04\0\x02\0\x12\x06\xaf\x02\x02\xb4\
    \x02\x04\x1a=\x20Required.\x20The\x20database\x20in\x20which\x20the\x20n\
    ew\x20session\x20is\x20created.\n\n\r\n\x05\x04\0\x02\0\x05\x12\x04\xaf\
    \x02\x02\x08\n\r\n\x05\x04\0\x02\0\x01\x12\x04\xaf\x02\t\x11\n\r\n\x05\
    \x04\0\x02\0\x03\x12\x04\xaf\x02\x14\x15\n\x0f\n\x05\x04\0\x02\0\x08\x12\
    \x06\xaf\x02\x16\xb4\x02\x03\n\x10\n\x08\x04\0\x02\0\x08\x9c\x08\0\x12\
    \x04\xb0\x02\x04*\n\x11\n\x07\x04\0\x02\0\x08\x9f\x08\x12\x06\xb1\x02\
    \x04\xb3\x02\x05\n&\n\x04\x04\0\x02\x01\x12\x04\xb7\x02\x02\x16\x1a\x18\
    \x20The\x20session\x20to\x20create.\n\n\r\n\x05\x04\0\x02\x01\x06\x12\
    \x04\xb7\x02\x02\t\n\r\n\x05\x04\0\x02\x01\x01\x12\x04\xb7\x02\n\x11\n\r\
    \n\x05\x04\0\x02\x01\x03\x12\x04\xb7\x02\x14\x15\nf\n\x02\x04\x01\x12\
    \x06\xbc\x02\0\xcf\x02\x01\x1aX\x20The\x20request\x20for\n\x20[BatchCrea\
    teSessions][google.spanner.v1.Spanner.BatchCreateSessions].\n\n\x0b\n\
    \x03\x04\x01\x01\x12\x04\xbc\x02\x08\"\nO\n\x04\x04\x01\x02\0\x12\x06\
    \xbe\x02\x02\xc3\x02\x04\x1a?\x20Required.\x20The\x20database\x20in\x20w\
    hich\x20the\x20new\x20sessions\x20are\x20created.\n\n\r\n\x05\x04\x01\
    \x02\0\x05\x12\x04\xbe\x02\x02\x08\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\
    \xbe\x02\t\x11\n\r\n\x05\x04\x01\x02\0\x03\x12\x04\xbe\x02\x14\x15\n\x0f\
    \n\x05\x04\x01\x02\0\x08\x12\x06\xbe\x02\x16\xc3\x02\x03\n\x10\n\x08\x04\
    \x01\x02\0\x08\x9c\x08\0\x12\x04\xbf\x02\x04*\n\x11\n\x07\x04\x01\x02\0\
    \x08\x9f\x08\x12\x06\xc0\x02\x04\xc2\x02\x05\nA\n\x04\x04\x01\x02\x01\
    \x12\x04\xc6\x02\x02\x1f\x1a3\x20Parameters\x20to\x20be\x20applied\x20to\
    \x20each\x20created\x20session.\n\n\r\n\x05\x04\x01\x02\x01\x06\x12\x04\
    \xc6\x02\x02\t\n\r\n\x05\x04\x01\x02\x01\x01\x12\x04\xc6\x02\n\x1a\n\r\n\
    \x05\x04\x01\x02\x01\x03\x12\x04\xc6\x02\x1d\x1e\n\xe8\x02\n\x04\x04\x01\
    \x02\x02\x12\x04\xce\x02\x02C\x1a\xd9\x02\x20Required.\x20The\x20number\
    \x20of\x20sessions\x20to\x20be\x20created\x20in\x20this\x20batch\x20call\
    .\n\x20The\x20API\x20may\x20return\x20fewer\x20than\x20the\x20requested\
    \x20number\x20of\x20sessions.\x20If\x20a\n\x20specific\x20number\x20of\
    \x20sessions\x20are\x20desired,\x20the\x20client\x20can\x20make\x20addit\
    ional\n\x20calls\x20to\x20BatchCreateSessions\x20(adjusting\n\x20[sessio\
    n_count][google.spanner.v1.BatchCreateSessionsRequest.session_count]\n\
    \x20as\x20necessary).\n\n\r\n\x05\x04\x01\x02\x02\x05\x12\x04\xce\x02\
    \x02\x07\n\r\n\x05\x04\x01\x02\x02\x01\x12\x04\xce\x02\x08\x15\n\r\n\x05\
    \x04\x01\x02\x02\x03\x12\x04\xce\x02\x18\x19\n\r\n\x05\x04\x01\x02\x02\
    \x08\x12\x04\xce\x02\x1aB\n\x10\n\x08\x04\x01\x02\x02\x08\x9c\x08\0\x12\
    \x04\xce\x02\x1bA\ng\n\x02\x04\x02\x12\x06\xd3\x02\0\xd6\x02\x01\x1aY\
    \x20The\x20response\x20for\n\x20[BatchCreateSessions][google.spanner.v1.\
    Spanner.BatchCreateSessions].\n\n\x0b\n\x03\x04\x02\x01\x12\x04\xd3\x02\
    \x08#\n-\n\x04\x04\x02\x02\0\x12\x04\xd5\x02\x02\x1f\x1a\x1f\x20The\x20f\
    reshly\x20created\x20sessions.\n\n\r\n\x05\x04\x02\x02\0\x04\x12\x04\xd5\
    \x02\x02\n\n\r\n\x05\x04\x02\x02\0\x06\x12\x04\xd5\x02\x0b\x12\n\r\n\x05\
    \x04\x02\x02\0\x01\x12\x04\xd5\x02\x13\x1a\n\r\n\x05\x04\x02\x02\0\x03\
    \x12\x04\xd5\x02\x1d\x1e\n3\n\x02\x04\x03\x12\x06\xd9\x02\0\xf4\x02\x01\
    \x1a%\x20A\x20session\x20in\x20the\x20Cloud\x20Spanner\x20API.\n\n\x0b\n\
    \x03\x04\x03\x01\x12\x04\xd9\x02\x08\x0f\n\r\n\x03\x04\x03\x07\x12\x06\
    \xda\x02\x02\xdd\x02\x04\n\x0f\n\x05\x04\x03\x07\x9d\x08\x12\x06\xda\x02\
    \x02\xdd\x02\x04\n~\n\x04\x04\x03\x02\0\x12\x04\xe1\x02\x02\x12\x1ap\x20\
    The\x20name\x20of\x20the\x20session.\x20This\x20is\x20always\x20system-a\
    ssigned;\x20values\x20provided\n\x20when\x20creating\x20a\x20session\x20\
    are\x20ignored.\n\n\r\n\x05\x04\x03\x02\0\x05\x12\x04\xe1\x02\x02\x08\n\
    \r\n\x05\x04\x03\x02\0\x01\x12\x04\xe1\x02\t\r\n\r\n\x05\x04\x03\x02\0\
    \x03\x12\x04\xe1\x02\x10\x11\n\xd6\x03\n\x04\x04\x03\x02\x01\x12\x04\xec\
    \x02\x02!\x1a\xc7\x03\x20The\x20labels\x20for\x20the\x20session.\n\n\x20\
    \x20*\x20Label\x20keys\x20must\x20be\x20between\x201\x20and\x2063\x20cha\
    racters\x20long\x20and\x20must\x20conform\x20to\n\x20\x20\x20\x20the\x20\
    following\x20regular\x20expression:\x20`[a-z]([-a-z0-9]*[a-z0-9])?`.\n\
    \x20\x20*\x20Label\x20values\x20must\x20be\x20between\x200\x20and\x2063\
    \x20characters\x20long\x20and\x20must\x20conform\n\x20\x20\x20\x20to\x20\
    the\x20regular\x20expression\x20`([a-z]([-a-z0-9]*[a-z0-9])?)?`.\n\x20\
    \x20*\x20No\x20more\x20than\x2064\x20labels\x20can\x20be\x20associated\
    \x20with\x20a\x20given\x20session.\n\n\x20See\x20https://goo.gl/xmQnxf\
    \x20for\x20more\x20information\x20on\x20and\x20examples\x20of\x20labels.\
    \n\n\r\n\x05\x04\x03\x02\x01\x06\x12\x04\xec\x02\x02\x15\n\r\n\x05\x04\
    \x03\x02\x01\x01\x12\x04\xec\x02\x16\x1c\n\r\n\x05\x04\x03\x02\x01\x03\
    \x12\x04\xec\x02\x1f\x20\nG\n\x04\x04\x03\x02\x02\x12\x04\xef\x02\x02,\
    \x1a9\x20Output\x20only.\x20The\x20timestamp\x20when\x20the\x20session\
    \x20is\x20created.\n\n\r\n\x05\x04\x03\x02\x02\x06\x12\x04\xef\x02\x02\
    \x1b\n\r\n\x05\x04\x03\x02\x02\x01\x12\x04\xef\x02\x1c'\n\r\n\x05\x04\
    \x03\x02\x02\x03\x12\x04\xef\x02*+\n\x8d\x01\n\x04\x04\x03\x02\x03\x12\
    \x04\xf3\x02\x02:\x1a\x7f\x20Output\x20only.\x20The\x20approximate\x20ti\
    mestamp\x20when\x20the\x20session\x20is\x20last\x20used.\x20It\x20is\n\
    \x20typically\x20earlier\x20than\x20the\x20actual\x20last\x20use\x20time\
    .\n\n\r\n\x05\x04\x03\x02\x03\x06\x12\x04\xf3\x02\x02\x1b\n\r\n\x05\x04\
    \x03\x02\x03\x01\x12\x04\xf3\x02\x1c5\n\r\n\x05\x04\x03\x02\x03\x03\x12\
    \x04\xf3\x0289\nS\n\x02\x04\x04\x12\x06\xf7\x02\0\xfd\x02\x01\x1aE\x20Th\
    e\x20request\x20for\x20[GetSession][google.spanner.v1.Spanner.GetSession\
    ].\n\n\x0b\n\x03\x04\x04\x01\x12\x04\xf7\x02\x08\x19\n@\n\x04\x04\x04\
    \x02\0\x12\x06\xf9\x02\x02\xfc\x02\x04\x1a0\x20Required.\x20The\x20name\
    \x20of\x20the\x20session\x20to\x20retrieve.\n\n\r\n\x05\x04\x04\x02\0\
    \x05\x12\x04\xf9\x02\x02\x08\n\r\n\x05\x04\x04\x02\0\x01\x12\x04\xf9\x02\
    \t\r\n\r\n\x05\x04\x04\x02\0\x03\x12\x04\xf9\x02\x10\x11\n\x0f\n\x05\x04\
    \x04\x02\0\x08\x12\x06\xf9\x02\x12\xfc\x02\x03\n\x10\n\x08\x04\x04\x02\0\
    \x08\x9c\x08\0\x12\x04\xfa\x02\x04*\n\x0f\n\x07\x04\x04\x02\0\x08\x9f\
    \x08\x12\x04\xfb\x02\x04P\nW\n\x02\x04\x05\x12\x06\x80\x03\0\x9e\x03\x01\
    \x1aI\x20The\x20request\x20for\x20[ListSessions][google.spanner.v1.Spann\
    er.ListSessions].\n\n\x0b\n\x03\x04\x05\x01\x12\x04\x80\x03\x08\x1b\nC\n\
    \x04\x04\x05\x02\0\x12\x06\x82\x03\x02\x87\x03\x04\x1a3\x20Required.\x20\
    The\x20database\x20in\x20which\x20to\x20list\x20sessions.\n\n\r\n\x05\
    \x04\x05\x02\0\x05\x12\x04\x82\x03\x02\x08\n\r\n\x05\x04\x05\x02\0\x01\
    \x12\x04\x82\x03\t\x11\n\r\n\x05\x04\x05\x02\0\x03\x12\x04\x82\x03\x14\
    \x15\n\x0f\n\x05\x04\x05\x02\0\x08\x12\x06\x82\x03\x16\x87\x03\x03\n\x10\
    \n\x08\x04\x05\x02\0\x08\x9c\x08\0\x12\x04\x83\x03\x04*\n\x11\n\x07\x04\
    \x05\x02\0\x08\x9f\x08\x12\x06\x84\x03\x04\x86\x03\x05\n\x85\x01\n\x04\
    \x04\x05\x02\x01\x12\x04\x8b\x03\x02\x16\x1aw\x20Number\x20of\x20session\
    s\x20to\x20be\x20returned\x20in\x20the\x20response.\x20If\x200\x20or\x20\
    less,\x20defaults\n\x20to\x20the\x20server's\x20maximum\x20allowed\x20pa\
    ge\x20size.\n\n\r\n\x05\x04\x05\x02\x01\x05\x12\x04\x8b\x03\x02\x07\n\r\
    \n\x05\x04\x05\x02\x01\x01\x12\x04\x8b\x03\x08\x11\n\r\n\x05\x04\x05\x02\
    \x01\x03\x12\x04\x8b\x03\x14\x15\n\xd9\x01\n\x04\x04\x05\x02\x02\x12\x04\
    \x91\x03\x02\x18\x1a\xca\x01\x20If\x20non-empty,\x20`page_token`\x20shou\
    ld\x20contain\x20a\n\x20[next_page_token][google.spanner.v1.ListSessions\
    Response.next_page_token]\n\x20from\x20a\x20previous\n\x20[ListSessionsR\
    esponse][google.spanner.v1.ListSessionsResponse].\n\n\r\n\x05\x04\x05\
    \x02\x02\x05\x12\x04\x91\x03\x02\x08\n\r\n\x05\x04\x05\x02\x02\x01\x12\
    \x04\x91\x03\t\x13\n\r\n\x05\x04\x05\x02\x02\x03\x12\x04\x91\x03\x16\x17\
    \n\xaf\x03\n\x04\x04\x05\x02\x03\x12\x04\x9d\x03\x02\x14\x1a\xa0\x03\x20\
    An\x20expression\x20for\x20filtering\x20the\x20results\x20of\x20the\x20r\
    equest.\x20Filter\x20rules\x20are\n\x20case\x20insensitive.\x20The\x20fi\
    elds\x20eligible\x20for\x20filtering\x20are:\n\n\x20\x20\x20*\x20`labels\
    .key`\x20where\x20key\x20is\x20the\x20name\x20of\x20a\x20label\n\n\x20So\
    me\x20examples\x20of\x20using\x20filters\x20are:\n\n\x20\x20\x20*\x20`la\
    bels.env:*`\x20-->\x20The\x20session\x20has\x20the\x20label\x20\"env\".\
    \n\x20\x20\x20*\x20`labels.env:dev`\x20-->\x20The\x20session\x20has\x20t\
    he\x20label\x20\"env\"\x20and\x20the\x20value\x20of\n\x20\x20\x20\x20\
    \x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\
    \x20\x20the\x20label\x20contains\x20the\x20string\x20\"dev\".\n\n\r\n\
    \x05\x04\x05\x02\x03\x05\x12\x04\x9d\x03\x02\x08\n\r\n\x05\x04\x05\x02\
    \x03\x01\x12\x04\x9d\x03\t\x0f\n\r\n\x05\x04\x05\x02\x03\x03\x12\x04\x9d\
    \x03\x12\x13\nX\n\x02\x04\x06\x12\x06\xa1\x03\0\xa9\x03\x01\x1aJ\x20The\
    \x20response\x20for\x20[ListSessions][google.spanner.v1.Spanner.ListSess\
    ions].\n\n\x0b\n\x03\x04\x06\x01\x12\x04\xa1\x03\x08\x1c\n/\n\x04\x04\
    \x06\x02\0\x12\x04\xa3\x03\x02\x20\x1a!\x20The\x20list\x20of\x20requeste\
    d\x20sessions.\n\n\r\n\x05\x04\x06\x02\0\x04\x12\x04\xa3\x03\x02\n\n\r\n\
    \x05\x04\x06\x02\0\x06\x12\x04\xa3\x03\x0b\x12\n\r\n\x05\x04\x06\x02\0\
    \x01\x12\x04\xa3\x03\x13\x1b\n\r\n\x05\x04\x06\x02\0\x03\x12\x04\xa3\x03\
    \x1e\x1f\n\xa4\x01\n\x04\x04\x06\x02\x01\x12\x04\xa8\x03\x02\x1d\x1a\x95\
    \x01\x20`next_page_token`\x20can\x20be\x20sent\x20in\x20a\x20subsequent\
    \n\x20[ListSessions][google.spanner.v1.Spanner.ListSessions]\x20call\x20\
    to\x20fetch\x20more\n\x20of\x20the\x20matching\x20sessions.\n\n\r\n\x05\
    \x04\x06\x02\x01\x05\x12\x04\xa8\x03\x02\x08\n\r\n\x05\x04\x06\x02\x01\
    \x01\x12\x04\xa8\x03\t\x18\n\r\n\x05\x04\x06\x02\x01\x03\x12\x04\xa8\x03\
    \x1b\x1c\nY\n\x02\x04\x07\x12\x06\xac\x03\0\xb2\x03\x01\x1aK\x20The\x20r\
    equest\x20for\x20[DeleteSession][google.spanner.v1.Spanner.DeleteSession\
    ].\n\n\x0b\n\x03\x04\x07\x01\x12\x04\xac\x03\x08\x1c\n>\n\x04\x04\x07\
    \x02\0\x12\x06\xae\x03\x02\xb1\x03\x04\x1a.\x20Required.\x20The\x20name\
    \x20of\x20the\x20session\x20to\x20delete.\n\n\r\n\x05\x04\x07\x02\0\x05\
    \x12\x04\xae\x03\x02\x08\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\xae\x03\t\r\
    \n\r\n\x05\x04\x07\x02\0\x03\x12\x04\xae\x03\x10\x11\n\x0f\n\x05\x04\x07\
    \x02\0\x08\x12\x06\xae\x03\x12\xb1\x03\x03\n\x10\n\x08\x04\x07\x02\0\x08\
    \x9c\x08\0\x12\x04\xaf\x03\x04*\n\x0f\n\x07\x04\x07\x02\0\x08\x9f\x08\
    \x12\x04\xb0\x03\x04P\n\x9e\x01\n\x02\x04\x08\x12\x06\xb6\x03\0\x94\x04\
    \x01\x1a\x8f\x01\x20The\x20request\x20for\x20[ExecuteSql][google.spanner\
    .v1.Spanner.ExecuteSql]\x20and\n\x20[ExecuteStreamingSql][google.spanner\
    .v1.Spanner.ExecuteStreamingSql].\n\n\x0b\n\x03\x04\x08\x01\x12\x04\xb6\
    \x03\x08\x19\n@\n\x04\x04\x08\x04\0\x12\x06\xb8\x03\x02\xc3\x03\x03\x1a0\
    \x20Mode\x20in\x20which\x20the\x20statement\x20must\x20be\x20processed.\
    \n\n\r\n\x05\x04\x08\x04\0\x01\x12\x04\xb8\x03\x07\x10\nL\n\x06\x04\x08\
    \x04\0\x02\0\x12\x04\xba\x03\x04\x0f\x1a<\x20The\x20default\x20mode.\x20\
    Only\x20the\x20statement\x20results\x20are\x20returned.\n\n\x0f\n\x07\
    \x04\x08\x04\0\x02\0\x01\x12\x04\xba\x03\x04\n\n\x0f\n\x07\x04\x08\x04\0\
    \x02\0\x02\x12\x04\xba\x03\r\x0e\nr\n\x06\x04\x08\x04\0\x02\x01\x12\x04\
    \xbe\x03\x04\r\x1ab\x20This\x20mode\x20returns\x20only\x20the\x20query\
    \x20plan,\x20without\x20any\x20results\x20or\n\x20execution\x20statistic\
    s\x20information.\n\n\x0f\n\x07\x04\x08\x04\0\x02\x01\x01\x12\x04\xbe\
    \x03\x04\x08\n\x0f\n\x07\x04\x08\x04\0\x02\x01\x02\x12\x04\xbe\x03\x0b\
    \x0c\nm\n\x06\x04\x08\x04\0\x02\x02\x12\x04\xc2\x03\x04\x10\x1a]\x20This\
    \x20mode\x20returns\x20both\x20the\x20query\x20plan\x20and\x20the\x20exe\
    cution\x20statistics\x20along\n\x20with\x20the\x20results.\n\n\x0f\n\x07\
    \x04\x08\x04\0\x02\x02\x01\x12\x04\xc2\x03\x04\x0b\n\x0f\n\x07\x04\x08\
    \x04\0\x02\x02\x02\x12\x04\xc2\x03\x0e\x0f\nS\n\x04\x04\x08\x02\0\x12\
    \x06\xc6\x03\x02\xc9\x03\x04\x1aC\x20Required.\x20The\x20session\x20in\
    \x20which\x20the\x20SQL\x20query\x20should\x20be\x20performed.\n\n\r\n\
    \x05\x04\x08\x02\0\x05\x12\x04\xc6\x03\x02\x08\n\r\n\x05\x04\x08\x02\0\
    \x01\x12\x04\xc6\x03\t\x10\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\xc6\x03\
    \x13\x14\n\x0f\n\x05\x04\x08\x02\0\x08\x12\x06\xc6\x03\x15\xc9\x03\x03\n\
    \x10\n\x08\x04\x08\x02\0\x08\x9c\x08\0\x12\x04\xc7\x03\x04*\n\x0f\n\x07\
    \x04\x08\x02\0\x08\x9f\x08\x12\x04\xc8\x03\x04P\n\xb9\x03\n\x04\x04\x08\
    \x02\x01\x12\x04\xd5\x03\x02&\x1a\xaa\x03\x20The\x20transaction\x20to\
    \x20use.\n\n\x20For\x20queries,\x20if\x20none\x20is\x20provided,\x20the\
    \x20default\x20is\x20a\x20temporary\x20read-only\n\x20transaction\x20wit\
    h\x20strong\x20concurrency.\n\n\x20Standard\x20DML\x20statements\x20requ\
    ire\x20a\x20read-write\x20transaction.\x20To\x20protect\n\x20against\x20\
    replays,\x20single-use\x20transactions\x20are\x20not\x20supported.\x20\
    \x20The\x20caller\n\x20must\x20either\x20supply\x20an\x20existing\x20tra\
    nsaction\x20ID\x20or\x20begin\x20a\x20new\x20transaction.\n\n\x20Partiti\
    oned\x20DML\x20requires\x20an\x20existing\x20Partitioned\x20DML\x20trans\
    action\x20ID.\n\n\r\n\x05\x04\x08\x02\x01\x06\x12\x04\xd5\x03\x02\x15\n\
    \r\n\x05\x04\x08\x02\x01\x01\x12\x04\xd5\x03\x16!\n\r\n\x05\x04\x08\x02\
    \x01\x03\x12\x04\xd5\x03$%\n)\n\x04\x04\x08\x02\x02\x12\x04\xd8\x03\x02:\
    \x1a\x1b\x20Required.\x20The\x20SQL\x20string.\n\n\r\n\x05\x04\x08\x02\
    \x02\x05\x12\x04\xd8\x03\x02\x08\n\r\n\x05\x04\x08\x02\x02\x01\x12\x04\
    \xd8\x03\t\x0c\n\r\n\x05\x04\x08\x02\x02\x03\x12\x04\xd8\x03\x0f\x10\n\r\
    \n\x05\x04\x08\x02\x02\x08\x12\x04\xd8\x03\x119\n\x10\n\x08\x04\x08\x02\
    \x02\x08\x9c\x08\0\x12\x04\xd8\x03\x128\n\x88\x04\n\x04\x04\x08\x02\x03\
    \x12\x04\xe6\x03\x02$\x1a\xf9\x03\x20Parameter\x20names\x20and\x20values\
    \x20that\x20bind\x20to\x20placeholders\x20in\x20the\x20SQL\x20string.\n\
    \n\x20A\x20parameter\x20placeholder\x20consists\x20of\x20the\x20`@`\x20c\
    haracter\x20followed\x20by\x20the\n\x20parameter\x20name\x20(for\x20exam\
    ple,\x20`@firstName`).\x20Parameter\x20names\x20can\x20contain\n\x20lett\
    ers,\x20numbers,\x20and\x20underscores.\n\n\x20Parameters\x20can\x20appe\
    ar\x20anywhere\x20that\x20a\x20literal\x20value\x20is\x20expected.\x20\
    \x20The\x20same\n\x20parameter\x20name\x20can\x20be\x20used\x20more\x20t\
    han\x20once,\x20for\x20example:\n\n\x20`\"WHERE\x20id\x20>\x20@msg_id\
    \x20AND\x20id\x20<\x20@msg_id\x20+\x20100\"`\n\n\x20It\x20is\x20an\x20er\
    ror\x20to\x20execute\x20a\x20SQL\x20statement\x20with\x20unbound\x20para\
    meters.\n\n\r\n\x05\x04\x08\x02\x03\x06\x12\x04\xe6\x03\x02\x18\n\r\n\
    \x05\x04\x08\x02\x03\x01\x12\x04\xe6\x03\x19\x1f\n\r\n\x05\x04\x08\x02\
    \x03\x03\x12\x04\xe6\x03\"#\n\xdd\x03\n\x04\x04\x08\x02\x04\x12\x04\xf1\
    \x03\x02$\x1a\xce\x03\x20It\x20is\x20not\x20always\x20possible\x20for\
    \x20Cloud\x20Spanner\x20to\x20infer\x20the\x20right\x20SQL\x20type\n\x20\
    from\x20a\x20JSON\x20value.\x20\x20For\x20example,\x20values\x20of\x20ty\
    pe\x20`BYTES`\x20and\x20values\n\x20of\x20type\x20`STRING`\x20both\x20ap\
    pear\x20in\n\x20[params][google.spanner.v1.ExecuteSqlRequest.params]\x20\
    as\x20JSON\x20strings.\n\n\x20In\x20these\x20cases,\x20`param_types`\x20\
    can\x20be\x20used\x20to\x20specify\x20the\x20exact\n\x20SQL\x20type\x20f\
    or\x20some\x20or\x20all\x20of\x20the\x20SQL\x20statement\x20parameters.\
    \x20See\x20the\n\x20definition\x20of\x20[Type][google.spanner.v1.Type]\
    \x20for\x20more\x20information\n\x20about\x20SQL\x20types.\n\n\r\n\x05\
    \x04\x08\x02\x04\x06\x12\x04\xf1\x03\x02\x13\n\r\n\x05\x04\x08\x02\x04\
    \x01\x12\x04\xf1\x03\x14\x1f\n\r\n\x05\x04\x08\x02\x04\x03\x12\x04\xf1\
    \x03\"#\n\x9e\x03\n\x04\x04\x08\x02\x05\x12\x04\xf9\x03\x02\x19\x1a\x8f\
    \x03\x20If\x20this\x20request\x20is\x20resuming\x20a\x20previously\x20in\
    terrupted\x20SQL\x20statement\n\x20execution,\x20`resume_token`\x20shoul\
    d\x20be\x20copied\x20from\x20the\x20last\n\x20[PartialResultSet][google.\
    spanner.v1.PartialResultSet]\x20yielded\x20before\x20the\n\x20interrupti\
    on.\x20Doing\x20this\x20enables\x20the\x20new\x20SQL\x20statement\x20exe\
    cution\x20to\x20resume\n\x20where\x20the\x20last\x20one\x20left\x20off.\
    \x20The\x20rest\x20of\x20the\x20request\x20parameters\x20must\n\x20exact\
    ly\x20match\x20the\x20request\x20that\x20yielded\x20this\x20token.\n\n\r\
    \n\x05\x04\x08\x02\x05\x05\x12\x04\xf9\x03\x02\x07\n\r\n\x05\x04\x08\x02\
    \x05\x01\x12\x04\xf9\x03\x08\x14\n\r\n\x05\x04\x08\x02\x05\x03\x12\x04\
    \xf9\x03\x17\x18\n\xf5\x02\n\x04\x04\x08\x02\x06\x12\x04\x81\x04\x02\x1b\
    \x1a\xe6\x02\x20Used\x20to\x20control\x20the\x20amount\x20of\x20debuggin\
    g\x20information\x20returned\x20in\n\x20[ResultSetStats][google.spanner.\
    v1.ResultSetStats].\x20If\n\x20[partition_token][google.spanner.v1.Execu\
    teSqlRequest.partition_token]\x20is\n\x20set,\x20[query_mode][google.spa\
    nner.v1.ExecuteSqlRequest.query_mode]\x20can\x20only\n\x20be\x20set\x20t\
    o\n\x20[QueryMode.NORMAL][google.spanner.v1.ExecuteSqlRequest.QueryMode.\
    NORMAL].\n\n\r\n\x05\x04\x08\x02\x06\x06\x12\x04\x81\x04\x02\x0b\n\r\n\
    \x05\x04\x08\x02\x06\x01\x12\x04\x81\x04\x0c\x16\n\r\n\x05\x04\x08\x02\
    \x06\x03\x12\x04\x81\x04\x19\x1a\n\x99\x02\n\x04\x04\x08\x02\x07\x12\x04\
    \x87\x04\x02\x1c\x1a\x8a\x02\x20If\x20present,\x20results\x20will\x20be\
    \x20restricted\x20to\x20the\x20specified\x20partition\n\x20previously\
    \x20created\x20using\x20PartitionQuery().\x20\x20There\x20must\x20be\x20\
    an\x20exact\n\x20match\x20for\x20the\x20values\x20of\x20fields\x20common\
    \x20to\x20this\x20message\x20and\x20the\n\x20PartitionQueryRequest\x20me\
    ssage\x20used\x20to\x20create\x20this\x20partition_token.\n\n\r\n\x05\
    \x04\x08\x02\x07\x05\x12\x04\x87\x04\x02\x07\n\r\n\x05\x04\x08\x02\x07\
    \x01\x12\x04\x87\x04\x08\x17\n\r\n\x05\x04\x08\x02\x07\x03\x12\x04\x87\
    \x04\x1a\x1b\n\x9b\x04\n\x04\x04\x08\x02\x08\x12\x04\x93\x04\x02\x12\x1a\
    \x8c\x04\x20A\x20per-transaction\x20sequence\x20number\x20used\x20to\x20\
    identify\x20this\x20request.\x20This\x20field\n\x20makes\x20each\x20requ\
    est\x20idempotent\x20such\x20that\x20if\x20the\x20request\x20is\x20recei\
    ved\x20multiple\n\x20times,\x20at\x20most\x20one\x20will\x20succeed.\n\n\
    \x20The\x20sequence\x20number\x20must\x20be\x20monotonically\x20increasi\
    ng\x20within\x20the\n\x20transaction.\x20If\x20a\x20request\x20arrives\
    \x20for\x20the\x20first\x20time\x20with\x20an\x20out-of-order\n\x20seque\
    nce\x20number,\x20the\x20transaction\x20may\x20be\x20aborted.\x20Replays\
    \x20of\x20previously\n\x20handled\x20requests\x20will\x20yield\x20the\
    \x20same\x20response\x20as\x20the\x20first\x20execution.\n\n\x20Required\
    \x20for\x20DML\x20statements.\x20Ignored\x20for\x20queries.\n\n\r\n\x05\
    \x04\x08\x02\x08\x05\x12\x04\x93\x04\x02\x07\n\r\n\x05\x04\x08\x02\x08\
    \x01\x12\x04\x93\x04\x08\r\n\r\n\x05\x04\x08\x02\x08\x03\x12\x04\x93\x04\
    \x10\x11\n]\n\x02\x04\t\x12\x06\x97\x04\0\xd6\x04\x01\x1aO\x20The\x20req\
    uest\x20for\x20[ExecuteBatchDml][google.spanner.v1.Spanner.ExecuteBatchD\
    ml].\n\n\x0b\n\x03\x04\t\x01\x12\x04\x97\x04\x08\x1e\n)\n\x04\x04\t\x03\
    \0\x12\x06\x99\x04\x02\xb6\x04\x03\x1a\x19\x20A\x20single\x20DML\x20stat\
    ement.\n\n\r\n\x05\x04\t\x03\0\x01\x12\x04\x99\x04\n\x13\n+\n\x06\x04\t\
    \x03\0\x02\0\x12\x04\x9b\x04\x04\x13\x1a\x1b\x20Required.\x20The\x20DML\
    \x20string.\n\n\x0f\n\x07\x04\t\x03\0\x02\0\x05\x12\x04\x9b\x04\x04\n\n\
    \x0f\n\x07\x04\t\x03\0\x02\0\x01\x12\x04\x9b\x04\x0b\x0e\n\x0f\n\x07\x04\
    \t\x03\0\x02\0\x03\x12\x04\x9b\x04\x11\x12\n\x8a\x04\n\x06\x04\t\x03\0\
    \x02\x01\x12\x04\xa9\x04\x04&\x1a\xf9\x03\x20Parameter\x20names\x20and\
    \x20values\x20that\x20bind\x20to\x20placeholders\x20in\x20the\x20DML\x20\
    string.\n\n\x20A\x20parameter\x20placeholder\x20consists\x20of\x20the\
    \x20`@`\x20character\x20followed\x20by\x20the\n\x20parameter\x20name\x20\
    (for\x20example,\x20`@firstName`).\x20Parameter\x20names\x20can\x20conta\
    in\n\x20letters,\x20numbers,\x20and\x20underscores.\n\n\x20Parameters\
    \x20can\x20appear\x20anywhere\x20that\x20a\x20literal\x20value\x20is\x20\
    expected.\x20\x20The\n\x20same\x20parameter\x20name\x20can\x20be\x20used\
    \x20more\x20than\x20once,\x20for\x20example:\n\n\x20`\"WHERE\x20id\x20>\
    \x20@msg_id\x20AND\x20id\x20<\x20@msg_id\x20+\x20100\"`\n\n\x20It\x20is\
    \x20an\x20error\x20to\x20execute\x20a\x20SQL\x20statement\x20with\x20unb\
    ound\x20parameters.\n\n\x0f\n\x07\x04\t\x03\0\x02\x01\x06\x12\x04\xa9\
    \x04\x04\x1a\n\x0f\n\x07\x04\t\x03\0\x02\x01\x01\x12\x04\xa9\x04\x1b!\n\
    \x0f\n\x07\x04\t\x03\0\x02\x01\x03\x12\x04\xa9\x04$%\n\xef\x03\n\x06\x04\
    \t\x03\0\x02\x02\x12\x04\xb5\x04\x04&\x1a\xde\x03\x20It\x20is\x20not\x20\
    always\x20possible\x20for\x20Cloud\x20Spanner\x20to\x20infer\x20the\x20r\
    ight\x20SQL\x20type\n\x20from\x20a\x20JSON\x20value.\x20\x20For\x20examp\
    le,\x20values\x20of\x20type\x20`BYTES`\x20and\x20values\n\x20of\x20type\
    \x20`STRING`\x20both\x20appear\x20in\n\x20[params][google.spanner.v1.Exe\
    cuteBatchDmlRequest.Statement.params]\x20as\n\x20JSON\x20strings.\n\n\
    \x20In\x20these\x20cases,\x20`param_types`\x20can\x20be\x20used\x20to\
    \x20specify\x20the\x20exact\n\x20SQL\x20type\x20for\x20some\x20or\x20all\
    \x20of\x20the\x20SQL\x20statement\x20parameters.\x20See\x20the\n\x20defi\
    nition\x20of\x20[Type][google.spanner.v1.Type]\x20for\x20more\x20informa\
    tion\n\x20about\x20SQL\x20types.\n\n\x0f\n\x07\x04\t\x03\0\x02\x02\x06\
    \x12\x04\xb5\x04\x04\x15\n\x0f\n\x07\x04\t\x03\0\x02\x02\x01\x12\x04\xb5\
    \x04\x16!\n\x0f\n\x07\x04\t\x03\0\x02\x02\x03\x12\x04\xb5\x04$%\nX\n\x04\
    \x04\t\x02\0\x12\x06\xb9\x04\x02\xbc\x04\x04\x1aH\x20Required.\x20The\
    \x20session\x20in\x20which\x20the\x20DML\x20statements\x20should\x20be\
    \x20performed.\n\n\r\n\x05\x04\t\x02\0\x05\x12\x04\xb9\x04\x02\x08\n\r\n\
    \x05\x04\t\x02\0\x01\x12\x04\xb9\x04\t\x10\n\r\n\x05\x04\t\x02\0\x03\x12\
    \x04\xb9\x04\x13\x14\n\x0f\n\x05\x04\t\x02\0\x08\x12\x06\xb9\x04\x15\xbc\
    \x04\x03\n\x10\n\x08\x04\t\x02\0\x08\x9c\x08\0\x12\x04\xba\x04\x04*\n\
    \x0f\n\x07\x04\t\x02\0\x08\x9f\x08\x12\x04\xbb\x04\x04P\n\xf4\x01\n\x04\
    \x04\t\x02\x01\x12\x04\xc3\x04\x02O\x1a\xe5\x01\x20Required.\x20The\x20t\
    ransaction\x20to\x20use.\x20Must\x20be\x20a\x20read-write\x20transaction\
    .\n\n\x20To\x20protect\x20against\x20replays,\x20single-use\x20transacti\
    ons\x20are\x20not\x20supported.\x20The\n\x20caller\x20must\x20either\x20\
    supply\x20an\x20existing\x20transaction\x20ID\x20or\x20begin\x20a\x20new\
    \n\x20transaction.\n\n\r\n\x05\x04\t\x02\x01\x06\x12\x04\xc3\x04\x02\x15\
    \n\r\n\x05\x04\t\x02\x01\x01\x12\x04\xc3\x04\x16!\n\r\n\x05\x04\t\x02\
    \x01\x03\x12\x04\xc3\x04$%\n\r\n\x05\x04\t\x02\x01\x08\x12\x04\xc3\x04&N\
    \n\x10\n\x08\x04\t\x02\x01\x08\x9c\x08\0\x12\x04\xc3\x04'M\n\xe8\x02\n\
    \x04\x04\t\x02\x02\x12\x04\xcb\x04\x02M\x1a\xd9\x02\x20Required.\x20The\
    \x20list\x20of\x20statements\x20to\x20execute\x20in\x20this\x20batch.\
    \x20Statements\x20are\n\x20executed\x20serially,\x20such\x20that\x20the\
    \x20effects\x20of\x20statement\x20`i`\x20are\x20visible\x20to\n\x20state\
    ment\x20`i+1`.\x20Each\x20statement\x20must\x20be\x20a\x20DML\x20stateme\
    nt.\x20Execution\x20stops\x20at\n\x20the\x20first\x20failed\x20statement\
    ;\x20the\x20remaining\x20statements\x20are\x20not\x20executed.\n\n\x20Ca\
    llers\x20must\x20provide\x20at\x20least\x20one\x20statement.\n\n\r\n\x05\
    \x04\t\x02\x02\x04\x12\x04\xcb\x04\x02\n\n\r\n\x05\x04\t\x02\x02\x06\x12\
    \x04\xcb\x04\x0b\x14\n\r\n\x05\x04\t\x02\x02\x01\x12\x04\xcb\x04\x15\x1f\
    \n\r\n\x05\x04\t\x02\x02\x03\x12\x04\xcb\x04\"#\n\r\n\x05\x04\t\x02\x02\
    \x08\x12\x04\xcb\x04$L\n\x10\n\x08\x04\t\x02\x02\x08\x9c\x08\0\x12\x04\
    \xcb\x04%K\n\xf1\x03\n\x04\x04\t\x02\x03\x12\x04\xd5\x04\x02;\x1a\xe2\
    \x03\x20Required.\x20A\x20per-transaction\x20sequence\x20number\x20used\
    \x20to\x20identify\x20this\x20request.\n\x20This\x20field\x20makes\x20ea\
    ch\x20request\x20idempotent\x20such\x20that\x20if\x20the\x20request\x20i\
    s\n\x20received\x20multiple\x20times,\x20at\x20most\x20one\x20will\x20su\
    cceed.\n\n\x20The\x20sequence\x20number\x20must\x20be\x20monotonically\
    \x20increasing\x20within\x20the\n\x20transaction.\x20If\x20a\x20request\
    \x20arrives\x20for\x20the\x20first\x20time\x20with\x20an\x20out-of-order\
    \n\x20sequence\x20number,\x20the\x20transaction\x20may\x20be\x20aborted.\
    \x20Replays\x20of\x20previously\n\x20handled\x20requests\x20will\x20yiel\
    d\x20the\x20same\x20response\x20as\x20the\x20first\x20execution.\n\n\r\n\
    \x05\x04\t\x02\x03\x05\x12\x04\xd5\x04\x02\x07\n\r\n\x05\x04\t\x02\x03\
    \x01\x12\x04\xd5\x04\x08\r\n\r\n\x05\x04\t\x02\x03\x03\x12\x04\xd5\x04\
    \x10\x11\n\r\n\x05\x04\t\x02\x03\x08\x12\x04\xd5\x04\x12:\n\x10\n\x08\
    \x04\t\x02\x03\x08\x9c\x08\0\x12\x04\xd5\x04\x139\n\xcb\n\n\x02\x04\n\
    \x12\x06\xf7\x04\0\x86\x05\x01\x1a\xbc\n\x20The\x20response\x20for\n\x20\
    [ExecuteBatchDml][google.spanner.v1.Spanner.ExecuteBatchDml].\x20Contain\
    s\x20a\x20list\n\x20of\x20[ResultSet][google.spanner.v1.ResultSet]\x20me\
    ssages,\x20one\x20for\x20each\x20DML\n\x20statement\x20that\x20has\x20su\
    ccessfully\x20executed,\x20in\x20the\x20same\x20order\x20as\x20the\x20st\
    atements\n\x20in\x20the\x20request.\x20If\x20a\x20statement\x20fails,\
    \x20the\x20status\x20in\x20the\x20response\x20body\n\x20identifies\x20th\
    e\x20cause\x20of\x20the\x20failure.\n\n\x20To\x20check\x20for\x20DML\x20\
    statements\x20that\x20failed,\x20use\x20the\x20following\x20approach:\n\
    \n\x201.\x20Check\x20the\x20status\x20in\x20the\x20response\x20message.\
    \x20The\n\x20[google.rpc.Code][google.rpc.Code]\x20enum\n\x20\x20\x20\
    \x20value\x20`OK`\x20indicates\x20that\x20all\x20statements\x20were\x20e\
    xecuted\x20successfully.\n\x202.\x20If\x20the\x20status\x20was\x20not\
    \x20`OK`,\x20check\x20the\x20number\x20of\x20result\x20sets\x20in\x20the\
    \n\x20\x20\x20\x20response.\x20If\x20the\x20response\x20contains\x20`N`\
    \n\x20\x20\x20\x20[ResultSet][google.spanner.v1.ResultSet]\x20messages,\
    \x20then\x20statement\x20`N+1`\x20in\n\x20\x20\x20\x20the\x20request\x20\
    failed.\n\n\x20Example\x201:\n\n\x20*\x20Request:\x205\x20DML\x20stateme\
    nts,\x20all\x20executed\x20successfully.\n\x20*\x20Response:\x205\x20[Re\
    sultSet][google.spanner.v1.ResultSet]\x20messages,\x20with\x20the\n\x20s\
    tatus\x20`OK`.\n\n\x20Example\x202:\n\n\x20*\x20Request:\x205\x20DML\x20\
    statements.\x20The\x20third\x20statement\x20has\x20a\x20syntax\x20error.\
    \n\x20*\x20Response:\x202\x20[ResultSet][google.spanner.v1.ResultSet]\
    \x20messages,\x20and\x20a\x20syntax\n\x20error\x20(`INVALID_ARGUMENT`)\n\
    \x20\x20\x20status.\x20The\x20number\x20of\x20[ResultSet][google.spanner\
    .v1.ResultSet]\x20messages\n\x20\x20\x20indicates\x20that\x20the\x20thir\
    d\x20statement\x20failed,\x20and\x20the\x20fourth\x20and\x20fifth\n\x20\
    \x20\x20statements\x20were\x20not\x20executed.\n\n\x0b\n\x03\x04\n\x01\
    \x12\x04\xf7\x04\x08\x1f\n\xaa\x04\n\x04\x04\n\x02\0\x12\x04\x81\x05\x02\
    %\x1a\x9b\x04\x20One\x20[ResultSet][google.spanner.v1.ResultSet]\x20for\
    \x20each\x20statement\x20in\x20the\n\x20request\x20that\x20ran\x20succes\
    sfully,\x20in\x20the\x20same\x20order\x20as\x20the\x20statements\x20in\
    \x20the\n\x20request.\x20Each\x20[ResultSet][google.spanner.v1.ResultSet\
    ]\x20does\x20not\x20contain\x20any\n\x20rows.\x20The\x20[ResultSetStats]\
    [google.spanner.v1.ResultSetStats]\x20in\x20each\n\x20[ResultSet][google\
    .spanner.v1.ResultSet]\x20contain\x20the\x20number\x20of\x20rows\n\x20mo\
    dified\x20by\x20the\x20statement.\n\n\x20Only\x20the\x20first\x20[Result\
    Set][google.spanner.v1.ResultSet]\x20in\x20the\x20response\n\x20contains\
    \x20valid\x20[ResultSetMetadata][google.spanner.v1.ResultSetMetadata].\n\
    \n\r\n\x05\x04\n\x02\0\x04\x12\x04\x81\x05\x02\n\n\r\n\x05\x04\n\x02\0\
    \x06\x12\x04\x81\x05\x0b\x14\n\r\n\x05\x04\n\x02\0\x01\x12\x04\x81\x05\
    \x15\x20\n\r\n\x05\x04\n\x02\0\x03\x12\x04\x81\x05#$\n\x91\x01\n\x04\x04\
    \n\x02\x01\x12\x04\x85\x05\x02\x1f\x1a\x82\x01\x20If\x20all\x20DML\x20st\
    atements\x20are\x20executed\x20successfully,\x20the\x20status\x20is\x20`\
    OK`.\n\x20Otherwise,\x20the\x20error\x20status\x20of\x20the\x20first\x20\
    failed\x20statement.\n\n\r\n\x05\x04\n\x02\x01\x06\x12\x04\x85\x05\x02\
    \x13\n\r\n\x05\x04\n\x02\x01\x01\x12\x04\x85\x05\x14\x1a\n\r\n\x05\x04\n\
    \x02\x01\x03\x12\x04\x85\x05\x1d\x1e\nN\n\x02\x04\x0b\x12\x06\x8a\x05\0\
    \x9c\x05\x01\x1a@\x20Options\x20for\x20a\x20PartitionQueryRequest\x20and\
    \n\x20PartitionReadRequest.\n\n\x0b\n\x03\x04\x0b\x01\x12\x04\x8a\x05\
    \x08\x18\n\xba\x02\n\x04\x04\x0b\x02\0\x12\x04\x91\x05\x02!\x1a\xab\x02\
    \x20**Note:**\x20This\x20hint\x20is\x20currently\x20ignored\x20by\x20Par\
    titionQuery\x20and\n\x20PartitionRead\x20requests.\n\n\x20The\x20desired\
    \x20data\x20size\x20for\x20each\x20partition\x20generated.\x20\x20The\
    \x20default\x20for\x20this\n\x20option\x20is\x20currently\x201\x20GiB.\
    \x20\x20This\x20is\x20only\x20a\x20hint.\x20The\x20actual\x20size\x20of\
    \x20each\n\x20partition\x20may\x20be\x20smaller\x20or\x20larger\x20than\
    \x20this\x20size\x20request.\n\n\r\n\x05\x04\x0b\x02\0\x05\x12\x04\x91\
    \x05\x02\x07\n\r\n\x05\x04\x0b\x02\0\x01\x12\x04\x91\x05\x08\x1c\n\r\n\
    \x05\x04\x0b\x02\0\x03\x12\x04\x91\x05\x1f\x20\n\xb8\x03\n\x04\x04\x0b\
    \x02\x01\x12\x04\x9b\x05\x02\x1b\x1a\xa9\x03\x20**Note:**\x20This\x20hin\
    t\x20is\x20currently\x20ignored\x20by\x20PartitionQuery\x20and\n\x20Part\
    itionRead\x20requests.\n\n\x20The\x20desired\x20maximum\x20number\x20of\
    \x20partitions\x20to\x20return.\x20\x20For\x20example,\x20this\x20may\n\
    \x20be\x20set\x20to\x20the\x20number\x20of\x20workers\x20available.\x20\
    \x20The\x20default\x20for\x20this\x20option\n\x20is\x20currently\x2010,0\
    00.\x20The\x20maximum\x20value\x20is\x20currently\x20200,000.\x20\x20Thi\
    s\x20is\x20only\n\x20a\x20hint.\x20\x20The\x20actual\x20number\x20of\x20\
    partitions\x20returned\x20may\x20be\x20smaller\x20or\x20larger\n\x20than\
    \x20this\x20maximum\x20count\x20request.\n\n\r\n\x05\x04\x0b\x02\x01\x05\
    \x12\x04\x9b\x05\x02\x07\n\r\n\x05\x04\x0b\x02\x01\x01\x12\x04\x9b\x05\
    \x08\x16\n\r\n\x05\x04\x0b\x02\x01\x03\x12\x04\x9b\x05\x19\x1a\nZ\n\x02\
    \x04\x0c\x12\x06\x9f\x05\0\xd2\x05\x01\x1aL\x20The\x20request\x20for\x20\
    [PartitionQuery][google.spanner.v1.Spanner.PartitionQuery]\n\n\x0b\n\x03\
    \x04\x0c\x01\x12\x04\x9f\x05\x08\x1d\nF\n\x04\x04\x0c\x02\0\x12\x06\xa1\
    \x05\x02\xa4\x05\x04\x1a6\x20Required.\x20The\x20session\x20used\x20to\
    \x20create\x20the\x20partitions.\n\n\r\n\x05\x04\x0c\x02\0\x05\x12\x04\
    \xa1\x05\x02\x08\n\r\n\x05\x04\x0c\x02\0\x01\x12\x04\xa1\x05\t\x10\n\r\n\
    \x05\x04\x0c\x02\0\x03\x12\x04\xa1\x05\x13\x14\n\x0f\n\x05\x04\x0c\x02\0\
    \x08\x12\x06\xa1\x05\x15\xa4\x05\x03\n\x10\n\x08\x04\x0c\x02\0\x08\x9c\
    \x08\0\x12\x04\xa2\x05\x04*\n\x0f\n\x07\x04\x0c\x02\0\x08\x9f\x08\x12\
    \x04\xa3\x05\x04P\no\n\x04\x04\x0c\x02\x01\x12\x04\xa8\x05\x02&\x1aa\x20\
    Read\x20only\x20snapshot\x20transactions\x20are\x20supported,\x20read/wr\
    ite\x20and\x20single\x20use\n\x20transactions\x20are\x20not.\n\n\r\n\x05\
    \x04\x0c\x02\x01\x06\x12\x04\xa8\x05\x02\x15\n\r\n\x05\x04\x0c\x02\x01\
    \x01\x12\x04\xa8\x05\x16!\n\r\n\x05\x04\x0c\x02\x01\x03\x12\x04\xa8\x05$\
    %\n\xf9\x04\n\x04\x04\x0c\x02\x02\x12\x04\xb5\x05\x02:\x1a\xea\x04\x20Re\
    quired.\x20The\x20query\x20request\x20to\x20generate\x20partitions\x20fo\
    r.\x20The\x20request\x20will\n\x20fail\x20if\x20the\x20query\x20is\x20no\
    t\x20root\x20partitionable.\x20The\x20query\x20plan\x20of\x20a\x20root\n\
    \x20partitionable\x20query\x20has\x20a\x20single\x20distributed\x20union\
    \x20operator.\x20A\x20distributed\n\x20union\x20operator\x20conceptually\
    \x20divides\x20one\x20or\x20more\x20tables\x20into\x20multiple\n\x20spli\
    ts,\x20remotely\x20evaluates\x20a\x20subquery\x20independently\x20on\x20\
    each\x20split,\x20and\n\x20then\x20unions\x20all\x20results.\n\n\x20This\
    \x20must\x20not\x20contain\x20DML\x20commands,\x20such\x20as\x20INSERT,\
    \x20UPDATE,\x20or\n\x20DELETE.\x20Use\n\x20[ExecuteStreamingSql][google.\
    spanner.v1.Spanner.ExecuteStreamingSql]\x20with\x20a\n\x20PartitionedDml\
    \x20transaction\x20for\x20large,\x20partition-friendly\x20DML\x20operati\
    ons.\n\n\r\n\x05\x04\x0c\x02\x02\x05\x12\x04\xb5\x05\x02\x08\n\r\n\x05\
    \x04\x0c\x02\x02\x01\x12\x04\xb5\x05\t\x0c\n\r\n\x05\x04\x0c\x02\x02\x03\
    \x12\x04\xb5\x05\x0f\x10\n\r\n\x05\x04\x0c\x02\x02\x08\x12\x04\xb5\x05\
    \x119\n\x10\n\x08\x04\x0c\x02\x02\x08\x9c\x08\0\x12\x04\xb5\x05\x128\n\
    \x88\x04\n\x04\x04\x0c\x02\x03\x12\x04\xc3\x05\x02$\x1a\xf9\x03\x20Param\
    eter\x20names\x20and\x20values\x20that\x20bind\x20to\x20placeholders\x20\
    in\x20the\x20SQL\x20string.\n\n\x20A\x20parameter\x20placeholder\x20cons\
    ists\x20of\x20the\x20`@`\x20character\x20followed\x20by\x20the\n\x20para\
    meter\x20name\x20(for\x20example,\x20`@firstName`).\x20Parameter\x20name\
    s\x20can\x20contain\n\x20letters,\x20numbers,\x20and\x20underscores.\n\n\
    \x20Parameters\x20can\x20appear\x20anywhere\x20that\x20a\x20literal\x20v\
    alue\x20is\x20expected.\x20\x20The\x20same\n\x20parameter\x20name\x20can\
    \x20be\x20used\x20more\x20than\x20once,\x20for\x20example:\n\n\x20`\"WHE\
    RE\x20id\x20>\x20@msg_id\x20AND\x20id\x20<\x20@msg_id\x20+\x20100\"`\n\n\
    \x20It\x20is\x20an\x20error\x20to\x20execute\x20a\x20SQL\x20statement\
    \x20with\x20unbound\x20parameters.\n\n\r\n\x05\x04\x0c\x02\x03\x06\x12\
    \x04\xc3\x05\x02\x18\n\r\n\x05\x04\x0c\x02\x03\x01\x12\x04\xc3\x05\x19\
    \x1f\n\r\n\x05\x04\x0c\x02\x03\x03\x12\x04\xc3\x05\"#\n\xdd\x03\n\x04\
    \x04\x0c\x02\x04\x12\x04\xce\x05\x02$\x1a\xce\x03\x20It\x20is\x20not\x20\
    always\x20possible\x20for\x20Cloud\x20Spanner\x20to\x20infer\x20the\x20r\
    ight\x20SQL\x20type\n\x20from\x20a\x20JSON\x20value.\x20\x20For\x20examp\
    le,\x20values\x20of\x20type\x20`BYTES`\x20and\x20values\n\x20of\x20type\
    \x20`STRING`\x20both\x20appear\x20in\n\x20[params][google.spanner.v1.Par\
    titionQueryRequest.params]\x20as\x20JSON\x20strings.\n\n\x20In\x20these\
    \x20cases,\x20`param_types`\x20can\x20be\x20used\x20to\x20specify\x20the\
    \x20exact\n\x20SQL\x20type\x20for\x20some\x20or\x20all\x20of\x20the\x20S\
    QL\x20query\x20parameters.\x20See\x20the\n\x20definition\x20of\x20[Type]\
    [google.spanner.v1.Type]\x20for\x20more\x20information\n\x20about\x20SQL\
    \x20types.\n\n\r\n\x05\x04\x0c\x02\x04\x06\x12\x04\xce\x05\x02\x13\n\r\n\
    \x05\x04\x0c\x02\x04\x01\x12\x04\xce\x05\x14\x1f\n\r\n\x05\x04\x0c\x02\
    \x04\x03\x12\x04\xce\x05\"#\nO\n\x04\x04\x0c\x02\x05\x12\x04\xd1\x05\x02\
    )\x1aA\x20Additional\x20options\x20that\x20affect\x20how\x20many\x20part\
    itions\x20are\x20created.\n\n\r\n\x05\x04\x0c\x02\x05\x06\x12\x04\xd1\
    \x05\x02\x12\n\r\n\x05\x04\x0c\x02\x05\x01\x12\x04\xd1\x05\x13$\n\r\n\
    \x05\x04\x0c\x02\x05\x03\x12\x04\xd1\x05'(\nX\n\x02\x04\r\x12\x06\xd5\
    \x05\0\xfd\x05\x01\x1aJ\x20The\x20request\x20for\x20[PartitionRead][goog\
    le.spanner.v1.Spanner.PartitionRead]\n\n\x0b\n\x03\x04\r\x01\x12\x04\xd5\
    \x05\x08\x1c\nF\n\x04\x04\r\x02\0\x12\x06\xd7\x05\x02\xda\x05\x04\x1a6\
    \x20Required.\x20The\x20session\x20used\x20to\x20create\x20the\x20partit\
    ions.\n\n\r\n\x05\x04\r\x02\0\x05\x12\x04\xd7\x05\x02\x08\n\r\n\x05\x04\
    \r\x02\0\x01\x12\x04\xd7\x05\t\x10\n\r\n\x05\x04\r\x02\0\x03\x12\x04\xd7\
    \x05\x13\x14\n\x0f\n\x05\x04\r\x02\0\x08\x12\x06\xd7\x05\x15\xda\x05\x03\
    \n\x10\n\x08\x04\r\x02\0\x08\x9c\x08\0\x12\x04\xd8\x05\x04*\n\x0f\n\x07\
    \x04\r\x02\0\x08\x9f\x08\x12\x04\xd9\x05\x04P\no\n\x04\x04\r\x02\x01\x12\
    \x04\xde\x05\x02&\x1aa\x20Read\x20only\x20snapshot\x20transactions\x20ar\
    e\x20supported,\x20read/write\x20and\x20single\x20use\n\x20transactions\
    \x20are\x20not.\n\n\r\n\x05\x04\r\x02\x01\x06\x12\x04\xde\x05\x02\x15\n\
    \r\n\x05\x04\r\x02\x01\x01\x12\x04\xde\x05\x16!\n\r\n\x05\x04\r\x02\x01\
    \x03\x12\x04\xde\x05$%\nK\n\x04\x04\r\x02\x02\x12\x04\xe1\x05\x02<\x1a=\
    \x20Required.\x20The\x20name\x20of\x20the\x20table\x20in\x20the\x20datab\
    ase\x20to\x20be\x20read.\n\n\r\n\x05\x04\r\x02\x02\x05\x12\x04\xe1\x05\
    \x02\x08\n\r\n\x05\x04\r\x02\x02\x01\x12\x04\xe1\x05\t\x0e\n\r\n\x05\x04\
    \r\x02\x02\x03\x12\x04\xe1\x05\x11\x12\n\r\n\x05\x04\r\x02\x02\x08\x12\
    \x04\xe1\x05\x13;\n\x10\n\x08\x04\r\x02\x02\x08\x9c\x08\0\x12\x04\xe1\
    \x05\x14:\n\xe2\x02\n\x04\x04\r\x02\x03\x12\x04\xe9\x05\x02\x13\x1a\xd3\
    \x02\x20If\x20non-empty,\x20the\x20name\x20of\x20an\x20index\x20on\n\x20\
    [table][google.spanner.v1.PartitionReadRequest.table].\x20This\x20index\
    \x20is\x20used\n\x20instead\x20of\x20the\x20table\x20primary\x20key\x20w\
    hen\x20interpreting\n\x20[key_set][google.spanner.v1.PartitionReadReques\
    t.key_set]\x20and\x20sorting\n\x20result\x20rows.\x20See\x20[key_set][go\
    ogle.spanner.v1.PartitionReadRequest.key_set]\n\x20for\x20further\x20inf\
    ormation.\n\n\r\n\x05\x04\r\x02\x03\x05\x12\x04\xe9\x05\x02\x08\n\r\n\
    \x05\x04\r\x02\x03\x01\x12\x04\xe9\x05\t\x0e\n\r\n\x05\x04\r\x02\x03\x03\
    \x12\x04\xe9\x05\x11\x12\n\x88\x01\n\x04\x04\r\x02\x04\x12\x04\xed\x05\
    \x02\x1e\x1az\x20The\x20columns\x20of\x20[table][google.spanner.v1.Parti\
    tionReadRequest.table]\x20to\x20be\n\x20returned\x20for\x20each\x20row\
    \x20matching\x20this\x20request.\n\n\r\n\x05\x04\r\x02\x04\x04\x12\x04\
    \xed\x05\x02\n\n\r\n\x05\x04\r\x02\x04\x05\x12\x04\xed\x05\x0b\x11\n\r\n\
    \x05\x04\r\x02\x04\x01\x12\x04\xed\x05\x12\x19\n\r\n\x05\x04\r\x02\x04\
    \x03\x12\x04\xed\x05\x1c\x1d\n\xe4\x04\n\x04\x04\r\x02\x05\x12\x04\xf9\
    \x05\x02>\x1a\xd5\x04\x20Required.\x20`key_set`\x20identifies\x20the\x20\
    rows\x20to\x20be\x20yielded.\x20`key_set`\x20names\x20the\n\x20primary\
    \x20keys\x20of\x20the\x20rows\x20in\n\x20[table][google.spanner.v1.Parti\
    tionReadRequest.table]\x20to\x20be\x20yielded,\x20unless\n\x20[index][go\
    ogle.spanner.v1.PartitionReadRequest.index]\x20is\x20present.\x20If\n\
    \x20[index][google.spanner.v1.PartitionReadRequest.index]\x20is\x20prese\
    nt,\x20then\n\x20[key_set][google.spanner.v1.PartitionReadRequest.key_se\
    t]\x20instead\x20names\n\x20index\x20keys\x20in\x20[index][google.spanne\
    r.v1.PartitionReadRequest.index].\n\n\x20It\x20is\x20not\x20an\x20error\
    \x20for\x20the\x20`key_set`\x20to\x20name\x20rows\x20that\x20do\x20not\n\
    \x20exist\x20in\x20the\x20database.\x20Read\x20yields\x20nothing\x20for\
    \x20nonexistent\x20rows.\n\n\r\n\x05\x04\r\x02\x05\x06\x12\x04\xf9\x05\
    \x02\x08\n\r\n\x05\x04\r\x02\x05\x01\x12\x04\xf9\x05\t\x10\n\r\n\x05\x04\
    \r\x02\x05\x03\x12\x04\xf9\x05\x13\x14\n\r\n\x05\x04\r\x02\x05\x08\x12\
    \x04\xf9\x05\x15=\n\x10\n\x08\x04\r\x02\x05\x08\x9c\x08\0\x12\x04\xf9\
    \x05\x16<\nO\n\x04\x04\r\x02\x06\x12\x04\xfc\x05\x02)\x1aA\x20Additional\
    \x20options\x20that\x20affect\x20how\x20many\x20partitions\x20are\x20cre\
    ated.\n\n\r\n\x05\x04\r\x02\x06\x06\x12\x04\xfc\x05\x02\x12\n\r\n\x05\
    \x04\r\x02\x06\x01\x12\x04\xfc\x05\x13$\n\r\n\x05\x04\r\x02\x06\x03\x12\
    \x04\xfc\x05'(\nY\n\x02\x04\x0e\x12\x06\x81\x06\0\x86\x06\x01\x1aK\x20In\
    formation\x20returned\x20for\x20each\x20partition\x20returned\x20in\x20a\
    \n\x20PartitionResponse.\n\n\x0b\n\x03\x04\x0e\x01\x12\x04\x81\x06\x08\
    \x11\n\xb4\x01\n\x04\x04\x0e\x02\0\x12\x04\x85\x06\x02\x1c\x1a\xa5\x01\
    \x20This\x20token\x20can\x20be\x20passed\x20to\x20Read,\x20StreamingRead\
    ,\x20ExecuteSql,\x20or\n\x20ExecuteStreamingSql\x20requests\x20to\x20res\
    trict\x20the\x20results\x20to\x20those\x20identified\x20by\n\x20this\x20\
    partition\x20token.\n\n\r\n\x05\x04\x0e\x02\0\x05\x12\x04\x85\x06\x02\
    \x07\n\r\n\x05\x04\x0e\x02\0\x01\x12\x04\x85\x06\x08\x17\n\r\n\x05\x04\
    \x0e\x02\0\x03\x12\x04\x85\x06\x1a\x1b\n\x99\x01\n\x02\x04\x0f\x12\x06\
    \x8a\x06\0\x90\x06\x01\x1a\x8a\x01\x20The\x20response\x20for\x20[Partiti\
    onQuery][google.spanner.v1.Spanner.PartitionQuery]\n\x20or\x20[Partition\
    Read][google.spanner.v1.Spanner.PartitionRead]\n\n\x0b\n\x03\x04\x0f\x01\
    \x12\x04\x8a\x06\x08\x19\n3\n\x04\x04\x0f\x02\0\x12\x04\x8c\x06\x02$\x1a\
    %\x20Partitions\x20created\x20by\x20this\x20request.\n\n\r\n\x05\x04\x0f\
    \x02\0\x04\x12\x04\x8c\x06\x02\n\n\r\n\x05\x04\x0f\x02\0\x06\x12\x04\x8c\
    \x06\x0b\x14\n\r\n\x05\x04\x0f\x02\0\x01\x12\x04\x8c\x06\x15\x1f\n\r\n\
    \x05\x04\x0f\x02\0\x03\x12\x04\x8c\x06\"#\n4\n\x04\x04\x0f\x02\x01\x12\
    \x04\x8f\x06\x02\x1e\x1a&\x20Transaction\x20created\x20by\x20this\x20req\
    uest.\n\n\r\n\x05\x04\x0f\x02\x01\x06\x12\x04\x8f\x06\x02\r\n\r\n\x05\
    \x04\x0f\x02\x01\x01\x12\x04\x8f\x06\x0e\x19\n\r\n\x05\x04\x0f\x02\x01\
    \x03\x12\x04\x8f\x06\x1c\x1d\n\x85\x01\n\x02\x04\x10\x12\x06\x94\x06\0\
    \xd2\x06\x01\x1aw\x20The\x20request\x20for\x20[Read][google.spanner.v1.S\
    panner.Read]\x20and\n\x20[StreamingRead][google.spanner.v1.Spanner.Strea\
    mingRead].\n\n\x0b\n\x03\x04\x10\x01\x12\x04\x94\x06\x08\x13\nN\n\x04\
    \x04\x10\x02\0\x12\x06\x96\x06\x02\x99\x06\x04\x1a>\x20Required.\x20The\
    \x20session\x20in\x20which\x20the\x20read\x20should\x20be\x20performed.\
    \n\n\r\n\x05\x04\x10\x02\0\x05\x12\x04\x96\x06\x02\x08\n\r\n\x05\x04\x10\
    \x02\0\x01\x12\x04\x96\x06\t\x10\n\r\n\x05\x04\x10\x02\0\x03\x12\x04\x96\
    \x06\x13\x14\n\x0f\n\x05\x04\x10\x02\0\x08\x12\x06\x96\x06\x15\x99\x06\
    \x03\n\x10\n\x08\x04\x10\x02\0\x08\x9c\x08\0\x12\x04\x97\x06\x04*\n\x0f\
    \n\x07\x04\x10\x02\0\x08\x9f\x08\x12\x04\x98\x06\x04P\n\x87\x01\n\x04\
    \x04\x10\x02\x01\x12\x04\x9d\x06\x02&\x1ay\x20The\x20transaction\x20to\
    \x20use.\x20If\x20none\x20is\x20provided,\x20the\x20default\x20is\x20a\n\
    \x20temporary\x20read-only\x20transaction\x20with\x20strong\x20concurren\
    cy.\n\n\r\n\x05\x04\x10\x02\x01\x06\x12\x04\x9d\x06\x02\x15\n\r\n\x05\
    \x04\x10\x02\x01\x01\x12\x04\x9d\x06\x16!\n\r\n\x05\x04\x10\x02\x01\x03\
    \x12\x04\x9d\x06$%\nK\n\x04\x04\x10\x02\x02\x12\x04\xa0\x06\x02<\x1a=\
    \x20Required.\x20The\x20name\x20of\x20the\x20table\x20in\x20the\x20datab\
    ase\x20to\x20be\x20read.\n\n\r\n\x05\x04\x10\x02\x02\x05\x12\x04\xa0\x06\
    \x02\x08\n\r\n\x05\x04\x10\x02\x02\x01\x12\x04\xa0\x06\t\x0e\n\r\n\x05\
    \x04\x10\x02\x02\x03\x12\x04\xa0\x06\x11\x12\n\r\n\x05\x04\x10\x02\x02\
    \x08\x12\x04\xa0\x06\x13;\n\x10\n\x08\x04\x10\x02\x02\x08\x9c\x08\0\x12\
    \x04\xa0\x06\x14:\n\xc7\x02\n\x04\x04\x10\x02\x03\x12\x04\xa8\x06\x02\
    \x13\x1a\xb8\x02\x20If\x20non-empty,\x20the\x20name\x20of\x20an\x20index\
    \x20on\n\x20[table][google.spanner.v1.ReadRequest.table].\x20This\x20ind\
    ex\x20is\x20used\x20instead\x20of\n\x20the\x20table\x20primary\x20key\
    \x20when\x20interpreting\n\x20[key_set][google.spanner.v1.ReadRequest.ke\
    y_set]\x20and\x20sorting\x20result\x20rows.\n\x20See\x20[key_set][google\
    .spanner.v1.ReadRequest.key_set]\x20for\x20further\n\x20information.\n\n\
    \r\n\x05\x04\x10\x02\x03\x05\x12\x04\xa8\x06\x02\x08\n\r\n\x05\x04\x10\
    \x02\x03\x01\x12\x04\xa8\x06\t\x0e\n\r\n\x05\x04\x10\x02\x03\x03\x12\x04\
    \xa8\x06\x11\x12\n\x89\x01\n\x04\x04\x10\x02\x04\x12\x04\xac\x06\x02G\
    \x1a{\x20Required.\x20The\x20columns\x20of\x20[table][google.spanner.v1.\
    ReadRequest.table]\x20to\x20be\n\x20returned\x20for\x20each\x20row\x20ma\
    tching\x20this\x20request.\n\n\r\n\x05\x04\x10\x02\x04\x04\x12\x04\xac\
    \x06\x02\n\n\r\n\x05\x04\x10\x02\x04\x05\x12\x04\xac\x06\x0b\x11\n\r\n\
    \x05\x04\x10\x02\x04\x01\x12\x04\xac\x06\x12\x19\n\r\n\x05\x04\x10\x02\
    \x04\x03\x12\x04\xac\x06\x1c\x1d\n\r\n\x05\x04\x10\x02\x04\x08\x12\x04\
    \xac\x06\x1eF\n\x10\n\x08\x04\x10\x02\x04\x08\x9c\x08\0\x12\x04\xac\x06\
    \x1fE\n\xda\x07\n\x04\x04\x10\x02\x05\x12\x04\xbe\x06\x02>\x1a\xcb\x07\
    \x20Required.\x20`key_set`\x20identifies\x20the\x20rows\x20to\x20be\x20y\
    ielded.\x20`key_set`\x20names\x20the\n\x20primary\x20keys\x20of\x20the\
    \x20rows\x20in\x20[table][google.spanner.v1.ReadRequest.table]\x20to\n\
    \x20be\x20yielded,\x20unless\x20[index][google.spanner.v1.ReadRequest.in\
    dex]\x20is\x20present.\n\x20If\x20[index][google.spanner.v1.ReadRequest.\
    index]\x20is\x20present,\x20then\n\x20[key_set][google.spanner.v1.ReadRe\
    quest.key_set]\x20instead\x20names\x20index\x20keys\n\x20in\x20[index][g\
    oogle.spanner.v1.ReadRequest.index].\n\n\x20If\x20the\x20[partition_toke\
    n][google.spanner.v1.ReadRequest.partition_token]\n\x20field\x20is\x20em\
    pty,\x20rows\x20are\x20yielded\x20in\x20table\x20primary\x20key\x20order\
    \x20(if\n\x20[index][google.spanner.v1.ReadRequest.index]\x20is\x20empty\
    )\x20or\x20index\x20key\x20order\n\x20(if\x20[index][google.spanner.v1.R\
    eadRequest.index]\x20is\x20non-empty).\x20\x20If\x20the\n\x20[partition_\
    token][google.spanner.v1.ReadRequest.partition_token]\x20field\x20is\n\
    \x20not\x20empty,\x20rows\x20will\x20be\x20yielded\x20in\x20an\x20unspec\
    ified\x20order.\n\n\x20It\x20is\x20not\x20an\x20error\x20for\x20the\x20`\
    key_set`\x20to\x20name\x20rows\x20that\x20do\x20not\n\x20exist\x20in\x20\
    the\x20database.\x20Read\x20yields\x20nothing\x20for\x20nonexistent\x20r\
    ows.\n\n\r\n\x05\x04\x10\x02\x05\x06\x12\x04\xbe\x06\x02\x08\n\r\n\x05\
    \x04\x10\x02\x05\x01\x12\x04\xbe\x06\t\x10\n\r\n\x05\x04\x10\x02\x05\x03\
    \x12\x04\xbe\x06\x13\x14\n\r\n\x05\x04\x10\x02\x05\x08\x12\x04\xbe\x06\
    \x15=\n\x10\n\x08\x04\x10\x02\x05\x08\x9c\x08\0\x12\x04\xbe\x06\x16<\n\
    \xb7\x01\n\x04\x04\x10\x02\x06\x12\x04\xc3\x06\x02\x12\x1a\xa8\x01\x20If\
    \x20greater\x20than\x20zero,\x20only\x20the\x20first\x20`limit`\x20rows\
    \x20are\x20yielded.\x20If\x20`limit`\n\x20is\x20zero,\x20the\x20default\
    \x20is\x20no\x20limit.\x20A\x20limit\x20cannot\x20be\x20specified\x20if\
    \n\x20`partition_token`\x20is\x20set.\n\n\r\n\x05\x04\x10\x02\x06\x05\
    \x12\x04\xc3\x06\x02\x07\n\r\n\x05\x04\x10\x02\x06\x01\x12\x04\xc3\x06\
    \x08\r\n\r\n\x05\x04\x10\x02\x06\x03\x12\x04\xc3\x06\x10\x11\n\xf9\x02\n\
    \x04\x04\x10\x02\x07\x12\x04\xcb\x06\x02\x19\x1a\xea\x02\x20If\x20this\
    \x20request\x20is\x20resuming\x20a\x20previously\x20interrupted\x20read,\
    \n\x20`resume_token`\x20should\x20be\x20copied\x20from\x20the\x20last\n\
    \x20[PartialResultSet][google.spanner.v1.PartialResultSet]\x20yielded\
    \x20before\x20the\n\x20interruption.\x20Doing\x20this\x20enables\x20the\
    \x20new\x20read\x20to\x20resume\x20where\x20the\x20last\x20read\n\x20lef\
    t\x20off.\x20The\x20rest\x20of\x20the\x20request\x20parameters\x20must\
    \x20exactly\x20match\x20the\x20request\n\x20that\x20yielded\x20this\x20t\
    oken.\n\n\r\n\x05\x04\x10\x02\x07\x05\x12\x04\xcb\x06\x02\x07\n\r\n\x05\
    \x04\x10\x02\x07\x01\x12\x04\xcb\x06\x08\x14\n\r\n\x05\x04\x10\x02\x07\
    \x03\x12\x04\xcb\x06\x17\x18\n\x99\x02\n\x04\x04\x10\x02\x08\x12\x04\xd1\
    \x06\x02\x1d\x1a\x8a\x02\x20If\x20present,\x20results\x20will\x20be\x20r\
    estricted\x20to\x20the\x20specified\x20partition\n\x20previously\x20crea\
    ted\x20using\x20PartitionRead().\x20\x20\x20\x20There\x20must\x20be\x20a\
    n\x20exact\n\x20match\x20for\x20the\x20values\x20of\x20fields\x20common\
    \x20to\x20this\x20message\x20and\x20the\n\x20PartitionReadRequest\x20mes\
    sage\x20used\x20to\x20create\x20this\x20partition_token.\n\n\r\n\x05\x04\
    \x10\x02\x08\x05\x12\x04\xd1\x06\x02\x07\n\r\n\x05\x04\x10\x02\x08\x01\
    \x12\x04\xd1\x06\x08\x17\n\r\n\x05\x04\x10\x02\x08\x03\x12\x04\xd1\x06\
    \x1a\x1c\n`\n\x02\x04\x11\x12\x06\xd6\x06\0\xdf\x06\x01\x1aR\x20The\x20r\
    equest\x20for\n\x20[BeginTransaction][google.spanner.v1.Spanner.BeginTra\
    nsaction].\n\n\x0b\n\x03\x04\x11\x01\x12\x04\xd6\x06\x08\x1f\nF\n\x04\
    \x04\x11\x02\0\x12\x06\xd8\x06\x02\xdb\x06\x04\x1a6\x20Required.\x20The\
    \x20session\x20in\x20which\x20the\x20transaction\x20runs.\n\n\r\n\x05\
    \x04\x11\x02\0\x05\x12\x04\xd8\x06\x02\x08\n\r\n\x05\x04\x11\x02\0\x01\
    \x12\x04\xd8\x06\t\x10\n\r\n\x05\x04\x11\x02\0\x03\x12\x04\xd8\x06\x13\
    \x14\n\x0f\n\x05\x04\x11\x02\0\x08\x12\x06\xd8\x06\x15\xdb\x06\x03\n\x10\
    \n\x08\x04\x11\x02\0\x08\x9c\x08\0\x12\x04\xd9\x06\x04*\n\x0f\n\x07\x04\
    \x11\x02\0\x08\x9f\x08\x12\x04\xda\x06\x04P\n:\n\x04\x04\x11\x02\x01\x12\
    \x04\xde\x06\x02J\x1a,\x20Required.\x20Options\x20for\x20the\x20new\x20t\
    ransaction.\n\n\r\n\x05\x04\x11\x02\x01\x06\x12\x04\xde\x06\x02\x14\n\r\
    \n\x05\x04\x11\x02\x01\x01\x12\x04\xde\x06\x15\x1c\n\r\n\x05\x04\x11\x02\
    \x01\x03\x12\x04\xde\x06\x1f\x20\n\r\n\x05\x04\x11\x02\x01\x08\x12\x04\
    \xde\x06!I\n\x10\n\x08\x04\x11\x02\x01\x08\x9c\x08\0\x12\x04\xde\x06\"H\
    \nK\n\x02\x04\x12\x12\x06\xe2\x06\0\xfe\x06\x01\x1a=\x20The\x20request\
    \x20for\x20[Commit][google.spanner.v1.Spanner.Commit].\n\n\x0b\n\x03\x04\
    \x12\x01\x12\x04\xe2\x06\x08\x15\n\\\n\x04\x04\x12\x02\0\x12\x06\xe4\x06\
    \x02\xe7\x06\x04\x1aL\x20Required.\x20The\x20session\x20in\x20which\x20t\
    he\x20transaction\x20to\x20be\x20committed\x20is\x20running.\n\n\r\n\x05\
    \x04\x12\x02\0\x05\x12\x04\xe4\x06\x02\x08\n\r\n\x05\x04\x12\x02\0\x01\
    \x12\x04\xe4\x06\t\x10\n\r\n\x05\x04\x12\x02\0\x03\x12\x04\xe4\x06\x13\
    \x14\n\x0f\n\x05\x04\x12\x02\0\x08\x12\x06\xe4\x06\x15\xe7\x06\x03\n\x10\
    \n\x08\x04\x12\x02\0\x08\x9c\x08\0\x12\x04\xe5\x06\x04*\n\x0f\n\x07\x04\
    \x12\x02\0\x08\x9f\x08\x12\x04\xe6\x06\x04P\n?\n\x04\x04\x12\x08\0\x12\
    \x06\xea\x06\x02\xf8\x06\x03\x1a/\x20Required.\x20The\x20transaction\x20\
    in\x20which\x20to\x20commit.\n\n\r\n\x05\x04\x12\x08\0\x01\x12\x04\xea\
    \x06\x08\x13\n8\n\x04\x04\x12\x02\x01\x12\x04\xec\x06\x04\x1d\x1a*\x20Co\
    mmit\x20a\x20previously-started\x20transaction.\n\n\r\n\x05\x04\x12\x02\
    \x01\x05\x12\x04\xec\x06\x04\t\n\r\n\x05\x04\x12\x02\x01\x01\x12\x04\xec\
    \x06\n\x18\n\r\n\x05\x04\x12\x02\x01\x03\x12\x04\xec\x06\x1b\x1c\n\xa4\
    \x04\n\x04\x04\x12\x02\x02\x12\x04\xf7\x06\x042\x1a\x95\x04\x20Execute\
    \x20mutations\x20in\x20a\x20temporary\x20transaction.\x20Note\x20that\
    \x20unlike\n\x20commit\x20of\x20a\x20previously-started\x20transaction,\
    \x20commit\x20with\x20a\n\x20temporary\x20transaction\x20is\x20non-idemp\
    otent.\x20That\x20is,\x20if\x20the\n\x20`CommitRequest`\x20is\x20sent\
    \x20to\x20Cloud\x20Spanner\x20more\x20than\x20once\x20(for\n\x20instance\
    ,\x20due\x20to\x20retries\x20in\x20the\x20application,\x20or\x20in\x20th\
    e\n\x20transport\x20library),\x20it\x20is\x20possible\x20that\x20the\x20\
    mutations\x20are\n\x20executed\x20more\x20than\x20once.\x20If\x20this\
    \x20is\x20undesirable,\x20use\n\x20[BeginTransaction][google.spanner.v1.\
    Spanner.BeginTransaction]\x20and\n\x20[Commit][google.spanner.v1.Spanner\
    .Commit]\x20instead.\n\n\r\n\x05\x04\x12\x02\x02\x06\x12\x04\xf7\x06\x04\
    \x16\n\r\n\x05\x04\x12\x02\x02\x01\x12\x04\xf7\x06\x17-\n\r\n\x05\x04\
    \x12\x02\x02\x03\x12\x04\xf7\x0601\n\x9b\x01\n\x04\x04\x12\x02\x03\x12\
    \x04\xfd\x06\x02\"\x1a\x8c\x01\x20The\x20mutations\x20to\x20be\x20execut\
    ed\x20when\x20this\x20transaction\x20commits.\x20All\n\x20mutations\x20a\
    re\x20applied\x20atomically,\x20in\x20the\x20order\x20they\x20appear\x20\
    in\n\x20this\x20list.\n\n\r\n\x05\x04\x12\x02\x03\x04\x12\x04\xfd\x06\
    \x02\n\n\r\n\x05\x04\x12\x02\x03\x06\x12\x04\xfd\x06\x0b\x13\n\r\n\x05\
    \x04\x12\x02\x03\x01\x12\x04\xfd\x06\x14\x1d\n\r\n\x05\x04\x12\x02\x03\
    \x03\x12\x04\xfd\x06\x20!\nL\n\x02\x04\x13\x12\x06\x81\x07\0\x84\x07\x01\
    \x1a>\x20The\x20response\x20for\x20[Commit][google.spanner.v1.Spanner.Co\
    mmit].\n\n\x0b\n\x03\x04\x13\x01\x12\x04\x81\x07\x08\x16\nO\n\x04\x04\
    \x13\x02\0\x12\x04\x83\x07\x021\x1aA\x20The\x20Cloud\x20Spanner\x20times\
    tamp\x20at\x20which\x20the\x20transaction\x20committed.\n\n\r\n\x05\x04\
    \x13\x02\0\x06\x12\x04\x83\x07\x02\x1b\n\r\n\x05\x04\x13\x02\0\x01\x12\
    \x04\x83\x07\x1c,\n\r\n\x05\x04\x13\x02\0\x03\x12\x04\x83\x07/0\nO\n\x02\
    \x04\x14\x12\x06\x87\x07\0\x90\x07\x01\x1aA\x20The\x20request\x20for\x20\
    [Rollback][google.spanner.v1.Spanner.Rollback].\n\n\x0b\n\x03\x04\x14\
    \x01\x12\x04\x87\x07\x08\x17\nY\n\x04\x04\x14\x02\0\x12\x06\x89\x07\x02\
    \x8c\x07\x04\x1aI\x20Required.\x20The\x20session\x20in\x20which\x20the\
    \x20transaction\x20to\x20roll\x20back\x20is\x20running.\n\n\r\n\x05\x04\
    \x14\x02\0\x05\x12\x04\x89\x07\x02\x08\n\r\n\x05\x04\x14\x02\0\x01\x12\
    \x04\x89\x07\t\x10\n\r\n\x05\x04\x14\x02\0\x03\x12\x04\x89\x07\x13\x14\n\
    \x0f\n\x05\x04\x14\x02\0\x08\x12\x06\x89\x07\x15\x8c\x07\x03\n\x10\n\x08\
    \x04\x14\x02\0\x08\x9c\x08\0\x12\x04\x8a\x07\x04*\n\x0f\n\x07\x04\x14\
    \x02\0\x08\x9f\x08\x12\x04\x8b\x07\x04P\n7\n\x04\x04\x14\x02\x01\x12\x04\
    \x8f\x07\x02D\x1a)\x20Required.\x20The\x20transaction\x20to\x20roll\x20b\
    ack.\n\n\r\n\x05\x04\x14\x02\x01\x05\x12\x04\x8f\x07\x02\x07\n\r\n\x05\
    \x04\x14\x02\x01\x01\x12\x04\x8f\x07\x08\x16\n\r\n\x05\x04\x14\x02\x01\
    \x03\x12\x04\x8f\x07\x19\x1a\n\r\n\x05\x04\x14\x02\x01\x08\x12\x04\x8f\
    \x07\x1bC\n\x10\n\x08\x04\x14\x02\x01\x08\x9c\x08\0\x12\x04\x8f\x07\x1cB\
    b\x06proto3\
";

static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;

fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
    ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}

pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
    file_descriptor_proto_lazy.get(|| {
        parse_descriptor_proto()
    })
}