sqlite-requests 0.0.2

// This file is generated by rust-protobuf 2.0.4. 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 ProtoQueryRequest {
    // message fields
    pub sql: ::std::string::String,
    pub queued_parameters: ::protobuf::SingularPtrField<ProtoQueuedParameters>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // string sql = 1;

    pub fn clear_sql(&mut self) {
        self.sql.clear();
    }

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

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

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

    pub fn get_sql(&self) -> &str {
        &self.sql
    }

    // .sqlite_commands.ProtoQueuedParameters queued_parameters = 2;

    pub fn clear_queued_parameters(&mut self) {
        self.queued_parameters.clear();
    }

    pub fn has_queued_parameters(&self) -> bool {
        self.queued_parameters.is_some()
    }

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

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

    // Take field
    pub fn take_queued_parameters(&mut self) -> ProtoQueuedParameters {
        self.queued_parameters.take().unwrap_or_else(|| ProtoQueuedParameters::new())
    }

    pub fn get_queued_parameters(&self) -> &ProtoQueuedParameters {
        self.queued_parameters.as_ref().unwrap_or_else(|| ProtoQueuedParameters::default_instance())
    }
}

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if !self.sql.is_empty() {
            os.write_string(1, &self.sql)?;
        }
        if let Some(ref v) = self.queued_parameters.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        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() -> ProtoQueryRequest {
        ProtoQueryRequest::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>(
                    "sql",
                    |m: &ProtoQueryRequest| { &m.sql },
                    |m: &mut ProtoQueryRequest| { &mut m.sql },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ProtoQueuedParameters>>(
                    "queued_parameters",
                    |m: &ProtoQueryRequest| { &m.queued_parameters },
                    |m: &mut ProtoQueryRequest| { &mut m.queued_parameters },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoQueryRequest>(
                    "ProtoQueryRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ProtoQueryRequest {
    fn clear(&mut self) {
        self.clear_sql();
        self.clear_queued_parameters();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ProtoQueuedParameters {
    // message oneof groups
    pub queued_parameters: ::std::option::Option<ProtoQueuedParameters_oneof_queued_parameters>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

#[derive(Clone,PartialEq)]
pub enum ProtoQueuedParameters_oneof_queued_parameters {
    queued_indexed_parameters(ProtoQueuedIndexedParameters),
    queued_named_parameters(ProtoQueuedNamedParameters),
}

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

    // .sqlite_commands.ProtoQueuedIndexedParameters queued_indexed_parameters = 1;

    pub fn clear_queued_indexed_parameters(&mut self) {
        self.queued_parameters = ::std::option::Option::None;
    }

    pub fn has_queued_indexed_parameters(&self) -> bool {
        match self.queued_parameters {
            ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_indexed_parameters(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_queued_indexed_parameters(&mut self, v: ProtoQueuedIndexedParameters) {
        self.queued_parameters = ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_indexed_parameters(v))
    }

    // Mutable pointer to the field.
    pub fn mut_queued_indexed_parameters(&mut self) -> &mut ProtoQueuedIndexedParameters {
        if let ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_indexed_parameters(_)) = self.queued_parameters {
        } else {
            self.queued_parameters = ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_indexed_parameters(ProtoQueuedIndexedParameters::new()));
        }
        match self.queued_parameters {
            ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_indexed_parameters(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_queued_indexed_parameters(&mut self) -> ProtoQueuedIndexedParameters {
        if self.has_queued_indexed_parameters() {
            match self.queued_parameters.take() {
                ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_indexed_parameters(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoQueuedIndexedParameters::new()
        }
    }

    pub fn get_queued_indexed_parameters(&self) -> &ProtoQueuedIndexedParameters {
        match self.queued_parameters {
            ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_indexed_parameters(ref v)) => v,
            _ => ProtoQueuedIndexedParameters::default_instance(),
        }
    }

    // .sqlite_commands.ProtoQueuedNamedParameters queued_named_parameters = 2;

    pub fn clear_queued_named_parameters(&mut self) {
        self.queued_parameters = ::std::option::Option::None;
    }

    pub fn has_queued_named_parameters(&self) -> bool {
        match self.queued_parameters {
            ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_named_parameters(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_queued_named_parameters(&mut self, v: ProtoQueuedNamedParameters) {
        self.queued_parameters = ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_named_parameters(v))
    }

    // Mutable pointer to the field.
    pub fn mut_queued_named_parameters(&mut self) -> &mut ProtoQueuedNamedParameters {
        if let ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_named_parameters(_)) = self.queued_parameters {
        } else {
            self.queued_parameters = ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_named_parameters(ProtoQueuedNamedParameters::new()));
        }
        match self.queued_parameters {
            ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_named_parameters(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_queued_named_parameters(&mut self) -> ProtoQueuedNamedParameters {
        if self.has_queued_named_parameters() {
            match self.queued_parameters.take() {
                ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_named_parameters(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoQueuedNamedParameters::new()
        }
    }

    pub fn get_queued_named_parameters(&self) -> &ProtoQueuedNamedParameters {
        match self.queued_parameters {
            ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_named_parameters(ref v)) => v,
            _ => ProtoQueuedNamedParameters::default_instance(),
        }
    }
}

impl ::protobuf::Message for ProtoQueuedParameters {
    fn is_initialized(&self) -> bool {
        if let Some(ProtoQueuedParameters_oneof_queued_parameters::queued_indexed_parameters(ref v)) = self.queued_parameters {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(ProtoQueuedParameters_oneof_queued_parameters::queued_named_parameters(ref v)) = self.queued_parameters {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.queued_parameters = ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_indexed_parameters(is.read_message()?));
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.queued_parameters = ::std::option::Option::Some(ProtoQueuedParameters_oneof_queued_parameters::queued_named_parameters(is.read_message()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.queued_parameters {
            match v {
                &ProtoQueuedParameters_oneof_queued_parameters::queued_indexed_parameters(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &ProtoQueuedParameters_oneof_queued_parameters::queued_named_parameters(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if let ::std::option::Option::Some(ref v) = self.queued_parameters {
            match v {
                &ProtoQueuedParameters_oneof_queued_parameters::queued_indexed_parameters(ref v) => {
                    os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &ProtoQueuedParameters_oneof_queued_parameters::queued_named_parameters(ref v) => {
                    os.write_tag(2, ::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() -> ProtoQueuedParameters {
        ProtoQueuedParameters::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_singular_message_accessor::<_, ProtoQueuedIndexedParameters>(
                    "queued_indexed_parameters",
                    ProtoQueuedParameters::has_queued_indexed_parameters,
                    ProtoQueuedParameters::get_queued_indexed_parameters,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ProtoQueuedNamedParameters>(
                    "queued_named_parameters",
                    ProtoQueuedParameters::has_queued_named_parameters,
                    ProtoQueuedParameters::get_queued_named_parameters,
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoQueuedParameters>(
                    "ProtoQueuedParameters",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ProtoQueuedParameters {
    fn clear(&mut self) {
        self.clear_queued_indexed_parameters();
        self.clear_queued_named_parameters();
        self.unknown_fields.clear();
    }
}

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

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

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

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

    // repeated .sqlite_commands.ProtoIndexedParameters queued_indexed_parameters = 1;

    pub fn clear_queued_indexed_parameters(&mut self) {
        self.queued_indexed_parameters.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_queued_indexed_parameters(&mut self) -> &mut ::protobuf::RepeatedField<ProtoIndexedParameters> {
        &mut self.queued_indexed_parameters
    }

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

    pub fn get_queued_indexed_parameters(&self) -> &[ProtoIndexedParameters] {
        &self.queued_indexed_parameters
    }
}

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.queued_indexed_parameters {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> ProtoQueuedIndexedParameters {
        ProtoQueuedIndexedParameters::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<ProtoIndexedParameters>>(
                    "queued_indexed_parameters",
                    |m: &ProtoQueuedIndexedParameters| { &m.queued_indexed_parameters },
                    |m: &mut ProtoQueuedIndexedParameters| { &mut m.queued_indexed_parameters },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoQueuedIndexedParameters>(
                    "ProtoQueuedIndexedParameters",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

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

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

    // repeated .sqlite_commands.ProtoNamedParameters queued_named_parameters = 1;

    pub fn clear_queued_named_parameters(&mut self) {
        self.queued_named_parameters.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_queued_named_parameters(&mut self) -> &mut ::protobuf::RepeatedField<ProtoNamedParameters> {
        &mut self.queued_named_parameters
    }

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

    pub fn get_queued_named_parameters(&self) -> &[ProtoNamedParameters] {
        &self.queued_named_parameters
    }
}

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.queued_named_parameters {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> ProtoQueuedNamedParameters {
        ProtoQueuedNamedParameters::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<ProtoNamedParameters>>(
                    "queued_named_parameters",
                    |m: &ProtoQueuedNamedParameters| { &m.queued_named_parameters },
                    |m: &mut ProtoQueuedNamedParameters| { &mut m.queued_named_parameters },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoQueuedNamedParameters>(
                    "ProtoQueuedNamedParameters",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

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

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

    // repeated .sqlite_commands.ProtoValue parameters = 1;

    pub fn clear_parameters(&mut self) {
        self.parameters.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_parameters(&mut self) -> &mut ::protobuf::RepeatedField<ProtoValue> {
        &mut self.parameters
    }

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

    pub fn get_parameters(&self) -> &[ProtoValue] {
        &self.parameters
    }
}

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.parameters {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> ProtoIndexedParameters {
        ProtoIndexedParameters::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<ProtoValue>>(
                    "parameters",
                    |m: &ProtoIndexedParameters| { &m.parameters },
                    |m: &mut ProtoIndexedParameters| { &mut m.parameters },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoIndexedParameters>(
                    "ProtoIndexedParameters",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

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

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

    // repeated .sqlite_commands.ProtoNamedParameter parameters = 1;

    pub fn clear_parameters(&mut self) {
        self.parameters.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_parameters(&mut self) -> &mut ::protobuf::RepeatedField<ProtoNamedParameter> {
        &mut self.parameters
    }

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

    pub fn get_parameters(&self) -> &[ProtoNamedParameter] {
        &self.parameters
    }
}

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.parameters {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> ProtoNamedParameters {
        ProtoNamedParameters::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<ProtoNamedParameter>>(
                    "parameters",
                    |m: &ProtoNamedParameters| { &m.parameters },
                    |m: &mut ProtoNamedParameters| { &mut m.parameters },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoNamedParameters>(
                    "ProtoNamedParameters",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

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

impl ProtoNamedParameter {
    pub fn new() -> ProtoNamedParameter {
        ::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
    }

    // .sqlite_commands.ProtoValue value = 2;

    pub fn clear_value(&mut self) {
        self.value.clear();
    }

    pub fn has_value(&self) -> bool {
        self.value.is_some()
    }

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

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

    // Take field
    pub fn take_value(&mut self) -> ProtoValue {
        self.value.take().unwrap_or_else(|| ProtoValue::new())
    }

    pub fn get_value(&self) -> &ProtoValue {
        self.value.as_ref().unwrap_or_else(|| ProtoValue::default_instance())
    }
}

impl ::protobuf::Message for ProtoNamedParameter {
    fn is_initialized(&self) -> bool {
        for v in &self.value {
            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.name)?;
                },
                2 => {
                    ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.value)?;
                },
                _ => {
                    ::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 let Some(ref v) = self.value.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if !self.name.is_empty() {
            os.write_string(1, &self.name)?;
        }
        if let Some(ref v) = self.value.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        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() -> ProtoNamedParameter {
        ProtoNamedParameter::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: &ProtoNamedParameter| { &m.name },
                    |m: &mut ProtoNamedParameter| { &mut m.name },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ProtoValue>>(
                    "value",
                    |m: &ProtoNamedParameter| { &m.value },
                    |m: &mut ProtoNamedParameter| { &mut m.value },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoNamedParameter>(
                    "ProtoNamedParameter",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ProtoNamedParameter {
    fn clear(&mut self) {
        self.clear_name();
        self.clear_value();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ProtoValue {
    // message oneof groups
    pub value: ::std::option::Option<ProtoValue_oneof_value>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

#[derive(Clone,PartialEq)]
pub enum ProtoValue_oneof_value {
    null(ProtoNull),
    integer(i64),
    real(f64),
    text(::std::string::String),
    blob(::std::vec::Vec<u8>),
}

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

    // .sqlite_commands.ProtoNull null = 1;

    pub fn clear_null(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_null(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(ProtoValue_oneof_value::null(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_null(&mut self, v: ProtoNull) {
        self.value = ::std::option::Option::Some(ProtoValue_oneof_value::null(v))
    }

    // Mutable pointer to the field.
    pub fn mut_null(&mut self) -> &mut ProtoNull {
        if let ::std::option::Option::Some(ProtoValue_oneof_value::null(_)) = self.value {
        } else {
            self.value = ::std::option::Option::Some(ProtoValue_oneof_value::null(ProtoNull::new()));
        }
        match self.value {
            ::std::option::Option::Some(ProtoValue_oneof_value::null(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_null(&mut self) -> ProtoNull {
        if self.has_null() {
            match self.value.take() {
                ::std::option::Option::Some(ProtoValue_oneof_value::null(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoNull::new()
        }
    }

    pub fn get_null(&self) -> &ProtoNull {
        match self.value {
            ::std::option::Option::Some(ProtoValue_oneof_value::null(ref v)) => v,
            _ => ProtoNull::default_instance(),
        }
    }

    // int64 integer = 2;

    pub fn clear_integer(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_integer(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(ProtoValue_oneof_value::integer(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_integer(&mut self, v: i64) {
        self.value = ::std::option::Option::Some(ProtoValue_oneof_value::integer(v))
    }

    pub fn get_integer(&self) -> i64 {
        match self.value {
            ::std::option::Option::Some(ProtoValue_oneof_value::integer(v)) => v,
            _ => 0,
        }
    }

    // double real = 3;

    pub fn clear_real(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_real(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(ProtoValue_oneof_value::real(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_real(&mut self, v: f64) {
        self.value = ::std::option::Option::Some(ProtoValue_oneof_value::real(v))
    }

    pub fn get_real(&self) -> f64 {
        match self.value {
            ::std::option::Option::Some(ProtoValue_oneof_value::real(v)) => v,
            _ => 0.,
        }
    }

    // string text = 4;

    pub fn clear_text(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_text(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(ProtoValue_oneof_value::text(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_text(&mut self, v: ::std::string::String) {
        self.value = ::std::option::Option::Some(ProtoValue_oneof_value::text(v))
    }

    // Mutable pointer to the field.
    pub fn mut_text(&mut self) -> &mut ::std::string::String {
        if let ::std::option::Option::Some(ProtoValue_oneof_value::text(_)) = self.value {
        } else {
            self.value = ::std::option::Option::Some(ProtoValue_oneof_value::text(::std::string::String::new()));
        }
        match self.value {
            ::std::option::Option::Some(ProtoValue_oneof_value::text(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_text(&mut self) -> ::std::string::String {
        if self.has_text() {
            match self.value.take() {
                ::std::option::Option::Some(ProtoValue_oneof_value::text(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::string::String::new()
        }
    }

    pub fn get_text(&self) -> &str {
        match self.value {
            ::std::option::Option::Some(ProtoValue_oneof_value::text(ref v)) => v,
            _ => "",
        }
    }

    // bytes blob = 5;

    pub fn clear_blob(&mut self) {
        self.value = ::std::option::Option::None;
    }

    pub fn has_blob(&self) -> bool {
        match self.value {
            ::std::option::Option::Some(ProtoValue_oneof_value::blob(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_blob(&mut self, v: ::std::vec::Vec<u8>) {
        self.value = ::std::option::Option::Some(ProtoValue_oneof_value::blob(v))
    }

    // Mutable pointer to the field.
    pub fn mut_blob(&mut self) -> &mut ::std::vec::Vec<u8> {
        if let ::std::option::Option::Some(ProtoValue_oneof_value::blob(_)) = self.value {
        } else {
            self.value = ::std::option::Option::Some(ProtoValue_oneof_value::blob(::std::vec::Vec::new()));
        }
        match self.value {
            ::std::option::Option::Some(ProtoValue_oneof_value::blob(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_blob(&mut self) -> ::std::vec::Vec<u8> {
        if self.has_blob() {
            match self.value.take() {
                ::std::option::Option::Some(ProtoValue_oneof_value::blob(v)) => v,
                _ => panic!(),
            }
        } else {
            ::std::vec::Vec::new()
        }
    }

    pub fn get_blob(&self) -> &[u8] {
        match self.value {
            ::std::option::Option::Some(ProtoValue_oneof_value::blob(ref v)) => v,
            _ => &[],
        }
    }
}

impl ::protobuf::Message for ProtoValue {
    fn is_initialized(&self) -> bool {
        if let Some(ProtoValue_oneof_value::null(ref v)) = self.value {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.value = ::std::option::Option::Some(ProtoValue_oneof_value::null(is.read_message()?));
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.value = ::std::option::Option::Some(ProtoValue_oneof_value::integer(is.read_int64()?));
                },
                3 => {
                    if wire_type != ::protobuf::wire_format::WireTypeFixed64 {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.value = ::std::option::Option::Some(ProtoValue_oneof_value::real(is.read_double()?));
                },
                4 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.value = ::std::option::Option::Some(ProtoValue_oneof_value::text(is.read_string()?));
                },
                5 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.value = ::std::option::Option::Some(ProtoValue_oneof_value::blob(is.read_bytes()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.value {
            match v {
                &ProtoValue_oneof_value::null(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &ProtoValue_oneof_value::integer(v) => {
                    my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
                },
                &ProtoValue_oneof_value::real(v) => {
                    my_size += 9;
                },
                &ProtoValue_oneof_value::text(ref v) => {
                    my_size += ::protobuf::rt::string_size(4, &v);
                },
                &ProtoValue_oneof_value::blob(ref v) => {
                    my_size += ::protobuf::rt::bytes_size(5, &v);
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if let ::std::option::Option::Some(ref v) = self.value {
            match v {
                &ProtoValue_oneof_value::null(ref v) => {
                    os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &ProtoValue_oneof_value::integer(v) => {
                    os.write_int64(2, v)?;
                },
                &ProtoValue_oneof_value::real(v) => {
                    os.write_double(3, v)?;
                },
                &ProtoValue_oneof_value::text(ref v) => {
                    os.write_string(4, v)?;
                },
                &ProtoValue_oneof_value::blob(ref v) => {
                    os.write_bytes(5, 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() -> ProtoValue {
        ProtoValue::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_singular_message_accessor::<_, ProtoNull>(
                    "null",
                    ProtoValue::has_null,
                    ProtoValue::get_null,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_i64_accessor::<_>(
                    "integer",
                    ProtoValue::has_integer,
                    ProtoValue::get_integer,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_f64_accessor::<_>(
                    "real",
                    ProtoValue::has_real,
                    ProtoValue::get_real,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_string_accessor::<_>(
                    "text",
                    ProtoValue::has_text,
                    ProtoValue::get_text,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_bytes_accessor::<_>(
                    "blob",
                    ProtoValue::has_blob,
                    ProtoValue::get_blob,
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoValue>(
                    "ProtoValue",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ProtoValue {
    fn clear(&mut self) {
        self.clear_null();
        self.clear_integer();
        self.clear_real();
        self.clear_text();
        self.clear_blob();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ProtoNull {
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

impl ::protobuf::Message for ProtoNull {
    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 {
                _ => {
                    ::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;
        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<()> {
        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() -> ProtoNull {
        ProtoNull::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 fields = ::std::vec::Vec::new();
                ::protobuf::reflect::MessageDescriptor::new::<ProtoNull>(
                    "ProtoNull",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

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

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

    // repeated .sqlite_commands.ProtoQueryResultSet query_result_sets = 1;

    pub fn clear_query_result_sets(&mut self) {
        self.query_result_sets.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_query_result_sets(&mut self) -> &mut ::protobuf::RepeatedField<ProtoQueryResultSet> {
        &mut self.query_result_sets
    }

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

    pub fn get_query_result_sets(&self) -> &[ProtoQueryResultSet] {
        &self.query_result_sets
    }
}

impl ::protobuf::Message for ProtoQueryResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.query_result_sets {
            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.query_result_sets)?;
                },
                _ => {
                    ::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.query_result_sets {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.query_result_sets {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> ProtoQueryResponse {
        ProtoQueryResponse::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<ProtoQueryResultSet>>(
                    "query_result_sets",
                    |m: &ProtoQueryResponse| { &m.query_result_sets },
                    |m: &mut ProtoQueryResponse| { &mut m.query_result_sets },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoQueryResponse>(
                    "ProtoQueryResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

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

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

    // repeated .sqlite_commands.ProtoQueryResultRow rows = 1;

    pub fn clear_rows(&mut self) {
        self.rows.clear();
    }

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

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

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

    pub fn get_rows(&self) -> &[ProtoQueryResultRow] {
        &self.rows
    }
}

impl ::protobuf::Message for ProtoQueryResultSet {
    fn is_initialized(&self) -> bool {
        for v in &self.rows {
            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.rows)?;
                },
                _ => {
                    ::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.rows {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.rows {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> ProtoQueryResultSet {
        ProtoQueryResultSet::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<ProtoQueryResultRow>>(
                    "rows",
                    |m: &ProtoQueryResultSet| { &m.rows },
                    |m: &mut ProtoQueryResultSet| { &mut m.rows },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoQueryResultSet>(
                    "ProtoQueryResultSet",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

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

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

    // repeated .sqlite_commands.ProtoValue row = 1;

    pub fn clear_row(&mut self) {
        self.row.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_row(&mut self) -> &mut ::protobuf::RepeatedField<ProtoValue> {
        &mut self.row
    }

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

    pub fn get_row(&self) -> &[ProtoValue] {
        &self.row
    }
}

impl ::protobuf::Message for ProtoQueryResultRow {
    fn is_initialized(&self) -> bool {
        for v in &self.row {
            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.row)?;
                },
                _ => {
                    ::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.row {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.row {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> ProtoQueryResultRow {
        ProtoQueryResultRow::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<ProtoValue>>(
                    "row",
                    |m: &ProtoQueryResultRow| { &m.row },
                    |m: &mut ProtoQueryResultRow| { &mut m.row },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoQueryResultRow>(
                    "ProtoQueryResultRow",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ProtoExecuteRequest {
    // message fields
    pub sql: ::std::string::String,
    pub queued_parameters: ::protobuf::SingularPtrField<ProtoQueuedParameters>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // string sql = 1;

    pub fn clear_sql(&mut self) {
        self.sql.clear();
    }

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

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

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

    pub fn get_sql(&self) -> &str {
        &self.sql
    }

    // .sqlite_commands.ProtoQueuedParameters queued_parameters = 2;

    pub fn clear_queued_parameters(&mut self) {
        self.queued_parameters.clear();
    }

    pub fn has_queued_parameters(&self) -> bool {
        self.queued_parameters.is_some()
    }

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

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

    // Take field
    pub fn take_queued_parameters(&mut self) -> ProtoQueuedParameters {
        self.queued_parameters.take().unwrap_or_else(|| ProtoQueuedParameters::new())
    }

    pub fn get_queued_parameters(&self) -> &ProtoQueuedParameters {
        self.queued_parameters.as_ref().unwrap_or_else(|| ProtoQueuedParameters::default_instance())
    }
}

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

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

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

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if !self.sql.is_empty() {
            os.write_string(1, &self.sql)?;
        }
        if let Some(ref v) = self.queued_parameters.as_ref() {
            os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        }
        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() -> ProtoExecuteRequest {
        ProtoExecuteRequest::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>(
                    "sql",
                    |m: &ProtoExecuteRequest| { &m.sql },
                    |m: &mut ProtoExecuteRequest| { &mut m.sql },
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<ProtoQueuedParameters>>(
                    "queued_parameters",
                    |m: &ProtoExecuteRequest| { &m.queued_parameters },
                    |m: &mut ProtoExecuteRequest| { &mut m.queued_parameters },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoExecuteRequest>(
                    "ProtoExecuteRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ProtoExecuteRequest {
    fn clear(&mut self) {
        self.clear_sql();
        self.clear_queued_parameters();
        self.unknown_fields.clear();
    }
}

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

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

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

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

    // repeated .sqlite_commands.ProtoExecuteResult execute_results = 1;

    pub fn clear_execute_results(&mut self) {
        self.execute_results.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_execute_results(&mut self) -> &mut ::protobuf::RepeatedField<ProtoExecuteResult> {
        &mut self.execute_results
    }

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

    pub fn get_execute_results(&self) -> &[ProtoExecuteResult] {
        &self.execute_results
    }
}

impl ::protobuf::Message for ProtoExecuteResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.execute_results {
            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.execute_results)?;
                },
                _ => {
                    ::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.execute_results {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.execute_results {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> ProtoExecuteResponse {
        ProtoExecuteResponse::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<ProtoExecuteResult>>(
                    "execute_results",
                    |m: &ProtoExecuteResponse| { &m.execute_results },
                    |m: &mut ProtoExecuteResponse| { &mut m.execute_results },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoExecuteResponse>(
                    "ProtoExecuteResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ProtoExecuteResult {
    // message fields
    pub changes: u64,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // uint64 changes = 1;

    pub fn clear_changes(&mut self) {
        self.changes = 0;
    }

    // Param is passed by value, moved
    pub fn set_changes(&mut self, v: u64) {
        self.changes = v;
    }

    pub fn get_changes(&self) -> u64 {
        self.changes
    }
}

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

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    let tmp = is.read_uint64()?;
                    self.changes = tmp;
                },
                _ => {
                    ::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.changes != 0 {
            my_size += ::protobuf::rt::value_size(1, self.changes, ::protobuf::wire_format::WireTypeVarint);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if self.changes != 0 {
            os.write_uint64(1, self.changes)?;
        }
        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() -> ProtoExecuteResult {
        ProtoExecuteResult::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::ProtobufTypeUint64>(
                    "changes",
                    |m: &ProtoExecuteResult| { &m.changes },
                    |m: &mut ProtoExecuteResult| { &mut m.changes },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoExecuteResult>(
                    "ProtoExecuteResult",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

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

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

    // repeated .sqlite_commands.ProtoQueryRequest queries = 1;

    pub fn clear_queries(&mut self) {
        self.queries.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_queries(&mut self) -> &mut ::protobuf::RepeatedField<ProtoQueryRequest> {
        &mut self.queries
    }

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

    pub fn get_queries(&self) -> &[ProtoQueryRequest] {
        &self.queries
    }
}

impl ::protobuf::Message for ProtoBulkQueryRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.queries {
            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.queries)?;
                },
                _ => {
                    ::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.queries {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.queries {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> ProtoBulkQueryRequest {
        ProtoBulkQueryRequest::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<ProtoQueryRequest>>(
                    "queries",
                    |m: &ProtoBulkQueryRequest| { &m.queries },
                    |m: &mut ProtoBulkQueryRequest| { &mut m.queries },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoBulkQueryRequest>(
                    "ProtoBulkQueryRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

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

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

    // repeated .sqlite_commands.ProtoQueryResponse query_responses = 1;

    pub fn clear_query_responses(&mut self) {
        self.query_responses.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_query_responses(&mut self) -> &mut ::protobuf::RepeatedField<ProtoQueryResponse> {
        &mut self.query_responses
    }

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

    pub fn get_query_responses(&self) -> &[ProtoQueryResponse] {
        &self.query_responses
    }
}

impl ::protobuf::Message for ProtoBulkQueryResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.query_responses {
            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.query_responses)?;
                },
                _ => {
                    ::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.query_responses {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.query_responses {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> ProtoBulkQueryResponse {
        ProtoBulkQueryResponse::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<ProtoQueryResponse>>(
                    "query_responses",
                    |m: &ProtoBulkQueryResponse| { &m.query_responses },
                    |m: &mut ProtoBulkQueryResponse| { &mut m.query_responses },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoBulkQueryResponse>(
                    "ProtoBulkQueryResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

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

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

    // repeated .sqlite_commands.ProtoExecuteRequest executes = 1;

    pub fn clear_executes(&mut self) {
        self.executes.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_executes(&mut self) -> &mut ::protobuf::RepeatedField<ProtoExecuteRequest> {
        &mut self.executes
    }

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

    pub fn get_executes(&self) -> &[ProtoExecuteRequest] {
        &self.executes
    }
}

impl ::protobuf::Message for ProtoBulkExecuteRequest {
    fn is_initialized(&self) -> bool {
        for v in &self.executes {
            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.executes)?;
                },
                _ => {
                    ::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.executes {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.executes {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> ProtoBulkExecuteRequest {
        ProtoBulkExecuteRequest::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<ProtoExecuteRequest>>(
                    "executes",
                    |m: &ProtoBulkExecuteRequest| { &m.executes },
                    |m: &mut ProtoBulkExecuteRequest| { &mut m.executes },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoBulkExecuteRequest>(
                    "ProtoBulkExecuteRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

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

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

    // repeated .sqlite_commands.ProtoExecuteResponse execute_responses = 1;

    pub fn clear_execute_responses(&mut self) {
        self.execute_responses.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_execute_responses(&mut self) -> &mut ::protobuf::RepeatedField<ProtoExecuteResponse> {
        &mut self.execute_responses
    }

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

    pub fn get_execute_responses(&self) -> &[ProtoExecuteResponse] {
        &self.execute_responses
    }
}

impl ::protobuf::Message for ProtoBulkExecuteResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.execute_responses {
            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.execute_responses)?;
                },
                _ => {
                    ::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.execute_responses {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        for v in &self.execute_responses {
            os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
            os.write_raw_varint32(v.get_cached_size())?;
            v.write_to_with_cached_sizes(os)?;
        };
        os.write_unknown_fields(self.get_unknown_fields())?;
        ::std::result::Result::Ok(())
    }

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

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

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

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

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

    fn new() -> ProtoBulkExecuteResponse {
        ProtoBulkExecuteResponse::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<ProtoExecuteResponse>>(
                    "execute_responses",
                    |m: &ProtoBulkExecuteResponse| { &m.execute_responses },
                    |m: &mut ProtoBulkExecuteResponse| { &mut m.execute_responses },
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoBulkExecuteResponse>(
                    "ProtoBulkExecuteResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

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

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ProtoSqliteRequest {
    // message oneof groups
    pub request: ::std::option::Option<ProtoSqliteRequest_oneof_request>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

#[derive(Clone,PartialEq)]
pub enum ProtoSqliteRequest_oneof_request {
    query(ProtoSqliteQuery),
    execute(ProtoSqliteExecute),
}

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

    // .sqlite_commands.ProtoSqliteQuery query = 1;

    pub fn clear_query(&mut self) {
        self.request = ::std::option::Option::None;
    }

    pub fn has_query(&self) -> bool {
        match self.request {
            ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::query(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_query(&mut self, v: ProtoSqliteQuery) {
        self.request = ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::query(v))
    }

    // Mutable pointer to the field.
    pub fn mut_query(&mut self) -> &mut ProtoSqliteQuery {
        if let ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::query(_)) = self.request {
        } else {
            self.request = ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::query(ProtoSqliteQuery::new()));
        }
        match self.request {
            ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::query(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_query(&mut self) -> ProtoSqliteQuery {
        if self.has_query() {
            match self.request.take() {
                ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::query(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoSqliteQuery::new()
        }
    }

    pub fn get_query(&self) -> &ProtoSqliteQuery {
        match self.request {
            ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::query(ref v)) => v,
            _ => ProtoSqliteQuery::default_instance(),
        }
    }

    // .sqlite_commands.ProtoSqliteExecute execute = 2;

    pub fn clear_execute(&mut self) {
        self.request = ::std::option::Option::None;
    }

    pub fn has_execute(&self) -> bool {
        match self.request {
            ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::execute(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_execute(&mut self, v: ProtoSqliteExecute) {
        self.request = ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::execute(v))
    }

    // Mutable pointer to the field.
    pub fn mut_execute(&mut self) -> &mut ProtoSqliteExecute {
        if let ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::execute(_)) = self.request {
        } else {
            self.request = ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::execute(ProtoSqliteExecute::new()));
        }
        match self.request {
            ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::execute(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_execute(&mut self) -> ProtoSqliteExecute {
        if self.has_execute() {
            match self.request.take() {
                ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::execute(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoSqliteExecute::new()
        }
    }

    pub fn get_execute(&self) -> &ProtoSqliteExecute {
        match self.request {
            ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::execute(ref v)) => v,
            _ => ProtoSqliteExecute::default_instance(),
        }
    }
}

impl ::protobuf::Message for ProtoSqliteRequest {
    fn is_initialized(&self) -> bool {
        if let Some(ProtoSqliteRequest_oneof_request::query(ref v)) = self.request {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(ProtoSqliteRequest_oneof_request::execute(ref v)) = self.request {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.request = ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::query(is.read_message()?));
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.request = ::std::option::Option::Some(ProtoSqliteRequest_oneof_request::execute(is.read_message()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.request {
            match v {
                &ProtoSqliteRequest_oneof_request::query(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &ProtoSqliteRequest_oneof_request::execute(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if let ::std::option::Option::Some(ref v) = self.request {
            match v {
                &ProtoSqliteRequest_oneof_request::query(ref v) => {
                    os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &ProtoSqliteRequest_oneof_request::execute(ref v) => {
                    os.write_tag(2, ::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() -> ProtoSqliteRequest {
        ProtoSqliteRequest::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_singular_message_accessor::<_, ProtoSqliteQuery>(
                    "query",
                    ProtoSqliteRequest::has_query,
                    ProtoSqliteRequest::get_query,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ProtoSqliteExecute>(
                    "execute",
                    ProtoSqliteRequest::has_execute,
                    ProtoSqliteRequest::get_execute,
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoSqliteRequest>(
                    "ProtoSqliteRequest",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ProtoSqliteRequest {
    fn clear(&mut self) {
        self.clear_query();
        self.clear_execute();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ProtoSqliteResponse {
    // message oneof groups
    pub response: ::std::option::Option<ProtoSqliteResponse_oneof_response>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

#[derive(Clone,PartialEq)]
pub enum ProtoSqliteResponse_oneof_response {
    query(ProtoSqliteQueryResponse),
    execute(ProtoSqliteExecuteResponse),
}

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

    // .sqlite_commands.ProtoSqliteQueryResponse query = 1;

    pub fn clear_query(&mut self) {
        self.response = ::std::option::Option::None;
    }

    pub fn has_query(&self) -> bool {
        match self.response {
            ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::query(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_query(&mut self, v: ProtoSqliteQueryResponse) {
        self.response = ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::query(v))
    }

    // Mutable pointer to the field.
    pub fn mut_query(&mut self) -> &mut ProtoSqliteQueryResponse {
        if let ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::query(_)) = self.response {
        } else {
            self.response = ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::query(ProtoSqliteQueryResponse::new()));
        }
        match self.response {
            ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::query(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_query(&mut self) -> ProtoSqliteQueryResponse {
        if self.has_query() {
            match self.response.take() {
                ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::query(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoSqliteQueryResponse::new()
        }
    }

    pub fn get_query(&self) -> &ProtoSqliteQueryResponse {
        match self.response {
            ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::query(ref v)) => v,
            _ => ProtoSqliteQueryResponse::default_instance(),
        }
    }

    // .sqlite_commands.ProtoSqliteExecuteResponse execute = 2;

    pub fn clear_execute(&mut self) {
        self.response = ::std::option::Option::None;
    }

    pub fn has_execute(&self) -> bool {
        match self.response {
            ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::execute(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_execute(&mut self, v: ProtoSqliteExecuteResponse) {
        self.response = ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::execute(v))
    }

    // Mutable pointer to the field.
    pub fn mut_execute(&mut self) -> &mut ProtoSqliteExecuteResponse {
        if let ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::execute(_)) = self.response {
        } else {
            self.response = ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::execute(ProtoSqliteExecuteResponse::new()));
        }
        match self.response {
            ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::execute(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_execute(&mut self) -> ProtoSqliteExecuteResponse {
        if self.has_execute() {
            match self.response.take() {
                ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::execute(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoSqliteExecuteResponse::new()
        }
    }

    pub fn get_execute(&self) -> &ProtoSqliteExecuteResponse {
        match self.response {
            ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::execute(ref v)) => v,
            _ => ProtoSqliteExecuteResponse::default_instance(),
        }
    }
}

impl ::protobuf::Message for ProtoSqliteResponse {
    fn is_initialized(&self) -> bool {
        if let Some(ProtoSqliteResponse_oneof_response::query(ref v)) = self.response {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(ProtoSqliteResponse_oneof_response::execute(ref v)) = self.response {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.response = ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::query(is.read_message()?));
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.response = ::std::option::Option::Some(ProtoSqliteResponse_oneof_response::execute(is.read_message()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.response {
            match v {
                &ProtoSqliteResponse_oneof_response::query(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &ProtoSqliteResponse_oneof_response::execute(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if let ::std::option::Option::Some(ref v) = self.response {
            match v {
                &ProtoSqliteResponse_oneof_response::query(ref v) => {
                    os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &ProtoSqliteResponse_oneof_response::execute(ref v) => {
                    os.write_tag(2, ::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() -> ProtoSqliteResponse {
        ProtoSqliteResponse::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_singular_message_accessor::<_, ProtoSqliteQueryResponse>(
                    "query",
                    ProtoSqliteResponse::has_query,
                    ProtoSqliteResponse::get_query,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ProtoSqliteExecuteResponse>(
                    "execute",
                    ProtoSqliteResponse::has_execute,
                    ProtoSqliteResponse::get_execute,
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoSqliteResponse>(
                    "ProtoSqliteResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ProtoSqliteResponse {
    fn clear(&mut self) {
        self.clear_query();
        self.clear_execute();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ProtoSqliteQuery {
    // message oneof groups
    pub query: ::std::option::Option<ProtoSqliteQuery_oneof_query>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

#[derive(Clone,PartialEq)]
pub enum ProtoSqliteQuery_oneof_query {
    single(ProtoQueryRequest),
    bulk(ProtoBulkQueryRequest),
}

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

    // .sqlite_commands.ProtoQueryRequest single = 1;

    pub fn clear_single(&mut self) {
        self.query = ::std::option::Option::None;
    }

    pub fn has_single(&self) -> bool {
        match self.query {
            ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::single(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_single(&mut self, v: ProtoQueryRequest) {
        self.query = ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::single(v))
    }

    // Mutable pointer to the field.
    pub fn mut_single(&mut self) -> &mut ProtoQueryRequest {
        if let ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::single(_)) = self.query {
        } else {
            self.query = ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::single(ProtoQueryRequest::new()));
        }
        match self.query {
            ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::single(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_single(&mut self) -> ProtoQueryRequest {
        if self.has_single() {
            match self.query.take() {
                ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::single(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoQueryRequest::new()
        }
    }

    pub fn get_single(&self) -> &ProtoQueryRequest {
        match self.query {
            ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::single(ref v)) => v,
            _ => ProtoQueryRequest::default_instance(),
        }
    }

    // .sqlite_commands.ProtoBulkQueryRequest bulk = 2;

    pub fn clear_bulk(&mut self) {
        self.query = ::std::option::Option::None;
    }

    pub fn has_bulk(&self) -> bool {
        match self.query {
            ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::bulk(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_bulk(&mut self, v: ProtoBulkQueryRequest) {
        self.query = ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::bulk(v))
    }

    // Mutable pointer to the field.
    pub fn mut_bulk(&mut self) -> &mut ProtoBulkQueryRequest {
        if let ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::bulk(_)) = self.query {
        } else {
            self.query = ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::bulk(ProtoBulkQueryRequest::new()));
        }
        match self.query {
            ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::bulk(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_bulk(&mut self) -> ProtoBulkQueryRequest {
        if self.has_bulk() {
            match self.query.take() {
                ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::bulk(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoBulkQueryRequest::new()
        }
    }

    pub fn get_bulk(&self) -> &ProtoBulkQueryRequest {
        match self.query {
            ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::bulk(ref v)) => v,
            _ => ProtoBulkQueryRequest::default_instance(),
        }
    }
}

impl ::protobuf::Message for ProtoSqliteQuery {
    fn is_initialized(&self) -> bool {
        if let Some(ProtoSqliteQuery_oneof_query::single(ref v)) = self.query {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(ProtoSqliteQuery_oneof_query::bulk(ref v)) = self.query {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.query = ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::single(is.read_message()?));
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.query = ::std::option::Option::Some(ProtoSqliteQuery_oneof_query::bulk(is.read_message()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.query {
            match v {
                &ProtoSqliteQuery_oneof_query::single(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &ProtoSqliteQuery_oneof_query::bulk(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if let ::std::option::Option::Some(ref v) = self.query {
            match v {
                &ProtoSqliteQuery_oneof_query::single(ref v) => {
                    os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &ProtoSqliteQuery_oneof_query::bulk(ref v) => {
                    os.write_tag(2, ::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() -> ProtoSqliteQuery {
        ProtoSqliteQuery::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_singular_message_accessor::<_, ProtoQueryRequest>(
                    "single",
                    ProtoSqliteQuery::has_single,
                    ProtoSqliteQuery::get_single,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ProtoBulkQueryRequest>(
                    "bulk",
                    ProtoSqliteQuery::has_bulk,
                    ProtoSqliteQuery::get_bulk,
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoSqliteQuery>(
                    "ProtoSqliteQuery",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ProtoSqliteQuery {
    fn clear(&mut self) {
        self.clear_single();
        self.clear_bulk();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ProtoSqliteQueryResponse {
    // message oneof groups
    pub response: ::std::option::Option<ProtoSqliteQueryResponse_oneof_response>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

#[derive(Clone,PartialEq)]
pub enum ProtoSqliteQueryResponse_oneof_response {
    single(ProtoQueryResponse),
    bulk(ProtoBulkQueryResponse),
}

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

    // .sqlite_commands.ProtoQueryResponse single = 1;

    pub fn clear_single(&mut self) {
        self.response = ::std::option::Option::None;
    }

    pub fn has_single(&self) -> bool {
        match self.response {
            ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::single(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_single(&mut self, v: ProtoQueryResponse) {
        self.response = ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::single(v))
    }

    // Mutable pointer to the field.
    pub fn mut_single(&mut self) -> &mut ProtoQueryResponse {
        if let ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::single(_)) = self.response {
        } else {
            self.response = ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::single(ProtoQueryResponse::new()));
        }
        match self.response {
            ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::single(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_single(&mut self) -> ProtoQueryResponse {
        if self.has_single() {
            match self.response.take() {
                ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::single(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoQueryResponse::new()
        }
    }

    pub fn get_single(&self) -> &ProtoQueryResponse {
        match self.response {
            ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::single(ref v)) => v,
            _ => ProtoQueryResponse::default_instance(),
        }
    }

    // .sqlite_commands.ProtoBulkQueryResponse bulk = 2;

    pub fn clear_bulk(&mut self) {
        self.response = ::std::option::Option::None;
    }

    pub fn has_bulk(&self) -> bool {
        match self.response {
            ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::bulk(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_bulk(&mut self, v: ProtoBulkQueryResponse) {
        self.response = ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::bulk(v))
    }

    // Mutable pointer to the field.
    pub fn mut_bulk(&mut self) -> &mut ProtoBulkQueryResponse {
        if let ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::bulk(_)) = self.response {
        } else {
            self.response = ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::bulk(ProtoBulkQueryResponse::new()));
        }
        match self.response {
            ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::bulk(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_bulk(&mut self) -> ProtoBulkQueryResponse {
        if self.has_bulk() {
            match self.response.take() {
                ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::bulk(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoBulkQueryResponse::new()
        }
    }

    pub fn get_bulk(&self) -> &ProtoBulkQueryResponse {
        match self.response {
            ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::bulk(ref v)) => v,
            _ => ProtoBulkQueryResponse::default_instance(),
        }
    }
}

impl ::protobuf::Message for ProtoSqliteQueryResponse {
    fn is_initialized(&self) -> bool {
        if let Some(ProtoSqliteQueryResponse_oneof_response::single(ref v)) = self.response {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(ProtoSqliteQueryResponse_oneof_response::bulk(ref v)) = self.response {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.response = ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::single(is.read_message()?));
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.response = ::std::option::Option::Some(ProtoSqliteQueryResponse_oneof_response::bulk(is.read_message()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.response {
            match v {
                &ProtoSqliteQueryResponse_oneof_response::single(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &ProtoSqliteQueryResponse_oneof_response::bulk(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if let ::std::option::Option::Some(ref v) = self.response {
            match v {
                &ProtoSqliteQueryResponse_oneof_response::single(ref v) => {
                    os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &ProtoSqliteQueryResponse_oneof_response::bulk(ref v) => {
                    os.write_tag(2, ::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() -> ProtoSqliteQueryResponse {
        ProtoSqliteQueryResponse::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_singular_message_accessor::<_, ProtoQueryResponse>(
                    "single",
                    ProtoSqliteQueryResponse::has_single,
                    ProtoSqliteQueryResponse::get_single,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ProtoBulkQueryResponse>(
                    "bulk",
                    ProtoSqliteQueryResponse::has_bulk,
                    ProtoSqliteQueryResponse::get_bulk,
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoSqliteQueryResponse>(
                    "ProtoSqliteQueryResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ProtoSqliteQueryResponse {
    fn clear(&mut self) {
        self.clear_single();
        self.clear_bulk();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ProtoSqliteExecute {
    // message oneof groups
    pub execute: ::std::option::Option<ProtoSqliteExecute_oneof_execute>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

#[derive(Clone,PartialEq)]
pub enum ProtoSqliteExecute_oneof_execute {
    single(ProtoExecuteRequest),
    bulk(ProtoBulkExecuteRequest),
}

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

    // .sqlite_commands.ProtoExecuteRequest single = 1;

    pub fn clear_single(&mut self) {
        self.execute = ::std::option::Option::None;
    }

    pub fn has_single(&self) -> bool {
        match self.execute {
            ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::single(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_single(&mut self, v: ProtoExecuteRequest) {
        self.execute = ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::single(v))
    }

    // Mutable pointer to the field.
    pub fn mut_single(&mut self) -> &mut ProtoExecuteRequest {
        if let ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::single(_)) = self.execute {
        } else {
            self.execute = ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::single(ProtoExecuteRequest::new()));
        }
        match self.execute {
            ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::single(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_single(&mut self) -> ProtoExecuteRequest {
        if self.has_single() {
            match self.execute.take() {
                ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::single(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoExecuteRequest::new()
        }
    }

    pub fn get_single(&self) -> &ProtoExecuteRequest {
        match self.execute {
            ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::single(ref v)) => v,
            _ => ProtoExecuteRequest::default_instance(),
        }
    }

    // .sqlite_commands.ProtoBulkExecuteRequest bulk = 2;

    pub fn clear_bulk(&mut self) {
        self.execute = ::std::option::Option::None;
    }

    pub fn has_bulk(&self) -> bool {
        match self.execute {
            ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::bulk(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_bulk(&mut self, v: ProtoBulkExecuteRequest) {
        self.execute = ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::bulk(v))
    }

    // Mutable pointer to the field.
    pub fn mut_bulk(&mut self) -> &mut ProtoBulkExecuteRequest {
        if let ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::bulk(_)) = self.execute {
        } else {
            self.execute = ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::bulk(ProtoBulkExecuteRequest::new()));
        }
        match self.execute {
            ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::bulk(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_bulk(&mut self) -> ProtoBulkExecuteRequest {
        if self.has_bulk() {
            match self.execute.take() {
                ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::bulk(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoBulkExecuteRequest::new()
        }
    }

    pub fn get_bulk(&self) -> &ProtoBulkExecuteRequest {
        match self.execute {
            ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::bulk(ref v)) => v,
            _ => ProtoBulkExecuteRequest::default_instance(),
        }
    }
}

impl ::protobuf::Message for ProtoSqliteExecute {
    fn is_initialized(&self) -> bool {
        if let Some(ProtoSqliteExecute_oneof_execute::single(ref v)) = self.execute {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(ProtoSqliteExecute_oneof_execute::bulk(ref v)) = self.execute {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.execute = ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::single(is.read_message()?));
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.execute = ::std::option::Option::Some(ProtoSqliteExecute_oneof_execute::bulk(is.read_message()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.execute {
            match v {
                &ProtoSqliteExecute_oneof_execute::single(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &ProtoSqliteExecute_oneof_execute::bulk(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if let ::std::option::Option::Some(ref v) = self.execute {
            match v {
                &ProtoSqliteExecute_oneof_execute::single(ref v) => {
                    os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &ProtoSqliteExecute_oneof_execute::bulk(ref v) => {
                    os.write_tag(2, ::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() -> ProtoSqliteExecute {
        ProtoSqliteExecute::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_singular_message_accessor::<_, ProtoExecuteRequest>(
                    "single",
                    ProtoSqliteExecute::has_single,
                    ProtoSqliteExecute::get_single,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ProtoBulkExecuteRequest>(
                    "bulk",
                    ProtoSqliteExecute::has_bulk,
                    ProtoSqliteExecute::get_bulk,
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoSqliteExecute>(
                    "ProtoSqliteExecute",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ProtoSqliteExecute {
    fn clear(&mut self) {
        self.clear_single();
        self.clear_bulk();
        self.unknown_fields.clear();
    }
}

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

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

#[derive(PartialEq,Clone,Default)]
pub struct ProtoSqliteExecuteResponse {
    // message oneof groups
    pub response: ::std::option::Option<ProtoSqliteExecuteResponse_oneof_response>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

#[derive(Clone,PartialEq)]
pub enum ProtoSqliteExecuteResponse_oneof_response {
    single(ProtoExecuteResponse),
    bulk(ProtoBulkExecuteResponse),
}

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

    // .sqlite_commands.ProtoExecuteResponse single = 1;

    pub fn clear_single(&mut self) {
        self.response = ::std::option::Option::None;
    }

    pub fn has_single(&self) -> bool {
        match self.response {
            ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::single(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_single(&mut self, v: ProtoExecuteResponse) {
        self.response = ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::single(v))
    }

    // Mutable pointer to the field.
    pub fn mut_single(&mut self) -> &mut ProtoExecuteResponse {
        if let ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::single(_)) = self.response {
        } else {
            self.response = ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::single(ProtoExecuteResponse::new()));
        }
        match self.response {
            ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::single(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_single(&mut self) -> ProtoExecuteResponse {
        if self.has_single() {
            match self.response.take() {
                ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::single(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoExecuteResponse::new()
        }
    }

    pub fn get_single(&self) -> &ProtoExecuteResponse {
        match self.response {
            ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::single(ref v)) => v,
            _ => ProtoExecuteResponse::default_instance(),
        }
    }

    // .sqlite_commands.ProtoBulkExecuteResponse bulk = 2;

    pub fn clear_bulk(&mut self) {
        self.response = ::std::option::Option::None;
    }

    pub fn has_bulk(&self) -> bool {
        match self.response {
            ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::bulk(..)) => true,
            _ => false,
        }
    }

    // Param is passed by value, moved
    pub fn set_bulk(&mut self, v: ProtoBulkExecuteResponse) {
        self.response = ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::bulk(v))
    }

    // Mutable pointer to the field.
    pub fn mut_bulk(&mut self) -> &mut ProtoBulkExecuteResponse {
        if let ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::bulk(_)) = self.response {
        } else {
            self.response = ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::bulk(ProtoBulkExecuteResponse::new()));
        }
        match self.response {
            ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::bulk(ref mut v)) => v,
            _ => panic!(),
        }
    }

    // Take field
    pub fn take_bulk(&mut self) -> ProtoBulkExecuteResponse {
        if self.has_bulk() {
            match self.response.take() {
                ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::bulk(v)) => v,
                _ => panic!(),
            }
        } else {
            ProtoBulkExecuteResponse::new()
        }
    }

    pub fn get_bulk(&self) -> &ProtoBulkExecuteResponse {
        match self.response {
            ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::bulk(ref v)) => v,
            _ => ProtoBulkExecuteResponse::default_instance(),
        }
    }
}

impl ::protobuf::Message for ProtoSqliteExecuteResponse {
    fn is_initialized(&self) -> bool {
        if let Some(ProtoSqliteExecuteResponse_oneof_response::single(ref v)) = self.response {
            if !v.is_initialized() {
                return false;
            }
        }
        if let Some(ProtoSqliteExecuteResponse_oneof_response::bulk(ref v)) = self.response {
            if !v.is_initialized() {
                return false;
            }
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
        while !is.eof()? {
            let (field_number, wire_type) = is.read_tag_unpack()?;
            match field_number {
                1 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.response = ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::single(is.read_message()?));
                },
                2 => {
                    if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
                    }
                    self.response = ::std::option::Option::Some(ProtoSqliteExecuteResponse_oneof_response::bulk(is.read_message()?));
                },
                _ => {
                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u32 {
        let mut my_size = 0;
        if let ::std::option::Option::Some(ref v) = self.response {
            match v {
                &ProtoSqliteExecuteResponse_oneof_response::single(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
                &ProtoSqliteExecuteResponse_oneof_response::bulk(ref v) => {
                    let len = v.compute_size();
                    my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
                },
            };
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
        self.cached_size.set(my_size);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
        if let ::std::option::Option::Some(ref v) = self.response {
            match v {
                &ProtoSqliteExecuteResponse_oneof_response::single(ref v) => {
                    os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
                    os.write_raw_varint32(v.get_cached_size())?;
                    v.write_to_with_cached_sizes(os)?;
                },
                &ProtoSqliteExecuteResponse_oneof_response::bulk(ref v) => {
                    os.write_tag(2, ::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() -> ProtoSqliteExecuteResponse {
        ProtoSqliteExecuteResponse::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_singular_message_accessor::<_, ProtoExecuteResponse>(
                    "single",
                    ProtoSqliteExecuteResponse::has_single,
                    ProtoSqliteExecuteResponse::get_single,
                ));
                fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, ProtoBulkExecuteResponse>(
                    "bulk",
                    ProtoSqliteExecuteResponse::has_bulk,
                    ProtoSqliteExecuteResponse::get_bulk,
                ));
                ::protobuf::reflect::MessageDescriptor::new::<ProtoSqliteExecuteResponse>(
                    "ProtoSqliteExecuteResponse",
                    fields,
                    file_descriptor_proto()
                )
            })
        }
    }

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

impl ::protobuf::Clear for ProtoSqliteExecuteResponse {
    fn clear(&mut self) {
        self.clear_single();
        self.clear_bulk();
        self.unknown_fields.clear();
    }
}

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x15sqlite_requests.proto\x12\x0fsqlite_commands\"k\n\x11ProtoQueryReq\
    uest\x12\x0f\n\x03sql\x18\x01\x20\x01(\tB\x02\x18\0\x12E\n\x11queued_par\
    ameters\x18\x02\x20\x01(\x0b2&.sqlite_commands.ProtoQueuedParametersB\
    \x02\x18\0\"\xd8\x01\n\x15ProtoQueuedParameters\x12V\n\x19queued_indexed\
    _parameters\x18\x01\x20\x01(\x0b2-.sqlite_commands.ProtoQueuedIndexedPar\
    ametersH\0B\x02\x18\0\x12R\n\x17queued_named_parameters\x18\x02\x20\x01(\
    \x0b2+.sqlite_commands.ProtoQueuedNamedParametersH\0B\x02\x18\0B\x13\n\
    \x11queued_parameters\"n\n\x1cProtoQueuedIndexedParameters\x12N\n\x19que\
    ued_indexed_parameters\x18\x01\x20\x03(\x0b2'.sqlite_commands.ProtoIndex\
    edParametersB\x02\x18\0\"h\n\x1aProtoQueuedNamedParameters\x12J\n\x17que\
    ued_named_parameters\x18\x01\x20\x03(\x0b2%.sqlite_commands.ProtoNamedPa\
    rametersB\x02\x18\0\"M\n\x16ProtoIndexedParameters\x123\n\nparameters\
    \x18\x01\x20\x03(\x0b2\x1b.sqlite_commands.ProtoValueB\x02\x18\0\"T\n\
    \x14ProtoNamedParameters\x12<\n\nparameters\x18\x01\x20\x03(\x0b2$.sqlit\
    e_commands.ProtoNamedParameterB\x02\x18\0\"W\n\x13ProtoNamedParameter\
    \x12\x10\n\x04name\x18\x01\x20\x01(\tB\x02\x18\0\x12.\n\x05value\x18\x02\
    \x20\x01(\x0b2\x1b.sqlite_commands.ProtoValueB\x02\x18\0\"\x98\x01\n\nPr\
    otoValue\x12.\n\x04null\x18\x01\x20\x01(\x0b2\x1a.sqlite_commands.ProtoN\
    ullH\0B\x02\x18\0\x12\x15\n\x07integer\x18\x02\x20\x01(\x03H\0B\x02\x18\
    \0\x12\x12\n\x04real\x18\x03\x20\x01(\x01H\0B\x02\x18\0\x12\x12\n\x04tex\
    t\x18\x04\x20\x01(\tH\0B\x02\x18\0\x12\x12\n\x04blob\x18\x05\x20\x01(\
    \x0cH\0B\x02\x18\0B\x07\n\x05value\"\x0b\n\tProtoNull\"Y\n\x12ProtoQuery\
    Response\x12C\n\x11query_result_sets\x18\x01\x20\x03(\x0b2$.sqlite_comma\
    nds.ProtoQueryResultSetB\x02\x18\0\"M\n\x13ProtoQueryResultSet\x126\n\
    \x04rows\x18\x01\x20\x03(\x0b2$.sqlite_commands.ProtoQueryResultRowB\x02\
    \x18\0\"C\n\x13ProtoQueryResultRow\x12,\n\x03row\x18\x01\x20\x03(\x0b2\
    \x1b.sqlite_commands.ProtoValueB\x02\x18\0\"m\n\x13ProtoExecuteRequest\
    \x12\x0f\n\x03sql\x18\x01\x20\x01(\tB\x02\x18\0\x12E\n\x11queued_paramet\
    ers\x18\x02\x20\x01(\x0b2&.sqlite_commands.ProtoQueuedParametersB\x02\
    \x18\0\"X\n\x14ProtoExecuteResponse\x12@\n\x0fexecute_results\x18\x01\
    \x20\x03(\x0b2#.sqlite_commands.ProtoExecuteResultB\x02\x18\0\")\n\x12Pr\
    otoExecuteResult\x12\x13\n\x07changes\x18\x01\x20\x01(\x04B\x02\x18\0\"P\
    \n\x15ProtoBulkQueryRequest\x127\n\x07queries\x18\x01\x20\x03(\x0b2\".sq\
    lite_commands.ProtoQueryRequestB\x02\x18\0\"Z\n\x16ProtoBulkQueryRespons\
    e\x12@\n\x0fquery_responses\x18\x01\x20\x03(\x0b2#.sqlite_commands.Proto\
    QueryResponseB\x02\x18\0\"U\n\x17ProtoBulkExecuteRequest\x12:\n\x08execu\
    tes\x18\x01\x20\x03(\x0b2$.sqlite_commands.ProtoExecuteRequestB\x02\x18\
    \0\"`\n\x18ProtoBulkExecuteResponse\x12D\n\x11execute_responses\x18\x01\
    \x20\x03(\x0b2%.sqlite_commands.ProtoExecuteResponseB\x02\x18\0\"\x93\
    \x01\n\x12ProtoSqliteRequest\x126\n\x05query\x18\x01\x20\x01(\x0b2!.sqli\
    te_commands.ProtoSqliteQueryH\0B\x02\x18\0\x12:\n\x07execute\x18\x02\x20\
    \x01(\x0b2#.sqlite_commands.ProtoSqliteExecuteH\0B\x02\x18\0B\t\n\x07req\
    uest\"\xa5\x01\n\x13ProtoSqliteResponse\x12>\n\x05query\x18\x01\x20\x01(\
    \x0b2).sqlite_commands.ProtoSqliteQueryResponseH\0B\x02\x18\0\x12B\n\x07\
    execute\x18\x02\x20\x01(\x0b2+.sqlite_commands.ProtoSqliteExecuteRespons\
    eH\0B\x02\x18\0B\n\n\x08response\"\x91\x01\n\x10ProtoSqliteQuery\x128\n\
    \x06single\x18\x01\x20\x01(\x0b2\".sqlite_commands.ProtoQueryRequestH\0B\
    \x02\x18\0\x12:\n\x04bulk\x18\x02\x20\x01(\x0b2&.sqlite_commands.ProtoBu\
    lkQueryRequestH\0B\x02\x18\0B\x07\n\x05query\"\x9e\x01\n\x18ProtoSqliteQ\
    ueryResponse\x129\n\x06single\x18\x01\x20\x01(\x0b2#.sqlite_commands.Pro\
    toQueryResponseH\0B\x02\x18\0\x12;\n\x04bulk\x18\x02\x20\x01(\x0b2'.sqli\
    te_commands.ProtoBulkQueryResponseH\0B\x02\x18\0B\n\n\x08response\"\x99\
    \x01\n\x12ProtoSqliteExecute\x12:\n\x06single\x18\x01\x20\x01(\x0b2$.sql\
    ite_commands.ProtoExecuteRequestH\0B\x02\x18\0\x12<\n\x04bulk\x18\x02\
    \x20\x01(\x0b2(.sqlite_commands.ProtoBulkExecuteRequestH\0B\x02\x18\0B\t\
    \n\x07execute\"\xa4\x01\n\x1aProtoSqliteExecuteResponse\x12;\n\x06single\
    \x18\x01\x20\x01(\x0b2%.sqlite_commands.ProtoExecuteResponseH\0B\x02\x18\
    \0\x12=\n\x04bulk\x18\x02\x20\x01(\x0b2).sqlite_commands.ProtoBulkExecut\
    eResponseH\0B\x02\x18\0B\n\n\x08responseB\0b\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()
        })
    }
}