rustyspanner 0.1.1

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

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

#![cfg_attr(rustfmt, rustfmt_skip)]

#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]

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

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

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

    // string name = 1;

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

    pub fn get_name(&self) -> &str {
        &self.name
    }

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

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

    pub fn get_state(&self) -> Database_State {
        self.state
    }
}

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, self.state.value())?;
        }
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "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::<Database>(
                    "Database",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

    // string parent = 1;

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

    pub fn get_parent(&self) -> &str {
        &self.parent
    }

    // int32 page_size = 3;

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

    pub fn get_page_size(&self) -> i32 {
        self.page_size
    }

    // string page_token = 4;

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

    pub fn get_page_token(&self) -> &str {
        &self.page_token
    }
}

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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "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::<ListDatabasesRequest>(
                    "ListDatabasesRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ListDatabasesRequest {
    fn clear(&mut self) {
        self.clear_parent();
        self.clear_page_size();
        self.clear_page_token();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::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
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

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

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

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

    // string next_page_token = 2;

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

    pub fn get_next_page_token(&self) -> &str {
        &self.next_page_token
    }
}

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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<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::<ListDatabasesResponse>(
                    "ListDatabasesResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

    // string parent = 1;

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

    pub fn get_parent(&self) -> &str {
        &self.parent
    }

    // string create_statement = 2;

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

    pub fn get_create_statement(&self) -> &str {
        &self.create_statement
    }

    // repeated string extra_statements = 3;

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

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

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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "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::<CreateDatabaseRequest>(
                    "CreateDatabaseRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

    // string database = 1;

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

    pub fn get_database(&self) -> &str {
        &self.database
    }
}

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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "database",
                    |m: &CreateDatabaseMetadata| { &m.database },
                    |m: &mut CreateDatabaseMetadata| { &mut m.database },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<CreateDatabaseMetadata>(
                    "CreateDatabaseMetadata",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

    // string name = 1;

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

    pub fn get_name(&self) -> &str {
        &self.name
    }
}

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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "name",
                    |m: &GetDatabaseRequest| { &m.name },
                    |m: &mut GetDatabaseRequest| { &mut m.name },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<GetDatabaseRequest>(
                    "GetDatabaseRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

    // string database = 1;

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

    pub fn get_database(&self) -> &str {
        &self.database
    }

    // repeated string statements = 2;

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

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

    // string operation_id = 3;

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

    pub fn get_operation_id(&self) -> &str {
        &self.operation_id
    }
}

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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "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::<UpdateDatabaseDdlRequest>(
                    "UpdateDatabaseDdlRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for UpdateDatabaseDdlRequest {
    fn clear(&mut self) {
        self.clear_database();
        self.clear_statements();
        self.clear_operation_id();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::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
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // string database = 1;

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

    pub fn get_database(&self) -> &str {
        &self.database
    }

    // repeated string statements = 2;

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

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

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

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

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

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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "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::<UpdateDatabaseDdlMetadata>(
                    "UpdateDatabaseDdlMetadata",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

    // string database = 1;

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

    pub fn get_database(&self) -> &str {
        &self.database
    }
}

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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "database",
                    |m: &DropDatabaseRequest| { &m.database },
                    |m: &mut DropDatabaseRequest| { &mut m.database },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<DropDatabaseRequest>(
                    "DropDatabaseRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

    // string database = 1;

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

    pub fn get_database(&self) -> &str {
        &self.database
    }
}

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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "database",
                    |m: &GetDatabaseDdlRequest| { &m.database },
                    |m: &mut GetDatabaseDdlRequest| { &mut m.database },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<GetDatabaseDdlRequest>(
                    "GetDatabaseDdlRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

    // repeated string statements = 1;

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

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

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) -> &::std::any::Any {
        self as &::std::any::Any
    }
    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
        self as &mut ::std::any::Any
    }
    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
        self
    }

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

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

    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
            lock: ::protobuf::lazy::ONCE_INIT,
            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
        };
        unsafe {
            descriptor.get(|| {
                let mut fields = ::std::vec::Vec::new();
                fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
                    "statements",
                    |m: &GetDatabaseDdlResponse| { &m.statements },
                    |m: &mut GetDatabaseDdlResponse| { &mut m.statements },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<GetDatabaseDdlResponse>(
                    "GetDatabaseDdlResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for GetDatabaseDdlResponse {
    fn clear(&mut self) {
        self.clear_statements();
        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::ProtobufValueRef {
        ::protobuf::reflect::ProtobufValueRef::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\
    \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.proto\"\x9f\x01\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\"j\n\x14ListDatabasesRequest\x12\x16\n\x06\
    parent\x18\x01\x20\x01(\tR\x06parent\x12\x1b\n\tpage_size\x18\x03\x20\
    \x01(\x05R\x08pageSize\x12\x1d\n\npage_token\x18\x04\x20\x01(\tR\tpageTo\
    ken\"\x89\x01\n\x15ListDatabasesResponse\x12H\n\tdatabases\x18\x01\x20\
    \x03(\x0b2*.google.spanner.admin.database.v1.DatabaseR\tdatabases\x12&\n\
    \x0fnext_page_token\x18\x02\x20\x01(\tR\rnextPageToken\"\x85\x01\n\x15Cr\
    eateDatabaseRequest\x12\x16\n\x06parent\x18\x01\x20\x01(\tR\x06parent\
    \x12)\n\x10create_statement\x18\x02\x20\x01(\tR\x0fcreateStatement\x12)\
    \n\x10extra_statements\x18\x03\x20\x03(\tR\x0fextraStatements\"4\n\x16Cr\
    eateDatabaseMetadata\x12\x1a\n\x08database\x18\x01\x20\x01(\tR\x08databa\
    se\"(\n\x12GetDatabaseRequest\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04n\
    ame\"y\n\x18UpdateDatabaseDdlRequest\x12\x1a\n\x08database\x18\x01\x20\
    \x01(\tR\x08database\x12\x1e\n\nstatements\x18\x02\x20\x03(\tR\nstatemen\
    ts\x12!\n\x0coperation_id\x18\x03\x20\x01(\tR\x0boperationId\"\xa0\x01\n\
    \x19UpdateDatabaseDdlMetadata\x12\x1a\n\x08database\x18\x01\x20\x01(\tR\
    \x08database\x12\x1e\n\nstatements\x18\x02\x20\x03(\tR\nstatements\x12G\
    \n\x11commit_timestamps\x18\x03\x20\x03(\x0b2\x1a.google.protobuf.Timest\
    ampR\x10commitTimestamps\"1\n\x13DropDatabaseRequest\x12\x1a\n\x08databa\
    se\x18\x01\x20\x01(\tR\x08database\"3\n\x15GetDatabaseDdlRequest\x12\x1a\
    \n\x08database\x18\x01\x20\x01(\tR\x08database\"8\n\x16GetDatabaseDdlRes\
    ponse\x12\x1e\n\nstatements\x18\x01\x20\x03(\tR\nstatements2\x95\x0c\n\r\
    DatabaseAdmin\x12\xb7\x01\n\rListDatabases\x126.google.spanner.admin.dat\
    abase.v1.ListDatabasesRequest\x1a7.google.spanner.admin.database.v1.List\
    DatabasesResponse\"5\x82\xd3\xe4\x93\x02/\x12-/v1/{parent=projects/*/ins\
    tances/*}/databases\x12\xa2\x01\n\x0eCreateDatabase\x127.google.spanner.\
    admin.database.v1.CreateDatabaseRequest\x1a\x1d.google.longrunning.Opera\
    tion\"8\x82\xd3\xe4\x93\x022\"-/v1/{parent=projects/*/instances/*}/datab\
    ases:\x01*\x12\xa6\x01\n\x0bGetDatabase\x124.google.spanner.admin.databa\
    se.v1.GetDatabaseRequest\x1a*.google.spanner.admin.database.v1.Database\
    \"5\x82\xd3\xe4\x93\x02/\x12-/v1/{name=projects/*/instances/*/databases/\
    *}\x12\xb0\x01\n\x11UpdateDatabaseDdl\x12:.google.spanner.admin.database\
    .v1.UpdateDatabaseDdlRequest\x1a\x1d.google.longrunning.Operation\"@\x82\
    \xd3\xe4\x93\x02:25/v1/{database=projects/*/instances/*/databases/*}/ddl\
    :\x01*\x12\x98\x01\n\x0cDropDatabase\x125.google.spanner.admin.database.\
    v1.DropDatabaseRequest\x1a\x16.google.protobuf.Empty\"9\x82\xd3\xe4\x93\
    \x023*1/v1/{database=projects/*/instances/*/databases/*}\x12\xc2\x01\n\
    \x0eGetDatabaseDdl\x127.google.spanner.admin.database.v1.GetDatabaseDdlR\
    equest\x1a8.google.spanner.admin.database.v1.GetDatabaseDdlResponse\"=\
    \x82\xd3\xe4\x93\x027\x125/v1/{database=projects/*/instances/*/databases\
    /*}/ddl\x12\x94\x01\n\x0cSetIamPolicy\x12\".google.iam.v1.SetIamPolicyRe\
    quest\x1a\x15.google.iam.v1.Policy\"I\x82\xd3\xe4\x93\x02C\">/v1/{resour\
    ce=projects/*/instances/*/databases/*}:setIamPolicy:\x01*\x12\x94\x01\n\
    \x0cGetIamPolicy\x12\".google.iam.v1.GetIamPolicyRequest\x1a\x15.google.\
    iam.v1.Policy\"I\x82\xd3\xe4\x93\x02C\">/v1/{resource=projects/*/instanc\
    es/*/databases/*}:getIamPolicy:\x01*\x12\xba\x01\n\x12TestIamPermissions\
    \x12(.google.iam.v1.TestIamPermissionsRequest\x1a).google.iam.v1.TestIam\
    PermissionsResponse\"O\x82\xd3\xe4\x93\x02I\"D/v1/{resource=projects/*/i\
    nstances/*/databases/*}:testIamPermissions:\x01*B\xdf\x01\n$com.google.s\
    panner.admin.database.v1B\x19SpannerDatabaseAdminProtoP\x01ZHgoogle.gola\
    ng.org/genproto/googleapis/spanner/admin/database/v1;database\xaa\x02&Go\
    ogle.Cloud.Spanner.Admin.Database.V1\xca\x02&Google\\Cloud\\Spanner\\Adm\
    in\\Database\\V1J\xb7e\n\x07\x12\x05\x0e\0\xad\x02\x01\n\xbd\x04\n\x01\
    \x0c\x12\x03\x0e\0\x122\xb2\x04\x20Copyright\x202018\x20Google\x20Inc.\n\
    \n\x20Licensed\x20under\x20the\x20Apache\x20License,\x20Version\x202.0\
    \x20(the\x20\"License\");\n\x20you\x20may\x20not\x20use\x20this\x20file\
    \x20except\x20in\x20compliance\x20with\x20the\x20License.\n\x20You\x20ma\
    y\x20obtain\x20a\x20copy\x20of\x20the\x20License\x20at\n\n\x20\x20\x20\
    \x20\x20http://www.apache.org/licenses/LICENSE-2.0\n\n\x20Unless\x20requ\
    ired\x20by\x20applicable\x20law\x20or\x20agreed\x20to\x20in\x20writing,\
    \x20software\n\x20distributed\x20under\x20the\x20License\x20is\x20distri\
    buted\x20on\x20an\x20\"AS\x20IS\"\x20BASIS,\n\x20WITHOUT\x20WARRANTIES\
    \x20OR\x20CONDITIONS\x20OF\x20ANY\x20KIND,\x20either\x20express\x20or\
    \x20implied.\n\x20See\x20the\x20License\x20for\x20the\x20specific\x20lan\
    guage\x20governing\x20permissions\x20and\n\x20limitations\x20under\x20th\
    e\x20License.\n\n\x08\n\x01\x02\x12\x03\x10\x08(\n\t\n\x02\x03\0\x12\x03\
    \x12\x07%\n\t\n\x02\x03\x01\x12\x03\x13\x07'\n\t\n\x02\x03\x02\x12\x03\
    \x14\x07#\n\t\n\x02\x03\x03\x12\x03\x15\x07,\n\t\n\x02\x03\x04\x12\x03\
    \x16\x07$\n\t\n\x02\x03\x05\x12\x03\x17\x07(\n\x08\n\x01\x08\x12\x03\x19\
    \0C\n\x0b\n\x04\x08\xe7\x07\0\x12\x03\x19\0C\n\x0c\n\x05\x08\xe7\x07\0\
    \x02\x12\x03\x19\x07\x17\n\r\n\x06\x08\xe7\x07\0\x02\0\x12\x03\x19\x07\
    \x17\n\x0e\n\x07\x08\xe7\x07\0\x02\0\x01\x12\x03\x19\x07\x17\n\x0c\n\x05\
    \x08\xe7\x07\0\x07\x12\x03\x19\x1aB\n\x08\n\x01\x08\x12\x03\x1a\0_\n\x0b\
    \n\x04\x08\xe7\x07\x01\x12\x03\x1a\0_\n\x0c\n\x05\x08\xe7\x07\x01\x02\
    \x12\x03\x1a\x07\x11\n\r\n\x06\x08\xe7\x07\x01\x02\0\x12\x03\x1a\x07\x11\
    \n\x0e\n\x07\x08\xe7\x07\x01\x02\0\x01\x12\x03\x1a\x07\x11\n\x0c\n\x05\
    \x08\xe7\x07\x01\x07\x12\x03\x1a\x14^\n\x08\n\x01\x08\x12\x03\x1b\0\"\n\
    \x0b\n\x04\x08\xe7\x07\x02\x12\x03\x1b\0\"\n\x0c\n\x05\x08\xe7\x07\x02\
    \x02\x12\x03\x1b\x07\x1a\n\r\n\x06\x08\xe7\x07\x02\x02\0\x12\x03\x1b\x07\
    \x1a\n\x0e\n\x07\x08\xe7\x07\x02\x02\0\x01\x12\x03\x1b\x07\x1a\n\x0c\n\
    \x05\x08\xe7\x07\x02\x03\x12\x03\x1b\x1d!\n\x08\n\x01\x08\x12\x03\x1c\0:\
    \n\x0b\n\x04\x08\xe7\x07\x03\x12\x03\x1c\0:\n\x0c\n\x05\x08\xe7\x07\x03\
    \x02\x12\x03\x1c\x07\x1b\n\r\n\x06\x08\xe7\x07\x03\x02\0\x12\x03\x1c\x07\
    \x1b\n\x0e\n\x07\x08\xe7\x07\x03\x02\0\x01\x12\x03\x1c\x07\x1b\n\x0c\n\
    \x05\x08\xe7\x07\x03\x07\x12\x03\x1c\x1e9\n\x08\n\x01\x08\x12\x03\x1d\0=\
    \n\x0b\n\x04\x08\xe7\x07\x04\x12\x03\x1d\0=\n\x0c\n\x05\x08\xe7\x07\x04\
    \x02\x12\x03\x1d\x07\x13\n\r\n\x06\x08\xe7\x07\x04\x02\0\x12\x03\x1d\x07\
    \x13\n\x0e\n\x07\x08\xe7\x07\x04\x02\0\x01\x12\x03\x1d\x07\x13\n\x0c\n\
    \x05\x08\xe7\x07\x04\x07\x12\x03\x1d\x16<\n\x08\n\x01\x08\x12\x03\x1e\0E\
    \n\x0b\n\x04\x08\xe7\x07\x05\x12\x03\x1e\0E\n\x0c\n\x05\x08\xe7\x07\x05\
    \x02\x12\x03\x1e\x07\x14\n\r\n\x06\x08\xe7\x07\x05\x02\0\x12\x03\x1e\x07\
    \x14\n\x0e\n\x07\x08\xe7\x07\x05\x02\0\x01\x12\x03\x1e\x07\x14\n\x0c\n\
    \x05\x08\xe7\x07\x05\x07\x12\x03\x1e\x17D\n\xc9\x01\n\x02\x06\0\x12\x05&\
    \0\x86\x01\x01\x1a\xbb\x01\x20Cloud\x20Spanner\x20Database\x20Admin\x20A\
    PI\n\n\x20The\x20Cloud\x20Spanner\x20Database\x20Admin\x20API\x20can\x20\
    be\x20used\x20to\x20create,\x20drop,\x20and\n\x20list\x20databases.\x20I\
    t\x20also\x20enables\x20updating\x20the\x20schema\x20of\x20pre-existing\
    \n\x20databases.\n\n\n\n\x03\x06\0\x01\x12\x03&\x08\x15\n.\n\x04\x06\0\
    \x02\0\x12\x04(\x02,\x03\x1a\x20\x20Lists\x20Cloud\x20Spanner\x20databas\
    es.\n\n\x0c\n\x05\x06\0\x02\0\x01\x12\x03(\x06\x13\n\x0c\n\x05\x06\0\x02\
    \0\x02\x12\x03(\x14(\n\x0c\n\x05\x06\0\x02\0\x03\x12\x03(3H\n\r\n\x05\
    \x06\0\x02\0\x04\x12\x04)\x04+\x06\n\x10\n\x08\x06\0\x02\0\x04\xe7\x07\0\
    \x12\x04)\x04+\x06\n\x10\n\t\x06\0\x02\0\x04\xe7\x07\0\x02\x12\x03)\x0b\
    \x1c\n\x11\n\n\x06\0\x02\0\x04\xe7\x07\0\x02\0\x12\x03)\x0b\x1c\n\x12\n\
    \x0b\x06\0\x02\0\x04\xe7\x07\0\x02\0\x01\x12\x03)\x0c\x1b\n\x11\n\t\x06\
    \0\x02\0\x04\xe7\x07\0\x08\x12\x04)\x1f+\x05\n\xc8\x04\n\x04\x06\0\x02\
    \x01\x12\x046\x02;\x03\x1a\xb9\x04\x20Creates\x20a\x20new\x20Cloud\x20Sp\
    anner\x20database\x20and\x20starts\x20to\x20prepare\x20it\x20for\x20serv\
    ing.\n\x20The\x20returned\x20[long-running\x20operation][google.longrunn\
    ing.Operation]\x20will\n\x20have\x20a\x20name\x20of\x20the\x20format\x20\
    `<database_name>/operations/<operation_id>`\x20and\n\x20can\x20be\x20use\
    d\x20to\x20track\x20preparation\x20of\x20the\x20database.\x20The\n\x20[m\
    etadata][google.longrunning.Operation.metadata]\x20field\x20type\x20is\n\
    \x20[CreateDatabaseMetadata][google.spanner.admin.database.v1.CreateData\
    baseMetadata].\x20The\n\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\
    \x036\x06\x14\n\x0c\n\x05\x06\0\x02\x01\x02\x12\x036\x15*\n\x0c\n\x05\
    \x06\0\x02\x01\x03\x12\x0365Q\n\r\n\x05\x06\0\x02\x01\x04\x12\x047\x04:\
    \x06\n\x10\n\x08\x06\0\x02\x01\x04\xe7\x07\0\x12\x047\x04:\x06\n\x10\n\t\
    \x06\0\x02\x01\x04\xe7\x07\0\x02\x12\x037\x0b\x1c\n\x11\n\n\x06\0\x02\
    \x01\x04\xe7\x07\0\x02\0\x12\x037\x0b\x1c\n\x12\n\x0b\x06\0\x02\x01\x04\
    \xe7\x07\0\x02\0\x01\x12\x037\x0c\x1b\n\x11\n\t\x06\0\x02\x01\x04\xe7\
    \x07\0\x08\x12\x047\x1f:\x05\n;\n\x04\x06\0\x02\x02\x12\x04>\x02B\x03\
    \x1a-\x20Gets\x20the\x20state\x20of\x20a\x20Cloud\x20Spanner\x20database\
    .\n\n\x0c\n\x05\x06\0\x02\x02\x01\x12\x03>\x06\x11\n\x0c\n\x05\x06\0\x02\
    \x02\x02\x12\x03>\x12$\n\x0c\n\x05\x06\0\x02\x02\x03\x12\x03>/7\n\r\n\
    \x05\x06\0\x02\x02\x04\x12\x04?\x04A\x06\n\x10\n\x08\x06\0\x02\x02\x04\
    \xe7\x07\0\x12\x04?\x04A\x06\n\x10\n\t\x06\0\x02\x02\x04\xe7\x07\0\x02\
    \x12\x03?\x0b\x1c\n\x11\n\n\x06\0\x02\x02\x04\xe7\x07\0\x02\0\x12\x03?\
    \x0b\x1c\n\x12\n\x0b\x06\0\x02\x02\x04\xe7\x07\0\x02\0\x01\x12\x03?\x0c\
    \x1b\n\x11\n\t\x06\0\x02\x02\x04\xe7\x07\0\x08\x12\x04?\x1fA\x05\n\x8a\
    \x04\n\x04\x06\0\x02\x03\x12\x04K\x02P\x03\x1a\xfb\x03\x20Updates\x20the\
    \x20schema\x20of\x20a\x20Cloud\x20Spanner\x20database\x20by\n\x20creatin\
    g/altering/dropping\x20tables,\x20columns,\x20indexes,\x20etc.\x20The\
    \x20returned\n\x20[long-running\x20operation][google.longrunning.Operati\
    on]\x20will\x20have\x20a\x20name\x20of\n\x20the\x20format\x20`<database_\
    name>/operations/<operation_id>`\x20and\x20can\x20be\x20used\x20to\n\x20\
    track\x20execution\x20of\x20the\x20schema\x20change(s).\x20The\n\x20[met\
    adata][google.longrunning.Operation.metadata]\x20field\x20type\x20is\n\
    \x20[UpdateDatabaseDdlMetadata][google.spanner.admin.database.v1.UpdateD\
    atabaseDdlMetadata].\x20\x20The\x20operation\x20has\x20no\x20response.\n\
    \n\x0c\n\x05\x06\0\x02\x03\x01\x12\x03K\x06\x17\n\x0c\n\x05\x06\0\x02\
    \x03\x02\x12\x03K\x180\n\x0c\n\x05\x06\0\x02\x03\x03\x12\x03K;W\n\r\n\
    \x05\x06\0\x02\x03\x04\x12\x04L\x04O\x06\n\x10\n\x08\x06\0\x02\x03\x04\
    \xe7\x07\0\x12\x04L\x04O\x06\n\x10\n\t\x06\0\x02\x03\x04\xe7\x07\0\x02\
    \x12\x03L\x0b\x1c\n\x11\n\n\x06\0\x02\x03\x04\xe7\x07\0\x02\0\x12\x03L\
    \x0b\x1c\n\x12\n\x0b\x06\0\x02\x03\x04\xe7\x07\0\x02\0\x01\x12\x03L\x0c\
    \x1b\n\x11\n\t\x06\0\x02\x03\x04\xe7\x07\0\x08\x12\x04L\x1fO\x05\n=\n\
    \x04\x06\0\x02\x04\x12\x04S\x02W\x03\x1a/\x20Drops\x20(aka\x20deletes)\
    \x20a\x20Cloud\x20Spanner\x20database.\n\n\x0c\n\x05\x06\0\x02\x04\x01\
    \x12\x03S\x06\x12\n\x0c\n\x05\x06\0\x02\x04\x02\x12\x03S\x13&\n\x0c\n\
    \x05\x06\0\x02\x04\x03\x12\x03S1F\n\r\n\x05\x06\0\x02\x04\x04\x12\x04T\
    \x04V\x06\n\x10\n\x08\x06\0\x02\x04\x04\xe7\x07\0\x12\x04T\x04V\x06\n\
    \x10\n\t\x06\0\x02\x04\x04\xe7\x07\0\x02\x12\x03T\x0b\x1c\n\x11\n\n\x06\
    \0\x02\x04\x04\xe7\x07\0\x02\0\x12\x03T\x0b\x1c\n\x12\n\x0b\x06\0\x02\
    \x04\x04\xe7\x07\0\x02\0\x01\x12\x03T\x0c\x1b\n\x11\n\t\x06\0\x02\x04\
    \x04\xe7\x07\0\x08\x12\x04T\x1fV\x05\n\xea\x01\n\x04\x06\0\x02\x05\x12\
    \x04\\\x02`\x03\x1a\xdb\x01\x20Returns\x20the\x20schema\x20of\x20a\x20Cl\
    oud\x20Spanner\x20database\x20as\x20a\x20list\x20of\x20formatted\n\x20DD\
    L\x20statements.\x20This\x20method\x20does\x20not\x20show\x20pending\x20\
    schema\x20updates,\x20those\x20may\n\x20be\x20queried\x20using\x20the\
    \x20[Operations][google.longrunning.Operations]\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\\5K\n\r\n\x05\x06\0\
    \x02\x05\x04\x12\x04]\x04_\x06\n\x10\n\x08\x06\0\x02\x05\x04\xe7\x07\0\
    \x12\x04]\x04_\x06\n\x10\n\t\x06\0\x02\x05\x04\xe7\x07\0\x02\x12\x03]\
    \x0b\x1c\n\x11\n\n\x06\0\x02\x05\x04\xe7\x07\0\x02\0\x12\x03]\x0b\x1c\n\
    \x12\n\x0b\x06\0\x02\x05\x04\xe7\x07\0\x02\0\x01\x12\x03]\x0c\x1b\n\x11\
    \n\t\x06\0\x02\x05\x04\xe7\x07\0\x08\x12\x04]\x1f_\x05\n\xe7\x01\n\x04\
    \x06\0\x02\x06\x12\x04g\x02l\x03\x1a\xd8\x01\x20Sets\x20the\x20access\
    \x20control\x20policy\x20on\x20a\x20database\x20resource.\x20Replaces\
    \x20any\n\x20existing\x20policy.\n\n\x20Authorization\x20requires\x20`sp\
    anner.databases.setIamPolicy`\x20permission\x20on\n\x20[resource][google\
    .iam.v1.SetIamPolicyRequest.resource].\n\n\x0c\n\x05\x06\0\x02\x06\x01\
    \x12\x03g\x06\x12\n\x0c\n\x05\x06\0\x02\x06\x02\x12\x03g\x134\n\x0c\n\
    \x05\x06\0\x02\x06\x03\x12\x03g?S\n\r\n\x05\x06\0\x02\x06\x04\x12\x04h\
    \x04k\x06\n\x10\n\x08\x06\0\x02\x06\x04\xe7\x07\0\x12\x04h\x04k\x06\n\
    \x10\n\t\x06\0\x02\x06\x04\xe7\x07\0\x02\x12\x03h\x0b\x1c\n\x11\n\n\x06\
    \0\x02\x06\x04\xe7\x07\0\x02\0\x12\x03h\x0b\x1c\n\x12\n\x0b\x06\0\x02\
    \x06\x04\xe7\x07\0\x02\0\x01\x12\x03h\x0c\x1b\n\x11\n\t\x06\0\x02\x06\
    \x04\xe7\x07\0\x08\x12\x04h\x1fk\x05\n\x97\x02\n\x04\x06\0\x02\x07\x12\
    \x04s\x02x\x03\x1a\x88\x02\x20Gets\x20the\x20access\x20control\x20policy\
    \x20for\x20a\x20database\x20resource.\x20Returns\x20an\x20empty\n\x20pol\
    icy\x20if\x20a\x20database\x20exists\x20but\x20does\x20not\x20have\x20a\
    \x20policy\x20set.\n\n\x20Authorization\x20requires\x20`spanner.database\
    s.getIamPolicy`\x20permission\x20on\n\x20[resource][google.iam.v1.GetIam\
    PolicyRequest.resource].\n\n\x0c\n\x05\x06\0\x02\x07\x01\x12\x03s\x06\
    \x12\n\x0c\n\x05\x06\0\x02\x07\x02\x12\x03s\x134\n\x0c\n\x05\x06\0\x02\
    \x07\x03\x12\x03s?S\n\r\n\x05\x06\0\x02\x07\x04\x12\x04t\x04w\x06\n\x10\
    \n\x08\x06\0\x02\x07\x04\xe7\x07\0\x12\x04t\x04w\x06\n\x10\n\t\x06\0\x02\
    \x07\x04\xe7\x07\0\x02\x12\x03t\x0b\x1c\n\x11\n\n\x06\0\x02\x07\x04\xe7\
    \x07\0\x02\0\x12\x03t\x0b\x1c\n\x12\n\x0b\x06\0\x02\x07\x04\xe7\x07\0\
    \x02\0\x01\x12\x03t\x0c\x1b\n\x11\n\t\x06\0\x02\x07\x04\xe7\x07\0\x08\
    \x12\x04t\x1fw\x05\n\xce\x02\n\x04\x06\0\x02\x08\x12\x06\x80\x01\x02\x85\
    \x01\x03\x1a\xbd\x02\x20Returns\x20permissions\x20that\x20the\x20caller\
    \x20has\x20on\x20the\x20specified\x20database\x20resource.\n\n\x20Attemp\
    ting\x20this\x20RPC\x20on\x20a\x20non-existent\x20Cloud\x20Spanner\x20da\
    tabase\x20will\x20result\x20in\n\x20a\x20NOT_FOUND\x20error\x20if\x20the\
    \x20user\x20has\x20`spanner.databases.list`\x20permission\x20on\n\x20the\
    \x20containing\x20Cloud\x20Spanner\x20instance.\x20Otherwise\x20returns\
    \x20an\x20empty\x20set\x20of\n\x20permissions.\n\n\r\n\x05\x06\0\x02\x08\
    \x01\x12\x04\x80\x01\x06\x18\n\r\n\x05\x06\0\x02\x08\x02\x12\x04\x80\x01\
    \x19@\n\r\n\x05\x06\0\x02\x08\x03\x12\x04\x80\x01Ks\n\x0f\n\x05\x06\0\
    \x02\x08\x04\x12\x06\x81\x01\x04\x84\x01\x06\n\x12\n\x08\x06\0\x02\x08\
    \x04\xe7\x07\0\x12\x06\x81\x01\x04\x84\x01\x06\n\x11\n\t\x06\0\x02\x08\
    \x04\xe7\x07\0\x02\x12\x04\x81\x01\x0b\x1c\n\x12\n\n\x06\0\x02\x08\x04\
    \xe7\x07\0\x02\0\x12\x04\x81\x01\x0b\x1c\n\x13\n\x0b\x06\0\x02\x08\x04\
    \xe7\x07\0\x02\0\x01\x12\x04\x81\x01\x0c\x1b\n\x13\n\t\x06\0\x02\x08\x04\
    \xe7\x07\0\x08\x12\x06\x81\x01\x1f\x84\x01\x05\n)\n\x02\x04\0\x12\x06\
    \x89\x01\0\xa0\x01\x01\x1a\x1b\x20A\x20Cloud\x20Spanner\x20database.\n\n\
    \x0b\n\x03\x04\0\x01\x12\x04\x89\x01\x08\x10\n>\n\x04\x04\0\x04\0\x12\
    \x06\x8b\x01\x02\x95\x01\x03\x1a.\x20Indicates\x20the\x20current\x20stat\
    e\x20of\x20the\x20database.\n\n\r\n\x05\x04\0\x04\0\x01\x12\x04\x8b\x01\
    \x07\x0c\n\x20\n\x06\x04\0\x04\0\x02\0\x12\x04\x8d\x01\x04\x1a\x1a\x10\
    \x20Not\x20specified.\n\n\x0f\n\x07\x04\0\x04\0\x02\0\x01\x12\x04\x8d\
    \x01\x04\x15\n\x0f\n\x07\x04\0\x04\0\x02\0\x02\x12\x04\x8d\x01\x18\x19\n\
    \x85\x01\n\x06\x04\0\x04\0\x02\x01\x12\x04\x91\x01\x04\x11\x1au\x20The\
    \x20database\x20is\x20still\x20being\x20created.\x20Operations\x20on\x20\
    the\x20database\x20may\x20fail\n\x20with\x20`FAILED_PRECONDITION`\x20in\
    \x20this\x20state.\n\n\x0f\n\x07\x04\0\x04\0\x02\x01\x01\x12\x04\x91\x01\
    \x04\x0c\n\x0f\n\x07\x04\0\x04\0\x02\x01\x02\x12\x04\x91\x01\x0f\x10\nB\
    \n\x06\x04\0\x04\0\x02\x02\x12\x04\x94\x01\x04\x0e\x1a2\x20The\x20databa\
    se\x20is\x20fully\x20created\x20and\x20ready\x20for\x20use.\n\n\x0f\n\
    \x07\x04\0\x04\0\x02\x02\x01\x12\x04\x94\x01\x04\t\n\x0f\n\x07\x04\0\x04\
    \0\x02\x02\x02\x12\x04\x94\x01\x0c\r\n\x9d\x02\n\x04\x04\0\x02\0\x12\x04\
    \x9c\x01\x02\x12\x1a\x8e\x02\x20Required.\x20The\x20name\x20of\x20the\
    \x20database.\x20Values\x20are\x20of\x20the\x20form\n\x20`projects/<proj\
    ect>/instances/<instance>/databases/<database>`,\n\x20where\x20`<databas\
    e>`\x20is\x20as\x20specified\x20in\x20the\x20`CREATE\x20DATABASE`\n\x20s\
    tatement.\x20This\x20name\x20can\x20be\x20passed\x20to\x20other\x20API\
    \x20methods\x20to\n\x20identify\x20the\x20database.\n\n\x0f\n\x05\x04\0\
    \x02\0\x04\x12\x06\x9c\x01\x02\x95\x01\x03\n\r\n\x05\x04\0\x02\0\x05\x12\
    \x04\x9c\x01\x02\x08\n\r\n\x05\x04\0\x02\0\x01\x12\x04\x9c\x01\t\r\n\r\n\
    \x05\x04\0\x02\0\x03\x12\x04\x9c\x01\x10\x11\n8\n\x04\x04\0\x02\x01\x12\
    \x04\x9f\x01\x02\x12\x1a*\x20Output\x20only.\x20The\x20current\x20databa\
    se\x20state.\n\n\x0f\n\x05\x04\0\x02\x01\x04\x12\x06\x9f\x01\x02\x9c\x01\
    \x12\n\r\n\x05\x04\0\x02\x01\x06\x12\x04\x9f\x01\x02\x07\n\r\n\x05\x04\0\
    \x02\x01\x01\x12\x04\x9f\x01\x08\r\n\r\n\x05\x04\0\x02\x01\x03\x12\x04\
    \x9f\x01\x10\x11\nn\n\x02\x04\x01\x12\x06\xa3\x01\0\xb0\x01\x01\x1a`\x20\
    The\x20request\x20for\x20[ListDatabases][google.spanner.admin.database.v\
    1.DatabaseAdmin.ListDatabases].\n\n\x0b\n\x03\x04\x01\x01\x12\x04\xa3\
    \x01\x08\x1c\n\x8b\x01\n\x04\x04\x01\x02\0\x12\x04\xa6\x01\x02\x14\x1a}\
    \x20Required.\x20The\x20instance\x20whose\x20databases\x20should\x20be\
    \x20listed.\n\x20Values\x20are\x20of\x20the\x20form\x20`projects/<projec\
    t>/instances/<instance>`.\n\n\x0f\n\x05\x04\x01\x02\0\x04\x12\x06\xa6\
    \x01\x02\xa3\x01\x1e\n\r\n\x05\x04\x01\x02\0\x05\x12\x04\xa6\x01\x02\x08\
    \n\r\n\x05\x04\x01\x02\0\x01\x12\x04\xa6\x01\t\x0f\n\r\n\x05\x04\x01\x02\
    \0\x03\x12\x04\xa6\x01\x12\x13\n\x86\x01\n\x04\x04\x01\x02\x01\x12\x04\
    \xaa\x01\x02\x16\x1ax\x20Number\x20of\x20databases\x20to\x20be\x20return\
    ed\x20in\x20the\x20response.\x20If\x200\x20or\x20less,\n\x20defaults\x20\
    to\x20the\x20server's\x20maximum\x20allowed\x20page\x20size.\n\n\x0f\n\
    \x05\x04\x01\x02\x01\x04\x12\x06\xaa\x01\x02\xa6\x01\x14\n\r\n\x05\x04\
    \x01\x02\x01\x05\x12\x04\xaa\x01\x02\x07\n\r\n\x05\x04\x01\x02\x01\x01\
    \x12\x04\xaa\x01\x08\x11\n\r\n\x05\x04\x01\x02\x01\x03\x12\x04\xaa\x01\
    \x14\x15\n\xf9\x01\n\x04\x04\x01\x02\x02\x12\x04\xaf\x01\x02\x18\x1a\xea\
    \x01\x20If\x20non-empty,\x20`page_token`\x20should\x20contain\x20a\n\x20\
    [next_page_token][google.spanner.admin.database.v1.ListDatabasesResponse\
    .next_page_token]\x20from\x20a\n\x20previous\x20[ListDatabasesResponse][\
    google.spanner.admin.database.v1.ListDatabasesResponse].\n\n\x0f\n\x05\
    \x04\x01\x02\x02\x04\x12\x06\xaf\x01\x02\xaa\x01\x16\n\r\n\x05\x04\x01\
    \x02\x02\x05\x12\x04\xaf\x01\x02\x08\n\r\n\x05\x04\x01\x02\x02\x01\x12\
    \x04\xaf\x01\t\x13\n\r\n\x05\x04\x01\x02\x02\x03\x12\x04\xaf\x01\x16\x17\
    \no\n\x02\x04\x02\x12\x06\xb3\x01\0\xbb\x01\x01\x1aa\x20The\x20response\
    \x20for\x20[ListDatabases][google.spanner.admin.database.v1.DatabaseAdmi\
    n.ListDatabases].\n\n\x0b\n\x03\x04\x02\x01\x12\x04\xb3\x01\x08\x1d\n3\n\
    \x04\x04\x02\x02\0\x12\x04\xb5\x01\x02\"\x1a%\x20Databases\x20that\x20ma\
    tched\x20the\x20request.\n\n\r\n\x05\x04\x02\x02\0\x04\x12\x04\xb5\x01\
    \x02\n\n\r\n\x05\x04\x02\x02\0\x06\x12\x04\xb5\x01\x0b\x13\n\r\n\x05\x04\
    \x02\x02\0\x01\x12\x04\xb5\x01\x14\x1d\n\r\n\x05\x04\x02\x02\0\x03\x12\
    \x04\xb5\x01\x20!\n\xbc\x01\n\x04\x04\x02\x02\x01\x12\x04\xba\x01\x02\
    \x1d\x1a\xad\x01\x20`next_page_token`\x20can\x20be\x20sent\x20in\x20a\
    \x20subsequent\n\x20[ListDatabases][google.spanner.admin.database.v1.Dat\
    abaseAdmin.ListDatabases]\x20call\x20to\x20fetch\x20more\n\x20of\x20the\
    \x20matching\x20databases.\n\n\x0f\n\x05\x04\x02\x02\x01\x04\x12\x06\xba\
    \x01\x02\xb5\x01\"\n\r\n\x05\x04\x02\x02\x01\x05\x12\x04\xba\x01\x02\x08\
    \n\r\n\x05\x04\x02\x02\x01\x01\x12\x04\xba\x01\t\x18\n\r\n\x05\x04\x02\
    \x02\x01\x03\x12\x04\xba\x01\x1b\x1c\np\n\x02\x04\x03\x12\x06\xbe\x01\0\
    \xcf\x01\x01\x1ab\x20The\x20request\x20for\x20[CreateDatabase][google.sp\
    anner.admin.database.v1.DatabaseAdmin.CreateDatabase].\n\n\x0b\n\x03\x04\
    \x03\x01\x12\x04\xbe\x01\x08\x1d\n\x98\x01\n\x04\x04\x03\x02\0\x12\x04\
    \xc1\x01\x02\x14\x1a\x89\x01\x20Required.\x20The\x20name\x20of\x20the\
    \x20instance\x20that\x20will\x20serve\x20the\x20new\x20database.\n\x20Va\
    lues\x20are\x20of\x20the\x20form\x20`projects/<project>/instances/<insta\
    nce>`.\n\n\x0f\n\x05\x04\x03\x02\0\x04\x12\x06\xc1\x01\x02\xbe\x01\x1f\n\
    \r\n\x05\x04\x03\x02\0\x05\x12\x04\xc1\x01\x02\x08\n\r\n\x05\x04\x03\x02\
    \0\x01\x12\x04\xc1\x01\t\x0f\n\r\n\x05\x04\x03\x02\0\x03\x12\x04\xc1\x01\
    \x12\x13\n\xe6\x02\n\x04\x04\x03\x02\x01\x12\x04\xc8\x01\x02\x1e\x1a\xd7\
    \x02\x20Required.\x20A\x20`CREATE\x20DATABASE`\x20statement,\x20which\
    \x20specifies\x20the\x20ID\x20of\x20the\n\x20new\x20database.\x20\x20The\
    \x20database\x20ID\x20must\x20conform\x20to\x20the\x20regular\x20express\
    ion\n\x20`[a-z][a-z0-9_\\-]*[a-z0-9]`\x20and\x20be\x20between\x202\x20an\
    d\x2030\x20characters\x20in\x20length.\n\x20If\x20the\x20database\x20ID\
    \x20is\x20a\x20reserved\x20word\x20or\x20if\x20it\x20contains\x20a\x20hy\
    phen,\x20the\n\x20database\x20ID\x20must\x20be\x20enclosed\x20in\x20back\
    ticks\x20(``\x20`\x20``).\n\n\x0f\n\x05\x04\x03\x02\x01\x04\x12\x06\xc8\
    \x01\x02\xc1\x01\x14\n\r\n\x05\x04\x03\x02\x01\x05\x12\x04\xc8\x01\x02\
    \x08\n\r\n\x05\x04\x03\x02\x01\x01\x12\x04\xc8\x01\t\x19\n\r\n\x05\x04\
    \x03\x02\x01\x03\x12\x04\xc8\x01\x1c\x1d\n\x97\x02\n\x04\x04\x03\x02\x02\
    \x12\x04\xce\x01\x02'\x1a\x88\x02\x20An\x20optional\x20list\x20of\x20DDL\
    \x20statements\x20to\x20run\x20inside\x20the\x20newly\x20created\n\x20da\
    tabase.\x20Statements\x20can\x20create\x20tables,\x20indexes,\x20etc.\
    \x20These\n\x20statements\x20execute\x20atomically\x20with\x20the\x20cre\
    ation\x20of\x20the\x20database:\n\x20if\x20there\x20is\x20an\x20error\
    \x20in\x20any\x20statement,\x20the\x20database\x20is\x20not\x20created.\
    \n\n\r\n\x05\x04\x03\x02\x02\x04\x12\x04\xce\x01\x02\n\n\r\n\x05\x04\x03\
    \x02\x02\x05\x12\x04\xce\x01\x0b\x11\n\r\n\x05\x04\x03\x02\x02\x01\x12\
    \x04\xce\x01\x12\"\n\r\n\x05\x04\x03\x02\x02\x03\x12\x04\xce\x01%&\n\x8d\
    \x01\n\x02\x04\x04\x12\x06\xd3\x01\0\xd6\x01\x01\x1a\x7f\x20Metadata\x20\
    type\x20for\x20the\x20operation\x20returned\x20by\n\x20[CreateDatabase][\
    google.spanner.admin.database.v1.DatabaseAdmin.CreateDatabase].\n\n\x0b\
    \n\x03\x04\x04\x01\x12\x04\xd3\x01\x08\x1e\n+\n\x04\x04\x04\x02\0\x12\
    \x04\xd5\x01\x02\x16\x1a\x1d\x20The\x20database\x20being\x20created.\n\n\
    \x0f\n\x05\x04\x04\x02\0\x04\x12\x06\xd5\x01\x02\xd3\x01\x20\n\r\n\x05\
    \x04\x04\x02\0\x05\x12\x04\xd5\x01\x02\x08\n\r\n\x05\x04\x04\x02\0\x01\
    \x12\x04\xd5\x01\t\x11\n\r\n\x05\x04\x04\x02\0\x03\x12\x04\xd5\x01\x14\
    \x15\nj\n\x02\x04\x05\x12\x06\xd9\x01\0\xdd\x01\x01\x1a\\\x20The\x20requ\
    est\x20for\x20[GetDatabase][google.spanner.admin.database.v1.DatabaseAdm\
    in.GetDatabase].\n\n\x0b\n\x03\x04\x05\x01\x12\x04\xd9\x01\x08\x1a\n\x96\
    \x01\n\x04\x04\x05\x02\0\x12\x04\xdc\x01\x02\x12\x1a\x87\x01\x20Required\
    .\x20The\x20name\x20of\x20the\x20requested\x20database.\x20Values\x20are\
    \x20of\x20the\x20form\n\x20`projects/<project>/instances/<instance>/data\
    bases/<database>`.\n\n\x0f\n\x05\x04\x05\x02\0\x04\x12\x06\xdc\x01\x02\
    \xd9\x01\x1c\n\r\n\x05\x04\x05\x02\0\x05\x12\x04\xdc\x01\x02\x08\n\r\n\
    \x05\x04\x05\x02\0\x01\x12\x04\xdc\x01\t\r\n\r\n\x05\x04\x05\x02\0\x03\
    \x12\x04\xdc\x01\x10\x11\n\x99\x07\n\x02\x04\x06\x12\x06\xef\x01\0\x8a\
    \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\x20that\x20the\x20statements\n\x20are\x20executable\x20(synta\
    ctically\x20valid,\x20name\x20tables\x20that\x20exist,\x20etc.)\n\x20bef\
    ore\x20enqueueing\x20them,\x20but\x20they\x20may\x20still\x20fail\x20upo\
    n\n\x20later\x20execution\x20(e.g.,\x20if\x20a\x20statement\x20from\x20a\
    nother\x20batch\x20of\n\x20statements\x20is\x20applied\x20first\x20and\
    \x20it\x20conflicts\x20in\x20some\x20way,\x20or\x20if\n\x20there\x20is\
    \x20some\x20data-related\x20problem\x20like\x20a\x20`NULL`\x20value\x20i\
    n\x20a\x20column\x20to\n\x20which\x20`NOT\x20NULL`\x20would\x20be\x20add\
    ed).\x20If\x20a\x20statement\x20fails,\x20all\n\x20subsequent\x20stateme\
    nts\x20in\x20the\x20batch\x20are\x20automatically\x20cancelled.\n\n\x20E\
    ach\x20batch\x20of\x20statements\x20is\x20assigned\x20a\x20name\x20which\
    \x20can\x20be\x20used\x20with\n\x20the\x20[Operations][google.longrunnin\
    g.Operations]\x20API\x20to\x20monitor\n\x20progress.\x20See\x20the\n\x20\
    [operation_id][google.spanner.admin.database.v1.UpdateDatabaseDdlRequest\
    .operation_id]\x20field\x20for\x20more\n\x20details.\n\n\x0b\n\x03\x04\
    \x06\x01\x12\x04\xef\x01\x08\x20\n1\n\x04\x04\x06\x02\0\x12\x04\xf1\x01\
    \x02\x16\x1a#\x20Required.\x20The\x20database\x20to\x20update.\n\n\x0f\n\
    \x05\x04\x06\x02\0\x04\x12\x06\xf1\x01\x02\xef\x01\"\n\r\n\x05\x04\x06\
    \x02\0\x05\x12\x04\xf1\x01\x02\x08\n\r\n\x05\x04\x06\x02\0\x01\x12\x04\
    \xf1\x01\t\x11\n\r\n\x05\x04\x06\x02\0\x03\x12\x04\xf1\x01\x14\x15\n=\n\
    \x04\x04\x06\x02\x01\x12\x04\xf4\x01\x02!\x1a/\x20DDL\x20statements\x20t\
    o\x20be\x20applied\x20to\x20the\x20database.\n\n\r\n\x05\x04\x06\x02\x01\
    \x04\x12\x04\xf4\x01\x02\n\n\r\n\x05\x04\x06\x02\x01\x05\x12\x04\xf4\x01\
    \x0b\x11\n\r\n\x05\x04\x06\x02\x01\x01\x12\x04\xf4\x01\x12\x1c\n\r\n\x05\
    \x04\x06\x02\x01\x03\x12\x04\xf4\x01\x1f\x20\n\xe4\x08\n\x04\x04\x06\x02\
    \x02\x12\x04\x89\x02\x02\x1a\x1a\xd5\x08\x20If\x20empty,\x20the\x20new\
    \x20update\x20request\x20is\x20assigned\x20an\n\x20automatically-generat\
    ed\x20operation\x20ID.\x20Otherwise,\x20`operation_id`\n\x20is\x20used\
    \x20to\x20construct\x20the\x20name\x20of\x20the\x20resulting\n\x20[Opera\
    tion][google.longrunning.Operation].\n\n\x20Specifying\x20an\x20explicit\
    \x20operation\x20ID\x20simplifies\x20determining\n\x20whether\x20the\x20\
    statements\x20were\x20executed\x20in\x20the\x20event\x20that\x20the\n\
    \x20[UpdateDatabaseDdl][google.spanner.admin.database.v1.DatabaseAdmin.U\
    pdateDatabaseDdl]\x20call\x20is\x20replayed,\n\x20or\x20the\x20return\
    \x20value\x20is\x20otherwise\x20lost:\x20the\x20[database][google.spanne\
    r.admin.database.v1.UpdateDatabaseDdlRequest.database]\x20and\n\x20`oper\
    ation_id`\x20fields\x20can\x20be\x20combined\x20to\x20form\x20the\n\x20[\
    name][google.longrunning.Operation.name]\x20of\x20the\x20resulting\n\x20\
    [longrunning.Operation][google.longrunning.Operation]:\x20`<database>/op\
    erations/<operation_id>`.\n\n\x20`operation_id`\x20should\x20be\x20uniqu\
    e\x20within\x20the\x20database,\x20and\x20must\x20be\n\x20a\x20valid\x20\
    identifier:\x20`[a-z][a-z0-9_]*`.\x20Note\x20that\n\x20automatically-gen\
    erated\x20operation\x20IDs\x20always\x20begin\x20with\x20an\n\x20undersc\
    ore.\x20If\x20the\x20named\x20operation\x20already\x20exists,\n\x20[Upda\
    teDatabaseDdl][google.spanner.admin.database.v1.DatabaseAdmin.UpdateData\
    baseDdl]\x20returns\n\x20`ALREADY_EXISTS`.\n\n\x0f\n\x05\x04\x06\x02\x02\
    \x04\x12\x06\x89\x02\x02\xf4\x01!\n\r\n\x05\x04\x06\x02\x02\x05\x12\x04\
    \x89\x02\x02\x08\n\r\n\x05\x04\x06\x02\x02\x01\x12\x04\x89\x02\t\x15\n\r\
    \n\x05\x04\x06\x02\x02\x03\x12\x04\x89\x02\x18\x19\n\x94\x01\n\x02\x04\
    \x07\x12\x06\x8e\x02\0\x9a\x02\x01\x1a\x85\x01\x20Metadata\x20type\x20fo\
    r\x20the\x20operation\x20returned\x20by\n\x20[UpdateDatabaseDdl][google.\
    spanner.admin.database.v1.DatabaseAdmin.UpdateDatabaseDdl].\n\n\x0b\n\
    \x03\x04\x07\x01\x12\x04\x8e\x02\x08!\n,\n\x04\x04\x07\x02\0\x12\x04\x90\
    \x02\x02\x16\x1a\x1e\x20The\x20database\x20being\x20modified.\n\n\x0f\n\
    \x05\x04\x07\x02\0\x04\x12\x06\x90\x02\x02\x8e\x02#\n\r\n\x05\x04\x07\
    \x02\0\x05\x12\x04\x90\x02\x02\x08\n\r\n\x05\x04\x07\x02\0\x01\x12\x04\
    \x90\x02\t\x11\n\r\n\x05\x04\x07\x02\0\x03\x12\x04\x90\x02\x14\x15\n\x8a\
    \x01\n\x04\x04\x07\x02\x01\x12\x04\x94\x02\x02!\x1a|\x20For\x20an\x20upd\
    ate\x20this\x20list\x20contains\x20all\x20the\x20statements.\x20For\x20a\
    n\n\x20individual\x20statement,\x20this\x20list\x20contains\x20only\x20t\
    hat\x20statement.\n\n\r\n\x05\x04\x07\x02\x01\x04\x12\x04\x94\x02\x02\n\
    \n\r\n\x05\x04\x07\x02\x01\x05\x12\x04\x94\x02\x0b\x11\n\r\n\x05\x04\x07\
    \x02\x01\x01\x12\x04\x94\x02\x12\x1c\n\r\n\x05\x04\x07\x02\x01\x03\x12\
    \x04\x94\x02\x1f\x20\n\xb6\x01\n\x04\x04\x07\x02\x02\x12\x04\x99\x02\x02\
    ;\x1a\xa7\x01\x20Reports\x20the\x20commit\x20timestamps\x20of\x20all\x20\
    statements\x20that\x20have\n\x20succeeded\x20so\x20far,\x20where\x20`com\
    mit_timestamps[i]`\x20is\x20the\x20commit\n\x20timestamp\x20for\x20the\
    \x20statement\x20`statements[i]`.\n\n\r\n\x05\x04\x07\x02\x02\x04\x12\
    \x04\x99\x02\x02\n\n\r\n\x05\x04\x07\x02\x02\x06\x12\x04\x99\x02\x0b$\n\
    \r\n\x05\x04\x07\x02\x02\x01\x12\x04\x99\x02%6\n\r\n\x05\x04\x07\x02\x02\
    \x03\x12\x04\x99\x029:\nl\n\x02\x04\x08\x12\x06\x9d\x02\0\xa0\x02\x01\
    \x1a^\x20The\x20request\x20for\x20[DropDatabase][google.spanner.admin.da\
    tabase.v1.DatabaseAdmin.DropDatabase].\n\n\x0b\n\x03\x04\x08\x01\x12\x04\
    \x9d\x02\x08\x1b\n5\n\x04\x04\x08\x02\0\x12\x04\x9f\x02\x02\x16\x1a'\x20\
    Required.\x20The\x20database\x20to\x20be\x20dropped.\n\n\x0f\n\x05\x04\
    \x08\x02\0\x04\x12\x06\x9f\x02\x02\x9d\x02\x1d\n\r\n\x05\x04\x08\x02\0\
    \x05\x12\x04\x9f\x02\x02\x08\n\r\n\x05\x04\x08\x02\0\x01\x12\x04\x9f\x02\
    \t\x11\n\r\n\x05\x04\x08\x02\0\x03\x12\x04\x9f\x02\x14\x15\np\n\x02\x04\
    \t\x12\x06\xa3\x02\0\xa6\x02\x01\x1ab\x20The\x20request\x20for\x20[GetDa\
    tabaseDdl][google.spanner.admin.database.v1.DatabaseAdmin.GetDatabaseDdl\
    ].\n\n\x0b\n\x03\x04\t\x01\x12\x04\xa3\x02\x08\x1d\nC\n\x04\x04\t\x02\0\
    \x12\x04\xa5\x02\x02\x16\x1a5\x20Required.\x20The\x20database\x20whose\
    \x20schema\x20we\x20wish\x20to\x20get.\n\n\x0f\n\x05\x04\t\x02\0\x04\x12\
    \x06\xa5\x02\x02\xa3\x02\x1f\n\r\n\x05\x04\t\x02\0\x05\x12\x04\xa5\x02\
    \x02\x08\n\r\n\x05\x04\t\x02\0\x01\x12\x04\xa5\x02\t\x11\n\r\n\x05\x04\t\
    \x02\0\x03\x12\x04\xa5\x02\x14\x15\nq\n\x02\x04\n\x12\x06\xa9\x02\0\xad\
    \x02\x01\x1ac\x20The\x20response\x20for\x20[GetDatabaseDdl][google.spann\
    er.admin.database.v1.DatabaseAdmin.GetDatabaseDdl].\n\n\x0b\n\x03\x04\n\
    \x01\x12\x04\xa9\x02\x08\x1e\nq\n\x04\x04\n\x02\0\x12\x04\xac\x02\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\xac\x02\x02\n\n\r\n\x05\
    \x04\n\x02\0\x05\x12\x04\xac\x02\x0b\x11\n\r\n\x05\x04\n\x02\0\x01\x12\
    \x04\xac\x02\x12\x1c\n\r\n\x05\x04\n\x02\0\x03\x12\x04\xac\x02\x1f\x20b\
    \x06proto3\
";

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

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

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