autobuild-tools/code/sys_nicmonitor/include/db_com/rdb_define.pb.h

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

#ifndef PROTOBUF_rdb_5fdefine_2eproto__INCLUDED
#define PROTOBUF_rdb_5fdefine_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2005000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)

namespace RDB_PROTO {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_rdb_5fdefine_2eproto();
void protobuf_AssignDesc_rdb_5fdefine_2eproto();
void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

class SEQ_STRING;
class SEQ_CHAR;
class SEQ_FLOAT;
class SEQ_INT;
class SEQ_LONG;
class APPKEYID_STRUCT;
class APPID_STRUCT;
class RTDBKEY_STRUCT;
class APPRTDBKDY_STRUCT;
class UNION_DATA_VALUE;
class SEQ_DATA_VALUE;
class DBERROR_STRUCT;
class SEQ_DBERROR;
class RESULT_DATA_VALUE;
class SEQ_RESULT_DATA_VALUE;
class RESULT_FIELD_INFO;
class SEQ_RESULT_FIELD_INFO;
class OUT_DATA_TYPE;
class SEQ_OUT_DATA_TYPE;
class SELECT_RESULT;
class EXEC_MULTI_RESULT;
class SEQ_EXEC_MULTI_RESULT;
class BIND_PARA;
class SEQ_BIND_PARA;

enum DB_BYTE_T {
  BYTE_LITTLE_ENDIAN = 0,
  BYTE_BIG_ENDIAN = 1,
  BYTE_OTHER = 2
};
bool DB_BYTE_T_IsValid(int value);
const DB_BYTE_T DB_BYTE_T_MIN = BYTE_LITTLE_ENDIAN;
const DB_BYTE_T DB_BYTE_T_MAX = BYTE_OTHER;
const int DB_BYTE_T_ARRAYSIZE = DB_BYTE_T_MAX + 1;

const ::google::protobuf::EnumDescriptor* DB_BYTE_T_descriptor();
inline const ::std::string& DB_BYTE_T_Name(DB_BYTE_T value) {
  return ::google::protobuf::internal::NameOfEnum(
    DB_BYTE_T_descriptor(), value);
}
inline bool DB_BYTE_T_Parse(
    const ::std::string& name, DB_BYTE_T* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DB_BYTE_T>(
    DB_BYTE_T_descriptor(), name, value);
}
// ===================================================================

class SEQ_STRING : public ::google::protobuf::Message {
 public:
  SEQ_STRING();
  virtual ~SEQ_STRING();

  SEQ_STRING(const SEQ_STRING& from);

