HM-SPMS/platform/src/idl_files/DbSaveMessage.pb.cc

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: DbSaveMessage.proto

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "DbSaveMessage.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)

namespace iot_idl {

namespace {

const ::google::protobuf::Descriptor* DbCondition_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DbCondition_reflection_ = NULL;
const ::google::protobuf::Descriptor* DbConditionHead_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DbConditionHead_reflection_ = NULL;
const ::google::protobuf::Descriptor* DbValueArray_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DbValueArray_reflection_ = NULL;
const ::google::protobuf::Descriptor* DbUpdateValue_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DbUpdateValue_reflection_ = NULL;
const ::google::protobuf::Descriptor* DbInsert_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DbInsert_reflection_ = NULL;
const ::google::protobuf::Descriptor* DbRemove_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DbRemove_reflection_ = NULL;
const ::google::protobuf::Descriptor* DbRemoveMulti_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DbRemoveMulti_reflection_ = NULL;
const ::google::protobuf::Descriptor* DbUpdate_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DbUpdate_reflection_ = NULL;
const ::google::protobuf::Descriptor* DbUpdateMulti_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DbUpdateMulti_reflection_ = NULL;
const ::google::protobuf::Descriptor* DbRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DbRequest_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* enDssMsgType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* enDssSaveAction_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_DbSaveMessage_2eproto() {
  protobuf_AddDesc_DbSaveMessage_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "DbSaveMessage.proto");
  GOOGLE_CHECK(file != NULL);
  DbCondition_descriptor_ = file->message_type(0);
  static const int DbCondition_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbCondition, enlogic_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbCondition, enrelation_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbCondition, strcolumnname_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbCondition, msgvalue_),
  };
  DbCondition_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DbCondition_descriptor_,
      DbCondition::default_instance_,
      DbCondition_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbCondition, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbCondition, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DbCondition));
  DbConditionHead_descriptor_ = file->message_type(1);
  static const int DbConditionHead_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbConditionHead, enlogic_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbConditionHead, enrelation_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbConditionHead, strcolumnname_),
  };
  DbConditionHead_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DbConditionHead_descriptor_,
      DbConditionHead::default_instance_,
      DbConditionHead_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbConditionHead, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbConditionHead, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DbConditionHead));
  DbValueArray_descriptor_ = file->message_type(2);
  static const int DbValueArray_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbValueArray, msgvalue_),
  };
  DbValueArray_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DbValueArray_descriptor_,
      DbValueArray::default_instance_,
      DbValueArray_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbValueArray, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbValueArray, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DbValueArray));
  DbUpdateValue_descriptor_ = file->message_type(3);
  static const int DbUpdateValue_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdateValue, strcolumnname_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdateValue, msgvalue_),
  };
  DbUpdateValue_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DbUpdateValue_descriptor_,
      DbUpdateValue::default_instance_,
      DbUpdateValue_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdateValue, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdateValue, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DbUpdateValue));
  DbInsert_descriptor_ = file->message_type(4);
  static const int DbInsert_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbInsert, ensaveaction_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbInsert, strtablename_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbInsert, strcolumnname_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbInsert, msgrecord_),
  };
  DbInsert_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DbInsert_descriptor_,
      DbInsert::default_instance_,
      DbInsert_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbInsert, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbInsert, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DbInsert));
  DbRemove_descriptor_ = file->message_type(5);
  static const int DbRemove_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRemove, ensaveaction_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRemove, strtablename_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRemove, msgcondtionarray_),
  };
  DbRemove_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DbRemove_descriptor_,
      DbRemove::default_instance_,
      DbRemove_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRemove, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRemove, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DbRemove));
  DbRemoveMulti_descriptor_ = file->message_type(6);
  static const int DbRemoveMulti_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRemoveMulti, ensaveaction_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRemoveMulti, strtablename_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRemoveMulti, msgconditionhead_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRemoveMulti, msgconditionvalue_),
  };
  DbRemoveMulti_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DbRemoveMulti_descriptor_,
      DbRemoveMulti::default_instance_,
      DbRemoveMulti_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRemoveMulti, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRemoveMulti, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DbRemoveMulti));
  DbUpdate_descriptor_ = file->message_type(7);
  static const int DbUpdate_offsets_[4] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdate, ensaveaction_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdate, strtablename_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdate, msgupdatevalue_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdate, msgcondition_),
  };
  DbUpdate_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DbUpdate_descriptor_,
      DbUpdate::default_instance_,
      DbUpdate_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdate, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdate, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DbUpdate));
  DbUpdateMulti_descriptor_ = file->message_type(8);
  static const int DbUpdateMulti_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdateMulti, ensaveaction_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdateMulti, strtablename_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdateMulti, msgupdatevalue_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdateMulti, msgconditionhead_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdateMulti, msgconditionvalue_),
  };
  DbUpdateMulti_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DbUpdateMulti_descriptor_,
      DbUpdateMulti::default_instance_,
      DbUpdateMulti_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdateMulti, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbUpdateMulti, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DbUpdateMulti));
  DbRequest_descriptor_ = file->message_type(9);
  static const int DbRequest_offsets_[5] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRequest, msginsert_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRequest, msgremove_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRequest, msgremovemulti_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRequest, msgupdate_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRequest, msgupdatemulti_),
  };
  DbRequest_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      DbRequest_descriptor_,
      DbRequest::default_instance_,
      DbRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRequest, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DbRequest, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(DbRequest));
  enDssMsgType_descriptor_ = file->enum_type(0);
  enDssSaveAction_descriptor_ = file->enum_type(1);
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_DbSaveMessage_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DbCondition_descriptor_, &DbCondition::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DbConditionHead_descriptor_, &DbConditionHead::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DbValueArray_descriptor_, &DbValueArray::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DbUpdateValue_descriptor_, &DbUpdateValue::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DbInsert_descriptor_, &DbInsert::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DbRemove_descriptor_, &DbRemove::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DbRemoveMulti_descriptor_, &DbRemoveMulti::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DbUpdate_descriptor_, &DbUpdate::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DbUpdateMulti_descriptor_, &DbUpdateMulti::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    DbRequest_descriptor_, &DbRequest::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_DbSaveMessage_2eproto() {
  delete DbCondition::default_instance_;
  delete DbCondition_reflection_;
  delete DbConditionHead::default_instance_;
  delete DbConditionHead_reflection_;
  delete DbValueArray::default_instance_;
  delete DbValueArray_reflection_;
  delete DbUpdateValue::default_instance_;
  delete DbUpdateValue_reflection_;
  delete DbInsert::default_instance_;
  delete DbInsert_reflection_;
  delete DbRemove::default_instance_;
  delete DbRemove_reflection_;
  delete DbRemoveMulti::default_instance_;
  delete DbRemoveMulti_reflection_;
  delete DbUpdate::default_instance_;
  delete DbUpdate_reflection_;
  delete DbUpdateMulti::default_instance_;
  delete DbUpdateMulti_reflection_;
  delete DbRequest::default_instance_;
  delete DbRequest_reflection_;
}

