service_msg.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_service_5fmsg_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_service_5fmsg_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3009000
#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 3009000 < 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/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "common.pb.h"
#include "schema.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_service_5fmsg_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_service_5fmsg_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[15]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_service_5fmsg_2eproto;
namespace milvus {
namespace proto {
namespace service {
class BoolResponse;
class BoolResponseDefaultTypeInternal;
extern BoolResponseDefaultTypeInternal _BoolResponse_default_instance_;
class CollectionDescription;
class CollectionDescriptionDefaultTypeInternal;
extern CollectionDescriptionDefaultTypeInternal _CollectionDescription_default_instance_;
class CollectionName;
class CollectionNameDefaultTypeInternal;
extern CollectionNameDefaultTypeInternal _CollectionName_default_instance_;
class Hits;
class HitsDefaultTypeInternal;
extern HitsDefaultTypeInternal _Hits_default_instance_;
class IntegerListResponse;
class IntegerListResponseDefaultTypeInternal;
extern IntegerListResponseDefaultTypeInternal _IntegerListResponse_default_instance_;
class IntegerRangeResponse;
class IntegerRangeResponseDefaultTypeInternal;
extern IntegerRangeResponseDefaultTypeInternal _IntegerRangeResponse_default_instance_;
class PartitionDescription;
class PartitionDescriptionDefaultTypeInternal;
extern PartitionDescriptionDefaultTypeInternal _PartitionDescription_default_instance_;
class PartitionName;
class PartitionNameDefaultTypeInternal;
extern PartitionNameDefaultTypeInternal _PartitionName_default_instance_;
class PlaceholderGroup;
class PlaceholderGroupDefaultTypeInternal;
extern PlaceholderGroupDefaultTypeInternal _PlaceholderGroup_default_instance_;
class PlaceholderValue;
class PlaceholderValueDefaultTypeInternal;
extern PlaceholderValueDefaultTypeInternal _PlaceholderValue_default_instance_;
class Query;
class QueryDefaultTypeInternal;
extern QueryDefaultTypeInternal _Query_default_instance_;
class QueryResult;
class QueryResultDefaultTypeInternal;
extern QueryResultDefaultTypeInternal _QueryResult_default_instance_;
class RowBatch;
class RowBatchDefaultTypeInternal;
extern RowBatchDefaultTypeInternal _RowBatch_default_instance_;
class StringListResponse;
class StringListResponseDefaultTypeInternal;
extern StringListResponseDefaultTypeInternal _StringListResponse_default_instance_;
class StringResponse;
class StringResponseDefaultTypeInternal;
extern StringResponseDefaultTypeInternal _StringResponse_default_instance_;
}  // namespace service
}  // namespace proto
}  // namespace milvus
PROTOBUF_NAMESPACE_OPEN
template<> ::milvus::proto::service::BoolResponse* Arena::CreateMaybeMessage<::milvus::proto::service::BoolResponse>(Arena*);
template<> ::milvus::proto::service::CollectionDescription* Arena::CreateMaybeMessage<::milvus::proto::service::CollectionDescription>(Arena*);
template<> ::milvus::proto::service::CollectionName* Arena::CreateMaybeMessage<::milvus::proto::service::CollectionName>(Arena*);
template<> ::milvus::proto::service::Hits* Arena::CreateMaybeMessage<::milvus::proto::service::Hits>(Arena*);
template<> ::milvus::proto::service::IntegerListResponse* Arena::CreateMaybeMessage<::milvus::proto::service::IntegerListResponse>(Arena*);
template<> ::milvus::proto::service::IntegerRangeResponse* Arena::CreateMaybeMessage<::milvus::proto::service::IntegerRangeResponse>(Arena*);
template<> ::milvus::proto::service::PartitionDescription* Arena::CreateMaybeMessage<::milvus::proto::service::PartitionDescription>(Arena*);
template<> ::milvus::proto::service::PartitionName* Arena::CreateMaybeMessage<::milvus::proto::service::PartitionName>(Arena*);
template<> ::milvus::proto::service::PlaceholderGroup* Arena::CreateMaybeMessage<::milvus::proto::service::PlaceholderGroup>(Arena*);
template<> ::milvus::proto::service::PlaceholderValue* Arena::CreateMaybeMessage<::milvus::proto::service::PlaceholderValue>(Arena*);
template<> ::milvus::proto::service::Query* Arena::CreateMaybeMessage<::milvus::proto::service::Query>(Arena*);
template<> ::milvus::proto::service::QueryResult* Arena::CreateMaybeMessage<::milvus::proto::service::QueryResult>(Arena*);
template<> ::milvus::proto::service::RowBatch* Arena::CreateMaybeMessage<::milvus::proto::service::RowBatch>(Arena*);
template<> ::milvus::proto::service::StringListResponse* Arena::CreateMaybeMessage<::milvus::proto::service::StringListResponse>(Arena*);
template<> ::milvus::proto::service::StringResponse* Arena::CreateMaybeMessage<::milvus::proto::service::StringResponse>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace milvus {
namespace proto {
namespace service {

enum PlaceholderType : int {
  NONE = 0,
  VECTOR_BINARY = 100,
  VECTOR_FLOAT = 101,
  PlaceholderType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  PlaceholderType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool PlaceholderType_IsValid(int value);
constexpr PlaceholderType PlaceholderType_MIN = NONE;
constexpr PlaceholderType PlaceholderType_MAX = VECTOR_FLOAT;
constexpr int PlaceholderType_ARRAYSIZE = PlaceholderType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlaceholderType_descriptor();
template<typename T>
inline const std::string& PlaceholderType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, PlaceholderType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function PlaceholderType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    PlaceholderType_descriptor(), enum_t_value);
}
inline bool PlaceholderType_Parse(
    const std::string& name, PlaceholderType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlaceholderType>(
    PlaceholderType_descriptor(), name, value);
}
// ===================================================================

class CollectionName :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.CollectionName) */ {
 public:
  CollectionName();
  virtual ~CollectionName();

  CollectionName(const CollectionName& from);
  CollectionName(CollectionName&& from) noexcept
    : CollectionName() {
    *this = ::std::move(from);
  }

  inline CollectionName& operator=(const CollectionName& from) {
    CopyFrom(from);
    return *this;
  }
  inline CollectionName& operator=(CollectionName&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CollectionName& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CollectionName* internal_default_instance() {
    return reinterpret_cast<const CollectionName*>(
               &_CollectionName_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(CollectionName& a, CollectionName& b) {
    a.Swap(&b);
  }
  inline void Swap(CollectionName* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline CollectionName* New() const final {
    return CreateMaybeMessage<CollectionName>(nullptr);
  }

  CollectionName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CollectionName>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CollectionName& from);
  void MergeFrom(const CollectionName& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CollectionName* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.CollectionName";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCollectionNameFieldNumber = 1,
  };
  // string collection_name = 1;
  void clear_collection_name();
  const std::string& collection_name() const;
  void set_collection_name(const std::string& value);
  void set_collection_name(std::string&& value);
  void set_collection_name(const char* value);
  void set_collection_name(const char* value, size_t size);
  std::string* mutable_collection_name();
  std::string* release_collection_name();
  void set_allocated_collection_name(std::string* collection_name);

  // @@protoc_insertion_point(class_scope:milvus.proto.service.CollectionName)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class PartitionName :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.PartitionName) */ {
 public:
  PartitionName();
  virtual ~PartitionName();

  PartitionName(const PartitionName& from);
  PartitionName(PartitionName&& from) noexcept
    : PartitionName() {
    *this = ::std::move(from);
  }

  inline PartitionName& operator=(const PartitionName& from) {
    CopyFrom(from);
    return *this;
  }
  inline PartitionName& operator=(PartitionName&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PartitionName& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PartitionName* internal_default_instance() {
    return reinterpret_cast<const PartitionName*>(
               &_PartitionName_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(PartitionName& a, PartitionName& b) {
    a.Swap(&b);
  }
  inline void Swap(PartitionName* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline PartitionName* New() const final {
    return CreateMaybeMessage<PartitionName>(nullptr);
  }

  PartitionName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PartitionName>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PartitionName& from);
  void MergeFrom(const PartitionName& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PartitionName* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.PartitionName";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kCollectionNameFieldNumber = 1,
    kTagFieldNumber = 2,
  };
  // string collection_name = 1;
  void clear_collection_name();
  const std::string& collection_name() const;
  void set_collection_name(const std::string& value);
  void set_collection_name(std::string&& value);
  void set_collection_name(const char* value);
  void set_collection_name(const char* value, size_t size);
  std::string* mutable_collection_name();
  std::string* release_collection_name();
  void set_allocated_collection_name(std::string* collection_name);

  // string tag = 2;
  void clear_tag();
  const std::string& tag() const;
  void set_tag(const std::string& value);
  void set_tag(std::string&& value);
  void set_tag(const char* value);
  void set_tag(const char* value, size_t size);
  std::string* mutable_tag();
  std::string* release_tag();
  void set_allocated_tag(std::string* tag);

  // @@protoc_insertion_point(class_scope:milvus.proto.service.PartitionName)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tag_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class RowBatch :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.RowBatch) */ {
 public:
  RowBatch();
  virtual ~RowBatch();

  RowBatch(const RowBatch& from);
  RowBatch(RowBatch&& from) noexcept
    : RowBatch() {
    *this = ::std::move(from);
  }

  inline RowBatch& operator=(const RowBatch& from) {
    CopyFrom(from);
    return *this;
  }
  inline RowBatch& operator=(RowBatch&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RowBatch& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RowBatch* internal_default_instance() {
    return reinterpret_cast<const RowBatch*>(
               &_RowBatch_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(RowBatch& a, RowBatch& b) {
    a.Swap(&b);
  }
  inline void Swap(RowBatch* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline RowBatch* New() const final {
    return CreateMaybeMessage<RowBatch>(nullptr);
  }

  RowBatch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RowBatch>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RowBatch& from);
  void MergeFrom(const RowBatch& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RowBatch* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.RowBatch";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRowDataFieldNumber = 3,
    kHashKeysFieldNumber = 4,
    kCollectionNameFieldNumber = 1,
    kPartitionTagFieldNumber = 2,
  };
  // repeated .milvus.proto.common.Blob row_data = 3;
  int row_data_size() const;
  void clear_row_data();
  ::milvus::proto::common::Blob* mutable_row_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::Blob >*
      mutable_row_data();
  const ::milvus::proto::common::Blob& row_data(int index) const;
  ::milvus::proto::common::Blob* add_row_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::Blob >&
      row_data() const;

  // repeated int32 hash_keys = 4;
  int hash_keys_size() const;
  void clear_hash_keys();
  ::PROTOBUF_NAMESPACE_ID::int32 hash_keys(int index) const;
  void set_hash_keys(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
  void add_hash_keys(::PROTOBUF_NAMESPACE_ID::int32 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
      hash_keys() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
      mutable_hash_keys();

  // string collection_name = 1;
  void clear_collection_name();
  const std::string& collection_name() const;
  void set_collection_name(const std::string& value);
  void set_collection_name(std::string&& value);
  void set_collection_name(const char* value);
  void set_collection_name(const char* value, size_t size);
  std::string* mutable_collection_name();
  std::string* release_collection_name();
  void set_allocated_collection_name(std::string* collection_name);

  // string partition_tag = 2;
  void clear_partition_tag();
  const std::string& partition_tag() const;
  void set_partition_tag(const std::string& value);
  void set_partition_tag(std::string&& value);
  void set_partition_tag(const char* value);
  void set_partition_tag(const char* value, size_t size);
  std::string* mutable_partition_tag();
  std::string* release_partition_tag();
  void set_allocated_partition_tag(std::string* partition_tag);

  // @@protoc_insertion_point(class_scope:milvus.proto.service.RowBatch)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::Blob > row_data_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > hash_keys_;
  mutable std::atomic<int> _hash_keys_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_tag_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class PlaceholderValue :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.PlaceholderValue) */ {
 public:
  PlaceholderValue();
  virtual ~PlaceholderValue();

  PlaceholderValue(const PlaceholderValue& from);
  PlaceholderValue(PlaceholderValue&& from) noexcept
    : PlaceholderValue() {
    *this = ::std::move(from);
  }

  inline PlaceholderValue& operator=(const PlaceholderValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline PlaceholderValue& operator=(PlaceholderValue&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PlaceholderValue& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PlaceholderValue* internal_default_instance() {
    return reinterpret_cast<const PlaceholderValue*>(
               &_PlaceholderValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(PlaceholderValue& a, PlaceholderValue& b) {
    a.Swap(&b);
  }
  inline void Swap(PlaceholderValue* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline PlaceholderValue* New() const final {
    return CreateMaybeMessage<PlaceholderValue>(nullptr);
  }

  PlaceholderValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PlaceholderValue>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PlaceholderValue& from);
  void MergeFrom(const PlaceholderValue& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PlaceholderValue* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.PlaceholderValue";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kValuesFieldNumber = 3,
    kTagFieldNumber = 1,
    kTypeFieldNumber = 2,
  };
  // repeated bytes values = 3;
  int values_size() const;
  void clear_values();
  const std::string& values(int index) const;
  std::string* mutable_values(int index);
  void set_values(int index, const std::string& value);
  void set_values(int index, std::string&& value);
  void set_values(int index, const char* value);
  void set_values(int index, const void* value, size_t size);
  std::string* add_values();
  void add_values(const std::string& value);
  void add_values(std::string&& value);
  void add_values(const char* value);
  void add_values(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_values();

  // string tag = 1;
  void clear_tag();
  const std::string& tag() const;
  void set_tag(const std::string& value);
  void set_tag(std::string&& value);
  void set_tag(const char* value);
  void set_tag(const char* value, size_t size);
  std::string* mutable_tag();
  std::string* release_tag();
  void set_allocated_tag(std::string* tag);

  // .milvus.proto.service.PlaceholderType type = 2;
  void clear_type();
  ::milvus::proto::service::PlaceholderType type() const;
  void set_type(::milvus::proto::service::PlaceholderType value);

  // @@protoc_insertion_point(class_scope:milvus.proto.service.PlaceholderValue)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> values_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tag_;
  int type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class PlaceholderGroup :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.PlaceholderGroup) */ {
 public:
  PlaceholderGroup();
  virtual ~PlaceholderGroup();

  PlaceholderGroup(const PlaceholderGroup& from);
  PlaceholderGroup(PlaceholderGroup&& from) noexcept
    : PlaceholderGroup() {
    *this = ::std::move(from);
  }

  inline PlaceholderGroup& operator=(const PlaceholderGroup& from) {
    CopyFrom(from);
    return *this;
  }
  inline PlaceholderGroup& operator=(PlaceholderGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PlaceholderGroup& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PlaceholderGroup* internal_default_instance() {
    return reinterpret_cast<const PlaceholderGroup*>(
               &_PlaceholderGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(PlaceholderGroup& a, PlaceholderGroup& b) {
    a.Swap(&b);
  }
  inline void Swap(PlaceholderGroup* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline PlaceholderGroup* New() const final {
    return CreateMaybeMessage<PlaceholderGroup>(nullptr);
  }

  PlaceholderGroup* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PlaceholderGroup>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PlaceholderGroup& from);
  void MergeFrom(const PlaceholderGroup& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PlaceholderGroup* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.PlaceholderGroup";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPlaceholdersFieldNumber = 1,
  };
  // repeated .milvus.proto.service.PlaceholderValue placeholders = 1;
  int placeholders_size() const;
  void clear_placeholders();
  ::milvus::proto::service::PlaceholderValue* mutable_placeholders(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::service::PlaceholderValue >*
      mutable_placeholders();
  const ::milvus::proto::service::PlaceholderValue& placeholders(int index) const;
  ::milvus::proto::service::PlaceholderValue* add_placeholders();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::service::PlaceholderValue >&
      placeholders() const;

  // @@protoc_insertion_point(class_scope:milvus.proto.service.PlaceholderGroup)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::service::PlaceholderValue > placeholders_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class Query :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.Query) */ {
 public:
  Query();
  virtual ~Query();

  Query(const Query& from);
  Query(Query&& from) noexcept
    : Query() {
    *this = ::std::move(from);
  }

  inline Query& operator=(const Query& from) {
    CopyFrom(from);
    return *this;
  }
  inline Query& operator=(Query&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Query& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Query* internal_default_instance() {
    return reinterpret_cast<const Query*>(
               &_Query_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(Query& a, Query& b) {
    a.Swap(&b);
  }
  inline void Swap(Query* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline Query* New() const final {
    return CreateMaybeMessage<Query>(nullptr);
  }

  Query* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Query>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Query& from);
  void MergeFrom(const Query& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Query* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.Query";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPartitionTagsFieldNumber = 2,
    kCollectionNameFieldNumber = 1,
    kDslFieldNumber = 3,
    kPlaceholderGroupFieldNumber = 4,
  };
  // repeated string partition_tags = 2;
  int partition_tags_size() const;
  void clear_partition_tags();
  const std::string& partition_tags(int index) const;
  std::string* mutable_partition_tags(int index);
  void set_partition_tags(int index, const std::string& value);
  void set_partition_tags(int index, std::string&& value);
  void set_partition_tags(int index, const char* value);
  void set_partition_tags(int index, const char* value, size_t size);
  std::string* add_partition_tags();
  void add_partition_tags(const std::string& value);
  void add_partition_tags(std::string&& value);
  void add_partition_tags(const char* value);
  void add_partition_tags(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& partition_tags() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_partition_tags();

  // string collection_name = 1;
  void clear_collection_name();
  const std::string& collection_name() const;
  void set_collection_name(const std::string& value);
  void set_collection_name(std::string&& value);
  void set_collection_name(const char* value);
  void set_collection_name(const char* value, size_t size);
  std::string* mutable_collection_name();
  std::string* release_collection_name();
  void set_allocated_collection_name(std::string* collection_name);

  // string dsl = 3;
  void clear_dsl();
  const std::string& dsl() const;
  void set_dsl(const std::string& value);
  void set_dsl(std::string&& value);
  void set_dsl(const char* value);
  void set_dsl(const char* value, size_t size);
  std::string* mutable_dsl();
  std::string* release_dsl();
  void set_allocated_dsl(std::string* dsl);

  // bytes placeholder_group = 4;
  void clear_placeholder_group();
  const std::string& placeholder_group() const;
  void set_placeholder_group(const std::string& value);
  void set_placeholder_group(std::string&& value);
  void set_placeholder_group(const char* value);
  void set_placeholder_group(const void* value, size_t size);
  std::string* mutable_placeholder_group();
  std::string* release_placeholder_group();
  void set_allocated_placeholder_group(std::string* placeholder_group);

  // @@protoc_insertion_point(class_scope:milvus.proto.service.Query)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> partition_tags_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr collection_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dsl_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr placeholder_group_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class StringResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.StringResponse) */ {
 public:
  StringResponse();
  virtual ~StringResponse();

  StringResponse(const StringResponse& from);
  StringResponse(StringResponse&& from) noexcept
    : StringResponse() {
    *this = ::std::move(from);
  }

  inline StringResponse& operator=(const StringResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline StringResponse& operator=(StringResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const StringResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StringResponse* internal_default_instance() {
    return reinterpret_cast<const StringResponse*>(
               &_StringResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(StringResponse& a, StringResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(StringResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline StringResponse* New() const final {
    return CreateMaybeMessage<StringResponse>(nullptr);
  }

  StringResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<StringResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const StringResponse& from);
  void MergeFrom(const StringResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StringResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.StringResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kValueFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // string value = 2;
  void clear_value();
  const std::string& value() const;
  void set_value(const std::string& value);
  void set_value(std::string&& value);
  void set_value(const char* value);
  void set_value(const char* value, size_t size);
  std::string* mutable_value();
  std::string* release_value();
  void set_allocated_value(std::string* value);

  // .milvus.proto.common.Status status = 1;
  bool has_status() const;
  void clear_status();
  const ::milvus::proto::common::Status& status() const;
  ::milvus::proto::common::Status* release_status();
  ::milvus::proto::common::Status* mutable_status();
  void set_allocated_status(::milvus::proto::common::Status* status);

  // @@protoc_insertion_point(class_scope:milvus.proto.service.StringResponse)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
  ::milvus::proto::common::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class BoolResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.BoolResponse) */ {
 public:
  BoolResponse();
  virtual ~BoolResponse();

  BoolResponse(const BoolResponse& from);
  BoolResponse(BoolResponse&& from) noexcept
    : BoolResponse() {
    *this = ::std::move(from);
  }

  inline BoolResponse& operator=(const BoolResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline BoolResponse& operator=(BoolResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const BoolResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BoolResponse* internal_default_instance() {
    return reinterpret_cast<const BoolResponse*>(
               &_BoolResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(BoolResponse& a, BoolResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(BoolResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline BoolResponse* New() const final {
    return CreateMaybeMessage<BoolResponse>(nullptr);
  }

  BoolResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BoolResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BoolResponse& from);
  void MergeFrom(const BoolResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BoolResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.BoolResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kStatusFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // .milvus.proto.common.Status status = 1;
  bool has_status() const;
  void clear_status();
  const ::milvus::proto::common::Status& status() const;
  ::milvus::proto::common::Status* release_status();
  ::milvus::proto::common::Status* mutable_status();
  void set_allocated_status(::milvus::proto::common::Status* status);

  // bool value = 2;
  void clear_value();
  bool value() const;
  void set_value(bool value);

  // @@protoc_insertion_point(class_scope:milvus.proto.service.BoolResponse)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::milvus::proto::common::Status* status_;
  bool value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class StringListResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.StringListResponse) */ {
 public:
  StringListResponse();
  virtual ~StringListResponse();

  StringListResponse(const StringListResponse& from);
  StringListResponse(StringListResponse&& from) noexcept
    : StringListResponse() {
    *this = ::std::move(from);
  }

  inline StringListResponse& operator=(const StringListResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline StringListResponse& operator=(StringListResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const StringListResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StringListResponse* internal_default_instance() {
    return reinterpret_cast<const StringListResponse*>(
               &_StringListResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(StringListResponse& a, StringListResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(StringListResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline StringListResponse* New() const final {
    return CreateMaybeMessage<StringListResponse>(nullptr);
  }

  StringListResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<StringListResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const StringListResponse& from);
  void MergeFrom(const StringListResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(StringListResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.StringListResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kValuesFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // repeated string values = 2;
  int values_size() const;
  void clear_values();
  const std::string& values(int index) const;
  std::string* mutable_values(int index);
  void set_values(int index, const std::string& value);
  void set_values(int index, std::string&& value);
  void set_values(int index, const char* value);
  void set_values(int index, const char* value, size_t size);
  std::string* add_values();
  void add_values(const std::string& value);
  void add_values(std::string&& value);
  void add_values(const char* value);
  void add_values(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_values();

  // .milvus.proto.common.Status status = 1;
  bool has_status() const;
  void clear_status();
  const ::milvus::proto::common::Status& status() const;
  ::milvus::proto::common::Status* release_status();
  ::milvus::proto::common::Status* mutable_status();
  void set_allocated_status(::milvus::proto::common::Status* status);

  // @@protoc_insertion_point(class_scope:milvus.proto.service.StringListResponse)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> values_;
  ::milvus::proto::common::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class IntegerListResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.IntegerListResponse) */ {
 public:
  IntegerListResponse();
  virtual ~IntegerListResponse();

  IntegerListResponse(const IntegerListResponse& from);
  IntegerListResponse(IntegerListResponse&& from) noexcept
    : IntegerListResponse() {
    *this = ::std::move(from);
  }

  inline IntegerListResponse& operator=(const IntegerListResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline IntegerListResponse& operator=(IntegerListResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const IntegerListResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const IntegerListResponse* internal_default_instance() {
    return reinterpret_cast<const IntegerListResponse*>(
               &_IntegerListResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(IntegerListResponse& a, IntegerListResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(IntegerListResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline IntegerListResponse* New() const final {
    return CreateMaybeMessage<IntegerListResponse>(nullptr);
  }

  IntegerListResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<IntegerListResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const IntegerListResponse& from);
  void MergeFrom(const IntegerListResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(IntegerListResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.IntegerListResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kValuesFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // repeated int64 values = 2;
  int values_size() const;
  void clear_values();
  ::PROTOBUF_NAMESPACE_ID::int64 values(int index) const;
  void set_values(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_values(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_values();

  // .milvus.proto.common.Status status = 1;
  bool has_status() const;
  void clear_status();
  const ::milvus::proto::common::Status& status() const;
  ::milvus::proto::common::Status* release_status();
  ::milvus::proto::common::Status* mutable_status();
  void set_allocated_status(::milvus::proto::common::Status* status);

  // @@protoc_insertion_point(class_scope:milvus.proto.service.IntegerListResponse)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > values_;
  mutable std::atomic<int> _values_cached_byte_size_;
  ::milvus::proto::common::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class IntegerRangeResponse :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.IntegerRangeResponse) */ {
 public:
  IntegerRangeResponse();
  virtual ~IntegerRangeResponse();

  IntegerRangeResponse(const IntegerRangeResponse& from);
  IntegerRangeResponse(IntegerRangeResponse&& from) noexcept
    : IntegerRangeResponse() {
    *this = ::std::move(from);
  }

  inline IntegerRangeResponse& operator=(const IntegerRangeResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline IntegerRangeResponse& operator=(IntegerRangeResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const IntegerRangeResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const IntegerRangeResponse* internal_default_instance() {
    return reinterpret_cast<const IntegerRangeResponse*>(
               &_IntegerRangeResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(IntegerRangeResponse& a, IntegerRangeResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(IntegerRangeResponse* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline IntegerRangeResponse* New() const final {
    return CreateMaybeMessage<IntegerRangeResponse>(nullptr);
  }

  IntegerRangeResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<IntegerRangeResponse>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const IntegerRangeResponse& from);
  void MergeFrom(const IntegerRangeResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(IntegerRangeResponse* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.IntegerRangeResponse";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kStatusFieldNumber = 1,
    kBeginFieldNumber = 2,
    kEndFieldNumber = 3,
  };
  // .milvus.proto.common.Status status = 1;
  bool has_status() const;
  void clear_status();
  const ::milvus::proto::common::Status& status() const;
  ::milvus::proto::common::Status* release_status();
  ::milvus::proto::common::Status* mutable_status();
  void set_allocated_status(::milvus::proto::common::Status* status);

  // int64 begin = 2;
  void clear_begin();
  ::PROTOBUF_NAMESPACE_ID::int64 begin() const;
  void set_begin(::PROTOBUF_NAMESPACE_ID::int64 value);

  // int64 end = 3;
  void clear_end();
  ::PROTOBUF_NAMESPACE_ID::int64 end() const;
  void set_end(::PROTOBUF_NAMESPACE_ID::int64 value);

  // @@protoc_insertion_point(class_scope:milvus.proto.service.IntegerRangeResponse)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::milvus::proto::common::Status* status_;
  ::PROTOBUF_NAMESPACE_ID::int64 begin_;
  ::PROTOBUF_NAMESPACE_ID::int64 end_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class CollectionDescription :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.CollectionDescription) */ {
 public:
  CollectionDescription();
  virtual ~CollectionDescription();

  CollectionDescription(const CollectionDescription& from);
  CollectionDescription(CollectionDescription&& from) noexcept
    : CollectionDescription() {
    *this = ::std::move(from);
  }

  inline CollectionDescription& operator=(const CollectionDescription& from) {
    CopyFrom(from);
    return *this;
  }
  inline CollectionDescription& operator=(CollectionDescription&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const CollectionDescription& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CollectionDescription* internal_default_instance() {
    return reinterpret_cast<const CollectionDescription*>(
               &_CollectionDescription_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(CollectionDescription& a, CollectionDescription& b) {
    a.Swap(&b);
  }
  inline void Swap(CollectionDescription* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline CollectionDescription* New() const final {
    return CreateMaybeMessage<CollectionDescription>(nullptr);
  }

  CollectionDescription* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CollectionDescription>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CollectionDescription& from);
  void MergeFrom(const CollectionDescription& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CollectionDescription* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.CollectionDescription";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kStatisticsFieldNumber = 3,
    kStatusFieldNumber = 1,
    kSchemaFieldNumber = 2,
  };
  // repeated .milvus.proto.common.KeyValuePair statistics = 3;
  int statistics_size() const;
  void clear_statistics();
  ::milvus::proto::common::KeyValuePair* mutable_statistics(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >*
      mutable_statistics();
  const ::milvus::proto::common::KeyValuePair& statistics(int index) const;
  ::milvus::proto::common::KeyValuePair* add_statistics();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >&
      statistics() const;

  // .milvus.proto.common.Status status = 1;
  bool has_status() const;
  void clear_status();
  const ::milvus::proto::common::Status& status() const;
  ::milvus::proto::common::Status* release_status();
  ::milvus::proto::common::Status* mutable_status();
  void set_allocated_status(::milvus::proto::common::Status* status);

  // .milvus.proto.schema.CollectionSchema schema = 2;
  bool has_schema() const;
  void clear_schema();
  const ::milvus::proto::schema::CollectionSchema& schema() const;
  ::milvus::proto::schema::CollectionSchema* release_schema();
  ::milvus::proto::schema::CollectionSchema* mutable_schema();
  void set_allocated_schema(::milvus::proto::schema::CollectionSchema* schema);

  // @@protoc_insertion_point(class_scope:milvus.proto.service.CollectionDescription)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair > statistics_;
  ::milvus::proto::common::Status* status_;
  ::milvus::proto::schema::CollectionSchema* schema_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class PartitionDescription :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.PartitionDescription) */ {
 public:
  PartitionDescription();
  virtual ~PartitionDescription();

  PartitionDescription(const PartitionDescription& from);
  PartitionDescription(PartitionDescription&& from) noexcept
    : PartitionDescription() {
    *this = ::std::move(from);
  }

  inline PartitionDescription& operator=(const PartitionDescription& from) {
    CopyFrom(from);
    return *this;
  }
  inline PartitionDescription& operator=(PartitionDescription&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const PartitionDescription& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PartitionDescription* internal_default_instance() {
    return reinterpret_cast<const PartitionDescription*>(
               &_PartitionDescription_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(PartitionDescription& a, PartitionDescription& b) {
    a.Swap(&b);
  }
  inline void Swap(PartitionDescription* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline PartitionDescription* New() const final {
    return CreateMaybeMessage<PartitionDescription>(nullptr);
  }

  PartitionDescription* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<PartitionDescription>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const PartitionDescription& from);
  void MergeFrom(const PartitionDescription& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PartitionDescription* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.PartitionDescription";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kStatisticsFieldNumber = 3,
    kStatusFieldNumber = 1,
    kNameFieldNumber = 2,
  };
  // repeated .milvus.proto.common.KeyValuePair statistics = 3;
  int statistics_size() const;
  void clear_statistics();
  ::milvus::proto::common::KeyValuePair* mutable_statistics(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >*
      mutable_statistics();
  const ::milvus::proto::common::KeyValuePair& statistics(int index) const;
  ::milvus::proto::common::KeyValuePair* add_statistics();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >&
      statistics() const;

  // .milvus.proto.common.Status status = 1;
  bool has_status() const;
  void clear_status();
  const ::milvus::proto::common::Status& status() const;
  ::milvus::proto::common::Status* release_status();
  ::milvus::proto::common::Status* mutable_status();
  void set_allocated_status(::milvus::proto::common::Status* status);

  // .milvus.proto.service.PartitionName name = 2;
  bool has_name() const;
  void clear_name();
  const ::milvus::proto::service::PartitionName& name() const;
  ::milvus::proto::service::PartitionName* release_name();
  ::milvus::proto::service::PartitionName* mutable_name();
  void set_allocated_name(::milvus::proto::service::PartitionName* name);

  // @@protoc_insertion_point(class_scope:milvus.proto.service.PartitionDescription)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair > statistics_;
  ::milvus::proto::common::Status* status_;
  ::milvus::proto::service::PartitionName* name_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class Hits :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.Hits) */ {
 public:
  Hits();
  virtual ~Hits();

  Hits(const Hits& from);
  Hits(Hits&& from) noexcept
    : Hits() {
    *this = ::std::move(from);
  }

  inline Hits& operator=(const Hits& from) {
    CopyFrom(from);
    return *this;
  }
  inline Hits& operator=(Hits&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Hits& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Hits* internal_default_instance() {
    return reinterpret_cast<const Hits*>(
               &_Hits_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(Hits& a, Hits& b) {
    a.Swap(&b);
  }
  inline void Swap(Hits* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline Hits* New() const final {
    return CreateMaybeMessage<Hits>(nullptr);
  }

  Hits* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Hits>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Hits& from);
  void MergeFrom(const Hits& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Hits* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.Hits";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIDsFieldNumber = 1,
    kRowDataFieldNumber = 2,
    kScoresFieldNumber = 3,
  };
  // repeated int64 IDs = 1;
  int ids_size() const;
  void clear_ids();
  ::PROTOBUF_NAMESPACE_ID::int64 ids(int index) const;
  void set_ids(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
  void add_ids(::PROTOBUF_NAMESPACE_ID::int64 value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
      ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
      mutable_ids();

  // repeated bytes row_data = 2;
  int row_data_size() const;
  void clear_row_data();
  const std::string& row_data(int index) const;
  std::string* mutable_row_data(int index);
  void set_row_data(int index, const std::string& value);
  void set_row_data(int index, std::string&& value);
  void set_row_data(int index, const char* value);
  void set_row_data(int index, const void* value, size_t size);
  std::string* add_row_data();
  void add_row_data(const std::string& value);
  void add_row_data(std::string&& value);
  void add_row_data(const char* value);
  void add_row_data(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& row_data() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_row_data();

  // repeated float scores = 3;
  int scores_size() const;
  void clear_scores();
  float scores(int index) const;
  void set_scores(int index, float value);
  void add_scores(float value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
      scores() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
      mutable_scores();

  // @@protoc_insertion_point(class_scope:milvus.proto.service.Hits)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > ids_;
  mutable std::atomic<int> _ids_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> row_data_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > scores_;
  mutable std::atomic<int> _scores_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// -------------------------------------------------------------------

class QueryResult :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.proto.service.QueryResult) */ {
 public:
  QueryResult();
  virtual ~QueryResult();

  QueryResult(const QueryResult& from);
  QueryResult(QueryResult&& from) noexcept
    : QueryResult() {
    *this = ::std::move(from);
  }

  inline QueryResult& operator=(const QueryResult& from) {
    CopyFrom(from);
    return *this;
  }
  inline QueryResult& operator=(QueryResult&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const QueryResult& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const QueryResult* internal_default_instance() {
    return reinterpret_cast<const QueryResult*>(
               &_QueryResult_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(QueryResult& a, QueryResult& b) {
    a.Swap(&b);
  }
  inline void Swap(QueryResult* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

  inline QueryResult* New() const final {
    return CreateMaybeMessage<QueryResult>(nullptr);
  }

  QueryResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<QueryResult>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const QueryResult& from);
  void MergeFrom(const QueryResult& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(QueryResult* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "milvus.proto.service.QueryResult";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_service_5fmsg_2eproto);
    return ::descriptor_table_service_5fmsg_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kHitsFieldNumber = 2,
    kStatusFieldNumber = 1,
  };
  // repeated bytes hits = 2;
  int hits_size() const;
  void clear_hits();
  const std::string& hits(int index) const;
  std::string* mutable_hits(int index);
  void set_hits(int index, const std::string& value);
  void set_hits(int index, std::string&& value);
  void set_hits(int index, const char* value);
  void set_hits(int index, const void* value, size_t size);
  std::string* add_hits();
  void add_hits(const std::string& value);
  void add_hits(std::string&& value);
  void add_hits(const char* value);
  void add_hits(const void* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& hits() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_hits();

  // .milvus.proto.common.Status status = 1;
  bool has_status() const;
  void clear_status();
  const ::milvus::proto::common::Status& status() const;
  ::milvus::proto::common::Status* release_status();
  ::milvus::proto::common::Status* mutable_status();
  void set_allocated_status(::milvus::proto::common::Status* status);

  // @@protoc_insertion_point(class_scope:milvus.proto.service.QueryResult)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> hits_;
  ::milvus::proto::common::Status* status_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_service_5fmsg_2eproto;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// CollectionName

// string collection_name = 1;
inline void CollectionName::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& CollectionName::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.CollectionName.collection_name)
  return collection_name_.GetNoArena();
}
inline void CollectionName::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.CollectionName.collection_name)
}
inline void CollectionName::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.service.CollectionName.collection_name)
}
inline void CollectionName::set_collection_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.CollectionName.collection_name)
}
inline void CollectionName::set_collection_name(const char* value, size_t size) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.CollectionName.collection_name)
}
inline std::string* CollectionName::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.CollectionName.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* CollectionName::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.CollectionName.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void CollectionName::set_allocated_collection_name(std::string* collection_name) {
  if (collection_name != nullptr) {
    
  } else {
    
  }
  collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.CollectionName.collection_name)
}

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

// PartitionName

// string collection_name = 1;
inline void PartitionName::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PartitionName::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.PartitionName.collection_name)
  return collection_name_.GetNoArena();
}
inline void PartitionName::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.PartitionName.collection_name)
}
inline void PartitionName::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.service.PartitionName.collection_name)
}
inline void PartitionName::set_collection_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.PartitionName.collection_name)
}
inline void PartitionName::set_collection_name(const char* value, size_t size) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.PartitionName.collection_name)
}
inline std::string* PartitionName::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.PartitionName.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PartitionName::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.PartitionName.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PartitionName::set_allocated_collection_name(std::string* collection_name) {
  if (collection_name != nullptr) {
    
  } else {
    
  }
  collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.PartitionName.collection_name)
}

// string tag = 2;
inline void PartitionName::clear_tag() {
  tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PartitionName::tag() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.PartitionName.tag)
  return tag_.GetNoArena();
}
inline void PartitionName::set_tag(const std::string& value) {
  
  tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.PartitionName.tag)
}
inline void PartitionName::set_tag(std::string&& value) {
  
  tag_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.service.PartitionName.tag)
}
inline void PartitionName::set_tag(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.PartitionName.tag)
}
inline void PartitionName::set_tag(const char* value, size_t size) {
  
  tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.PartitionName.tag)
}
inline std::string* PartitionName::mutable_tag() {
  
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.PartitionName.tag)
  return tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PartitionName::release_tag() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.PartitionName.tag)
  
  return tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PartitionName::set_allocated_tag(std::string* tag) {
  if (tag != nullptr) {
    
  } else {
    
  }
  tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tag);
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.PartitionName.tag)
}

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

// RowBatch

// string collection_name = 1;
inline void RowBatch::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& RowBatch::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.RowBatch.collection_name)
  return collection_name_.GetNoArena();
}
inline void RowBatch::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.RowBatch.collection_name)
}
inline void RowBatch::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.service.RowBatch.collection_name)
}
inline void RowBatch::set_collection_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.RowBatch.collection_name)
}
inline void RowBatch::set_collection_name(const char* value, size_t size) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.RowBatch.collection_name)
}
inline std::string* RowBatch::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.RowBatch.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* RowBatch::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.RowBatch.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void RowBatch::set_allocated_collection_name(std::string* collection_name) {
  if (collection_name != nullptr) {
    
  } else {
    
  }
  collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.RowBatch.collection_name)
}

// string partition_tag = 2;
inline void RowBatch::clear_partition_tag() {
  partition_tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& RowBatch::partition_tag() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.RowBatch.partition_tag)
  return partition_tag_.GetNoArena();
}
inline void RowBatch::set_partition_tag(const std::string& value) {
  
  partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.RowBatch.partition_tag)
}
inline void RowBatch::set_partition_tag(std::string&& value) {
  
  partition_tag_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.service.RowBatch.partition_tag)
}
inline void RowBatch::set_partition_tag(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.RowBatch.partition_tag)
}
inline void RowBatch::set_partition_tag(const char* value, size_t size) {
  
  partition_tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.RowBatch.partition_tag)
}
inline std::string* RowBatch::mutable_partition_tag() {
  
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.RowBatch.partition_tag)
  return partition_tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* RowBatch::release_partition_tag() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.RowBatch.partition_tag)
  
  return partition_tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void RowBatch::set_allocated_partition_tag(std::string* partition_tag) {
  if (partition_tag != nullptr) {
    
  } else {
    
  }
  partition_tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), partition_tag);
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.RowBatch.partition_tag)
}

// repeated .milvus.proto.common.Blob row_data = 3;
inline int RowBatch::row_data_size() const {
  return row_data_.size();
}
inline ::milvus::proto::common::Blob* RowBatch::mutable_row_data(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.RowBatch.row_data)
  return row_data_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::Blob >*
RowBatch::mutable_row_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.service.RowBatch.row_data)
  return &row_data_;
}
inline const ::milvus::proto::common::Blob& RowBatch::row_data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.RowBatch.row_data)
  return row_data_.Get(index);
}
inline ::milvus::proto::common::Blob* RowBatch::add_row_data() {
  // @@protoc_insertion_point(field_add:milvus.proto.service.RowBatch.row_data)
  return row_data_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::Blob >&
RowBatch::row_data() const {
  // @@protoc_insertion_point(field_list:milvus.proto.service.RowBatch.row_data)
  return row_data_;
}

// repeated int32 hash_keys = 4;
inline int RowBatch::hash_keys_size() const {
  return hash_keys_.size();
}
inline void RowBatch::clear_hash_keys() {
  hash_keys_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int32 RowBatch::hash_keys(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.RowBatch.hash_keys)
  return hash_keys_.Get(index);
}
inline void RowBatch::set_hash_keys(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
  hash_keys_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.RowBatch.hash_keys)
}
inline void RowBatch::add_hash_keys(::PROTOBUF_NAMESPACE_ID::int32 value) {
  hash_keys_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.proto.service.RowBatch.hash_keys)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
RowBatch::hash_keys() const {
  // @@protoc_insertion_point(field_list:milvus.proto.service.RowBatch.hash_keys)
  return hash_keys_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
RowBatch::mutable_hash_keys() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.service.RowBatch.hash_keys)
  return &hash_keys_;
}

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

// PlaceholderValue

// string tag = 1;
inline void PlaceholderValue::clear_tag() {
  tag_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& PlaceholderValue::tag() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.PlaceholderValue.tag)
  return tag_.GetNoArena();
}
inline void PlaceholderValue::set_tag(const std::string& value) {
  
  tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.PlaceholderValue.tag)
}
inline void PlaceholderValue::set_tag(std::string&& value) {
  
  tag_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.service.PlaceholderValue.tag)
}
inline void PlaceholderValue::set_tag(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.PlaceholderValue.tag)
}
inline void PlaceholderValue::set_tag(const char* value, size_t size) {
  
  tag_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.PlaceholderValue.tag)
}
inline std::string* PlaceholderValue::mutable_tag() {
  
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.PlaceholderValue.tag)
  return tag_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* PlaceholderValue::release_tag() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.PlaceholderValue.tag)
  
  return tag_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void PlaceholderValue::set_allocated_tag(std::string* tag) {
  if (tag != nullptr) {
    
  } else {
    
  }
  tag_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tag);
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.PlaceholderValue.tag)
}

// .milvus.proto.service.PlaceholderType type = 2;
inline void PlaceholderValue::clear_type() {
  type_ = 0;
}
inline ::milvus::proto::service::PlaceholderType PlaceholderValue::type() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.PlaceholderValue.type)
  return static_cast< ::milvus::proto::service::PlaceholderType >(type_);
}
inline void PlaceholderValue::set_type(::milvus::proto::service::PlaceholderType value) {
  
  type_ = value;
  // @@protoc_insertion_point(field_set:milvus.proto.service.PlaceholderValue.type)
}

// repeated bytes values = 3;
inline int PlaceholderValue::values_size() const {
  return values_.size();
}
inline void PlaceholderValue::clear_values() {
  values_.Clear();
}
inline const std::string& PlaceholderValue::values(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.PlaceholderValue.values)
  return values_.Get(index);
}
inline std::string* PlaceholderValue::mutable_values(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.PlaceholderValue.values)
  return values_.Mutable(index);
}
inline void PlaceholderValue::set_values(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.proto.service.PlaceholderValue.values)
  values_.Mutable(index)->assign(value);
}
inline void PlaceholderValue::set_values(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.proto.service.PlaceholderValue.values)
  values_.Mutable(index)->assign(std::move(value));
}
inline void PlaceholderValue::set_values(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  values_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.PlaceholderValue.values)
}
inline void PlaceholderValue::set_values(int index, const void* value, size_t size) {
  values_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.PlaceholderValue.values)
}
inline std::string* PlaceholderValue::add_values() {
  // @@protoc_insertion_point(field_add_mutable:milvus.proto.service.PlaceholderValue.values)
  return values_.Add();
}
inline void PlaceholderValue::add_values(const std::string& value) {
  values_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.proto.service.PlaceholderValue.values)
}
inline void PlaceholderValue::add_values(std::string&& value) {
  values_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.proto.service.PlaceholderValue.values)
}
inline void PlaceholderValue::add_values(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  values_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.proto.service.PlaceholderValue.values)
}
inline void PlaceholderValue::add_values(const void* value, size_t size) {
  values_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.proto.service.PlaceholderValue.values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
PlaceholderValue::values() const {
  // @@protoc_insertion_point(field_list:milvus.proto.service.PlaceholderValue.values)
  return values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
PlaceholderValue::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.service.PlaceholderValue.values)
  return &values_;
}

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

// PlaceholderGroup

// repeated .milvus.proto.service.PlaceholderValue placeholders = 1;
inline int PlaceholderGroup::placeholders_size() const {
  return placeholders_.size();
}
inline void PlaceholderGroup::clear_placeholders() {
  placeholders_.Clear();
}
inline ::milvus::proto::service::PlaceholderValue* PlaceholderGroup::mutable_placeholders(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.PlaceholderGroup.placeholders)
  return placeholders_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::service::PlaceholderValue >*
PlaceholderGroup::mutable_placeholders() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.service.PlaceholderGroup.placeholders)
  return &placeholders_;
}
inline const ::milvus::proto::service::PlaceholderValue& PlaceholderGroup::placeholders(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.PlaceholderGroup.placeholders)
  return placeholders_.Get(index);
}
inline ::milvus::proto::service::PlaceholderValue* PlaceholderGroup::add_placeholders() {
  // @@protoc_insertion_point(field_add:milvus.proto.service.PlaceholderGroup.placeholders)
  return placeholders_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::service::PlaceholderValue >&
PlaceholderGroup::placeholders() const {
  // @@protoc_insertion_point(field_list:milvus.proto.service.PlaceholderGroup.placeholders)
  return placeholders_;
}

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

// Query

// string collection_name = 1;
inline void Query::clear_collection_name() {
  collection_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& Query::collection_name() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.Query.collection_name)
  return collection_name_.GetNoArena();
}
inline void Query::set_collection_name(const std::string& value) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.Query.collection_name)
}
inline void Query::set_collection_name(std::string&& value) {
  
  collection_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.service.Query.collection_name)
}
inline void Query::set_collection_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.Query.collection_name)
}
inline void Query::set_collection_name(const char* value, size_t size) {
  
  collection_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.Query.collection_name)
}
inline std::string* Query::mutable_collection_name() {
  
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.Query.collection_name)
  return collection_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Query::release_collection_name() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.Query.collection_name)
  
  return collection_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Query::set_allocated_collection_name(std::string* collection_name) {
  if (collection_name != nullptr) {
    
  } else {
    
  }
  collection_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), collection_name);
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.Query.collection_name)
}

