google-cloud-rust-raw 0.14.0

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

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

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

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `google/spanner/admin/database/v1/spanner_database_admin.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 Database {
    // message fields
    pub name: ::std::string::String,
    pub state: Database_State,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string name = 1;


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

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

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

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

    // .google.spanner.admin.database.v1.Database.State state = 2;


    pub fn get_state(&self) -> Database_State {
        self.state
    }
    pub fn clear_state(&mut self) {
        self.state = Database_State::STATE_UNSPECIFIED;
    }

    // Param is passed by value, moved
    pub fn set_state(&mut self, v: Database_State) {
        self.state = v;
    }
}

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if self.state != Database_State::STATE_UNSPECIFIED {
            os.write_enum(2, ::protobuf::ProtobufEnum::value(&self.state))?;
        }
        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() -> Database {
        Database::new()
    }

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

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

impl ::protobuf::Clear for Database {
    fn clear(&mut self) {
        self.name.clear();
        self.state = Database_State::STATE_UNSPECIFIED;
        self.unknown_fields.clear();
    }
}

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

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

#[derive(Clone,PartialEq,Eq,Debug,Hash)]
pub enum Database_State {
    STATE_UNSPECIFIED = 0,
    CREATING = 1,
    READY = 2,
}

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

    fn from_i32(value: i32) -> ::std::option::Option<Database_State> {
        match value {
            0 => ::std::option::Option::Some(Database_State::STATE_UNSPECIFIED),
            1 => ::std::option::Option::Some(Database_State::CREATING),
            2 => ::std::option::Option::Some(Database_State::READY),
            _ => ::std::option::Option::None
        }
    }

    fn values() -> &'static [Self] {
        static values: &'static [Database_State] = &[
            Database_State::STATE_UNSPECIFIED,
            Database_State::CREATING,
            Database_State::READY,
        ];
        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::<Database_State>("Database.State", file_descriptor_proto())
        })
    }
}

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

impl ::std::default::Default for Database_State {
    fn default() -> Self {
        Database_State::STATE_UNSPECIFIED
    }
}

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

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

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

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

    // string parent = 1;


    pub fn get_parent(&self) -> &str {
        &self.parent
    }
    pub fn clear_parent(&mut self) {
        self.parent.clear();
    }

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

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

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

    // int32 page_size = 3;


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

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

    // string page_token = 4;


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

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

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

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

impl ::protobuf::Message for ListDatabasesRequest {
    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.parent)?;
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_int32()?;
                    self.page_size = tmp;
                },
                4 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.page_token)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

    fn new() -> ListDatabasesRequest {
        ListDatabasesRequest::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>(
                "parent",
                |m: &ListDatabasesRequest| { &m.parent },
                |m: &mut ListDatabasesRequest| { &mut m.parent },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
                "page_size",
                |m: &ListDatabasesRequest| { &m.page_size },
                |m: &mut ListDatabasesRequest| { &mut m.page_size },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "page_token",
                |m: &ListDatabasesRequest| { &m.page_token },
                |m: &mut ListDatabasesRequest| { &mut m.page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListDatabasesRequest>(
                "ListDatabasesRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

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

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

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

    // repeated .google.spanner.admin.database.v1.Database databases = 1;


    pub fn get_databases(&self) -> &[Database] {
        &self.databases
    }
    pub fn clear_databases(&mut self) {
        self.databases.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_databases(&mut self) -> &mut ::protobuf::RepeatedField<Database> {
        &mut self.databases
    }

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

    // string next_page_token = 2;


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

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

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

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

impl ::protobuf::Message for ListDatabasesResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.databases {
            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.databases)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.next_page_token)?;
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

    fn new() -> ListDatabasesResponse {
        ListDatabasesResponse::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<Database>>(
                "databases",
                |m: &ListDatabasesResponse| { &m.databases },
                |m: &mut ListDatabasesResponse| { &mut m.databases },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "next_page_token",
                |m: &ListDatabasesResponse| { &m.next_page_token },
                |m: &mut ListDatabasesResponse| { &mut m.next_page_token },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<ListDatabasesResponse>(
                "ListDatabasesResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct CreateDatabaseRequest {
    // message fields
    pub parent: ::std::string::String,
    pub create_statement: ::std::string::String,
    pub extra_statements: ::protobuf::RepeatedField<::std::string::String>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string parent = 1;


    pub fn get_parent(&self) -> &str {
        &self.parent
    }
    pub fn clear_parent(&mut self) {
        self.parent.clear();
    }

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

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

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

    // string create_statement = 2;


    pub fn get_create_statement(&self) -> &str {
        &self.create_statement
    }
    pub fn clear_create_statement(&mut self) {
        self.create_statement.clear();
    }

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

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

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

    // repeated string extra_statements = 3;


    pub fn get_extra_statements(&self) -> &[::std::string::String] {
        &self.extra_statements
    }
    pub fn clear_extra_statements(&mut self) {
        self.extra_statements.clear();
    }

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

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

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

impl ::protobuf::Message for CreateDatabaseRequest {
    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.parent)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.create_statement)?;
                },
                3 => {
                    ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.extra_statements)?;
                },
                _ => {
                    ::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.parent.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.parent);
        }
        if !self.create_statement.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.create_statement);
        }
        for value in &self.extra_statements {
            my_size += ::protobuf::rt::string_size(3, &value);
        };
        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.parent.is_empty() {
            os.write_string(1, &self.parent)?;
        }
        if !self.create_statement.is_empty() {
            os.write_string(2, &self.create_statement)?;
        }
        for v in &self.extra_statements {
            os.write_string(3, &v)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> CreateDatabaseRequest {
        CreateDatabaseRequest::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>(
                "parent",
                |m: &CreateDatabaseRequest| { &m.parent },
                |m: &mut CreateDatabaseRequest| { &mut m.parent },
            ));
            fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "create_statement",
                |m: &CreateDatabaseRequest| { &m.create_statement },
                |m: &mut CreateDatabaseRequest| { &mut m.create_statement },
            ));
            fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                "extra_statements",
                |m: &CreateDatabaseRequest| { &m.extra_statements },
                |m: &mut CreateDatabaseRequest| { &mut m.extra_statements },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<CreateDatabaseRequest>(
                "CreateDatabaseRequest",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

impl ::protobuf::Clear for CreateDatabaseRequest {
    fn clear(&mut self) {
        self.parent.clear();
        self.create_statement.clear();
        self.extra_statements.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // string database = 1;


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

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

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.database.is_empty() {
            os.write_string(1, &self.database)?;
        }
        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() -> CreateDatabaseMetadata {
        CreateDatabaseMetadata::new()
    }

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

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

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

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

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

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

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

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

    // string name = 1;


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct UpdateDatabaseDdlRequest {
    // message fields
    pub database: ::std::string::String,
    pub statements: ::protobuf::RepeatedField<::std::string::String>,
    pub operation_id: ::std::string::String,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string database = 1;


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

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

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

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

    // repeated string statements = 2;


    pub fn get_statements(&self) -> &[::std::string::String] {
        &self.statements
    }
    pub fn clear_statements(&mut self) {
        self.statements.clear();
    }

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

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

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

    // string operation_id = 3;


    pub fn get_operation_id(&self) -> &str {
        &self.operation_id
    }
    pub fn clear_operation_id(&mut self) {
        self.operation_id.clear();
    }

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

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.database.is_empty() {
            os.write_string(1, &self.database)?;
        }
        for v in &self.statements {
            os.write_string(2, &v)?;
        };
        if !self.operation_id.is_empty() {
            os.write_string(3, &self.operation_id)?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

impl ::protobuf::Clear for UpdateDatabaseDdlRequest {
    fn clear(&mut self) {
        self.database.clear();
        self.statements.clear();
        self.operation_id.clear();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct UpdateDatabaseDdlMetadata {
    // message fields
    pub database: ::std::string::String,
    pub statements: ::protobuf::RepeatedField<::std::string::String>,
    pub commit_timestamps: ::protobuf::RepeatedField<::protobuf::well_known_types::Timestamp>,
    // special fields
    pub unknown_fields: ::protobuf::UnknownFields,
    pub cached_size: ::protobuf::CachedSize,
}

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

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

    // string database = 1;


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

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

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

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

    // repeated string statements = 2;


    pub fn get_statements(&self) -> &[::std::string::String] {
        &self.statements
    }
    pub fn clear_statements(&mut self) {
        self.statements.clear();
    }

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

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

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

    // repeated .google.protobuf.Timestamp commit_timestamps = 3;


    pub fn get_commit_timestamps(&self) -> &[::protobuf::well_known_types::Timestamp] {
        &self.commit_timestamps
    }
    pub fn clear_commit_timestamps(&mut self) {
        self.commit_timestamps.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_commit_timestamps(&mut self) -> &mut ::protobuf::RepeatedField<::protobuf::well_known_types::Timestamp> {
        &mut self.commit_timestamps
    }

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

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

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

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if !self.database.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.database);
        }
        for value in &self.statements {
            my_size += ::protobuf::rt::string_size(2, &value);
        };
        for value in &self.commit_timestamps {
            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<()> {
        if !self.database.is_empty() {
            os.write_string(1, &self.database)?;
        }
        for v in &self.statements {
            os.write_string(2, &v)?;
        };
        for v in &self.commit_timestamps {
            os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

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

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

impl ::protobuf::Clear for UpdateDatabaseDdlMetadata {
    fn clear(&mut self) {
        self.database.clear();
        self.statements.clear();
        self.commit_timestamps.clear();
        self.unknown_fields.clear();
    }
}

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

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

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

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

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

    // string database = 1;


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

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

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.database.is_empty() {
            os.write_string(1, &self.database)?;
        }
        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() -> DropDatabaseRequest {
        DropDatabaseRequest::new()
    }

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

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

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

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

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

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

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

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

    // string database = 1;


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

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

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

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

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
        if !self.database.is_empty() {
            os.write_string(1, &self.database)?;
        }
        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() -> GetDatabaseDdlRequest {
        GetDatabaseDdlRequest::new()
    }

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

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

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

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

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

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

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

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

    // repeated string statements = 1;


    pub fn get_statements(&self) -> &[::std::string::String] {
        &self.statements
    }
    pub fn clear_statements(&mut self) {
        self.statements.clear();
    }

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

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

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

impl ::protobuf::Message for GetDatabaseDdlResponse {
    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_repeated_string_into(wire_type, is, &mut self.statements)?;
                },
                _ => {
                    ::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.statements {
            my_size += ::protobuf::rt::string_size(1, &value);
        };
        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.statements {
            os.write_string(1, &v)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> GetDatabaseDdlResponse {
        GetDatabaseDdlResponse::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::ProtobufTypeString>(
                "statements",
                |m: &GetDatabaseDdlResponse| { &m.statements },
                |m: &mut GetDatabaseDdlResponse| { &mut m.statements },
            ));
            ::protobuf::reflect::MessageDescriptor::new_pb_name::<GetDatabaseDdlResponse>(
                "GetDatabaseDdlResponse",
                fields,
                file_descriptor_proto()
            )
        })
    }

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

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

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n=google/spanner/admin/database/v1/spanner_database_admin.proto\x12\x20\
    google.spanner.admin.database.v1\x1a\x1cgoogle/api/annotations.proto\x1a\
    \x17google/api/client.proto\x1a\x1fgoogle/api/field_behavior.proto\x1a\
    \x19google/api/resource.proto\x1a\x1egoogle/iam/v1/iam_policy.proto\x1a\
    \x1agoogle/iam/v1/policy.proto\x1a#google/longrunning/operations.proto\
    \x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoogle/protobuf/timestamp.pro\
    to\"\x83\x02\n\x08Database\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\
    \x12F\n\x05state\x18\x02\x20\x01(\x0e20.google.spanner.admin.database.v1\
    .Database.StateR\x05state\"7\n\x05State\x12\x15\n\x11STATE_UNSPECIFIED\
    \x10\0\x12\x0c\n\x08CREATING\x10\x01\x12\t\n\x05READY\x10\x02:b\xeaA_\n\
    \x1fspanner.googleapis.com/Database\x12<projects/{project}/instances/{in\
    stance}/databases/{database}\"\x93\x01\n\x14ListDatabasesRequest\x12?\n\
    \x06parent\x18\x01\x20\x01(\tR\x06parentB'\xfaA!\n\x1fspanner.googleapis\
    .com/Instance\xe0A\x02\x12\x1b\n\tpage_size\x18\x03\x20\x01(\x05R\x08pag\
    eSize\x12\x1d\n\npage_token\x18\x04\x20\x01(\tR\tpageToken\"\x89\x01\n\
    \x15ListDatabasesResponse\x12H\n\tdatabases\x18\x01\x20\x03(\x0b2*.googl\
    e.spanner.admin.database.v1.DatabaseR\tdatabases\x12&\n\x0fnext_page_tok\
    en\x18\x02\x20\x01(\tR\rnextPageToken\"\xb3\x01\n\x15CreateDatabaseReque\
    st\x12?\n\x06parent\x18\x01\x20\x01(\tR\x06parentB'\xfaA!\n\x1fspanner.g\
    oogleapis.com/Instance\xe0A\x02\x12.\n\x10create_statement\x18\x02\x20\
    \x01(\tR\x0fcreateStatementB\x03\xe0A\x02\x12)\n\x10extra_statements\x18\
    \x03\x20\x03(\tR\x0fextraStatements\"Z\n\x16CreateDatabaseMetadata\x12@\
    \n\x08database\x18\x01\x20\x01(\tR\x08databaseB$\xfaA!\n\x1fspanner.goog\
    leapis.com/Database\"Q\n\x12GetDatabaseRequest\x12;\n\x04name\x18\x01\
    \x20\x01(\tR\x04nameB'\xfaA!\n\x1fspanner.googleapis.com/Database\xe0A\
    \x02\"\xa7\x01\n\x18UpdateDatabaseDdlRequest\x12C\n\x08database\x18\x01\
    \x20\x01(\tR\x08databaseB'\xfaA!\n\x1fspanner.googleapis.com/Database\
    \xe0A\x02\x12#\n\nstatements\x18\x02\x20\x03(\tR\nstatementsB\x03\xe0A\
    \x02\x12!\n\x0coperation_id\x18\x03\x20\x01(\tR\x0boperationId\"\xc6\x01\
    \n\x19UpdateDatabaseDdlMetadata\x12@\n\x08database\x18\x01\x20\x01(\tR\
    \x08databaseB$\xfaA!\n\x1fspanner.googleapis.com/Database\x12\x1e\n\nsta\
    tements\x18\x02\x20\x03(\tR\nstatements\x12G\n\x11commit_timestamps\x18\
    \x03\x20\x03(\x0b2\x1a.google.protobuf.TimestampR\x10commitTimestamps\"Z\
    \n\x13DropDatabaseRequest\x12C\n\x08database\x18\x01\x20\x01(\tR\x08data\
    baseB'\xfaA!\n\x1fspanner.googleapis.com/Database\xe0A\x02\"\\\n\x15GetD\
    atabaseDdlRequest\x12C\n\x08database\x18\x01\x20\x01(\tR\x08databaseB'\
    \xfaA!\n\x1fspanner.googleapis.com/Database\xe0A\x02\"8\n\x16GetDatabase\
    DdlResponse\x12\x1e\n\nstatements\x18\x01\x20\x03(\tR\nstatements2\xad\
    \x11\n\rDatabaseAdmin\x12\xc0\x01\n\rListDatabases\x126.google.spanner.a\
    dmin.database.v1.ListDatabasesRequest\x1a7.google.spanner.admin.database\
    .v1.ListDatabasesResponse\">\x82\xd3\xe4\x93\x02/\x12-/v1/{parent=projec\
    ts/*/instances/*}/databases\xdaA\x06parent\x12\xa4\x02\n\x0eCreateDataba\
    se\x127.google.spanner.admin.database.v1.CreateDatabaseRequest\x1a\x1d.g\
    oogle.longrunning.Operation\"\xb9\x01\xcaAd\n)google.spanner.admin.datab\
    ase.v1.Database\x127google.spanner.admin.database.v1.CreateDatabaseMetad\
    ata\x82\xd3\xe4\x93\x022\"-/v1/{parent=projects/*/instances/*}/databases\
    :\x01*\xdaA\x17parent,create_statement\x12\xad\x01\n\x0bGetDatabase\x124\
    .google.spanner.admin.database.v1.GetDatabaseRequest\x1a*.google.spanner\
    .admin.database.v1.Database\"<\x82\xd3\xe4\x93\x02/\x12-/v1/{name=projec\
    ts/*/instances/*/databases/*}\xdaA\x04name\x12\x9d\x02\n\x11UpdateDataba\
    seDdl\x12:.google.spanner.admin.database.v1.UpdateDatabaseDdlRequest\x1a\
    \x1d.google.longrunning.Operation\"\xac\x01\xcaAS\n\x15google.protobuf.E\
    mpty\x12:google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata\x82\
    \xd3\xe4\x93\x02:25/v1/{database=projects/*/instances/*/databases/*}/ddl\
    :\x01*\xdaA\x13database,statements\x12\xa3\x01\n\x0cDropDatabase\x125.go\
    ogle.spanner.admin.database.v1.DropDatabaseRequest\x1a\x16.google.protob\
    uf.Empty\"D\x82\xd3\xe4\x93\x023*1/v1/{database=projects/*/instances/*/d\
    atabases/*}\xdaA\x08database\x12\xcd\x01\n\x0eGetDatabaseDdl\x127.google\
    .spanner.admin.database.v1.GetDatabaseDdlRequest\x1a8.google.spanner.adm\
    in.database.v1.GetDatabaseDdlResponse\"H\x82\xd3\xe4\x93\x027\x125/v1/{d\
    atabase=projects/*/instances/*/databases/*}/ddl\xdaA\x08database\x12\xeb\
    \x01\n\x0cSetIamPolicy\x12\".google.iam.v1.SetIamPolicyRequest\x1a\x15.g\
    oogle.iam.v1.Policy\"\x9f\x01\x82\xd3\xe4\x93\x02\x86\x01\">/v1/{resourc\
    e=projects/*/instances/*/databases/*}:setIamPolicy:\x01*ZA\"</v1/{resour\
    ce=projects/*/instances/*/backups/*}:setIamPolicy:\x01*\xdaA\x0fresource\
    ,policy\x12\xe4\x01\n\x0cGetIamPolicy\x12\".google.iam.v1.GetIamPolicyRe\
    quest\x1a\x15.google.iam.v1.Policy\"\x98\x01\x82\xd3\xe4\x93\x02\x86\x01\
    \">/v1/{resource=projects/*/instances/*/databases/*}:getIamPolicy:\x01*Z\
    A\"</v1/{resource=projects/*/instances/*/backups/*}:getIamPolicy:\x01*\
    \xdaA\x08resource\x12\x9c\x02\n\x12TestIamPermissions\x12(.google.iam.v1\
    .TestIamPermissionsRequest\x1a).google.iam.v1.TestIamPermissionsResponse\
    \"\xb0\x01\x82\xd3\xe4\x93\x02\x92\x01\"D/v1/{resource=projects/*/instan\
    ces/*/databases/*}:testIamPermissions:\x01*ZG\"B/v1/{resource=projects/*\
    /instances/*/backups/*}:testIamPermissions:\x01*\xdaA\x14resource,permis\
    sions\x1ax\xd2A\\https://www.googleapis.com/auth/cloud-platform,https://\
    www.googleapis.com/auth/spanner.admin\xcaA\x16spanner.googleapis.comB\
    \xac\x02\n$com.google.spanner.admin.database.v1B\x19SpannerDatabaseAdmin\
    ProtoP\x01ZHgoogle.golang.org/genproto/googleapis/spanner/admin/database\
    /v1;database\xaa\x02&Google.Cloud.Spanner.Admin.Database.V1\xca\x02&Goog\
    le\\Cloud\\Spanner\\Admin\\Database\\V1\xeaAJ\n\x1fspanner.googleapis.co\
    m/Instance\x12'projects/{project}/instances/{instance}J\xced\n\x07\x12\
    \x05\x0f\0\x92\x03\x01\n\xbe\x04\n\x01\x0c\x12\x03\x0f\0\x122\xb3\x04\
    \x20Copyright\x202019\x20Google\x20LLC.\n\n\x20Licensed\x20under\x20the\
    \x20Apache\x20License,\x20Version\x202.0\x20(the\x20\"License\");\n\x20y\
    ou\x20may\x20not\x20use\x20this\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/li\
    censes/LICENSE-2.0\n\n\x20Unless\x20required\x20by\x20applicable\x20law\
    \x20or\x20agreed\x20to\x20in\x20writing,\x20software\n\x20distributed\
    \x20under\x20the\x20License\x20is\x20distributed\x20on\x20an\x20\"AS\x20\
    IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\x20OR\x20CONDITIONS\x20OF\x20A\
    NY\x20KIND,\x20either\x20express\x20or\x20implied.\n\x20See\x20the\x20Li\
    cense\x20for\x20the\x20specific\x20language\x20governing\x20permissions\
    \x20and\n\x20limitations\x20under\x20the\x20License.\n\n\n\x08\n\x01\x02\
    \x12\x03\x11\0)\n\t\n\x02\x03\0\x12\x03\x13\0&\n\t\n\x02\x03\x01\x12\x03\
    \x14\0!\n\t\n\x02\x03\x02\x12\x03\x15\0)\n\t\n\x02\x03\x03\x12\x03\x16\0\
    #\n\t\n\x02\x03\x04\x12\x03\x17\0(\n\t\n\x02\x03\x05\x12\x03\x18\0$\n\t\
    \n\x02\x03\x06\x12\x03\x19\0-\n\t\n\x02\x03\x07\x12\x03\x1a\0%\n\t\n\x02\
    \x03\x08\x12\x03\x1b\0)\n\x08\n\x01\x08\x12\x03\x1d\0C\n\t\n\x02\x08%\
    \x12\x03\x1d\0C\n\x08\n\x01\x08\x12\x03\x1e\0_\n\t\n\x02\x08\x0b\x12\x03\
    \x1e\0_\n\x08\n\x01\x08\x12\x03\x1f\0\"\n\t\n\x02\x08\n\x12\x03\x1f\0\"\
    \n\x08\n\x01\x08\x12\x03\x20\0:\n\t\n\x02\x08\x08\x12\x03\x20\0:\n\x08\n\
    \x01\x08\x12\x03!\0=\n\t\n\x02\x08\x01\x12\x03!\0=\n\x08\n\x01\x08\x12\
    \x03\"\0E\n\t\n\x02\x08)\x12\x03\"\0E\n\t\n\x01\x08\x12\x04'\0*\x02\n\
    \xc1\x01\n\x04\x08\x9d\x08\0\x12\x04'\0*\x02\x1a\xb2\x01\x20The\x20Insta\
    nce\x20resource\x20is\x20defined\x20in\x20`google.spanner.admin.instance\
    .v1`.\n\x20Because\x20this\x20is\x20a\x20separate,\x20independent\x20API\
    \x20(technically),\x20we\x20redefine\n\x20the\x20resource\x20name\x20pat\
    tern\x20here.\n\n\xc9\x01\n\x02\x06\0\x12\x051\0\xba\x01\x01\x1a\xbb\x01\
    \x20Cloud\x20Spanner\x20Database\x20Admin\x20API\n\n\x20The\x20Cloud\x20\
    Spanner\x20Database\x20Admin\x20API\x20can\x20be\x20used\x20to\x20create\
    ,\x20drop,\x20and\n\x20list\x20databases.\x20It\x20also\x20enables\x20up\
    dating\x20the\x20schema\x20of\x20pre-existing\n\x20databases.\n\n\n\n\
    \x03\x06\0\x01\x12\x031\x08\x15\n\n\n\x03\x06\0\x03\x12\x032\x02>\n\x0c\
    \n\x05\x06\0\x03\x99\x08\x12\x032\x02>\n\x0b\n\x03\x06\0\x03\x12\x043\
    \x0256\n\r\n\x05\x06\0\x03\x9a\x08\x12\x043\x0256\n.\n\x04\x06\0\x02\0\
    \x12\x048\x02=\x03\x1a\x20\x20Lists\x20Cloud\x20Spanner\x20databases.\n\
    \n\x0c\n\x05\x06\0\x02\0\x01\x12\x038\x06\x13\n\x0c\n\x05\x06\0\x02\0\
    \x02\x12\x038\x14(\n\x0c\n\x05\x06\0\x02\0\x03\x12\x0383H\n\r\n\x05\x06\
    \0\x02\0\x04\x12\x049\x04;\x06\n\x11\n\t\x06\0\x02\0\x04\xb0\xca\xbc\"\
    \x12\x049\x04;\x06\n\x0c\n\x05\x06\0\x02\0\x04\x12\x03<\x044\n\x0f\n\x08\
    \x06\0\x02\0\x04\x9b\x08\0\x12\x03<\x044\n\xc8\x04\n\x04\x06\0\x02\x01\
    \x12\x04G\x02R\x03\x1a\xb9\x04\x20Creates\x20a\x20new\x20Cloud\x20Spanne\
    r\x20database\x20and\x20starts\x20to\x20prepare\x20it\x20for\x20serving.\
    \n\x20The\x20returned\x20[long-running\x20operation][google.longrunning.\
    Operation]\x20will\n\x20have\x20a\x20name\x20of\x20the\x20format\x20`<da\
    tabase_name>/operations/<operation_id>`\x20and\n\x20can\x20be\x20used\
    \x20to\x20track\x20preparation\x20of\x20the\x20database.\x20The\n\x20[me\
    tadata][google.longrunning.Operation.metadata]\x20field\x20type\x20is\n\
    \x20[CreateDatabaseMetadata][google.spanner.admin.database.v1.CreateData\
    baseMetadata].\n\x20The\x20[response][google.longrunning.Operation.respo\
    nse]\x20field\x20type\x20is\n\x20[Database][google.spanner.admin.databas\
    e.v1.Database],\x20if\x20successful.\n\n\x0c\n\x05\x06\0\x02\x01\x01\x12\
    \x03G\x06\x14\n\x0c\n\x05\x06\0\x02\x01\x02\x12\x03G\x15*\n\x0c\n\x05\
    \x06\0\x02\x01\x03\x12\x03H\x0f+\n\r\n\x05\x06\0\x02\x01\x04\x12\x04I\
    \x04L\x06\n\x11\n\t\x06\0\x02\x01\x04\xb0\xca\xbc\"\x12\x04I\x04L\x06\n\
    \x0c\n\x05\x06\0\x02\x01\x04\x12\x03M\x04E\n\x0f\n\x08\x06\0\x02\x01\x04\
    \x9b\x08\0\x12\x03M\x04E\n\r\n\x05\x06\0\x02\x01\x04\x12\x04N\x04Q\x06\n\
    \x0f\n\x07\x06\0\x02\x01\x04\x99\x08\x12\x04N\x04Q\x06\n;\n\x04\x06\0\
    \x02\x02\x12\x04U\x02Z\x03\x1a-\x20Gets\x20the\x20state\x20of\x20a\x20Cl\
    oud\x20Spanner\x20database.\n\n\x0c\n\x05\x06\0\x02\x02\x01\x12\x03U\x06\
    \x11\n\x0c\n\x05\x06\0\x02\x02\x02\x12\x03U\x12$\n\x0c\n\x05\x06\0\x02\
    \x02\x03\x12\x03U/7\n\r\n\x05\x06\0\x02\x02\x04\x12\x04V\x04X\x06\n\x11\
    \n\t\x06\0\x02\x02\x04\xb0\xca\xbc\"\x12\x04V\x04X\x06\n\x0c\n\x05\x06\0\
    \x02\x02\x04\x12\x03Y\x042\n\x0f\n\x08\x06\0\x02\x02\x04\x9b\x08\0\x12\
    \x03Y\x042\n\x8a\x04\n\x04\x06\0\x02\x03\x12\x04d\x02o\x03\x1a\xfb\x03\
    \x20Updates\x20the\x20schema\x20of\x20a\x20Cloud\x20Spanner\x20database\
    \x20by\n\x20creating/altering/dropping\x20tables,\x20columns,\x20indexes\
    ,\x20etc.\x20The\x20returned\n\x20[long-running\x20operation][google.lon\
    grunning.Operation]\x20will\x20have\x20a\x20name\x20of\n\x20the\x20forma\
    t\x20`<database_name>/operations/<operation_id>`\x20and\x20can\x20be\x20\
    used\x20to\n\x20track\x20execution\x20of\x20the\x20schema\x20change(s).\
    \x20The\n\x20[metadata][google.longrunning.Operation.metadata]\x20field\
    \x20type\x20is\n\x20[UpdateDatabaseDdlMetadata][google.spanner.admin.dat\
    abase.v1.UpdateDatabaseDdlMetadata].\n\x20The\x20operation\x20has\x20no\
    \x20response.\n\n\x0c\n\x05\x06\0\x02\x03\x01\x12\x03d\x06\x17\n\x0c\n\
    \x05\x06\0\x02\x03\x02\x12\x03d\x180\n\x0c\n\x05\x06\0\x02\x03\x03\x12\
    \x03e\x0f+\n\r\n\x05\x06\0\x02\x03\x04\x12\x04f\x04i\x06\n\x11\n\t\x06\0\
    \x02\x03\x04\xb0\xca\xbc\"\x12\x04f\x04i\x06\n\x0c\n\x05\x06\0\x02\x03\
    \x04\x12\x03j\x04A\n\x0f\n\x08\x06\0\x02\x03\x04\x9b\x08\0\x12\x03j\x04A\
    \n\r\n\x05\x06\0\x02\x03\x04\x12\x04k\x04n\x06\n\x0f\n\x07\x06\0\x02\x03\
    \x04\x99\x08\x12\x04k\x04n\x06\n=\n\x04\x06\0\x02\x04\x12\x04r\x02w\x03\
    \x1a/\x20Drops\x20(aka\x20deletes)\x20a\x20Cloud\x20Spanner\x20database.\
    \n\n\x0c\n\x05\x06\0\x02\x04\x01\x12\x03r\x06\x12\n\x0c\n\x05\x06\0\x02\
    \x04\x02\x12\x03r\x13&\n\x0c\n\x05\x06\0\x02\x04\x03\x12\x03r1F\n\r\n\
    \x05\x06\0\x02\x04\x04\x12\x04s\x04u\x06\n\x11\n\t\x06\0\x02\x04\x04\xb0\
    \xca\xbc\"\x12\x04s\x04u\x06\n\x0c\n\x05\x06\0\x02\x04\x04\x12\x03v\x046\
    \n\x0f\n\x08\x06\0\x02\x04\x04\x9b\x08\0\x12\x03v\x046\n\xeb\x01\n\x04\
    \x06\0\x02\x05\x12\x05|\x02\x81\x01\x03\x1a\xdb\x01\x20Returns\x20the\
    \x20schema\x20of\x20a\x20Cloud\x20Spanner\x20database\x20as\x20a\x20list\
    \x20of\x20formatted\n\x20DDL\x20statements.\x20This\x20method\x20does\
    \x20not\x20show\x20pending\x20schema\x20updates,\x20those\x20may\n\x20be\
    \x20queried\x20using\x20the\x20[Operations][google.longrunning.Operation\
    s]\x20API.\n\n\x0c\n\x05\x06\0\x02\x05\x01\x12\x03|\x06\x14\n\x0c\n\x05\
    \x06\0\x02\x05\x02\x12\x03|\x15*\n\x0c\n\x05\x06\0\x02\x05\x03\x12\x03|5\
    K\n\r\n\x05\x06\0\x02\x05\x04\x12\x04}\x04\x7f\x06\n\x11\n\t\x06\0\x02\
    \x05\x04\xb0\xca\xbc\"\x12\x04}\x04\x7f\x06\n\r\n\x05\x06\0\x02\x05\x04\
    \x12\x04\x80\x01\x046\n\x10\n\x08\x06\0\x02\x05\x04\x9b\x08\0\x12\x04\
    \x80\x01\x046\n\xe9\x01\n\x04\x06\0\x02\x06\x12\x06\x88\x01\x02\x93\x01\
    \x03\x1a\xd8\x01\x20Sets\x20the\x20access\x20control\x20policy\x20on\x20\
    a\x20database\x20resource.\n\x20Replaces\x20any\x20existing\x20policy.\n\
    \n\x20Authorization\x20requires\x20`spanner.databases.setIamPolicy`\n\
    \x20permission\x20on\x20[resource][google.iam.v1.SetIamPolicyRequest.res\
    ource].\n\n\r\n\x05\x06\0\x02\x06\x01\x12\x04\x88\x01\x06\x12\n\r\n\x05\
    \x06\0\x02\x06\x02\x12\x04\x88\x01\x134\n\r\n\x05\x06\0\x02\x06\x03\x12\
    \x04\x89\x01\x0f#\n\x0f\n\x05\x06\0\x02\x06\x04\x12\x06\x8a\x01\x04\x91\
    \x01\x06\n\x13\n\t\x06\0\x02\x06\x04\xb0\xca\xbc\"\x12\x06\x8a\x01\x04\
    \x91\x01\x06\n\r\n\x05\x06\0\x02\x06\x04\x12\x04\x92\x01\x04=\n\x10\n\
    \x08\x06\0\x02\x06\x04\x9b\x08\0\x12\x04\x92\x01\x04=\n\x9a\x02\n\x04\
    \x06\0\x02\x07\x12\x06\x9b\x01\x02\xa6\x01\x03\x1a\x89\x02\x20Gets\x20th\
    e\x20access\x20control\x20policy\x20for\x20a\x20database\x20resource.\n\
    \x20Returns\x20an\x20empty\x20policy\x20if\x20a\x20database\x20exists\
    \x20but\x20does\n\x20not\x20have\x20a\x20policy\x20set.\n\n\x20Authoriza\
    tion\x20requires\x20`spanner.databases.getIamPolicy`\x20permission\x20on\
    \n\x20[resource][google.iam.v1.GetIamPolicyRequest.resource].\n\n\r\n\
    \x05\x06\0\x02\x07\x01\x12\x04\x9b\x01\x06\x12\n\r\n\x05\x06\0\x02\x07\
    \x02\x12\x04\x9b\x01\x134\n\r\n\x05\x06\0\x02\x07\x03\x12\x04\x9c\x01\
    \x0f#\n\x0f\n\x05\x06\0\x02\x07\x04\x12\x06\x9d\x01\x04\xa4\x01\x06\n\
    \x13\n\t\x06\0\x02\x07\x04\xb0\xca\xbc\"\x12\x06\x9d\x01\x04\xa4\x01\x06\
    \n\r\n\x05\x06\0\x02\x07\x04\x12\x04\xa5\x01\x046\n\x10\n\x08\x06\0\x02\
    \x07\x04\x9b\x08\0\x12\x04\xa5\x01\x046\n\xce\x02\n\x04\x06\0\x02\x08\
    \x12\x06\xae\x01\x02\xb9\x01\x03\x1a\xbd\x02\x20Returns\x20permissions\
    \x20that\x20the\x20caller\x20has\x20on\x20the\x20specified\x20database\
    \x20resource.\n\n\x20Attempting\x20this\x20RPC\x20on\x20a\x20non-existen\
    t\x20Cloud\x20Spanner\x20database\x20will\n\x20result\x20in\x20a\x20NOT_\
    FOUND\x20error\x20if\x20the\x20user\x20has\n\x20`spanner.databases.list`\
    \x20permission\x20on\x20the\x20containing\x20Cloud\n\x20Spanner\x20insta\
    nce.\x20Otherwise\x20returns\x20an\x20empty\x20set\x20of\x20permissions.\
    \n\n\r\n\x05\x06\0\x02\x08\x01\x12\x04\xae\x01\x06\x18\n\r\n\x05\x06\0\
    \x02\x08\x02\x12\x04\xae\x01\x19@\n\r\n\x05\x06\0\x02\x08\x03\x12\x04\
    \xaf\x01\x0f7\n\x0f\n\x05\x06\0\x02\x08\x04\x12\x06\xb0\x01\x04\xb7\x01\
    \x06\n\x13\n\t\x06\0\x02\x08\x04\xb0\xca\xbc\"\x12\x06\xb0\x01\x04\xb7\
    \x01\x06\n\r\n\x05\x06\0\x02\x08\x04\x12\x04\xb8\x01\x04B\n\x10\n\x08\
    \x06\0\x02\x08\x04\x9b\x08\0\x12\x04\xb8\x01\x04B\n)\n\x02\x04\0\x12\x06\
    \xbd\x01\0\xd9\x01\x01\x1a\x1b\x20A\x20Cloud\x20Spanner\x20database.\n\n\
    \x0b\n\x03\x04\0\x01\x12\x04\xbd\x01\x08\x10\n\r\n\x03\x04\0\x07\x12\x06\
    \xbe\x01\x02\xc1\x01\x04\n\x0f\n\x05\x04\0\x07\x9d\x08\x12\x06\xbe\x01\
    \x02\xc1\x01\x04\n>\n\x04\x04\0\x04\0\x12\x06\xc4\x01\x02\xce\x01\x03\
    \x1a.\x20Indicates\x20the\x20current\x20state\x20of\x20the\x20database.\
    \n\n\r\n\x05\x04\0\x04\0\x01\x12\x04\xc4\x01\x07\x0c\n\x20\n\x06\x04\0\
    \x04\0\x02\0\x12\x04\xc6\x01\x04\x1a\x1a\x10\x20Not\x20specified.\n\n\
    \x0f\n\x07\x04\0\x04\0\x02\0\x01\x12\x04\xc6\x01\x04\x15\n\x0f\n\x07\x04\
    \0\x04\0\x02\0\x02\x12\x04\xc6\x01\x18\x19\n\x85\x01\n\x06\x04\0\x04\0\
    \x02\x01\x12\x04\xca\x01\x04\x11\x1au\x20The\x20database\x20is\x20still\
    \x20being\x20created.\x20Operations\x20on\x20the\x20database\x20may\x20f\
    ail\n\x20with\x20`FAILED_PRECONDITION`\x20in\x20this\x20state.\n\n\x0f\n\
    \x07\x04\0\x04\0\x02\x01\x01\x12\x04\xca\x01\x04\x0c\n\x0f\n\x07\x04\0\
    \x04\0\x02\x01\x02\x12\x04\xca\x01\x0f\x10\nB\n\x06\x04\0\x04\0\x02\x02\
    \x12\x04\xcd\x01\x04\x0e\x1a2\x20The\x20database\x20is\x20fully\x20creat\
    ed\x20and\x20ready\x20for\x20use.\n\n\x0f\n\x07\x04\0\x04\0\x02\x02\x01\
    \x12\x04\xcd\x01\x04\t\n\x0f\n\x07\x04\0\x04\0\x02\x02\x02\x12\x04\xcd\
    \x01\x0c\r\n\x9d\x02\n\x04\x04\0\x02\0\x12\x04\xd5\x01\x02\x12\x1a\x8e\
    \x02\x20Required.\x20The\x20name\x20of\x20the\x20database.\x20Values\x20\
    are\x20of\x20the\x20form\n\x20`projects/<project>/instances/<instance>/d\
    atabases/<database>`,\n\x20where\x20`<database>`\x20is\x20as\x20specifie\
    d\x20in\x20the\x20`CREATE\x20DATABASE`\n\x20statement.\x20This\x20name\
    \x20can\x20be\x20passed\x20to\x20other\x20API\x20methods\x20to\n\x20iden\
    tify\x20the\x20database.\n\n\r\n\x05\x04\0\x02\0\x05\x12\x04\xd5\x01\x02\
    \x08\n\r\n\x05\x04\0\x02\0\x01\x12\x04\xd5\x01\t\r\n\r\n\x05\x04\0\x02\0\
    \x03\x12\x04\xd5\x01\x10\x11\n8\n\x04\x04\0\x02\x01\x12\x04\xd8\x01\x02\
    \x12\x1a*\x20Output\x20only.\x20The\x20current\x20database\x20state.\n\n\
    \r\n\x05\x04\0\x02\x01\x06\x12\x04\xd8\x01\x02\x07\n\r\n\x05\x04\0\x02\
    \x01\x01\x12\x04\xd8\x01\x08\r\n\r\n\x05\x04\0\x02\x01\x03\x12\x04\xd8\
    \x01\x10\x11\no\n\x02\x04\x01\x12\x06\xdd\x01\0\xf0\x01\x01\x1aa\x20The\
    \x20request\x20for\n\x20[ListDatabases][google.spanner.admin.database.v1\
    .DatabaseAdmin.ListDatabases].\n\n\x0b\n\x03\x04\x01\x01\x12\x04\xdd\x01\
    \x08\x1c\n\x8d\x01\n\x04\x04\x01\x02\0\x12\x06\xe0\x01\x02\xe5\x01\x04\
    \x1a}\x20Required.\x20The\x20instance\x20whose\x20databases\x20should\
    \x20be\x20listed.\n\x20Values\x20are\x20of\x20the\x20form\x20`projects/<\
    project>/instances/<instance>`.\n\n\r\n\x05\x04\x01\x02\0\x05\x12\x04\
    \xe0\x01\x02\x08\n\r\n\x05\x04\x01\x02\0\x01\x12\x04\xe0\x01\t\x0f\n\r\n\
    \x05\x04\x01\x02\0\x03\x12\x04\xe0\x01\x12\x13\n\x0f\n\x05\x04\x01\x02\0\
    \x08\x12\x06\xe0\x01\x14\xe5\x01\x03\n\x10\n\x08\x04\x01\x02\0\x08\x9c\
    \x08\0\x12\x04\xe1\x01\x04*\n\x11\n\x07\x04\x01\x02\0\x08\x9f\x08\x12\
    \x06\xe2\x01\x04\xe4\x01\x05\n\x86\x01\n\x04\x04\x01\x02\x01\x12\x04\xe9\
    \x01\x02\x16\x1ax\x20Number\x20of\x20databases\x20to\x20be\x20returned\
    \x20in\x20the\x20response.\x20If\x200\x20or\x20less,\n\x20defaults\x20to\
    \x20the\x20server's\x20maximum\x20allowed\x20page\x20size.\n\n\r\n\x05\
    \x04\x01\x02\x01\x05\x12\x04\xe9\x01\x02\x07\n\r\n\x05\x04\x01\x02\x01\
    \x01\x12\x04\xe9\x01\x08\x11\n\r\n\x05\x04\x01\x02\x01\x03\x12\x04\xe9\
    \x01\x14\x15\n\xfa\x01\n\x04\x04\x01\x02\x02\x12\x04\xef\x01\x02\x18\x1a\
    \xeb\x01\x20If\x20non-empty,\x20`page_token`\x20should\x20contain\x20a\n\
    \x20[next_page_token][google.spanner.admin.database.v1.ListDatabasesResp\
    onse.next_page_token]\n\x20from\x20a\x20previous\n\x20[ListDatabasesResp\
    onse][google.spanner.admin.database.v1.ListDatabasesResponse].\n\n\r\n\
    \x05\x04\x01\x02\x02\x05\x12\x04\xef\x01\x02\x08\n\r\n\x05\x04\x01\x02\
    \x02\x01\x12\x04\xef\x01\t\x13\n\r\n\x05\x04\x01\x02\x02\x03\x12\x04\xef\
    \x01\x16\x17\np\n\x02\x04\x02\x12\x06\xf4\x01\0\xfc\x01\x01\x1ab\x20The\
    \x20response\x20for\n\x20[ListDatabases][google.spanner.admin.database.v\
    1.DatabaseAdmin.ListDatabases].\n\n\x0b\n\x03\x04\x02\x01\x12\x04\xf4\
    \x01\x08\x1d\n3\n\x04\x04\x02\x02\0\x12\x04\xf6\x01\x02\"\x1a%\x20Databa\
    ses\x20that\x20matched\x20the\x20request.\n\n\r\n\x05\x04\x02\x02\0\x04\
    \x12\x04\xf6\x01\x02\n\n\r\n\x05\x04\x02\x02\0\x06\x12\x04\xf6\x01\x0b\
    \x13\n\r\n\x05\x04\x02\x02\0\x01\x12\x04\xf6\x01\x14\x1d\n\r\n\x05\x04\
    \x02\x02\0\x03\x12\x04\xf6\x01\x20!\n\xbc\x01\n\x04\x04\x02\x02\x01\x12\
    \x04\xfb\x01\x02\x1d\x1a\xad\x01\x20`next_page_token`\x20can\x20be\x20se\
    nt\x20in\x20a\x20subsequent\n\x20[ListDatabases][google.spanner.admin.da\
    tabase.v1.DatabaseAdmin.ListDatabases]\n\x20call\x20to\x20fetch\x20more\
    \x20of\x20the\x20matching\x20databases.\n\n\r\n\x05\x04\x02\x02\x01\x05\
    \x12\x04\xfb\x01\x02\x08\n\r\n\x05\x04\x02\x02\x01\x01\x12\x04\xfb\x01\t\
    \x18\n\r\n\x05\x04\x02\x02\x01\x03\x12\x04\xfb\x01\x1b\x1c\nq\n\x02\x04\
    \x03\x12\x06\x80\x02\0\x96\x02\x01\x1ac\x20The\x20request\x20for\n\x20[C\
    reateDatabase][google.spanner.admin.database.v1.DatabaseAdmin.CreateData\
    base].\n\n\x0b\n\x03\x04\x03\x01\x12\x04\x80\x02\x08\x1d\n\x9a\x01\n\x04\
    \x04\x03\x02\0\x12\x06\x83\x02\x02\x88\x02\x04\x1a\x89\x01\x20Required.\
    \x20The\x20name\x20of\x20the\x20instance\x20that\x20will\x20serve\x20the\
    \x20new\x20database.\n\x20Values\x20are\x20of\x20the\x20form\x20`project\
    s/<project>/instances/<instance>`.\n\n\r\n\x05\x04\x03\x02\0\x05\x12\x04\
    \x83\x02\x02\x08\n\r\n\x05\x04\x03\x02\0\x01\x12\x04\x83\x02\t\x0f\n\r\n\
    \x05\x04\x03\x02\0\x03\x12\x04\x83\x02\x12\x13\n\x0f\n\x05\x04\x03\x02\0\
    \x08\x12\x06\x83\x02\x14\x88\x02\x03\n\x10\n\x08\x04\x03\x02\0\x08\x9c\
    \x08\0\x12\x04\x84\x02\x04*\n\x11\n\x07\x04\x03\x02\0\x08\x9f\x08\x12\
    \x06\x85\x02\x04\x87\x02\x05\n\xe6\x02\n\x04\x04\x03\x02\x01\x12\x04\x8f\
    \x02\x02G\x1a\xd7\x02\x20Required.\x20A\x20`CREATE\x20DATABASE`\x20state\
    ment,\x20which\x20specifies\x20the\x20ID\x20of\x20the\n\x20new\x20databa\
    se.\x20\x20The\x20database\x20ID\x20must\x20conform\x20to\x20the\x20regu\
    lar\x20expression\n\x20`[a-z][a-z0-9_\\-]*[a-z0-9]`\x20and\x20be\x20betw\
    een\x202\x20and\x2030\x20characters\x20in\x20length.\n\x20If\x20the\x20d\
    atabase\x20ID\x20is\x20a\x20reserved\x20word\x20or\x20if\x20it\x20contai\
    ns\x20a\x20hyphen,\x20the\n\x20database\x20ID\x20must\x20be\x20enclosed\
    \x20in\x20backticks\x20(``\x20`\x20``).\n\n\r\n\x05\x04\x03\x02\x01\x05\
    \x12\x04\x8f\x02\x02\x08\n\r\n\x05\x04\x03\x02\x01\x01\x12\x04\x8f\x02\t\
    \x19\n\r\n\x05\x04\x03\x02\x01\x03\x12\x04\x8f\x02\x1c\x1d\n\r\n\x05\x04\
    \x03\x02\x01\x08\x12\x04\x8f\x02\x1eF\n\x10\n\x08\x04\x03\x02\x01\x08\
    \x9c\x08\0\x12\x04\x8f\x02\x1fE\n\x97\x02\n\x04\x04\x03\x02\x02\x12\x04\
    \x95\x02\x02'\x1a\x88\x02\x20An\x20optional\x20list\x20of\x20DDL\x20stat\
    ements\x20to\x20run\x20inside\x20the\x20newly\x20created\n\x20database.\
    \x20Statements\x20can\x20create\x20tables,\x20indexes,\x20etc.\x20These\
    \n\x20statements\x20execute\x20atomically\x20with\x20the\x20creation\x20\
    of\x20the\x20database:\n\x20if\x20there\x20is\x20an\x20error\x20in\x20an\
    y\x20statement,\x20the\x20database\x20is\x20not\x20created.\n\n\r\n\x05\
    \x04\x03\x02\x02\x04\x12\x04\x95\x02\x02\n\n\r\n\x05\x04\x03\x02\x02\x05\
    \x12\x04\x95\x02\x0b\x11\n\r\n\x05\x04\x03\x02\x02\x01\x12\x04\x95\x02\
    \x12\"\n\r\n\x05\x04\x03\x02\x02\x03\x12\x04\x95\x02%&\n\x8d\x01\n\x02\
    \x04\x04\x12\x06\x9a\x02\0\x9f\x02\x01\x1a\x7f\x20Metadata\x20type\x20fo\
    r\x20the\x20operation\x20returned\x20by\n\x20[CreateDatabase][google.spa\
    nner.admin.database.v1.DatabaseAdmin.CreateDatabase].\n\n\x0b\n\x03\x04\
    \x04\x01\x12\x04\x9a\x02\x08\x1e\n-\n\x04\x04\x04\x02\0\x12\x06\x9c\x02\
    \x02\x9e\x02\x05\x1a\x1d\x20The\x20database\x20being\x20created.\n\n\r\n\
    \x05\x04\x04\x02\0\x05\x12\x04\x9c\x02\x02\x08\n\r\n\x05\x04\x04\x02\0\
    \x01\x12\x04\x9c\x02\t\x11\n\r\n\x05\x04\x04\x02\0\x03\x12\x04\x9c\x02\
    \x14\x15\n\x0f\n\x05\x04\x04\x02\0\x08\x12\x06\x9c\x02\x16\x9e\x02\x04\n\
    \x11\n\x07\x04\x04\x02\0\x08\x9f\x08\x12\x06\x9c\x02\x17\x9e\x02\x03\nk\
    \n\x02\x04\x05\x12\x06\xa3\x02\0\xac\x02\x01\x1a]\x20The\x20request\x20f\
    or\n\x20[GetDatabase][google.spanner.admin.database.v1.DatabaseAdmin.Get\
    Database].\n\n\x0b\n\x03\x04\x05\x01\x12\x04\xa3\x02\x08\x1a\n\x98\x01\n\
    \x04\x04\x05\x02\0\x12\x06\xa6\x02\x02\xab\x02\x04\x1a\x87\x01\x20Requir\
    ed.\x20The\x20name\x20of\x20the\x20requested\x20database.\x20Values\x20a\
    re\x20of\x20the\x20form\n\x20`projects/<project>/instances/<instance>/da\
    tabases/<database>`.\n\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\xa6\x02\x02\
    \x08\n\r\n\x05\x04\x05\x02\0\x01\x12\x04\xa6\x02\t\r\n\r\n\x05\x04\x05\
    \x02\0\x03\x12\x04\xa6\x02\x10\x11\n\x0f\n\x05\x04\x05\x02\0\x08\x12\x06\
    \xa6\x02\x12\xab\x02\x03\n\x10\n\x08\x04\x05\x02\0\x08\x9c\x08\0\x12\x04\
    \xa7\x02\x04*\n\x11\n\x07\x04\x05\x02\0\x08\x9f\x08\x12\x06\xa8\x02\x04\
    \xaa\x02\x05\n\x99\x07\n\x02\x04\x06\x12\x06\xbe\x02\0\xe0\x02\x01\x1a\
    \x8a\x07\x20Enqueues\x20the\x20given\x20DDL\x20statements\x20to\x20be\
    \x20applied,\x20in\x20order\x20but\x20not\n\x20necessarily\x20all\x20at\
    \x20once,\x20to\x20the\x20database\x20schema\x20at\x20some\x20point\x20(\
    or\n\x20points)\x20in\x20the\x20future.\x20The\x20server\x20checks\x20th\
    at\x20the\x20statements\n\x20are\x20executable\x20(syntactically\x20vali\
    d,\x20name\x20tables\x20that\x20exist,\x20etc.)\n\x20before\x20enqueuein\
    g\x20them,\x20but\x20they\x20may\x20still\x20fail\x20upon\n\x20later\x20\
    execution\x20(e.g.,\x20if\x20a\x20statement\x20from\x20another\x20batch\
    \x20of\n\x20statements\x20is\x20applied\x20first\x20and\x20it\x20conflic\
    ts\x20in\x20some\x20way,\x20or\x20if\n\x20there\x20is\x20some\x20data-re\
    lated\x20problem\x20like\x20a\x20`NULL`\x20value\x20in\x20a\x20column\
    \x20to\n\x20which\x20`NOT\x20NULL`\x20would\x20be\x20added).\x20If\x20a\
    \x20statement\x20fails,\x20all\n\x20subsequent\x20statements\x20in\x20th\
    e\x20batch\x20are\x20automatically\x20cancelled.\n\n\x20Each\x20batch\
    \x20of\x20statements\x20is\x20assigned\x20a\x20name\x20which\x20can\x20b\
    e\x20used\x20with\n\x20the\x20[Operations][google.longrunning.Operations\
    ]\x20API\x20to\x20monitor\n\x20progress.\x20See\x20the\n\x20[operation_i\
    d][google.spanner.admin.database.v1.UpdateDatabaseDdlRequest.operation_i\
    d]\n\x20field\x20for\x20more\x20details.\n\n\x0b\n\x03\x04\x06\x01\x12\
    \x04\xbe\x02\x08\x20\n3\n\x04\x04\x06\x02\0\x12\x06\xc0\x02\x02\xc5\x02\
    \x04\x1a#\x20Required.\x20The\x20database\x20to\x20update.\n\n\r\n\x05\
    \x04\x06\x02\0\x05\x12\x04\xc0\x02\x02\x08\n\r\n\x05\x04\x06\x02\0\x01\
    \x12\x04\xc0\x02\t\x11\n\r\n\x05\x04\x06\x02\0\x03\x12\x04\xc0\x02\x14\
    \x15\n\x0f\n\x05\x04\x06\x02\0\x08\x12\x06\xc0\x02\x16\xc5\x02\x03\n\x10\
    \n\x08\x04\x06\x02\0\x08\x9c\x08\0\x12\x04\xc1\x02\x04*\n\x11\n\x07\x04\
    \x06\x02\0\x08\x9f\x08\x12\x06\xc2\x02\x04\xc4\x02\x05\nG\n\x04\x04\x06\
    \x02\x01\x12\x04\xc8\x02\x02J\x1a9\x20Required.\x20DDL\x20statements\x20\
    to\x20be\x20applied\x20to\x20the\x20database.\n\n\r\n\x05\x04\x06\x02\
    \x01\x04\x12\x04\xc8\x02\x02\n\n\r\n\x05\x04\x06\x02\x01\x05\x12\x04\xc8\
    \x02\x0b\x11\n\r\n\x05\x04\x06\x02\x01\x01\x12\x04\xc8\x02\x12\x1c\n\r\n\
    \x05\x04\x06\x02\x01\x03\x12\x04\xc8\x02\x1f\x20\n\r\n\x05\x04\x06\x02\
    \x01\x08\x12\x04\xc8\x02!I\n\x10\n\x08\x04\x06\x02\x01\x08\x9c\x08\0\x12\
    \x04\xc8\x02\"H\n\xe6\x08\n\x04\x04\x06\x02\x02\x12\x04\xdf\x02\x02\x1a\
    \x1a\xd7\x08\x20If\x20empty,\x20the\x20new\x20update\x20request\x20is\
    \x20assigned\x20an\n\x20automatically-generated\x20operation\x20ID.\x20O\
    therwise,\x20`operation_id`\n\x20is\x20used\x20to\x20construct\x20the\
    \x20name\x20of\x20the\x20resulting\n\x20[Operation][google.longrunning.O\
    peration].\n\n\x20Specifying\x20an\x20explicit\x20operation\x20ID\x20sim\
    plifies\x20determining\n\x20whether\x20the\x20statements\x20were\x20exec\
    uted\x20in\x20the\x20event\x20that\x20the\n\x20[UpdateDatabaseDdl][googl\
    e.spanner.admin.database.v1.DatabaseAdmin.UpdateDatabaseDdl]\n\x20call\
    \x20is\x20replayed,\x20or\x20the\x20return\x20value\x20is\x20otherwise\
    \x20lost:\x20the\n\x20[database][google.spanner.admin.database.v1.Update\
    DatabaseDdlRequest.database]\n\x20and\x20`operation_id`\x20fields\x20can\
    \x20be\x20combined\x20to\x20form\x20the\n\x20[name][google.longrunning.O\
    peration.name]\x20of\x20the\x20resulting\n\x20[longrunning.Operation][go\
    ogle.longrunning.Operation]:\n\x20`<database>/operations/<operation_id>`\
    .\n\n\x20`operation_id`\x20should\x20be\x20unique\x20within\x20the\x20da\
    tabase,\x20and\x20must\x20be\n\x20a\x20valid\x20identifier:\x20`[a-z][a-\
    z0-9_]*`.\x20Note\x20that\n\x20automatically-generated\x20operation\x20I\
    Ds\x20always\x20begin\x20with\x20an\n\x20underscore.\x20If\x20the\x20nam\
    ed\x20operation\x20already\x20exists,\n\x20[UpdateDatabaseDdl][google.sp\
    anner.admin.database.v1.DatabaseAdmin.UpdateDatabaseDdl]\n\x20returns\
    \x20`ALREADY_EXISTS`.\n\n\r\n\x05\x04\x06\x02\x02\x05\x12\x04\xdf\x02\
    \x02\x08\n\r\n\x05\x04\x06\x02\x02\x01\x12\x04\xdf\x02\t\x15\n\r\n\x05\
    \x04\x06\x02\x02\x03\x12\x04\xdf\x02\x18\x19\n\x94\x01\n\x02\x04\x07\x12\
    \x06\xe4\x02\0\xf2\x02\x01\x1a\x85\x01\x20Metadata\x20type\x20for\x20the\
    \x20operation\x20returned\x20by\n\x20[UpdateDatabaseDdl][google.spanner.\
    admin.database.v1.DatabaseAdmin.UpdateDatabaseDdl].\n\n\x0b\n\x03\x04\
    \x07\x01\x12\x04\xe4\x02\x08!\n.\n\x04\x04\x07\x02\0\x12\x06\xe6\x02\x02\
    \xe8\x02\x05\x1a\x1e\x20The\x20database\x20being\x20modified.\n\n\r\n\
    \x05\x04\x07\x02\0\x05\x12\x04\xe6\x02\x02\x08\n\r\n\x05\x04\x07\x02\0\
    \x01\x12\x04\xe6\x02\t\x11\n\r\n\x05\x04\x07\x02\0\x03\x12\x04\xe6\x02\
    \x14\x15\n\x0f\n\x05\x04\x07\x02\0\x08\x12\x06\xe6\x02\x16\xe8\x02\x04\n\
    \x11\n\x07\x04\x07\x02\0\x08\x9f\x08\x12\x06\xe6\x02\x17\xe8\x02\x03\n\
    \x8a\x01\n\x04\x04\x07\x02\x01\x12\x04\xec\x02\x02!\x1a|\x20For\x20an\
    \x20update\x20this\x20list\x20contains\x20all\x20the\x20statements.\x20F\
    or\x20an\n\x20individual\x20statement,\x20this\x20list\x20contains\x20on\
    ly\x20that\x20statement.\n\n\r\n\x05\x04\x07\x02\x01\x04\x12\x04\xec\x02\
    \x02\n\n\r\n\x05\x04\x07\x02\x01\x05\x12\x04\xec\x02\x0b\x11\n\r\n\x05\
    \x04\x07\x02\x01\x01\x12\x04\xec\x02\x12\x1c\n\r\n\x05\x04\x07\x02\x01\
    \x03\x12\x04\xec\x02\x1f\x20\n\xb6\x01\n\x04\x04\x07\x02\x02\x12\x04\xf1\
    \x02\x02;\x1a\xa7\x01\x20Reports\x20the\x20commit\x20timestamps\x20of\
    \x20all\x20statements\x20that\x20have\n\x20succeeded\x20so\x20far,\x20wh\
    ere\x20`commit_timestamps[i]`\x20is\x20the\x20commit\n\x20timestamp\x20f\
    or\x20the\x20statement\x20`statements[i]`.\n\n\r\n\x05\x04\x07\x02\x02\
    \x04\x12\x04\xf1\x02\x02\n\n\r\n\x05\x04\x07\x02\x02\x06\x12\x04\xf1\x02\
    \x0b$\n\r\n\x05\x04\x07\x02\x02\x01\x12\x04\xf1\x02%6\n\r\n\x05\x04\x07\
    \x02\x02\x03\x12\x04\xf1\x029:\nm\n\x02\x04\x08\x12\x06\xf6\x02\0\xfe\
    \x02\x01\x1a_\x20The\x20request\x20for\n\x20[DropDatabase][google.spanne\
    r.admin.database.v1.DatabaseAdmin.DropDatabase].\n\n\x0b\n\x03\x04\x08\
    \x01\x12\x04\xf6\x02\x08\x1b\n7\n\x04\x04\x08\x02\0\x12\x06\xf8\x02\x02\
    \xfd\x02\x04\x1a'\x20Required.\x20The\x20database\x20to\x20be\x20dropped\
    .\n\n\r\n\x05\x04\x08\x02\0\x05\x12\x04\xf8\x02\x02\x08\n\r\n\x05\x04\
    \x08\x02\0\x01\x12\x04\xf8\x02\t\x11\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\
    \xf8\x02\x14\x15\n\x0f\n\x05\x04\x08\x02\0\x08\x12\x06\xf8\x02\x16\xfd\
    \x02\x03\n\x10\n\x08\x04\x08\x02\0\x08\x9c\x08\0\x12\x04\xf9\x02\x04*\n\
    \x11\n\x07\x04\x08\x02\0\x08\x9f\x08\x12\x06\xfa\x02\x04\xfc\x02\x05\nq\
    \n\x02\x04\t\x12\x06\x82\x03\0\x8a\x03\x01\x1ac\x20The\x20request\x20for\
    \n\x20[GetDatabaseDdl][google.spanner.admin.database.v1.DatabaseAdmin.Ge\
    tDatabaseDdl].\n\n\x0b\n\x03\x04\t\x01\x12\x04\x82\x03\x08\x1d\nE\n\x04\
    \x04\t\x02\0\x12\x06\x84\x03\x02\x89\x03\x04\x1a5\x20Required.\x20The\
    \x20database\x20whose\x20schema\x20we\x20wish\x20to\x20get.\n\n\r\n\x05\
    \x04\t\x02\0\x05\x12\x04\x84\x03\x02\x08\n\r\n\x05\x04\t\x02\0\x01\x12\
    \x04\x84\x03\t\x11\n\r\n\x05\x04\t\x02\0\x03\x12\x04\x84\x03\x14\x15\n\
    \x0f\n\x05\x04\t\x02\0\x08\x12\x06\x84\x03\x16\x89\x03\x03\n\x10\n\x08\
    \x04\t\x02\0\x08\x9c\x08\0\x12\x04\x85\x03\x04*\n\x11\n\x07\x04\t\x02\0\
    \x08\x9f\x08\x12\x06\x86\x03\x04\x88\x03\x05\nr\n\x02\x04\n\x12\x06\x8e\
    \x03\0\x92\x03\x01\x1ad\x20The\x20response\x20for\n\x20[GetDatabaseDdl][\
    google.spanner.admin.database.v1.DatabaseAdmin.GetDatabaseDdl].\n\n\x0b\
    \n\x03\x04\n\x01\x12\x04\x8e\x03\x08\x1e\nq\n\x04\x04\n\x02\0\x12\x04\
    \x91\x03\x02!\x1ac\x20A\x20list\x20of\x20formatted\x20DDL\x20statements\
    \x20defining\x20the\x20schema\x20of\x20the\x20database\n\x20specified\
    \x20in\x20the\x20request.\n\n\r\n\x05\x04\n\x02\0\x04\x12\x04\x91\x03\
    \x02\n\n\r\n\x05\x04\n\x02\0\x05\x12\x04\x91\x03\x0b\x11\n\r\n\x05\x04\n\
    \x02\0\x01\x12\x04\x91\x03\x12\x1c\n\r\n\x05\x04\n\x02\0\x03\x12\x04\x91\
    \x03\x1f\x20b\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()
    })
}