void protobuf_AddDesc_DbSaveMessage_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::iot_idl::protobuf_AddDesc_Public_2eproto();
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\023DbSaveMessage.proto\022\013iot_idl\032\014Publ"
    "ic.proto\"\264\001\n\013DbCondition\022.\n\007enLogic\030\001 \001("
    "\0162\035.iot_idl.ENConditionLogic\0224\n\nenRe"
    "lation\030\002 \002(\0162 .iot_idl.ENConditionRe"
    "lation\022\025\n\rstrColumnName\030\003 \002(\t\022(\n\010msgValu"
    "e\030\004 \002(\0132\026.iot_idl.SVariable\"\216\001\n\017DbCo"
    "nditionHead\022.\n\007enLogic\030\001 \001(\0162\035.kbd_idlfi"
    "le.ENConditionLogic\0224\n\nenRelation\030\002 \002(\0162"
    " .iot_idl.ENConditionRelation\022\025\n\rstr"
    "ColumnName\030\003 \002(\t\"8\n\014DbValueArray\022(\n\010msgV"
    "alue\030\001 \003(\0132\026.iot_idl.SVariable\"P\n\rDb"
    "UpdateValue\022\025\n\rstrColumnName\030\001 \002(\t\022(\n\010ms"
    "gValue\030\002 \002(\0132\026.iot_idl.SVariable\"\231\001\n"
    "\010DbInsert\0222\n\014enSaveAction\030\001 \002(\0162\034.kbd_id"
    "lfile.enDssSaveAction\022\024\n\014strTableName\030\002 "
    "\002(\t\022\025\n\rstrColumnName\030\003 \003(\t\022,\n\tmsgRecord\030"
    "\004 \003(\0132\031.iot_idl.DbValueArray\"\210\001\n\010DbR"
    "emove\0222\n\014enSaveAction\030\001 \002(\0162\034.kbd_idlfil"
    "e.enDssSaveAction\022\024\n\014strTableName\030\002 \002(\t\022"
    "2\n\020msgCondtionArray\030\003 \003(\0132\030.iot_idl."
    "DbCondition\"\307\001\n\rDbRemoveMulti\0222\n\014enSaveA"
    "ction\030\001 \002(\0162\034.iot_idl.enDssSaveActio"
    "n\022\024\n\014strTableName\030\002 \002(\t\0226\n\020msgConditionH"
    "ead\030\003 \003(\0132\034.iot_idl.DbConditionHead\022"
    "4\n\021msgConditionValue\030\004 \003(\0132\031.iot_idl"
    ".DbValueArray\"\270\001\n\010DbUpdate\0222\n\014enSaveActi"
    "on\030\001 \002(\0162\034.iot_idl.enDssSaveAction\022\024"
    "\n\014strTableName\030\002 \002(\t\0222\n\016msgUpdateValue\030\003"
    " \003(\0132\032.iot_idl.DbUpdateValue\022.\n\014msgC"
    "ondition\030\004 \003(\0132\030.iot_idl.DbCondition"
    "\"\373\001\n\rDbUpdateMulti\0222\n\014enSaveAction\030\001 \002(\016"
    "2\034.iot_idl.enDssSaveAction\022\024\n\014strTab"
    "leName\030\002 \002(\t\0222\n\016msgUpdateValue\030\003 \003(\0132\032.k"
    "bd_idlfile.DbUpdateValue\0226\n\020msgCondition"
    "Head\030\004 \003(\0132\034.iot_idl.DbConditionHead"
    "\0224\n\021msgConditionValue\030\005 \003(\0132\031.kbd_idlfil"
    "e.DbValueArray\"\361\001\n\tDbRequest\022(\n\tmsgInser"
    "t\030\001 \001(\0132\025.iot_idl.DbInsert\022(\n\tmsgRem"
    "ove\030\002 \001(\0132\025.iot_idl.DbRemove\0222\n\016msgR"
    "emoveMulti\030\003 \001(\0132\032.iot_idl.DbRemoveM"
    "ulti\022(\n\tmsgUpdate\030\004 \001(\0132\025.iot_idl.Db"
    "Update\0222\n\016msgUpdateMulti\030\005 \001(\0132\032.kbd_idl"
    "file.DbUpdateMulti*\267\001\n\014enDssMsgType\022\031\n\025M"
    "T_DSS_APP2SRV_INSERT\020\n\022\031\n\025MT_DSS_APP2SRV"
    "_REMOVE\020\024\022\036\n\032MT_DSS_APP2SRV_REMOVEMULTI\020"
    "\025\022\031\n\025MT_DSS_APP2SRV_UPDATE\020\036\022\036\n\032MT_DSS_A"
    "PP2SRV_UPDATEMULTI\020\037\022\026\n\022MT_DSS_SRV2APP_A"
    "CK\020d*p\n\017enDssSaveAction\022\025\n\021SA_DSS_DO_NOT"
    "HING\020\000\022\025\n\021SA_DSS_LOCAL_ONLY\020\001\022\026\n\022SA_DSS_"
    "REMOTE_ONLY\020\002\022\027\n\023SA_DSS_LOCAL_REMOTE\020\003", 1998);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "DbSaveMessage.proto", &protobuf_RegisterTypes);
  DbCondition::default_instance_ = new DbCondition();
  DbConditionHead::default_instance_ = new DbConditionHead();
  DbValueArray::default_instance_ = new DbValueArray();
  DbUpdateValue::default_instance_ = new DbUpdateValue();
  DbInsert::default_instance_ = new DbInsert();
  DbRemove::default_instance_ = new DbRemove();
  DbRemoveMulti::default_instance_ = new DbRemoveMulti();
  DbUpdate::default_instance_ = new DbUpdate();
  DbUpdateMulti::default_instance_ = new DbUpdateMulti();
  DbRequest::default_instance_ = new DbRequest();
  DbCondition::default_instance_->InitAsDefaultInstance();
  DbConditionHead::default_instance_->InitAsDefaultInstance();
  DbValueArray::default_instance_->InitAsDefaultInstance();
  DbUpdateValue::default_instance_->InitAsDefaultInstance();
  DbInsert::default_instance_->InitAsDefaultInstance();
  DbRemove::default_instance_->InitAsDefaultInstance();
  DbRemoveMulti::default_instance_->InitAsDefaultInstance();
  DbUpdate::default_instance_->InitAsDefaultInstance();
  DbUpdateMulti::default_instance_->InitAsDefaultInstance();
  DbRequest::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_DbSaveMessage_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_DbSaveMessage_2eproto {
  StaticDescriptorInitializer_DbSaveMessage_2eproto() {
    protobuf_AddDesc_DbSaveMessage_2eproto();
  }
} static_descriptor_initializer_DbSaveMessage_2eproto_;
const ::google::protobuf::EnumDescriptor* enDssMsgType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return enDssMsgType_descriptor_;
}
bool enDssMsgType_IsValid(int value) {
  switch(value) {
    case 10:
    case 20:
    case 21:
    case 30:
    case 31:
    case 100:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* enDssSaveAction_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return enDssSaveAction_descriptor_;
}
bool enDssSaveAction_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}


// ===================================================================

#ifndef _MSC_VER
const int DbCondition::kEnLogicFieldNumber;
const int DbCondition::kEnRelationFieldNumber;
const int DbCondition::kStrColumnNameFieldNumber;
const int DbCondition::kMsgValueFieldNumber;
#endif  // !_MSC_VER

DbCondition::DbCondition()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.DbCondition)
}

void DbCondition::InitAsDefaultInstance() {
  msgvalue_ = const_cast< ::iot_idl::SVariable*>(&::iot_idl::SVariable::default_instance());
}

DbCondition::DbCondition(const DbCondition& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.DbCondition)
}

void DbCondition::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  enlogic_ = 0;
  enrelation_ = 0;
  strcolumnname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  msgvalue_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DbCondition::~DbCondition() {
  // @@protoc_insertion_point(destructor:iot_idl.DbCondition)
  SharedDtor();
}

void DbCondition::SharedDtor() {
  if (strcolumnname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete strcolumnname_;
  }
  if (this != default_instance_) {
    delete msgvalue_;
  }
}

void DbCondition::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DbCondition::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DbCondition_descriptor_;
}

const DbCondition& DbCondition::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_DbSaveMessage_2eproto();
  return *default_instance_;
}

DbCondition* DbCondition::default_instance_ = NULL;

DbCondition* DbCondition::New() const {
  return new DbCondition;
}

void DbCondition::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<DbCondition*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(enlogic_, enrelation_);
    if (has_strcolumnname()) {
      if (strcolumnname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        strcolumnname_->clear();
      }
    }
    if (has_msgvalue()) {
      if (msgvalue_ != NULL) msgvalue_->::iot_idl::SVariable::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DbCondition::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.DbCondition)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .iot_idl.ENConditionLogic enLogic = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::ENConditionLogic_IsValid(value)) {
            set_enlogic(static_cast< ::iot_idl::ENConditionLogic >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_enRelation;
        break;
      }

      // required .iot_idl.ENConditionRelation enRelation = 2;
      case 2: {
        if (tag == 16) {
         parse_enRelation:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::ENConditionRelation_IsValid(value)) {
            set_enrelation(static_cast< ::iot_idl::ENConditionRelation >(value));
          } else {
            mutable_unknown_fields()->AddVarint(2, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_strColumnName;
        break;
      }

      // required string strColumnName = 3;
      case 3: {
        if (tag == 26) {
         parse_strColumnName:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_strcolumnname()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->strcolumnname().data(), this->strcolumnname().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "strcolumnname");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_msgValue;
        break;
      }

      // required .iot_idl.SVariable msgValue = 4;
      case 4: {
        if (tag == 34) {
         parse_msgValue:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_msgvalue()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.DbCondition)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.DbCondition)
  return false;
#undef DO_
}

void DbCondition::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.DbCondition)
  // optional .iot_idl.ENConditionLogic enLogic = 1;
  if (has_enlogic()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->enlogic(), output);
  }

  // required .iot_idl.ENConditionRelation enRelation = 2;
  if (has_enrelation()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->enrelation(), output);
  }

  // required string strColumnName = 3;
  if (has_strcolumnname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strcolumnname().data(), this->strcolumnname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strcolumnname");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->strcolumnname(), output);
  }

  // required .iot_idl.SVariable msgValue = 4;
  if (has_msgvalue()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->msgvalue(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.DbCondition)
}