// repeated string partition_tags = 2;
inline int Query::partition_tags_size() const {
  return partition_tags_.size();
}
inline void Query::clear_partition_tags() {
  partition_tags_.Clear();
}
inline const std::string& Query::partition_tags(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.Query.partition_tags)
  return partition_tags_.Get(index);
}
inline std::string* Query::mutable_partition_tags(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.Query.partition_tags)
  return partition_tags_.Mutable(index);
}
inline void Query::set_partition_tags(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.proto.service.Query.partition_tags)
  partition_tags_.Mutable(index)->assign(value);
}
inline void Query::set_partition_tags(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.proto.service.Query.partition_tags)
  partition_tags_.Mutable(index)->assign(std::move(value));
}
inline void Query::set_partition_tags(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  partition_tags_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.Query.partition_tags)
}
inline void Query::set_partition_tags(int index, const char* value, size_t size) {
  partition_tags_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.Query.partition_tags)
}
inline std::string* Query::add_partition_tags() {
  // @@protoc_insertion_point(field_add_mutable:milvus.proto.service.Query.partition_tags)
  return partition_tags_.Add();
}
inline void Query::add_partition_tags(const std::string& value) {
  partition_tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.proto.service.Query.partition_tags)
}
inline void Query::add_partition_tags(std::string&& value) {
  partition_tags_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.proto.service.Query.partition_tags)
}
inline void Query::add_partition_tags(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  partition_tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.proto.service.Query.partition_tags)
}
inline void Query::add_partition_tags(const char* value, size_t size) {
  partition_tags_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.proto.service.Query.partition_tags)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Query::partition_tags() const {
  // @@protoc_insertion_point(field_list:milvus.proto.service.Query.partition_tags)
  return partition_tags_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Query::mutable_partition_tags() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.service.Query.partition_tags)
  return &partition_tags_;
}

