rustyspanner 0.1.1

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

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

#![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(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]

use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;

#[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
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // int32 index = 1;

    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;
    }

    pub fn get_index(&self) -> i32 {
        self.index
    }

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

    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;
    }

    pub fn get_kind(&self) -> PlanNode_Kind {
        self.kind
    }

    // string display_name = 3;

    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())
    }

    pub fn get_display_name(&self) -> &str {
        &self.display_name
    }

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

    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())
    }

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

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

    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())
    }

    pub fn get_short_representation(&self) -> &PlanNode_ShortRepresentation {
        self.short_representation.as_ref().unwrap_or_else(|| PlanNode_ShortRepresentation::default_instance())
    }

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

    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())
    }

    pub fn get_metadata(&self) -> &::protobuf::well_known_types::Struct {
        self.metadata.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Struct::default_instance())
    }

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

    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())
    }

    pub fn get_execution_stats(&self) -> &::protobuf::well_known_types::Struct {
        self.execution_stats.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Struct::default_instance())
    }
}

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, self.kind.value())?;
        }
        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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<PlanNode>(
                    "PlanNode",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static PlanNode {
        static mut instance: ::protobuf::lazy::Lazy<PlanNode> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const PlanNode,
        };
        unsafe {
            instance.get(PlanNode::new)
        }
    }
}

impl ::protobuf::Clear for PlanNode {
    fn clear(&mut self) {
        self.clear_index();
        self.clear_kind();
        self.clear_display_name();
        self.clear_child_links();
        self.clear_short_representation();
        self.clear_metadata();
        self.clear_execution_stats();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::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
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // int32 child_index = 1;

    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;
    }

    pub fn get_child_index(&self) -> i32 {
        self.child_index
    }

    // string type = 2;

    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())
    }

    pub fn get_field_type(&self) -> &str {
        &self.field_type
    }

    // string variable = 3;

    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())
    }

    pub fn get_variable(&self) -> &str {
        &self.variable
    }
}

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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<PlanNode_ChildLink>(
                    "PlanNode_ChildLink",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static PlanNode_ChildLink {
        static mut instance: ::protobuf::lazy::Lazy<PlanNode_ChildLink> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const PlanNode_ChildLink,
        };
        unsafe {
            instance.get(PlanNode_ChildLink::new)
        }
    }
}

impl ::protobuf::Clear for PlanNode_ChildLink {
    fn clear(&mut self) {
        self.clear_child_index();
        self.clear_field_type();
        self.clear_variable();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::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
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // string description = 1;

    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())
    }

    pub fn get_description(&self) -> &str {
        &self.description
    }

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

    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())
    }

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

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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<PlanNode_ShortRepresentation>(
                    "PlanNode_ShortRepresentation",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static PlanNode_ShortRepresentation {
        static mut instance: ::protobuf::lazy::Lazy<PlanNode_ShortRepresentation> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const PlanNode_ShortRepresentation,
        };
        unsafe {
            instance.get(PlanNode_ShortRepresentation::new)
        }
    }
}

impl ::protobuf::Clear for PlanNode_ShortRepresentation {
    fn clear(&mut self) {
        self.clear_description();
        self.clear_subqueries();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                ::protobuf::reflect::EnumDescriptor::new("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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
    }
}

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

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

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

    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())
    }

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

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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::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 mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            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::<QueryPlan>(
                    "QueryPlan",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

    fn default_instance() -> &'static QueryPlan {
        static mut instance: ::protobuf::lazy::Lazy<QueryPlan> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const QueryPlan,
        };
        unsafe {
            instance.get(QueryPlan::new)
        }
    }
}