::google::protobuf::uint8* DbCondition::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.DbCondition)
  // optional .iot_idl.ENConditionLogic enLogic = 1;
  if (has_enlogic()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->enlogic(), target);
  }

  // required .iot_idl.ENConditionRelation enRelation = 2;
  if (has_enrelation()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->enrelation(), target);
  }

  // required string strColumnName = 3;
  if (has_strcolumnname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strcolumnname().data(), this->strcolumnname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strcolumnname");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->strcolumnname(), target);
  }

  // required .iot_idl.SVariable msgValue = 4;
  if (has_msgvalue()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->msgvalue(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.DbCondition)
  return target;
}

int DbCondition::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .iot_idl.ENConditionLogic enLogic = 1;
    if (has_enlogic()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->enlogic());
    }

    // required .iot_idl.ENConditionRelation enRelation = 2;
    if (has_enrelation()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->enrelation());
    }

    // required string strColumnName = 3;
    if (has_strcolumnname()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->strcolumnname());
    }

    // required .iot_idl.SVariable msgValue = 4;
    if (has_msgvalue()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->msgvalue());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DbCondition::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DbCondition* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DbCondition*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DbCondition::MergeFrom(const DbCondition& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_enlogic()) {
      set_enlogic(from.enlogic());
    }
    if (from.has_enrelation()) {
      set_enrelation(from.enrelation());
    }
    if (from.has_strcolumnname()) {
      set_strcolumnname(from.strcolumnname());
    }
    if (from.has_msgvalue()) {
      mutable_msgvalue()->::iot_idl::SVariable::MergeFrom(from.msgvalue());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void DbCondition::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DbCondition::CopyFrom(const DbCondition& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DbCondition::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000e) != 0x0000000e) return false;

  if (has_msgvalue()) {
    if (!this->msgvalue().IsInitialized()) return false;
  }
  return true;
}

void DbCondition::Swap(DbCondition* other) {
  if (other != this) {
    std::swap(enlogic_, other->enlogic_);
    std::swap(enrelation_, other->enrelation_);
    std::swap(strcolumnname_, other->strcolumnname_);
    std::swap(msgvalue_, other->msgvalue_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata DbCondition::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DbCondition_descriptor_;
  metadata.reflection = DbCondition_reflection_;
  return metadata;
}


// ===================================================================

#ifndef _MSC_VER
const int DbConditionHead::kEnLogicFieldNumber;
const int DbConditionHead::kEnRelationFieldNumber;
const int DbConditionHead::kStrColumnNameFieldNumber;
#endif  // !_MSC_VER

DbConditionHead::DbConditionHead()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.DbConditionHead)
}

void DbConditionHead::InitAsDefaultInstance() {
}

DbConditionHead::DbConditionHead(const DbConditionHead& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.DbConditionHead)
}

void DbConditionHead::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  enlogic_ = 0;
  enrelation_ = 0;
  strcolumnname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DbConditionHead::~DbConditionHead() {
  // @@protoc_insertion_point(destructor:iot_idl.DbConditionHead)
  SharedDtor();
}

void DbConditionHead::SharedDtor() {
  if (strcolumnname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete strcolumnname_;
  }
  if (this != default_instance_) {
  }
}

void DbConditionHead::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DbConditionHead::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DbConditionHead_descriptor_;
}

const DbConditionHead& DbConditionHead::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_DbSaveMessage_2eproto();
  return *default_instance_;
}

DbConditionHead* DbConditionHead::default_instance_ = NULL;

DbConditionHead* DbConditionHead::New() const {
  return new DbConditionHead;
}

void DbConditionHead::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<DbConditionHead*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 7) {
    ZR_(enlogic_, enrelation_);
    if (has_strcolumnname()) {
      if (strcolumnname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        strcolumnname_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DbConditionHead::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.DbConditionHead)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .iot_idl.ENConditionLogic enLogic = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::ENConditionLogic_IsValid(value)) {
            set_enlogic(static_cast< ::iot_idl::ENConditionLogic >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_enRelation;
        break;
      }

      // required .iot_idl.ENConditionRelation enRelation = 2;
      case 2: {
        if (tag == 16) {
         parse_enRelation:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::ENConditionRelation_IsValid(value)) {
            set_enrelation(static_cast< ::iot_idl::ENConditionRelation >(value));
          } else {
            mutable_unknown_fields()->AddVarint(2, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_strColumnName;
        break;
      }

      // required string strColumnName = 3;
      case 3: {
        if (tag == 26) {
         parse_strColumnName:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_strcolumnname()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->strcolumnname().data(), this->strcolumnname().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "strcolumnname");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.DbConditionHead)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.DbConditionHead)
  return false;
#undef DO_
}

void DbConditionHead::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.DbConditionHead)
  // optional .iot_idl.ENConditionLogic enLogic = 1;
  if (has_enlogic()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->enlogic(), output);
  }

  // required .iot_idl.ENConditionRelation enRelation = 2;
  if (has_enrelation()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->enrelation(), output);
  }

  // required string strColumnName = 3;
  if (has_strcolumnname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strcolumnname().data(), this->strcolumnname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strcolumnname");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->strcolumnname(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.DbConditionHead)
}

::google::protobuf::uint8* DbConditionHead::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.DbConditionHead)
  // optional .iot_idl.ENConditionLogic enLogic = 1;
  if (has_enlogic()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->enlogic(), target);
  }

  // required .iot_idl.ENConditionRelation enRelation = 2;
  if (has_enrelation()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->enrelation(), target);
  }

  // required string strColumnName = 3;
  if (has_strcolumnname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strcolumnname().data(), this->strcolumnname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strcolumnname");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->strcolumnname(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.DbConditionHead)
  return target;
}

int DbConditionHead::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .iot_idl.ENConditionLogic enLogic = 1;
    if (has_enlogic()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->enlogic());
    }

    // required .iot_idl.ENConditionRelation enRelation = 2;
    if (has_enrelation()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->enrelation());
    }

    // required string strColumnName = 3;
    if (has_strcolumnname()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->strcolumnname());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DbConditionHead::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DbConditionHead* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DbConditionHead*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DbConditionHead::MergeFrom(const DbConditionHead& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_enlogic()) {
      set_enlogic(from.enlogic());
    }
    if (from.has_enrelation()) {
      set_enrelation(from.enrelation());
    }
    if (from.has_strcolumnname()) {
      set_strcolumnname(from.strcolumnname());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void DbConditionHead::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DbConditionHead::CopyFrom(const DbConditionHead& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DbConditionHead::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false;

  return true;
}

void DbConditionHead::Swap(DbConditionHead* other) {
  if (other != this) {
    std::swap(enlogic_, other->enlogic_);
    std::swap(enrelation_, other->enrelation_);
    std::swap(strcolumnname_, other->strcolumnname_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata DbConditionHead::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DbConditionHead_descriptor_;
  metadata.reflection = DbConditionHead_reflection_;
  return metadata;
}


// ===================================================================

#ifndef _MSC_VER
const int DbValueArray::kMsgValueFieldNumber;
#endif  // !_MSC_VER

DbValueArray::DbValueArray()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.DbValueArray)
}

void DbValueArray::InitAsDefaultInstance() {
}

DbValueArray::DbValueArray(const DbValueArray& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.DbValueArray)
}

void DbValueArray::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DbValueArray::~DbValueArray() {
  // @@protoc_insertion_point(destructor:iot_idl.DbValueArray)
  SharedDtor();
}

void DbValueArray::SharedDtor() {
  if (this != default_instance_) {
  }
}

void DbValueArray::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DbValueArray::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DbValueArray_descriptor_;
}

const DbValueArray& DbValueArray::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_DbSaveMessage_2eproto();
  return *default_instance_;
}

DbValueArray* DbValueArray::default_instance_ = NULL;

DbValueArray* DbValueArray::New() const {
  return new DbValueArray;
}

void DbValueArray::Clear() {
  msgvalue_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DbValueArray::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.DbValueArray)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .iot_idl.SVariable msgValue = 1;
      case 1: {
        if (tag == 10) {
         parse_msgValue:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_msgvalue()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_msgValue;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.DbValueArray)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.DbValueArray)
  return false;
#undef DO_
}

void DbValueArray::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.DbValueArray)
  // repeated .iot_idl.SVariable msgValue = 1;
  for (int i = 0; i < this->msgvalue_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->msgvalue(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.DbValueArray)
}

::google::protobuf::uint8* DbValueArray::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.DbValueArray)
  // repeated .iot_idl.SVariable msgValue = 1;
  for (int i = 0; i < this->msgvalue_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->msgvalue(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.DbValueArray)
  return target;
}