// string dsl = 3;
inline void Query::clear_dsl() {
  dsl_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& Query::dsl() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.Query.dsl)
  return dsl_.GetNoArena();
}
inline void Query::set_dsl(const std::string& value) {
  
  dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.Query.dsl)
}
inline void Query::set_dsl(std::string&& value) {
  
  dsl_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.service.Query.dsl)
}
inline void Query::set_dsl(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.Query.dsl)
}
inline void Query::set_dsl(const char* value, size_t size) {
  
  dsl_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.Query.dsl)
}
inline std::string* Query::mutable_dsl() {
  
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.Query.dsl)
  return dsl_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Query::release_dsl() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.Query.dsl)
  
  return dsl_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Query::set_allocated_dsl(std::string* dsl) {
  if (dsl != nullptr) {
    
  } else {
    
  }
  dsl_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dsl);
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.Query.dsl)
}

// bytes placeholder_group = 4;
inline void Query::clear_placeholder_group() {
  placeholder_group_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& Query::placeholder_group() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.Query.placeholder_group)
  return placeholder_group_.GetNoArena();
}
inline void Query::set_placeholder_group(const std::string& value) {
  
  placeholder_group_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.Query.placeholder_group)
}
inline void Query::set_placeholder_group(std::string&& value) {
  
  placeholder_group_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.service.Query.placeholder_group)
}
inline void Query::set_placeholder_group(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  placeholder_group_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.Query.placeholder_group)
}
inline void Query::set_placeholder_group(const void* value, size_t size) {
  
  placeholder_group_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.Query.placeholder_group)
}
inline std::string* Query::mutable_placeholder_group() {
  
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.Query.placeholder_group)
  return placeholder_group_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Query::release_placeholder_group() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.Query.placeholder_group)
  
  return placeholder_group_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Query::set_allocated_placeholder_group(std::string* placeholder_group) {
  if (placeholder_group != nullptr) {
    
  } else {
    
  }
  placeholder_group_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), placeholder_group);
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.Query.placeholder_group)
}

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