impl ::protobuf::Clear for QueryPlan {
    fn clear(&mut self) {
        self.clear_plan_nodes();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::Message(self)
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\"google/spanner/v1/query_plan.proto\x12\x11google.spanner.v1\x1a\x1cg\
    oogle/api/annotations.proto\x1a\x1cgoogle/protobuf/struct.proto\"\x8e\
    \x06\n\x08PlanNode\x12\x14\n\x05index\x18\x01\x20\x01(\x05R\x05index\x12\
    4\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.Chil\
    dLinkR\nchildLinks\x12b\n\x14short_representation\x18\x05\x20\x01(\x0b2/\
    .google.spanner.v1.PlanNode.ShortRepresentationR\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\nsubqueries\x18\x02\x20\x03(\x0b2?.go\
    ogle.spanner.v1.PlanNode.ShortRepresentation.SubqueriesEntryR\nsubquerie\
    s\x1a=\n\x0fSubqueriesEntry\x12\x10\n\x03key\x18\x01\x20\x01(\tR\x03key\
    \x12\x14\n\x05value\x18\x02\x20\x01(\x05R\x05value:\x028\x01\"8\n\x04Kin\
    d\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\tplanNodesB\x97\x01\n\x15com.\
    google.spanner.v1B\x0eQueryPlanProtoP\x01Z8google.golang.org/genproto/go\
    ogleapis/spanner/v1;spanner\xaa\x02\x17Google.Cloud.Spanner.V1\xca\x02\
    \x17Google\\Cloud\\Spanner\\V1J\xb5-\n\x07\x12\x05\x0e\0\x80\x01\x01\n\
    \xbd\x04\n\x01\x0c\x12\x03\x0e\0\x122\xb2\x04\x20Copyright\x202018\x20Go\
    ogle\x20Inc.\n\n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Ve\
    rsion\x202.0\x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20t\
    his\x20file\x20except\x20in\x20compliance\x20with\x20the\x20License.\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\x20Un\
    less\x20required\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\
    \x20writing,\x20software\n\x20distributed\x20under\x20the\x20License\x20\
    is\x20distributed\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20\
    WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20expres\
    s\x20or\x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20specific\
    \x20language\x20governing\x20permissions\x20and\n\x20limitations\x20unde\
    r\x20the\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\x08\x19\n\t\n\x02\x03\
    \0\x12\x03\x12\x07%\n\t\n\x02\x03\x01\x12\x03\x13\x07%\n\x08\n\x01\x08\
    \x12\x03\x15\04\n\x0b\n\x04\x08\xe7\x07\0\x12\x03\x15\04\n\x0c\n\x05\x08\
    \xe7\x07\0\x02\x12\x03\x15\x07\x17\n\r\n\x06\x08\xe7\x07\0\x02\0\x12\x03\
    \x15\x07\x17\n\x0e\n\x07\x08\xe7\x07\0\x02\0\x01\x12\x03\x15\x07\x17\n\
    \x0c\n\x05\x08\xe7\x07\0\x07\x12\x03\x15\x1a3\n\x08\n\x01\x08\x12\x03\
    \x16\0O\n\x0b\n\x04\x08\xe7\x07\x01\x12\x03\x16\0O\n\x0c\n\x05\x08\xe7\
    \x07\x01\x02\x12\x03\x16\x07\x11\n\r\n\x06\x08\xe7\x07\x01\x02\0\x12\x03\
    \x16\x07\x11\n\x0e\n\x07\x08\xe7\x07\x01\x02\0\x01\x12\x03\x16\x07\x11\n\
    \x0c\n\x05\x08\xe7\x07\x01\x07\x12\x03\x16\x14N\n\x08\n\x01\x08\x12\x03\
    \x17\0\"\n\x0b\n\x04\x08\xe7\x07\x02\x12\x03\x17\0\"\n\x0c\n\x05\x08\xe7\
    \x07\x02\x02\x12\x03\x17\x07\x1a\n\r\n\x06\x08\xe7\x07\x02\x02\0\x12\x03\
    \x17\x07\x1a\n\x0e\n\x07\x08\xe7\x07\x02\x02\0\x01\x12\x03\x17\x07\x1a\n\
    \x0c\n\x05\x08\xe7\x07\x02\x03\x12\x03\x17\x1d!\n\x08\n\x01\x08\x12\x03\
    \x18\0/\n\x0b\n\x04\x08\xe7\x07\x03\x12\x03\x18\0/\n\x0c\n\x05\x08\xe7\
    \x07\x03\x02\x12\x03\x18\x07\x1b\n\r\n\x06\x08\xe7\x07\x03\x02\0\x12\x03\
    \x18\x07\x1b\n\x0e\n\x07\x08\xe7\x07\x03\x02\0\x01\x12\x03\x18\x07\x1b\n\
    \x0c\n\x05\x08\xe7\x07\x03\x07\x12\x03\x18\x1e.\n\x08\n\x01\x08\x12\x03\
    \x19\0.\n\x0b\n\x04\x08\xe7\x07\x04\x12\x03\x19\0.\n\x0c\n\x05\x08\xe7\
    \x07\x04\x02\x12\x03\x19\x07\x13\n\r\n\x06\x08\xe7\x07\x04\x02\0\x12\x03\
    \x19\x07\x13\n\x0e\n\x07\x08\xe7\x07\x04\x02\0\x01\x12\x03\x19\x07\x13\n\
    \x0c\n\x05\x08\xe7\x07\x04\x07\x12\x03\x19\x16-\n\x08\n\x01\x08\x12\x03\
    \x1a\04\n\x0b\n\x04\x08\xe7\x07\x05\x12\x03\x1a\04\n\x0c\n\x05\x08\xe7\
    \x07\x05\x02\x12\x03\x1a\x07\x14\n\r\n\x06\x08\xe7\x07\x05\x02\0\x12\x03\
    \x1a\x07\x14\n\x0e\n\x07\x08\xe7\x07\x05\x02\0\x01\x12\x03\x1a\x07\x14\n\
    \x0c\n\x05\x08\xe7\x07\x05\x07\x12\x03\x1a\x173\nw\n\x02\x04\0\x12\x04\
    \x1e\0x\x01\x1ak\x20Node\x20information\x20for\x20nodes\x20appearing\x20\
    in\x20a\x20[QueryPlan.plan_nodes][google.spanner.v1.QueryPlan.plan_nodes\
    ].\n\n\n\n\x03\x04\0\x01\x12\x03\x1e\x08\x10\n|\n\x04\x04\0\x03\0\x12\
    \x04!\x024\x03\x1an\x20Metadata\x20associated\x20with\x20a\x20parent-chi\
    ld\x20relationship\x20appearing\x20in\x20a\n\x20[PlanNode][google.spanne\
    r.v1.PlanNode].\n\n\x0c\n\x05\x04\0\x03\0\x01\x12\x03!\n\x13\n3\n\x06\
    \x04\0\x03\0\x02\0\x12\x03#\x04\x1a\x1a$\x20The\x20node\x20to\x20which\
    \x20the\x20link\x20points.\n\n\x0f\n\x07\x04\0\x03\0\x02\0\x04\x12\x04#\
    \x04!\x15\n\x0e\n\x07\x04\0\x03\0\x02\0\x05\x12\x03#\x04\t\n\x0e\n\x07\
    \x04\0\x03\0\x02\0\x01\x12\x03#\n\x15\n\x0e\n\x07\x04\0\x03\0\x02\0\x03\
    \x12\x03#\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,\x20\
    in\x20Hash\x20Joins\x20this\x20could\x20be\x20used\x20to\n\x20distinguis\
    h\x20between\x20the\x20build\x20child\x20and\x20the\x20probe\x20child,\
    \x20or\x20in\x20the\x20case\n\x20of\x20the\x20child\x20being\x20an\x20ou\
    tput\x20variable,\x20to\x20represent\x20the\x20tag\x20associated\n\x20wi\
    th\x20the\x20output\x20variable.\n\n\x0f\n\x07\x04\0\x03\0\x02\x01\x04\
    \x12\x04)\x04#\x1a\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\x033\x04\x18\x1a\xec\x03\x20Only\x20present\x20if\x20the\x20child\
    \x20node\x20is\x20[SCALAR][google.spanner.v1.PlanNode.Kind.SCALAR]\x20an\
    d\x20corresponds\n\x20to\x20an\x20output\x20variable\x20of\x20the\x20par\
    ent\x20node.\x20The\x20field\x20carries\x20the\x20name\x20of\n\x20the\
    \x20output\x20variable.\n\x20For\x20example,\x20a\x20`TableScan`\x20oper\
    ator\x20that\x20reads\x20rows\x20from\x20a\x20table\x20will\n\x20have\
    \x20child\x20links\x20to\x20the\x20`SCALAR`\x20nodes\x20representing\x20\
    the\x20output\x20variables\n\x20created\x20for\x20each\x20column\x20that\
    \x20is\x20read\x20by\x20the\x20operator.\x20The\x20corresponding\n\x20`v\
    ariable`\x20fields\x20will\x20be\x20set\x20to\x20the\x20variable\x20name\
    s\x20assigned\x20to\x20the\n\x20columns.\n\n\x0f\n\x07\x04\0\x03\0\x02\
    \x02\x04\x12\x043\x04)\x14\n\x0e\n\x07\x04\0\x03\0\x02\x02\x05\x12\x033\
    \x04\n\n\x0e\n\x07\x04\0\x03\0\x02\x02\x01\x12\x033\x0b\x13\n\x0e\n\x07\
    \x04\0\x03\0\x02\x02\x03\x12\x033\x16\x17\n\x89\x01\n\x04\x04\0\x03\x01\
    \x12\x048\x02B\x03\x1a{\x20Condensed\x20representation\x20of\x20a\x20nod\
    e\x20and\x20its\x20subtree.\x20Only\x20present\x20for\n\x20`SCALAR`\x20[\
    PlanNode(s)][google.spanner.v1.PlanNode].\n\n\x0c\n\x05\x04\0\x03\x01\
    \x01\x12\x038\n\x1d\nW\n\x06\x04\0\x03\x01\x02\0\x12\x03:\x04\x1b\x1aH\
    \x20A\x20string\x20representation\x20of\x20the\x20expression\x20subtree\
    \x20rooted\x20at\x20this\x20node.\n\n\x0f\n\x07\x04\0\x03\x01\x02\0\x04\
    \x12\x04:\x048\x1f\n\x0e\n\x07\x04\0\x03\x01\x02\0\x05\x12\x03:\x04\n\n\
    \x0e\n\x07\x04\0\x03\x01\x02\0\x01\x12\x03:\x0b\x16\n\x0e\n\x07\x04\0\
    \x03\x01\x02\0\x03\x12\x03:\x19\x1a\n\xb4\x02\n\x06\x04\0\x03\x01\x02\
    \x01\x12\x03A\x04&\x1a\xa4\x02\x20A\x20mapping\x20of\x20(subquery\x20var\
    iable\x20name)\x20->\x20(subquery\x20node\x20id)\x20for\x20cases\n\x20wh\
    ere\x20the\x20`description`\x20string\x20of\x20this\x20node\x20reference\
    s\x20a\x20`SCALAR`\n\x20subquery\x20contained\x20in\x20the\x20expression\
    \x20subtree\x20rooted\x20at\x20this\x20node.\x20The\n\x20referenced\x20`\
    SCALAR`\x20subquery\x20may\x20not\x20necessarily\x20be\x20a\x20direct\
    \x20child\x20of\n\x20this\x20node.\n\n\x0f\n\x07\x04\0\x03\x01\x02\x01\
    \x04\x12\x04A\x04:\x1b\n\x0e\n\x07\x04\0\x03\x01\x02\x01\x06\x12\x03A\
    \x04\x16\n\x0e\n\x07\x04\0\x03\x01\x02\x01\x01\x12\x03A\x17!\n\x0e\n\x07\
    \x04\0\x03\x01\x02\x01\x03\x12\x03A$%\n\x9d\x01\n\x04\x04\0\x04\0\x12\
    \x04F\x02T\x03\x1a\x8e\x01\x20The\x20kind\x20of\x20[PlanNode][google.spa\
    nner.v1.PlanNode].\x20Distinguishes\x20between\x20the\x20two\x20differen\
    t\x20kinds\x20of\n\x20nodes\x20that\x20can\x20appear\x20in\x20a\x20query\
    \x20plan.\n\n\x0c\n\x05\x04\0\x04\0\x01\x12\x03F\x07\x0b\n\x1f\n\x06\x04\
    \0\x04\0\x02\0\x12\x03H\x04\x19\x1a\x10\x20Not\x20specified.\n\n\x0e\n\
    \x07\x04\0\x04\0\x02\0\x01\x12\x03H\x04\x14\n\x0e\n\x07\x04\0\x04\0\x02\
    \0\x02\x12\x03H\x17\x18\n\xe5\x01\n\x06\x04\0\x04\0\x02\x01\x12\x03M\x04\
    \x13\x1a\xd5\x01\x20Denotes\x20a\x20Relational\x20operator\x20node\x20in\
    \x20the\x20expression\x20tree.\x20Relational\n\x20operators\x20represent\
    \x20iterative\x20processing\x20of\x20rows\x20during\x20query\x20executio\
    n.\n\x20For\x20example,\x20a\x20`TableScan`\x20operation\x20that\x20read\
    s\x20rows\x20from\x20a\x20table.\n\n\x0e\n\x07\x04\0\x04\0\x02\x01\x01\
    \x12\x03M\x04\x0e\n\x0e\n\x07\x04\0\x04\0\x02\x01\x02\x12\x03M\x11\x12\n\
    \xf7\x01\n\x06\x04\0\x04\0\x02\x02\x12\x03S\x04\x0f\x1a\xe7\x01\x20Denot\
    es\x20a\x20Scalar\x20node\x20in\x20the\x20expression\x20tree.\x20Scalar\
    \x20nodes\x20represent\n\x20non-iterable\x20entities\x20in\x20the\x20que\
    ry\x20plan.\x20For\x20example,\x20constants\x20or\n\x20arithmetic\x20ope\
    rators\x20appearing\x20inside\x20predicate\x20expressions\x20or\x20refer\
    ences\n\x20to\x20column\x20names.\n\n\x0e\n\x07\x04\0\x04\0\x02\x02\x01\
    \x12\x03S\x04\n\n\x0e\n\x07\x04\0\x04\0\x02\x02\x02\x12\x03S\r\x0e\n]\n\
    \x04\x04\0\x02\0\x12\x03W\x02\x12\x1aP\x20The\x20`PlanNode`'s\x20index\
    \x20in\x20[node\x20list][google.spanner.v1.QueryPlan.plan_nodes].\n\n\r\
    \n\x05\x04\0\x02\0\x04\x12\x04W\x02T\x03\n\x0c\n\x05\x04\0\x02\0\x05\x12\
    \x03W\x02\x07\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03W\x08\r\n\x0c\n\x05\x04\
    \0\x02\0\x03\x12\x03W\x10\x11\n\xc5\x02\n\x04\x04\0\x02\x01\x12\x03^\x02\
    \x10\x1a\xb7\x02\x20Used\x20to\x20determine\x20the\x20type\x20of\x20node\
    .\x20May\x20be\x20needed\x20for\x20visualizing\n\x20different\x20kinds\
    \x20of\x20nodes\x20differently.\x20For\x20example,\x20If\x20the\x20node\
    \x20is\x20a\n\x20[SCALAR][google.spanner.v1.PlanNode.Kind.SCALAR]\x20nod\
    e,\x20it\x20will\x20have\x20a\x20condensed\x20representation\n\x20which\
    \x20can\x20be\x20used\x20to\x20directly\x20embed\x20a\x20description\x20\
    of\x20the\x20node\x20in\x20its\n\x20parent.\n\n\r\n\x05\x04\0\x02\x01\
    \x04\x12\x04^\x02W\x12\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\x03a\x02\x1a\x1a\x20\
    \x20The\x20display\x20name\x20for\x20the\x20node.\n\n\r\n\x05\x04\0\x02\
    \x02\x04\x12\x04a\x02^\x10\n\x0c\n\x05\x04\0\x02\x02\x05\x12\x03a\x02\
    \x08\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03a\t\x15\n\x0c\n\x05\x04\0\x02\
    \x02\x03\x12\x03a\x18\x19\nR\n\x04\x04\0\x02\x03\x12\x03d\x02%\x1aE\x20L\
    ist\x20of\x20child\x20node\x20`index`es\x20and\x20their\x20relationship\
    \x20to\x20this\x20parent.\n\n\x0c\n\x05\x04\0\x02\x03\x04\x12\x03d\x02\n\
    \n\x0c\n\x05\x04\0\x02\x03\x06\x12\x03d\x0b\x14\n\x0c\n\x05\x04\0\x02\
    \x03\x01\x12\x03d\x15\x20\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03d#$\nc\n\
    \x04\x04\0\x02\x04\x12\x03g\x02/\x1aV\x20Condensed\x20representation\x20\
    for\x20[SCALAR][google.spanner.v1.PlanNode.Kind.SCALAR]\x20nodes.\n\n\r\
    \n\x05\x04\0\x02\x04\x04\x12\x04g\x02d%\n\x0c\n\x05\x04\0\x02\x04\x06\
    \x12\x03g\x02\x15\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x03g\x16*\n\x0c\n\
    \x05\x04\0\x02\x04\x03\x12\x03g-.\n\x90\x02\n\x04\x04\0\x02\x05\x12\x03q\
    \x02&\x1a\x82\x02\x20Attributes\x20relevant\x20to\x20the\x20node\x20cont\
    ained\x20in\x20a\x20group\x20of\x20key-value\x20pairs.\n\x20For\x20examp\
    le,\x20a\x20Parameter\x20Reference\x20node\x20could\x20have\x20the\x20fo\
    llowing\n\x20information\x20in\x20its\x20metadata:\n\n\x20\x20\x20\x20\
    \x20{\n\x20\x20\x20\x20\x20\x20\x20\"parameter_reference\":\x20\"param1\
    \",\n\x20\x20\x20\x20\x20\x20\x20\"parameter_type\":\x20\"array\"\n\x20\
    \x20\x20\x20\x20}\n\n\r\n\x05\x04\0\x02\x05\x04\x12\x04q\x02g/\n\x0c\n\
    \x05\x04\0\x02\x05\x06\x12\x03q\x02\x18\n\x0c\n\x05\x04\0\x02\x05\x01\
    \x12\x03q\x19!\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x03q$%\n\xfe\x01\n\x04\
    \x04\0\x02\x06\x12\x03w\x02-\x1a\xf0\x01\x20The\x20execution\x20statisti\
    cs\x20associated\x20with\x20the\x20node,\x20contained\x20in\x20a\x20grou\
    p\x20of\n\x20key-value\x20pairs.\x20Only\x20present\x20if\x20the\x20plan\
    \x20was\x20returned\x20as\x20a\x20result\x20of\x20a\n\x20profile\x20quer\
    y.\x20For\x20example,\x20number\x20of\x20executions,\x20number\x20of\x20\
    rows/time\x20per\n\x20execution\x20etc.\n\n\r\n\x05\x04\0\x02\x06\x04\
    \x12\x04w\x02q&\n\x0c\n\x05\x04\0\x02\x06\x06\x12\x03w\x02\x18\n\x0c\n\
    \x05\x04\0\x02\x06\x01\x12\x03w\x19(\n\x0c\n\x05\x04\0\x02\x06\x03\x12\
    \x03w+,\nM\n\x02\x04\x01\x12\x05{\0\x80\x01\x01\x1a@\x20Contains\x20an\
    \x20ordered\x20list\x20of\x20nodes\x20appearing\x20in\x20the\x20query\
    \x20plan.\n\n\n\n\x03\x04\x01\x01\x12\x03{\x08\x11\n\xcd\x01\n\x04\x04\
    \x01\x02\0\x12\x03\x7f\x02#\x1a\xbf\x01\x20The\x20nodes\x20in\x20the\x20\
    query\x20plan.\x20Plan\x20nodes\x20are\x20returned\x20in\x20pre-order\
    \x20starting\n\x20with\x20the\x20plan\x20root.\x20Each\x20[PlanNode][goo\
    gle.spanner.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\x7f\
    \x02\n\n\x0c\n\x05\x04\x01\x02\0\x06\x12\x03\x7f\x0b\x13\n\x0c\n\x05\x04\
    \x01\x02\0\x01\x12\x03\x7f\x14\x1e\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\
    \x7f!\"b\x06proto3\
";

static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
    lock: ::protobuf::lazy::ONCE_INIT,
    ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
};

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

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