int DbValueArray::ByteSize() const {
  int total_size = 0;

  // repeated .iot_idl.SVariable msgValue = 1;
  total_size += 1 * this->msgvalue_size();
  for (int i = 0; i < this->msgvalue_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->msgvalue(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DbValueArray::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DbValueArray* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DbValueArray*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DbValueArray::MergeFrom(const DbValueArray& from) {
  GOOGLE_CHECK_NE(&from, this);
  msgvalue_.MergeFrom(from.msgvalue_);
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void DbValueArray::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DbValueArray::CopyFrom(const DbValueArray& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DbValueArray::IsInitialized() const {

  if (!::google::protobuf::internal::AllAreInitialized(this->msgvalue())) return false;
  return true;
}

void DbValueArray::Swap(DbValueArray* other) {
  if (other != this) {
    msgvalue_.Swap(&other->msgvalue_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata DbValueArray::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DbValueArray_descriptor_;
  metadata.reflection = DbValueArray_reflection_;
  return metadata;
}


// ===================================================================

#ifndef _MSC_VER
const int DbUpdateValue::kStrColumnNameFieldNumber;
const int DbUpdateValue::kMsgValueFieldNumber;
#endif  // !_MSC_VER

DbUpdateValue::DbUpdateValue()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.DbUpdateValue)
}

void DbUpdateValue::InitAsDefaultInstance() {
  msgvalue_ = const_cast< ::iot_idl::SVariable*>(&::iot_idl::SVariable::default_instance());
}

DbUpdateValue::DbUpdateValue(const DbUpdateValue& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.DbUpdateValue)
}

void DbUpdateValue::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  strcolumnname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  msgvalue_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DbUpdateValue::~DbUpdateValue() {
  // @@protoc_insertion_point(destructor:iot_idl.DbUpdateValue)
  SharedDtor();
}

void DbUpdateValue::SharedDtor() {
  if (strcolumnname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete strcolumnname_;
  }
  if (this != default_instance_) {
    delete msgvalue_;
  }
}

void DbUpdateValue::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DbUpdateValue::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DbUpdateValue_descriptor_;
}

const DbUpdateValue& DbUpdateValue::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_DbSaveMessage_2eproto();
  return *default_instance_;
}

DbUpdateValue* DbUpdateValue::default_instance_ = NULL;

DbUpdateValue* DbUpdateValue::New() const {
  return new DbUpdateValue;
}

void DbUpdateValue::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    if (has_strcolumnname()) {
      if (strcolumnname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        strcolumnname_->clear();
      }
    }
    if (has_msgvalue()) {
      if (msgvalue_ != NULL) msgvalue_->::iot_idl::SVariable::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DbUpdateValue::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.DbUpdateValue)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string strColumnName = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_strcolumnname()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->strcolumnname().data(), this->strcolumnname().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "strcolumnname");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_msgValue;
        break;
      }

      // required .iot_idl.SVariable msgValue = 2;
      case 2: {
        if (tag == 18) {
         parse_msgValue:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_msgvalue()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.DbUpdateValue)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.DbUpdateValue)
  return false;
#undef DO_
}

void DbUpdateValue::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.DbUpdateValue)
  // required string strColumnName = 1;
  if (has_strcolumnname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strcolumnname().data(), this->strcolumnname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strcolumnname");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->strcolumnname(), output);
  }

  // required .iot_idl.SVariable msgValue = 2;
  if (has_msgvalue()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->msgvalue(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.DbUpdateValue)
}

::google::protobuf::uint8* DbUpdateValue::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.DbUpdateValue)
  // required string strColumnName = 1;
  if (has_strcolumnname()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strcolumnname().data(), this->strcolumnname().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strcolumnname");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->strcolumnname(), target);
  }

  // required .iot_idl.SVariable msgValue = 2;
  if (has_msgvalue()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->msgvalue(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.DbUpdateValue)
  return target;
}

int DbUpdateValue::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string strColumnName = 1;
    if (has_strcolumnname()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->strcolumnname());
    }

    // required .iot_idl.SVariable msgValue = 2;
    if (has_msgvalue()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->msgvalue());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DbUpdateValue::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DbUpdateValue* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DbUpdateValue*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DbUpdateValue::MergeFrom(const DbUpdateValue& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_strcolumnname()) {
      set_strcolumnname(from.strcolumnname());
    }
    if (from.has_msgvalue()) {
      mutable_msgvalue()->::iot_idl::SVariable::MergeFrom(from.msgvalue());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void DbUpdateValue::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DbUpdateValue::CopyFrom(const DbUpdateValue& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DbUpdateValue::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  if (has_msgvalue()) {
    if (!this->msgvalue().IsInitialized()) return false;
  }
  return true;
}

void DbUpdateValue::Swap(DbUpdateValue* other) {
  if (other != this) {
    std::swap(strcolumnname_, other->strcolumnname_);
    std::swap(msgvalue_, other->msgvalue_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata DbUpdateValue::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DbUpdateValue_descriptor_;
  metadata.reflection = DbUpdateValue_reflection_;
  return metadata;
}


// ===================================================================

#ifndef _MSC_VER
const int DbInsert::kEnSaveActionFieldNumber;
const int DbInsert::kStrTableNameFieldNumber;
const int DbInsert::kStrColumnNameFieldNumber;
const int DbInsert::kMsgRecordFieldNumber;
#endif  // !_MSC_VER

DbInsert::DbInsert()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.DbInsert)
}

void DbInsert::InitAsDefaultInstance() {
}

DbInsert::DbInsert(const DbInsert& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.DbInsert)
}

void DbInsert::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  ensaveaction_ = 0;
  strtablename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DbInsert::~DbInsert() {
  // @@protoc_insertion_point(destructor:iot_idl.DbInsert)
  SharedDtor();
}

void DbInsert::SharedDtor() {
  if (strtablename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete strtablename_;
  }
  if (this != default_instance_) {
  }
}

void DbInsert::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DbInsert::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DbInsert_descriptor_;
}

const DbInsert& DbInsert::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_DbSaveMessage_2eproto();
  return *default_instance_;
}

DbInsert* DbInsert::default_instance_ = NULL;

DbInsert* DbInsert::New() const {
  return new DbInsert;
}

void DbInsert::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    ensaveaction_ = 0;
    if (has_strtablename()) {
      if (strtablename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        strtablename_->clear();
      }
    }
  }
  strcolumnname_.Clear();
  msgrecord_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DbInsert::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.DbInsert)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .iot_idl.enDssSaveAction enSaveAction = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::enDssSaveAction_IsValid(value)) {
            set_ensaveaction(static_cast< ::iot_idl::enDssSaveAction >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_strTableName;
        break;
      }

      // required string strTableName = 2;
      case 2: {
        if (tag == 18) {
         parse_strTableName:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_strtablename()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->strtablename().data(), this->strtablename().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "strtablename");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_strColumnName;
        break;
      }

      // repeated string strColumnName = 3;
      case 3: {
        if (tag == 26) {
         parse_strColumnName:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_strcolumnname()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->strcolumnname(this->strcolumnname_size() - 1).data(),
            this->strcolumnname(this->strcolumnname_size() - 1).length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "strcolumnname");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_strColumnName;
        if (input->ExpectTag(34)) goto parse_msgRecord;
        break;
      }

      // repeated .iot_idl.DbValueArray msgRecord = 4;
      case 4: {
        if (tag == 34) {
         parse_msgRecord:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_msgrecord()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_msgRecord;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.DbInsert)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.DbInsert)
  return false;
#undef DO_
}

void DbInsert::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.DbInsert)
  // required .iot_idl.enDssSaveAction enSaveAction = 1;
  if (has_ensaveaction()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->ensaveaction(), output);
  }

  // required string strTableName = 2;
  if (has_strtablename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strtablename().data(), this->strtablename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strtablename");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->strtablename(), output);
  }

  // repeated string strColumnName = 3;
  for (int i = 0; i < this->strcolumnname_size(); i++) {
  ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
    this->strcolumnname(i).data(), this->strcolumnname(i).length(),
    ::google::protobuf::internal::WireFormat::SERIALIZE,
    "strcolumnname");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      3, this->strcolumnname(i), output);
  }

  // repeated .iot_idl.DbValueArray msgRecord = 4;
  for (int i = 0; i < this->msgrecord_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->msgrecord(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.DbInsert)
}