// StringResponse

// .milvus.proto.common.Status status = 1;
inline bool StringResponse::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline const ::milvus::proto::common::Status& StringResponse::status() const {
  const ::milvus::proto::common::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.proto.service.StringResponse.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::Status*>(
      &::milvus::proto::common::_Status_default_instance_);
}
inline ::milvus::proto::common::Status* StringResponse::release_status() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.StringResponse.status)
  
  ::milvus::proto::common::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::proto::common::Status* StringResponse::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::common::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.StringResponse.status)
  return status_;
}
inline void StringResponse::set_allocated_status(::milvus::proto::common::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.StringResponse.status)
}

// string value = 2;
inline void StringResponse::clear_value() {
  value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& StringResponse::value() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.StringResponse.value)
  return value_.GetNoArena();
}
inline void StringResponse::set_value(const std::string& value) {
  
  value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.StringResponse.value)
}
inline void StringResponse::set_value(std::string&& value) {
  
  value_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:milvus.proto.service.StringResponse.value)
}
inline void StringResponse::set_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.StringResponse.value)
}
inline void StringResponse::set_value(const char* value, size_t size) {
  
  value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.StringResponse.value)
}
inline std::string* StringResponse::mutable_value() {
  
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.StringResponse.value)
  return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* StringResponse::release_value() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.StringResponse.value)
  
  return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void StringResponse::set_allocated_value(std::string* value) {
  if (value != nullptr) {
    
  } else {
    
  }
  value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.StringResponse.value)
}

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