  inline SEQ_STRING& operator=(const SEQ_STRING& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SEQ_STRING& default_instance();

  void Swap(SEQ_STRING* other);

  // implements Message ----------------------------------------------

  SEQ_STRING* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SEQ_STRING& from);
  void MergeFrom(const SEQ_STRING& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated bytes vec_string = 1;
  inline int vec_string_size() const;
  inline void clear_vec_string();
  static const int kVecStringFieldNumber = 1;
  inline const ::std::string& vec_string(int index) const;
  inline ::std::string* mutable_vec_string(int index);
  inline void set_vec_string(int index, const ::std::string& value);
  inline void set_vec_string(int index, const char* value);
  inline void set_vec_string(int index, const void* value, size_t size);
  inline ::std::string* add_vec_string();
  inline void add_vec_string(const ::std::string& value);
  inline void add_vec_string(const char* value);
  inline void add_vec_string(const void* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& vec_string() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_vec_string();

  // @@protoc_insertion_point(class_scope:RDB_PROTO.SEQ_STRING)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::std::string> vec_string_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static SEQ_STRING* default_instance_;
};
// -------------------------------------------------------------------

class SEQ_CHAR : public ::google::protobuf::Message {
 public:
  SEQ_CHAR();
  virtual ~SEQ_CHAR();

  SEQ_CHAR(const SEQ_CHAR& from);

  inline SEQ_CHAR& operator=(const SEQ_CHAR& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SEQ_CHAR& default_instance();

  void Swap(SEQ_CHAR* other);

  // implements Message ----------------------------------------------

  SEQ_CHAR* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SEQ_CHAR& from);
  void MergeFrom(const SEQ_CHAR& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes vec_char = 1;
  inline bool has_vec_char() const;
  inline void clear_vec_char();
  static const int kVecCharFieldNumber = 1;
  inline const ::std::string& vec_char() const;
  inline void set_vec_char(const ::std::string& value);
  inline void set_vec_char(const char* value);
  inline void set_vec_char(const void* value, size_t size);
  inline ::std::string* mutable_vec_char();
  inline ::std::string* release_vec_char();
  inline void set_allocated_vec_char(::std::string* vec_char);

  // @@protoc_insertion_point(class_scope:RDB_PROTO.SEQ_CHAR)
 private:
  inline void set_has_vec_char();
  inline void clear_has_vec_char();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* vec_char_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static SEQ_CHAR* default_instance_;
};
// -------------------------------------------------------------------

class SEQ_FLOAT : public ::google::protobuf::Message {
 public:
  SEQ_FLOAT();
  virtual ~SEQ_FLOAT();

  SEQ_FLOAT(const SEQ_FLOAT& from);

  inline SEQ_FLOAT& operator=(const SEQ_FLOAT& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SEQ_FLOAT& default_instance();

  void Swap(SEQ_FLOAT* other);

  // implements Message ----------------------------------------------

  SEQ_FLOAT* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SEQ_FLOAT& from);
  void MergeFrom(const SEQ_FLOAT& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated float vec_float = 1;
  inline int vec_float_size() const;
  inline void clear_vec_float();
  static const int kVecFloatFieldNumber = 1;
  inline float vec_float(int index) const;
  inline void set_vec_float(int index, float value);
  inline void add_vec_float(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      vec_float() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_vec_float();

  // @@protoc_insertion_point(class_scope:RDB_PROTO.SEQ_FLOAT)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedField< float > vec_float_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static SEQ_FLOAT* default_instance_;
};
// -------------------------------------------------------------------

class SEQ_INT : public ::google::protobuf::Message {
 public:
  SEQ_INT();
  virtual ~SEQ_INT();

  SEQ_INT(const SEQ_INT& from);

  inline SEQ_INT& operator=(const SEQ_INT& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SEQ_INT& default_instance();

  void Swap(SEQ_INT* other);

  // implements Message ----------------------------------------------

  SEQ_INT* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SEQ_INT& from);
  void MergeFrom(const SEQ_INT& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 vec_int = 1;
  inline int vec_int_size() const;
  inline void clear_vec_int();
  static const int kVecIntFieldNumber = 1;
  inline ::google::protobuf::int32 vec_int(int index) const;
  inline void set_vec_int(int index, ::google::protobuf::int32 value);
  inline void add_vec_int(::google::protobuf::int32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      vec_int() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_vec_int();

  // @@protoc_insertion_point(class_scope:RDB_PROTO.SEQ_INT)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > vec_int_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static SEQ_INT* default_instance_;
};
// -------------------------------------------------------------------

class SEQ_LONG : public ::google::protobuf::Message {
 public:
  SEQ_LONG();
  virtual ~SEQ_LONG();

  SEQ_LONG(const SEQ_LONG& from);

  inline SEQ_LONG& operator=(const SEQ_LONG& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SEQ_LONG& default_instance();

  void Swap(SEQ_LONG* other);

  // implements Message ----------------------------------------------

  SEQ_LONG* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SEQ_LONG& from);
  void MergeFrom(const SEQ_LONG& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int64 vec_long = 1;
  inline int vec_long_size() const;
  inline void clear_vec_long();
  static const int kVecLongFieldNumber = 1;
  inline ::google::protobuf::int64 vec_long(int index) const;
  inline void set_vec_long(int index, ::google::protobuf::int64 value);
  inline void add_vec_long(::google::protobuf::int64 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      vec_long() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_vec_long();

  // @@protoc_insertion_point(class_scope:RDB_PROTO.SEQ_LONG)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > vec_long_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static SEQ_LONG* default_instance_;
};
// -------------------------------------------------------------------

class APPKEYID_STRUCT : public ::google::protobuf::Message {
 public:
  APPKEYID_STRUCT();
  virtual ~APPKEYID_STRUCT();

  APPKEYID_STRUCT(const APPKEYID_STRUCT& from);

  inline APPKEYID_STRUCT& operator=(const APPKEYID_STRUCT& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const APPKEYID_STRUCT& default_instance();

  void Swap(APPKEYID_STRUCT* other);

  // implements Message ----------------------------------------------

  APPKEYID_STRUCT* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const APPKEYID_STRUCT& from);
  void MergeFrom(const APPKEYID_STRUCT& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 app_id = 1;
  inline bool has_app_id() const;
  inline void clear_app_id();
  static const int kAppIdFieldNumber = 1;
  inline ::google::protobuf::int32 app_id() const;
  inline void set_app_id(::google::protobuf::int32 value);

  // optional int64 key_id = 2;
  inline bool has_key_id() const;
  inline void clear_key_id();
  static const int kKeyIdFieldNumber = 2;
  inline ::google::protobuf::int64 key_id() const;
  inline void set_key_id(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:RDB_PROTO.APPKEYID_STRUCT)
 private:
  inline void set_has_app_id();
  inline void clear_has_app_id();
  inline void set_has_key_id();
  inline void clear_has_key_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int64 key_id_;
  ::google::protobuf::int32 app_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static APPKEYID_STRUCT* default_instance_;
};
// -------------------------------------------------------------------

class APPID_STRUCT : public ::google::protobuf::Message {
 public:
  APPID_STRUCT();
  virtual ~APPID_STRUCT();

  APPID_STRUCT(const APPID_STRUCT& from);

  inline APPID_STRUCT& operator=(const APPID_STRUCT& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const APPID_STRUCT& default_instance();

  void Swap(APPID_STRUCT* other);

  // implements Message ----------------------------------------------

  APPID_STRUCT* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const APPID_STRUCT& from);
  void MergeFrom(const APPID_STRUCT& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 app_id = 1;
  inline bool has_app_id() const;
  inline void clear_app_id();
  static const int kAppIdFieldNumber = 1;
  inline ::google::protobuf::int32 app_id() const;
  inline void set_app_id(::google::protobuf::int32 value);

  // optional int64 key_id = 2;
  inline bool has_key_id() const;
  inline void clear_key_id();
  static const int kKeyIdFieldNumber = 2;
  inline ::google::protobuf::int64 key_id() const;
  inline void set_key_id(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:RDB_PROTO.APPID_STRUCT)
 private:
  inline void set_has_app_id();
  inline void clear_has_app_id();
  inline void set_has_key_id();
  inline void clear_has_key_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int64 key_id_;
  ::google::protobuf::int32 app_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static APPID_STRUCT* default_instance_;
};
// -------------------------------------------------------------------

class RTDBKEY_STRUCT : public ::google::protobuf::Message {
 public:
  RTDBKEY_STRUCT();
  virtual ~RTDBKEY_STRUCT();

  RTDBKEY_STRUCT(const RTDBKEY_STRUCT& from);

  inline RTDBKEY_STRUCT& operator=(const RTDBKEY_STRUCT& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RTDBKEY_STRUCT& default_instance();

  void Swap(RTDBKEY_STRUCT* other);

  // implements Message ----------------------------------------------

  RTDBKEY_STRUCT* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RTDBKEY_STRUCT& from);
  void MergeFrom(const RTDBKEY_STRUCT& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional sint64 table_column_id = 1;
  inline bool has_table_column_id() const;
  inline void clear_table_column_id();
  static const int kTableColumnIdFieldNumber = 1;
  inline ::google::protobuf::int64 table_column_id() const;
  inline void set_table_column_id(::google::protobuf::int64 value);

  // optional sint64 region_record_id = 2;
  inline bool has_region_record_id() const;
  inline void clear_region_record_id();
  static const int kRegionRecordIdFieldNumber = 2;
  inline ::google::protobuf::int64 region_record_id() const;
  inline void set_region_record_id(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:RDB_PROTO.RTDBKEY_STRUCT)
 private:
  inline void set_has_table_column_id();
  inline void clear_has_table_column_id();
  inline void set_has_region_record_id();
  inline void clear_has_region_record_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int64 table_column_id_;
  ::google::protobuf::int64 region_record_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static RTDBKEY_STRUCT* default_instance_;
};
// -------------------------------------------------------------------

class APPRTDBKDY_STRUCT : public ::google::protobuf::Message {
 public:
  APPRTDBKDY_STRUCT();
  virtual ~APPRTDBKDY_STRUCT();

  APPRTDBKDY_STRUCT(const APPRTDBKDY_STRUCT& from);

  inline APPRTDBKDY_STRUCT& operator=(const APPRTDBKDY_STRUCT& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const APPRTDBKDY_STRUCT& default_instance();

  void Swap(APPRTDBKDY_STRUCT* other);

  // implements Message ----------------------------------------------

  APPRTDBKDY_STRUCT* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const APPRTDBKDY_STRUCT& from);
  void MergeFrom(const APPRTDBKDY_STRUCT& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 app_id = 1;
  inline bool has_app_id() const;
  inline void clear_app_id();
  static const int kAppIdFieldNumber = 1;
  inline ::google::protobuf::int32 app_id() const;
  inline void set_app_id(::google::protobuf::int32 value);

  // optional .RDB_PROTO.RTDBKEY_STRUCT key_id = 2;
  inline bool has_key_id() const;
  inline void clear_key_id();
  static const int kKeyIdFieldNumber = 2;
  inline const ::RDB_PROTO::RTDBKEY_STRUCT& key_id() const;
  inline ::RDB_PROTO::RTDBKEY_STRUCT* mutable_key_id();
  inline ::RDB_PROTO::RTDBKEY_STRUCT* release_key_id();
  inline void set_allocated_key_id(::RDB_PROTO::RTDBKEY_STRUCT* key_id);

  // @@protoc_insertion_point(class_scope:RDB_PROTO.APPRTDBKDY_STRUCT)
 private:
  inline void set_has_app_id();
  inline void clear_has_app_id();
  inline void set_has_key_id();
  inline void clear_has_key_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::RDB_PROTO::RTDBKEY_STRUCT* key_id_;
  ::google::protobuf::int32 app_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static APPRTDBKDY_STRUCT* default_instance_;
};
// -------------------------------------------------------------------

class UNION_DATA_VALUE : public ::google::protobuf::Message {
 public:
  UNION_DATA_VALUE();
  virtual ~UNION_DATA_VALUE();

  UNION_DATA_VALUE(const UNION_DATA_VALUE& from);

  inline UNION_DATA_VALUE& operator=(const UNION_DATA_VALUE& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const UNION_DATA_VALUE& default_instance();

  void Swap(UNION_DATA_VALUE* other);

  // implements Message ----------------------------------------------

  UNION_DATA_VALUE* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UNION_DATA_VALUE& from);
  void MergeFrom(const UNION_DATA_VALUE& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 type = 1;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 1;
  inline ::google::protobuf::int32 type() const;
  inline void set_type(::google::protobuf::int32 value);

  // optional bytes c_string = 2;
  inline bool has_c_string() const;
  inline void clear_c_string();
  static const int kCStringFieldNumber = 2;
  inline const ::std::string& c_string() const;
  inline void set_c_string(const ::std::string& value);
  inline void set_c_string(const char* value);
  inline void set_c_string(const void* value, size_t size);
  inline ::std::string* mutable_c_string();
  inline ::std::string* release_c_string();
  inline void set_allocated_c_string(::std::string* c_string);

  // optional uint32 c_uchar = 3;
  inline bool has_c_uchar() const;
  inline void clear_c_uchar();
  static const int kCUcharFieldNumber = 3;
  inline ::google::protobuf::uint32 c_uchar() const;
  inline void set_c_uchar(::google::protobuf::uint32 value);

  // optional int32 c_short = 4;
  inline bool has_c_short() const;
  inline void clear_c_short();
  static const int kCShortFieldNumber = 4;
  inline ::google::protobuf::int32 c_short() const;
  inline void set_c_short(::google::protobuf::int32 value);

  // optional int32 c_int = 5;
  inline bool has_c_int() const;
  inline void clear_c_int();
  static const int kCIntFieldNumber = 5;
  inline ::google::protobuf::int32 c_int() const;
  inline void set_c_int(::google::protobuf::int32 value);

  // optional int64 c_time = 6;
  inline bool has_c_time() const;
  inline void clear_c_time();
  static const int kCTimeFieldNumber = 6;
  inline ::google::protobuf::int64 c_time() const;
  inline void set_c_time(::google::protobuf::int64 value);

  // optional float c_float = 7;
  inline bool has_c_float() const;
  inline void clear_c_float();
  static const int kCFloatFieldNumber = 7;
  inline float c_float() const;
  inline void set_c_float(float value);

  // optional double c_double = 8;
  inline bool has_c_double() const;
  inline void clear_c_double();
  static const int kCDoubleFieldNumber = 8;
  inline double c_double() const;
  inline void set_c_double(double value);

  // optional int64 c_keyid = 9;
  inline bool has_c_keyid() const;
  inline void clear_c_keyid();
  static const int kCKeyidFieldNumber = 9;
  inline ::google::protobuf::int64 c_keyid() const;
  inline void set_c_keyid(::google::protobuf::int64 value);

  // optional .RDB_PROTO.SEQ_CHAR c_binary = 10;
  inline bool has_c_binary() const;
  inline void clear_c_binary();
  static const int kCBinaryFieldNumber = 10;
  inline const ::RDB_PROTO::SEQ_CHAR& c_binary() const;
  inline ::RDB_PROTO::SEQ_CHAR* mutable_c_binary();
  inline ::RDB_PROTO::SEQ_CHAR* release_c_binary();
  inline void set_allocated_c_binary(::RDB_PROTO::SEQ_CHAR* c_binary);

  // optional .RDB_PROTO.SEQ_CHAR c_text = 11;
  inline bool has_c_text() const;
  inline void clear_c_text();
  static const int kCTextFieldNumber = 11;
  inline const ::RDB_PROTO::SEQ_CHAR& c_text() const;
  inline ::RDB_PROTO::SEQ_CHAR* mutable_c_text();
  inline ::RDB_PROTO::SEQ_CHAR* release_c_text();
  inline void set_allocated_c_text(::RDB_PROTO::SEQ_CHAR* c_text);

  // optional .RDB_PROTO.SEQ_CHAR c_image = 12;
  inline bool has_c_image() const;
  inline void clear_c_image();
  static const int kCImageFieldNumber = 12;
  inline const ::RDB_PROTO::SEQ_CHAR& c_image() const;
  inline ::RDB_PROTO::SEQ_CHAR* mutable_c_image();
  inline ::RDB_PROTO::SEQ_CHAR* release_c_image();
  inline void set_allocated_c_image(::RDB_PROTO::SEQ_CHAR* c_image);

  // optional .RDB_PROTO.APPKEYID_STRUCT c_appkeyid = 13;
  inline bool has_c_appkeyid() const;
  inline void clear_c_appkeyid();
  static const int kCAppkeyidFieldNumber = 13;
  inline const ::RDB_PROTO::APPKEYID_STRUCT& c_appkeyid() const;
  inline ::RDB_PROTO::APPKEYID_STRUCT* mutable_c_appkeyid();
  inline ::RDB_PROTO::APPKEYID_STRUCT* release_c_appkeyid();
  inline void set_allocated_c_appkeyid(::RDB_PROTO::APPKEYID_STRUCT* c_appkeyid);

  // optional .RDB_PROTO.APPID_STRUCT c_appid = 14;
  inline bool has_c_appid() const;
  inline void clear_c_appid();
  static const int kCAppidFieldNumber = 14;
  inline const ::RDB_PROTO::APPID_STRUCT& c_appid() const;
  inline ::RDB_PROTO::APPID_STRUCT* mutable_c_appid();
  inline ::RDB_PROTO::APPID_STRUCT* release_c_appid();
  inline void set_allocated_c_appid(::RDB_PROTO::APPID_STRUCT* c_appid);

  // optional bytes c_default = 15;
  inline bool has_c_default() const;
  inline void clear_c_default();
  static const int kCDefaultFieldNumber = 15;
  inline const ::std::string& c_default() const;
  inline void set_c_default(const ::std::string& value);
  inline void set_c_default(const char* value);
  inline void set_c_default(const void* value, size_t size);
  inline ::std::string* mutable_c_default();
  inline ::std::string* release_c_default();
  inline void set_allocated_c_default(::std::string* c_default);

  // optional uint32 c_uint = 16;
  inline bool has_c_uint() const;
  inline void clear_c_uint();
  static const int kCUintFieldNumber = 16;
  inline ::google::protobuf::uint32 c_uint() const;
  inline void set_c_uint(::google::protobuf::uint32 value);

  // optional int64 c_long = 17;
  inline bool has_c_long() const;
  inline void clear_c_long();
  static const int kCLongFieldNumber = 17;
  inline ::google::protobuf::int64 c_long() const;
  inline void set_c_long(::google::protobuf::int64 value);

  // optional .RDB_PROTO.RTDBKEY_STRUCT c_rtdbkeyid = 18;
  inline bool has_c_rtdbkeyid() const;
  inline void clear_c_rtdbkeyid();
  static const int kCRtdbkeyidFieldNumber = 18;
  inline const ::RDB_PROTO::RTDBKEY_STRUCT& c_rtdbkeyid() const;
  inline ::RDB_PROTO::RTDBKEY_STRUCT* mutable_c_rtdbkeyid();
  inline ::RDB_PROTO::RTDBKEY_STRUCT* release_c_rtdbkeyid();
  inline void set_allocated_c_rtdbkeyid(::RDB_PROTO::RTDBKEY_STRUCT* c_rtdbkeyid);

  // optional .RDB_PROTO.RTDBKEY_STRUCT c_measrtdbkeyid = 19;
  inline bool has_c_measrtdbkeyid() const;
  inline void clear_c_measrtdbkeyid();
  static const int kCMeasrtdbkeyidFieldNumber = 19;
  inline const ::RDB_PROTO::RTDBKEY_STRUCT& c_measrtdbkeyid() const;
  inline ::RDB_PROTO::RTDBKEY_STRUCT* mutable_c_measrtdbkeyid();
  inline ::RDB_PROTO::RTDBKEY_STRUCT* release_c_measrtdbkeyid();
  inline void set_allocated_c_measrtdbkeyid(::RDB_PROTO::RTDBKEY_STRUCT* c_measrtdbkeyid);

  // optional .RDB_PROTO.APPRTDBKDY_STRUCT c_apprtdbkey = 20;
  inline bool has_c_apprtdbkey() const;
  inline void clear_c_apprtdbkey();
  static const int kCApprtdbkeyFieldNumber = 20;
  inline const ::RDB_PROTO::APPRTDBKDY_STRUCT& c_apprtdbkey() const;
  inline ::RDB_PROTO::APPRTDBKDY_STRUCT* mutable_c_apprtdbkey();
  inline ::RDB_PROTO::APPRTDBKDY_STRUCT* release_c_apprtdbkey();
  inline void set_allocated_c_apprtdbkey(::RDB_PROTO::APPRTDBKDY_STRUCT* c_apprtdbkey);

  // @@protoc_insertion_point(class_scope:RDB_PROTO.UNION_DATA_VALUE)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_c_string();
  inline void clear_has_c_string();
  inline void set_has_c_uchar();
  inline void clear_has_c_uchar();
  inline void set_has_c_short();
  inline void clear_has_c_short();
  inline void set_has_c_int();
  inline void clear_has_c_int();
  inline void set_has_c_time();
  inline void clear_has_c_time();
  inline void set_has_c_float();
  inline void clear_has_c_float();
  inline void set_has_c_double();
  inline void clear_has_c_double();
  inline void set_has_c_keyid();
  inline void clear_has_c_keyid();
  inline void set_has_c_binary();
  inline void clear_has_c_binary();
  inline void set_has_c_text();
  inline void clear_has_c_text();
  inline void set_has_c_image();
  inline void clear_has_c_image();
  inline void set_has_c_appkeyid();
  inline void clear_has_c_appkeyid();
  inline void set_has_c_appid();
  inline void clear_has_c_appid();
  inline void set_has_c_default();
  inline void clear_has_c_default();
  inline void set_has_c_uint();
  inline void clear_has_c_uint();
  inline void set_has_c_long();
  inline void clear_has_c_long();
  inline void set_has_c_rtdbkeyid();
  inline void clear_has_c_rtdbkeyid();
  inline void set_has_c_measrtdbkeyid();
  inline void clear_has_c_measrtdbkeyid();
  inline void set_has_c_apprtdbkey();
  inline void clear_has_c_apprtdbkey();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* c_string_;
  ::google::protobuf::int32 type_;
  ::google::protobuf::uint32 c_uchar_;
  ::google::protobuf::int32 c_short_;
  ::google::protobuf::int32 c_int_;
  ::google::protobuf::int64 c_time_;
  double c_double_;
  ::google::protobuf::int64 c_keyid_;
  ::RDB_PROTO::SEQ_CHAR* c_binary_;
  ::RDB_PROTO::SEQ_CHAR* c_text_;
  float c_float_;
  ::google::protobuf::uint32 c_uint_;
  ::RDB_PROTO::SEQ_CHAR* c_image_;
  ::RDB_PROTO::APPKEYID_STRUCT* c_appkeyid_;
  ::RDB_PROTO::APPID_STRUCT* c_appid_;
  ::std::string* c_default_;
  ::google::protobuf::int64 c_long_;
  ::RDB_PROTO::RTDBKEY_STRUCT* c_rtdbkeyid_;
  ::RDB_PROTO::RTDBKEY_STRUCT* c_measrtdbkeyid_;
  ::RDB_PROTO::APPRTDBKDY_STRUCT* c_apprtdbkey_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(20 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static UNION_DATA_VALUE* default_instance_;
};
// -------------------------------------------------------------------

class SEQ_DATA_VALUE : public ::google::protobuf::Message {
 public:
  SEQ_DATA_VALUE();
  virtual ~SEQ_DATA_VALUE();

  SEQ_DATA_VALUE(const SEQ_DATA_VALUE& from);

  inline SEQ_DATA_VALUE& operator=(const SEQ_DATA_VALUE& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SEQ_DATA_VALUE& default_instance();

  void Swap(SEQ_DATA_VALUE* other);

  // implements Message ----------------------------------------------

  SEQ_DATA_VALUE* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SEQ_DATA_VALUE& from);
  void MergeFrom(const SEQ_DATA_VALUE& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .RDB_PROTO.UNION_DATA_VALUE vec_data = 1;
  inline int vec_data_size() const;
  inline void clear_vec_data();
  static const int kVecDataFieldNumber = 1;
  inline const ::RDB_PROTO::UNION_DATA_VALUE& vec_data(int index) const;
  inline ::RDB_PROTO::UNION_DATA_VALUE* mutable_vec_data(int index);
  inline ::RDB_PROTO::UNION_DATA_VALUE* add_vec_data();
  inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::UNION_DATA_VALUE >&
      vec_data() const;
  inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::UNION_DATA_VALUE >*
      mutable_vec_data();

  // @@protoc_insertion_point(class_scope:RDB_PROTO.SEQ_DATA_VALUE)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::UNION_DATA_VALUE > vec_data_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static SEQ_DATA_VALUE* default_instance_;
};
// -------------------------------------------------------------------

class DBERROR_STRUCT : public ::google::protobuf::Message {
 public:
  DBERROR_STRUCT();
  virtual ~DBERROR_STRUCT();

  DBERROR_STRUCT(const DBERROR_STRUCT& from);

  inline DBERROR_STRUCT& operator=(const DBERROR_STRUCT& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DBERROR_STRUCT& default_instance();

  void Swap(DBERROR_STRUCT* other);

  // implements Message ----------------------------------------------

  DBERROR_STRUCT* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DBERROR_STRUCT& from);
  void MergeFrom(const DBERROR_STRUCT& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint32 error_no = 1;
  inline bool has_error_no() const;
  inline void clear_error_no();
  static const int kErrorNoFieldNumber = 1;
  inline ::google::protobuf::uint32 error_no() const;
  inline void set_error_no(::google::protobuf::uint32 value);

  // optional bytes error_msg = 2;
  inline bool has_error_msg() const;
  inline void clear_error_msg();
  static const int kErrorMsgFieldNumber = 2;
  inline const ::std::string& error_msg() const;
  inline void set_error_msg(const ::std::string& value);
  inline void set_error_msg(const char* value);
  inline void set_error_msg(const void* value, size_t size);
  inline ::std::string* mutable_error_msg();
  inline ::std::string* release_error_msg();
  inline void set_allocated_error_msg(::std::string* error_msg);

  // @@protoc_insertion_point(class_scope:RDB_PROTO.DBERROR_STRUCT)
 private:
  inline void set_has_error_no();
  inline void clear_has_error_no();
  inline void set_has_error_msg();
  inline void clear_has_error_msg();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* error_msg_;
  ::google::protobuf::uint32 error_no_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static DBERROR_STRUCT* default_instance_;
};
// -------------------------------------------------------------------

class SEQ_DBERROR : public ::google::protobuf::Message {
 public:
  SEQ_DBERROR();
  virtual ~SEQ_DBERROR();

  SEQ_DBERROR(const SEQ_DBERROR& from);

  inline SEQ_DBERROR& operator=(const SEQ_DBERROR& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SEQ_DBERROR& default_instance();

  void Swap(SEQ_DBERROR* other);

  // implements Message ----------------------------------------------

  SEQ_DBERROR* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SEQ_DBERROR& from);
  void MergeFrom(const SEQ_DBERROR& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .RDB_PROTO.DBERROR_STRUCT vec_error = 1;
  inline int vec_error_size() const;
  inline void clear_vec_error();
  static const int kVecErrorFieldNumber = 1;
  inline const ::RDB_PROTO::DBERROR_STRUCT& vec_error(int index) const;
  inline ::RDB_PROTO::DBERROR_STRUCT* mutable_vec_error(int index);
  inline ::RDB_PROTO::DBERROR_STRUCT* add_vec_error();
  inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::DBERROR_STRUCT >&
      vec_error() const;
  inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::DBERROR_STRUCT >*
      mutable_vec_error();

  // @@protoc_insertion_point(class_scope:RDB_PROTO.SEQ_DBERROR)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::DBERROR_STRUCT > vec_error_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static SEQ_DBERROR* default_instance_;
};
// -------------------------------------------------------------------

class RESULT_DATA_VALUE : public ::google::protobuf::Message {
 public:
  RESULT_DATA_VALUE();
  virtual ~RESULT_DATA_VALUE();

  RESULT_DATA_VALUE(const RESULT_DATA_VALUE& from);

  inline RESULT_DATA_VALUE& operator=(const RESULT_DATA_VALUE& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RESULT_DATA_VALUE& default_instance();

  void Swap(RESULT_DATA_VALUE* other);

  // implements Message ----------------------------------------------

  RESULT_DATA_VALUE* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RESULT_DATA_VALUE& from);
  void MergeFrom(const RESULT_DATA_VALUE& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required bool is_null = 1;
  inline bool has_is_null() const;
  inline void clear_is_null();
  static const int kIsNullFieldNumber = 1;
  inline bool is_null() const;
  inline void set_is_null(bool value);

  // required .RDB_PROTO.UNION_DATA_VALUE data_value = 2;
  inline bool has_data_value() const;
  inline void clear_data_value();
  static const int kDataValueFieldNumber = 2;
  inline const ::RDB_PROTO::UNION_DATA_VALUE& data_value() const;
  inline ::RDB_PROTO::UNION_DATA_VALUE* mutable_data_value();
  inline ::RDB_PROTO::UNION_DATA_VALUE* release_data_value();
  inline void set_allocated_data_value(::RDB_PROTO::UNION_DATA_VALUE* data_value);

  // @@protoc_insertion_point(class_scope:RDB_PROTO.RESULT_DATA_VALUE)
 private:
  inline void set_has_is_null();
  inline void clear_has_is_null();
  inline void set_has_data_value();
  inline void clear_has_data_value();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::RDB_PROTO::UNION_DATA_VALUE* data_value_;
  bool is_null_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static RESULT_DATA_VALUE* default_instance_;
};
// -------------------------------------------------------------------

class SEQ_RESULT_DATA_VALUE : public ::google::protobuf::Message {
 public:
  SEQ_RESULT_DATA_VALUE();
  virtual ~SEQ_RESULT_DATA_VALUE();

  SEQ_RESULT_DATA_VALUE(const SEQ_RESULT_DATA_VALUE& from);

  inline SEQ_RESULT_DATA_VALUE& operator=(const SEQ_RESULT_DATA_VALUE& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SEQ_RESULT_DATA_VALUE& default_instance();

  void Swap(SEQ_RESULT_DATA_VALUE* other);

  // implements Message ----------------------------------------------

  SEQ_RESULT_DATA_VALUE* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SEQ_RESULT_DATA_VALUE& from);
  void MergeFrom(const SEQ_RESULT_DATA_VALUE& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .RDB_PROTO.RESULT_DATA_VALUE vec_result_data_value = 1;
  inline int vec_result_data_value_size() const;
  inline void clear_vec_result_data_value();
  static const int kVecResultDataValueFieldNumber = 1;
  inline const ::RDB_PROTO::RESULT_DATA_VALUE& vec_result_data_value(int index) const;
  inline ::RDB_PROTO::RESULT_DATA_VALUE* mutable_vec_result_data_value(int index);
  inline ::RDB_PROTO::RESULT_DATA_VALUE* add_vec_result_data_value();
  inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::RESULT_DATA_VALUE >&
      vec_result_data_value() const;
  inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::RESULT_DATA_VALUE >*
      mutable_vec_result_data_value();

  // @@protoc_insertion_point(class_scope:RDB_PROTO.SEQ_RESULT_DATA_VALUE)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::RESULT_DATA_VALUE > vec_result_data_value_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static SEQ_RESULT_DATA_VALUE* default_instance_;
};
// -------------------------------------------------------------------

class RESULT_FIELD_INFO : public ::google::protobuf::Message {
 public:
  RESULT_FIELD_INFO();
  virtual ~RESULT_FIELD_INFO();

  RESULT_FIELD_INFO(const RESULT_FIELD_INFO& from);

  inline RESULT_FIELD_INFO& operator=(const RESULT_FIELD_INFO& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const RESULT_FIELD_INFO& default_instance();

  void Swap(RESULT_FIELD_INFO* other);

  // implements Message ----------------------------------------------

  RESULT_FIELD_INFO* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RESULT_FIELD_INFO& from);
  void MergeFrom(const RESULT_FIELD_INFO& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required int32 data_type = 1;
  inline bool has_data_type() const;
  inline void clear_data_type();
  static const int kDataTypeFieldNumber = 1;
  inline ::google::protobuf::int32 data_type() const;
  inline void set_data_type(::google::protobuf::int32 value);

  // required int32 data_len = 2;
  inline bool has_data_len() const;
  inline void clear_data_len();
  static const int kDataLenFieldNumber = 2;
  inline ::google::protobuf::int32 data_len() const;
  inline void set_data_len(::google::protobuf::int32 value);

  // required bytes col_name = 3;
  inline bool has_col_name() const;
  inline void clear_col_name();
  static const int kColNameFieldNumber = 3;
  inline const ::std::string& col_name() const;
  inline void set_col_name(const ::std::string& value);
  inline void set_col_name(const char* value);
  inline void set_col_name(const void* value, size_t size);
  inline ::std::string* mutable_col_name();
  inline ::std::string* release_col_name();
  inline void set_allocated_col_name(::std::string* col_name);

  // @@protoc_insertion_point(class_scope:RDB_PROTO.RESULT_FIELD_INFO)
 private:
  inline void set_has_data_type();
  inline void clear_has_data_type();
  inline void set_has_data_len();
  inline void clear_has_data_len();
  inline void set_has_col_name();
  inline void clear_has_col_name();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 data_type_;
  ::google::protobuf::int32 data_len_;
  ::std::string* col_name_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static RESULT_FIELD_INFO* default_instance_;
};
// -------------------------------------------------------------------

class SEQ_RESULT_FIELD_INFO : public ::google::protobuf::Message {
 public:
  SEQ_RESULT_FIELD_INFO();
  virtual ~SEQ_RESULT_FIELD_INFO();

  SEQ_RESULT_FIELD_INFO(const SEQ_RESULT_FIELD_INFO& from);

  inline SEQ_RESULT_FIELD_INFO& operator=(const SEQ_RESULT_FIELD_INFO& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SEQ_RESULT_FIELD_INFO& default_instance();

  void Swap(SEQ_RESULT_FIELD_INFO* other);

  // implements Message ----------------------------------------------

  SEQ_RESULT_FIELD_INFO* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SEQ_RESULT_FIELD_INFO& from);
  void MergeFrom(const SEQ_RESULT_FIELD_INFO& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .RDB_PROTO.RESULT_FIELD_INFO vec_result_field_info = 1;
  inline int vec_result_field_info_size() const;
  inline void clear_vec_result_field_info();
  static const int kVecResultFieldInfoFieldNumber = 1;
  inline const ::RDB_PROTO::RESULT_FIELD_INFO& vec_result_field_info(int index) const;
  inline ::RDB_PROTO::RESULT_FIELD_INFO* mutable_vec_result_field_info(int index);
  inline ::RDB_PROTO::RESULT_FIELD_INFO* add_vec_result_field_info();
  inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::RESULT_FIELD_INFO >&
      vec_result_field_info() const;
  inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::RESULT_FIELD_INFO >*
      mutable_vec_result_field_info();

  // @@protoc_insertion_point(class_scope:RDB_PROTO.SEQ_RESULT_FIELD_INFO)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::RESULT_FIELD_INFO > vec_result_field_info_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static SEQ_RESULT_FIELD_INFO* default_instance_;
};
// -------------------------------------------------------------------

class OUT_DATA_TYPE : public ::google::protobuf::Message {
 public:
  OUT_DATA_TYPE();
  virtual ~OUT_DATA_TYPE();

  OUT_DATA_TYPE(const OUT_DATA_TYPE& from);

  inline OUT_DATA_TYPE& operator=(const OUT_DATA_TYPE& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const OUT_DATA_TYPE& default_instance();

  void Swap(OUT_DATA_TYPE* other);

  // implements Message ----------------------------------------------

  OUT_DATA_TYPE* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const OUT_DATA_TYPE& from);
  void MergeFrom(const OUT_DATA_TYPE& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required int32 out_field_position = 1;
  inline bool has_out_field_position() const;
  inline void clear_out_field_position();
  static const int kOutFieldPositionFieldNumber = 1;
  inline ::google::protobuf::int32 out_field_position() const;
  inline void set_out_field_position(::google::protobuf::int32 value);

  // required int32 out_field_datatype = 2;
  inline bool has_out_field_datatype() const;
  inline void clear_out_field_datatype();
  static const int kOutFieldDatatypeFieldNumber = 2;
  inline ::google::protobuf::int32 out_field_datatype() const;
  inline void set_out_field_datatype(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:RDB_PROTO.OUT_DATA_TYPE)
 private:
  inline void set_has_out_field_position();
  inline void clear_has_out_field_position();
  inline void set_has_out_field_datatype();
  inline void clear_has_out_field_datatype();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::int32 out_field_position_;
  ::google::protobuf::int32 out_field_datatype_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static OUT_DATA_TYPE* default_instance_;
};
// -------------------------------------------------------------------

class SEQ_OUT_DATA_TYPE : public ::google::protobuf::Message {
 public:
  SEQ_OUT_DATA_TYPE();
  virtual ~SEQ_OUT_DATA_TYPE();

  SEQ_OUT_DATA_TYPE(const SEQ_OUT_DATA_TYPE& from);

  inline SEQ_OUT_DATA_TYPE& operator=(const SEQ_OUT_DATA_TYPE& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SEQ_OUT_DATA_TYPE& default_instance();

  void Swap(SEQ_OUT_DATA_TYPE* other);

  // implements Message ----------------------------------------------

  SEQ_OUT_DATA_TYPE* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SEQ_OUT_DATA_TYPE& from);
  void MergeFrom(const SEQ_OUT_DATA_TYPE& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .RDB_PROTO.OUT_DATA_TYPE vec_out_data_type = 1;
  inline int vec_out_data_type_size() const;
  inline void clear_vec_out_data_type();
  static const int kVecOutDataTypeFieldNumber = 1;
  inline const ::RDB_PROTO::OUT_DATA_TYPE& vec_out_data_type(int index) const;
  inline ::RDB_PROTO::OUT_DATA_TYPE* mutable_vec_out_data_type(int index);
  inline ::RDB_PROTO::OUT_DATA_TYPE* add_vec_out_data_type();
  inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::OUT_DATA_TYPE >&
      vec_out_data_type() const;
  inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::OUT_DATA_TYPE >*
      mutable_vec_out_data_type();

  // @@protoc_insertion_point(class_scope:RDB_PROTO.SEQ_OUT_DATA_TYPE)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::OUT_DATA_TYPE > vec_out_data_type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static SEQ_OUT_DATA_TYPE* default_instance_;
};
// -------------------------------------------------------------------

class SELECT_RESULT : public ::google::protobuf::Message {
 public:
  SELECT_RESULT();
  virtual ~SELECT_RESULT();

  SELECT_RESULT(const SELECT_RESULT& from);

  inline SELECT_RESULT& operator=(const SELECT_RESULT& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SELECT_RESULT& default_instance();

  void Swap(SELECT_RESULT* other);

  // implements Message ----------------------------------------------

  SELECT_RESULT* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SELECT_RESULT& from);
  void MergeFrom(const SELECT_RESULT& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required int32 field_num = 1;
  inline bool has_field_num() const;
  inline void clear_field_num();
  static const int kFieldNumFieldNumber = 1;
  inline ::google::protobuf::int32 field_num() const;
  inline void set_field_num(::google::protobuf::int32 value);

  // required .RDB_PROTO.SEQ_RESULT_FIELD_INFO field_info = 2;
  inline bool has_field_info() const;
  inline void clear_field_info();
  static const int kFieldInfoFieldNumber = 2;
  inline const ::RDB_PROTO::SEQ_RESULT_FIELD_INFO& field_info() const;
  inline ::RDB_PROTO::SEQ_RESULT_FIELD_INFO* mutable_field_info();
  inline ::RDB_PROTO::SEQ_RESULT_FIELD_INFO* release_field_info();
  inline void set_allocated_field_info(::RDB_PROTO::SEQ_RESULT_FIELD_INFO* field_info);

  // required uint32 data_num = 3;
  inline bool has_data_num() const;
  inline void clear_data_num();
  static const int kDataNumFieldNumber = 3;
  inline ::google::protobuf::uint32 data_num() const;
  inline void set_data_num(::google::protobuf::uint32 value);

  // required .RDB_PROTO.SEQ_RESULT_DATA_VALUE data_value_seq = 4;
  inline bool has_data_value_seq() const;
  inline void clear_data_value_seq();
  static const int kDataValueSeqFieldNumber = 4;
  inline const ::RDB_PROTO::SEQ_RESULT_DATA_VALUE& data_value_seq() const;
  inline ::RDB_PROTO::SEQ_RESULT_DATA_VALUE* mutable_data_value_seq();
  inline ::RDB_PROTO::SEQ_RESULT_DATA_VALUE* release_data_value_seq();
  inline void set_allocated_data_value_seq(::RDB_PROTO::SEQ_RESULT_DATA_VALUE* data_value_seq);

  // @@protoc_insertion_point(class_scope:RDB_PROTO.SELECT_RESULT)
 private:
  inline void set_has_field_num();
  inline void clear_has_field_num();
  inline void set_has_field_info();
  inline void clear_has_field_info();
  inline void set_has_data_num();
  inline void clear_has_data_num();
  inline void set_has_data_value_seq();
  inline void clear_has_data_value_seq();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::RDB_PROTO::SEQ_RESULT_FIELD_INFO* field_info_;
  ::google::protobuf::int32 field_num_;
  ::google::protobuf::uint32 data_num_;
  ::RDB_PROTO::SEQ_RESULT_DATA_VALUE* data_value_seq_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static SELECT_RESULT* default_instance_;
};
// -------------------------------------------------------------------

class EXEC_MULTI_RESULT : public ::google::protobuf::Message {
 public:
  EXEC_MULTI_RESULT();
  virtual ~EXEC_MULTI_RESULT();

  EXEC_MULTI_RESULT(const EXEC_MULTI_RESULT& from);

  inline EXEC_MULTI_RESULT& operator=(const EXEC_MULTI_RESULT& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const EXEC_MULTI_RESULT& default_instance();

  void Swap(EXEC_MULTI_RESULT* other);

  // implements Message ----------------------------------------------

  EXEC_MULTI_RESULT* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const EXEC_MULTI_RESULT& from);
  void MergeFrom(const EXEC_MULTI_RESULT& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required bool is_success = 1;
  inline bool has_is_success() const;
  inline void clear_is_success();
  static const int kIsSuccessFieldNumber = 1;
  inline bool is_success() const;
  inline void set_is_success(bool value);

  // required .RDB_PROTO.DBERROR_STRUCT db_error = 2;
  inline bool has_db_error() const;
  inline void clear_db_error();
  static const int kDbErrorFieldNumber = 2;
  inline const ::RDB_PROTO::DBERROR_STRUCT& db_error() const;
  inline ::RDB_PROTO::DBERROR_STRUCT* mutable_db_error();
  inline ::RDB_PROTO::DBERROR_STRUCT* release_db_error();
  inline void set_allocated_db_error(::RDB_PROTO::DBERROR_STRUCT* db_error);

  // @@protoc_insertion_point(class_scope:RDB_PROTO.EXEC_MULTI_RESULT)
 private:
  inline void set_has_is_success();
  inline void clear_has_is_success();
  inline void set_has_db_error();
  inline void clear_has_db_error();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::RDB_PROTO::DBERROR_STRUCT* db_error_;
  bool is_success_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static EXEC_MULTI_RESULT* default_instance_;
};
// -------------------------------------------------------------------

class SEQ_EXEC_MULTI_RESULT : public ::google::protobuf::Message {
 public:
  SEQ_EXEC_MULTI_RESULT();
  virtual ~SEQ_EXEC_MULTI_RESULT();

  SEQ_EXEC_MULTI_RESULT(const SEQ_EXEC_MULTI_RESULT& from);

  inline SEQ_EXEC_MULTI_RESULT& operator=(const SEQ_EXEC_MULTI_RESULT& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SEQ_EXEC_MULTI_RESULT& default_instance();

  void Swap(SEQ_EXEC_MULTI_RESULT* other);

  // implements Message ----------------------------------------------

  SEQ_EXEC_MULTI_RESULT* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SEQ_EXEC_MULTI_RESULT& from);
  void MergeFrom(const SEQ_EXEC_MULTI_RESULT& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .RDB_PROTO.EXEC_MULTI_RESULT vec_exec_multi_result = 1;
  inline int vec_exec_multi_result_size() const;
  inline void clear_vec_exec_multi_result();
  static const int kVecExecMultiResultFieldNumber = 1;
  inline const ::RDB_PROTO::EXEC_MULTI_RESULT& vec_exec_multi_result(int index) const;
  inline ::RDB_PROTO::EXEC_MULTI_RESULT* mutable_vec_exec_multi_result(int index);
  inline ::RDB_PROTO::EXEC_MULTI_RESULT* add_vec_exec_multi_result();
  inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::EXEC_MULTI_RESULT >&
      vec_exec_multi_result() const;
  inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::EXEC_MULTI_RESULT >*
      mutable_vec_exec_multi_result();

  // @@protoc_insertion_point(class_scope:RDB_PROTO.SEQ_EXEC_MULTI_RESULT)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::EXEC_MULTI_RESULT > vec_exec_multi_result_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static SEQ_EXEC_MULTI_RESULT* default_instance_;
};
// -------------------------------------------------------------------

class BIND_PARA : public ::google::protobuf::Message {
 public:
  BIND_PARA();
  virtual ~BIND_PARA();

  BIND_PARA(const BIND_PARA& from);

  inline BIND_PARA& operator=(const BIND_PARA& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const BIND_PARA& default_instance();

  void Swap(BIND_PARA* other);

  // implements Message ----------------------------------------------

  BIND_PARA* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BIND_PARA& from);
  void MergeFrom(const BIND_PARA& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required uint32 dci_type = 1;
  inline bool has_dci_type() const;
  inline void clear_dci_type();
  static const int kDciTypeFieldNumber = 1;
  inline ::google::protobuf::uint32 dci_type() const;
  inline void set_dci_type(::google::protobuf::uint32 value);

  // required int32 data_size = 2;
  inline bool has_data_size() const;
  inline void clear_data_size();
  static const int kDataSizeFieldNumber = 2;
  inline ::google::protobuf::int32 data_size() const;
  inline void set_data_size(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:RDB_PROTO.BIND_PARA)
 private:
  inline void set_has_dci_type();
  inline void clear_has_dci_type();
  inline void set_has_data_size();
  inline void clear_has_data_size();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 dci_type_;
  ::google::protobuf::int32 data_size_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static BIND_PARA* default_instance_;
};
// -------------------------------------------------------------------

class SEQ_BIND_PARA : public ::google::protobuf::Message {
 public:
  SEQ_BIND_PARA();
  virtual ~SEQ_BIND_PARA();

  SEQ_BIND_PARA(const SEQ_BIND_PARA& from);

  inline SEQ_BIND_PARA& operator=(const SEQ_BIND_PARA& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const SEQ_BIND_PARA& default_instance();

  void Swap(SEQ_BIND_PARA* other);

  // implements Message ----------------------------------------------

  SEQ_BIND_PARA* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SEQ_BIND_PARA& from);
  void MergeFrom(const SEQ_BIND_PARA& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .RDB_PROTO.BIND_PARA vec_bind_para = 1;
  inline int vec_bind_para_size() const;
  inline void clear_vec_bind_para();
  static const int kVecBindParaFieldNumber = 1;
  inline const ::RDB_PROTO::BIND_PARA& vec_bind_para(int index) const;
  inline ::RDB_PROTO::BIND_PARA* mutable_vec_bind_para(int index);
  inline ::RDB_PROTO::BIND_PARA* add_vec_bind_para();
  inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::BIND_PARA >&
      vec_bind_para() const;
  inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::BIND_PARA >*
      mutable_vec_bind_para();

  // @@protoc_insertion_point(class_scope:RDB_PROTO.SEQ_BIND_PARA)
 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::BIND_PARA > vec_bind_para_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void  protobuf_AddDesc_rdb_5fdefine_2eproto();
  friend void protobuf_AssignDesc_rdb_5fdefine_2eproto();
  friend void protobuf_ShutdownFile_rdb_5fdefine_2eproto();

  void InitAsDefaultInstance();
  static SEQ_BIND_PARA* default_instance_;
};
// ===================================================================


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

// SEQ_STRING

// repeated bytes vec_string = 1;
inline int SEQ_STRING::vec_string_size() const {
  return vec_string_.size();
}
inline void SEQ_STRING::clear_vec_string() {
  vec_string_.Clear();
}
inline const ::std::string& SEQ_STRING::vec_string(int index) const {
  return vec_string_.Get(index);
}
inline ::std::string* SEQ_STRING::mutable_vec_string(int index) {
  return vec_string_.Mutable(index);
}
inline void SEQ_STRING::set_vec_string(int index, const ::std::string& value) {
  vec_string_.Mutable(index)->assign(value);
}
inline void SEQ_STRING::set_vec_string(int index, const char* value) {
  vec_string_.Mutable(index)->assign(value);
}
inline void SEQ_STRING::set_vec_string(int index, const void* value, size_t size) {
  vec_string_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SEQ_STRING::add_vec_string() {
  return vec_string_.Add();
}
inline void SEQ_STRING::add_vec_string(const ::std::string& value) {
  vec_string_.Add()->assign(value);
}
inline void SEQ_STRING::add_vec_string(const char* value) {
  vec_string_.Add()->assign(value);
}
inline void SEQ_STRING::add_vec_string(const void* value, size_t size) {
  vec_string_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
SEQ_STRING::vec_string() const {
  return vec_string_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
SEQ_STRING::mutable_vec_string() {
  return &vec_string_;
}

// -------------------------------------------------------------------

// SEQ_CHAR

// optional bytes vec_char = 1;
inline bool SEQ_CHAR::has_vec_char() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SEQ_CHAR::set_has_vec_char() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SEQ_CHAR::clear_has_vec_char() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SEQ_CHAR::clear_vec_char() {
  if (vec_char_ != &::google::protobuf::internal::kEmptyString) {
    vec_char_->clear();
  }
  clear_has_vec_char();
}
inline const ::std::string& SEQ_CHAR::vec_char() const {
  return *vec_char_;
}
inline void SEQ_CHAR::set_vec_char(const ::std::string& value) {
  set_has_vec_char();
  if (vec_char_ == &::google::protobuf::internal::kEmptyString) {
    vec_char_ = new ::std::string;
  }
  vec_char_->assign(value);
}
inline void SEQ_CHAR::set_vec_char(const char* value) {
  set_has_vec_char();
  if (vec_char_ == &::google::protobuf::internal::kEmptyString) {
    vec_char_ = new ::std::string;
  }
  vec_char_->assign(value);
}
inline void SEQ_CHAR::set_vec_char(const void* value, size_t size) {
  set_has_vec_char();
  if (vec_char_ == &::google::protobuf::internal::kEmptyString) {
    vec_char_ = new ::std::string;
  }
  vec_char_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SEQ_CHAR::mutable_vec_char() {
  set_has_vec_char();
  if (vec_char_ == &::google::protobuf::internal::kEmptyString) {
    vec_char_ = new ::std::string;
  }
  return vec_char_;
}
inline ::std::string* SEQ_CHAR::release_vec_char() {
  clear_has_vec_char();
  if (vec_char_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = vec_char_;
    vec_char_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void SEQ_CHAR::set_allocated_vec_char(::std::string* vec_char) {
  if (vec_char_ != &::google::protobuf::internal::kEmptyString) {
    delete vec_char_;
  }
  if (vec_char) {
    set_has_vec_char();
    vec_char_ = vec_char;
  } else {
    clear_has_vec_char();
    vec_char_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// SEQ_FLOAT

// repeated float vec_float = 1;
inline int SEQ_FLOAT::vec_float_size() const {
  return vec_float_.size();
}
inline void SEQ_FLOAT::clear_vec_float() {
  vec_float_.Clear();
}
inline float SEQ_FLOAT::vec_float(int index) const {
  return vec_float_.Get(index);
}
inline void SEQ_FLOAT::set_vec_float(int index, float value) {
  vec_float_.Set(index, value);
}
inline void SEQ_FLOAT::add_vec_float(float value) {
  vec_float_.Add(value);
}
inline const ::google::protobuf::RepeatedField< float >&
SEQ_FLOAT::vec_float() const {
  return vec_float_;
}
inline ::google::protobuf::RepeatedField< float >*
SEQ_FLOAT::mutable_vec_float() {
  return &vec_float_;
}

// -------------------------------------------------------------------

// SEQ_INT

// repeated int32 vec_int = 1;
inline int SEQ_INT::vec_int_size() const {
  return vec_int_.size();
}
inline void SEQ_INT::clear_vec_int() {
  vec_int_.Clear();
}
inline ::google::protobuf::int32 SEQ_INT::vec_int(int index) const {
  return vec_int_.Get(index);
}
inline void SEQ_INT::set_vec_int(int index, ::google::protobuf::int32 value) {
  vec_int_.Set(index, value);
}
inline void SEQ_INT::add_vec_int(::google::protobuf::int32 value) {
  vec_int_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
SEQ_INT::vec_int() const {
  return vec_int_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
SEQ_INT::mutable_vec_int() {
  return &vec_int_;
}

// -------------------------------------------------------------------

// SEQ_LONG

// repeated int64 vec_long = 1;
inline int SEQ_LONG::vec_long_size() const {
  return vec_long_.size();
}
inline void SEQ_LONG::clear_vec_long() {
  vec_long_.Clear();
}
inline ::google::protobuf::int64 SEQ_LONG::vec_long(int index) const {
  return vec_long_.Get(index);
}
inline void SEQ_LONG::set_vec_long(int index, ::google::protobuf::int64 value) {
  vec_long_.Set(index, value);
}
inline void SEQ_LONG::add_vec_long(::google::protobuf::int64 value) {
  vec_long_.Add(value);
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
SEQ_LONG::vec_long() const {
  return vec_long_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
SEQ_LONG::mutable_vec_long() {
  return &vec_long_;
}

// -------------------------------------------------------------------

// APPKEYID_STRUCT

// optional int32 app_id = 1;
inline bool APPKEYID_STRUCT::has_app_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void APPKEYID_STRUCT::set_has_app_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void APPKEYID_STRUCT::clear_has_app_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void APPKEYID_STRUCT::clear_app_id() {
  app_id_ = 0;
  clear_has_app_id();
}
inline ::google::protobuf::int32 APPKEYID_STRUCT::app_id() const {
  return app_id_;
}
inline void APPKEYID_STRUCT::set_app_id(::google::protobuf::int32 value) {
  set_has_app_id();
  app_id_ = value;
}

// optional int64 key_id = 2;
inline bool APPKEYID_STRUCT::has_key_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void APPKEYID_STRUCT::set_has_key_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void APPKEYID_STRUCT::clear_has_key_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void APPKEYID_STRUCT::clear_key_id() {
  key_id_ = GOOGLE_LONGLONG(0);
  clear_has_key_id();
}
inline ::google::protobuf::int64 APPKEYID_STRUCT::key_id() const {
  return key_id_;
}
inline void APPKEYID_STRUCT::set_key_id(::google::protobuf::int64 value) {
  set_has_key_id();
  key_id_ = value;
}

// -------------------------------------------------------------------

// APPID_STRUCT

// optional int32 app_id = 1;
inline bool APPID_STRUCT::has_app_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void APPID_STRUCT::set_has_app_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void APPID_STRUCT::clear_has_app_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void APPID_STRUCT::clear_app_id() {
  app_id_ = 0;
  clear_has_app_id();
}
inline ::google::protobuf::int32 APPID_STRUCT::app_id() const {
  return app_id_;
}
inline void APPID_STRUCT::set_app_id(::google::protobuf::int32 value) {
  set_has_app_id();
  app_id_ = value;
}

// optional int64 key_id = 2;
inline bool APPID_STRUCT::has_key_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void APPID_STRUCT::set_has_key_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void APPID_STRUCT::clear_has_key_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void APPID_STRUCT::clear_key_id() {
  key_id_ = GOOGLE_LONGLONG(0);
  clear_has_key_id();
}
inline ::google::protobuf::int64 APPID_STRUCT::key_id() const {
  return key_id_;
}
inline void APPID_STRUCT::set_key_id(::google::protobuf::int64 value) {
  set_has_key_id();
  key_id_ = value;
}

// -------------------------------------------------------------------

// RTDBKEY_STRUCT

// optional sint64 table_column_id = 1;
inline bool RTDBKEY_STRUCT::has_table_column_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RTDBKEY_STRUCT::set_has_table_column_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RTDBKEY_STRUCT::clear_has_table_column_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RTDBKEY_STRUCT::clear_table_column_id() {
  table_column_id_ = GOOGLE_LONGLONG(0);
  clear_has_table_column_id();
}
inline ::google::protobuf::int64 RTDBKEY_STRUCT::table_column_id() const {
  return table_column_id_;
}
inline void RTDBKEY_STRUCT::set_table_column_id(::google::protobuf::int64 value) {
  set_has_table_column_id();
  table_column_id_ = value;
}

// optional sint64 region_record_id = 2;
inline bool RTDBKEY_STRUCT::has_region_record_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RTDBKEY_STRUCT::set_has_region_record_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RTDBKEY_STRUCT::clear_has_region_record_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RTDBKEY_STRUCT::clear_region_record_id() {
  region_record_id_ = GOOGLE_LONGLONG(0);
  clear_has_region_record_id();
}
inline ::google::protobuf::int64 RTDBKEY_STRUCT::region_record_id() const {
  return region_record_id_;
}
inline void RTDBKEY_STRUCT::set_region_record_id(::google::protobuf::int64 value) {
  set_has_region_record_id();
  region_record_id_ = value;
}

// -------------------------------------------------------------------

// APPRTDBKDY_STRUCT

// optional int32 app_id = 1;
inline bool APPRTDBKDY_STRUCT::has_app_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void APPRTDBKDY_STRUCT::set_has_app_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void APPRTDBKDY_STRUCT::clear_has_app_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void APPRTDBKDY_STRUCT::clear_app_id() {
  app_id_ = 0;
  clear_has_app_id();
}
inline ::google::protobuf::int32 APPRTDBKDY_STRUCT::app_id() const {
  return app_id_;
}
inline void APPRTDBKDY_STRUCT::set_app_id(::google::protobuf::int32 value) {
  set_has_app_id();
  app_id_ = value;
}

// optional .RDB_PROTO.RTDBKEY_STRUCT key_id = 2;
inline bool APPRTDBKDY_STRUCT::has_key_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void APPRTDBKDY_STRUCT::set_has_key_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void APPRTDBKDY_STRUCT::clear_has_key_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void APPRTDBKDY_STRUCT::clear_key_id() {
  if (key_id_ != NULL) key_id_->::RDB_PROTO::RTDBKEY_STRUCT::Clear();
  clear_has_key_id();
}
inline const ::RDB_PROTO::RTDBKEY_STRUCT& APPRTDBKDY_STRUCT::key_id() const {
  return key_id_ != NULL ? *key_id_ : *default_instance_->key_id_;
}
inline ::RDB_PROTO::RTDBKEY_STRUCT* APPRTDBKDY_STRUCT::mutable_key_id() {
  set_has_key_id();
  if (key_id_ == NULL) key_id_ = new ::RDB_PROTO::RTDBKEY_STRUCT;
  return key_id_;
}
inline ::RDB_PROTO::RTDBKEY_STRUCT* APPRTDBKDY_STRUCT::release_key_id() {
  clear_has_key_id();
  ::RDB_PROTO::RTDBKEY_STRUCT* temp = key_id_;
  key_id_ = NULL;
  return temp;
}
inline void APPRTDBKDY_STRUCT::set_allocated_key_id(::RDB_PROTO::RTDBKEY_STRUCT* key_id) {
  delete key_id_;
  key_id_ = key_id;
  if (key_id) {
    set_has_key_id();
  } else {
    clear_has_key_id();
  }
}

// -------------------------------------------------------------------

// UNION_DATA_VALUE

// optional int32 type = 1;
inline bool UNION_DATA_VALUE::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void UNION_DATA_VALUE::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void UNION_DATA_VALUE::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void UNION_DATA_VALUE::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::google::protobuf::int32 UNION_DATA_VALUE::type() const {
  return type_;
}
inline void UNION_DATA_VALUE::set_type(::google::protobuf::int32 value) {
  set_has_type();
  type_ = value;
}

// optional bytes c_string = 2;
inline bool UNION_DATA_VALUE::has_c_string() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_string() {
  _has_bits_[0] |= 0x00000002u;
}
inline void UNION_DATA_VALUE::clear_has_c_string() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void UNION_DATA_VALUE::clear_c_string() {
  if (c_string_ != &::google::protobuf::internal::kEmptyString) {
    c_string_->clear();
  }
  clear_has_c_string();
}
inline const ::std::string& UNION_DATA_VALUE::c_string() const {
  return *c_string_;
}
inline void UNION_DATA_VALUE::set_c_string(const ::std::string& value) {
  set_has_c_string();
  if (c_string_ == &::google::protobuf::internal::kEmptyString) {
    c_string_ = new ::std::string;
  }
  c_string_->assign(value);
}
inline void UNION_DATA_VALUE::set_c_string(const char* value) {
  set_has_c_string();
  if (c_string_ == &::google::protobuf::internal::kEmptyString) {
    c_string_ = new ::std::string;
  }
  c_string_->assign(value);
}
inline void UNION_DATA_VALUE::set_c_string(const void* value, size_t size) {
  set_has_c_string();
  if (c_string_ == &::google::protobuf::internal::kEmptyString) {
    c_string_ = new ::std::string;
  }
  c_string_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UNION_DATA_VALUE::mutable_c_string() {
  set_has_c_string();
  if (c_string_ == &::google::protobuf::internal::kEmptyString) {
    c_string_ = new ::std::string;
  }
  return c_string_;
}
inline ::std::string* UNION_DATA_VALUE::release_c_string() {
  clear_has_c_string();
  if (c_string_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = c_string_;
    c_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void UNION_DATA_VALUE::set_allocated_c_string(::std::string* c_string) {
  if (c_string_ != &::google::protobuf::internal::kEmptyString) {
    delete c_string_;
  }
  if (c_string) {
    set_has_c_string();
    c_string_ = c_string;
  } else {
    clear_has_c_string();
    c_string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 c_uchar = 3;
inline bool UNION_DATA_VALUE::has_c_uchar() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_uchar() {
  _has_bits_[0] |= 0x00000004u;
}
inline void UNION_DATA_VALUE::clear_has_c_uchar() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void UNION_DATA_VALUE::clear_c_uchar() {
  c_uchar_ = 0u;
  clear_has_c_uchar();
}
inline ::google::protobuf::uint32 UNION_DATA_VALUE::c_uchar() const {
  return c_uchar_;
}
inline void UNION_DATA_VALUE::set_c_uchar(::google::protobuf::uint32 value) {
  set_has_c_uchar();
  c_uchar_ = value;
}

// optional int32 c_short = 4;
inline bool UNION_DATA_VALUE::has_c_short() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_short() {
  _has_bits_[0] |= 0x00000008u;
}
inline void UNION_DATA_VALUE::clear_has_c_short() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void UNION_DATA_VALUE::clear_c_short() {
  c_short_ = 0;
  clear_has_c_short();
}
inline ::google::protobuf::int32 UNION_DATA_VALUE::c_short() const {
  return c_short_;
}
inline void UNION_DATA_VALUE::set_c_short(::google::protobuf::int32 value) {
  set_has_c_short();
  c_short_ = value;
}

// optional int32 c_int = 5;
inline bool UNION_DATA_VALUE::has_c_int() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_int() {
  _has_bits_[0] |= 0x00000010u;
}
inline void UNION_DATA_VALUE::clear_has_c_int() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void UNION_DATA_VALUE::clear_c_int() {
  c_int_ = 0;
  clear_has_c_int();
}
inline ::google::protobuf::int32 UNION_DATA_VALUE::c_int() const {
  return c_int_;
}
inline void UNION_DATA_VALUE::set_c_int(::google::protobuf::int32 value) {
  set_has_c_int();
  c_int_ = value;
}

// optional int64 c_time = 6;
inline bool UNION_DATA_VALUE::has_c_time() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_time() {
  _has_bits_[0] |= 0x00000020u;
}
inline void UNION_DATA_VALUE::clear_has_c_time() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void UNION_DATA_VALUE::clear_c_time() {
  c_time_ = GOOGLE_LONGLONG(0);
  clear_has_c_time();
}
inline ::google::protobuf::int64 UNION_DATA_VALUE::c_time() const {
  return c_time_;
}
inline void UNION_DATA_VALUE::set_c_time(::google::protobuf::int64 value) {
  set_has_c_time();
  c_time_ = value;
}

// optional float c_float = 7;
inline bool UNION_DATA_VALUE::has_c_float() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_float() {
  _has_bits_[0] |= 0x00000040u;
}
inline void UNION_DATA_VALUE::clear_has_c_float() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void UNION_DATA_VALUE::clear_c_float() {
  c_float_ = 0;
  clear_has_c_float();
}
inline float UNION_DATA_VALUE::c_float() const {
  return c_float_;
}
inline void UNION_DATA_VALUE::set_c_float(float value) {
  set_has_c_float();
  c_float_ = value;
}

// optional double c_double = 8;
inline bool UNION_DATA_VALUE::has_c_double() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_double() {
  _has_bits_[0] |= 0x00000080u;
}
inline void UNION_DATA_VALUE::clear_has_c_double() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void UNION_DATA_VALUE::clear_c_double() {
  c_double_ = 0;
  clear_has_c_double();
}
inline double UNION_DATA_VALUE::c_double() const {
  return c_double_;
}
inline void UNION_DATA_VALUE::set_c_double(double value) {
  set_has_c_double();
  c_double_ = value;
}

// optional int64 c_keyid = 9;
inline bool UNION_DATA_VALUE::has_c_keyid() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_keyid() {
  _has_bits_[0] |= 0x00000100u;
}
inline void UNION_DATA_VALUE::clear_has_c_keyid() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void UNION_DATA_VALUE::clear_c_keyid() {
  c_keyid_ = GOOGLE_LONGLONG(0);
  clear_has_c_keyid();
}
inline ::google::protobuf::int64 UNION_DATA_VALUE::c_keyid() const {
  return c_keyid_;
}
inline void UNION_DATA_VALUE::set_c_keyid(::google::protobuf::int64 value) {
  set_has_c_keyid();
  c_keyid_ = value;
}

// optional .RDB_PROTO.SEQ_CHAR c_binary = 10;
inline bool UNION_DATA_VALUE::has_c_binary() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_binary() {
  _has_bits_[0] |= 0x00000200u;
}
inline void UNION_DATA_VALUE::clear_has_c_binary() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void UNION_DATA_VALUE::clear_c_binary() {
  if (c_binary_ != NULL) c_binary_->::RDB_PROTO::SEQ_CHAR::Clear();
  clear_has_c_binary();
}
inline const ::RDB_PROTO::SEQ_CHAR& UNION_DATA_VALUE::c_binary() const {
  return c_binary_ != NULL ? *c_binary_ : *default_instance_->c_binary_;
}
inline ::RDB_PROTO::SEQ_CHAR* UNION_DATA_VALUE::mutable_c_binary() {
  set_has_c_binary();
  if (c_binary_ == NULL) c_binary_ = new ::RDB_PROTO::SEQ_CHAR;
  return c_binary_;
}
inline ::RDB_PROTO::SEQ_CHAR* UNION_DATA_VALUE::release_c_binary() {
  clear_has_c_binary();
  ::RDB_PROTO::SEQ_CHAR* temp = c_binary_;
  c_binary_ = NULL;
  return temp;
}
inline void UNION_DATA_VALUE::set_allocated_c_binary(::RDB_PROTO::SEQ_CHAR* c_binary) {
  delete c_binary_;
  c_binary_ = c_binary;
  if (c_binary) {
    set_has_c_binary();
  } else {
    clear_has_c_binary();
  }
}

// optional .RDB_PROTO.SEQ_CHAR c_text = 11;
inline bool UNION_DATA_VALUE::has_c_text() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_text() {
  _has_bits_[0] |= 0x00000400u;
}
inline void UNION_DATA_VALUE::clear_has_c_text() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void UNION_DATA_VALUE::clear_c_text() {
  if (c_text_ != NULL) c_text_->::RDB_PROTO::SEQ_CHAR::Clear();
  clear_has_c_text();
}
inline const ::RDB_PROTO::SEQ_CHAR& UNION_DATA_VALUE::c_text() const {
  return c_text_ != NULL ? *c_text_ : *default_instance_->c_text_;
}
inline ::RDB_PROTO::SEQ_CHAR* UNION_DATA_VALUE::mutable_c_text() {
  set_has_c_text();
  if (c_text_ == NULL) c_text_ = new ::RDB_PROTO::SEQ_CHAR;
  return c_text_;
}
inline ::RDB_PROTO::SEQ_CHAR* UNION_DATA_VALUE::release_c_text() {
  clear_has_c_text();
  ::RDB_PROTO::SEQ_CHAR* temp = c_text_;
  c_text_ = NULL;
  return temp;
}
inline void UNION_DATA_VALUE::set_allocated_c_text(::RDB_PROTO::SEQ_CHAR* c_text) {
  delete c_text_;
  c_text_ = c_text;
  if (c_text) {
    set_has_c_text();
  } else {
    clear_has_c_text();
  }
}

// optional .RDB_PROTO.SEQ_CHAR c_image = 12;
inline bool UNION_DATA_VALUE::has_c_image() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_image() {
  _has_bits_[0] |= 0x00000800u;
}
inline void UNION_DATA_VALUE::clear_has_c_image() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void UNION_DATA_VALUE::clear_c_image() {
  if (c_image_ != NULL) c_image_->::RDB_PROTO::SEQ_CHAR::Clear();
  clear_has_c_image();
}
inline const ::RDB_PROTO::SEQ_CHAR& UNION_DATA_VALUE::c_image() const {
  return c_image_ != NULL ? *c_image_ : *default_instance_->c_image_;
}
inline ::RDB_PROTO::SEQ_CHAR* UNION_DATA_VALUE::mutable_c_image() {
  set_has_c_image();
  if (c_image_ == NULL) c_image_ = new ::RDB_PROTO::SEQ_CHAR;
  return c_image_;
}
inline ::RDB_PROTO::SEQ_CHAR* UNION_DATA_VALUE::release_c_image() {
  clear_has_c_image();
  ::RDB_PROTO::SEQ_CHAR* temp = c_image_;
  c_image_ = NULL;
  return temp;
}
inline void UNION_DATA_VALUE::set_allocated_c_image(::RDB_PROTO::SEQ_CHAR* c_image) {
  delete c_image_;
  c_image_ = c_image;
  if (c_image) {
    set_has_c_image();
  } else {
    clear_has_c_image();
  }
}

// optional .RDB_PROTO.APPKEYID_STRUCT c_appkeyid = 13;
inline bool UNION_DATA_VALUE::has_c_appkeyid() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_appkeyid() {
  _has_bits_[0] |= 0x00001000u;
}
inline void UNION_DATA_VALUE::clear_has_c_appkeyid() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void UNION_DATA_VALUE::clear_c_appkeyid() {
  if (c_appkeyid_ != NULL) c_appkeyid_->::RDB_PROTO::APPKEYID_STRUCT::Clear();
  clear_has_c_appkeyid();
}
inline const ::RDB_PROTO::APPKEYID_STRUCT& UNION_DATA_VALUE::c_appkeyid() const {
  return c_appkeyid_ != NULL ? *c_appkeyid_ : *default_instance_->c_appkeyid_;
}
inline ::RDB_PROTO::APPKEYID_STRUCT* UNION_DATA_VALUE::mutable_c_appkeyid() {
  set_has_c_appkeyid();
  if (c_appkeyid_ == NULL) c_appkeyid_ = new ::RDB_PROTO::APPKEYID_STRUCT;
  return c_appkeyid_;
}
inline ::RDB_PROTO::APPKEYID_STRUCT* UNION_DATA_VALUE::release_c_appkeyid() {
  clear_has_c_appkeyid();
  ::RDB_PROTO::APPKEYID_STRUCT* temp = c_appkeyid_;
  c_appkeyid_ = NULL;
  return temp;
}
inline void UNION_DATA_VALUE::set_allocated_c_appkeyid(::RDB_PROTO::APPKEYID_STRUCT* c_appkeyid) {
  delete c_appkeyid_;
  c_appkeyid_ = c_appkeyid;
  if (c_appkeyid) {
    set_has_c_appkeyid();
  } else {
    clear_has_c_appkeyid();
  }
}

// optional .RDB_PROTO.APPID_STRUCT c_appid = 14;
inline bool UNION_DATA_VALUE::has_c_appid() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_appid() {
  _has_bits_[0] |= 0x00002000u;
}
inline void UNION_DATA_VALUE::clear_has_c_appid() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void UNION_DATA_VALUE::clear_c_appid() {
  if (c_appid_ != NULL) c_appid_->::RDB_PROTO::APPID_STRUCT::Clear();
  clear_has_c_appid();
}
inline const ::RDB_PROTO::APPID_STRUCT& UNION_DATA_VALUE::c_appid() const {
  return c_appid_ != NULL ? *c_appid_ : *default_instance_->c_appid_;
}
inline ::RDB_PROTO::APPID_STRUCT* UNION_DATA_VALUE::mutable_c_appid() {
  set_has_c_appid();
  if (c_appid_ == NULL) c_appid_ = new ::RDB_PROTO::APPID_STRUCT;
  return c_appid_;
}
inline ::RDB_PROTO::APPID_STRUCT* UNION_DATA_VALUE::release_c_appid() {
  clear_has_c_appid();
  ::RDB_PROTO::APPID_STRUCT* temp = c_appid_;
  c_appid_ = NULL;
  return temp;
}
inline void UNION_DATA_VALUE::set_allocated_c_appid(::RDB_PROTO::APPID_STRUCT* c_appid) {
  delete c_appid_;
  c_appid_ = c_appid;
  if (c_appid) {
    set_has_c_appid();
  } else {
    clear_has_c_appid();
  }
}

// optional bytes c_default = 15;
inline bool UNION_DATA_VALUE::has_c_default() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_default() {
  _has_bits_[0] |= 0x00004000u;
}
inline void UNION_DATA_VALUE::clear_has_c_default() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void UNION_DATA_VALUE::clear_c_default() {
  if (c_default_ != &::google::protobuf::internal::kEmptyString) {
    c_default_->clear();
  }
  clear_has_c_default();
}
inline const ::std::string& UNION_DATA_VALUE::c_default() const {
  return *c_default_;
}
inline void UNION_DATA_VALUE::set_c_default(const ::std::string& value) {
  set_has_c_default();
  if (c_default_ == &::google::protobuf::internal::kEmptyString) {
    c_default_ = new ::std::string;
  }
  c_default_->assign(value);
}
inline void UNION_DATA_VALUE::set_c_default(const char* value) {
  set_has_c_default();
  if (c_default_ == &::google::protobuf::internal::kEmptyString) {
    c_default_ = new ::std::string;
  }
  c_default_->assign(value);
}
inline void UNION_DATA_VALUE::set_c_default(const void* value, size_t size) {
  set_has_c_default();
  if (c_default_ == &::google::protobuf::internal::kEmptyString) {
    c_default_ = new ::std::string;
  }
  c_default_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UNION_DATA_VALUE::mutable_c_default() {
  set_has_c_default();
  if (c_default_ == &::google::protobuf::internal::kEmptyString) {
    c_default_ = new ::std::string;
  }
  return c_default_;
}
inline ::std::string* UNION_DATA_VALUE::release_c_default() {
  clear_has_c_default();
  if (c_default_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = c_default_;
    c_default_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void UNION_DATA_VALUE::set_allocated_c_default(::std::string* c_default) {
  if (c_default_ != &::google::protobuf::internal::kEmptyString) {
    delete c_default_;
  }
  if (c_default) {
    set_has_c_default();
    c_default_ = c_default;
  } else {
    clear_has_c_default();
    c_default_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// optional uint32 c_uint = 16;
inline bool UNION_DATA_VALUE::has_c_uint() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_uint() {
  _has_bits_[0] |= 0x00008000u;
}
inline void UNION_DATA_VALUE::clear_has_c_uint() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void UNION_DATA_VALUE::clear_c_uint() {
  c_uint_ = 0u;
  clear_has_c_uint();
}
inline ::google::protobuf::uint32 UNION_DATA_VALUE::c_uint() const {
  return c_uint_;
}
inline void UNION_DATA_VALUE::set_c_uint(::google::protobuf::uint32 value) {
  set_has_c_uint();
  c_uint_ = value;
}

// optional int64 c_long = 17;
inline bool UNION_DATA_VALUE::has_c_long() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_long() {
  _has_bits_[0] |= 0x00010000u;
}
inline void UNION_DATA_VALUE::clear_has_c_long() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void UNION_DATA_VALUE::clear_c_long() {
  c_long_ = GOOGLE_LONGLONG(0);
  clear_has_c_long();
}
inline ::google::protobuf::int64 UNION_DATA_VALUE::c_long() const {
  return c_long_;
}
inline void UNION_DATA_VALUE::set_c_long(::google::protobuf::int64 value) {
  set_has_c_long();
  c_long_ = value;
}

// optional .RDB_PROTO.RTDBKEY_STRUCT c_rtdbkeyid = 18;
inline bool UNION_DATA_VALUE::has_c_rtdbkeyid() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_rtdbkeyid() {
  _has_bits_[0] |= 0x00020000u;
}
inline void UNION_DATA_VALUE::clear_has_c_rtdbkeyid() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void UNION_DATA_VALUE::clear_c_rtdbkeyid() {
  if (c_rtdbkeyid_ != NULL) c_rtdbkeyid_->::RDB_PROTO::RTDBKEY_STRUCT::Clear();
  clear_has_c_rtdbkeyid();
}
inline const ::RDB_PROTO::RTDBKEY_STRUCT& UNION_DATA_VALUE::c_rtdbkeyid() const {
  return c_rtdbkeyid_ != NULL ? *c_rtdbkeyid_ : *default_instance_->c_rtdbkeyid_;
}
inline ::RDB_PROTO::RTDBKEY_STRUCT* UNION_DATA_VALUE::mutable_c_rtdbkeyid() {
  set_has_c_rtdbkeyid();
  if (c_rtdbkeyid_ == NULL) c_rtdbkeyid_ = new ::RDB_PROTO::RTDBKEY_STRUCT;
  return c_rtdbkeyid_;
}
inline ::RDB_PROTO::RTDBKEY_STRUCT* UNION_DATA_VALUE::release_c_rtdbkeyid() {
  clear_has_c_rtdbkeyid();
  ::RDB_PROTO::RTDBKEY_STRUCT* temp = c_rtdbkeyid_;
  c_rtdbkeyid_ = NULL;
  return temp;
}
inline void UNION_DATA_VALUE::set_allocated_c_rtdbkeyid(::RDB_PROTO::RTDBKEY_STRUCT* c_rtdbkeyid) {
  delete c_rtdbkeyid_;
  c_rtdbkeyid_ = c_rtdbkeyid;
  if (c_rtdbkeyid) {
    set_has_c_rtdbkeyid();
  } else {
    clear_has_c_rtdbkeyid();
  }
}

// optional .RDB_PROTO.RTDBKEY_STRUCT c_measrtdbkeyid = 19;
inline bool UNION_DATA_VALUE::has_c_measrtdbkeyid() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_measrtdbkeyid() {
  _has_bits_[0] |= 0x00040000u;
}
inline void UNION_DATA_VALUE::clear_has_c_measrtdbkeyid() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void UNION_DATA_VALUE::clear_c_measrtdbkeyid() {
  if (c_measrtdbkeyid_ != NULL) c_measrtdbkeyid_->::RDB_PROTO::RTDBKEY_STRUCT::Clear();
  clear_has_c_measrtdbkeyid();
}
inline const ::RDB_PROTO::RTDBKEY_STRUCT& UNION_DATA_VALUE::c_measrtdbkeyid() const {
  return c_measrtdbkeyid_ != NULL ? *c_measrtdbkeyid_ : *default_instance_->c_measrtdbkeyid_;
}
inline ::RDB_PROTO::RTDBKEY_STRUCT* UNION_DATA_VALUE::mutable_c_measrtdbkeyid() {
  set_has_c_measrtdbkeyid();
  if (c_measrtdbkeyid_ == NULL) c_measrtdbkeyid_ = new ::RDB_PROTO::RTDBKEY_STRUCT;
  return c_measrtdbkeyid_;
}
inline ::RDB_PROTO::RTDBKEY_STRUCT* UNION_DATA_VALUE::release_c_measrtdbkeyid() {
  clear_has_c_measrtdbkeyid();
  ::RDB_PROTO::RTDBKEY_STRUCT* temp = c_measrtdbkeyid_;
  c_measrtdbkeyid_ = NULL;
  return temp;
}
inline void UNION_DATA_VALUE::set_allocated_c_measrtdbkeyid(::RDB_PROTO::RTDBKEY_STRUCT* c_measrtdbkeyid) {
  delete c_measrtdbkeyid_;
  c_measrtdbkeyid_ = c_measrtdbkeyid;
  if (c_measrtdbkeyid) {
    set_has_c_measrtdbkeyid();
  } else {
    clear_has_c_measrtdbkeyid();
  }
}

// optional .RDB_PROTO.APPRTDBKDY_STRUCT c_apprtdbkey = 20;
inline bool UNION_DATA_VALUE::has_c_apprtdbkey() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void UNION_DATA_VALUE::set_has_c_apprtdbkey() {
  _has_bits_[0] |= 0x00080000u;
}
inline void UNION_DATA_VALUE::clear_has_c_apprtdbkey() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void UNION_DATA_VALUE::clear_c_apprtdbkey() {
  if (c_apprtdbkey_ != NULL) c_apprtdbkey_->::RDB_PROTO::APPRTDBKDY_STRUCT::Clear();
  clear_has_c_apprtdbkey();
}
inline const ::RDB_PROTO::APPRTDBKDY_STRUCT& UNION_DATA_VALUE::c_apprtdbkey() const {
  return c_apprtdbkey_ != NULL ? *c_apprtdbkey_ : *default_instance_->c_apprtdbkey_;
}
inline ::RDB_PROTO::APPRTDBKDY_STRUCT* UNION_DATA_VALUE::mutable_c_apprtdbkey() {
  set_has_c_apprtdbkey();
  if (c_apprtdbkey_ == NULL) c_apprtdbkey_ = new ::RDB_PROTO::APPRTDBKDY_STRUCT;
  return c_apprtdbkey_;
}
inline ::RDB_PROTO::APPRTDBKDY_STRUCT* UNION_DATA_VALUE::release_c_apprtdbkey() {
  clear_has_c_apprtdbkey();
  ::RDB_PROTO::APPRTDBKDY_STRUCT* temp = c_apprtdbkey_;
  c_apprtdbkey_ = NULL;
  return temp;
}
inline void UNION_DATA_VALUE::set_allocated_c_apprtdbkey(::RDB_PROTO::APPRTDBKDY_STRUCT* c_apprtdbkey) {
  delete c_apprtdbkey_;
  c_apprtdbkey_ = c_apprtdbkey;
  if (c_apprtdbkey) {
    set_has_c_apprtdbkey();
  } else {
    clear_has_c_apprtdbkey();
  }
}

// -------------------------------------------------------------------

// SEQ_DATA_VALUE

// repeated .RDB_PROTO.UNION_DATA_VALUE vec_data = 1;
inline int SEQ_DATA_VALUE::vec_data_size() const {
  return vec_data_.size();
}
inline void SEQ_DATA_VALUE::clear_vec_data() {
  vec_data_.Clear();
}
inline const ::RDB_PROTO::UNION_DATA_VALUE& SEQ_DATA_VALUE::vec_data(int index) const {
  return vec_data_.Get(index);
}
inline ::RDB_PROTO::UNION_DATA_VALUE* SEQ_DATA_VALUE::mutable_vec_data(int index) {
  return vec_data_.Mutable(index);
}
inline ::RDB_PROTO::UNION_DATA_VALUE* SEQ_DATA_VALUE::add_vec_data() {
  return vec_data_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::UNION_DATA_VALUE >&
SEQ_DATA_VALUE::vec_data() const {
  return vec_data_;
}
inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::UNION_DATA_VALUE >*
SEQ_DATA_VALUE::mutable_vec_data() {
  return &vec_data_;
}

// -------------------------------------------------------------------

// DBERROR_STRUCT

// optional uint32 error_no = 1;
inline bool DBERROR_STRUCT::has_error_no() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void DBERROR_STRUCT::set_has_error_no() {
  _has_bits_[0] |= 0x00000001u;
}
inline void DBERROR_STRUCT::clear_has_error_no() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void DBERROR_STRUCT::clear_error_no() {
  error_no_ = 0u;
  clear_has_error_no();
}
inline ::google::protobuf::uint32 DBERROR_STRUCT::error_no() const {
  return error_no_;
}
inline void DBERROR_STRUCT::set_error_no(::google::protobuf::uint32 value) {
  set_has_error_no();
  error_no_ = value;
}

// optional bytes error_msg = 2;
inline bool DBERROR_STRUCT::has_error_msg() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void DBERROR_STRUCT::set_has_error_msg() {
  _has_bits_[0] |= 0x00000002u;
}
inline void DBERROR_STRUCT::clear_has_error_msg() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void DBERROR_STRUCT::clear_error_msg() {
  if (error_msg_ != &::google::protobuf::internal::kEmptyString) {
    error_msg_->clear();
  }
  clear_has_error_msg();
}
inline const ::std::string& DBERROR_STRUCT::error_msg() const {
  return *error_msg_;
}
inline void DBERROR_STRUCT::set_error_msg(const ::std::string& value) {
  set_has_error_msg();
  if (error_msg_ == &::google::protobuf::internal::kEmptyString) {
    error_msg_ = new ::std::string;
  }
  error_msg_->assign(value);
}
inline void DBERROR_STRUCT::set_error_msg(const char* value) {
  set_has_error_msg();
  if (error_msg_ == &::google::protobuf::internal::kEmptyString) {
    error_msg_ = new ::std::string;
  }
  error_msg_->assign(value);
}
inline void DBERROR_STRUCT::set_error_msg(const void* value, size_t size) {
  set_has_error_msg();
  if (error_msg_ == &::google::protobuf::internal::kEmptyString) {
    error_msg_ = new ::std::string;
  }
  error_msg_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DBERROR_STRUCT::mutable_error_msg() {
  set_has_error_msg();
  if (error_msg_ == &::google::protobuf::internal::kEmptyString) {
    error_msg_ = new ::std::string;
  }
  return error_msg_;
}
inline ::std::string* DBERROR_STRUCT::release_error_msg() {
  clear_has_error_msg();
  if (error_msg_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = error_msg_;
    error_msg_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void DBERROR_STRUCT::set_allocated_error_msg(::std::string* error_msg) {
  if (error_msg_ != &::google::protobuf::internal::kEmptyString) {
    delete error_msg_;
  }
  if (error_msg) {
    set_has_error_msg();
    error_msg_ = error_msg;
  } else {
    clear_has_error_msg();
    error_msg_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// SEQ_DBERROR

// repeated .RDB_PROTO.DBERROR_STRUCT vec_error = 1;
inline int SEQ_DBERROR::vec_error_size() const {
  return vec_error_.size();
}
inline void SEQ_DBERROR::clear_vec_error() {
  vec_error_.Clear();
}
inline const ::RDB_PROTO::DBERROR_STRUCT& SEQ_DBERROR::vec_error(int index) const {
  return vec_error_.Get(index);
}
inline ::RDB_PROTO::DBERROR_STRUCT* SEQ_DBERROR::mutable_vec_error(int index) {
  return vec_error_.Mutable(index);
}
inline ::RDB_PROTO::DBERROR_STRUCT* SEQ_DBERROR::add_vec_error() {
  return vec_error_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::DBERROR_STRUCT >&
SEQ_DBERROR::vec_error() const {
  return vec_error_;
}
inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::DBERROR_STRUCT >*
SEQ_DBERROR::mutable_vec_error() {
  return &vec_error_;
}

// -------------------------------------------------------------------

// RESULT_DATA_VALUE

// required bool is_null = 1;
inline bool RESULT_DATA_VALUE::has_is_null() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RESULT_DATA_VALUE::set_has_is_null() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RESULT_DATA_VALUE::clear_has_is_null() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RESULT_DATA_VALUE::clear_is_null() {
  is_null_ = false;
  clear_has_is_null();
}
inline bool RESULT_DATA_VALUE::is_null() const {
  return is_null_;
}
inline void RESULT_DATA_VALUE::set_is_null(bool value) {
  set_has_is_null();
  is_null_ = value;
}

// required .RDB_PROTO.UNION_DATA_VALUE data_value = 2;
inline bool RESULT_DATA_VALUE::has_data_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RESULT_DATA_VALUE::set_has_data_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RESULT_DATA_VALUE::clear_has_data_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RESULT_DATA_VALUE::clear_data_value() {
  if (data_value_ != NULL) data_value_->::RDB_PROTO::UNION_DATA_VALUE::Clear();
  clear_has_data_value();
}
inline const ::RDB_PROTO::UNION_DATA_VALUE& RESULT_DATA_VALUE::data_value() const {
  return data_value_ != NULL ? *data_value_ : *default_instance_->data_value_;
}
inline ::RDB_PROTO::UNION_DATA_VALUE* RESULT_DATA_VALUE::mutable_data_value() {
  set_has_data_value();
  if (data_value_ == NULL) data_value_ = new ::RDB_PROTO::UNION_DATA_VALUE;
  return data_value_;
}
inline ::RDB_PROTO::UNION_DATA_VALUE* RESULT_DATA_VALUE::release_data_value() {
  clear_has_data_value();
  ::RDB_PROTO::UNION_DATA_VALUE* temp = data_value_;
  data_value_ = NULL;
  return temp;
}
inline void RESULT_DATA_VALUE::set_allocated_data_value(::RDB_PROTO::UNION_DATA_VALUE* data_value) {
  delete data_value_;
  data_value_ = data_value;
  if (data_value) {
    set_has_data_value();
  } else {
    clear_has_data_value();
  }
}

// -------------------------------------------------------------------

// SEQ_RESULT_DATA_VALUE

// repeated .RDB_PROTO.RESULT_DATA_VALUE vec_result_data_value = 1;
inline int SEQ_RESULT_DATA_VALUE::vec_result_data_value_size() const {
  return vec_result_data_value_.size();
}
inline void SEQ_RESULT_DATA_VALUE::clear_vec_result_data_value() {
  vec_result_data_value_.Clear();
}
inline const ::RDB_PROTO::RESULT_DATA_VALUE& SEQ_RESULT_DATA_VALUE::vec_result_data_value(int index) const {
  return vec_result_data_value_.Get(index);
}
inline ::RDB_PROTO::RESULT_DATA_VALUE* SEQ_RESULT_DATA_VALUE::mutable_vec_result_data_value(int index) {
  return vec_result_data_value_.Mutable(index);
}
inline ::RDB_PROTO::RESULT_DATA_VALUE* SEQ_RESULT_DATA_VALUE::add_vec_result_data_value() {
  return vec_result_data_value_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::RESULT_DATA_VALUE >&
SEQ_RESULT_DATA_VALUE::vec_result_data_value() const {
  return vec_result_data_value_;
}
inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::RESULT_DATA_VALUE >*
SEQ_RESULT_DATA_VALUE::mutable_vec_result_data_value() {
  return &vec_result_data_value_;
}

// -------------------------------------------------------------------

// RESULT_FIELD_INFO

// required int32 data_type = 1;
inline bool RESULT_FIELD_INFO::has_data_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RESULT_FIELD_INFO::set_has_data_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RESULT_FIELD_INFO::clear_has_data_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RESULT_FIELD_INFO::clear_data_type() {
  data_type_ = 0;
  clear_has_data_type();
}
inline ::google::protobuf::int32 RESULT_FIELD_INFO::data_type() const {
  return data_type_;
}
inline void RESULT_FIELD_INFO::set_data_type(::google::protobuf::int32 value) {
  set_has_data_type();
  data_type_ = value;
}

// required int32 data_len = 2;
inline bool RESULT_FIELD_INFO::has_data_len() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RESULT_FIELD_INFO::set_has_data_len() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RESULT_FIELD_INFO::clear_has_data_len() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RESULT_FIELD_INFO::clear_data_len() {
  data_len_ = 0;
  clear_has_data_len();
}
inline ::google::protobuf::int32 RESULT_FIELD_INFO::data_len() const {
  return data_len_;
}
inline void RESULT_FIELD_INFO::set_data_len(::google::protobuf::int32 value) {
  set_has_data_len();
  data_len_ = value;
}

// required bytes col_name = 3;
inline bool RESULT_FIELD_INFO::has_col_name() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RESULT_FIELD_INFO::set_has_col_name() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RESULT_FIELD_INFO::clear_has_col_name() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void RESULT_FIELD_INFO::clear_col_name() {
  if (col_name_ != &::google::protobuf::internal::kEmptyString) {
    col_name_->clear();
  }
  clear_has_col_name();
}
inline const ::std::string& RESULT_FIELD_INFO::col_name() const {
  return *col_name_;
}
inline void RESULT_FIELD_INFO::set_col_name(const ::std::string& value) {
  set_has_col_name();
  if (col_name_ == &::google::protobuf::internal::kEmptyString) {
    col_name_ = new ::std::string;
  }
  col_name_->assign(value);
}
inline void RESULT_FIELD_INFO::set_col_name(const char* value) {
  set_has_col_name();
  if (col_name_ == &::google::protobuf::internal::kEmptyString) {
    col_name_ = new ::std::string;
  }
  col_name_->assign(value);
}
inline void RESULT_FIELD_INFO::set_col_name(const void* value, size_t size) {
  set_has_col_name();
  if (col_name_ == &::google::protobuf::internal::kEmptyString) {
    col_name_ = new ::std::string;
  }
  col_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* RESULT_FIELD_INFO::mutable_col_name() {
  set_has_col_name();
  if (col_name_ == &::google::protobuf::internal::kEmptyString) {
    col_name_ = new ::std::string;
  }
  return col_name_;
}
inline ::std::string* RESULT_FIELD_INFO::release_col_name() {
  clear_has_col_name();
  if (col_name_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = col_name_;
    col_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}
inline void RESULT_FIELD_INFO::set_allocated_col_name(::std::string* col_name) {
  if (col_name_ != &::google::protobuf::internal::kEmptyString) {
    delete col_name_;
  }
  if (col_name) {
    set_has_col_name();
    col_name_ = col_name;
  } else {
    clear_has_col_name();
    col_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  }
}

// -------------------------------------------------------------------

// SEQ_RESULT_FIELD_INFO

// repeated .RDB_PROTO.RESULT_FIELD_INFO vec_result_field_info = 1;
inline int SEQ_RESULT_FIELD_INFO::vec_result_field_info_size() const {
  return vec_result_field_info_.size();
}
inline void SEQ_RESULT_FIELD_INFO::clear_vec_result_field_info() {
  vec_result_field_info_.Clear();
}
inline const ::RDB_PROTO::RESULT_FIELD_INFO& SEQ_RESULT_FIELD_INFO::vec_result_field_info(int index) const {
  return vec_result_field_info_.Get(index);
}
inline ::RDB_PROTO::RESULT_FIELD_INFO* SEQ_RESULT_FIELD_INFO::mutable_vec_result_field_info(int index) {
  return vec_result_field_info_.Mutable(index);
}
inline ::RDB_PROTO::RESULT_FIELD_INFO* SEQ_RESULT_FIELD_INFO::add_vec_result_field_info() {
  return vec_result_field_info_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::RESULT_FIELD_INFO >&
SEQ_RESULT_FIELD_INFO::vec_result_field_info() const {
  return vec_result_field_info_;
}
inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::RESULT_FIELD_INFO >*
SEQ_RESULT_FIELD_INFO::mutable_vec_result_field_info() {
  return &vec_result_field_info_;
}

// -------------------------------------------------------------------

// OUT_DATA_TYPE

// required int32 out_field_position = 1;
inline bool OUT_DATA_TYPE::has_out_field_position() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OUT_DATA_TYPE::set_has_out_field_position() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OUT_DATA_TYPE::clear_has_out_field_position() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OUT_DATA_TYPE::clear_out_field_position() {
  out_field_position_ = 0;
  clear_has_out_field_position();
}
inline ::google::protobuf::int32 OUT_DATA_TYPE::out_field_position() const {
  return out_field_position_;
}
inline void OUT_DATA_TYPE::set_out_field_position(::google::protobuf::int32 value) {
  set_has_out_field_position();
  out_field_position_ = value;
}

// required int32 out_field_datatype = 2;
inline bool OUT_DATA_TYPE::has_out_field_datatype() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void OUT_DATA_TYPE::set_has_out_field_datatype() {
  _has_bits_[0] |= 0x00000002u;
}
inline void OUT_DATA_TYPE::clear_has_out_field_datatype() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void OUT_DATA_TYPE::clear_out_field_datatype() {
  out_field_datatype_ = 0;
  clear_has_out_field_datatype();
}
inline ::google::protobuf::int32 OUT_DATA_TYPE::out_field_datatype() const {
  return out_field_datatype_;
}
inline void OUT_DATA_TYPE::set_out_field_datatype(::google::protobuf::int32 value) {
  set_has_out_field_datatype();
  out_field_datatype_ = value;
}

// -------------------------------------------------------------------

// SEQ_OUT_DATA_TYPE

// repeated .RDB_PROTO.OUT_DATA_TYPE vec_out_data_type = 1;
inline int SEQ_OUT_DATA_TYPE::vec_out_data_type_size() const {
  return vec_out_data_type_.size();
}
inline void SEQ_OUT_DATA_TYPE::clear_vec_out_data_type() {
  vec_out_data_type_.Clear();
}
inline const ::RDB_PROTO::OUT_DATA_TYPE& SEQ_OUT_DATA_TYPE::vec_out_data_type(int index) const {
  return vec_out_data_type_.Get(index);
}
inline ::RDB_PROTO::OUT_DATA_TYPE* SEQ_OUT_DATA_TYPE::mutable_vec_out_data_type(int index) {
  return vec_out_data_type_.Mutable(index);
}
inline ::RDB_PROTO::OUT_DATA_TYPE* SEQ_OUT_DATA_TYPE::add_vec_out_data_type() {
  return vec_out_data_type_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::OUT_DATA_TYPE >&
SEQ_OUT_DATA_TYPE::vec_out_data_type() const {
  return vec_out_data_type_;
}
inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::OUT_DATA_TYPE >*
SEQ_OUT_DATA_TYPE::mutable_vec_out_data_type() {
  return &vec_out_data_type_;
}

// -------------------------------------------------------------------

// SELECT_RESULT

// required int32 field_num = 1;
inline bool SELECT_RESULT::has_field_num() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SELECT_RESULT::set_has_field_num() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SELECT_RESULT::clear_has_field_num() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SELECT_RESULT::clear_field_num() {
  field_num_ = 0;
  clear_has_field_num();
}
inline ::google::protobuf::int32 SELECT_RESULT::field_num() const {
  return field_num_;
}
inline void SELECT_RESULT::set_field_num(::google::protobuf::int32 value) {
  set_has_field_num();
  field_num_ = value;
}

// required .RDB_PROTO.SEQ_RESULT_FIELD_INFO field_info = 2;
inline bool SELECT_RESULT::has_field_info() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SELECT_RESULT::set_has_field_info() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SELECT_RESULT::clear_has_field_info() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SELECT_RESULT::clear_field_info() {
  if (field_info_ != NULL) field_info_->::RDB_PROTO::SEQ_RESULT_FIELD_INFO::Clear();
  clear_has_field_info();
}
inline const ::RDB_PROTO::SEQ_RESULT_FIELD_INFO& SELECT_RESULT::field_info() const {
  return field_info_ != NULL ? *field_info_ : *default_instance_->field_info_;
}
inline ::RDB_PROTO::SEQ_RESULT_FIELD_INFO* SELECT_RESULT::mutable_field_info() {
  set_has_field_info();
  if (field_info_ == NULL) field_info_ = new ::RDB_PROTO::SEQ_RESULT_FIELD_INFO;
  return field_info_;
}
inline ::RDB_PROTO::SEQ_RESULT_FIELD_INFO* SELECT_RESULT::release_field_info() {
  clear_has_field_info();
  ::RDB_PROTO::SEQ_RESULT_FIELD_INFO* temp = field_info_;
  field_info_ = NULL;
  return temp;
}
inline void SELECT_RESULT::set_allocated_field_info(::RDB_PROTO::SEQ_RESULT_FIELD_INFO* field_info) {
  delete field_info_;
  field_info_ = field_info;
  if (field_info) {
    set_has_field_info();
  } else {
    clear_has_field_info();
  }
}

// required uint32 data_num = 3;
inline bool SELECT_RESULT::has_data_num() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SELECT_RESULT::set_has_data_num() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SELECT_RESULT::clear_has_data_num() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SELECT_RESULT::clear_data_num() {
  data_num_ = 0u;
  clear_has_data_num();
}
inline ::google::protobuf::uint32 SELECT_RESULT::data_num() const {
  return data_num_;
}
inline void SELECT_RESULT::set_data_num(::google::protobuf::uint32 value) {
  set_has_data_num();
  data_num_ = value;
}

// required .RDB_PROTO.SEQ_RESULT_DATA_VALUE data_value_seq = 4;
inline bool SELECT_RESULT::has_data_value_seq() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SELECT_RESULT::set_has_data_value_seq() {
  _has_bits_[0] |= 0x00000008u;
}
inline void SELECT_RESULT::clear_has_data_value_seq() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void SELECT_RESULT::clear_data_value_seq() {
  if (data_value_seq_ != NULL) data_value_seq_->::RDB_PROTO::SEQ_RESULT_DATA_VALUE::Clear();
  clear_has_data_value_seq();
}
inline const ::RDB_PROTO::SEQ_RESULT_DATA_VALUE& SELECT_RESULT::data_value_seq() const {
  return data_value_seq_ != NULL ? *data_value_seq_ : *default_instance_->data_value_seq_;
}
inline ::RDB_PROTO::SEQ_RESULT_DATA_VALUE* SELECT_RESULT::mutable_data_value_seq() {
  set_has_data_value_seq();
  if (data_value_seq_ == NULL) data_value_seq_ = new ::RDB_PROTO::SEQ_RESULT_DATA_VALUE;
  return data_value_seq_;
}
inline ::RDB_PROTO::SEQ_RESULT_DATA_VALUE* SELECT_RESULT::release_data_value_seq() {
  clear_has_data_value_seq();
  ::RDB_PROTO::SEQ_RESULT_DATA_VALUE* temp = data_value_seq_;
  data_value_seq_ = NULL;
  return temp;
}
inline void SELECT_RESULT::set_allocated_data_value_seq(::RDB_PROTO::SEQ_RESULT_DATA_VALUE* data_value_seq) {
  delete data_value_seq_;
  data_value_seq_ = data_value_seq;
  if (data_value_seq) {
    set_has_data_value_seq();
  } else {
    clear_has_data_value_seq();
  }
}

// -------------------------------------------------------------------

// EXEC_MULTI_RESULT

// required bool is_success = 1;
inline bool EXEC_MULTI_RESULT::has_is_success() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EXEC_MULTI_RESULT::set_has_is_success() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EXEC_MULTI_RESULT::clear_has_is_success() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EXEC_MULTI_RESULT::clear_is_success() {
  is_success_ = false;
  clear_has_is_success();
}
inline bool EXEC_MULTI_RESULT::is_success() const {
  return is_success_;
}
inline void EXEC_MULTI_RESULT::set_is_success(bool value) {
  set_has_is_success();
  is_success_ = value;
}

// required .RDB_PROTO.DBERROR_STRUCT db_error = 2;
inline bool EXEC_MULTI_RESULT::has_db_error() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void EXEC_MULTI_RESULT::set_has_db_error() {
  _has_bits_[0] |= 0x00000002u;
}
inline void EXEC_MULTI_RESULT::clear_has_db_error() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void EXEC_MULTI_RESULT::clear_db_error() {
  if (db_error_ != NULL) db_error_->::RDB_PROTO::DBERROR_STRUCT::Clear();
  clear_has_db_error();
}
inline const ::RDB_PROTO::DBERROR_STRUCT& EXEC_MULTI_RESULT::db_error() const {
  return db_error_ != NULL ? *db_error_ : *default_instance_->db_error_;
}
inline ::RDB_PROTO::DBERROR_STRUCT* EXEC_MULTI_RESULT::mutable_db_error() {
  set_has_db_error();
  if (db_error_ == NULL) db_error_ = new ::RDB_PROTO::DBERROR_STRUCT;
  return db_error_;
}
inline ::RDB_PROTO::DBERROR_STRUCT* EXEC_MULTI_RESULT::release_db_error() {
  clear_has_db_error();
  ::RDB_PROTO::DBERROR_STRUCT* temp = db_error_;
  db_error_ = NULL;
  return temp;
}
inline void EXEC_MULTI_RESULT::set_allocated_db_error(::RDB_PROTO::DBERROR_STRUCT* db_error) {
  delete db_error_;
  db_error_ = db_error;
  if (db_error) {
    set_has_db_error();
  } else {
    clear_has_db_error();
  }
}

// -------------------------------------------------------------------

// SEQ_EXEC_MULTI_RESULT

// repeated .RDB_PROTO.EXEC_MULTI_RESULT vec_exec_multi_result = 1;
inline int SEQ_EXEC_MULTI_RESULT::vec_exec_multi_result_size() const {
  return vec_exec_multi_result_.size();
}
inline void SEQ_EXEC_MULTI_RESULT::clear_vec_exec_multi_result() {
  vec_exec_multi_result_.Clear();
}
inline const ::RDB_PROTO::EXEC_MULTI_RESULT& SEQ_EXEC_MULTI_RESULT::vec_exec_multi_result(int index) const {
  return vec_exec_multi_result_.Get(index);
}
inline ::RDB_PROTO::EXEC_MULTI_RESULT* SEQ_EXEC_MULTI_RESULT::mutable_vec_exec_multi_result(int index) {
  return vec_exec_multi_result_.Mutable(index);
}
inline ::RDB_PROTO::EXEC_MULTI_RESULT* SEQ_EXEC_MULTI_RESULT::add_vec_exec_multi_result() {
  return vec_exec_multi_result_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::EXEC_MULTI_RESULT >&
SEQ_EXEC_MULTI_RESULT::vec_exec_multi_result() const {
  return vec_exec_multi_result_;
}
inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::EXEC_MULTI_RESULT >*
SEQ_EXEC_MULTI_RESULT::mutable_vec_exec_multi_result() {
  return &vec_exec_multi_result_;
}

// -------------------------------------------------------------------

// BIND_PARA

// required uint32 dci_type = 1;
inline bool BIND_PARA::has_dci_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BIND_PARA::set_has_dci_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BIND_PARA::clear_has_dci_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BIND_PARA::clear_dci_type() {
  dci_type_ = 0u;
  clear_has_dci_type();
}
inline ::google::protobuf::uint32 BIND_PARA::dci_type() const {
  return dci_type_;
}
inline void BIND_PARA::set_dci_type(::google::protobuf::uint32 value) {
  set_has_dci_type();
  dci_type_ = value;
}

// required int32 data_size = 2;
inline bool BIND_PARA::has_data_size() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BIND_PARA::set_has_data_size() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BIND_PARA::clear_has_data_size() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BIND_PARA::clear_data_size() {
  data_size_ = 0;
  clear_has_data_size();
}
inline ::google::protobuf::int32 BIND_PARA::data_size() const {
  return data_size_;
}
inline void BIND_PARA::set_data_size(::google::protobuf::int32 value) {
  set_has_data_size();
  data_size_ = value;
}

// -------------------------------------------------------------------

// SEQ_BIND_PARA

// repeated .RDB_PROTO.BIND_PARA vec_bind_para = 1;
inline int SEQ_BIND_PARA::vec_bind_para_size() const {
  return vec_bind_para_.size();
}
inline void SEQ_BIND_PARA::clear_vec_bind_para() {
  vec_bind_para_.Clear();
}
inline const ::RDB_PROTO::BIND_PARA& SEQ_BIND_PARA::vec_bind_para(int index) const {
  return vec_bind_para_.Get(index);
}
inline ::RDB_PROTO::BIND_PARA* SEQ_BIND_PARA::mutable_vec_bind_para(int index) {
  return vec_bind_para_.Mutable(index);
}
inline ::RDB_PROTO::BIND_PARA* SEQ_BIND_PARA::add_vec_bind_para() {
  return vec_bind_para_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::BIND_PARA >&
SEQ_BIND_PARA::vec_bind_para() const {
  return vec_bind_para_;
}
inline ::google::protobuf::RepeatedPtrField< ::RDB_PROTO::BIND_PARA >*
SEQ_BIND_PARA::mutable_vec_bind_para() {
  return &vec_bind_para_;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace RDB_PROTO

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::RDB_PROTO::DB_BYTE_T>() {
  return ::RDB_PROTO::DB_BYTE_T_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_rdb_5fdefine_2eproto__INCLUDED