::google::protobuf::uint8* DbInsert::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.DbInsert)
  // required .iot_idl.enDssSaveAction enSaveAction = 1;
  if (has_ensaveaction()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->ensaveaction(), target);
  }

  // required string strTableName = 2;
  if (has_strtablename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strtablename().data(), this->strtablename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strtablename");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->strtablename(), target);
  }

  // repeated string strColumnName = 3;
  for (int i = 0; i < this->strcolumnname_size(); i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strcolumnname(i).data(), this->strcolumnname(i).length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strcolumnname");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(3, this->strcolumnname(i), target);
  }

  // repeated .iot_idl.DbValueArray msgRecord = 4;
  for (int i = 0; i < this->msgrecord_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->msgrecord(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.DbInsert)
  return target;
}

int DbInsert::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .iot_idl.enDssSaveAction enSaveAction = 1;
    if (has_ensaveaction()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->ensaveaction());
    }

    // required string strTableName = 2;
    if (has_strtablename()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->strtablename());
    }

  }
  // repeated string strColumnName = 3;
  total_size += 1 * this->strcolumnname_size();
  for (int i = 0; i < this->strcolumnname_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->strcolumnname(i));
  }

  // repeated .iot_idl.DbValueArray msgRecord = 4;
  total_size += 1 * this->msgrecord_size();
  for (int i = 0; i < this->msgrecord_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->msgrecord(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DbInsert::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DbInsert* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DbInsert*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DbInsert::MergeFrom(const DbInsert& from) {
  GOOGLE_CHECK_NE(&from, this);
  strcolumnname_.MergeFrom(from.strcolumnname_);
  msgrecord_.MergeFrom(from.msgrecord_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_ensaveaction()) {
      set_ensaveaction(from.ensaveaction());
    }
    if (from.has_strtablename()) {
      set_strtablename(from.strtablename());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void DbInsert::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DbInsert::CopyFrom(const DbInsert& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DbInsert::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->msgrecord())) return false;
  return true;
}

void DbInsert::Swap(DbInsert* other) {
  if (other != this) {
    std::swap(ensaveaction_, other->ensaveaction_);
    std::swap(strtablename_, other->strtablename_);
    strcolumnname_.Swap(&other->strcolumnname_);
    msgrecord_.Swap(&other->msgrecord_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata DbInsert::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DbInsert_descriptor_;
  metadata.reflection = DbInsert_reflection_;
  return metadata;
}


// ===================================================================

#ifndef _MSC_VER
const int DbRemove::kEnSaveActionFieldNumber;
const int DbRemove::kStrTableNameFieldNumber;
const int DbRemove::kMsgCondtionArrayFieldNumber;
#endif  // !_MSC_VER

DbRemove::DbRemove()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.DbRemove)
}

void DbRemove::InitAsDefaultInstance() {
}

DbRemove::DbRemove(const DbRemove& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.DbRemove)
}

void DbRemove::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  ensaveaction_ = 0;
  strtablename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DbRemove::~DbRemove() {
  // @@protoc_insertion_point(destructor:iot_idl.DbRemove)
  SharedDtor();
}

void DbRemove::SharedDtor() {
  if (strtablename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete strtablename_;
  }
  if (this != default_instance_) {
  }
}

void DbRemove::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DbRemove::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DbRemove_descriptor_;
}

const DbRemove& DbRemove::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_DbSaveMessage_2eproto();
  return *default_instance_;
}

DbRemove* DbRemove::default_instance_ = NULL;

DbRemove* DbRemove::New() const {
  return new DbRemove;
}

void DbRemove::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    ensaveaction_ = 0;
    if (has_strtablename()) {
      if (strtablename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        strtablename_->clear();
      }
    }
  }
  msgcondtionarray_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DbRemove::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.DbRemove)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .iot_idl.enDssSaveAction enSaveAction = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::enDssSaveAction_IsValid(value)) {
            set_ensaveaction(static_cast< ::iot_idl::enDssSaveAction >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_strTableName;
        break;
      }

      // required string strTableName = 2;
      case 2: {
        if (tag == 18) {
         parse_strTableName:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_strtablename()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->strtablename().data(), this->strtablename().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "strtablename");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_msgCondtionArray;
        break;
      }

      // repeated .iot_idl.DbCondition msgCondtionArray = 3;
      case 3: {
        if (tag == 26) {
         parse_msgCondtionArray:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_msgcondtionarray()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_msgCondtionArray;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.DbRemove)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.DbRemove)
  return false;
#undef DO_
}

void DbRemove::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.DbRemove)
  // required .iot_idl.enDssSaveAction enSaveAction = 1;
  if (has_ensaveaction()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->ensaveaction(), output);
  }

  // required string strTableName = 2;
  if (has_strtablename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strtablename().data(), this->strtablename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strtablename");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->strtablename(), output);
  }

  // repeated .iot_idl.DbCondition msgCondtionArray = 3;
  for (int i = 0; i < this->msgcondtionarray_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->msgcondtionarray(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.DbRemove)
}

::google::protobuf::uint8* DbRemove::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.DbRemove)
  // required .iot_idl.enDssSaveAction enSaveAction = 1;
  if (has_ensaveaction()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->ensaveaction(), target);
  }

  // required string strTableName = 2;
  if (has_strtablename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strtablename().data(), this->strtablename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strtablename");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->strtablename(), target);
  }

  // repeated .iot_idl.DbCondition msgCondtionArray = 3;
  for (int i = 0; i < this->msgcondtionarray_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->msgcondtionarray(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.DbRemove)
  return target;
}

int DbRemove::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .iot_idl.enDssSaveAction enSaveAction = 1;
    if (has_ensaveaction()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->ensaveaction());
    }

    // required string strTableName = 2;
    if (has_strtablename()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->strtablename());
    }

  }
  // repeated .iot_idl.DbCondition msgCondtionArray = 3;
  total_size += 1 * this->msgcondtionarray_size();
  for (int i = 0; i < this->msgcondtionarray_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->msgcondtionarray(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DbRemove::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DbRemove* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DbRemove*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DbRemove::MergeFrom(const DbRemove& from) {
  GOOGLE_CHECK_NE(&from, this);
  msgcondtionarray_.MergeFrom(from.msgcondtionarray_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_ensaveaction()) {
      set_ensaveaction(from.ensaveaction());
    }
    if (from.has_strtablename()) {
      set_strtablename(from.strtablename());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void DbRemove::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DbRemove::CopyFrom(const DbRemove& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DbRemove::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->msgcondtionarray())) return false;
  return true;
}

void DbRemove::Swap(DbRemove* other) {
  if (other != this) {
    std::swap(ensaveaction_, other->ensaveaction_);
    std::swap(strtablename_, other->strtablename_);
    msgcondtionarray_.Swap(&other->msgcondtionarray_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata DbRemove::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DbRemove_descriptor_;
  metadata.reflection = DbRemove_reflection_;
  return metadata;
}


// ===================================================================

#ifndef _MSC_VER
const int DbRemoveMulti::kEnSaveActionFieldNumber;
const int DbRemoveMulti::kStrTableNameFieldNumber;
const int DbRemoveMulti::kMsgConditionHeadFieldNumber;
const int DbRemoveMulti::kMsgConditionValueFieldNumber;
#endif  // !_MSC_VER

DbRemoveMulti::DbRemoveMulti()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.DbRemoveMulti)
}

void DbRemoveMulti::InitAsDefaultInstance() {
}

DbRemoveMulti::DbRemoveMulti(const DbRemoveMulti& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.DbRemoveMulti)
}

void DbRemoveMulti::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  ensaveaction_ = 0;
  strtablename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DbRemoveMulti::~DbRemoveMulti() {
  // @@protoc_insertion_point(destructor:iot_idl.DbRemoveMulti)
  SharedDtor();
}

void DbRemoveMulti::SharedDtor() {
  if (strtablename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete strtablename_;
  }
  if (this != default_instance_) {
  }
}

void DbRemoveMulti::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DbRemoveMulti::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DbRemoveMulti_descriptor_;
}

const DbRemoveMulti& DbRemoveMulti::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_DbSaveMessage_2eproto();
  return *default_instance_;
}

DbRemoveMulti* DbRemoveMulti::default_instance_ = NULL;

DbRemoveMulti* DbRemoveMulti::New() const {
  return new DbRemoveMulti;
}