// BoolResponse

// .milvus.proto.common.Status status = 1;
inline bool BoolResponse::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline const ::milvus::proto::common::Status& BoolResponse::status() const {
  const ::milvus::proto::common::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.proto.service.BoolResponse.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::Status*>(
      &::milvus::proto::common::_Status_default_instance_);
}
inline ::milvus::proto::common::Status* BoolResponse::release_status() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.BoolResponse.status)
  
  ::milvus::proto::common::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::proto::common::Status* BoolResponse::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::common::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.BoolResponse.status)
  return status_;
}
inline void BoolResponse::set_allocated_status(::milvus::proto::common::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.BoolResponse.status)
}

// bool value = 2;
inline void BoolResponse::clear_value() {
  value_ = false;
}
inline bool BoolResponse::value() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.BoolResponse.value)
  return value_;
}
inline void BoolResponse::set_value(bool value) {
  
  value_ = value;
  // @@protoc_insertion_point(field_set:milvus.proto.service.BoolResponse.value)
}

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

// StringListResponse

// .milvus.proto.common.Status status = 1;
inline bool StringListResponse::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline const ::milvus::proto::common::Status& StringListResponse::status() const {
  const ::milvus::proto::common::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.proto.service.StringListResponse.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::Status*>(
      &::milvus::proto::common::_Status_default_instance_);
}
inline ::milvus::proto::common::Status* StringListResponse::release_status() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.StringListResponse.status)
  
  ::milvus::proto::common::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::proto::common::Status* StringListResponse::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::common::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.StringListResponse.status)
  return status_;
}
inline void StringListResponse::set_allocated_status(::milvus::proto::common::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.StringListResponse.status)
}

