google_cloud_rust_raw/spanner/v1/

query_plan.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/query_plan.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 PlanNode {
    // message fields
    pub index: i32,
    pub kind: PlanNode_Kind,
    pub display_name: ::std::string::String,
    pub child_links: ::protobuf::RepeatedField<PlanNode_ChildLink>,
    pub short_representation: ::protobuf::SingularPtrField<PlanNode_ShortRepresentation>,
    pub metadata: ::protobuf::SingularPtrField<::protobuf::well_known_types::Struct>,
    pub execution_stats: ::protobuf::SingularPtrField<::protobuf::well_known_types::Struct>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // int32 index = 1;


    pub fn get_index(&self) -> i32 {
        self.index
    }
    pub fn clear_index(&mut self) {
        self.index = 0;
    }

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

    // .google.spanner.v1.PlanNode.Kind kind = 2;


    pub fn get_kind(&self) -> PlanNode_Kind {
        self.kind
    }
    pub fn clear_kind(&mut self) {
        self.kind = PlanNode_Kind::KIND_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_kind(&mut self, v: PlanNode_Kind) {
        self.kind = v;
    }

    // string display_name = 3;


    pub fn get_display_name(&self) -> &str {
        &self.display_name
    }
    pub fn clear_display_name(&mut self) {
        self.display_name.clear();
    }

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

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

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

    // repeated .google.spanner.v1.PlanNode.ChildLink child_links = 4;


    pub fn get_child_links(&self) -> &[PlanNode_ChildLink] {
        &self.child_links
    }
    pub fn clear_child_links(&mut self) {
        self.child_links.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_child_links(&mut self) -> &mut ::protobuf::RepeatedField<PlanNode_ChildLink> {
        &mut self.child_links
    }

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

    // .google.spanner.v1.PlanNode.ShortRepresentation short_representation = 5;


    pub fn get_short_representation(&self) -> &PlanNode_ShortRepresentation {
        self.short_representation.as_ref().unwrap_or_else(|| <PlanNode_ShortRepresentation as ::protobuf::Message>::default_instance())
    }
    pub fn clear_short_representation(&mut self) {
        self.short_representation.clear();
    }

    pub fn has_short_representation(&self) -> bool {
        self.short_representation.is_some()
    }

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

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

    // Take field
    pub fn take_short_representation(&mut self) -> PlanNode_ShortRepresentation {
        self.short_representation.take().unwrap_or_else(|| PlanNode_ShortRepresentation::new())
    }

    // .google.protobuf.Struct metadata = 6;


    pub fn get_metadata(&self) -> &::protobuf::well_known_types::Struct {
        self.metadata.as_ref().unwrap_or_else(|| <::protobuf::well_known_types::Struct 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: ::protobuf::well_known_types::Struct) {
        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 ::protobuf::well_known_types::Struct {
        if self.metadata.is_none() {
            self.metadata.set_default();
        }
        self.metadata.as_mut().unwrap()
    }

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

    // .google.protobuf.Struct execution_stats = 7;


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

    pub fn has_execution_stats(&self) -> bool {
        self.execution_stats.is_some()
    }

    // Param is passed by value, moved
    pub fn set_execution_stats(&mut self, v: ::protobuf::well_known_types::Struct) {
        self.execution_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_execution_stats(&mut self) -> &mut ::protobuf::well_known_types::Struct {
        if self.execution_stats.is_none() {
            self.execution_stats.set_default();
        }
        self.execution_stats.as_mut().unwrap()
    }

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

impl ::protobuf::Message for PlanNode {
    fn is_initialized(&self) -> bool {
        for v in &self.child_links {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.short_representation {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.metadata {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.execution_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 => {
                    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.index = tmp;
                },
                2 => {
                    ::protobuf::rt::read_proto3_enum_with_unknown_fields_into(wire_type, is, &mut self.kind, 2, &mut self.unknown_fields)?
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.display_name)?;
                },
                4 => {
                    ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.child_links)?;
                },
                5 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.short_representation)?;
                },
                6 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.metadata)?;
                },
                7 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.execution_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 self.index != 0 {
            my_size += ::protobuf::rt::value_size(1, self.index, ::protobuf::wire_format::WireTypeVarint);
        }
        if self.kind != PlanNode_Kind::KIND_UNSPECIFIED {
            my_size += ::protobuf::rt::enum_size(2, self.kind);
        }
        if !self.display_name.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.display_name);
        }
        for value in &self.child_links {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        if let Some(ref v) = self.short_representation.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        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;
        }
        if let Some(ref v) = self.execution_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 self.index != 0 {
            os.write_int32(1, self.index)?;
        }
        if self.kind != PlanNode_Kind::KIND_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.kind))?;
        }
        if !self.display_name.is_empty() {
            os.write_string(3, &self.display_name)?;
        }
        for v in &self.child_links {
            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 Some(ref v) = self.short_representation.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)?;
        }
        if let Some(ref v) = self.metadata.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.execution_stats.as_ref() {
            os.write_tag(7, ::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() -> PlanNode {
        PlanNode::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::ProtobufTypeInt32>(
                "index",
                |m: &PlanNode| { &m.index },
                |m: &mut PlanNode| { &mut m.index },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeEnum<PlanNode_Kind>>(
                "kind",
                |m: &PlanNode| { &m.kind },
                |m: &mut PlanNode| { &mut m.kind },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "display_name",
                |m: &PlanNode| { &m.display_name },
                |m: &mut PlanNode| { &mut m.display_name },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<PlanNode_ChildLink>>(
                "child_links",
                |m: &PlanNode| { &m.child_links },
                |m: &mut PlanNode| { &mut m.child_links },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<PlanNode_ShortRepresentation>>(
                "short_representation",
                |m: &PlanNode| { &m.short_representation },
                |m: &mut PlanNode| { &mut m.short_representation },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Struct>>(
                "metadata",
                |m: &PlanNode| { &m.metadata },
                |m: &mut PlanNode| { &mut m.metadata },
            ));
            fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Struct>>(
                "execution_stats",
                |m: &PlanNode| { &m.execution_stats },
                |m: &mut PlanNode| { &mut m.execution_stats },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PlanNode>(
                "PlanNode",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for PlanNode {
    fn clear(&mut self) {
        self.index = 0;
        self.kind = PlanNode_Kind::KIND_UNSPECIFIED;
        self.display_name.clear();
        self.child_links.clear();
        self.short_representation.clear();
        self.metadata.clear();
        self.execution_stats.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct PlanNode_ChildLink {
    // message fields
    pub child_index: i32,
    pub field_type: ::std::string::String,
    pub variable: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // int32 child_index = 1;


    pub fn get_child_index(&self) -> i32 {
        self.child_index
    }
    pub fn clear_child_index(&mut self) {
        self.child_index = 0;
    }

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

    // string type = 2;


    pub fn get_field_type(&self) -> &str {
        &self.field_type
    }
    pub fn clear_field_type(&mut self) {
        self.field_type.clear();
    }

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

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

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

    // string variable = 3;


    pub fn get_variable(&self) -> &str {
        &self.variable
    }
    pub fn clear_variable(&mut self) {
        self.variable.clear();
    }

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

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

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

impl ::protobuf::Message for PlanNode_ChildLink {
    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_int32()?;
                    self.child_index = tmp;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.field_type)?;
                },
                3 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.variable)?;
                },
                _ => {
                    ::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.child_index != 0 {
            my_size += ::protobuf::rt::value_size(1, self.child_index, ::protobuf::wire_format::WireTypeVarint);
        }
        if !self.field_type.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.field_type);
        }
        if !self.variable.is_empty() {
            my_size += ::protobuf::rt::string_size(3, &self.variable);
        }
        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.child_index != 0 {
            os.write_int32(1, self.child_index)?;
        }
        if !self.field_type.is_empty() {
            os.write_string(2, &self.field_type)?;
        }
        if !self.variable.is_empty() {
            os.write_string(3, &self.variable)?;
        }
        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() -> PlanNode_ChildLink {
        PlanNode_ChildLink::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::ProtobufTypeInt32>(
                "child_index",
                |m: &PlanNode_ChildLink| { &m.child_index },
                |m: &mut PlanNode_ChildLink| { &mut m.child_index },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "type",
                |m: &PlanNode_ChildLink| { &m.field_type },
                |m: &mut PlanNode_ChildLink| { &mut m.field_type },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "variable",
                |m: &PlanNode_ChildLink| { &m.variable },
                |m: &mut PlanNode_ChildLink| { &mut m.variable },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PlanNode_ChildLink>(
                "PlanNode.ChildLink",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for PlanNode_ChildLink {
    fn clear(&mut self) {
        self.child_index = 0;
        self.field_type.clear();
        self.variable.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct PlanNode_ShortRepresentation {
    // message fields
    pub description: ::std::string::String,
    pub subqueries: ::std::collections::HashMap<::std::string::String, i32>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string description = 1;


    pub fn get_description(&self) -> &str {
        &self.description
    }
    pub fn clear_description(&mut self) {
        self.description.clear();
    }

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

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

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

    // repeated .google.spanner.v1.PlanNode.ShortRepresentation.SubqueriesEntry subqueries = 2;


    pub fn get_subqueries(&self) -> &::std::collections::HashMap<::std::string::String, i32> {
        &self.subqueries
    }
    pub fn clear_subqueries(&mut self) {
        self.subqueries.clear();
    }

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

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

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

impl ::protobuf::Message for PlanNode_ShortRepresentation {
    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.description)?;
                },
                2 => {
                    ::protobuf::rt::read_map_into::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeInt32>(wire_type, is, &mut self.subqueries)?;
                },
                _ => {
                    ::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.description.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.description);
        }
        my_size += ::protobuf::rt::compute_map_size::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeInt32>(2, &self.subqueries);
        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.description.is_empty() {
            os.write_string(1, &self.description)?;
        }
        ::protobuf::rt::write_map_with_cached_sizes::<::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeInt32>(2, &self.subqueries, 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() -> PlanNode_ShortRepresentation {
        PlanNode_ShortRepresentation::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>(
                "description",
                |m: &PlanNode_ShortRepresentation| { &m.description },
                |m: &mut PlanNode_ShortRepresentation| { &mut m.description },
            ));
            fields.push(::protobuf::reflect::accessor::make_map_accessor::<_, ::protobuf::types::ProtobufTypeString, ::protobuf::types::ProtobufTypeInt32>(
                "subqueries",
                |m: &PlanNode_ShortRepresentation| { &m.subqueries },
                |m: &mut PlanNode_ShortRepresentation| { &mut m.subqueries },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<PlanNode_ShortRepresentation>(
                "PlanNode.ShortRepresentation",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for PlanNode_ShortRepresentation {
    fn clear(&mut self) {
        self.description.clear();
        self.subqueries.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum PlanNode_Kind {
    KIND_UNSPECIFIED = 0,
    RELATIONAL = 1,
    SCALAR = 2,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<PlanNode_Kind> {
        match value {
            0 => ::std::option::Option::Some(PlanNode_Kind::KIND_UNSPECIFIED),
            1 => ::std::option::Option::Some(PlanNode_Kind::RELATIONAL),
            2 => ::std::option::Option::Some(PlanNode_Kind::SCALAR),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [PlanNode_Kind] = &[
            PlanNode_Kind::KIND_UNSPECIFIED,
            PlanNode_Kind::RELATIONAL,
            PlanNode_Kind::SCALAR,
        ];
        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::<PlanNode_Kind>("PlanNode.Kind", file_descriptor_proto())
        })
    }
}

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

impl ::std::default::Default for PlanNode_Kind {
    fn default() -> Self {
        PlanNode_Kind::KIND_UNSPECIFIED
    }
}

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

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

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

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

    // repeated .google.spanner.v1.PlanNode plan_nodes = 1;


    pub fn get_plan_nodes(&self) -> &[PlanNode] {
        &self.plan_nodes
    }
    pub fn clear_plan_nodes(&mut self) {
        self.plan_nodes.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_plan_nodes(&mut self) -> &mut ::protobuf::RepeatedField<PlanNode> {
        &mut self.plan_nodes
    }

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

impl ::protobuf::Message for QueryPlan {
    fn is_initialized(&self) -> bool {
        for v in &self.plan_nodes {
            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.plan_nodes)?;
                },
                _ => {
                    ::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.plan_nodes {
            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.plan_nodes {
            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() -> QueryPlan {
        QueryPlan::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<PlanNode>>(
                "plan_nodes",
                |m: &QueryPlan| { &m.plan_nodes },
                |m: &mut QueryPlan| { &mut m.plan_nodes },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<QueryPlan>(
                "QueryPlan",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\"google/spanner/v1/query_plan.proto\x12\x11google.spanner.v1\x1a\x1cg\
    oogle/protobuf/struct.proto\"\x8e\x06\n\x08PlanNode\x12\x14\n\x05index\
    \x18\x01\x20\x01(\x05R\x05index\x124\n\x04kind\x18\x02\x20\x01(\x0e2\x20\
    .google.spanner.v1.PlanNode.KindR\x04kind\x12!\n\x0cdisplay_name\x18\x03\
    \x20\x01(\tR\x0bdisplayName\x12F\n\x0bchild_links\x18\x04\x20\x03(\x0b2%\
    .google.spanner.v1.PlanNode.ChildLinkR\nchildLinks\x12b\n\x14short_repre\
    sentation\x18\x05\x20\x01(\x0b2/.google.spanner.v1.PlanNode.ShortReprese\
    ntationR\x13shortRepresentation\x123\n\x08metadata\x18\x06\x20\x01(\x0b2\
    \x17.google.protobuf.StructR\x08metadata\x12@\n\x0fexecution_stats\x18\
    \x07\x20\x01(\x0b2\x17.google.protobuf.StructR\x0eexecutionStats\x1a\\\n\
    \tChildLink\x12\x1f\n\x0bchild_index\x18\x01\x20\x01(\x05R\nchildIndex\
    \x12\x12\n\x04type\x18\x02\x20\x01(\tR\x04type\x12\x1a\n\x08variable\x18\
    \x03\x20\x01(\tR\x08variable\x1a\xd7\x01\n\x13ShortRepresentation\x12\
    \x20\n\x0bdescription\x18\x01\x20\x01(\tR\x0bdescription\x12_\n\nsubquer\
    ies\x18\x02\x20\x03(\x0b2?.google.spanner.v1.PlanNode.ShortRepresentatio\
    n.SubqueriesEntryR\nsubqueries\x1a=\n\x0fSubqueriesEntry\x12\x10\n\x03ke\
    y\x18\x01\x20\x01(\tR\x03key\x12\x14\n\x05value\x18\x02\x20\x01(\x05R\
    \x05value:\x028\x01\"8\n\x04Kind\x12\x14\n\x10KIND_UNSPECIFIED\x10\0\x12\
    \x0e\n\nRELATIONAL\x10\x01\x12\n\n\x06SCALAR\x10\x02\"G\n\tQueryPlan\x12\
    :\n\nplan_nodes\x18\x01\x20\x03(\x0b2\x1b.google.spanner.v1.PlanNodeR\tp\
    lanNodesB\xb1\x01\n\x15com.google.spanner.v1B\x0eQueryPlanProtoP\x01Z5cl\
    oud.google.com/go/spanner/apiv1/spannerpb;spannerpb\xaa\x02\x17Google.Cl\
    oud.Spanner.V1\xca\x02\x17Google\\Cloud\\Spanner\\V1\xea\x02\x1aGoogle::\
    Cloud::Spanner::V1J\x9f)\n\x06\x12\x04\x0e\0\x7f\x01\n\xbc\x04\n\x01\x0c\
    \x12\x03\x0e\0\x122\xb1\x04\x20Copyright\x202022\x20Google\x20LLC\n\n\
    \x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\x20\
    (the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\x20e\
    xcept\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20may\x20\
    obtain\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,\x20s\
    oftware\n\x20distributed\x20under\x20the\x20License\x20is\x20distributed\
    \x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\
    \x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\x20impli\
    ed.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20language\x20\
    governing\x20permissions\x20and\n\x20limitations\x20under\x20the\x20Lice\
    nse.\n\n\x08\n\x01\x02\x12\x03\x10\0\x1a\n\t\n\x02\x03\0\x12\x03\x12\0&\
    \n\x08\n\x01\x08\x12\x03\x14\04\n\t\n\x02\x08%\x12\x03\x14\04\n\x08\n\
    \x01\x08\x12\x03\x15\0L\n\t\n\x02\x08\x0b\x12\x03\x15\0L\n\x08\n\x01\x08\
    \x12\x03\x16\0\"\n\t\n\x02\x08\n\x12\x03\x16\0\"\n\x08\n\x01\x08\x12\x03\
    \x17\0/\n\t\n\x02\x08\x08\x12\x03\x17\0/\n\x08\n\x01\x08\x12\x03\x18\0.\
    \n\t\n\x02\x08\x01\x12\x03\x18\0.\n\x08\n\x01\x08\x12\x03\x19\04\n\t\n\
    \x02\x08)\x12\x03\x19\04\n\x08\n\x01\x08\x12\x03\x1a\03\n\t\n\x02\x08-\
    \x12\x03\x1a\03\nw\n\x02\x04\0\x12\x04\x1d\0w\x01\x1ak\x20Node\x20inform\
    ation\x20for\x20nodes\x20appearing\x20in\x20a\x20[QueryPlan.plan_nodes][\
    google.spanner.v1.QueryPlan.plan_nodes].\n\n\n\n\x03\x04\0\x01\x12\x03\
    \x1d\x08\x10\n\x9d\x01\n\x04\x04\0\x04\0\x12\x04\x20\x02.\x03\x1a\x8e\
    \x01\x20The\x20kind\x20of\x20[PlanNode][google.spanner.v1.PlanNode].\x20\
    Distinguishes\x20between\x20the\x20two\x20different\x20kinds\x20of\n\x20\
    nodes\x20that\x20can\x20appear\x20in\x20a\x20query\x20plan.\n\n\x0c\n\
    \x05\x04\0\x04\0\x01\x12\x03\x20\x07\x0b\n\x1f\n\x06\x04\0\x04\0\x02\0\
    \x12\x03\"\x04\x19\x1a\x10\x20Not\x20specified.\n\n\x0e\n\x07\x04\0\x04\
    \0\x02\0\x01\x12\x03\"\x04\x14\n\x0e\n\x07\x04\0\x04\0\x02\0\x02\x12\x03\
    \"\x17\x18\n\xe5\x01\n\x06\x04\0\x04\0\x02\x01\x12\x03'\x04\x13\x1a\xd5\
    \x01\x20Denotes\x20a\x20Relational\x20operator\x20node\x20in\x20the\x20e\
    xpression\x20tree.\x20Relational\n\x20operators\x20represent\x20iterativ\
    e\x20processing\x20of\x20rows\x20during\x20query\x20execution.\n\x20For\
    \x20example,\x20a\x20`TableScan`\x20operation\x20that\x20reads\x20rows\
    \x20from\x20a\x20table.\n\n\x0e\n\x07\x04\0\x04\0\x02\x01\x01\x12\x03'\
    \x04\x0e\n\x0e\n\x07\x04\0\x04\0\x02\x01\x02\x12\x03'\x11\x12\n\xf7\x01\
    \n\x06\x04\0\x04\0\x02\x02\x12\x03-\x04\x0f\x1a\xe7\x01\x20Denotes\x20a\
    \x20Scalar\x20node\x20in\x20the\x20expression\x20tree.\x20Scalar\x20node\
    s\x20represent\n\x20non-iterable\x20entities\x20in\x20the\x20query\x20pl\
    an.\x20For\x20example,\x20constants\x20or\n\x20arithmetic\x20operators\
    \x20appearing\x20inside\x20predicate\x20expressions\x20or\x20references\
    \n\x20to\x20column\x20names.\n\n\x0e\n\x07\x04\0\x04\0\x02\x02\x01\x12\
    \x03-\x04\n\n\x0e\n\x07\x04\0\x04\0\x02\x02\x02\x12\x03-\r\x0e\n|\n\x04\
    \x04\0\x03\0\x12\x042\x02E\x03\x1an\x20Metadata\x20associated\x20with\
    \x20a\x20parent-child\x20relationship\x20appearing\x20in\x20a\n\x20[Plan\
    Node][google.spanner.v1.PlanNode].\n\n\x0c\n\x05\x04\0\x03\0\x01\x12\x03\
    2\n\x13\n3\n\x06\x04\0\x03\0\x02\0\x12\x034\x04\x1a\x1a$\x20The\x20node\
    \x20to\x20which\x20the\x20link\x20points.\n\n\x0e\n\x07\x04\0\x03\0\x02\
    \0\x05\x12\x034\x04\t\n\x0e\n\x07\x04\0\x03\0\x02\0\x01\x12\x034\n\x15\n\
    \x0e\n\x07\x04\0\x03\0\x02\0\x03\x12\x034\x18\x19\n\x84\x02\n\x06\x04\0\
    \x03\0\x02\x01\x12\x03:\x04\x14\x1a\xf4\x01\x20The\x20type\x20of\x20the\
    \x20link.\x20For\x20example,\x20in\x20Hash\x20Joins\x20this\x20could\x20\
    be\x20used\x20to\n\x20distinguish\x20between\x20the\x20build\x20child\
    \x20and\x20the\x20probe\x20child,\x20or\x20in\x20the\x20case\n\x20of\x20\
    the\x20child\x20being\x20an\x20output\x20variable,\x20to\x20represent\
    \x20the\x20tag\x20associated\n\x20with\x20the\x20output\x20variable.\n\n\
    \x0e\n\x07\x04\0\x03\0\x02\x01\x05\x12\x03:\x04\n\n\x0e\n\x07\x04\0\x03\
    \0\x02\x01\x01\x12\x03:\x0b\x0f\n\x0e\n\x07\x04\0\x03\0\x02\x01\x03\x12\
    \x03:\x12\x13\n\xfc\x03\n\x06\x04\0\x03\0\x02\x02\x12\x03D\x04\x18\x1a\
    \xec\x03\x20Only\x20present\x20if\x20the\x20child\x20node\x20is\x20[SCAL\
    AR][google.spanner.v1.PlanNode.Kind.SCALAR]\x20and\x20corresponds\n\x20t\
    o\x20an\x20output\x20variable\x20of\x20the\x20parent\x20node.\x20The\x20\
    field\x20carries\x20the\x20name\x20of\n\x20the\x20output\x20variable.\n\
    \x20For\x20example,\x20a\x20`TableScan`\x20operator\x20that\x20reads\x20\
    rows\x20from\x20a\x20table\x20will\n\x20have\x20child\x20links\x20to\x20\
    the\x20`SCALAR`\x20nodes\x20representing\x20the\x20output\x20variables\n\
    \x20created\x20for\x20each\x20column\x20that\x20is\x20read\x20by\x20the\
    \x20operator.\x20The\x20corresponding\n\x20`variable`\x20fields\x20will\
    \x20be\x20set\x20to\x20the\x20variable\x20names\x20assigned\x20to\x20the\
    \n\x20columns.\n\n\x0e\n\x07\x04\0\x03\0\x02\x02\x05\x12\x03D\x04\n\n\
    \x0e\n\x07\x04\0\x03\0\x02\x02\x01\x12\x03D\x0b\x13\n\x0e\n\x07\x04\0\
    \x03\0\x02\x02\x03\x12\x03D\x16\x17\n\x89\x01\n\x04\x04\0\x03\x01\x12\
    \x04I\x02S\x03\x1a{\x20Condensed\x20representation\x20of\x20a\x20node\
    \x20and\x20its\x20subtree.\x20Only\x20present\x20for\n\x20`SCALAR`\x20[P\
    lanNode(s)][google.spanner.v1.PlanNode].\n\n\x0c\n\x05\x04\0\x03\x01\x01\
    \x12\x03I\n\x1d\nW\n\x06\x04\0\x03\x01\x02\0\x12\x03K\x04\x1b\x1aH\x20A\
    \x20string\x20representation\x20of\x20the\x20expression\x20subtree\x20ro\
    oted\x20at\x20this\x20node.\n\n\x0e\n\x07\x04\0\x03\x01\x02\0\x05\x12\
    \x03K\x04\n\n\x0e\n\x07\x04\0\x03\x01\x02\0\x01\x12\x03K\x0b\x16\n\x0e\n\
    \x07\x04\0\x03\x01\x02\0\x03\x12\x03K\x19\x1a\n\xb4\x02\n\x06\x04\0\x03\
    \x01\x02\x01\x12\x03R\x04&\x1a\xa4\x02\x20A\x20mapping\x20of\x20(subquer\
    y\x20variable\x20name)\x20->\x20(subquery\x20node\x20id)\x20for\x20cases\
    \n\x20where\x20the\x20`description`\x20string\x20of\x20this\x20node\x20r\
    eferences\x20a\x20`SCALAR`\n\x20subquery\x20contained\x20in\x20the\x20ex\
    pression\x20subtree\x20rooted\x20at\x20this\x20node.\x20The\n\x20referen\
    ced\x20`SCALAR`\x20subquery\x20may\x20not\x20necessarily\x20be\x20a\x20d\
    irect\x20child\x20of\n\x20this\x20node.\n\n\x0e\n\x07\x04\0\x03\x01\x02\
    \x01\x06\x12\x03R\x04\x16\n\x0e\n\x07\x04\0\x03\x01\x02\x01\x01\x12\x03R\
    \x17!\n\x0e\n\x07\x04\0\x03\x01\x02\x01\x03\x12\x03R$%\n]\n\x04\x04\0\
    \x02\0\x12\x03V\x02\x12\x1aP\x20The\x20`PlanNode`'s\x20index\x20in\x20[n\
    ode\x20list][google.spanner.v1.QueryPlan.plan_nodes].\n\n\x0c\n\x05\x04\
    \0\x02\0\x05\x12\x03V\x02\x07\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03V\x08\r\
    \n\x0c\n\x05\x04\0\x02\0\x03\x12\x03V\x10\x11\n\xc5\x02\n\x04\x04\0\x02\
    \x01\x12\x03]\x02\x10\x1a\xb7\x02\x20Used\x20to\x20determine\x20the\x20t\
    ype\x20of\x20node.\x20May\x20be\x20needed\x20for\x20visualizing\n\x20dif\
    ferent\x20kinds\x20of\x20nodes\x20differently.\x20For\x20example,\x20If\
    \x20the\x20node\x20is\x20a\n\x20[SCALAR][google.spanner.v1.PlanNode.Kind\
    .SCALAR]\x20node,\x20it\x20will\x20have\x20a\x20condensed\x20representat\
    ion\n\x20which\x20can\x20be\x20used\x20to\x20directly\x20embed\x20a\x20d\
    escription\x20of\x20the\x20node\x20in\x20its\n\x20parent.\n\n\x0c\n\x05\
    \x04\0\x02\x01\x06\x12\x03]\x02\x06\n\x0c\n\x05\x04\0\x02\x01\x01\x12\
    \x03]\x07\x0b\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03]\x0e\x0f\n-\n\x04\
    \x04\0\x02\x02\x12\x03`\x02\x1a\x1a\x20\x20The\x20display\x20name\x20for\
    \x20the\x20node.\n\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03`\x02\x08\n\x0c\
    \n\x05\x04\0\x02\x02\x01\x12\x03`\t\x15\n\x0c\n\x05\x04\0\x02\x02\x03\
    \x12\x03`\x18\x19\nR\n\x04\x04\0\x02\x03\x12\x03c\x02%\x1aE\x20List\x20o\
    f\x20child\x20node\x20`index`es\x20and\x20their\x20relationship\x20to\
    \x20this\x20parent.\n\n\x0c\n\x05\x04\0\x02\x03\x04\x12\x03c\x02\n\n\x0c\
    \n\x05\x04\0\x02\x03\x06\x12\x03c\x0b\x14\n\x0c\n\x05\x04\0\x02\x03\x01\
    \x12\x03c\x15\x20\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03c#$\nc\n\x04\x04\
    \0\x02\x04\x12\x03f\x02/\x1aV\x20Condensed\x20representation\x20for\x20[\
    SCALAR][google.spanner.v1.PlanNode.Kind.SCALAR]\x20nodes.\n\n\x0c\n\x05\
    \x04\0\x02\x04\x06\x12\x03f\x02\x15\n\x0c\n\x05\x04\0\x02\x04\x01\x12\
    \x03f\x16*\n\x0c\n\x05\x04\0\x02\x04\x03\x12\x03f-.\n\x90\x02\n\x04\x04\
    \0\x02\x05\x12\x03p\x02&\x1a\x82\x02\x20Attributes\x20relevant\x20to\x20\
    the\x20node\x20contained\x20in\x20a\x20group\x20of\x20key-value\x20pairs\
    .\n\x20For\x20example,\x20a\x20Parameter\x20Reference\x20node\x20could\
    \x20have\x20the\x20following\n\x20information\x20in\x20its\x20metadata:\
    \n\n\x20\x20\x20\x20\x20{\n\x20\x20\x20\x20\x20\x20\x20\"parameter_refer\
    ence\":\x20\"param1\",\n\x20\x20\x20\x20\x20\x20\x20\"parameter_type\":\
    \x20\"array\"\n\x20\x20\x20\x20\x20}\n\n\x0c\n\x05\x04\0\x02\x05\x06\x12\
    \x03p\x02\x18\n\x0c\n\x05\x04\0\x02\x05\x01\x12\x03p\x19!\n\x0c\n\x05\
    \x04\0\x02\x05\x03\x12\x03p$%\n\xfe\x01\n\x04\x04\0\x02\x06\x12\x03v\x02\
    -\x1a\xf0\x01\x20The\x20execution\x20statistics\x20associated\x20with\
    \x20the\x20node,\x20contained\x20in\x20a\x20group\x20of\n\x20key-value\
    \x20pairs.\x20Only\x20present\x20if\x20the\x20plan\x20was\x20returned\
    \x20as\x20a\x20result\x20of\x20a\n\x20profile\x20query.\x20For\x20exampl\
    e,\x20number\x20of\x20executions,\x20number\x20of\x20rows/time\x20per\n\
    \x20execution\x20etc.\n\n\x0c\n\x05\x04\0\x02\x06\x06\x12\x03v\x02\x18\n\
    \x0c\n\x05\x04\0\x02\x06\x01\x12\x03v\x19(\n\x0c\n\x05\x04\0\x02\x06\x03\
    \x12\x03v+,\nL\n\x02\x04\x01\x12\x04z\0\x7f\x01\x1a@\x20Contains\x20an\
    \x20ordered\x20list\x20of\x20nodes\x20appearing\x20in\x20the\x20query\
    \x20plan.\n\n\n\n\x03\x04\x01\x01\x12\x03z\x08\x11\n\xcd\x01\n\x04\x04\
    \x01\x02\0\x12\x03~\x02#\x1a\xbf\x01\x20The\x20nodes\x20in\x20the\x20que\
    ry\x20plan.\x20Plan\x20nodes\x20are\x20returned\x20in\x20pre-order\x20st\
    arting\n\x20with\x20the\x20plan\x20root.\x20Each\x20[PlanNode][google.sp\
    anner.v1.PlanNode]'s\x20`id`\x20corresponds\x20to\x20its\x20index\x20in\
    \n\x20`plan_nodes`.\n\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03~\x02\n\n\x0c\
    \n\x05\x04\x01\x02\0\x06\x12\x03~\x0b\x13\n\x0c\n\x05\x04\x01\x02\0\x01\
    \x12\x03~\x14\x1e\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03~!\"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()
    })
}