void DbRemoveMulti::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    ensaveaction_ = 0;
    if (has_strtablename()) {
      if (strtablename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        strtablename_->clear();
      }
    }
  }
  msgconditionhead_.Clear();
  msgconditionvalue_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DbRemoveMulti::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.DbRemoveMulti)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .iot_idl.enDssSaveAction enSaveAction = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::enDssSaveAction_IsValid(value)) {
            set_ensaveaction(static_cast< ::iot_idl::enDssSaveAction >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_strTableName;
        break;
      }

      // required string strTableName = 2;
      case 2: {
        if (tag == 18) {
         parse_strTableName:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_strtablename()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->strtablename().data(), this->strtablename().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "strtablename");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_msgConditionHead;
        break;
      }

      // repeated .iot_idl.DbConditionHead msgConditionHead = 3;
      case 3: {
        if (tag == 26) {
         parse_msgConditionHead:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_msgconditionhead()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_msgConditionHead;
        if (input->ExpectTag(34)) goto parse_msgConditionValue;
        break;
      }

      // repeated .iot_idl.DbValueArray msgConditionValue = 4;
      case 4: {
        if (tag == 34) {
         parse_msgConditionValue:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_msgconditionvalue()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_msgConditionValue;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.DbRemoveMulti)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.DbRemoveMulti)
  return false;
#undef DO_
}

void DbRemoveMulti::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.DbRemoveMulti)
  // required .iot_idl.enDssSaveAction enSaveAction = 1;
  if (has_ensaveaction()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->ensaveaction(), output);
  }

  // required string strTableName = 2;
  if (has_strtablename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strtablename().data(), this->strtablename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strtablename");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->strtablename(), output);
  }

  // repeated .iot_idl.DbConditionHead msgConditionHead = 3;
  for (int i = 0; i < this->msgconditionhead_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->msgconditionhead(i), output);
  }

  // repeated .iot_idl.DbValueArray msgConditionValue = 4;
  for (int i = 0; i < this->msgconditionvalue_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->msgconditionvalue(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.DbRemoveMulti)
}

::google::protobuf::uint8* DbRemoveMulti::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.DbRemoveMulti)
  // required .iot_idl.enDssSaveAction enSaveAction = 1;
  if (has_ensaveaction()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->ensaveaction(), target);
  }

  // required string strTableName = 2;
  if (has_strtablename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strtablename().data(), this->strtablename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strtablename");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->strtablename(), target);
  }

  // repeated .iot_idl.DbConditionHead msgConditionHead = 3;
  for (int i = 0; i < this->msgconditionhead_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->msgconditionhead(i), target);
  }

  // repeated .iot_idl.DbValueArray msgConditionValue = 4;
  for (int i = 0; i < this->msgconditionvalue_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->msgconditionvalue(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.DbRemoveMulti)
  return target;
}

int DbRemoveMulti::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .iot_idl.enDssSaveAction enSaveAction = 1;
    if (has_ensaveaction()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->ensaveaction());
    }

    // required string strTableName = 2;
    if (has_strtablename()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->strtablename());
    }

  }
  // repeated .iot_idl.DbConditionHead msgConditionHead = 3;
  total_size += 1 * this->msgconditionhead_size();
  for (int i = 0; i < this->msgconditionhead_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->msgconditionhead(i));
  }

  // repeated .iot_idl.DbValueArray msgConditionValue = 4;
  total_size += 1 * this->msgconditionvalue_size();
  for (int i = 0; i < this->msgconditionvalue_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->msgconditionvalue(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DbRemoveMulti::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DbRemoveMulti* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DbRemoveMulti*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DbRemoveMulti::MergeFrom(const DbRemoveMulti& from) {
  GOOGLE_CHECK_NE(&from, this);
  msgconditionhead_.MergeFrom(from.msgconditionhead_);
  msgconditionvalue_.MergeFrom(from.msgconditionvalue_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_ensaveaction()) {
      set_ensaveaction(from.ensaveaction());
    }
    if (from.has_strtablename()) {
      set_strtablename(from.strtablename());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void DbRemoveMulti::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DbRemoveMulti::CopyFrom(const DbRemoveMulti& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DbRemoveMulti::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->msgconditionhead())) return false;
  if (!::google::protobuf::internal::AllAreInitialized(this->msgconditionvalue())) return false;
  return true;
}

void DbRemoveMulti::Swap(DbRemoveMulti* other) {
  if (other != this) {
    std::swap(ensaveaction_, other->ensaveaction_);
    std::swap(strtablename_, other->strtablename_);
    msgconditionhead_.Swap(&other->msgconditionhead_);
    msgconditionvalue_.Swap(&other->msgconditionvalue_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata DbRemoveMulti::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DbRemoveMulti_descriptor_;
  metadata.reflection = DbRemoveMulti_reflection_;
  return metadata;
}


// ===================================================================

#ifndef _MSC_VER
const int DbUpdate::kEnSaveActionFieldNumber;
const int DbUpdate::kStrTableNameFieldNumber;
const int DbUpdate::kMsgUpdateValueFieldNumber;
const int DbUpdate::kMsgConditionFieldNumber;
#endif  // !_MSC_VER

DbUpdate::DbUpdate()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.DbUpdate)
}

void DbUpdate::InitAsDefaultInstance() {
}

DbUpdate::DbUpdate(const DbUpdate& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.DbUpdate)
}

void DbUpdate::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  ensaveaction_ = 0;
  strtablename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DbUpdate::~DbUpdate() {
  // @@protoc_insertion_point(destructor:iot_idl.DbUpdate)
  SharedDtor();
}

void DbUpdate::SharedDtor() {
  if (strtablename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete strtablename_;
  }
  if (this != default_instance_) {
  }
}

void DbUpdate::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DbUpdate::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DbUpdate_descriptor_;
}

const DbUpdate& DbUpdate::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_DbSaveMessage_2eproto();
  return *default_instance_;
}

DbUpdate* DbUpdate::default_instance_ = NULL;

DbUpdate* DbUpdate::New() const {
  return new DbUpdate;
}

void DbUpdate::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    ensaveaction_ = 0;
    if (has_strtablename()) {
      if (strtablename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        strtablename_->clear();
      }
    }
  }
  msgupdatevalue_.Clear();
  msgcondition_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DbUpdate::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.DbUpdate)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .iot_idl.enDssSaveAction enSaveAction = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::enDssSaveAction_IsValid(value)) {
            set_ensaveaction(static_cast< ::iot_idl::enDssSaveAction >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_strTableName;
        break;
      }

      // required string strTableName = 2;
      case 2: {
        if (tag == 18) {
         parse_strTableName:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_strtablename()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->strtablename().data(), this->strtablename().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "strtablename");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_msgUpdateValue;
        break;
      }

      // repeated .iot_idl.DbUpdateValue msgUpdateValue = 3;
      case 3: {
        if (tag == 26) {
         parse_msgUpdateValue:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_msgupdatevalue()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_msgUpdateValue;
        if (input->ExpectTag(34)) goto parse_msgCondition;
        break;
      }

      // repeated .iot_idl.DbCondition msgCondition = 4;
      case 4: {
        if (tag == 34) {
         parse_msgCondition:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_msgcondition()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_msgCondition;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.DbUpdate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.DbUpdate)
  return false;
#undef DO_
}

void DbUpdate::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.DbUpdate)
  // required .iot_idl.enDssSaveAction enSaveAction = 1;
  if (has_ensaveaction()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->ensaveaction(), output);
  }

  // required string strTableName = 2;
  if (has_strtablename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strtablename().data(), this->strtablename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strtablename");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->strtablename(), output);
  }

  // repeated .iot_idl.DbUpdateValue msgUpdateValue = 3;
  for (int i = 0; i < this->msgupdatevalue_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->msgupdatevalue(i), output);
  }

  // repeated .iot_idl.DbCondition msgCondition = 4;
  for (int i = 0; i < this->msgcondition_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->msgcondition(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.DbUpdate)
}

::google::protobuf::uint8* DbUpdate::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.DbUpdate)
  // required .iot_idl.enDssSaveAction enSaveAction = 1;
  if (has_ensaveaction()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->ensaveaction(), target);
  }

  // required string strTableName = 2;
  if (has_strtablename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strtablename().data(), this->strtablename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strtablename");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->strtablename(), target);
  }

  // repeated .iot_idl.DbUpdateValue msgUpdateValue = 3;
  for (int i = 0; i < this->msgupdatevalue_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->msgupdatevalue(i), target);
  }

  // repeated .iot_idl.DbCondition msgCondition = 4;
  for (int i = 0; i < this->msgcondition_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->msgcondition(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.DbUpdate)
  return target;
}