// repeated string values = 2;
inline int StringListResponse::values_size() const {
  return values_.size();
}
inline void StringListResponse::clear_values() {
  values_.Clear();
}
inline const std::string& StringListResponse::values(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.StringListResponse.values)
  return values_.Get(index);
}
inline std::string* StringListResponse::mutable_values(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.StringListResponse.values)
  return values_.Mutable(index);
}
inline void StringListResponse::set_values(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.proto.service.StringListResponse.values)
  values_.Mutable(index)->assign(value);
}
inline void StringListResponse::set_values(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.proto.service.StringListResponse.values)
  values_.Mutable(index)->assign(std::move(value));
}
inline void StringListResponse::set_values(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  values_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.StringListResponse.values)
}
inline void StringListResponse::set_values(int index, const char* value, size_t size) {
  values_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.StringListResponse.values)
}
inline std::string* StringListResponse::add_values() {
  // @@protoc_insertion_point(field_add_mutable:milvus.proto.service.StringListResponse.values)
  return values_.Add();
}
inline void StringListResponse::add_values(const std::string& value) {
  values_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.proto.service.StringListResponse.values)
}
inline void StringListResponse::add_values(std::string&& value) {
  values_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.proto.service.StringListResponse.values)
}
inline void StringListResponse::add_values(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  values_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.proto.service.StringListResponse.values)
}
inline void StringListResponse::add_values(const char* value, size_t size) {
  values_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.proto.service.StringListResponse.values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
StringListResponse::values() const {
  // @@protoc_insertion_point(field_list:milvus.proto.service.StringListResponse.values)
  return values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
StringListResponse::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.service.StringListResponse.values)
  return &values_;
}

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

