google_cloud_rust_raw/spanner/v1/

result_set.rs

// 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/result_set.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 ResultSet {
    // message fields
    pub metadata: ::protobuf::SingularPtrField<ResultSetMetadata>,
    pub rows: ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue>,
    pub stats: ::protobuf::SingularPtrField<ResultSetStats>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .google.spanner.v1.ResultSetMetadata metadata = 1;


    pub fn get_metadata(&self) -> &ResultSetMetadata {
        self.metadata.as_ref().unwrap_or_else(|| <ResultSetMetadata as ::protobuf::Message>::default_instance())
    }
    pub fn clear_metadata(&mut self) {
        self.metadata.clear();
    }

    pub fn has_metadata(&self) -> bool {
        self.metadata.is_some()
    }

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

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

    // Take field
    pub fn take_metadata(&mut self) -> ResultSetMetadata {
        self.metadata.take().unwrap_or_else(|| ResultSetMetadata::new())
    }

    // repeated .google.protobuf.ListValue rows = 2;


    pub fn get_rows(&self) -> &[::protobuf::well_known_types::ListValue] {
        &self.rows
    }
    pub fn clear_rows(&mut self) {
        self.rows.clear();
    }

    // Param is passed by value, moved
    pub fn set_rows(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue>) {
        self.rows = v;
    }

    // Mutable pointer to the field.
    pub fn mut_rows(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue> {
        &mut self.rows
    }

    // Take field
    pub fn take_rows(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::ListValue> {
        ::std::mem::replace(&mut self.rows, ::protobuf::RepeatedField::new())
    }

    // .google.spanner.v1.ResultSetStats stats = 3;


    pub fn get_stats(&self) -> &ResultSetStats {
        self.stats.as_ref().unwrap_or_else(|| <ResultSetStats as ::protobuf::Message>::default_instance())
    }
    pub fn clear_stats(&mut self) {
        self.stats.clear();
    }

    pub fn has_stats(&self) -> bool {
        self.stats.is_some()
    }

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

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

    // Take field
    pub fn take_stats(&mut self) -> ResultSetStats {
        self.stats.take().unwrap_or_else(|| ResultSetStats::new())
    }
}

impl ::protobuf::Message for ResultSet {
    fn is_initialized(&self) -> bool {
        for v in &self.metadata {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.rows {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.stats {
            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.metadata)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.rows)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.stats)?;
                },
                _ => {
                    ::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.metadata.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.rows {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.stats.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.metadata.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)?;
        }
        for v in &self.rows {
            os.write_tag(2, ::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.stats.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)?;
        }
        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() -> ResultSet {
        ResultSet::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<ResultSetMetadata>>(
                "metadata",
                |m: &ResultSet| { &m.metadata },
                |m: &mut ResultSet| { &mut m.metadata },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::ListValue>>(
                "rows",
                |m: &ResultSet| { &m.rows },
                |m: &mut ResultSet| { &mut m.rows },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ResultSetStats>>(
                "stats",
                |m: &ResultSet| { &m.stats },
                |m: &mut ResultSet| { &mut m.stats },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResultSet>(
                "ResultSet",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ResultSet {
    fn clear(&mut self) {
        self.metadata.clear();
        self.rows.clear();
        self.stats.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct PartialResultSet {
    // message fields
    pub metadata: ::protobuf::SingularPtrField<ResultSetMetadata>,
    pub values: ::protobuf::RepeatedField<::protobuf::well_known_types::Value>,
    pub chunked_value: bool,
    pub resume_token: ::std::vec::Vec<u8>,
    pub stats: ::protobuf::SingularPtrField<ResultSetStats>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .google.spanner.v1.ResultSetMetadata metadata = 1;


    pub fn get_metadata(&self) -> &ResultSetMetadata {
        self.metadata.as_ref().unwrap_or_else(|| <ResultSetMetadata as ::protobuf::Message>::default_instance())
    }
    pub fn clear_metadata(&mut self) {
        self.metadata.clear();
    }

    pub fn has_metadata(&self) -> bool {
        self.metadata.is_some()
    }

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

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

    // Take field
    pub fn take_metadata(&mut self) -> ResultSetMetadata {
        self.metadata.take().unwrap_or_else(|| ResultSetMetadata::new())
    }

    // repeated .google.protobuf.Value values = 2;


    pub fn get_values(&self) -> &[::protobuf::well_known_types::Value] {
        &self.values
    }
    pub fn clear_values(&mut self) {
        self.values.clear();
    }

    // Param is passed by value, moved
    pub fn set_values(&mut self, v: ::protobuf::RepeatedField<::protobuf::well_known_types::Value>) {
        self.values = v;
    }

    // Mutable pointer to the field.
    pub fn mut_values(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::Value> {
        &mut self.values
    }

    // Take field
    pub fn take_values(&mut self) -> ::protobuf::RepeatedField<::protobuf::well_known_types::Value> {
        ::std::mem::replace(&mut self.values, ::protobuf::RepeatedField::new())
    }

    // bool chunked_value = 3;


    pub fn get_chunked_value(&self) -> bool {
        self.chunked_value
    }
    pub fn clear_chunked_value(&mut self) {
        self.chunked_value = false;
    }

    // Param is passed by value, moved
    pub fn set_chunked_value(&mut self, v: bool) {
        self.chunked_value = v;
    }

    // bytes resume_token = 4;


    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.ResultSetStats stats = 5;


    pub fn get_stats(&self) -> &ResultSetStats {
        self.stats.as_ref().unwrap_or_else(|| <ResultSetStats as ::protobuf::Message>::default_instance())
    }
    pub fn clear_stats(&mut self) {
        self.stats.clear();
    }

    pub fn has_stats(&self) -> bool {
        self.stats.is_some()
    }

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

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

    // Take field
    pub fn take_stats(&mut self) -> ResultSetStats {
        self.stats.take().unwrap_or_else(|| ResultSetStats::new())
    }
}

impl ::protobuf::Message for PartialResultSet {
    fn is_initialized(&self) -> bool {
        for v in &self.metadata {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.values {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.stats {
            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.metadata)?;
                },
                2 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.values)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_bool()?;
                    self.chunked_value = tmp;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.resume_token)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.stats)?;
                },
                _ => {
                    ::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.metadata.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        for value in &self.values {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if self.chunked_value != false {
            my_size += 2;
        }
        if !self.resume_token.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.resume_token);
        }
        if let Some(ref v) = self.stats.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.metadata.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)?;
        }
        for v in &self.values {
            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.chunked_value != false {
            os.write_bool(3, self.chunked_value)?;
        }
        if !self.resume_token.is_empty() {
            os.write_bytes(4, &self.resume_token)?;
        }
        if let Some(ref v) = self.stats.as_ref() {
            os.write_tag(5, ::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() -> PartialResultSet {
        PartialResultSet::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<ResultSetMetadata>>(
                "metadata",
                |m: &PartialResultSet| { &m.metadata },
                |m: &mut PartialResultSet| { &mut m.metadata },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Value>>(
                "values",
                |m: &PartialResultSet| { &m.values },
                |m: &mut PartialResultSet| { &mut m.values },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
                "chunked_value",
                |m: &PartialResultSet| { &m.chunked_value },
                |m: &mut PartialResultSet| { &mut m.chunked_value },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
                "resume_token",
                |m: &PartialResultSet| { &m.resume_token },
                |m: &mut PartialResultSet| { &mut m.resume_token },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ResultSetStats>>(
                "stats",
                |m: &PartialResultSet| { &m.stats },
                |m: &mut PartialResultSet| { &mut m.stats },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PartialResultSet>(
                "PartialResultSet",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for PartialResultSet {
    fn clear(&mut self) {
        self.metadata.clear();
        self.values.clear();
        self.chunked_value = false;
        self.resume_token.clear();
        self.stats.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ResultSetMetadata {
    // message fields
    pub row_type: ::protobuf::SingularPtrField<super::type_pb::StructType>,
    pub transaction: ::protobuf::SingularPtrField<super::transaction::Transaction>,
    pub undeclared_parameters: ::protobuf::SingularPtrField<super::type_pb::StructType>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // .google.spanner.v1.StructType row_type = 1;


    pub fn get_row_type(&self) -> &super::type_pb::StructType {
        self.row_type.as_ref().unwrap_or_else(|| <super::type_pb::StructType as ::protobuf::Message>::default_instance())
    }
    pub fn clear_row_type(&mut self) {
        self.row_type.clear();
    }

    pub fn has_row_type(&self) -> bool {
        self.row_type.is_some()
    }

    // Param is passed by value, moved
    pub fn set_row_type(&mut self, v: super::type_pb::StructType) {
        self.row_type = ::protobuf::SingularPtrField::some(v);
    }

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

    // Take field
    pub fn take_row_type(&mut self) -> super::type_pb::StructType {
        self.row_type.take().unwrap_or_else(|| super::type_pb::StructType::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())
    }

    // .google.spanner.v1.StructType undeclared_parameters = 3;


    pub fn get_undeclared_parameters(&self) -> &super::type_pb::StructType {
        self.undeclared_parameters.as_ref().unwrap_or_else(|| <super::type_pb::StructType as ::protobuf::Message>::default_instance())
    }
    pub fn clear_undeclared_parameters(&mut self) {
        self.undeclared_parameters.clear();
    }

    pub fn has_undeclared_parameters(&self) -> bool {
        self.undeclared_parameters.is_some()
    }

    // Param is passed by value, moved
    pub fn set_undeclared_parameters(&mut self, v: super::type_pb::StructType) {
        self.undeclared_parameters = ::protobuf::SingularPtrField::some(v);
    }

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

    // Take field
    pub fn take_undeclared_parameters(&mut self) -> super::type_pb::StructType {
        self.undeclared_parameters.take().unwrap_or_else(|| super::type_pb::StructType::new())
    }
}

impl ::protobuf::Message for ResultSetMetadata {
    fn is_initialized(&self) -> bool {
        for v in &self.row_type {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.transaction {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.undeclared_parameters {
            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.row_type)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.transaction)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.undeclared_parameters)?;
                },
                _ => {
                    ::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.row_type.as_ref() {
            let len = v.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;
        }
        if let Some(ref v) = self.undeclared_parameters.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.row_type.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)?;
        }
        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 let Some(ref v) = self.undeclared_parameters.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)?;
        }
        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() -> ResultSetMetadata {
        ResultSetMetadata::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<super::type_pb::StructType>>(
                "row_type",
                |m: &ResultSetMetadata| { &m.row_type },
                |m: &mut ResultSetMetadata| { &mut m.row_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::transaction::Transaction>>(
                "transaction",
                |m: &ResultSetMetadata| { &m.transaction },
                |m: &mut ResultSetMetadata| { &mut m.transaction },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::type_pb::StructType>>(
                "undeclared_parameters",
                |m: &ResultSetMetadata| { &m.undeclared_parameters },
                |m: &mut ResultSetMetadata| { &mut m.undeclared_parameters },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResultSetMetadata>(
                "ResultSetMetadata",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ResultSetMetadata {
    fn clear(&mut self) {
        self.row_type.clear();
        self.transaction.clear();
        self.undeclared_parameters.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ResultSetStats {
    // message fields
    pub query_plan: ::protobuf::SingularPtrField<super::query_plan::QueryPlan>,
    pub query_stats: ::protobuf::SingularPtrField<::protobuf::well_known_types::Struct>,
    // message oneof groups
    pub row_count: ::std::option::Option<ResultSetStats_oneof_row_count>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

#[derive(Clone,PartialEq,Debug)]
pub enum ResultSetStats_oneof_row_count {
    row_count_exact(i64),
    row_count_lower_bound(i64),
}

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

    // .google.spanner.v1.QueryPlan query_plan = 1;


    pub fn get_query_plan(&self) -> &super::query_plan::QueryPlan {
        self.query_plan.as_ref().unwrap_or_else(|| <super::query_plan::QueryPlan as ::protobuf::Message>::default_instance())
    }
    pub fn clear_query_plan(&mut self) {
        self.query_plan.clear();
    }

    pub fn has_query_plan(&self) -> bool {
        self.query_plan.is_some()
    }

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

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

    // Take field
    pub fn take_query_plan(&mut self) -> super::query_plan::QueryPlan {
        self.query_plan.take().unwrap_or_else(|| super::query_plan::QueryPlan::new())
    }

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


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

    pub fn has_query_stats(&self) -> bool {
        self.query_stats.is_some()
    }

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

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

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

    // int64 row_count_exact = 3;


    pub fn get_row_count_exact(&self) -> i64 {
        match self.row_count {
            ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_exact(v)) => v,
            _ => 0,
        }
    }
    pub fn clear_row_count_exact(&mut self) {
        self.row_count = ::std::option::Option::None;
    }

    pub fn has_row_count_exact(&self) -> bool {
        match self.row_count {
            ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_exact(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_row_count_exact(&mut self, v: i64) {
        self.row_count = ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_exact(v))
    }

    // int64 row_count_lower_bound = 4;


    pub fn get_row_count_lower_bound(&self) -> i64 {
        match self.row_count {
            ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_lower_bound(v)) => v,
            _ => 0,
        }
    }
    pub fn clear_row_count_lower_bound(&mut self) {
        self.row_count = ::std::option::Option::None;
    }

    pub fn has_row_count_lower_bound(&self) -> bool {
        match self.row_count {
            ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_lower_bound(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_row_count_lower_bound(&mut self, v: i64) {
        self.row_count = ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_lower_bound(v))
    }
}

impl ::protobuf::Message for ResultSetStats {
    fn is_initialized(&self) -> bool {
        for v in &self.query_plan {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.query_stats {
            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.query_plan)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.query_stats)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.row_count = ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_exact(is.read_int64()?));
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.row_count = ::std::option::Option::Some(ResultSetStats_oneof_row_count::row_count_lower_bound(is.read_int64()?));
                },
                _ => {
                    ::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.query_plan.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let Some(ref v) = self.query_stats.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        if let ::std::option::Option::Some(ref v) = self.row_count {
            match v {
                &ResultSetStats_oneof_row_count::row_count_exact(v) => {
                    my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
                },
                &ResultSetStats_oneof_row_count::row_count_lower_bound(v) => {
                    my_size += ::protobuf::rt::value_size(4, v, ::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 let Some(ref v) = self.query_plan.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)?;
        }
        if let Some(ref v) = self.query_stats.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 let ::std::option::Option::Some(ref v) = self.row_count {
            match v {
                &ResultSetStats_oneof_row_count::row_count_exact(v) => {
                    os.write_int64(3, v)?;
                },
                &ResultSetStats_oneof_row_count::row_count_lower_bound(v) => {
                    os.write_int64(4, v)?;
                },
            };
        }
        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() -> ResultSetStats {
        ResultSetStats::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<super::query_plan::QueryPlan>>(
                "query_plan",
                |m: &ResultSetStats| { &m.query_plan },
                |m: &mut ResultSetStats| { &mut m.query_plan },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Struct>>(
                "query_stats",
                |m: &ResultSetStats| { &m.query_stats },
                |m: &mut ResultSetStats| { &mut m.query_stats },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor::<_>(
                "row_count_exact",
                ResultSetStats::has_row_count_exact,
                ResultSetStats::get_row_count_exact,
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor::<_>(
                "row_count_lower_bound",
                ResultSetStats::has_row_count_lower_bound,
                ResultSetStats::get_row_count_lower_bound,
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResultSetStats>(
                "ResultSetStats",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for ResultSetStats {
    fn clear(&mut self) {
        self.query_plan.clear();
        self.query_stats.clear();
        self.row_count = ::std::option::Option::None;
        self.row_count = ::std::option::Option::None;
        self.unknown_fields.clear();
    }
}

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\"google/spanner/v1/result_set.proto\x12\x11google.spanner.v1\x1a\x1cg\
    oogle/protobuf/struct.proto\x1a\"google/spanner/v1/query_plan.proto\x1a#\
    google/spanner/v1/transaction.proto\x1a\x1cgoogle/spanner/v1/type.proto\
    \"\xb6\x01\n\tResultSet\x12@\n\x08metadata\x18\x01\x20\x01(\x0b2$.google\
    .spanner.v1.ResultSetMetadataR\x08metadata\x12.\n\x04rows\x18\x02\x20\
    \x03(\x0b2\x1a.google.protobuf.ListValueR\x04rows\x127\n\x05stats\x18\
    \x03\x20\x01(\x0b2!.google.spanner.v1.ResultSetStatsR\x05stats\"\x85\x02\
    \n\x10PartialResultSet\x12@\n\x08metadata\x18\x01\x20\x01(\x0b2$.google.\
    spanner.v1.ResultSetMetadataR\x08metadata\x12.\n\x06values\x18\x02\x20\
    \x03(\x0b2\x16.google.protobuf.ValueR\x06values\x12#\n\rchunked_value\
    \x18\x03\x20\x01(\x08R\x0cchunkedValue\x12!\n\x0cresume_token\x18\x04\
    \x20\x01(\x0cR\x0bresumeToken\x127\n\x05stats\x18\x05\x20\x01(\x0b2!.goo\
    gle.spanner.v1.ResultSetStatsR\x05stats\"\xe3\x01\n\x11ResultSetMetadata\
    \x128\n\x08row_type\x18\x01\x20\x01(\x0b2\x1d.google.spanner.v1.StructTy\
    peR\x07rowType\x12@\n\x0btransaction\x18\x02\x20\x01(\x0b2\x1e.google.sp\
    anner.v1.TransactionR\x0btransaction\x12R\n\x15undeclared_parameters\x18\
    \x03\x20\x01(\x0b2\x1d.google.spanner.v1.StructTypeR\x14undeclaredParame\
    ters\"\xf3\x01\n\x0eResultSetStats\x12;\n\nquery_plan\x18\x01\x20\x01(\
    \x0b2\x1c.google.spanner.v1.QueryPlanR\tqueryPlan\x128\n\x0bquery_stats\
    \x18\x02\x20\x01(\x0b2\x17.google.protobuf.StructR\nqueryStats\x12(\n\
    \x0frow_count_exact\x18\x03\x20\x01(\x03H\0R\rrowCountExact\x123\n\x15ro\
    w_count_lower_bound\x18\x04\x20\x01(\x03H\0R\x12rowCountLowerBoundB\x0b\
    \n\trow_countB\xb4\x01\n\x15com.google.spanner.v1B\x0eResultSetProtoP\
    \x01Z5cloud.google.com/go/spanner/apiv1/spannerpb;spannerpb\xf8\x01\x01\
    \xaa\x02\x17Google.Cloud.Spanner.V1\xca\x02\x17Google\\Cloud\\Spanner\\V\
    1\xea\x02\x1aGoogle::Cloud::Spanner::V1J\xd3C\n\x07\x12\x05\x0e\0\xd7\
    \x01\x01\n\xbc\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb1\x04\x20Copyright\x20\
    2022\x20Google\x20LLC\n\n\x20Licensed\x20under\x20the\x20Apache\x20Licen\
    se,\x20Version\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20not\
    \x20use\x20this\x20file\x20except\x20in\x20compliance\x20with\x20the\x20\
    License.\n\x20You\x20may\x20obtain\x20a\x20copy\x20of\x20the\x20License\
    \x20at\n\n\x20\x20\x20\x20\x20http://www.apache.org/licenses/LICENSE-2.0\
    \n\n\x20Unless\x20required\x20by\x20applicable\x20law\x20or\x20agreed\
    \x20to\x20in\x20writing,\x20software\n\x20distributed\x20under\x20the\
    \x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\
    \x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20e\
    ither\x20express\x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20\
    the\x20specific\x20language\x20governing\x20permissions\x20and\n\x20limi\
    tations\x20under\x20the\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\0\x1a\
    \n\t\n\x02\x03\0\x12\x03\x12\0&\n\t\n\x02\x03\x01\x12\x03\x13\0,\n\t\n\
    \x02\x03\x02\x12\x03\x14\0-\n\t\n\x02\x03\x03\x12\x03\x15\0&\n\x08\n\x01\
    \x08\x12\x03\x17\0\x1f\n\t\n\x02\x08\x1f\x12\x03\x17\0\x1f\n\x08\n\x01\
    \x08\x12\x03\x18\04\n\t\n\x02\x08%\x12\x03\x18\04\n\x08\n\x01\x08\x12\
    \x03\x19\0L\n\t\n\x02\x08\x0b\x12\x03\x19\0L\n\x08\n\x01\x08\x12\x03\x1a\
    \0\"\n\t\n\x02\x08\n\x12\x03\x1a\0\"\n\x08\n\x01\x08\x12\x03\x1b\0/\n\t\
    \n\x02\x08\x08\x12\x03\x1b\0/\n\x08\n\x01\x08\x12\x03\x1c\0.\n\t\n\x02\
    \x08\x01\x12\x03\x1c\0.\n\x08\n\x01\x08\x12\x03\x1d\04\n\t\n\x02\x08)\
    \x12\x03\x1d\04\n\x08\n\x01\x08\x12\x03\x1e\03\n\t\n\x02\x08-\x12\x03\
    \x1e\03\ny\n\x02\x04\0\x12\x04\"\07\x01\x1am\x20Results\x20from\x20[Read\
    ][google.spanner.v1.Spanner.Read]\x20or\n\x20[ExecuteSql][google.spanner\
    .v1.Spanner.ExecuteSql].\n\n\n\n\x03\x04\0\x01\x12\x03\"\x08\x11\nK\n\
    \x04\x04\0\x02\0\x12\x03$\x02!\x1a>\x20Metadata\x20about\x20the\x20resul\
    t\x20set,\x20such\x20as\x20row\x20type\x20information.\n\n\x0c\n\x05\x04\
    \0\x02\0\x06\x12\x03$\x02\x13\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03$\x14\
    \x1c\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03$\x1f\x20\n\xde\x02\n\x04\x04\0\
    \x02\x01\x12\x03,\x02.\x1a\xd0\x02\x20Each\x20element\x20in\x20`rows`\
    \x20is\x20a\x20row\x20whose\x20format\x20is\x20defined\x20by\n\x20[metad\
    ata.row_type][google.spanner.v1.ResultSetMetadata.row_type].\x20The\x20i\
    th\x20element\n\x20in\x20each\x20row\x20matches\x20the\x20ith\x20field\
    \x20in\n\x20[metadata.row_type][google.spanner.v1.ResultSetMetadata.row_\
    type].\x20Elements\x20are\n\x20encoded\x20based\x20on\x20type\x20as\x20d\
    escribed\n\x20[here][google.spanner.v1.TypeCode].\n\n\x0c\n\x05\x04\0\
    \x02\x01\x04\x12\x03,\x02\n\n\x0c\n\x05\x04\0\x02\x01\x06\x12\x03,\x0b$\
    \n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03,%)\n\x0c\n\x05\x04\0\x02\x01\x03\
    \x12\x03,,-\n\xf5\x04\n\x04\x04\0\x02\x02\x12\x036\x02\x1b\x1a\xe7\x04\
    \x20Query\x20plan\x20and\x20execution\x20statistics\x20for\x20the\x20SQL\
    \x20statement\x20that\n\x20produced\x20this\x20result\x20set.\x20These\
    \x20can\x20be\x20requested\x20by\x20setting\n\x20[ExecuteSqlRequest.quer\
    y_mode][google.spanner.v1.ExecuteSqlRequest.query_mode].\n\x20DML\x20sta\
    tements\x20always\x20produce\x20stats\x20containing\x20the\x20number\x20\
    of\x20rows\n\x20modified,\x20unless\x20executed\x20using\x20the\n\x20[Ex\
    ecuteSqlRequest.QueryMode.PLAN][google.spanner.v1.ExecuteSqlRequest.Quer\
    yMode.PLAN]\x20[ExecuteSqlRequest.query_mode][google.spanner.v1.ExecuteS\
    qlRequest.query_mode].\n\x20Other\x20fields\x20may\x20or\x20may\x20not\
    \x20be\x20populated,\x20based\x20on\x20the\n\x20[ExecuteSqlRequest.query\
    _mode][google.spanner.v1.ExecuteSqlRequest.query_mode].\n\n\x0c\n\x05\
    \x04\0\x02\x02\x06\x12\x036\x02\x10\n\x0c\n\x05\x04\0\x02\x02\x01\x12\
    \x036\x11\x16\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x036\x19\x1a\n\xcc\x01\n\
    \x02\x04\x01\x12\x05<\0\x9f\x01\x01\x1a\xbe\x01\x20Partial\x20results\
    \x20from\x20a\x20streaming\x20read\x20or\x20SQL\x20query.\x20Streaming\
    \x20reads\x20and\n\x20SQL\x20queries\x20better\x20tolerate\x20large\x20r\
    esult\x20sets,\x20large\x20rows,\x20and\x20large\n\x20values,\x20but\x20\
    are\x20a\x20little\x20trickier\x20to\x20consume.\n\n\n\n\x03\x04\x01\x01\
    \x12\x03<\x08\x18\np\n\x04\x04\x01\x02\0\x12\x03?\x02!\x1ac\x20Metadata\
    \x20about\x20the\x20result\x20set,\x20such\x20as\x20row\x20type\x20infor\
    mation.\n\x20Only\x20present\x20in\x20the\x20first\x20response.\n\n\x0c\
    \n\x05\x04\x01\x02\0\x06\x12\x03?\x02\x13\n\x0c\n\x05\x04\x01\x02\0\x01\
    \x12\x03?\x14\x1c\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03?\x1f\x20\n\xc0\
    \x15\n\x04\x04\x01\x02\x01\x12\x04\x8a\x01\x02,\x1a\xb1\x15\x20A\x20stre\
    amed\x20result\x20set\x20consists\x20of\x20a\x20stream\x20of\x20values,\
    \x20which\x20might\n\x20be\x20split\x20into\x20many\x20`PartialResultSet\
    `\x20messages\x20to\x20accommodate\n\x20large\x20rows\x20and/or\x20large\
    \x20values.\x20Every\x20N\x20complete\x20values\x20defines\x20a\n\x20row\
    ,\x20where\x20N\x20is\x20equal\x20to\x20the\x20number\x20of\x20entries\
    \x20in\n\x20[metadata.row_type.fields][google.spanner.v1.StructType.fiel\
    ds].\n\n\x20Most\x20values\x20are\x20encoded\x20based\x20on\x20type\x20a\
    s\x20described\n\x20[here][google.spanner.v1.TypeCode].\n\n\x20It\x20is\
    \x20possible\x20that\x20the\x20last\x20value\x20in\x20values\x20is\x20\"\
    chunked\",\n\x20meaning\x20that\x20the\x20rest\x20of\x20the\x20value\x20\
    is\x20sent\x20in\x20subsequent\n\x20`PartialResultSet`(s).\x20This\x20is\
    \x20denoted\x20by\x20the\x20[chunked_value][google.spanner.v1.PartialRes\
    ultSet.chunked_value]\n\x20field.\x20Two\x20or\x20more\x20chunked\x20val\
    ues\x20can\x20be\x20merged\x20to\x20form\x20a\n\x20complete\x20value\x20\
    as\x20follows:\n\n\x20\x20\x20*\x20`bool/number/null`:\x20cannot\x20be\
    \x20chunked\n\x20\x20\x20*\x20`string`:\x20concatenate\x20the\x20strings\
    \n\x20\x20\x20*\x20`list`:\x20concatenate\x20the\x20lists.\x20If\x20the\
    \x20last\x20element\x20in\x20a\x20list\x20is\x20a\n\x20\x20\x20\x20\x20`\
    string`,\x20`list`,\x20or\x20`object`,\x20merge\x20it\x20with\x20the\x20\
    first\x20element\x20in\n\x20\x20\x20\x20\x20the\x20next\x20list\x20by\
    \x20applying\x20these\x20rules\x20recursively.\n\x20\x20\x20*\x20`object\
    `:\x20concatenate\x20the\x20(field\x20name,\x20field\x20value)\x20pairs.\
    \x20If\x20a\n\x20\x20\x20\x20\x20field\x20name\x20is\x20duplicated,\x20t\
    hen\x20apply\x20these\x20rules\x20recursively\n\x20\x20\x20\x20\x20to\
    \x20merge\x20the\x20field\x20values.\n\n\x20Some\x20examples\x20of\x20me\
    rging:\n\n\x20\x20\x20\x20\x20#\x20Strings\x20are\x20concatenated.\n\x20\
    \x20\x20\x20\x20\"foo\",\x20\"bar\"\x20=>\x20\"foobar\"\n\n\x20\x20\x20\
    \x20\x20#\x20Lists\x20of\x20non-strings\x20are\x20concatenated.\n\x20\
    \x20\x20\x20\x20[2,\x203],\x20[4]\x20=>\x20[2,\x203,\x204]\n\n\x20\x20\
    \x20\x20\x20#\x20Lists\x20are\x20concatenated,\x20but\x20the\x20last\x20\
    and\x20first\x20elements\x20are\x20merged\n\x20\x20\x20\x20\x20#\x20beca\
    use\x20they\x20are\x20strings.\n\x20\x20\x20\x20\x20[\"a\",\x20\"b\"],\
    \x20[\"c\",\x20\"d\"]\x20=>\x20[\"a\",\x20\"bc\",\x20\"d\"]\n\n\x20\x20\
    \x20\x20\x20#\x20Lists\x20are\x20concatenated,\x20but\x20the\x20last\x20\
    and\x20first\x20elements\x20are\x20merged\n\x20\x20\x20\x20\x20#\x20beca\
    use\x20they\x20are\x20lists.\x20Recursively,\x20the\x20last\x20and\x20fi\
    rst\x20elements\n\x20\x20\x20\x20\x20#\x20of\x20the\x20inner\x20lists\
    \x20are\x20merged\x20because\x20they\x20are\x20strings.\n\x20\x20\x20\
    \x20\x20[\"a\",\x20[\"b\",\x20\"c\"]],\x20[[\"d\"],\x20\"e\"]\x20=>\x20[\
    \"a\",\x20[\"b\",\x20\"cd\"],\x20\"e\"]\n\n\x20\x20\x20\x20\x20#\x20Non-\
    overlapping\x20object\x20fields\x20are\x20combined.\n\x20\x20\x20\x20\
    \x20{\"a\":\x20\"1\"},\x20{\"b\":\x20\"2\"}\x20=>\x20{\"a\":\x20\"1\",\
    \x20\"b\":\x202\"}\n\n\x20\x20\x20\x20\x20#\x20Overlapping\x20object\x20\
    fields\x20are\x20merged.\n\x20\x20\x20\x20\x20{\"a\":\x20\"1\"},\x20{\"a\
    \":\x20\"2\"}\x20=>\x20{\"a\":\x20\"12\"}\n\n\x20\x20\x20\x20\x20#\x20Ex\
    amples\x20of\x20merging\x20objects\x20containing\x20lists\x20of\x20strin\
    gs.\n\x20\x20\x20\x20\x20{\"a\":\x20[\"1\"]},\x20{\"a\":\x20[\"2\"]}\x20\
    =>\x20{\"a\":\x20[\"12\"]}\n\n\x20For\x20a\x20more\x20complete\x20exampl\
    e,\x20suppose\x20a\x20streaming\x20SQL\x20query\x20is\n\x20yielding\x20a\
    \x20result\x20set\x20whose\x20rows\x20contain\x20a\x20single\x20string\n\
    \x20field.\x20The\x20following\x20`PartialResultSet`s\x20might\x20be\x20\
    yielded:\n\n\x20\x20\x20\x20\x20{\n\x20\x20\x20\x20\x20\x20\x20\"metadat\
    a\":\x20{\x20...\x20}\n\x20\x20\x20\x20\x20\x20\x20\"values\":\x20[\"Hel\
    lo\",\x20\"W\"]\n\x20\x20\x20\x20\x20\x20\x20\"chunked_value\":\x20true\
    \n\x20\x20\x20\x20\x20\x20\x20\"resume_token\":\x20\"Af65...\"\n\x20\x20\
    \x20\x20\x20}\n\x20\x20\x20\x20\x20{\n\x20\x20\x20\x20\x20\x20\x20\"valu\
    es\":\x20[\"orl\"]\n\x20\x20\x20\x20\x20\x20\x20\"chunked_value\":\x20tr\
    ue\n\x20\x20\x20\x20\x20\x20\x20\"resume_token\":\x20\"Bqp2...\"\n\x20\
    \x20\x20\x20\x20}\n\x20\x20\x20\x20\x20{\n\x20\x20\x20\x20\x20\x20\x20\"\
    values\":\x20[\"d\"]\n\x20\x20\x20\x20\x20\x20\x20\"resume_token\":\x20\
    \"Zx1B...\"\n\x20\x20\x20\x20\x20}\n\n\x20This\x20sequence\x20of\x20`Par\
    tialResultSet`s\x20encodes\x20two\x20rows,\x20one\n\x20containing\x20the\
    \x20field\x20value\x20`\"Hello\"`,\x20and\x20a\x20second\x20containing\
    \x20the\n\x20field\x20value\x20`\"World\"\x20=\x20\"W\"\x20+\x20\"orl\"\
    \x20+\x20\"d\"`.\n\n\r\n\x05\x04\x01\x02\x01\x04\x12\x04\x8a\x01\x02\n\n\
    \r\n\x05\x04\x01\x02\x01\x06\x12\x04\x8a\x01\x0b\x20\n\r\n\x05\x04\x01\
    \x02\x01\x01\x12\x04\x8a\x01!'\n\r\n\x05\x04\x01\x02\x01\x03\x12\x04\x8a\
    \x01*+\n\xdf\x01\n\x04\x04\x01\x02\x02\x12\x04\x8f\x01\x02\x19\x1a\xd0\
    \x01\x20If\x20true,\x20then\x20the\x20final\x20value\x20in\x20[values][g\
    oogle.spanner.v1.PartialResultSet.values]\x20is\x20chunked,\x20and\x20mu\
    st\n\x20be\x20combined\x20with\x20more\x20values\x20from\x20subsequent\
    \x20`PartialResultSet`s\n\x20to\x20obtain\x20a\x20complete\x20field\x20v\
    alue.\n\n\r\n\x05\x04\x01\x02\x02\x05\x12\x04\x8f\x01\x02\x06\n\r\n\x05\
    \x04\x01\x02\x02\x01\x12\x04\x8f\x01\x07\x14\n\r\n\x05\x04\x01\x02\x02\
    \x03\x12\x04\x8f\x01\x17\x18\n\xbb\x02\n\x04\x04\x01\x02\x03\x12\x04\x96\
    \x01\x02\x19\x1a\xac\x02\x20Streaming\x20calls\x20might\x20be\x20interru\
    pted\x20for\x20a\x20variety\x20of\x20reasons,\x20such\n\x20as\x20TCP\x20\
    connection\x20loss.\x20If\x20this\x20occurs,\x20the\x20stream\x20of\x20r\
    esults\x20can\n\x20be\x20resumed\x20by\x20re-sending\x20the\x20original\
    \x20request\x20and\x20including\n\x20`resume_token`.\x20Note\x20that\x20\
    executing\x20any\x20other\x20transaction\x20in\x20the\n\x20same\x20sessi\
    on\x20invalidates\x20the\x20token.\n\n\r\n\x05\x04\x01\x02\x03\x05\x12\
    \x04\x96\x01\x02\x07\n\r\n\x05\x04\x01\x02\x03\x01\x12\x04\x96\x01\x08\
    \x14\n\r\n\x05\x04\x01\x02\x03\x03\x12\x04\x96\x01\x17\x18\n\xeb\x02\n\
    \x04\x04\x01\x02\x04\x12\x04\x9e\x01\x02\x1b\x1a\xdc\x02\x20Query\x20pla\
    n\x20and\x20execution\x20statistics\x20for\x20the\x20statement\x20that\
    \x20produced\x20this\n\x20streaming\x20result\x20set.\x20These\x20can\
    \x20be\x20requested\x20by\x20setting\n\x20[ExecuteSqlRequest.query_mode]\
    [google.spanner.v1.ExecuteSqlRequest.query_mode]\x20and\x20are\x20sent\n\
    \x20only\x20once\x20with\x20the\x20last\x20response\x20in\x20the\x20stre\
    am.\n\x20This\x20field\x20will\x20also\x20be\x20present\x20in\x20the\x20\
    last\x20response\x20for\x20DML\n\x20statements.\n\n\r\n\x05\x04\x01\x02\
    \x04\x06\x12\x04\x9e\x01\x02\x10\n\r\n\x05\x04\x01\x02\x04\x01\x12\x04\
    \x9e\x01\x11\x16\n\r\n\x05\x04\x01\x02\x04\x03\x12\x04\x9e\x01\x19\x1a\n\
    \x84\x01\n\x02\x04\x02\x12\x06\xa2\x01\0\xbc\x01\x01\x1av\x20Metadata\
    \x20about\x20a\x20[ResultSet][google.spanner.v1.ResultSet]\x20or\x20[Par\
    tialResultSet][google.spanner.v1.PartialResultSet].\n\n\x0b\n\x03\x04\
    \x02\x01\x12\x04\xa2\x01\x08\x19\n\xd2\x02\n\x04\x04\x02\x02\0\x12\x04\
    \xab\x01\x02\x1a\x1a\xc3\x02\x20Indicates\x20the\x20field\x20names\x20an\
    d\x20types\x20for\x20the\x20rows\x20in\x20the\x20result\n\x20set.\x20\
    \x20For\x20example,\x20a\x20SQL\x20query\x20like\x20`\"SELECT\x20UserId,\
    \x20UserName\x20FROM\n\x20Users\"`\x20could\x20return\x20a\x20`row_type`\
    \x20value\x20like:\n\n\x20\x20\x20\x20\x20\"fields\":\x20[\n\x20\x20\x20\
    \x20\x20\x20\x20{\x20\"name\":\x20\"UserId\",\x20\"type\":\x20{\x20\"cod\
    e\":\x20\"INT64\"\x20}\x20},\n\x20\x20\x20\x20\x20\x20\x20{\x20\"name\":\
    \x20\"UserName\",\x20\"type\":\x20{\x20\"code\":\x20\"STRING\"\x20}\x20}\
    ,\n\x20\x20\x20\x20\x20]\n\n\r\n\x05\x04\x02\x02\0\x06\x12\x04\xab\x01\
    \x02\x0c\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\xab\x01\r\x15\n\r\n\x05\x04\
    \x02\x02\0\x03\x12\x04\xab\x01\x18\x19\n\x8a\x01\n\x04\x04\x02\x02\x01\
    \x12\x04\xaf\x01\x02\x1e\x1a|\x20If\x20the\x20read\x20or\x20SQL\x20query\
    \x20began\x20a\x20transaction\x20as\x20a\x20side-effect,\x20the\n\x20inf\
    ormation\x20about\x20the\x20new\x20transaction\x20is\x20yielded\x20here.\
    \n\n\r\n\x05\x04\x02\x02\x01\x06\x12\x04\xaf\x01\x02\r\n\r\n\x05\x04\x02\
    \x02\x01\x01\x12\x04\xaf\x01\x0e\x19\n\r\n\x05\x04\x02\x02\x01\x03\x12\
    \x04\xaf\x01\x1c\x1d\n\xed\x03\n\x04\x04\x02\x02\x02\x12\x04\xbb\x01\x02\
    '\x1a\xde\x03\x20A\x20SQL\x20query\x20can\x20be\x20parameterized.\x20In\
    \x20PLAN\x20mode,\x20these\x20parameters\x20can\x20be\n\x20undeclared.\
    \x20This\x20indicates\x20the\x20field\x20names\x20and\x20types\x20for\
    \x20those\x20undeclared\n\x20parameters\x20in\x20the\x20SQL\x20query.\
    \x20For\x20example,\x20a\x20SQL\x20query\x20like\x20`\"SELECT\x20*\x20FR\
    OM\n\x20Users\x20where\x20UserId\x20=\x20@userId\x20and\x20UserName\x20=\
    \x20@userName\x20\"`\x20could\x20return\x20a\n\x20`undeclared_parameters\
    `\x20value\x20like:\n\n\x20\x20\x20\x20\x20\"fields\":\x20[\n\x20\x20\
    \x20\x20\x20\x20\x20{\x20\"name\":\x20\"UserId\",\x20\"type\":\x20{\x20\
    \"code\":\x20\"INT64\"\x20}\x20},\n\x20\x20\x20\x20\x20\x20\x20{\x20\"na\
    me\":\x20\"UserName\",\x20\"type\":\x20{\x20\"code\":\x20\"STRING\"\x20}\
    \x20},\n\x20\x20\x20\x20\x20]\n\n\r\n\x05\x04\x02\x02\x02\x06\x12\x04\
    \xbb\x01\x02\x0c\n\r\n\x05\x04\x02\x02\x02\x01\x12\x04\xbb\x01\r\"\n\r\n\
    \x05\x04\x02\x02\x02\x03\x12\x04\xbb\x01%&\n\x92\x01\n\x02\x04\x03\x12\
    \x06\xbf\x01\0\xd7\x01\x01\x1a\x83\x01\x20Additional\x20statistics\x20ab\
    out\x20a\x20[ResultSet][google.spanner.v1.ResultSet]\x20or\x20[PartialRe\
    sultSet][google.spanner.v1.PartialResultSet].\n\n\x0b\n\x03\x04\x03\x01\
    \x12\x04\xbf\x01\x08\x16\nc\n\x04\x04\x03\x02\0\x12\x04\xc1\x01\x02\x1b\
    \x1aU\x20[QueryPlan][google.spanner.v1.QueryPlan]\x20for\x20the\x20query\
    \x20associated\x20with\x20this\x20result.\n\n\r\n\x05\x04\x03\x02\0\x06\
    \x12\x04\xc1\x01\x02\x0b\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\xc1\x01\x0c\
    \x16\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\xc1\x01\x19\x1a\n\x9e\x02\n\x04\
    \x04\x03\x02\x01\x12\x04\xcc\x01\x02)\x1a\x8f\x02\x20Aggregated\x20stati\
    stics\x20from\x20the\x20execution\x20of\x20the\x20query.\x20Only\x20pres\
    ent\x20when\n\x20the\x20query\x20is\x20profiled.\x20For\x20example,\x20a\
    \x20query\x20could\x20return\x20the\x20statistics\x20as\n\x20follows:\n\
    \n\x20\x20\x20\x20\x20{\n\x20\x20\x20\x20\x20\x20\x20\"rows_returned\":\
    \x20\"3\",\n\x20\x20\x20\x20\x20\x20\x20\"elapsed_time\":\x20\"1.22\x20s\
    ecs\",\n\x20\x20\x20\x20\x20\x20\x20\"cpu_time\":\x20\"1.19\x20secs\"\n\
    \x20\x20\x20\x20\x20}\n\n\r\n\x05\x04\x03\x02\x01\x06\x12\x04\xcc\x01\
    \x02\x18\n\r\n\x05\x04\x03\x02\x01\x01\x12\x04\xcc\x01\x19$\n\r\n\x05\
    \x04\x03\x02\x01\x03\x12\x04\xcc\x01'(\nC\n\x04\x04\x03\x08\0\x12\x06\
    \xcf\x01\x02\xd6\x01\x03\x1a3\x20The\x20number\x20of\x20rows\x20modified\
    \x20by\x20the\x20DML\x20statement.\n\n\r\n\x05\x04\x03\x08\0\x01\x12\x04\
    \xcf\x01\x08\x11\nO\n\x04\x04\x03\x02\x02\x12\x04\xd1\x01\x04\x1e\x1aA\
    \x20Standard\x20DML\x20returns\x20an\x20exact\x20count\x20of\x20rows\x20\
    that\x20were\x20modified.\n\n\r\n\x05\x04\x03\x02\x02\x05\x12\x04\xd1\
    \x01\x04\t\n\r\n\x05\x04\x03\x02\x02\x01\x12\x04\xd1\x01\n\x19\n\r\n\x05\
    \x04\x03\x02\x02\x03\x12\x04\xd1\x01\x1c\x1d\ny\n\x04\x04\x03\x02\x03\
    \x12\x04\xd5\x01\x04$\x1ak\x20Partitioned\x20DML\x20does\x20not\x20offer\
    \x20exactly-once\x20semantics,\x20so\x20it\n\x20returns\x20a\x20lower\
    \x20bound\x20of\x20the\x20rows\x20modified.\n\n\r\n\x05\x04\x03\x02\x03\
    \x05\x12\x04\xd5\x01\x04\t\n\r\n\x05\x04\x03\x02\x03\x01\x12\x04\xd5\x01\
    \n\x1f\n\r\n\x05\x04\x03\x02\x03\x03\x12\x04\xd5\x01\"#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()
    })
}