int DbUpdate::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .iot_idl.enDssSaveAction enSaveAction = 1;
    if (has_ensaveaction()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->ensaveaction());
    }

    // required string strTableName = 2;
    if (has_strtablename()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->strtablename());
    }

  }
  // repeated .iot_idl.DbUpdateValue msgUpdateValue = 3;
  total_size += 1 * this->msgupdatevalue_size();
  for (int i = 0; i < this->msgupdatevalue_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->msgupdatevalue(i));
  }

  // repeated .iot_idl.DbCondition msgCondition = 4;
  total_size += 1 * this->msgcondition_size();
  for (int i = 0; i < this->msgcondition_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->msgcondition(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DbUpdate::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DbUpdate* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DbUpdate*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DbUpdate::MergeFrom(const DbUpdate& from) {
  GOOGLE_CHECK_NE(&from, this);
  msgupdatevalue_.MergeFrom(from.msgupdatevalue_);
  msgcondition_.MergeFrom(from.msgcondition_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_ensaveaction()) {
      set_ensaveaction(from.ensaveaction());
    }
    if (from.has_strtablename()) {
      set_strtablename(from.strtablename());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void DbUpdate::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DbUpdate::CopyFrom(const DbUpdate& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DbUpdate::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->msgupdatevalue())) return false;
  if (!::google::protobuf::internal::AllAreInitialized(this->msgcondition())) return false;
  return true;
}

void DbUpdate::Swap(DbUpdate* other) {
  if (other != this) {
    std::swap(ensaveaction_, other->ensaveaction_);
    std::swap(strtablename_, other->strtablename_);
    msgupdatevalue_.Swap(&other->msgupdatevalue_);
    msgcondition_.Swap(&other->msgcondition_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata DbUpdate::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DbUpdate_descriptor_;
  metadata.reflection = DbUpdate_reflection_;
  return metadata;
}


// ===================================================================

#ifndef _MSC_VER
const int DbUpdateMulti::kEnSaveActionFieldNumber;
const int DbUpdateMulti::kStrTableNameFieldNumber;
const int DbUpdateMulti::kMsgUpdateValueFieldNumber;
const int DbUpdateMulti::kMsgConditionHeadFieldNumber;
const int DbUpdateMulti::kMsgConditionValueFieldNumber;
#endif  // !_MSC_VER

DbUpdateMulti::DbUpdateMulti()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.DbUpdateMulti)
}

void DbUpdateMulti::InitAsDefaultInstance() {
}

DbUpdateMulti::DbUpdateMulti(const DbUpdateMulti& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.DbUpdateMulti)
}

void DbUpdateMulti::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  ensaveaction_ = 0;
  strtablename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DbUpdateMulti::~DbUpdateMulti() {
  // @@protoc_insertion_point(destructor:iot_idl.DbUpdateMulti)
  SharedDtor();
}

void DbUpdateMulti::SharedDtor() {
  if (strtablename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete strtablename_;
  }
  if (this != default_instance_) {
  }
}

void DbUpdateMulti::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DbUpdateMulti::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DbUpdateMulti_descriptor_;
}

const DbUpdateMulti& DbUpdateMulti::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_DbSaveMessage_2eproto();
  return *default_instance_;
}

DbUpdateMulti* DbUpdateMulti::default_instance_ = NULL;

DbUpdateMulti* DbUpdateMulti::New() const {
  return new DbUpdateMulti;
}

void DbUpdateMulti::Clear() {
  if (_has_bits_[0 / 32] & 3) {
    ensaveaction_ = 0;
    if (has_strtablename()) {
      if (strtablename_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        strtablename_->clear();
      }
    }
  }
  msgupdatevalue_.Clear();
  msgconditionhead_.Clear();
  msgconditionvalue_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DbUpdateMulti::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.DbUpdateMulti)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .iot_idl.enDssSaveAction enSaveAction = 1;
      case 1: {
        if (tag == 8) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::iot_idl::enDssSaveAction_IsValid(value)) {
            set_ensaveaction(static_cast< ::iot_idl::enDssSaveAction >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_strTableName;
        break;
      }

      // required string strTableName = 2;
      case 2: {
        if (tag == 18) {
         parse_strTableName:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_strtablename()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->strtablename().data(), this->strtablename().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "strtablename");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_msgUpdateValue;
        break;
      }

      // repeated .iot_idl.DbUpdateValue msgUpdateValue = 3;
      case 3: {
        if (tag == 26) {
         parse_msgUpdateValue:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_msgupdatevalue()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_msgUpdateValue;
        if (input->ExpectTag(34)) goto parse_msgConditionHead;
        break;
      }

      // repeated .iot_idl.DbConditionHead msgConditionHead = 4;
      case 4: {
        if (tag == 34) {
         parse_msgConditionHead:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_msgconditionhead()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_msgConditionHead;
        if (input->ExpectTag(42)) goto parse_msgConditionValue;
        break;
      }

      // repeated .iot_idl.DbValueArray msgConditionValue = 5;
      case 5: {
        if (tag == 42) {
         parse_msgConditionValue:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_msgconditionvalue()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_msgConditionValue;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.DbUpdateMulti)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.DbUpdateMulti)
  return false;
#undef DO_
}

void DbUpdateMulti::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.DbUpdateMulti)
  // required .iot_idl.enDssSaveAction enSaveAction = 1;
  if (has_ensaveaction()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->ensaveaction(), output);
  }

  // required string strTableName = 2;
  if (has_strtablename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strtablename().data(), this->strtablename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strtablename");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->strtablename(), output);
  }

  // repeated .iot_idl.DbUpdateValue msgUpdateValue = 3;
  for (int i = 0; i < this->msgupdatevalue_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->msgupdatevalue(i), output);
  }

  // repeated .iot_idl.DbConditionHead msgConditionHead = 4;
  for (int i = 0; i < this->msgconditionhead_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->msgconditionhead(i), output);
  }

  // repeated .iot_idl.DbValueArray msgConditionValue = 5;
  for (int i = 0; i < this->msgconditionvalue_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->msgconditionvalue(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.DbUpdateMulti)
}

::google::protobuf::uint8* DbUpdateMulti::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.DbUpdateMulti)
  // required .iot_idl.enDssSaveAction enSaveAction = 1;
  if (has_ensaveaction()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->ensaveaction(), target);
  }

  // required string strTableName = 2;
  if (has_strtablename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->strtablename().data(), this->strtablename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "strtablename");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->strtablename(), target);
  }

  // repeated .iot_idl.DbUpdateValue msgUpdateValue = 3;
  for (int i = 0; i < this->msgupdatevalue_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->msgupdatevalue(i), target);
  }

  // repeated .iot_idl.DbConditionHead msgConditionHead = 4;
  for (int i = 0; i < this->msgconditionhead_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->msgconditionhead(i), target);
  }

  // repeated .iot_idl.DbValueArray msgConditionValue = 5;
  for (int i = 0; i < this->msgconditionvalue_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->msgconditionvalue(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.DbUpdateMulti)
  return target;
}

int DbUpdateMulti::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .iot_idl.enDssSaveAction enSaveAction = 1;
    if (has_ensaveaction()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->ensaveaction());
    }

    // required string strTableName = 2;
    if (has_strtablename()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->strtablename());
    }

  }
  // repeated .iot_idl.DbUpdateValue msgUpdateValue = 3;
  total_size += 1 * this->msgupdatevalue_size();
  for (int i = 0; i < this->msgupdatevalue_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->msgupdatevalue(i));
  }

  // repeated .iot_idl.DbConditionHead msgConditionHead = 4;
  total_size += 1 * this->msgconditionhead_size();
  for (int i = 0; i < this->msgconditionhead_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->msgconditionhead(i));
  }

  // repeated .iot_idl.DbValueArray msgConditionValue = 5;
  total_size += 1 * this->msgconditionvalue_size();
  for (int i = 0; i < this->msgconditionvalue_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->msgconditionvalue(i));
  }

  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DbUpdateMulti::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DbUpdateMulti* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DbUpdateMulti*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DbUpdateMulti::MergeFrom(const DbUpdateMulti& from) {
  GOOGLE_CHECK_NE(&from, this);
  msgupdatevalue_.MergeFrom(from.msgupdatevalue_);
  msgconditionhead_.MergeFrom(from.msgconditionhead_);
  msgconditionvalue_.MergeFrom(from.msgconditionvalue_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_ensaveaction()) {
      set_ensaveaction(from.ensaveaction());
    }
    if (from.has_strtablename()) {
      set_strtablename(from.strtablename());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void DbUpdateMulti::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DbUpdateMulti::CopyFrom(const DbUpdateMulti& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DbUpdateMulti::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->msgupdatevalue())) return false;
  if (!::google::protobuf::internal::AllAreInitialized(this->msgconditionhead())) return false;
  if (!::google::protobuf::internal::AllAreInitialized(this->msgconditionvalue())) return false;
  return true;
}