// IntegerListResponse

// .milvus.proto.common.Status status = 1;
inline bool IntegerListResponse::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline const ::milvus::proto::common::Status& IntegerListResponse::status() const {
  const ::milvus::proto::common::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.proto.service.IntegerListResponse.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::Status*>(
      &::milvus::proto::common::_Status_default_instance_);
}
inline ::milvus::proto::common::Status* IntegerListResponse::release_status() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.IntegerListResponse.status)
  
  ::milvus::proto::common::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::proto::common::Status* IntegerListResponse::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::common::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.IntegerListResponse.status)
  return status_;
}
inline void IntegerListResponse::set_allocated_status(::milvus::proto::common::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.IntegerListResponse.status)
}

// repeated int64 values = 2;
inline int IntegerListResponse::values_size() const {
  return values_.size();
}
inline void IntegerListResponse::clear_values() {
  values_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 IntegerListResponse::values(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.IntegerListResponse.values)
  return values_.Get(index);
}
inline void IntegerListResponse::set_values(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  values_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.IntegerListResponse.values)
}
inline void IntegerListResponse::add_values(::PROTOBUF_NAMESPACE_ID::int64 value) {
  values_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.proto.service.IntegerListResponse.values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
IntegerListResponse::values() const {
  // @@protoc_insertion_point(field_list:milvus.proto.service.IntegerListResponse.values)
  return values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
IntegerListResponse::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.service.IntegerListResponse.values)
  return &values_;
}

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

// IntegerRangeResponse

// .milvus.proto.common.Status status = 1;
inline bool IntegerRangeResponse::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline const ::milvus::proto::common::Status& IntegerRangeResponse::status() const {
  const ::milvus::proto::common::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.proto.service.IntegerRangeResponse.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::Status*>(
      &::milvus::proto::common::_Status_default_instance_);
}
inline ::milvus::proto::common::Status* IntegerRangeResponse::release_status() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.IntegerRangeResponse.status)
  
  ::milvus::proto::common::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::proto::common::Status* IntegerRangeResponse::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::common::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.IntegerRangeResponse.status)
  return status_;
}
inline void IntegerRangeResponse::set_allocated_status(::milvus::proto::common::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.IntegerRangeResponse.status)
}

// int64 begin = 2;
inline void IntegerRangeResponse::clear_begin() {
  begin_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 IntegerRangeResponse::begin() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.IntegerRangeResponse.begin)
  return begin_;
}
inline void IntegerRangeResponse::set_begin(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  begin_ = value;
  // @@protoc_insertion_point(field_set:milvus.proto.service.IntegerRangeResponse.begin)
}

// int64 end = 3;
inline void IntegerRangeResponse::clear_end() {
  end_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 IntegerRangeResponse::end() const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.IntegerRangeResponse.end)
  return end_;
}
inline void IntegerRangeResponse::set_end(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  end_ = value;
  // @@protoc_insertion_point(field_set:milvus.proto.service.IntegerRangeResponse.end)
}

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

// CollectionDescription

// .milvus.proto.common.Status status = 1;
inline bool CollectionDescription::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline const ::milvus::proto::common::Status& CollectionDescription::status() const {
  const ::milvus::proto::common::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.proto.service.CollectionDescription.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::Status*>(
      &::milvus::proto::common::_Status_default_instance_);
}
inline ::milvus::proto::common::Status* CollectionDescription::release_status() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.CollectionDescription.status)
  
  ::milvus::proto::common::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::proto::common::Status* CollectionDescription::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::common::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.CollectionDescription.status)
  return status_;
}
inline void CollectionDescription::set_allocated_status(::milvus::proto::common::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.CollectionDescription.status)
}

// .milvus.proto.schema.CollectionSchema schema = 2;
inline bool CollectionDescription::has_schema() const {
  return this != internal_default_instance() && schema_ != nullptr;
}
inline const ::milvus::proto::schema::CollectionSchema& CollectionDescription::schema() const {
  const ::milvus::proto::schema::CollectionSchema* p = schema_;
  // @@protoc_insertion_point(field_get:milvus.proto.service.CollectionDescription.schema)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::schema::CollectionSchema*>(
      &::milvus::proto::schema::_CollectionSchema_default_instance_);
}
inline ::milvus::proto::schema::CollectionSchema* CollectionDescription::release_schema() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.CollectionDescription.schema)
  
  ::milvus::proto::schema::CollectionSchema* temp = schema_;
  schema_ = nullptr;
  return temp;
}
inline ::milvus::proto::schema::CollectionSchema* CollectionDescription::mutable_schema() {
  
  if (schema_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::schema::CollectionSchema>(GetArenaNoVirtual());
    schema_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.CollectionDescription.schema)
  return schema_;
}
inline void CollectionDescription::set_allocated_schema(::milvus::proto::schema::CollectionSchema* schema) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(schema_);
  }
  if (schema) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      schema = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, schema, submessage_arena);
    }
    
  } else {
    
  }
  schema_ = schema;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.CollectionDescription.schema)
}

// repeated .milvus.proto.common.KeyValuePair statistics = 3;
inline int CollectionDescription::statistics_size() const {
  return statistics_.size();
}
inline ::milvus::proto::common::KeyValuePair* CollectionDescription::mutable_statistics(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.CollectionDescription.statistics)
  return statistics_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >*
CollectionDescription::mutable_statistics() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.service.CollectionDescription.statistics)
  return &statistics_;
}
inline const ::milvus::proto::common::KeyValuePair& CollectionDescription::statistics(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.CollectionDescription.statistics)
  return statistics_.Get(index);
}
inline ::milvus::proto::common::KeyValuePair* CollectionDescription::add_statistics() {
  // @@protoc_insertion_point(field_add:milvus.proto.service.CollectionDescription.statistics)
  return statistics_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >&
CollectionDescription::statistics() const {
  // @@protoc_insertion_point(field_list:milvus.proto.service.CollectionDescription.statistics)
  return statistics_;
}

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

// PartitionDescription

// .milvus.proto.common.Status status = 1;
inline bool PartitionDescription::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline const ::milvus::proto::common::Status& PartitionDescription::status() const {
  const ::milvus::proto::common::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.proto.service.PartitionDescription.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::Status*>(
      &::milvus::proto::common::_Status_default_instance_);
}
inline ::milvus::proto::common::Status* PartitionDescription::release_status() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.PartitionDescription.status)
  
  ::milvus::proto::common::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::proto::common::Status* PartitionDescription::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::common::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.PartitionDescription.status)
  return status_;
}
inline void PartitionDescription::set_allocated_status(::milvus::proto::common::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.PartitionDescription.status)
}

