sqlite-requests 0.0.1

// 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_results: ::protobuf::RepeatedField<ProtoQueryResult>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

    // repeated .sqlite_commands.ProtoQueryResult query_results = 1;

    pub fn clear_query_results(&mut self) {
        self.query_results.clear();
    }

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

    // Mutable pointer to the field.
    pub fn mut_query_results(&mut self) -> &mut ::protobuf::RepeatedField<ProtoQueryResult> {
        &mut self.query_results
    }

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

    pub fn get_query_results(&self) -> &[ProtoQueryResult] {
        &self.query_results
    }
}

impl ::protobuf::Message for ProtoQueryResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.query_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.query_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.query_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.query_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() -> 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<ProtoQueryResult>>(
                    "query_results",
                    |m: &ProtoQueryResponse| { &m.query_results },
                    |m: &mut ProtoQueryResponse| { &mut m.query_results },
                ));
                ::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_results();
        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 ProtoQueryResult {
    // message fields
    pub rows: ::protobuf::RepeatedField<ProtoQueryResultRow>,
    // special fields
    unknown_fields: ::protobuf::UnknownFields,
    cached_size: ::protobuf::CachedSize,
}

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

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

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

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

impl ::protobuf::reflect::ProtobufValue for ProtoQueryResult {
    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_result: ::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_result = 1;

    pub fn clear_execute_result(&mut self) {
        self.execute_result.clear();
    }

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

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

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

    pub fn get_execute_result(&self) -> &[ProtoExecuteResult] {
        &self.execute_result
    }
}

impl ::protobuf::Message for ProtoExecuteResponse {
    fn is_initialized(&self) -> bool {
        for v in &self.execute_result {
            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_result)?;
                },
                _ => {
                    ::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_result {
            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_result {
            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_result",
                    |m: &ProtoExecuteResponse| { &m.execute_result },
                    |m: &mut ProtoExecuteResponse| { &mut m.execute_result },
                ));
                ::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_result();
        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)
    }
}

static file_descriptor_proto_data: &'static [u8] = b"\
    \n\x1bproto/sqlite_requests.proto\x12\x0fsqlite_commands\"z\n\x11ProtoQu\
    eryRequest\x12\x10\n\x03sql\x18\x01\x20\x01(\tR\x03sql\x12S\n\x11queued_\
    parameters\x18\x02\x20\x01(\x0b2&.sqlite_commands.ProtoQueuedParametersR\
    \x10queuedParameters\"\x80\x02\n\x15ProtoQueuedParameters\x12k\n\x19queu\
    ed_indexed_parameters\x18\x01\x20\x01(\x0b2-.sqlite_commands.ProtoQueued\
    IndexedParametersH\0R\x17queuedIndexedParameters\x12e\n\x17queued_named_\
    parameters\x18\x02\x20\x01(\x0b2+.sqlite_commands.ProtoQueuedNamedParame\
    tersH\0R\x15queuedNamedParametersB\x13\n\x11queued_parameters\"\x83\x01\
    \n\x1cProtoQueuedIndexedParameters\x12c\n\x19queued_indexed_parameters\
    \x18\x01\x20\x03(\x0b2'.sqlite_commands.ProtoIndexedParametersR\x17queue\
    dIndexedParameters\"{\n\x1aProtoQueuedNamedParameters\x12]\n\x17queued_n\
    amed_parameters\x18\x01\x20\x03(\x0b2%.sqlite_commands.ProtoNamedParamet\
    ersR\x15queuedNamedParameters\"U\n\x16ProtoIndexedParameters\x12;\n\npar\
    ameters\x18\x01\x20\x03(\x0b2\x1b.sqlite_commands.ProtoValueR\nparameter\
    s\"\\\n\x14ProtoNamedParameters\x12D\n\nparameters\x18\x01\x20\x03(\x0b2\
    $.sqlite_commands.ProtoNamedParameterR\nparameters\"\\\n\x13ProtoNamedPa\
    rameter\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x121\n\x05value\
    \x18\x02\x20\x01(\x0b2\x1b.sqlite_commands.ProtoValueR\x05value\"\xa5\
    \x01\n\nProtoValue\x120\n\x04null\x18\x01\x20\x01(\x0b2\x1a.sqlite_comma\
    nds.ProtoNullH\0R\x04null\x12\x1a\n\x07integer\x18\x02\x20\x01(\x03H\0R\
    \x07integer\x12\x14\n\x04real\x18\x03\x20\x01(\x01H\0R\x04real\x12\x14\n\
    \x04text\x18\x04\x20\x01(\tH\0R\x04text\x12\x14\n\x04blob\x18\x05\x20\
    \x01(\x0cH\0R\x04blobB\x07\n\x05value\"\x0b\n\tProtoNull\"\\\n\x12ProtoQ\
    ueryResponse\x12F\n\rquery_results\x18\x01\x20\x03(\x0b2!.sqlite_command\
    s.ProtoQueryResultR\x0cqueryResults\"L\n\x10ProtoQueryResult\x128\n\x04r\
    ows\x18\x01\x20\x03(\x0b2$.sqlite_commands.ProtoQueryResultRowR\x04rows\
    \"D\n\x13ProtoQueryResultRow\x12-\n\x03row\x18\x01\x20\x03(\x0b2\x1b.sql\
    ite_commands.ProtoValueR\x03row\"|\n\x13ProtoExecuteRequest\x12\x10\n\
    \x03sql\x18\x01\x20\x01(\tR\x03sql\x12S\n\x11queued_parameters\x18\x02\
    \x20\x01(\x0b2&.sqlite_commands.ProtoQueuedParametersR\x10queuedParamete\
    rs\"b\n\x14ProtoExecuteResponse\x12J\n\x0eexecute_result\x18\x01\x20\x03\
    (\x0b2#.sqlite_commands.ProtoExecuteResultR\rexecuteResult\".\n\x12Proto\
    ExecuteResult\x12\x18\n\x07changes\x18\x01\x20\x01(\x04R\x07changes\"U\n\
    \x15ProtoBulkQueryRequest\x12<\n\x07queries\x18\x01\x20\x03(\x0b2\".sqli\
    te_commands.ProtoQueryRequestR\x07queries\"f\n\x16ProtoBulkQueryResponse\
    \x12L\n\x0fquery_responses\x18\x01\x20\x03(\x0b2#.sqlite_commands.ProtoQ\
    ueryResponseR\x0equeryResponses\"[\n\x17ProtoBulkExecuteRequest\x12@\n\
    \x08executes\x18\x01\x20\x03(\x0b2$.sqlite_commands.ProtoExecuteRequestR\
    \x08executes\"n\n\x18ProtoBulkExecuteResponse\x12R\n\x11execute_response\
    s\x18\x01\x20\x03(\x0b2%.sqlite_commands.ProtoExecuteResponseR\x10execut\
    eResponsesb\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()
        })
    }
}