void DbUpdateMulti::Swap(DbUpdateMulti* other) {
  if (other != this) {
    std::swap(ensaveaction_, other->ensaveaction_);
    std::swap(strtablename_, other->strtablename_);
    msgupdatevalue_.Swap(&other->msgupdatevalue_);
    msgconditionhead_.Swap(&other->msgconditionhead_);
    msgconditionvalue_.Swap(&other->msgconditionvalue_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata DbUpdateMulti::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DbUpdateMulti_descriptor_;
  metadata.reflection = DbUpdateMulti_reflection_;
  return metadata;
}


// ===================================================================

#ifndef _MSC_VER
const int DbRequest::kMsgInsertFieldNumber;
const int DbRequest::kMsgRemoveFieldNumber;
const int DbRequest::kMsgRemoveMultiFieldNumber;
const int DbRequest::kMsgUpdateFieldNumber;
const int DbRequest::kMsgUpdateMultiFieldNumber;
#endif  // !_MSC_VER

DbRequest::DbRequest()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:iot_idl.DbRequest)
}

void DbRequest::InitAsDefaultInstance() {
  msginsert_ = const_cast< ::iot_idl::DbInsert*>(&::iot_idl::DbInsert::default_instance());
  msgremove_ = const_cast< ::iot_idl::DbRemove*>(&::iot_idl::DbRemove::default_instance());
  msgremovemulti_ = const_cast< ::iot_idl::DbRemoveMulti*>(&::iot_idl::DbRemoveMulti::default_instance());
  msgupdate_ = const_cast< ::iot_idl::DbUpdate*>(&::iot_idl::DbUpdate::default_instance());
  msgupdatemulti_ = const_cast< ::iot_idl::DbUpdateMulti*>(&::iot_idl::DbUpdateMulti::default_instance());
}

DbRequest::DbRequest(const DbRequest& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:iot_idl.DbRequest)
}

void DbRequest::SharedCtor() {
  _cached_size_ = 0;
  msginsert_ = NULL;
  msgremove_ = NULL;
  msgremovemulti_ = NULL;
  msgupdate_ = NULL;
  msgupdatemulti_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DbRequest::~DbRequest() {
  // @@protoc_insertion_point(destructor:iot_idl.DbRequest)
  SharedDtor();
}

void DbRequest::SharedDtor() {
  if (this != default_instance_) {
    delete msginsert_;
    delete msgremove_;
    delete msgremovemulti_;
    delete msgupdate_;
    delete msgupdatemulti_;
  }
}

void DbRequest::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DbRequest::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DbRequest_descriptor_;
}

const DbRequest& DbRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_DbSaveMessage_2eproto();
  return *default_instance_;
}

DbRequest* DbRequest::default_instance_ = NULL;

DbRequest* DbRequest::New() const {
  return new DbRequest;
}

void DbRequest::Clear() {
  if (_has_bits_[0 / 32] & 31) {
    if (has_msginsert()) {
      if (msginsert_ != NULL) msginsert_->::iot_idl::DbInsert::Clear();
    }
    if (has_msgremove()) {
      if (msgremove_ != NULL) msgremove_->::iot_idl::DbRemove::Clear();
    }
    if (has_msgremovemulti()) {
      if (msgremovemulti_ != NULL) msgremovemulti_->::iot_idl::DbRemoveMulti::Clear();
    }
    if (has_msgupdate()) {
      if (msgupdate_ != NULL) msgupdate_->::iot_idl::DbUpdate::Clear();
    }
    if (has_msgupdatemulti()) {
      if (msgupdatemulti_ != NULL) msgupdatemulti_->::iot_idl::DbUpdateMulti::Clear();
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool DbRequest::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:iot_idl.DbRequest)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .iot_idl.DbInsert msgInsert = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_msginsert()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_msgRemove;
        break;
      }

      // optional .iot_idl.DbRemove msgRemove = 2;
      case 2: {
        if (tag == 18) {
         parse_msgRemove:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_msgremove()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_msgRemoveMulti;
        break;
      }

      // optional .iot_idl.DbRemoveMulti msgRemoveMulti = 3;
      case 3: {
        if (tag == 26) {
         parse_msgRemoveMulti:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_msgremovemulti()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_msgUpdate;
        break;
      }

      // optional .iot_idl.DbUpdate msgUpdate = 4;
      case 4: {
        if (tag == 34) {
         parse_msgUpdate:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_msgupdate()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_msgUpdateMulti;
        break;
      }

      // optional .iot_idl.DbUpdateMulti msgUpdateMulti = 5;
      case 5: {
        if (tag == 42) {
         parse_msgUpdateMulti:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_msgupdatemulti()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:iot_idl.DbRequest)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:iot_idl.DbRequest)
  return false;
#undef DO_
}

void DbRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:iot_idl.DbRequest)
  // optional .iot_idl.DbInsert msgInsert = 1;
  if (has_msginsert()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->msginsert(), output);
  }

  // optional .iot_idl.DbRemove msgRemove = 2;
  if (has_msgremove()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->msgremove(), output);
  }

  // optional .iot_idl.DbRemoveMulti msgRemoveMulti = 3;
  if (has_msgremovemulti()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      3, this->msgremovemulti(), output);
  }

  // optional .iot_idl.DbUpdate msgUpdate = 4;
  if (has_msgupdate()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      4, this->msgupdate(), output);
  }

  // optional .iot_idl.DbUpdateMulti msgUpdateMulti = 5;
  if (has_msgupdatemulti()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->msgupdatemulti(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:iot_idl.DbRequest)
}

::google::protobuf::uint8* DbRequest::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:iot_idl.DbRequest)
  // optional .iot_idl.DbInsert msgInsert = 1;
  if (has_msginsert()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->msginsert(), target);
  }

  // optional .iot_idl.DbRemove msgRemove = 2;
  if (has_msgremove()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->msgremove(), target);
  }

  // optional .iot_idl.DbRemoveMulti msgRemoveMulti = 3;
  if (has_msgremovemulti()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        3, this->msgremovemulti(), target);
  }

  // optional .iot_idl.DbUpdate msgUpdate = 4;
  if (has_msgupdate()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        4, this->msgupdate(), target);
  }

  // optional .iot_idl.DbUpdateMulti msgUpdateMulti = 5;
  if (has_msgupdatemulti()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->msgupdatemulti(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:iot_idl.DbRequest)
  return target;
}

int DbRequest::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .iot_idl.DbInsert msgInsert = 1;
    if (has_msginsert()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->msginsert());
    }

    // optional .iot_idl.DbRemove msgRemove = 2;
    if (has_msgremove()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->msgremove());
    }

    // optional .iot_idl.DbRemoveMulti msgRemoveMulti = 3;
    if (has_msgremovemulti()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->msgremovemulti());
    }

    // optional .iot_idl.DbUpdate msgUpdate = 4;
    if (has_msgupdate()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->msgupdate());
    }

    // optional .iot_idl.DbUpdateMulti msgUpdateMulti = 5;
    if (has_msgupdatemulti()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->msgupdatemulti());
    }

  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DbRequest::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const DbRequest* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const DbRequest*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void DbRequest::MergeFrom(const DbRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_msginsert()) {
      mutable_msginsert()->::iot_idl::DbInsert::MergeFrom(from.msginsert());
    }
    if (from.has_msgremove()) {
      mutable_msgremove()->::iot_idl::DbRemove::MergeFrom(from.msgremove());
    }
    if (from.has_msgremovemulti()) {
      mutable_msgremovemulti()->::iot_idl::DbRemoveMulti::MergeFrom(from.msgremovemulti());
    }
    if (from.has_msgupdate()) {
      mutable_msgupdate()->::iot_idl::DbUpdate::MergeFrom(from.msgupdate());
    }
    if (from.has_msgupdatemulti()) {
      mutable_msgupdatemulti()->::iot_idl::DbUpdateMulti::MergeFrom(from.msgupdatemulti());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void DbRequest::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DbRequest::CopyFrom(const DbRequest& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DbRequest::IsInitialized() const {

  if (has_msginsert()) {
    if (!this->msginsert().IsInitialized()) return false;
  }
  if (has_msgremove()) {
    if (!this->msgremove().IsInitialized()) return false;
  }
  if (has_msgremovemulti()) {
    if (!this->msgremovemulti().IsInitialized()) return false;
  }
  if (has_msgupdate()) {
    if (!this->msgupdate().IsInitialized()) return false;
  }
  if (has_msgupdatemulti()) {
    if (!this->msgupdatemulti().IsInitialized()) return false;
  }
  return true;
}

void DbRequest::Swap(DbRequest* other) {
  if (other != this) {
    std::swap(msginsert_, other->msginsert_);
    std::swap(msgremove_, other->msgremove_);
    std::swap(msgremovemulti_, other->msgremovemulti_);
    std::swap(msgupdate_, other->msgupdate_);
    std::swap(msgupdatemulti_, other->msgupdatemulti_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata DbRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DbRequest_descriptor_;
  metadata.reflection = DbRequest_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace iot_idl

// @@protoc_insertion_point(global_scope)