// .milvus.proto.service.PartitionName name = 2;
inline bool PartitionDescription::has_name() const {
  return this != internal_default_instance() && name_ != nullptr;
}
inline void PartitionDescription::clear_name() {
  if (GetArenaNoVirtual() == nullptr && name_ != nullptr) {
    delete name_;
  }
  name_ = nullptr;
}
inline const ::milvus::proto::service::PartitionName& PartitionDescription::name() const {
  const ::milvus::proto::service::PartitionName* p = name_;
  // @@protoc_insertion_point(field_get:milvus.proto.service.PartitionDescription.name)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::service::PartitionName*>(
      &::milvus::proto::service::_PartitionName_default_instance_);
}
inline ::milvus::proto::service::PartitionName* PartitionDescription::release_name() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.PartitionDescription.name)
  
  ::milvus::proto::service::PartitionName* temp = name_;
  name_ = nullptr;
  return temp;
}
inline ::milvus::proto::service::PartitionName* PartitionDescription::mutable_name() {
  
  if (name_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::service::PartitionName>(GetArenaNoVirtual());
    name_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.PartitionDescription.name)
  return name_;
}
inline void PartitionDescription::set_allocated_name(::milvus::proto::service::PartitionName* name) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete name_;
  }
  if (name) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, name, submessage_arena);
    }
    
  } else {
    
  }
  name_ = name;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.PartitionDescription.name)
}

// repeated .milvus.proto.common.KeyValuePair statistics = 3;
inline int PartitionDescription::statistics_size() const {
  return statistics_.size();
}
inline ::milvus::proto::common::KeyValuePair* PartitionDescription::mutable_statistics(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.PartitionDescription.statistics)
  return statistics_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >*
PartitionDescription::mutable_statistics() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.service.PartitionDescription.statistics)
  return &statistics_;
}
inline const ::milvus::proto::common::KeyValuePair& PartitionDescription::statistics(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.PartitionDescription.statistics)
  return statistics_.Get(index);
}
inline ::milvus::proto::common::KeyValuePair* PartitionDescription::add_statistics() {
  // @@protoc_insertion_point(field_add:milvus.proto.service.PartitionDescription.statistics)
  return statistics_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::proto::common::KeyValuePair >&
PartitionDescription::statistics() const {
  // @@protoc_insertion_point(field_list:milvus.proto.service.PartitionDescription.statistics)
  return statistics_;
}

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

// Hits

// repeated int64 IDs = 1;
inline int Hits::ids_size() const {
  return ids_.size();
}
inline void Hits::clear_ids() {
  ids_.Clear();
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Hits::ids(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.Hits.IDs)
  return ids_.Get(index);
}
inline void Hits::set_ids(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
  ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.Hits.IDs)
}
inline void Hits::add_ids(::PROTOBUF_NAMESPACE_ID::int64 value) {
  ids_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.proto.service.Hits.IDs)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
Hits::ids() const {
  // @@protoc_insertion_point(field_list:milvus.proto.service.Hits.IDs)
  return ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
Hits::mutable_ids() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.service.Hits.IDs)
  return &ids_;
}

// repeated bytes row_data = 2;
inline int Hits::row_data_size() const {
  return row_data_.size();
}
inline void Hits::clear_row_data() {
  row_data_.Clear();
}
inline const std::string& Hits::row_data(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.Hits.row_data)
  return row_data_.Get(index);
}
inline std::string* Hits::mutable_row_data(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.Hits.row_data)
  return row_data_.Mutable(index);
}
inline void Hits::set_row_data(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.proto.service.Hits.row_data)
  row_data_.Mutable(index)->assign(value);
}
inline void Hits::set_row_data(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.proto.service.Hits.row_data)
  row_data_.Mutable(index)->assign(std::move(value));
}
inline void Hits::set_row_data(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  row_data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.Hits.row_data)
}
inline void Hits::set_row_data(int index, const void* value, size_t size) {
  row_data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.Hits.row_data)
}
inline std::string* Hits::add_row_data() {
  // @@protoc_insertion_point(field_add_mutable:milvus.proto.service.Hits.row_data)
  return row_data_.Add();
}
inline void Hits::add_row_data(const std::string& value) {
  row_data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.proto.service.Hits.row_data)
}
inline void Hits::add_row_data(std::string&& value) {
  row_data_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.proto.service.Hits.row_data)
}
inline void Hits::add_row_data(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  row_data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.proto.service.Hits.row_data)
}
inline void Hits::add_row_data(const void* value, size_t size) {
  row_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.proto.service.Hits.row_data)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Hits::row_data() const {
  // @@protoc_insertion_point(field_list:milvus.proto.service.Hits.row_data)
  return row_data_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Hits::mutable_row_data() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.service.Hits.row_data)
  return &row_data_;
}

// repeated float scores = 3;
inline int Hits::scores_size() const {
  return scores_.size();
}
inline void Hits::clear_scores() {
  scores_.Clear();
}
inline float Hits::scores(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.Hits.scores)
  return scores_.Get(index);
}
inline void Hits::set_scores(int index, float value) {
  scores_.Set(index, value);
  // @@protoc_insertion_point(field_set:milvus.proto.service.Hits.scores)
}
inline void Hits::add_scores(float value) {
  scores_.Add(value);
  // @@protoc_insertion_point(field_add:milvus.proto.service.Hits.scores)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
Hits::scores() const {
  // @@protoc_insertion_point(field_list:milvus.proto.service.Hits.scores)
  return scores_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
Hits::mutable_scores() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.service.Hits.scores)
  return &scores_;
}

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

// QueryResult

// .milvus.proto.common.Status status = 1;
inline bool QueryResult::has_status() const {
  return this != internal_default_instance() && status_ != nullptr;
}
inline const ::milvus::proto::common::Status& QueryResult::status() const {
  const ::milvus::proto::common::Status* p = status_;
  // @@protoc_insertion_point(field_get:milvus.proto.service.QueryResult.status)
  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::proto::common::Status*>(
      &::milvus::proto::common::_Status_default_instance_);
}
inline ::milvus::proto::common::Status* QueryResult::release_status() {
  // @@protoc_insertion_point(field_release:milvus.proto.service.QueryResult.status)
  
  ::milvus::proto::common::Status* temp = status_;
  status_ = nullptr;
  return temp;
}
inline ::milvus::proto::common::Status* QueryResult::mutable_status() {
  
  if (status_ == nullptr) {
    auto* p = CreateMaybeMessage<::milvus::proto::common::Status>(GetArenaNoVirtual());
    status_ = p;
  }
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.QueryResult.status)
  return status_;
}
inline void QueryResult::set_allocated_status(::milvus::proto::common::Status* status) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
  }
  if (status) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, status, submessage_arena);
    }
    
  } else {
    
  }
  status_ = status;
  // @@protoc_insertion_point(field_set_allocated:milvus.proto.service.QueryResult.status)
}

// repeated bytes hits = 2;
inline int QueryResult::hits_size() const {
  return hits_.size();
}
inline void QueryResult::clear_hits() {
  hits_.Clear();
}
inline const std::string& QueryResult::hits(int index) const {
  // @@protoc_insertion_point(field_get:milvus.proto.service.QueryResult.hits)
  return hits_.Get(index);
}
inline std::string* QueryResult::mutable_hits(int index) {
  // @@protoc_insertion_point(field_mutable:milvus.proto.service.QueryResult.hits)
  return hits_.Mutable(index);
}
inline void QueryResult::set_hits(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:milvus.proto.service.QueryResult.hits)
  hits_.Mutable(index)->assign(value);
}
inline void QueryResult::set_hits(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:milvus.proto.service.QueryResult.hits)
  hits_.Mutable(index)->assign(std::move(value));
}
inline void QueryResult::set_hits(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  hits_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:milvus.proto.service.QueryResult.hits)
}
inline void QueryResult::set_hits(int index, const void* value, size_t size) {
  hits_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:milvus.proto.service.QueryResult.hits)
}
inline std::string* QueryResult::add_hits() {
  // @@protoc_insertion_point(field_add_mutable:milvus.proto.service.QueryResult.hits)
  return hits_.Add();
}
inline void QueryResult::add_hits(const std::string& value) {
  hits_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:milvus.proto.service.QueryResult.hits)
}
inline void QueryResult::add_hits(std::string&& value) {
  hits_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:milvus.proto.service.QueryResult.hits)
}
inline void QueryResult::add_hits(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  hits_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:milvus.proto.service.QueryResult.hits)
}
inline void QueryResult::add_hits(const void* value, size_t size) {
  hits_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:milvus.proto.service.QueryResult.hits)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
QueryResult::hits() const {
  // @@protoc_insertion_point(field_list:milvus.proto.service.QueryResult.hits)
  return hits_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
QueryResult::mutable_hits() {
  // @@protoc_insertion_point(field_mutable_list:milvus.proto.service.QueryResult.hits)
  return &hits_;
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace service
}  // namespace proto
}  // namespace milvus

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::milvus::proto::service::PlaceholderType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::milvus::proto::service::PlaceholderType>() {
  return ::milvus::proto::service::PlaceholderType_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_service_5fmsg_2eproto